25681780363

Committed 11 May 2026 04:04PM UTC coverage: 90.192% (-0.003%) from 90.195%

Build # 25681780363

Build Type

push

github

Committed by

web-flow

Commit Message

Removed support for Python 3.9 and Added support for Python 3.14 (#268)

Coverage Stats

3 of 3 new or added lines in 1 file covered. (100.0%)

3 existing lines in 1 file now uncovered.

6685 of 7412 relevant lines covered (90.19%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.37

/qiskit_algorithms/utils/algorithm_globals.py

# This code is part of a Qiskit project.
#
# (C) Copyright IBM 2019, 2023.
#
# 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.

"""
utils.algorithm_globals
=======================
Common (global) properties used across qiskit_algorithms.

.. currentmodule:: qiskit_algorithms.utils.algorithm_globals

Includes:

  * Random number generator and random seed.

    Algorithms can use the generator for random values, as needed, and it
    can be seeded here for reproducible results when using such an algorithm.
    This is often important, for example in unit tests, where the same
    outcome is desired each time (reproducible) and not have it be variable
    due to randomness.

Attributes:
    random_seed (int | None): Random generator seed (read/write).
    random (np.random.Generator): Random generator (read-only)
"""

from __future__ import annotations

import warnings

import numpy as np


class QiskitAlgorithmGlobals:
    """Global properties for algorithms."""

    # The code is done to work even after some future removal of algorithm_globals
    # from Qiskit (qiskit.utils). All that is needed in the future, after that, if
    # this is updated, is just the logic in the except blocks.
    #
    # If the Qiskit version exists this acts a redirect to that (it delegates the
    # calls off to it). In the future when that does not exist this has similar code
    # in the except blocks here, as noted above, that will take over. By delegating
    # to the Qiskit instance it means that any existing code that uses that continues
    # to work. Logic here in qiskit_algorithms though uses this instance and the
    # random check here has logic to warn if the seed here is not the same as the Qiskit
    # version so we can detect direct usage of the Qiskit version and alert the user to
    # change their code to use this. So simply changing from:
    #     from qiskit.utils import algorithm_globals
    # to
    #     from qiskit_algorithm.utils import algorithm_globals

    def __init__(self) -> None:
        self._random_seed: int | None = None
        self._random: np.random.Generator | None = None

    @property
    def random_seed(self) -> int | None:
        """Random seed property (getter/setter)."""
        try:
            with warnings.catch_warnings():
                warnings.simplefilter("ignore", category=DeprecationWarning)

                from qiskit.utils import algorithm_globals as qiskit_globals

                return qiskit_globals.random_seed

        except ImportError:
            return self._random_seed

    @random_seed.setter
    def random_seed(self, seed: int | None) -> None:
        """Set the random generator seed.

        Args:
            seed: If ``None`` then internally a random value is used as a seed
        """
        try:
            with warnings.catch_warnings():
                warnings.simplefilter("ignore", category=DeprecationWarning)

                from qiskit.utils import algorithm_globals as qiskit_globals

                qiskit_globals.random_seed = seed
                # Mirror the seed here when set via this random_seed. If the seed is
                # set on the qiskit.utils instance then we can detect it's different
                self._random_seed = seed

        except ImportError:
            self._random_seed = seed
            self._random = None

    @property
    def random(self) -> np.random.Generator:
        """Return a numpy np.random.Generator (default_rng) using random_seed."""
        try:
            with warnings.catch_warnings():
                warnings.simplefilter("ignore", category=DeprecationWarning)

                from qiskit.utils import algorithm_globals as qiskit_globals

                if self._random_seed != qiskit_globals.random_seed:
                    # If the seeds are different - likely this local is None and the qiskit.utils
                    # algorithms global was seeded directly then we will warn to use this here as
                    # the Qiskit version is planned to be removed in a future version of Qiskit.
                    warnings.warn(
                        "Using random that is seeded via qiskit.utils algorithm_globals is deprecated "
                        "since version 0.2.0. Instead set random_seed directly to "
                        "qiskit_algorithms.utils algorithm_globals.",
                        category=DeprecationWarning,
                        stacklevel=2,
                    )

                return qiskit_globals.random

        except ImportError:
            if self._random is None:
                self._random = np.random.default_rng(self._random_seed)
            return self._random


# Global instance to be used as the entry point for globals.
algorithm_globals = QiskitAlgorithmGlobals()

1	# This code is part of a Qiskit project.
2	#
3	# (C) Copyright IBM 2019, 2023.
4	#
5	# This code is licensed under the Apache License, Version 2.0. You may
6	# obtain a copy of this license in the LICENSE.txt file in the root directory
7	# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
8	#
9	# Any modifications or derivative works of this code must retain this
10	# copyright notice, and modified files need to carry a notice indicating
11	# that they have been altered from the originals.
12
13	"""
14	utils.algorithm_globals
15	=======================
16	Common (global) properties used across qiskit_algorithms.
17
18	.. currentmodule:: qiskit_algorithms.utils.algorithm_globals
19
20	Includes:
21
22	* Random number generator and random seed.
23
24	Algorithms can use the generator for random values, as needed, and it
25	can be seeded here for reproducible results when using such an algorithm.
26	This is often important, for example in unit tests, where the same
27	outcome is desired each time (reproducible) and not have it be variable
28	due to randomness.
29
30	Attributes:
31	random_seed (int \| None): Random generator seed (read/write).
32	random (np.random.Generator): Random generator (read-only)
33	"""
34
35	from __future__ import annotations	1✔
36
37	import warnings	1✔
38
39	import numpy as np	1✔
40
41
42	class QiskitAlgorithmGlobals:	1✔
43	"""Global properties for algorithms."""
44
45	# The code is done to work even after some future removal of algorithm_globals
46	# from Qiskit (qiskit.utils). All that is needed in the future, after that, if
47	# this is updated, is just the logic in the except blocks.
48	#
49	# If the Qiskit version exists this acts a redirect to that (it delegates the
50	# calls off to it). In the future when that does not exist this has similar code
51	# in the except blocks here, as noted above, that will take over. By delegating
52	# to the Qiskit instance it means that any existing code that uses that continues
53	# to work. Logic here in qiskit_algorithms though uses this instance and the
54	# random check here has logic to warn if the seed here is not the same as the Qiskit
55	# version so we can detect direct usage of the Qiskit version and alert the user to
56	# change their code to use this. So simply changing from:
57	# from qiskit.utils import algorithm_globals
58	# to
59	# from qiskit_algorithm.utils import algorithm_globals
60
61	def __init__(self) -> None:	1✔
62	self._random_seed: int \| None = None	1✔
63	self._random: np.random.Generator \| None = None	1✔
64
65	@property	1✔
66	def random_seed(self) -> int \| None:	1✔
67	"""Random seed property (getter/setter)."""
68	try:	1✔
69	with warnings.catch_warnings():	1✔
70	warnings.simplefilter("ignore", category=DeprecationWarning)	1✔
71
72	from qiskit.utils import algorithm_globals as qiskit_globals	1✔
73
UNCOV 74	return qiskit_globals.random_seed	×
75
76	except ImportError:	1✔
77	return self._random_seed	1✔
78
79	@random_seed.setter	1✔
80	def random_seed(self, seed: int \| None) -> None:	1✔
81	"""Set the random generator seed.
82
83	Args:
84	seed: If ``None`` then internally a random value is used as a seed
85	"""
86	try:	1✔
87	with warnings.catch_warnings():	1✔
88	warnings.simplefilter("ignore", category=DeprecationWarning)	1✔
89
90	from qiskit.utils import algorithm_globals as qiskit_globals	1✔
91
92	qiskit_globals.random_seed = seed	×
93	# Mirror the seed here when set via this random_seed. If the seed is
94	# set on the qiskit.utils instance then we can detect it's different
UNCOV 95	self._random_seed = seed	×
96
97	except ImportError:	1✔
98	self._random_seed = seed	1✔
99	self._random = None	1✔
100
101	@property	1✔
102	def random(self) -> np.random.Generator:	1✔
103	"""Return a numpy np.random.Generator (default_rng) using random_seed."""
104	try:	1✔
105	with warnings.catch_warnings():	1✔
106	warnings.simplefilter("ignore", category=DeprecationWarning)	1✔
107
108	from qiskit.utils import algorithm_globals as qiskit_globals	1✔
109
110	if self._random_seed != qiskit_globals.random_seed:	×
111	# If the seeds are different - likely this local is None and the qiskit.utils
112	# algorithms global was seeded directly then we will warn to use this here as
113	# the Qiskit version is planned to be removed in a future version of Qiskit.
114	warnings.warn(	×
115	"Using random that is seeded via qiskit.utils algorithm_globals is deprecated "
116	"since version 0.2.0. Instead set random_seed directly to "
117	"qiskit_algorithms.utils algorithm_globals.",
118	category=DeprecationWarning,
119	stacklevel=2,
120	)
121
UNCOV 122	return qiskit_globals.random	×
123
124	except ImportError:	1✔
125	if self._random is None:	1✔
126	self._random = np.random.default_rng(self._random_seed)	1✔
127	return self._random	1✔
128
129
130	# Global instance to be used as the entry point for globals.
131	algorithm_globals = QiskitAlgorithmGlobals()	1✔

qiskit-community / qiskit-algorithms / 25681780363

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous