qiskit 1.4.1__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/user_config.py

@@ -245,15 +245,19 @@ def set_config(key, value, section=None, file_path=None):
 
 
 def get_config():
-    """Read the config file from the default location or env var
+    """Read the config file from the default location or env var.
 
-    It will read a config file at either the default location
-    ~/.qiskit/settings.conf or if set the value of the QISKIT_SETTINGS env var.
+    It will read a config file at the location specified by the ``QISKIT_SETTINGS`` environment
+    variable if set, or ``$HOME/.qiskit/settings.conf`` if not.
+
+    If the environment variable ``QISKIT_IGNORE_USER_SETTINGS`` is set to the string ``TRUE``, this
+    will return an empty configuration, regardless of all other variables.
 
-    It will return the parsed settings dict from the parsed config file.
     Returns:
         dict: The settings dict from the parsed config file.
     """
+    if os.getenv("QISKIT_IGNORE_USER_SETTINGS", "false").lower() == "true":
+        return {}
     filename = os.getenv("QISKIT_SETTINGS", DEFAULT_FILENAME)
     if not os.path.isfile(filename):
         return {}

qiskit/utils/__init__.py

@@ -23,9 +23,7 @@ Deprecations
 
 .. autofunction:: add_deprecation_to_docstring
 .. autofunction:: deprecate_arg
-.. autofunction:: deprecate_arguments
 .. autofunction:: deprecate_func
-.. autofunction:: deprecate_function
 
 SI unit conversion
 ==================
@@ -41,8 +39,10 @@ Class tools
 Multiprocessing
 ===============
 
-.. autofunction:: local_hardware_info
+.. autofunction:: default_num_processes
 .. autofunction:: is_main_process
+.. autofunction:: local_hardware_info
+.. autofunction:: should_run_in_parallel
 
 A helper function for calling a custom function with Python
 :class:`~concurrent.futures.ProcessPoolExecutor`. Tasks can be executed in parallel using this function.
@@ -58,32 +58,33 @@ Optional Dependency Checkers
 from .deprecation import (
     add_deprecation_to_docstring,
     deprecate_arg,
-    deprecate_arguments,
     deprecate_func,
-    deprecate_function,
 )
-from .multiprocessing import local_hardware_info
-from .multiprocessing import is_main_process
 from .units import apply_prefix, detach_prefix
 from .classtools import wrap_method
 from .lazy_tester import LazyDependencyManager, LazyImportTester, LazySubprocessTester
 
 from . import optionals
 
-from .parallel import parallel_map, should_run_in_parallel
+from .parallel import (
+    parallel_map,
+    should_run_in_parallel,
+    local_hardware_info,
+    is_main_process,
+    default_num_processes,
+)
 
 __all__ = [
     "LazyDependencyManager",
     "LazyImportTester",
     "LazySubprocessTester",
     "add_deprecation_to_docstring",
+    "apply_prefix",
+    "default_num_processes",
     "deprecate_arg",
-    "deprecate_arguments",
     "deprecate_func",
-    "deprecate_function",
-    "local_hardware_info",
     "is_main_process",
-    "apply_prefix",
+    "local_hardware_info",
     "parallel_map",
     "should_run_in_parallel",
 ]

qiskit/utils/deprecation.py

@@ -26,7 +26,7 @@ def deprecate_func(
     since: str,
     additional_msg: str | None = None,
     pending: bool = False,
-    package_name: str = "qiskit",
+    package_name: str = "Qiskit",
     removal_timeline: str = "no earlier than 3 months after the release date",
     is_property: bool = False,
     stacklevel: int = 2,
@@ -45,7 +45,7 @@ def deprecate_func(
             For example, "Instead, use the function ``new_func`` from the module
             ``<my_module>.<my_submodule>``, which is similar but uses GPU acceleration."
         pending: Set to ``True`` if the deprecation is still pending.
-        package_name: The PyPI package name, e.g. "qiskit-nature".
+        package_name: The package name shown in the deprecation message (e.g. the PyPI package name).
         removal_timeline: How soon can this deprecation be removed? Expects a value
             like "no sooner than 6 months after the latest release" or "in release 9.99".
         is_property: If the deprecated function is a `@property`, set this to True so that the
@@ -109,7 +109,7 @@ def deprecate_arg(
     additional_msg: str | None = None,
     deprecation_description: str | None = None,
     pending: bool = False,
-    package_name: str = "qiskit",
+    package_name: str = "Qiskit",
     new_alias: str | None = None,
     predicate: Callable[[Any], bool] | None = None,
     removal_timeline: str = "no earlier than 3 months after the release date",
@@ -130,7 +130,7 @@ def deprecate_arg(
             (if new_alias is not set). For example, "Instead, use the argument `new_arg`,
             which is similar but does not impact the circuit's setup."
         pending: Set to `True` if the deprecation is still pending.
-        package_name: The PyPI package name, e.g. "qiskit-nature".
+        package_name: The package name shown in the deprecation message (e.g. the PyPI package name).
         new_alias: If the arg has simply been renamed, set this to the new name. The decorator will
             dynamically update the `kwargs` so that when the user sets the old arg, it will be
             passed in as the `new_alias` arg.
@@ -205,114 +205,6 @@ def deprecate_arg(
     return decorator
 
 
-def deprecate_arguments(
-    kwarg_map: dict[str, str | None],
-    category: Type[Warning] = DeprecationWarning,
-    *,
-    since: str | None = None,
-):
-    """Deprecated. Instead, use `@deprecate_arg`.
-
-    Args:
-        kwarg_map: A dictionary of the old argument name to the new name.
-        category: Usually either DeprecationWarning or PendingDeprecationWarning.
-        since: The version the deprecation started at. Only Optional for backwards
-            compatibility - this should always be set. If the deprecation is pending, set
-            the version to when that started; but later, when switching from pending to
-            deprecated, update `since` to the new version.
-
-    Returns:
-        Callable: The decorated callable.
-    """
-
-    def decorator(func):
-        func_name = func.__qualname__
-        old_kwarg_to_msg = {}
-        for old_arg, new_arg in kwarg_map.items():
-            msg_suffix = (
-                "will in the future be removed." if new_arg is None else f"replaced with {new_arg}."
-            )
-            old_kwarg_to_msg[old_arg] = (
-                f"{func_name} keyword argument {old_arg} is deprecated and {msg_suffix}"
-            )
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            for old, new in kwarg_map.items():
-                _maybe_warn_and_rename_kwarg(
-                    args,
-                    kwargs,
-                    func_name=func_name,
-                    original_func_co_varnames=wrapper.__original_func_co_varnames,
-                    old_arg_name=old,
-                    new_alias=new,
-                    warning_msg=old_kwarg_to_msg[old],
-                    category=category,
-                    predicate=None,
-                )
-            return func(*args, **kwargs)
-
-        # When decorators get called repeatedly, `func` refers to the result of the prior
-        # decorator, not the original underlying function. This trick allows us to record the
-        # original function's variable names regardless of how many decorators are used.
-        #
-        # If it's the very first decorator call, we also check that *args and **kwargs are not used.
-        if hasattr(func, "__original_func_co_varnames"):
-            wrapper.__original_func_co_varnames = func.__original_func_co_varnames
-        else:
-            wrapper.__original_func_co_varnames = func.__code__.co_varnames
-            param_kinds = {param.kind for param in inspect.signature(func).parameters.values()}
-            if inspect.Parameter.VAR_POSITIONAL in param_kinds:
-                raise ValueError(
-                    "@deprecate_arg cannot be used with functions that take variable *args. Use "
-                    "warnings.warn() directly instead."
-                )
-
-        for msg in old_kwarg_to_msg.values():
-            add_deprecation_to_docstring(
-                wrapper, msg, since=since, pending=issubclass(category, PendingDeprecationWarning)
-            )
-        return wrapper
-
-    return decorator
-
-
-def deprecate_function(
-    msg: str,
-    stacklevel: int = 2,
-    category: Type[Warning] = DeprecationWarning,
-    *,
-    since: str | None = None,
-):
-    """Deprecated. Instead, use `@deprecate_func`.
-
-    Args:
-        msg: Warning message to emit.
-        stacklevel: The warning stacklevel to use, defaults to 2.
-        category: Usually either DeprecationWarning or PendingDeprecationWarning.
-        since: The version the deprecation started at. Only Optional for backwards
-            compatibility - this should always be set. If the deprecation is pending, set
-            the version to when that started; but later, when switching from pending to
-            deprecated, update `since` to the new version.
-
-    Returns:
-        Callable: The decorated, deprecated callable.
-    """
-
-    def decorator(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            warnings.warn(msg, category=category, stacklevel=stacklevel)
-            return func(*args, **kwargs)
-
-        add_deprecation_to_docstring(
-            wrapper, msg, since=since, pending=issubclass(category, PendingDeprecationWarning)
-        )
-        return wrapper
-
-    return decorator
-
-
 def _maybe_warn_and_rename_kwarg(
     args: tuple[Any, ...],
     kwargs: dict[str, Any],

qiskit/utils/optionals.py

@@ -177,6 +177,13 @@ External Python Libraries
     special methods from Symengine to accelerate its handling of
     :class:`~.circuit.Parameter`\\ s if available.
 
+.. py:data:: HAS_SYMPY
+
+    `SymPy <https://www.sympy.org/en/index.html>`__ is Python library for symbolic mathematics.
+    Sympy was historically used for the implementation of the :class:`.ParameterExpression`
+    class but isn't any longer. However it is needed for some legacy functionality that uses
+    :meth:`.ParameterExpression.sympify`. It is also used in some visualization functions.
+
 .. py:data:: HAS_TESTTOOLS
 
     Qiskit's test suite has more advanced functionality available if the optional
@@ -186,9 +193,8 @@ External Python Libraries
 .. py:data:: HAS_TWEEDLEDUM
 
     `Tweedledum <https://github.com/boschmitt/tweedledum>`__ is an extension library for
-    synthesis and optimization of circuits that may involve classical oracles.  Qiskit's
-    :class:`.PhaseOracle` uses this, which is used in turn by amplification algorithms via
-    the :class:`.AmplificationProblem`.
+    synthesis and optimization of circuits that may involve classical oracles. In the past
+    Qiskit's :class:`.PhaseOracle` used this but it is no longer used by Qiskit.
 
 .. py:data:: HAS_Z3
 
@@ -323,7 +329,8 @@ HAS_SKQUANT = _LazyImportTester(
     install="pip install scikit-quant",
 )
 HAS_SQSNOBFIT = _LazyImportTester("SQSnobFit", install="pip install SQSnobFit")
-HAS_SYMENGINE = _LazyImportTester("symengine", install="pip install symengine")
+HAS_SYMENGINE = _LazyImportTester("symengine", install="pip install symengine<0.14")
+HAS_SYMPY = _LazyImportTester("sympy", install="pip install sympy")
 HAS_TESTTOOLS = _LazyImportTester("testtools", install="pip install testtools")
 HAS_TWEEDLEDUM = _LazyImportTester("tweedledum", install="pip install tweedledum")
 HAS_Z3 = _LazyImportTester("z3", install="pip install z3-solver")

qiskit/utils/parallel.py

@@ -10,7 +10,11 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-# This file is part of QuTiP: Quantum Toolbox in Python.
+# The original implementation of Qiskit's `parallel_map` in our commit c9c4ed52 was substantially
+# derived from QuTiP's (https://github.com/qutip/qutip) in `qutip/parallel.py` at their commit
+# f22d3cb7.  It has subsequently been significantly rewritten.
+#
+# The original implementation was used under these licence terms:
 #
 #    Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson.
 #    All rights reserved.
@@ -50,85 +54,226 @@ from the multiprocessing library.
 
 from __future__ import annotations
 
+import contextlib
+import functools
+import multiprocessing
 import os
-from concurrent.futures import ProcessPoolExecutor
+import platform
 import sys
+import warnings
+from concurrent.futures import ProcessPoolExecutor
 
-from qiskit.exceptions import QiskitError
-from qiskit.utils.multiprocessing import local_hardware_info
 from qiskit import user_config
 
 
-def get_platform_parallel_default():
-    """
-    Returns the default parallelism flag value for the current platform.
+CONFIG = user_config.get_config()
 
-    Returns:
-        parallel_default: The default parallelism flag value for the
-        current platform.
 
-    """
-    # Default False on Windows
-    if sys.platform == "win32":
-        parallel_default = False
-    # On macOS default false on Python >=3.8
-    elif sys.platform == "darwin":
-        parallel_default = False
-    # On linux (and other OSes) default to True
+def _task_wrapper(param):
+    (task, value, task_args, task_kwargs) = param
+    return task(value, *task_args, **task_kwargs)
+
+
+def _physical_cpus_assuming_twofold_smt():
+    if (sched_getaffinity := getattr(os, "sched_getaffinity", None)) is not None:
+        # It is callable, just pylint doesn't recognise it as `os.sched_getaffinity` because of the
+        # `getattr`.
+        # pylint: disable=not-callable
+        num_cpus = len(sched_getaffinity(0))
     else:
-        parallel_default = True
+        num_cpus = os.cpu_count() or 1
+    return (num_cpus // 2) or 1
 
-    return parallel_default
 
+def _parallel_default():
+    # We default to False on `spawn`-based multiprocessing implementations, True on everything else.
+    if (set_start_method := multiprocessing.get_start_method(allow_none=True)) is None:
+        # The method hasn't been explicitly set, but it would be badly behaved of us to set it for
+        # the user, so handle platform defaults.
+        return sys.platform not in ("darwin", "win32")
+    return set_start_method in ("fork", "forkserver")
 
-CONFIG = user_config.get_config()
 
-if os.getenv("QISKIT_PARALLEL", None) is not None:
-    PARALLEL_DEFAULT = os.getenv("QISKIT_PARALLEL", None).lower() == "true"
-else:
-    PARALLEL_DEFAULT = get_platform_parallel_default()
+@functools.cache
+def default_num_processes() -> int:
+    """Get the number of processes that a multiprocessing parallel call will use by default.
 
-# Set parallel flag
-if os.getenv("QISKIT_IN_PARALLEL") is None:
-    os.environ["QISKIT_IN_PARALLEL"] = "FALSE"
+    Such functions typically also accept a ``num_processes`` keyword argument that will supersede
+    the value returned from this function.
 
-if os.getenv("QISKIT_NUM_PROCS") is not None:
-    CPU_COUNT = int(os.getenv("QISKIT_NUM_PROCS"))
-else:
-    CPU_COUNT = CONFIG.get("num_process", local_hardware_info()["cpus"])
+    In order of priority (highest to lowest), the return value will be:
 
+    1. The ``QISKIT_NUM_PROCS`` environment variable, if set.
+    2. The ``num_processes`` key of the Qiskit user configuration file, if set.
+    3. Half of the logical CPUs available to this process, if this can be determined.  This is a
+       proxy for the number of physical CPUs, assuming two-fold simultaneous multithreading (SMT);
+       empirically, multiprocessing performance of Qiskit seems to be worse when attempting to use
+       SMT cores.
+    4. 1, if all else fails.
 
-def _task_wrapper(param):
-    (task, value, task_args, task_kwargs) = param
-    return task(value, *task_args, **task_kwargs)
+    If a user-configured value is set to a number less than 1, it is treated as if it were 1.
+    """
+    # Ignore both `None` (unset) and explicit set to empty string.
+    if env_num_processes := os.getenv("QISKIT_NUM_PROCS"):
+        try:
+            env_num_processes = int(env_num_processes)
+        except ValueError:
+            # Invalid: fall back to other methods.
+            warnings.warn(
+                "failed to interpret environment 'QISKIT_NUM_PROCS' as a number:"
+                f" '{env_num_processes}'"
+            )
+        else:
+            return env_num_processes if env_num_processes > 0 else 1
+    if (user_num_processes := CONFIG.get("num_processes", None)) is not None:
+        return user_num_processes if user_num_processes > 0 else 1
+    return _physical_cpus_assuming_twofold_smt()
+
+
+def local_hardware_info():
+    """Basic hardware information about the local machine.
+
+    Attempts to estimate the number of physical CPUs in the machine, even when hyperthreading is
+    turned on. CPU count defaults to 1 when true count can't be determined.
 
+    Returns:
+        dict: The hardware information.
+    """
+    return {
+        "python_compiler": platform.python_compiler(),
+        "python_build": ", ".join(platform.python_build()),
+        "python_version": platform.python_version(),
+        "os": platform.system(),
+        "cpus": _physical_cpus_assuming_twofold_smt(),
+    }
+
+
+def is_main_process() -> bool:
+    """Checks whether the current process is the main one.
+
+    Since Python 3.8, this is identical to the standard Python way of calculating this::
+
+        >>> import multiprocessing
+        >>> multiprocessing.parent_process() is None
+
+    This function is left for backwards compatibility, but there is little reason not to use the
+    built-in tooling of Python.
+    """
+    return multiprocessing.parent_process() is None
+
+
+_PARALLEL_OVERRIDE = None
+_PARALLEL_IGNORE_USER_SETTINGS = False
+_IN_PARALLEL_ALLOW_PARALLELISM = "FALSE"
+_IN_PARALLEL_FORBID_PARALLELISM = "TRUE"
 
+
+@functools.cache
 def should_run_in_parallel(num_processes: int | None = None) -> bool:
-    """Return whether the current parallelisation configuration suggests that we should run things
-    like :func:`parallel_map` in parallel (``True``) or degrade to serial (``False``).
+    """Decide whether a multiprocessing function should spawn subprocesses for parallelization.
+
+    In particular, this is how :func:`parallel_map` decides whether to use multiprocessing or not.
+    The ``num_processes`` argument alone does not enforce parallelism; by default, Qiskit will only
+    use process-based parallelism when a ``fork``-like process spawning start method is in effect.
+    You can override this decision either by setting the :mod:`multiprocessing` start method you
+    use, setting the ``QISKIT_PARALLEL`` environment variable to ``"TRUE"``, or setting
+    ``parallel = true`` in your user settings file.
+
+    This function includes two context managers that can be used to temporarily modify the return
+    value of this function:
+
+    .. autofunction:: qiskit.utils::should_run_in_parallel.override
+    .. autofunction:: qiskit.utils::should_run_in_parallel.ignore_user_settings
 
     Args:
-        num_processes: the number of processes requested for use (if given).
-    """
-    num_processes = CPU_COUNT if num_processes is None else num_processes
-    return (
-        num_processes > 1
-        and os.getenv("QISKIT_IN_PARALLEL", "FALSE") == "FALSE"
-        and CONFIG.get("parallel_enabled", PARALLEL_DEFAULT)
-    )
+        num_processes: the maximum number of processes requested for use (``None`` implies the
+            default).
 
+    Examples:
+        Temporarily override the configured settings to disable parallelism::
 
-def parallel_map(  # pylint: disable=dangerous-default-value
-    task, values, task_args=(), task_kwargs={}, num_processes=CPU_COUNT
-):
+            >>> with should_run_in_parallel.override(True):
+            ...     assert should_run_in_parallel(8)
+            >>> with should_run_in_parallel.override(False):
+            ...     assert not should_run_in_parallel(8)
+    """
+    # It's a configuration function with many simple choices - it'd be less clean to return late.
+    # pylint: disable=too-many-return-statements
+    num_processes = default_num_processes() if num_processes is None else num_processes
+    if num_processes < 2:
+        # There's no resources to parallelise over.
+        return False
+    if (
+        os.getenv("QISKIT_IN_PARALLEL", _IN_PARALLEL_ALLOW_PARALLELISM)
+        != _IN_PARALLEL_ALLOW_PARALLELISM
+    ):
+        # This isn't a user-set variable; we set this to talk to our own child processes.
+        return False
+    if _PARALLEL_OVERRIDE is not None:
+        return _PARALLEL_OVERRIDE
+    if _PARALLEL_IGNORE_USER_SETTINGS:
+        return _parallel_default()
+    if (env_qiskit_parallel := os.getenv("QISKIT_PARALLEL")) is not None:
+        return env_qiskit_parallel.lower() == "true"
+    if (user_qiskit_parallel := CONFIG.get("parallel_enabled", None)) is not None:
+        return user_qiskit_parallel
+    # Otherwise, fallback to the default.
+    return _parallel_default()
+
+
+@contextlib.contextmanager
+def _parallel_ignore_user_settings():
+    """A context manager within which :func:`should_run_in_parallel` will ignore environmental
+    configuration variables.
+
+    In particular, the ``QISKIT_PARALLEL`` environment variable and the user-configuration file are
+    ignored within this context."""
+    # The way around this would be to encapsulate `should_run_in_parallel` into a class, but since
+    # it's a singleton, it ends up being functionally no different to a global anyway.
+    global _PARALLEL_IGNORE_USER_SETTINGS  # pylint: disable=global-statement
+
+    should_run_in_parallel.cache_clear()
+    previous, _PARALLEL_IGNORE_USER_SETTINGS = _PARALLEL_IGNORE_USER_SETTINGS, True
+    try:
+        yield
+    finally:
+        _PARALLEL_IGNORE_USER_SETTINGS = previous
+        should_run_in_parallel.cache_clear()
+
+
+@contextlib.contextmanager
+def _parallel_override(value: bool):
+    """A context manager within which :func:`should_run_in_parallel` will return the given
+    ``value``.
+
+    This is not a *complete* override; Qiskit will never attempt to parallelize if only a single
+    process is available, and will not allow process-based parallelism at a depth greater than 1."""
+    # The way around this would be to encapsulate `should_run_in_parallel` into a class, but since
+    # it's a singleton, it ends up being functionally no different to a global anyway.
+    global _PARALLEL_OVERRIDE  # pylint: disable=global-statement
+
+    should_run_in_parallel.cache_clear()
+    previous, _PARALLEL_OVERRIDE = _PARALLEL_OVERRIDE, value
+    try:
+        yield
+    finally:
+        _PARALLEL_OVERRIDE = previous
+        should_run_in_parallel.cache_clear()
+
+
+should_run_in_parallel.ignore_user_settings = _parallel_ignore_user_settings
+should_run_in_parallel.override = _parallel_override
+
+
+def parallel_map(task, values, task_args=(), task_kwargs=None, num_processes=None):
     """
     Parallel execution of a mapping of `values` to the function `task`. This
     is functionally equivalent to::
 
         result = [task(value, *task_args, **task_kwargs) for value in values]
 
-    This will parallelise the results if the number of ``values`` is greater than one, and the
-    current system configuration permits parallelization.
+    This will parallelise the results if the number of ``values`` is greater than one and
+    :func:`should_run_in_parallel` returns ``True``.  If not, it will run in serial.
 
     Args:
         task (func): Function that is to be called for each value in ``values``.
@@ -136,18 +281,18 @@ def parallel_map(  # pylint: disable=dangerous-default-value
             evaluated.
         task_args (list): Optional additional arguments to the ``task`` function.
         task_kwargs (dict): Optional additional keyword argument to the ``task`` function.
-        num_processes (int): Number of processes to spawn.
+        num_processes (int): Number of processes to spawn.  If not given, the return value of
+            :func:`default_num_processes` is used.
 
     Returns:
         result: The result list contains the value of ``task(value, *task_args, **task_kwargs)`` for
         each value in ``values``.
 
-    Raises:
-        QiskitError: If user interrupts via keyboard.
-
     Examples:
 
-        .. code-block:: python
+        .. plot::
+           :include-source:
+           :nofigs:
 
             import time
             from qiskit.utils import parallel_map
@@ -156,36 +301,18 @@ def parallel_map(  # pylint: disable=dangerous-default-value
                     return 0
             parallel_map(func, list(range(10)));
     """
+    task_kwargs = {} if task_kwargs is None else task_kwargs
     if num_processes is None:
-        num_processes = CPU_COUNT
-    if len(values) == 0:
-        return []
-    if len(values) == 1:
-        return [task(values[0], *task_args, **task_kwargs)]
-
-    if should_run_in_parallel(num_processes):
-        os.environ["QISKIT_IN_PARALLEL"] = "TRUE"
-        try:
-            results = []
-            with ProcessPoolExecutor(max_workers=num_processes) as executor:
-                param = ((task, value, task_args, task_kwargs) for value in values)
-                future = executor.map(_task_wrapper, param)
-
-            results = list(future)
-
-        except (KeyboardInterrupt, Exception) as error:
-            if isinstance(error, KeyboardInterrupt):
-                os.environ["QISKIT_IN_PARALLEL"] = "FALSE"
-                raise QiskitError("Keyboard interrupt in parallel_map.") from error
-            # Otherwise just reset parallel flag and error
-            os.environ["QISKIT_IN_PARALLEL"] = "FALSE"
-            raise error
-
-        os.environ["QISKIT_IN_PARALLEL"] = "FALSE"
-        return results
-
-    results = []
-    for _, value in enumerate(values):
-        result = task(value, *task_args, **task_kwargs)
-        results.append(result)
-    return results
+        num_processes = default_num_processes()
+    if len(values) < 2 or not should_run_in_parallel(num_processes):
+        return [task(value, *task_args, **task_kwargs) for value in values]
+    work_items = ((task, value, task_args, task_kwargs) for value in values)
+
+    # This isn't a user-set variable; we set this to talk to our own child processes.
+    previous_in_parallel = os.getenv("QISKIT_IN_PARALLEL", _IN_PARALLEL_ALLOW_PARALLELISM)
+    os.environ["QISKIT_IN_PARALLEL"] = _IN_PARALLEL_FORBID_PARALLELISM
+    try:
+        with ProcessPoolExecutor(max_workers=num_processes) as executor:
+            return list(executor.map(_task_wrapper, work_items))
+    finally:
+        os.environ["QISKIT_IN_PARALLEL"] = previous_in_parallel

qiskit/utils/units.py

@@ -13,9 +13,12 @@
 """SI unit utilities"""
 from __future__ import annotations
 
+import typing
+
 import numpy as np
 
-from qiskit.circuit.parameterexpression import ParameterExpression
+if typing.TYPE_CHECKING:
+    from qiskit.circuit.parameterexpression import ParameterExpression
 
 
 def apply_prefix(value: float | ParameterExpression, unit: str) -> float | ParameterExpression: