instance_id
stringlengths 13
37
| text
stringlengths 3.08k
667k
| repo
stringclasses 35
values | base_commit
stringlengths 40
40
| problem_statement
stringlengths 10
256k
| hints_text
stringlengths 0
908k
| created_at
stringlengths 20
20
| patch
stringlengths 18
101M
| test_patch
stringclasses 1
value | version
stringclasses 1
value | FAIL_TO_PASS
stringclasses 1
value | PASS_TO_PASS
stringclasses 1
value | environment_setup_commit
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
Qiskit__qiskit-4465 | You will be provided with a partial code base and an issue statement explaining a problem to resolve.
<issue>
`initialize` and `Statevector` don't play nicely
<!-- ⚠️ If you do not respect this template, your issue will be closed -->
<!-- ⚠️ Make sure to browse the opened and closed issues -->
### Informations
- **Qiskit Aer version**: 0.5.1
- **Python version**: 3.7.3
- **Operating system**: OSX
### What is the current behavior?
Using `initialize` in a circuit and then running with `Statevector` results in the error "Cannot apply Instruction: reset"
### Steps to reproduce the problem
```
import qiskit as qk
import qiskit.quantum_info as qi
from numpy import sqrt
n = 2
ket0 = [1/sqrt(2),0,0,1/sqrt(2)]
qc = qk.QuantumCircuit(n)
qc.initialize(ket0,range(n))
ket_qi = qi.Statevector.from_instruction(qc)
```
</issue>
<code>
[start of README.md]
1 # Qiskit Terra
2
3 [](https://opensource.org/licenses/Apache-2.0)[](https://travis-ci.com/Qiskit/qiskit-terra)[](https://github.com/Qiskit/qiskit-terra/releases)[](https://pypi.org/project/qiskit-terra/)[](https://coveralls.io/github/Qiskit/qiskit-terra?branch=master)
4
5 **Qiskit** is an open-source framework for working with noisy quantum computers at the level of pulses, circuits, and algorithms.
6
7 Qiskit is made up of elements that work together to enable quantum computing. This element is **Terra** and is the foundation on which the rest of Qiskit is built.
8
9 ## Installation
10
11 We encourage installing Qiskit via the pip tool (a python package manager), which installs all Qiskit elements, including Terra.
12
13 ```bash
14 pip install qiskit
15 ```
16
17 PIP will handle all dependencies automatically and you will always install the latest (and well-tested) version.
18
19 To install from source, follow the instructions in the [documentation](https://qiskit.org/documentation/contributing_to_qiskit.html#install-terra-from-source).
20
21 ## Creating Your First Quantum Program in Qiskit Terra
22
23 Now that Qiskit is installed, it's time to begin working with Terra.
24
25 We are ready to try out a quantum circuit example, which is simulated locally using
26 the Qiskit BasicAer element. This is a simple example that makes an entangled state.
27
28 ```
29 $ python
30 ```
31
32 ```python
33 >>> from qiskit import *
34 >>> qc = QuantumCircuit(2, 2)
35 >>> qc.h(0)
36 >>> qc.cx(0, 1)
37 >>> qc.measure([0,1], [0,1])
38 >>> backend_sim = BasicAer.get_backend('qasm_simulator')
39 >>> result = backend_sim.run(assemble(qc)).result()
40 >>> print(result.get_counts(qc))
41 ```
42
43 In this case, the output will be:
44
45 ```python
46 {'00': 513, '11': 511}
47 ```
48
49 A script is available [here](examples/python/ibmq/hello_quantum.py), where we also show how to
50 run the same program on a real quantum computer via IBMQ.
51
52 ### Executing your code on a real quantum chip
53
54 You can also use Qiskit to execute your code on a
55 **real quantum chip**.
56 In order to do so, you need to configure Qiskit for using the credentials in
57 your IBM Q account:
58
59 #### Configure your IBMQ credentials
60
61 1. Create an _[IBM Q](https://quantum-computing.ibm.com) > Account_ if you haven't already done so.
62
63 2. Get an API token from the IBM Q website under _My Account > API Token_ and the URL for the account.
64
65 3. Take your token and url from step 2, here called `MY_API_TOKEN`, `MY_URL`, and run:
66
67 ```python
68 >>> from qiskit import IBMQ
69 >>> IBMQ.save_account('MY_API_TOKEN', 'MY_URL')
70 ```
71
72 After calling `IBMQ.save_account()`, your credentials will be stored on disk.
73 Once they are stored, at any point in the future you can load and use them
74 in your program simply via:
75
76 ```python
77 >>> from qiskit import IBMQ
78 >>> IBMQ.load_account()
79 ```
80
81 Those who do not want to save their credentials to disk should use instead:
82
83 ```python
84 >>> from qiskit import IBMQ
85 >>> IBMQ.enable_account('MY_API_TOKEN')
86 ```
87
88 and the token will only be active for the session. For examples using Terra with real
89 devices we have provided a set of examples in **examples/python** and we suggest starting with [using_qiskit_terra_level_0.py](examples/python/using_qiskit_terra_level_0.py) and working up in
90 the levels.
91
92 ## Contribution Guidelines
93
94 If you'd like to contribute to Qiskit Terra, please take a look at our
95 [contribution guidelines](CONTRIBUTING.md). This project adheres to Qiskit's [code of conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code.
96
97 We use [GitHub issues](https://github.com/Qiskit/qiskit-terra/issues) for tracking requests and bugs. Please
98 [join the Qiskit Slack community](https://join.slack.com/t/qiskit/shared_invite/zt-e4sscbg2-p8NHTezPVkC3r8nV6BIUVw)
99 and use our [Qiskit Slack channel](https://qiskit.slack.com) for discussion and simple questions.
100 For questions that are more suited for a forum we use the Qiskit tag in the [Stack Exchange](https://quantumcomputing.stackexchange.com/questions/tagged/qiskit).
101
102 ## Next Steps
103
104 Now you're set up and ready to check out some of the other examples from our
105 [Qiskit Tutorials](https://github.com/Qiskit/qiskit-tutorials) repository.
106
107 ## Authors and Citation
108
109 Qiskit Terra is the work of [many people](https://github.com/Qiskit/qiskit-terra/graphs/contributors) who contribute
110 to the project at different levels. If you use Qiskit, please cite as per the included [BibTeX file](https://github.com/Qiskit/qiskit/blob/master/Qiskit.bib).
111
112 ## Changelog and Release Notes
113
114 The changelog for a particular release is dynamically generated and gets
115 written to the release page on Github for each release. For example, you can
116 find the page for the `0.9.0` release here:
117
118 https://github.com/Qiskit/qiskit-terra/releases/tag/0.9.0
119
120 The changelog for the current release can be found in the releases tab:
121 
122 The changelog provides a quick overview of noteable changes for a given
123 release.
124
125 Additionally, as part of each release detailed release notes are written to
126 document in detail what has changed as part of a release. This includes any
127 documentation on potential breaking changes on upgrade and new features.
128 For example, You can find the release notes for the `0.9.0` release in the
129 Qiskit documentation here:
130
131 https://qiskit.org/documentation/release_notes.html#terra-0-9
132
133 ## License
134
135 [Apache License 2.0](LICENSE.txt)
136
[end of README.md]
[start of qiskit/providers/basicaer/unitary_simulator.py]
1 # -*- coding: utf-8 -*-
2
3 # This code is part of Qiskit.
4 #
5 # (C) Copyright IBM 2017.
6 #
7 # This code is licensed under the Apache License, Version 2.0. You may
8 # obtain a copy of this license in the LICENSE.txt file in the root directory
9 # of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
10 #
11 # Any modifications or derivative works of this code must retain this
12 # copyright notice, and modified files need to carry a notice indicating
13 # that they have been altered from the originals.
14
15 # pylint: disable=arguments-differ
16
17 """Contains a Python simulator that returns the unitary of the circuit.
18
19 It simulates a unitary of a quantum circuit that has been compiled to run on
20 the simulator. It is exponential in the number of qubits.
21
22 .. code-block:: python
23
24 UnitarySimulator().run(qobj)
25
26 Where the input is a Qobj object and the output is a BasicAerJob object, which can
27 later be queried for the Result object. The result will contain a 'unitary'
28 data field, which is a 2**n x 2**n complex numpy array representing the
29 circuit's unitary matrix.
30 """
31 import logging
32 import uuid
33 import time
34 from math import log2, sqrt
35 import numpy as np
36 from qiskit.util import local_hardware_info
37 from qiskit.providers.models import QasmBackendConfiguration
38 from qiskit.providers import BaseBackend
39 from qiskit.providers.basicaer.basicaerjob import BasicAerJob
40 from qiskit.result import Result
41 from .exceptions import BasicAerError
42 from .basicaertools import single_gate_matrix
43 from .basicaertools import cx_gate_matrix
44 from .basicaertools import einsum_matmul_index
45
46 logger = logging.getLogger(__name__)
47
48
49 # TODO add ["status"] = 'DONE', 'ERROR' especially for empty circuit error
50 # does not show up
51
52
53 class UnitarySimulatorPy(BaseBackend):
54 """Python implementation of a unitary simulator."""
55
56 MAX_QUBITS_MEMORY = int(log2(sqrt(local_hardware_info()['memory'] * (1024 ** 3) / 16)))
57
58 DEFAULT_CONFIGURATION = {
59 'backend_name': 'unitary_simulator',
60 'backend_version': '1.0.0',
61 'n_qubits': min(24, MAX_QUBITS_MEMORY),
62 'url': 'https://github.com/Qiskit/qiskit-terra',
63 'simulator': True,
64 'local': True,
65 'conditional': False,
66 'open_pulse': False,
67 'memory': False,
68 'max_shots': 65536,
69 'coupling_map': None,
70 'description': 'A python simulator for unitary matrix corresponding to a circuit',
71 'basis_gates': ['u1', 'u2', 'u3', 'cx', 'id', 'unitary'],
72 'gates': [
73 {
74 'name': 'u1',
75 'parameters': ['lambda'],
76 'qasm_def': 'gate u1(lambda) q { U(0,0,lambda) q; }'
77 },
78 {
79 'name': 'u2',
80 'parameters': ['phi', 'lambda'],
81 'qasm_def': 'gate u2(phi,lambda) q { U(pi/2,phi,lambda) q; }'
82 },
83 {
84 'name': 'u3',
85 'parameters': ['theta', 'phi', 'lambda'],
86 'qasm_def': 'gate u3(theta,phi,lambda) q { U(theta,phi,lambda) q; }'
87 },
88 {
89 'name': 'cx',
90 'parameters': ['c', 't'],
91 'qasm_def': 'gate cx c,t { CX c,t; }'
92 },
93 {
94 'name': 'id',
95 'parameters': ['a'],
96 'qasm_def': 'gate id a { U(0,0,0) a; }'
97 },
98 {
99 'name': 'unitary',
100 'parameters': ['matrix'],
101 'qasm_def': 'unitary(matrix) q1, q2,...'
102 }
103 ]
104 }
105
106 DEFAULT_OPTIONS = {
107 "initial_unitary": None,
108 "chop_threshold": 1e-15
109 }
110
111 def __init__(self, configuration=None, provider=None):
112 super().__init__(configuration=(
113 configuration or QasmBackendConfiguration.from_dict(self.DEFAULT_CONFIGURATION)),
114 provider=provider)
115
116 # Define attributes inside __init__.
117 self._unitary = None
118 self._number_of_qubits = 0
119 self._initial_unitary = None
120 self._chop_threshold = 1e-15
121
122 def _add_unitary(self, gate, qubits):
123 """Apply an N-qubit unitary matrix.
124
125 Args:
126 gate (matrix_like): an N-qubit unitary matrix
127 qubits (list): the list of N-qubits.
128 """
129 # Get the number of qubits
130 num_qubits = len(qubits)
131 # Compute einsum index string for 1-qubit matrix multiplication
132 indexes = einsum_matmul_index(qubits, self._number_of_qubits)
133 # Convert to complex rank-2N tensor
134 gate_tensor = np.reshape(np.array(gate, dtype=complex),
135 num_qubits * [2, 2])
136 # Apply matrix multiplication
137 self._unitary = np.einsum(indexes, gate_tensor, self._unitary,
138 dtype=complex, casting='no')
139
140 def _validate_initial_unitary(self):
141 """Validate an initial unitary matrix"""
142 # If initial unitary isn't set we don't need to validate
143 if self._initial_unitary is None:
144 return
145 # Check unitary is correct length for number of qubits
146 shape = np.shape(self._initial_unitary)
147 required_shape = (2 ** self._number_of_qubits,
148 2 ** self._number_of_qubits)
149 if shape != required_shape:
150 raise BasicAerError('initial unitary is incorrect shape: ' +
151 '{} != 2 ** {}'.format(shape, required_shape))
152
153 def _set_options(self, qobj_config=None, backend_options=None):
154 """Set the backend options for all experiments in a qobj"""
155 # Reset default options
156 self._initial_unitary = self.DEFAULT_OPTIONS["initial_unitary"]
157 self._chop_threshold = self.DEFAULT_OPTIONS["chop_threshold"]
158 if backend_options is None:
159 backend_options = {}
160
161 # Check for custom initial statevector in backend_options first,
162 # then config second
163 if 'initial_unitary' in backend_options:
164 self._initial_unitary = np.array(backend_options['initial_unitary'],
165 dtype=complex)
166 elif hasattr(qobj_config, 'initial_unitary'):
167 self._initial_unitary = np.array(qobj_config.initial_unitary,
168 dtype=complex)
169 if self._initial_unitary is not None:
170 # Check the initial unitary is actually unitary
171 shape = np.shape(self._initial_unitary)
172 if len(shape) != 2 or shape[0] != shape[1]:
173 raise BasicAerError("initial unitary is not a square matrix")
174 iden = np.eye(len(self._initial_unitary))
175 u_dagger_u = np.dot(self._initial_unitary.T.conj(),
176 self._initial_unitary)
177 norm = np.linalg.norm(u_dagger_u - iden)
178 if round(norm, 10) != 0:
179 raise BasicAerError("initial unitary is not unitary")
180 # Check the initial statevector is normalized
181
182 # Check for custom chop threshold
183 # Replace with custom options
184 if 'chop_threshold' in backend_options:
185 self._chop_threshold = backend_options['chop_threshold']
186 elif hasattr(qobj_config, 'chop_threshold'):
187 self._chop_threshold = qobj_config.chop_threshold
188
189 def _initialize_unitary(self):
190 """Set the initial unitary for simulation"""
191 self._validate_initial_unitary()
192 if self._initial_unitary is None:
193 # Set to identity matrix
194 self._unitary = np.eye(2 ** self._number_of_qubits,
195 dtype=complex)
196 else:
197 self._unitary = self._initial_unitary.copy()
198 # Reshape to rank-N tensor
199 self._unitary = np.reshape(self._unitary,
200 self._number_of_qubits * [2, 2])
201
202 def _get_unitary(self):
203 """Return the current unitary"""
204 unitary = np.reshape(self._unitary, 2 * [2 ** self._number_of_qubits])
205 unitary[abs(unitary) < self._chop_threshold] = 0.0
206 return unitary
207
208 def run(self, qobj, backend_options=None):
209 """Run qobj asynchronously.
210
211 Args:
212 qobj (Qobj): payload of the experiment
213 backend_options (dict): backend options
214
215 Returns:
216 BasicAerJob: derived from BaseJob
217
218 Additional Information::
219
220 backend_options: Is a dict of options for the backend. It may contain
221 * "initial_unitary": matrix_like
222 * "chop_threshold": double
223
224 The "initial_unitary" option specifies a custom initial unitary
225 matrix for the simulator to be used instead of the identity
226 matrix. This size of this matrix must be correct for the number
227 of qubits inall experiments in the qobj.
228
229 The "chop_threshold" option specifies a truncation value for
230 setting small values to zero in the output unitary. The default
231 value is 1e-15.
232
233 Example::
234
235 backend_options = {
236 "initial_unitary": np.array([[1, 0, 0, 0],
237 [0, 0, 0, 1],
238 [0, 0, 1, 0],
239 [0, 1, 0, 0]])
240 "chop_threshold": 1e-15
241 }
242 """
243 self._set_options(qobj_config=qobj.config,
244 backend_options=backend_options)
245 job_id = str(uuid.uuid4())
246 job = BasicAerJob(self, job_id, self._run_job, qobj)
247 job.submit()
248 return job
249
250 def _run_job(self, job_id, qobj):
251 """Run experiments in qobj.
252
253 Args:
254 job_id (str): unique id for the job.
255 qobj (Qobj): job description
256
257 Returns:
258 Result: Result object
259 """
260 self._validate(qobj)
261 result_list = []
262 start = time.time()
263 for experiment in qobj.experiments:
264 result_list.append(self.run_experiment(experiment))
265 end = time.time()
266 result = {'backend_name': self.name(),
267 'backend_version': self._configuration.backend_version,
268 'qobj_id': qobj.qobj_id,
269 'job_id': job_id,
270 'results': result_list,
271 'status': 'COMPLETED',
272 'success': True,
273 'time_taken': (end - start),
274 'header': qobj.header.to_dict()}
275
276 return Result.from_dict(result)
277
278 def run_experiment(self, experiment):
279 """Run an experiment (circuit) and return a single experiment result.
280
281 Args:
282 experiment (QobjExperiment): experiment from qobj experiments list
283
284 Returns:
285 dict: A result dictionary which looks something like::
286
287 {
288 "name": name of this experiment (obtained from qobj.experiment header)
289 "seed": random seed used for simulation
290 "shots": number of shots used in the simulation
291 "data":
292 {
293 "unitary": [[[0.0, 0.0], [1.0, 0.0]],
294 [[1.0, 0.0], [0.0, 0.0]]]
295 },
296 "status": status string for the simulation
297 "success": boolean
298 "time taken": simulation time of this single experiment
299 }
300
301 Raises:
302 BasicAerError: if the number of qubits in the circuit is greater than 24.
303 Note that the practical qubit limit is much lower than 24.
304 """
305 start = time.time()
306 self._number_of_qubits = experiment.header.n_qubits
307
308 # Validate the dimension of initial unitary if set
309 self._validate_initial_unitary()
310 self._initialize_unitary()
311
312 for operation in experiment.instructions:
313 if operation.name == 'unitary':
314 qubits = operation.qubits
315 gate = operation.params[0]
316 self._add_unitary(gate, qubits)
317 # Check if single gate
318 elif operation.name in ('U', 'u1', 'u2', 'u3'):
319 params = getattr(operation, 'params', None)
320 qubit = operation.qubits[0]
321 gate = single_gate_matrix(operation.name, params)
322 self._add_unitary(gate, [qubit])
323 elif operation.name in ('id', 'u0'):
324 pass
325 # Check if CX gate
326 elif operation.name in ('CX', 'cx'):
327 qubit0 = operation.qubits[0]
328 qubit1 = operation.qubits[1]
329 gate = cx_gate_matrix()
330 self._add_unitary(gate, [qubit0, qubit1])
331 # Check if barrier
332 elif operation.name == 'barrier':
333 pass
334 else:
335 backend = self.name()
336 err_msg = '{0} encountered unrecognized operation "{1}"'
337 raise BasicAerError(err_msg.format(backend, operation.name))
338 # Add final state to data
339 data = {'unitary': self._get_unitary()}
340 end = time.time()
341 return {'name': experiment.header.name,
342 'shots': 1,
343 'data': data,
344 'status': 'DONE',
345 'success': True,
346 'time_taken': (end - start),
347 'header': experiment.header.to_dict()}
348
349 def _validate(self, qobj):
350 """Semantic validations of the qobj which cannot be done via schemas.
351 Some of these may later move to backend schemas.
352 1. No shots
353 2. No measurements in the middle
354 """
355 n_qubits = qobj.config.n_qubits
356 max_qubits = self.configuration().n_qubits
357 if n_qubits > max_qubits:
358 raise BasicAerError('Number of qubits {} '.format(n_qubits) +
359 'is greater than maximum ({}) '.format(max_qubits) +
360 'for "{}".'.format(self.name()))
361 if hasattr(qobj.config, 'shots') and qobj.config.shots != 1:
362 logger.info('"%s" only supports 1 shot. Setting shots=1.',
363 self.name())
364 qobj.config.shots = 1
365 for experiment in qobj.experiments:
366 name = experiment.header.name
367 if getattr(experiment.config, 'shots', 1) != 1:
368 logger.info('"%s" only supports 1 shot. '
369 'Setting shots=1 for circuit "%s".',
370 self.name(), name)
371 experiment.config.shots = 1
372 for operation in experiment.instructions:
373 if operation.name in ['measure', 'reset']:
374 raise BasicAerError('Unsupported "%s" instruction "%s" ' +
375 'in circuit "%s" ', self.name(),
376 operation.name, name)
377
[end of qiskit/providers/basicaer/unitary_simulator.py]
[start of qiskit/quantum_info/states/statevector.py]
1 # -*- coding: utf-8 -*-
2
3 # This code is part of Qiskit.
4 #
5 # (C) Copyright IBM 2017, 2019.
6 #
7 # This code is licensed under the Apache License, Version 2.0. You may
8 # obtain a copy of this license in the LICENSE.txt file in the root directory
9 # of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
10 #
11 # Any modifications or derivative works of this code must retain this
12 # copyright notice, and modified files need to carry a notice indicating
13 # that they have been altered from the originals.
14
15 """
16 Statevector quantum state class.
17 """
18
19 import re
20 import warnings
21 from numbers import Number
22
23 import numpy as np
24
25 from qiskit.circuit.quantumcircuit import QuantumCircuit
26 from qiskit.circuit.instruction import Instruction
27 from qiskit.exceptions import QiskitError
28 from qiskit.quantum_info.states.quantum_state import QuantumState
29 from qiskit.quantum_info.operators.operator import Operator
30 from qiskit.quantum_info.operators.predicates import matrix_equal
31
32
33 class Statevector(QuantumState):
34 """Statevector class"""
35
36 def __init__(self, data, dims=None):
37 """Initialize a statevector object.
38
39 Args:
40 data (vector_like): a complex statevector.
41 dims (int or tuple or list): Optional. The subsystem dimension of
42 the state (See additional information).
43
44 Raises:
45 QiskitError: if input data is not valid.
46
47 Additional Information:
48 The ``dims`` kwarg can be None, an integer, or an iterable of
49 integers.
50
51 * ``Iterable`` -- the subsystem dimensions are the values in the list
52 with the total number of subsystems given by the length of the list.
53
54 * ``Int`` or ``None`` -- the length of the input vector
55 specifies the total dimension of the density matrix. If it is a
56 power of two the state will be initialized as an N-qubit state.
57 If it is not a power of two the state will have a single
58 d-dimensional subsystem.
59 """
60 if isinstance(data, (list, np.ndarray)):
61 # Finally we check if the input is a raw vector in either a
62 # python list or numpy array format.
63 self._data = np.asarray(data, dtype=complex)
64 elif isinstance(data, Statevector):
65 self._data = data._data
66 if dims is None:
67 dims = data._dims
68 elif isinstance(data, Operator):
69 # We allow conversion of column-vector operators to Statevectors
70 input_dim, output_dim = data.dim
71 if input_dim != 1:
72 raise QiskitError("Input Operator is not a column-vector.")
73 self._data = np.ravel(data.data)
74 else:
75 raise QiskitError("Invalid input data format for Statevector")
76 # Check that the input is a numpy vector or column-vector numpy
77 # matrix. If it is a column-vector matrix reshape to a vector.
78 ndim = self._data.ndim
79 shape = self._data.shape
80 if ndim != 1:
81 if ndim == 2 and shape[1] == 1:
82 self._data = np.reshape(self._data, shape[0])
83 elif ndim != 2 or shape[1] != 1:
84 raise QiskitError("Invalid input: not a vector or column-vector.")
85 super().__init__(self._automatic_dims(dims, shape[0]))
86
87 def __eq__(self, other):
88 return super().__eq__(other) and np.allclose(
89 self._data, other._data, rtol=self.rtol, atol=self.atol)
90
91 def __repr__(self):
92 prefix = 'Statevector('
93 pad = len(prefix) * ' '
94 return '{}{},\n{}dims={})'.format(
95 prefix, np.array2string(
96 self.data, separator=', ', prefix=prefix),
97 pad, self._dims)
98
99 @property
100 def data(self):
101 """Return data."""
102 return self._data
103
104 def is_valid(self, atol=None, rtol=None):
105 """Return True if a Statevector has norm 1."""
106 if atol is None:
107 atol = self.atol
108 if rtol is None:
109 rtol = self.rtol
110 norm = np.linalg.norm(self.data)
111 return np.allclose(norm, 1, rtol=rtol, atol=atol)
112
113 def to_operator(self):
114 """Convert state to a rank-1 projector operator"""
115 mat = np.outer(self.data, np.conj(self.data))
116 return Operator(mat, input_dims=self.dims(), output_dims=self.dims())
117
118 def conjugate(self):
119 """Return the conjugate of the operator."""
120 return Statevector(np.conj(self.data), dims=self.dims())
121
122 def trace(self):
123 """Return the trace of the quantum state as a density matrix."""
124 return np.sum(np.abs(self.data) ** 2)
125
126 def purity(self):
127 """Return the purity of the quantum state."""
128 # For a valid statevector the purity is always 1, however if we simply
129 # have an arbitrary vector (not correctly normalized) then the
130 # purity is equivalent to the trace squared:
131 # P(|psi>) = Tr[|psi><psi|psi><psi|] = |<psi|psi>|^2
132 return self.trace() ** 2
133
134 def tensor(self, other):
135 """Return the tensor product state self ⊗ other.
136
137 Args:
138 other (Statevector): a quantum state object.
139
140 Returns:
141 Statevector: the tensor product operator self ⊗ other.
142
143 Raises:
144 QiskitError: if other is not a quantum state.
145 """
146 if not isinstance(other, Statevector):
147 other = Statevector(other)
148 dims = other.dims() + self.dims()
149 data = np.kron(self._data, other._data)
150 return Statevector(data, dims)
151
152 def expand(self, other):
153 """Return the tensor product state other ⊗ self.
154
155 Args:
156 other (Statevector): a quantum state object.
157
158 Returns:
159 Statevector: the tensor product state other ⊗ self.
160
161 Raises:
162 QiskitError: if other is not a quantum state.
163 """
164 if not isinstance(other, Statevector):
165 other = Statevector(other)
166 dims = self.dims() + other.dims()
167 data = np.kron(other._data, self._data)
168 return Statevector(data, dims)
169
170 def _add(self, other):
171 """Return the linear combination self + other.
172
173 Args:
174 other (Statevector): a quantum state object.
175
176 Returns:
177 Statevector: the linear combination self + other.
178
179 Raises:
180 QiskitError: if other is not a quantum state, or has
181 incompatible dimensions.
182 """
183 if not isinstance(other, Statevector):
184 other = Statevector(other)
185 if self.dim != other.dim:
186 raise QiskitError("other Statevector has different dimensions.")
187 return Statevector(self.data + other.data, self.dims())
188
189 def _multiply(self, other):
190 """Return the scalar multiplied state self * other.
191
192 Args:
193 other (complex): a complex number.
194
195 Returns:
196 Statevector: the scalar multiplied state other * self.
197
198 Raises:
199 QiskitError: if other is not a valid complex number.
200 """
201 if not isinstance(other, Number):
202 raise QiskitError("other is not a number")
203 return Statevector(other * self.data, self.dims())
204
205 def evolve(self, other, qargs=None):
206 """Evolve a quantum state by the operator.
207
208 Args:
209 other (Operator): The operator to evolve by.
210 qargs (list): a list of Statevector subsystem positions to apply
211 the operator on.
212
213 Returns:
214 Statevector: the output quantum state.
215
216 Raises:
217 QiskitError: if the operator dimension does not match the
218 specified Statevector subsystem dimensions.
219 """
220 if qargs is None:
221 qargs = getattr(other, 'qargs', None)
222
223 # Evolution by a circuit or instruction
224 if isinstance(other, (QuantumCircuit, Instruction)):
225 return self._evolve_instruction(other, qargs=qargs)
226 # Evolution by an Operator
227 if not isinstance(other, Operator):
228 other = Operator(other)
229 if qargs is None:
230 # Evolution on full statevector
231 if self._dim != other._input_dim:
232 raise QiskitError(
233 "Operator input dimension is not equal to statevector dimension."
234 )
235 return Statevector(np.dot(other.data, self.data), dims=other.output_dims())
236 # Otherwise we are applying an operator only to subsystems
237 # Check dimensions of subsystems match the operator
238 if self.dims(qargs) != other.input_dims():
239 raise QiskitError(
240 "Operator input dimensions are not equal to statevector subsystem dimensions."
241 )
242 # Reshape statevector and operator
243 tensor = np.reshape(self.data, self._shape)
244 mat = np.reshape(other.data, other._shape)
245 # Construct list of tensor indices of statevector to be contracted
246 num_indices = len(self.dims())
247 indices = [num_indices - 1 - qubit for qubit in qargs]
248 tensor = Operator._einsum_matmul(tensor, mat, indices)
249 new_dims = list(self.dims())
250 for i, qubit in enumerate(qargs):
251 new_dims[qubit] = other._output_dims[i]
252 # Replace evolved dimensions
253 return Statevector(np.reshape(tensor, np.product(new_dims)), dims=new_dims)
254
255 def equiv(self, other, rtol=None, atol=None):
256 """Return True if statevectors are equivalent up to global phase.
257
258 Args:
259 other (Statevector): a statevector object.
260 rtol (float): relative tolerance value for comparison.
261 atol (float): absolute tolerance value for comparison.
262
263 Returns:
264 bool: True if statevectors are equivalent up to global phase.
265 """
266 if not isinstance(other, Statevector):
267 try:
268 other = Statevector(other)
269 except QiskitError:
270 return False
271 if self.dim != other.dim:
272 return False
273 if atol is None:
274 atol = self.atol
275 if rtol is None:
276 rtol = self.rtol
277 return matrix_equal(self.data, other.data, ignore_phase=True,
278 rtol=rtol, atol=atol)
279
280 def probabilities(self, qargs=None, decimals=None):
281 """Return the subsystem measurement probability vector.
282
283 Measurement probabilities are with respect to measurement in the
284 computation (diagonal) basis.
285
286 Args:
287 qargs (None or list): subsystems to return probabilities for,
288 if None return for all subsystems (Default: None).
289 decimals (None or int): the number of decimal places to round
290 values. If None no rounding is done (Default: None).
291
292 Returns:
293 np.array: The Numpy vector array of probabilities.
294
295 Examples:
296
297 Consider a 2-qubit product state
298 :math:`|\\psi\\rangle=|+\\rangle\\otimes|0\\rangle`.
299
300 .. jupyter-execute::
301
302 from qiskit.quantum_info import Statevector
303
304 psi = Statevector.from_label('+0')
305
306 # Probabilities for measuring both qubits
307 probs = psi.probabilities()
308 print('probs: {}'.format(probs))
309
310 # Probabilities for measuring only qubit-0
311 probs_qubit_0 = psi.probabilities([0])
312 print('Qubit-0 probs: {}'.format(probs_qubit_0))
313
314 # Probabilities for measuring only qubit-1
315 probs_qubit_1 = psi.probabilities([1])
316 print('Qubit-1 probs: {}'.format(probs_qubit_1))
317
318 We can also permute the order of qubits in the ``qargs`` list
319 to change the qubit position in the probabilities output
320
321 .. jupyter-execute::
322
323 from qiskit.quantum_info import Statevector
324
325 psi = Statevector.from_label('+0')
326
327 # Probabilities for measuring both qubits
328 probs = psi.probabilities([0, 1])
329 print('probs: {}'.format(probs))
330
331 # Probabilities for measuring both qubits
332 # but swapping qubits 0 and 1 in output
333 probs_swapped = psi.probabilities([1, 0])
334 print('Swapped probs: {}'.format(probs_swapped))
335 """
336 probs = self._subsystem_probabilities(
337 np.abs(self.data) ** 2, self._dims, qargs=qargs)
338 if decimals is not None:
339 probs = probs.round(decimals=decimals)
340 return probs
341
342 def reset(self, qargs=None):
343 """Reset state or subsystems to the 0-state.
344
345 Args:
346 qargs (list or None): subsystems to reset, if None all
347 subsystems will be reset to their 0-state
348 (Default: None).
349
350 Returns:
351 Statevector: the reset state.
352
353 Additional Information:
354 If all subsystems are reset this will return the ground state
355 on all subsystems. If only a some subsystems are reset this
356 function will perform a measurement on those subsystems and
357 evolve the subsystems so that the collapsed post-measurement
358 states are rotated to the 0-state. The RNG seed for this
359 sampling can be set using the :meth:`seed` method.
360 """
361 if qargs is None:
362 # Resetting all qubits does not require sampling or RNG
363 state = np.zeros(self._dim, dtype=complex)
364 state[0] = 1
365 return Statevector(state, dims=self._dims)
366
367 # Sample a single measurement outcome
368 dims = self.dims(qargs)
369 probs = self.probabilities(qargs)
370 sample = self._rng.choice(len(probs), p=probs, size=1)
371
372 # Convert to projector for state update
373 proj = np.zeros(len(probs), dtype=complex)
374 proj[sample] = 1 / np.sqrt(probs[sample])
375
376 # Rotate outcome to 0
377 reset = np.eye(len(probs))
378 reset[0, 0] = 0
379 reset[sample, sample] = 0
380 reset[0, sample] = 1
381
382 # compose with reset projection
383 reset = np.dot(reset, np.diag(proj))
384 return self.evolve(
385 Operator(reset, input_dims=dims, output_dims=dims),
386 qargs=qargs)
387
388 def to_counts(self):
389 """Returns the statevector as a counts dict
390 of probabilities.
391
392 DEPRECATED: use :meth:`probabilities_dict` instead.
393
394 Returns:
395 dict: Counts of probabilities.
396 """
397 warnings.warn(
398 'The `Statevector.to_counts` method is deprecated as of 0.13.0,'
399 ' and will be removed no earlier than 3 months after that '
400 'release date. You should use the `Statevector.probabilities_dict`'
401 ' method instead.', DeprecationWarning, stacklevel=2)
402 return self.probabilities_dict()
403
404 @classmethod
405 def from_label(cls, label):
406 """Return a tensor product of Pauli X,Y,Z eigenstates.
407
408 .. list-table:: Single-qubit state labels
409 :header-rows: 1
410
411 * - Label
412 - Statevector
413 * - ``"0"``
414 - :math:`[1, 0]`
415 * - ``"1"``
416 - :math:`[0, 1]`
417 * - ``"+"``
418 - :math:`[1 / \\sqrt{2}, 1 / \\sqrt{2}]`
419 * - ``"-"``
420 - :math:`[1 / \\sqrt{2}, -1 / \\sqrt{2}]`
421 * - ``"r"``
422 - :math:`[1 / \\sqrt{2}, i / \\sqrt{2}]`
423 * - ``"l"``
424 - :math:`[1 / \\sqrt{2}, -i / \\sqrt{2}]`
425
426 Args:
427 label (string): a eigenstate string ket label (see table for
428 allowed values).
429
430 Returns:
431 Statevector: The N-qubit basis state density matrix.
432
433 Raises:
434 QiskitError: if the label contains invalid characters, or the
435 length of the label is larger than an explicitly
436 specified num_qubits.
437 """
438 # Check label is valid
439 if re.match(r'^[01rl\-+]+$', label) is None:
440 raise QiskitError('Label contains invalid characters.')
441 # We can prepare Z-eigenstates by converting the computational
442 # basis bit-string to an integer and preparing that unit vector
443 # However, for X-basis states, we will prepare a Z-eigenstate first
444 # then apply Hadamard gates to rotate 0 and 1s to + and -.
445 z_label = label
446 xy_states = False
447 if re.match('^[01]+$', label) is None:
448 # We have X or Y eigenstates so replace +,r with 0 and
449 # -,l with 1 and prepare the corresponding Z state
450 xy_states = True
451 z_label = z_label.replace('+', '0')
452 z_label = z_label.replace('r', '0')
453 z_label = z_label.replace('-', '1')
454 z_label = z_label.replace('l', '1')
455 # Initialize Z eigenstate vector
456 num_qubits = len(label)
457 data = np.zeros(1 << num_qubits, dtype=complex)
458 pos = int(z_label, 2)
459 data[pos] = 1
460 state = Statevector(data)
461 if xy_states:
462 # Apply hadamards to all qubits in X eigenstates
463 x_mat = np.array([[1, 1], [1, -1]], dtype=complex) / np.sqrt(2)
464 # Apply S.H to qubits in Y eigenstates
465 y_mat = np.dot(np.diag([1, 1j]), x_mat)
466 for qubit, char in enumerate(reversed(label)):
467 if char in ['+', '-']:
468 state = state.evolve(x_mat, qargs=[qubit])
469 elif char in ['r', 'l']:
470 state = state.evolve(y_mat, qargs=[qubit])
471 return state
472
473 @staticmethod
474 def from_int(i, dims):
475 """Return a computational basis statevector.
476
477 Args:
478 i (int): the basis state element.
479 dims (int or tuple or list): The subsystem dimensions of the statevector
480 (See additional information).
481
482 Returns:
483 Statevector: The computational basis state :math:`|i\\rangle`.
484
485 Additional Information:
486 The ``dims`` kwarg can be an integer or an iterable of integers.
487
488 * ``Iterable`` -- the subsystem dimensions are the values in the list
489 with the total number of subsystems given by the length of the list.
490
491 * ``Int`` -- the integer specifies the total dimension of the
492 state. If it is a power of two the state will be initialized
493 as an N-qubit state. If it is not a power of two the state
494 will have a single d-dimensional subsystem.
495 """
496 size = np.product(dims)
497 state = np.zeros(size, dtype=complex)
498 state[i] = 1.0
499 return Statevector(state, dims=dims)
500
501 @classmethod
502 def from_instruction(cls, instruction):
503 """Return the output statevector of an instruction.
504
505 The statevector is initialized in the state :math:`|{0,\\ldots,0}\\rangle` of the
506 same number of qubits as the input instruction or circuit, evolved
507 by the input instruction, and the output statevector returned.
508
509 Args:
510 instruction (qiskit.circuit.Instruction or QuantumCircuit): instruction or circuit
511
512 Returns:
513 Statevector: The final statevector.
514
515 Raises:
516 QiskitError: if the instruction contains invalid instructions for
517 the statevector simulation.
518 """
519 # Convert circuit to an instruction
520 if isinstance(instruction, QuantumCircuit):
521 instruction = instruction.to_instruction()
522 # Initialize an the statevector in the all |0> state
523 init = np.zeros(2 ** instruction.num_qubits, dtype=complex)
524 init[0] = 1.0
525 vec = Statevector(init, dims=instruction.num_qubits * (2,))
526 vec._append_instruction(instruction)
527 return vec
528
529 def to_dict(self, decimals=None):
530 r"""Convert the statevector to dictionary form.
531
532 This dictionary representation uses a Ket-like notation where the
533 dictionary keys are qudit strings for the subsystem basis vectors.
534 If any subsystem has a dimension greater than 10 comma delimiters are
535 inserted between integers so that subsystems can be distinguished.
536
537 Args:
538 decimals (None or int): the number of decimal places to round
539 values. If None no rounding is done
540 (Default: None).
541
542 Returns:
543 dict: the dictionary form of the Statevector.
544
545 Example:
546
547 The ket-form of a 2-qubit statevector
548 :math:`|\psi\rangle = |-\rangle\otimes |0\rangle`
549
550 .. jupyter-execute::
551
552 from qiskit.quantum_info import Statevector
553
554 psi = Statevector.from_label('-0')
555 print(psi.to_dict())
556
557 For non-qubit subsystems the integer range can go from 0 to 9. For
558 example in a qutrit system
559
560 .. jupyter-execute::
561
562 import numpy as np
563 from qiskit.quantum_info import Statevector
564
565 vec = np.zeros(9)
566 vec[0] = 1 / np.sqrt(2)
567 vec[-1] = 1 / np.sqrt(2)
568 psi = Statevector(vec, dims=(3, 3))
569 print(psi.to_dict())
570
571 For large subsystem dimensions delimeters are required. The
572 following example is for a 20-dimensional system consisting of
573 a qubit and 10-dimensional qudit.
574
575 .. jupyter-execute::
576
577 import numpy as np
578 from qiskit.quantum_info import Statevector
579
580 vec = np.zeros(2 * 10)
581 vec[0] = 1 / np.sqrt(2)
582 vec[-1] = 1 / np.sqrt(2)
583 psi = Statevector(vec, dims=(2, 10))
584 print(psi.to_dict())
585 """
586 return self._vector_to_dict(self.data,
587 self._dims,
588 decimals=decimals,
589 string_labels=True)
590
591 @property
592 def _shape(self):
593 """Return the tensor shape of the matrix operator"""
594 return tuple(reversed(self.dims()))
595
596 def _append_instruction(self, obj, qargs=None):
597 """Update the current Statevector by applying an instruction."""
598 mat = Operator._instruction_to_matrix(obj)
599 if mat is not None:
600 # Perform the composition and inplace update the current state
601 # of the operator
602 state = self.evolve(mat, qargs=qargs)
603 self._data = state.data
604 else:
605 # If the instruction doesn't have a matrix defined we use its
606 # circuit decomposition definition if it exists, otherwise we
607 # cannot compose this gate and raise an error.
608 if obj.definition is None:
609 raise QiskitError('Cannot apply Instruction: {}'.format(obj.name))
610 for instr, qregs, cregs in obj.definition:
611 if cregs:
612 raise QiskitError(
613 'Cannot apply instruction with classical registers: {}'.format(
614 instr.name))
615 # Get the integer position of the flat register
616 if qargs is None:
617 new_qargs = [tup.index for tup in qregs]
618 else:
619 new_qargs = [qargs[tup.index] for tup in qregs]
620 self._append_instruction(instr, qargs=new_qargs)
621
622 def _evolve_instruction(self, obj, qargs=None):
623 """Return a new statevector by applying an instruction."""
624 if isinstance(obj, QuantumCircuit):
625 obj = obj.to_instruction()
626 vec = Statevector(self.data, dims=self.dims())
627 vec._append_instruction(obj, qargs=qargs)
628 return vec
629
[end of qiskit/quantum_info/states/statevector.py]
</code>
I need you to solve this issue by generating a single patch file that I can apply directly to this repository using git apply. Please respond with a single patch file in the following format.
<patch>
--- a/file.py
+++ b/file.py
@@ -1,27 +1,35 @@
def euclidean(a, b):
- while b:
- a, b = b, a % b
- return a
+ if b == 0:
+ return a
+ return euclidean(b, a % b)
def bresenham(x0, y0, x1, y1):
points = []
dx = abs(x1 - x0)
dy = abs(y1 - y0)
- sx = 1 if x0 < x1 else -1
- sy = 1 if y0 < y1 else -1
- err = dx - dy
+ x, y = x0, y0
+ sx = -1 if x0 > x1 else 1
+ sy = -1 if y0 > y1 else 1
- while True:
- points.append((x0, y0))
- if x0 == x1 and y0 == y1:
- break
- e2 = 2 * err
- if e2 > -dy:
+ if dx > dy:
+ err = dx / 2.0
+ while x != x1:
+ points.append((x, y))
err -= dy
- x0 += sx
- if e2 < dx:
- err += dx
- y0 += sy
+ if err < 0:
+ y += sy
+ err += dx
+ x += sx
+ else:
+ err = dy / 2.0
+ while y != y1:
+ points.append((x, y))
+ err -= dx
+ if err < 0:
+ x += sx
+ err += dy
+ y += sy
+ points.append((x, y))
return points
</patch>
| Qiskit/qiskit | aae6eab589915d948f89d1b131019282560df61a | `initialize` and `Statevector` don't play nicely
<!-- ⚠️ If you do not respect this template, your issue will be closed -->
<!-- ⚠️ Make sure to browse the opened and closed issues -->
### Informations
- **Qiskit Aer version**: 0.5.1
- **Python version**: 3.7.3
- **Operating system**: OSX
### What is the current behavior?
Using `initialize` in a circuit and then running with `Statevector` results in the error "Cannot apply Instruction: reset"
### Steps to reproduce the problem
```
import qiskit as qk
import qiskit.quantum_info as qi
from numpy import sqrt
n = 2
ket0 = [1/sqrt(2),0,0,1/sqrt(2)]
qc = qk.QuantumCircuit(n)
qc.initialize(ket0,range(n))
ket_qi = qi.Statevector.from_instruction(qc)
```
| Funny cause the circuit has no resets:
```
┌───┐┌───────────────┐┌───┐»
q_0: ─|0>──────────────────────────────┤ X ├┤ U3(-pi/2,0,0) ├┤ X ├»
┌──────────────┐┌───────────┐└─┬─┘└───────────────┘└─┬─┘»
q_1: ─|0>─┤ U3(pi/2,0,0) ├┤ U3(0,0,0) ├──■─────────────────────■──»
└──────────────┘└───────────┘ »
« ┌──────────────┐┌───┐┌───────────┐┌───┐┌───────────┐
«q_0: ┤ U3(pi/2,0,0) ├┤ X ├┤ U3(0,0,0) ├┤ X ├┤ U3(0,0,0) ├
« └──────────────┘└─┬─┘└───────────┘└─┬─┘└───────────┘
«q_1: ──────────────────■─────────────────■───────────────
«
```
That circuit has a lot of things I don't like, but at least it has no resets.
@nonhermitian That circuit *does* have resets, notice the two |0> |0> at the start? The definition of initialize has reset instructions on all qubits that are removed by the transpiler if it is the first instruction in a circuit. This is so you can "initialize" subsets of qubits at any stage of a circuit.
I'm transferring this to Qiskit Terra. In the future please post issues related to the Quantum info module in Terra, not Aer.
That is not just the initial state of the qubits? That is what used to be there. It is hard to tell the difference here. So that means that initialize is no longer a unitary operation like it was before? I guess I missed that as well.
A reset method was added to the Statevector class last release, so the simulation could be updated to work with initialize via adding support of reset to the the from_instruction method.
@nonhermitian I think this was changed recently in the draw function. Now circuits are drawn without any initial states, so any time you see them they refer to reset instructions.
Yeah, it is just that the original text drawing is very close to the reset instructions so it is hard for the user to understand. | 2020-05-15T16:51:32Z | <patch>
diff --git a/qiskit/quantum_info/states/densitymatrix.py b/qiskit/quantum_info/states/densitymatrix.py
--- a/qiskit/quantum_info/states/densitymatrix.py
+++ b/qiskit/quantum_info/states/densitymatrix.py
@@ -547,12 +547,22 @@ def _evolve_operator(self, other, qargs=None):
def _append_instruction(self, other, qargs=None):
"""Update the current Statevector by applying an instruction."""
+ from qiskit.circuit.reset import Reset
+ from qiskit.circuit.barrier import Barrier
# Try evolving by a matrix operator (unitary-like evolution)
mat = Operator._instruction_to_matrix(other)
if mat is not None:
self._data = self._evolve_operator(Operator(mat), qargs=qargs).data
return
+
+ # Special instruction types
+ if isinstance(other, Reset):
+ self._data = self.reset(qargs)._data
+ return
+ if isinstance(other, Barrier):
+ return
+
# Otherwise try evolving by a Superoperator
chan = SuperOp._instruction_to_superop(other)
if chan is not None:
diff --git a/qiskit/quantum_info/states/statevector.py b/qiskit/quantum_info/states/statevector.py
--- a/qiskit/quantum_info/states/statevector.py
+++ b/qiskit/quantum_info/states/statevector.py
@@ -595,29 +595,40 @@ def _shape(self):
def _append_instruction(self, obj, qargs=None):
"""Update the current Statevector by applying an instruction."""
+ from qiskit.circuit.reset import Reset
+ from qiskit.circuit.barrier import Barrier
+
mat = Operator._instruction_to_matrix(obj)
if mat is not None:
# Perform the composition and inplace update the current state
# of the operator
- state = self.evolve(mat, qargs=qargs)
- self._data = state.data
- else:
- # If the instruction doesn't have a matrix defined we use its
- # circuit decomposition definition if it exists, otherwise we
- # cannot compose this gate and raise an error.
- if obj.definition is None:
- raise QiskitError('Cannot apply Instruction: {}'.format(obj.name))
- for instr, qregs, cregs in obj.definition:
- if cregs:
- raise QiskitError(
- 'Cannot apply instruction with classical registers: {}'.format(
- instr.name))
- # Get the integer position of the flat register
- if qargs is None:
- new_qargs = [tup.index for tup in qregs]
- else:
- new_qargs = [qargs[tup.index] for tup in qregs]
- self._append_instruction(instr, qargs=new_qargs)
+ self._data = self.evolve(mat, qargs=qargs).data
+ return
+
+ # Special instruction types
+ if isinstance(obj, Reset):
+ self._data = self.reset(qargs)._data
+ return
+ if isinstance(obj, Barrier):
+ return
+
+ # If the instruction doesn't have a matrix defined we use its
+ # circuit decomposition definition if it exists, otherwise we
+ # cannot compose this gate and raise an error.
+ if obj.definition is None:
+ raise QiskitError('Cannot apply Instruction: {}'.format(obj.name))
+
+ for instr, qregs, cregs in obj.definition:
+ if cregs:
+ raise QiskitError(
+ 'Cannot apply instruction with classical registers: {}'.format(
+ instr.name))
+ # Get the integer position of the flat register
+ if qargs is None:
+ new_qargs = [tup.index for tup in qregs]
+ else:
+ new_qargs = [qargs[tup.index] for tup in qregs]
+ self._append_instruction(instr, qargs=new_qargs)
def _evolve_instruction(self, obj, qargs=None):
"""Return a new statevector by applying an instruction."""
</patch> | [] | [] | |||
ipython__ipython-10213 | You will be provided with a partial code base and an issue statement explaining a problem to resolve.
<issue>
remove usage of backports.shutil_get_terminal_size
This is for pre-3.3 Python.
Pretty easy it should only require deleting lines.
Maybe a few need to be dedented.
</issue>
<code>
[start of README.rst]
1 .. image:: https://codecov.io/github/ipython/ipython/coverage.svg?branch=master
2 :target: https://codecov.io/github/ipython/ipython?branch=master
3
4 .. image:: https://img.shields.io/pypi/dm/IPython.svg
5 :target: https://pypi.python.org/pypi/ipython
6
7 .. image:: https://img.shields.io/pypi/v/IPython.svg
8 :target: https://pypi.python.org/pypi/ipython
9
10 .. image:: https://img.shields.io/travis/ipython/ipython.svg
11 :target: https://travis-ci.org/ipython/ipython
12
13
14 ===========================================
15 IPython: Productive Interactive Computing
16 ===========================================
17
18 Overview
19 ========
20
21 Welcome to IPython. Our full documentation is available on `ipython.readthedocs.io
22 <https://ipython.readthedocs.io/en/stable/>`_ and contains information on how to install, use and
23 contribute to the project.
24
25 Officially, IPython requires Python version 3.3 and above.
26 IPython 5.x is the last IPython version to support Python 2.7.
27
28 The Notebook, Qt console and a number of other pieces are now parts of *Jupyter*.
29 See the `Jupyter installation docs <http://jupyter.readthedocs.io/en/latest/install.html>`__
30 if you want to use these.
31
32
33
34
35 Development and Instant running
36 ===============================
37
38 You can find the latest version of the development documentation on `readthedocs
39 <http://ipython.readthedocs.io/en/latest/>`_.
40
41 You can run IPython from this directory without even installing it system-wide
42 by typing at the terminal::
43
44 $ python -m IPython
45
46 Or see the `development installation docs
47 <http://ipython.readthedocs.io/en/latest/install/install.html#installing-the-development-version>`_
48 for the latest revision on read the docs.
49
50 Documentation and installation instructions for older version of IPython can be
51 found on the `IPython website <http://ipython.org/documentation.html>`_
52
53
54
55 IPython requires Python version 3 or above
56 ==========================================
57
58 Starting with version 6.0, IPython does not support Python 2.7, 3.0, 3.1, or
59 3.2.
60
61 For a version compatible with Python 2.7, please install the 5.x LTS Long Term
62 Support version.
63
64 If you are encountering this error message you are likely trying to install or
65 use IPython from source. You need to checkout the remote 5.x branch. If you are
66 using git the following should work:
67
68 $ git fetch origin
69 $ git checkout -b origin/5.x
70
71 If you encounter this error message with a regular install of IPython, then you
72 likely need to update your package manager, for example if you are using `pip`
73 check the version of pip with
74
75 $ pip --version
76
77 You will need to update pip to the version 8.2 or greater. If you are not using
78 pip, please inquiry with the maintainers of the package for your package
79 manager.
80
81 For more information see one of our blog posts:
82
83 http://blog.jupyter.org/2016/07/08/ipython-5-0-released/
84
85 As well as the following Pull-Request for discussion:
86
87 https://github.com/ipython/ipython/pull/9900
88
[end of README.rst]
[start of IPython/core/magics/basic.py]
1 """Implementation of basic magic functions."""
2
3
4 import argparse
5 import io
6 import sys
7 from pprint import pformat
8
9 from IPython.core import magic_arguments, page
10 from IPython.core.error import UsageError
11 from IPython.core.magic import Magics, magics_class, line_magic, magic_escapes
12 from IPython.utils.text import format_screen, dedent, indent
13 from IPython.testing.skipdoctest import skip_doctest
14 from IPython.utils.ipstruct import Struct
15 from warnings import warn
16 from logging import error
17
18
19 class MagicsDisplay(object):
20 def __init__(self, magics_manager):
21 self.magics_manager = magics_manager
22
23 def _lsmagic(self):
24 """The main implementation of the %lsmagic"""
25 mesc = magic_escapes['line']
26 cesc = magic_escapes['cell']
27 mman = self.magics_manager
28 magics = mman.lsmagic()
29 out = ['Available line magics:',
30 mesc + (' '+mesc).join(sorted(magics['line'])),
31 '',
32 'Available cell magics:',
33 cesc + (' '+cesc).join(sorted(magics['cell'])),
34 '',
35 mman.auto_status()]
36 return '\n'.join(out)
37
38 def _repr_pretty_(self, p, cycle):
39 p.text(self._lsmagic())
40
41 def __str__(self):
42 return self._lsmagic()
43
44 def _jsonable(self):
45 """turn magics dict into jsonable dict of the same structure
46
47 replaces object instances with their class names as strings
48 """
49 magic_dict = {}
50 mman = self.magics_manager
51 magics = mman.lsmagic()
52 for key, subdict in magics.items():
53 d = {}
54 magic_dict[key] = d
55 for name, obj in subdict.items():
56 try:
57 classname = obj.__self__.__class__.__name__
58 except AttributeError:
59 classname = 'Other'
60
61 d[name] = classname
62 return magic_dict
63
64 def _repr_json_(self):
65 return self._jsonable()
66
67
68 @magics_class
69 class BasicMagics(Magics):
70 """Magics that provide central IPython functionality.
71
72 These are various magics that don't fit into specific categories but that
73 are all part of the base 'IPython experience'."""
74
75 @magic_arguments.magic_arguments()
76 @magic_arguments.argument(
77 '-l', '--line', action='store_true',
78 help="""Create a line magic alias."""
79 )
80 @magic_arguments.argument(
81 '-c', '--cell', action='store_true',
82 help="""Create a cell magic alias."""
83 )
84 @magic_arguments.argument(
85 'name',
86 help="""Name of the magic to be created."""
87 )
88 @magic_arguments.argument(
89 'target',
90 help="""Name of the existing line or cell magic."""
91 )
92 @line_magic
93 def alias_magic(self, line=''):
94 """Create an alias for an existing line or cell magic.
95
96 Examples
97 --------
98 ::
99
100 In [1]: %alias_magic t timeit
101 Created `%t` as an alias for `%timeit`.
102 Created `%%t` as an alias for `%%timeit`.
103
104 In [2]: %t -n1 pass
105 1 loops, best of 3: 954 ns per loop
106
107 In [3]: %%t -n1
108 ...: pass
109 ...:
110 1 loops, best of 3: 954 ns per loop
111
112 In [4]: %alias_magic --cell whereami pwd
113 UsageError: Cell magic function `%%pwd` not found.
114 In [5]: %alias_magic --line whereami pwd
115 Created `%whereami` as an alias for `%pwd`.
116
117 In [6]: %whereami
118 Out[6]: u'/home/testuser'
119 """
120 args = magic_arguments.parse_argstring(self.alias_magic, line)
121 shell = self.shell
122 mman = self.shell.magics_manager
123 escs = ''.join(magic_escapes.values())
124
125 target = args.target.lstrip(escs)
126 name = args.name.lstrip(escs)
127
128 # Find the requested magics.
129 m_line = shell.find_magic(target, 'line')
130 m_cell = shell.find_magic(target, 'cell')
131 if args.line and m_line is None:
132 raise UsageError('Line magic function `%s%s` not found.' %
133 (magic_escapes['line'], target))
134 if args.cell and m_cell is None:
135 raise UsageError('Cell magic function `%s%s` not found.' %
136 (magic_escapes['cell'], target))
137
138 # If --line and --cell are not specified, default to the ones
139 # that are available.
140 if not args.line and not args.cell:
141 if not m_line and not m_cell:
142 raise UsageError(
143 'No line or cell magic with name `%s` found.' % target
144 )
145 args.line = bool(m_line)
146 args.cell = bool(m_cell)
147
148 if args.line:
149 mman.register_alias(name, target, 'line')
150 print('Created `%s%s` as an alias for `%s%s`.' % (
151 magic_escapes['line'], name,
152 magic_escapes['line'], target))
153
154 if args.cell:
155 mman.register_alias(name, target, 'cell')
156 print('Created `%s%s` as an alias for `%s%s`.' % (
157 magic_escapes['cell'], name,
158 magic_escapes['cell'], target))
159
160 @line_magic
161 def lsmagic(self, parameter_s=''):
162 """List currently available magic functions."""
163 return MagicsDisplay(self.shell.magics_manager)
164
165 def _magic_docs(self, brief=False, rest=False):
166 """Return docstrings from magic functions."""
167 mman = self.shell.magics_manager
168 docs = mman.lsmagic_docs(brief, missing='No documentation')
169
170 if rest:
171 format_string = '**%s%s**::\n\n%s\n\n'
172 else:
173 format_string = '%s%s:\n%s\n'
174
175 return ''.join(
176 [format_string % (magic_escapes['line'], fname,
177 indent(dedent(fndoc)))
178 for fname, fndoc in sorted(docs['line'].items())]
179 +
180 [format_string % (magic_escapes['cell'], fname,
181 indent(dedent(fndoc)))
182 for fname, fndoc in sorted(docs['cell'].items())]
183 )
184
185 @line_magic
186 def magic(self, parameter_s=''):
187 """Print information about the magic function system.
188
189 Supported formats: -latex, -brief, -rest
190 """
191
192 mode = ''
193 try:
194 mode = parameter_s.split()[0][1:]
195 except IndexError:
196 pass
197
198 brief = (mode == 'brief')
199 rest = (mode == 'rest')
200 magic_docs = self._magic_docs(brief, rest)
201
202 if mode == 'latex':
203 print(self.format_latex(magic_docs))
204 return
205 else:
206 magic_docs = format_screen(magic_docs)
207
208 out = ["""
209 IPython's 'magic' functions
210 ===========================
211
212 The magic function system provides a series of functions which allow you to
213 control the behavior of IPython itself, plus a lot of system-type
214 features. There are two kinds of magics, line-oriented and cell-oriented.
215
216 Line magics are prefixed with the % character and work much like OS
217 command-line calls: they get as an argument the rest of the line, where
218 arguments are passed without parentheses or quotes. For example, this will
219 time the given statement::
220
221 %timeit range(1000)
222
223 Cell magics are prefixed with a double %%, and they are functions that get as
224 an argument not only the rest of the line, but also the lines below it in a
225 separate argument. These magics are called with two arguments: the rest of the
226 call line and the body of the cell, consisting of the lines below the first.
227 For example::
228
229 %%timeit x = numpy.random.randn((100, 100))
230 numpy.linalg.svd(x)
231
232 will time the execution of the numpy svd routine, running the assignment of x
233 as part of the setup phase, which is not timed.
234
235 In a line-oriented client (the terminal or Qt console IPython), starting a new
236 input with %% will automatically enter cell mode, and IPython will continue
237 reading input until a blank line is given. In the notebook, simply type the
238 whole cell as one entity, but keep in mind that the %% escape can only be at
239 the very start of the cell.
240
241 NOTE: If you have 'automagic' enabled (via the command line option or with the
242 %automagic function), you don't need to type in the % explicitly for line
243 magics; cell magics always require an explicit '%%' escape. By default,
244 IPython ships with automagic on, so you should only rarely need the % escape.
245
246 Example: typing '%cd mydir' (without the quotes) changes your working directory
247 to 'mydir', if it exists.
248
249 For a list of the available magic functions, use %lsmagic. For a description
250 of any of them, type %magic_name?, e.g. '%cd?'.
251
252 Currently the magic system has the following functions:""",
253 magic_docs,
254 "Summary of magic functions (from %slsmagic):" % magic_escapes['line'],
255 str(self.lsmagic()),
256 ]
257 page.page('\n'.join(out))
258
259
260 @line_magic
261 def page(self, parameter_s=''):
262 """Pretty print the object and display it through a pager.
263
264 %page [options] OBJECT
265
266 If no object is given, use _ (last output).
267
268 Options:
269
270 -r: page str(object), don't pretty-print it."""
271
272 # After a function contributed by Olivier Aubert, slightly modified.
273
274 # Process options/args
275 opts, args = self.parse_options(parameter_s, 'r')
276 raw = 'r' in opts
277
278 oname = args and args or '_'
279 info = self.shell._ofind(oname)
280 if info['found']:
281 txt = (raw and str or pformat)( info['obj'] )
282 page.page(txt)
283 else:
284 print('Object `%s` not found' % oname)
285
286 @line_magic
287 def profile(self, parameter_s=''):
288 """Print your currently active IPython profile.
289
290 See Also
291 --------
292 prun : run code using the Python profiler
293 (:meth:`~IPython.core.magics.execution.ExecutionMagics.prun`)
294 """
295 warn("%profile is now deprecated. Please use get_ipython().profile instead.")
296 from IPython.core.application import BaseIPythonApplication
297 if BaseIPythonApplication.initialized():
298 print(BaseIPythonApplication.instance().profile)
299 else:
300 error("profile is an application-level value, but you don't appear to be in an IPython application")
301
302 @line_magic
303 def pprint(self, parameter_s=''):
304 """Toggle pretty printing on/off."""
305 ptformatter = self.shell.display_formatter.formatters['text/plain']
306 ptformatter.pprint = bool(1 - ptformatter.pprint)
307 print('Pretty printing has been turned',
308 ['OFF','ON'][ptformatter.pprint])
309
310 @line_magic
311 def colors(self, parameter_s=''):
312 """Switch color scheme for prompts, info system and exception handlers.
313
314 Currently implemented schemes: NoColor, Linux, LightBG.
315
316 Color scheme names are not case-sensitive.
317
318 Examples
319 --------
320 To get a plain black and white terminal::
321
322 %colors nocolor
323 """
324 def color_switch_err(name):
325 warn('Error changing %s color schemes.\n%s' %
326 (name, sys.exc_info()[1]), stacklevel=2)
327
328
329 new_scheme = parameter_s.strip()
330 if not new_scheme:
331 raise UsageError(
332 "%colors: you must specify a color scheme. See '%colors?'")
333 # local shortcut
334 shell = self.shell
335
336 # Set shell colour scheme
337 try:
338 shell.colors = new_scheme
339 shell.refresh_style()
340 except:
341 color_switch_err('shell')
342
343 # Set exception colors
344 try:
345 shell.InteractiveTB.set_colors(scheme = new_scheme)
346 shell.SyntaxTB.set_colors(scheme = new_scheme)
347 except:
348 color_switch_err('exception')
349
350 # Set info (for 'object?') colors
351 if shell.color_info:
352 try:
353 shell.inspector.set_active_scheme(new_scheme)
354 except:
355 color_switch_err('object inspector')
356 else:
357 shell.inspector.set_active_scheme('NoColor')
358
359 @line_magic
360 def xmode(self, parameter_s=''):
361 """Switch modes for the exception handlers.
362
363 Valid modes: Plain, Context and Verbose.
364
365 If called without arguments, acts as a toggle."""
366
367 def xmode_switch_err(name):
368 warn('Error changing %s exception modes.\n%s' %
369 (name,sys.exc_info()[1]))
370
371 shell = self.shell
372 new_mode = parameter_s.strip().capitalize()
373 try:
374 shell.InteractiveTB.set_mode(mode=new_mode)
375 print('Exception reporting mode:',shell.InteractiveTB.mode)
376 except:
377 xmode_switch_err('user')
378
379 @line_magic
380 def quickref(self,arg):
381 """ Show a quick reference sheet """
382 from IPython.core.usage import quick_reference
383 qr = quick_reference + self._magic_docs(brief=True)
384 page.page(qr)
385
386 @line_magic
387 def doctest_mode(self, parameter_s=''):
388 """Toggle doctest mode on and off.
389
390 This mode is intended to make IPython behave as much as possible like a
391 plain Python shell, from the perspective of how its prompts, exceptions
392 and output look. This makes it easy to copy and paste parts of a
393 session into doctests. It does so by:
394
395 - Changing the prompts to the classic ``>>>`` ones.
396 - Changing the exception reporting mode to 'Plain'.
397 - Disabling pretty-printing of output.
398
399 Note that IPython also supports the pasting of code snippets that have
400 leading '>>>' and '...' prompts in them. This means that you can paste
401 doctests from files or docstrings (even if they have leading
402 whitespace), and the code will execute correctly. You can then use
403 '%history -t' to see the translated history; this will give you the
404 input after removal of all the leading prompts and whitespace, which
405 can be pasted back into an editor.
406
407 With these features, you can switch into this mode easily whenever you
408 need to do testing and changes to doctests, without having to leave
409 your existing IPython session.
410 """
411
412 # Shorthands
413 shell = self.shell
414 meta = shell.meta
415 disp_formatter = self.shell.display_formatter
416 ptformatter = disp_formatter.formatters['text/plain']
417 # dstore is a data store kept in the instance metadata bag to track any
418 # changes we make, so we can undo them later.
419 dstore = meta.setdefault('doctest_mode',Struct())
420 save_dstore = dstore.setdefault
421
422 # save a few values we'll need to recover later
423 mode = save_dstore('mode',False)
424 save_dstore('rc_pprint',ptformatter.pprint)
425 save_dstore('xmode',shell.InteractiveTB.mode)
426 save_dstore('rc_separate_out',shell.separate_out)
427 save_dstore('rc_separate_out2',shell.separate_out2)
428 save_dstore('rc_separate_in',shell.separate_in)
429 save_dstore('rc_active_types',disp_formatter.active_types)
430
431 if not mode:
432 # turn on
433
434 # Prompt separators like plain python
435 shell.separate_in = ''
436 shell.separate_out = ''
437 shell.separate_out2 = ''
438
439
440 ptformatter.pprint = False
441 disp_formatter.active_types = ['text/plain']
442
443 shell.magic('xmode Plain')
444 else:
445 # turn off
446 shell.separate_in = dstore.rc_separate_in
447
448 shell.separate_out = dstore.rc_separate_out
449 shell.separate_out2 = dstore.rc_separate_out2
450
451 ptformatter.pprint = dstore.rc_pprint
452 disp_formatter.active_types = dstore.rc_active_types
453
454 shell.magic('xmode ' + dstore.xmode)
455
456 # mode here is the state before we switch; switch_doctest_mode takes
457 # the mode we're switching to.
458 shell.switch_doctest_mode(not mode)
459
460 # Store new mode and inform
461 dstore.mode = bool(not mode)
462 mode_label = ['OFF','ON'][dstore.mode]
463 print('Doctest mode is:', mode_label)
464
465 @line_magic
466 def gui(self, parameter_s=''):
467 """Enable or disable IPython GUI event loop integration.
468
469 %gui [GUINAME]
470
471 This magic replaces IPython's threaded shells that were activated
472 using the (pylab/wthread/etc.) command line flags. GUI toolkits
473 can now be enabled at runtime and keyboard
474 interrupts should work without any problems. The following toolkits
475 are supported: wxPython, PyQt4, PyGTK, Tk and Cocoa (OSX)::
476
477 %gui wx # enable wxPython event loop integration
478 %gui qt4|qt # enable PyQt4 event loop integration
479 %gui qt5 # enable PyQt5 event loop integration
480 %gui gtk # enable PyGTK event loop integration
481 %gui gtk3 # enable Gtk3 event loop integration
482 %gui tk # enable Tk event loop integration
483 %gui osx # enable Cocoa event loop integration
484 # (requires %matplotlib 1.1)
485 %gui # disable all event loop integration
486
487 WARNING: after any of these has been called you can simply create
488 an application object, but DO NOT start the event loop yourself, as
489 we have already handled that.
490 """
491 opts, arg = self.parse_options(parameter_s, '')
492 if arg=='': arg = None
493 try:
494 return self.shell.enable_gui(arg)
495 except Exception as e:
496 # print simple error message, rather than traceback if we can't
497 # hook up the GUI
498 error(str(e))
499
500 @skip_doctest
501 @line_magic
502 def precision(self, s=''):
503 """Set floating point precision for pretty printing.
504
505 Can set either integer precision or a format string.
506
507 If numpy has been imported and precision is an int,
508 numpy display precision will also be set, via ``numpy.set_printoptions``.
509
510 If no argument is given, defaults will be restored.
511
512 Examples
513 --------
514 ::
515
516 In [1]: from math import pi
517
518 In [2]: %precision 3
519 Out[2]: u'%.3f'
520
521 In [3]: pi
522 Out[3]: 3.142
523
524 In [4]: %precision %i
525 Out[4]: u'%i'
526
527 In [5]: pi
528 Out[5]: 3
529
530 In [6]: %precision %e
531 Out[6]: u'%e'
532
533 In [7]: pi**10
534 Out[7]: 9.364805e+04
535
536 In [8]: %precision
537 Out[8]: u'%r'
538
539 In [9]: pi**10
540 Out[9]: 93648.047476082982
541 """
542 ptformatter = self.shell.display_formatter.formatters['text/plain']
543 ptformatter.float_precision = s
544 return ptformatter.float_format
545
546 @magic_arguments.magic_arguments()
547 @magic_arguments.argument(
548 '-e', '--export', action='store_true', default=False,
549 help=argparse.SUPPRESS
550 )
551 @magic_arguments.argument(
552 'filename', type=str,
553 help='Notebook name or filename'
554 )
555 @line_magic
556 def notebook(self, s):
557 """Export and convert IPython notebooks.
558
559 This function can export the current IPython history to a notebook file.
560 For example, to export the history to "foo.ipynb" do "%notebook foo.ipynb".
561
562 The -e or --export flag is deprecated in IPython 5.2, and will be
563 removed in the future.
564 """
565 args = magic_arguments.parse_argstring(self.notebook, s)
566
567 from nbformat import write, v4
568
569 cells = []
570 hist = list(self.shell.history_manager.get_range())
571 if(len(hist)<=1):
572 raise ValueError('History is empty, cannot export')
573 for session, execution_count, source in hist[:-1]:
574 cells.append(v4.new_code_cell(
575 execution_count=execution_count,
576 source=source
577 ))
578 nb = v4.new_notebook(cells=cells)
579 with io.open(args.filename, 'w', encoding='utf-8') as f:
580 write(nb, f, version=4)
581
[end of IPython/core/magics/basic.py]
[start of IPython/utils/tokenize2.py]
1 """Patched version of standard library tokenize, to deal with various bugs.
2
3 Based on Python 3.2 code.
4
5 Patches:
6
7 - Gareth Rees' patch for Python issue #12691 (untokenizing)
8 - Except we don't encode the output of untokenize
9 - Python 2 compatible syntax, so that it can be byte-compiled at installation
10 - Newlines in comments and blank lines should be either NL or NEWLINE, depending
11 on whether they are in a multi-line statement. Filed as Python issue #17061.
12 - Export generate_tokens & TokenError
13 - u and rb literals are allowed under Python 3.3 and above.
14
15 ------------------------------------------------------------------------------
16 Tokenization help for Python programs.
17
18 tokenize(readline) is a generator that breaks a stream of bytes into
19 Python tokens. It decodes the bytes according to PEP-0263 for
20 determining source file encoding.
21
22 It accepts a readline-like method which is called repeatedly to get the
23 next line of input (or b"" for EOF). It generates 5-tuples with these
24 members:
25
26 the token type (see token.py)
27 the token (a string)
28 the starting (row, column) indices of the token (a 2-tuple of ints)
29 the ending (row, column) indices of the token (a 2-tuple of ints)
30 the original line (string)
31
32 It is designed to match the working of the Python tokenizer exactly, except
33 that it produces COMMENT tokens for comments and gives type OP for all
34 operators. Additionally, all token lists start with an ENCODING token
35 which tells you which encoding was used to decode the bytes stream.
36 """
37
38 __author__ = 'Ka-Ping Yee <ping@lfw.org>'
39 __credits__ = ('GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, '
40 'Skip Montanaro, Raymond Hettinger, Trent Nelson, '
41 'Michael Foord')
42 import builtins
43 import re
44 import sys
45 from token import *
46 from codecs import lookup, BOM_UTF8
47 import collections
48 from io import TextIOWrapper
49 cookie_re = re.compile("coding[:=]\s*([-\w.]+)")
50
51 import token
52 __all__ = token.__all__ + ["COMMENT", "tokenize", "detect_encoding",
53 "NL", "untokenize", "ENCODING", "TokenInfo"]
54 del token
55
56 __all__ += ["generate_tokens", "TokenError"]
57
58 COMMENT = N_TOKENS
59 tok_name[COMMENT] = 'COMMENT'
60 NL = N_TOKENS + 1
61 tok_name[NL] = 'NL'
62 ENCODING = N_TOKENS + 2
63 tok_name[ENCODING] = 'ENCODING'
64 N_TOKENS += 3
65
66 class TokenInfo(collections.namedtuple('TokenInfo', 'type string start end line')):
67 def __repr__(self):
68 annotated_type = '%d (%s)' % (self.type, tok_name[self.type])
69 return ('TokenInfo(type=%s, string=%r, start=%r, end=%r, line=%r)' %
70 self._replace(type=annotated_type))
71
72 def group(*choices): return '(' + '|'.join(choices) + ')'
73 def any(*choices): return group(*choices) + '*'
74 def maybe(*choices): return group(*choices) + '?'
75
76 # Note: we use unicode matching for names ("\w") but ascii matching for
77 # number literals.
78 Whitespace = r'[ \f\t]*'
79 Comment = r'#[^\r\n]*'
80 Ignore = Whitespace + any(r'\\\r?\n' + Whitespace) + maybe(Comment)
81 Name = r'\w+'
82
83 Hexnumber = r'0[xX][0-9a-fA-F]+'
84 Binnumber = r'0[bB][01]+'
85 Octnumber = r'0[oO][0-7]+'
86 Decnumber = r'(?:0+|[1-9][0-9]*)'
87 Intnumber = group(Hexnumber, Binnumber, Octnumber, Decnumber)
88 Exponent = r'[eE][-+]?[0-9]+'
89 Pointfloat = group(r'[0-9]+\.[0-9]*', r'\.[0-9]+') + maybe(Exponent)
90 Expfloat = r'[0-9]+' + Exponent
91 Floatnumber = group(Pointfloat, Expfloat)
92 Imagnumber = group(r'[0-9]+[jJ]', Floatnumber + r'[jJ]')
93 Number = group(Imagnumber, Floatnumber, Intnumber)
94
95 if sys.version_info.minor >= 3:
96 StringPrefix = r'(?:[bB][rR]?|[rR][bB]?|[uU])?'
97 else:
98 StringPrefix = r'(?:[bB]?[rR]?)?'
99
100 # Tail end of ' string.
101 Single = r"[^'\\]*(?:\\.[^'\\]*)*'"
102 # Tail end of " string.
103 Double = r'[^"\\]*(?:\\.[^"\\]*)*"'
104 # Tail end of ''' string.
105 Single3 = r"[^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''"
106 # Tail end of """ string.
107 Double3 = r'[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""'
108 Triple = group(StringPrefix + "'''", StringPrefix + '"""')
109 # Single-line ' or " string.
110 String = group(StringPrefix + r"'[^\n'\\]*(?:\\.[^\n'\\]*)*'",
111 StringPrefix + r'"[^\n"\\]*(?:\\.[^\n"\\]*)*"')
112
113 # Because of leftmost-then-longest match semantics, be sure to put the
114 # longest operators first (e.g., if = came before ==, == would get
115 # recognized as two instances of =).
116 Operator = group(r"\*\*=?", r">>=?", r"<<=?", r"!=",
117 r"//=?", r"->",
118 r"[+\-*/%&|^=<>]=?",
119 r"~")
120
121 Bracket = '[][(){}]'
122 Special = group(r'\r?\n', r'\.\.\.', r'[:;.,@]')
123 Funny = group(Operator, Bracket, Special)
124
125 PlainToken = group(Number, Funny, String, Name)
126 Token = Ignore + PlainToken
127
128 # First (or only) line of ' or " string.
129 ContStr = group(StringPrefix + r"'[^\n'\\]*(?:\\.[^\n'\\]*)*" +
130 group("'", r'\\\r?\n'),
131 StringPrefix + r'"[^\n"\\]*(?:\\.[^\n"\\]*)*' +
132 group('"', r'\\\r?\n'))
133 PseudoExtras = group(r'\\\r?\n', Comment, Triple)
134 PseudoToken = Whitespace + group(PseudoExtras, Number, Funny, ContStr, Name)
135
136 def _compile(expr):
137 return re.compile(expr, re.UNICODE)
138
139 tokenprog, pseudoprog, single3prog, double3prog = map(
140 _compile, (Token, PseudoToken, Single3, Double3))
141 endprogs = {"'": _compile(Single), '"': _compile(Double),
142 "'''": single3prog, '"""': double3prog,
143 "r'''": single3prog, 'r"""': double3prog,
144 "b'''": single3prog, 'b"""': double3prog,
145 "R'''": single3prog, 'R"""': double3prog,
146 "B'''": single3prog, 'B"""': double3prog,
147 "br'''": single3prog, 'br"""': double3prog,
148 "bR'''": single3prog, 'bR"""': double3prog,
149 "Br'''": single3prog, 'Br"""': double3prog,
150 "BR'''": single3prog, 'BR"""': double3prog,
151 'r': None, 'R': None, 'b': None, 'B': None}
152
153 triple_quoted = {}
154 for t in ("'''", '"""',
155 "r'''", 'r"""', "R'''", 'R"""',
156 "b'''", 'b"""', "B'''", 'B"""',
157 "br'''", 'br"""', "Br'''", 'Br"""',
158 "bR'''", 'bR"""', "BR'''", 'BR"""'):
159 triple_quoted[t] = t
160 single_quoted = {}
161 for t in ("'", '"',
162 "r'", 'r"', "R'", 'R"',
163 "b'", 'b"', "B'", 'B"',
164 "br'", 'br"', "Br'", 'Br"',
165 "bR'", 'bR"', "BR'", 'BR"' ):
166 single_quoted[t] = t
167
168 if sys.version_info.minor >= 3:
169 # Python 3.3
170 for _prefix in ['rb', 'rB', 'Rb', 'RB', 'u', 'U']:
171 _t2 = _prefix+'"""'
172 endprogs[_t2] = double3prog
173 triple_quoted[_t2] = _t2
174 _t1 = _prefix + "'''"
175 endprogs[_t1] = single3prog
176 triple_quoted[_t1] = _t1
177 single_quoted[_prefix+'"'] = _prefix+'"'
178 single_quoted[_prefix+"'"] = _prefix+"'"
179 del _prefix, _t2, _t1
180 endprogs['u'] = None
181 endprogs['U'] = None
182
183 del _compile
184
185 tabsize = 8
186
187 class TokenError(Exception): pass
188
189 class StopTokenizing(Exception): pass
190
191
192 class Untokenizer:
193
194 def __init__(self):
195 self.tokens = []
196 self.prev_row = 1
197 self.prev_col = 0
198 self.encoding = 'utf-8'
199
200 def add_whitespace(self, tok_type, start):
201 row, col = start
202 assert row >= self.prev_row
203 col_offset = col - self.prev_col
204 if col_offset > 0:
205 self.tokens.append(" " * col_offset)
206 elif row > self.prev_row and tok_type not in (NEWLINE, NL, ENDMARKER):
207 # Line was backslash-continued.
208 self.tokens.append(" ")
209
210 def untokenize(self, tokens):
211 iterable = iter(tokens)
212 for t in iterable:
213 if len(t) == 2:
214 self.compat(t, iterable)
215 break
216 tok_type, token, start, end = t[:4]
217 if tok_type == ENCODING:
218 self.encoding = token
219 continue
220 self.add_whitespace(tok_type, start)
221 self.tokens.append(token)
222 self.prev_row, self.prev_col = end
223 if tok_type in (NEWLINE, NL):
224 self.prev_row += 1
225 self.prev_col = 0
226 return "".join(self.tokens)
227
228 def compat(self, token, iterable):
229 # This import is here to avoid problems when the itertools
230 # module is not built yet and tokenize is imported.
231 from itertools import chain
232 startline = False
233 prevstring = False
234 indents = []
235 toks_append = self.tokens.append
236
237 for tok in chain([token], iterable):
238 toknum, tokval = tok[:2]
239 if toknum == ENCODING:
240 self.encoding = tokval
241 continue
242
243 if toknum in (NAME, NUMBER):
244 tokval += ' '
245
246 # Insert a space between two consecutive strings
247 if toknum == STRING:
248 if prevstring:
249 tokval = ' ' + tokval
250 prevstring = True
251 else:
252 prevstring = False
253
254 if toknum == INDENT:
255 indents.append(tokval)
256 continue
257 elif toknum == DEDENT:
258 indents.pop()
259 continue
260 elif toknum in (NEWLINE, NL):
261 startline = True
262 elif startline and indents:
263 toks_append(indents[-1])
264 startline = False
265 toks_append(tokval)
266
267
268 def untokenize(tokens):
269 """
270 Convert ``tokens`` (an iterable) back into Python source code. Return
271 a bytes object, encoded using the encoding specified by the last
272 ENCODING token in ``tokens``, or UTF-8 if no ENCODING token is found.
273
274 The result is guaranteed to tokenize back to match the input so that
275 the conversion is lossless and round-trips are assured. The
276 guarantee applies only to the token type and token string as the
277 spacing between tokens (column positions) may change.
278
279 :func:`untokenize` has two modes. If the input tokens are sequences
280 of length 2 (``type``, ``string``) then spaces are added as necessary to
281 preserve the round-trip property.
282
283 If the input tokens are sequences of length 4 or more (``type``,
284 ``string``, ``start``, ``end``), as returned by :func:`tokenize`, then
285 spaces are added so that each token appears in the result at the
286 position indicated by ``start`` and ``end``, if possible.
287 """
288 return Untokenizer().untokenize(tokens)
289
290
291 def _get_normal_name(orig_enc):
292 """Imitates get_normal_name in tokenizer.c."""
293 # Only care about the first 12 characters.
294 enc = orig_enc[:12].lower().replace("_", "-")
295 if enc == "utf-8" or enc.startswith("utf-8-"):
296 return "utf-8"
297 if enc in ("latin-1", "iso-8859-1", "iso-latin-1") or \
298 enc.startswith(("latin-1-", "iso-8859-1-", "iso-latin-1-")):
299 return "iso-8859-1"
300 return orig_enc
301
302 def detect_encoding(readline):
303 """
304 The detect_encoding() function is used to detect the encoding that should
305 be used to decode a Python source file. It requires one argment, readline,
306 in the same way as the tokenize() generator.
307
308 It will call readline a maximum of twice, and return the encoding used
309 (as a string) and a list of any lines (left as bytes) it has read in.
310
311 It detects the encoding from the presence of a utf-8 bom or an encoding
312 cookie as specified in pep-0263. If both a bom and a cookie are present,
313 but disagree, a SyntaxError will be raised. If the encoding cookie is an
314 invalid charset, raise a SyntaxError. Note that if a utf-8 bom is found,
315 'utf-8-sig' is returned.
316
317 If no encoding is specified, then the default of 'utf-8' will be returned.
318 """
319 bom_found = False
320 encoding = None
321 default = 'utf-8'
322 def read_or_stop():
323 try:
324 return readline()
325 except StopIteration:
326 return b''
327
328 def find_cookie(line):
329 try:
330 # Decode as UTF-8. Either the line is an encoding declaration,
331 # in which case it should be pure ASCII, or it must be UTF-8
332 # per default encoding.
333 line_string = line.decode('utf-8')
334 except UnicodeDecodeError:
335 raise SyntaxError("invalid or missing encoding declaration")
336
337 matches = cookie_re.findall(line_string)
338 if not matches:
339 return None
340 encoding = _get_normal_name(matches[0])
341 try:
342 codec = lookup(encoding)
343 except LookupError:
344 # This behaviour mimics the Python interpreter
345 raise SyntaxError("unknown encoding: " + encoding)
346
347 if bom_found:
348 if encoding != 'utf-8':
349 # This behaviour mimics the Python interpreter
350 raise SyntaxError('encoding problem: utf-8')
351 encoding += '-sig'
352 return encoding
353
354 first = read_or_stop()
355 if first.startswith(BOM_UTF8):
356 bom_found = True
357 first = first[3:]
358 default = 'utf-8-sig'
359 if not first:
360 return default, []
361
362 encoding = find_cookie(first)
363 if encoding:
364 return encoding, [first]
365
366 second = read_or_stop()
367 if not second:
368 return default, [first]
369
370 encoding = find_cookie(second)
371 if encoding:
372 return encoding, [first, second]
373
374 return default, [first, second]
375
376
377 def open(filename):
378 """Open a file in read only mode using the encoding detected by
379 detect_encoding().
380 """
381 buffer = builtins.open(filename, 'rb')
382 encoding, lines = detect_encoding(buffer.readline)
383 buffer.seek(0)
384 text = TextIOWrapper(buffer, encoding, line_buffering=True)
385 text.mode = 'r'
386 return text
387
388
389 def tokenize(readline):
390 """
391 The tokenize() generator requires one argment, readline, which
392 must be a callable object which provides the same interface as the
393 readline() method of built-in file objects. Each call to the function
394 should return one line of input as bytes. Alternately, readline
395 can be a callable function terminating with StopIteration:
396 readline = open(myfile, 'rb').__next__ # Example of alternate readline
397
398 The generator produces 5-tuples with these members: the token type; the
399 token string; a 2-tuple (srow, scol) of ints specifying the row and
400 column where the token begins in the source; a 2-tuple (erow, ecol) of
401 ints specifying the row and column where the token ends in the source;
402 and the line on which the token was found. The line passed is the
403 logical line; continuation lines are included.
404
405 The first token sequence will always be an ENCODING token
406 which tells you which encoding was used to decode the bytes stream.
407 """
408 # This import is here to avoid problems when the itertools module is not
409 # built yet and tokenize is imported.
410 from itertools import chain, repeat
411 encoding, consumed = detect_encoding(readline)
412 rl_gen = iter(readline, b"")
413 empty = repeat(b"")
414 return _tokenize(chain(consumed, rl_gen, empty).__next__, encoding)
415
416
417 def _tokenize(readline, encoding):
418 lnum = parenlev = continued = 0
419 numchars = '0123456789'
420 contstr, needcont = '', 0
421 contline = None
422 indents = [0]
423
424 if encoding is not None:
425 if encoding == "utf-8-sig":
426 # BOM will already have been stripped.
427 encoding = "utf-8"
428 yield TokenInfo(ENCODING, encoding, (0, 0), (0, 0), '')
429 while True: # loop over lines in stream
430 try:
431 line = readline()
432 except StopIteration:
433 line = b''
434
435 if encoding is not None:
436 line = line.decode(encoding)
437 lnum += 1
438 pos, max = 0, len(line)
439
440 if contstr: # continued string
441 if not line:
442 raise TokenError("EOF in multi-line string", strstart)
443 endmatch = endprog.match(line)
444 if endmatch:
445 pos = end = endmatch.end(0)
446 yield TokenInfo(STRING, contstr + line[:end],
447 strstart, (lnum, end), contline + line)
448 contstr, needcont = '', 0
449 contline = None
450 elif needcont and line[-2:] != '\\\n' and line[-3:] != '\\\r\n':
451 yield TokenInfo(ERRORTOKEN, contstr + line,
452 strstart, (lnum, len(line)), contline)
453 contstr = ''
454 contline = None
455 continue
456 else:
457 contstr = contstr + line
458 contline = contline + line
459 continue
460
461 elif parenlev == 0 and not continued: # new statement
462 if not line: break
463 column = 0
464 while pos < max: # measure leading whitespace
465 if line[pos] == ' ':
466 column += 1
467 elif line[pos] == '\t':
468 column = (column//tabsize + 1)*tabsize
469 elif line[pos] == '\f':
470 column = 0
471 else:
472 break
473 pos += 1
474 if pos == max:
475 break
476
477 if line[pos] in '#\r\n': # skip comments or blank lines
478 if line[pos] == '#':
479 comment_token = line[pos:].rstrip('\r\n')
480 nl_pos = pos + len(comment_token)
481 yield TokenInfo(COMMENT, comment_token,
482 (lnum, pos), (lnum, pos + len(comment_token)), line)
483 yield TokenInfo(NEWLINE, line[nl_pos:],
484 (lnum, nl_pos), (lnum, len(line)), line)
485 else:
486 yield TokenInfo(NEWLINE, line[pos:],
487 (lnum, pos), (lnum, len(line)), line)
488 continue
489
490 if column > indents[-1]: # count indents or dedents
491 indents.append(column)
492 yield TokenInfo(INDENT, line[:pos], (lnum, 0), (lnum, pos), line)
493 while column < indents[-1]:
494 if column not in indents:
495 raise IndentationError(
496 "unindent does not match any outer indentation level",
497 ("<tokenize>", lnum, pos, line))
498 indents = indents[:-1]
499 yield TokenInfo(DEDENT, '', (lnum, pos), (lnum, pos), line)
500
501 else: # continued statement
502 if not line:
503 raise TokenError("EOF in multi-line statement", (lnum, 0))
504 continued = 0
505
506 while pos < max:
507 pseudomatch = pseudoprog.match(line, pos)
508 if pseudomatch: # scan for tokens
509 start, end = pseudomatch.span(1)
510 spos, epos, pos = (lnum, start), (lnum, end), end
511 token, initial = line[start:end], line[start]
512
513 if (initial in numchars or # ordinary number
514 (initial == '.' and token != '.' and token != '...')):
515 yield TokenInfo(NUMBER, token, spos, epos, line)
516 elif initial in '\r\n':
517 yield TokenInfo(NL if parenlev > 0 else NEWLINE,
518 token, spos, epos, line)
519 elif initial == '#':
520 assert not token.endswith("\n")
521 yield TokenInfo(COMMENT, token, spos, epos, line)
522 elif token in triple_quoted:
523 endprog = endprogs[token]
524 endmatch = endprog.match(line, pos)
525 if endmatch: # all on one line
526 pos = endmatch.end(0)
527 token = line[start:pos]
528 yield TokenInfo(STRING, token, spos, (lnum, pos), line)
529 else:
530 strstart = (lnum, start) # multiple lines
531 contstr = line[start:]
532 contline = line
533 break
534 elif initial in single_quoted or \
535 token[:2] in single_quoted or \
536 token[:3] in single_quoted:
537 if token[-1] == '\n': # continued string
538 strstart = (lnum, start)
539 endprog = (endprogs[initial] or endprogs[token[1]] or
540 endprogs[token[2]])
541 contstr, needcont = line[start:], 1
542 contline = line
543 break
544 else: # ordinary string
545 yield TokenInfo(STRING, token, spos, epos, line)
546 elif initial.isidentifier(): # ordinary name
547 yield TokenInfo(NAME, token, spos, epos, line)
548 elif initial == '\\': # continued stmt
549 continued = 1
550 else:
551 if initial in '([{':
552 parenlev += 1
553 elif initial in ')]}':
554 parenlev -= 1
555 yield TokenInfo(OP, token, spos, epos, line)
556 else:
557 yield TokenInfo(ERRORTOKEN, line[pos],
558 (lnum, pos), (lnum, pos+1), line)
559 pos += 1
560
561 for indent in indents[1:]: # pop remaining indent levels
562 yield TokenInfo(DEDENT, '', (lnum, 0), (lnum, 0), '')
563 yield TokenInfo(ENDMARKER, '', (lnum, 0), (lnum, 0), '')
564
565
566 # An undocumented, backwards compatible, API for all the places in the standard
567 # library that expect to be able to use tokenize with strings
568 def generate_tokens(readline):
569 return _tokenize(readline, None)
570
571 if __name__ == "__main__":
572 # Quick sanity check
573 s = b'''def parseline(self, line):
574 """Parse the line into a command name and a string containing
575 the arguments. Returns a tuple containing (command, args, line).
576 'command' and 'args' may be None if the line couldn't be parsed.
577 """
578 line = line.strip()
579 if not line:
580 return None, None, line
581 elif line[0] == '?':
582 line = 'help ' + line[1:]
583 elif line[0] == '!':
584 if hasattr(self, 'do_shell'):
585 line = 'shell ' + line[1:]
586 else:
587 return None, None, line
588 i, n = 0, len(line)
589 while i < n and line[i] in self.identchars: i = i+1
590 cmd, arg = line[:i], line[i:].strip()
591 return cmd, arg, line
592 '''
593 for tok in tokenize(iter(s.splitlines()).__next__):
594 print(tok)
595
[end of IPython/utils/tokenize2.py]
</code>
I need you to solve this issue by generating a single patch file that I can apply directly to this repository using git apply. Please respond with a single patch file in the following format.
<patch>
--- a/file.py
+++ b/file.py
@@ -1,27 +1,35 @@
def euclidean(a, b):
- while b:
- a, b = b, a % b
- return a
+ if b == 0:
+ return a
+ return euclidean(b, a % b)
def bresenham(x0, y0, x1, y1):
points = []
dx = abs(x1 - x0)
dy = abs(y1 - y0)
- sx = 1 if x0 < x1 else -1
- sy = 1 if y0 < y1 else -1
- err = dx - dy
+ x, y = x0, y0
+ sx = -1 if x0 > x1 else 1
+ sy = -1 if y0 > y1 else 1
- while True:
- points.append((x0, y0))
- if x0 == x1 and y0 == y1:
- break
- e2 = 2 * err
- if e2 > -dy:
+ if dx > dy:
+ err = dx / 2.0
+ while x != x1:
+ points.append((x, y))
err -= dy
- x0 += sx
- if e2 < dx:
- err += dx
- y0 += sy
+ if err < 0:
+ y += sy
+ err += dx
+ x += sx
+ else:
+ err = dy / 2.0
+ while y != y1:
+ points.append((x, y))
+ err -= dx
+ if err < 0:
+ x += sx
+ err += dy
+ y += sy
+ points.append((x, y))
return points
</patch>
| ipython/ipython | 78ec96d7ca0147f0655d5260f2ab0c61d94e4279 | remove usage of backports.shutil_get_terminal_size
This is for pre-3.3 Python.
Pretty easy it should only require deleting lines.
Maybe a few need to be dedented.
| 2017-01-28T05:22:06Z | <patch>
diff --git a/IPython/utils/terminal.py b/IPython/utils/terminal.py
--- a/IPython/utils/terminal.py
+++ b/IPython/utils/terminal.py
@@ -15,11 +15,7 @@
import os
import sys
import warnings
-try:
- from shutil import get_terminal_size as _get_terminal_size
-except ImportError:
- # use backport on Python 2
- from backports.shutil_get_terminal_size import get_terminal_size as _get_terminal_size
+from shutil import get_terminal_size as _get_terminal_size
from . import py3compat
</patch> | [] | [] | ||||
Qiskit__qiskit-1295 | You will be provided with a partial code base and an issue statement explaining a problem to resolve.
<issue>
credentials failed for qiskit ver 0.6.1
<!-- ⚠️ If you do not respect this template, your issue will be closed -->
<!-- ⚠️ Make sure to browse the opened and closed issues -->
### Informations
- **Qiskit Terra version**: 0.6.1
- **Python version**: 3.7.0
- **Operating system**:MAC OSX 10.13.6
### What is the current behavior?
After I acquired fresh token from https://quantumexperience.ng.bluemix.net/qx/account/advanced
IBMQ.load_accounts() fails.
### Steps to reproduce the problem
```
from qiskit import IBMQ
myToken='b6abe11442c9a...'
IBMQ.save_account(myToken)
IBMQ.load_accounts()
```
Results with
```
Traceback (most recent call last):
File "/anaconda3/lib/python3.7/site-packages/qiskit/backends/ibmq/ibmqsingleprovider.py", line 71, in _authenticate
credentials.verify)
File "/anaconda3/lib/python3.7/site-packages/IBMQuantumExperience/IBMQuantumExperience.py", line 478, in __init__
self.req = _Request(token, config=config, verify=verify)
File "/anaconda3/lib/python3.7/site-packages/IBMQuantumExperience/IBMQuantumExperience.py", line 253, in __init__
ntlm_credentials=self.ntlm_credentials)
File "/anaconda3/lib/python3.7/site-packages/IBMQuantumExperience/IBMQuantumExperience.py", line 95, in __init__
self.obtain_token(config=self.config)
File "/anaconda3/lib/python3.7/site-packages/IBMQuantumExperience/IBMQuantumExperience.py", line 159, in obtain_token
raise CredentialsError('error during login: %s' % error_message)
IBMQuantumExperience.IBMQuantumExperience.CredentialsError: error during login: Wrong user or password, check your credentials.
```
### What is the expected behavior?
Would be better if IBMQ.load_accounts() accepted me. All worked well w/ ver 0.5.
### Suggested solutions
</issue>
<code>
[start of README.md]
1 # Qiskit Terra
2
3 [](https://pypi.python.org/pypi/qiskit)
4 [](https://travis-ci.org/Qiskit/qiskit-terra)
5 [](https://travis-ci.org/Qiskit/qiskit-terra)
6
7 **Qiskit** is a software development kit for
8 developing quantum computing applications and working with NISQ (Noisy-Intermediate Scale Quantum) computers.
9
10 Qiskit is made up elements that each work together to enable quantum computing. This element is **Terra**
11 and is the foundation on which the rest of Qiskit is built (see this [post](https://medium.com/qiskit/qiskit-and-its-fundamental-elements-bcd7ead80492) for an overview).
12
13
14 ## Installation
15
16
17 We encourage installing Qiskit via the PIP tool (a python package manager):
18
19 ```bash
20 pip install qiskit
21 ```
22
23 PIP will handle all dependencies automatically for us and you will always install the latest (and well-tested) version.
24
25 At least [Python 3.5 or later](https://www.python.org/downloads/) is needed for using Qiskit. In
26 addition, [Jupyter Notebook](https://jupyter.readthedocs.io/en/latest/install.html) is recommended
27 for interacting with the tutorials.
28 For this reason we recommend installing the [Anaconda 3](https://www.continuum.io/downloads)
29 python distribution, as it comes with all of these dependencies pre-installed.
30
31 See [installing](doc/install.rst) Qiskit for detailed instructions, how to build from source and using environments.
32
33
34 ## Creating your first quantum program
35
36 Now that Qiskit is installed, it's time to begin working with Terra.
37
38 We are ready to try out a quantum circuit example, which is simulated locally using
39 the Qiskt Aer element. This is a simple example that makes an entangled state.
40
41 ```
42 $ python
43 ```
44
45 ```python
46 >>> from qiskit import *
47 >>> q = QuantumRegister(2)
48 >>> c = ClassicalRegister(2)
49 >>> qc = QuantumCircuit(q, c)
50 >>> qc.h(q[0])
51 >>> qc.cx(q[0], q[1])
52 >>> qc.measure(q, c)
53 >>> backend_sim = Aer.get_backend('qasm_simulator')
54 >>> result = execute(qc, backend_sim).result()
55 >>> print(result.get_counts(qc))
56 ```
57
58 In this case, the output will be:
59
60 ```python
61 {'counts': {'00': 513, '11': 511}}
62 ```
63
64 A script is available [here](examples/python/hello_quantum.py), where we also show how to
65 run the same program on a real quantum computer via IBMQ.
66
67 ### Executing your code on a real quantum chip
68
69 You can also use Qiskit to execute your code on a
70 **real quantum chip**.
71 In order to do so, you need to configure Qiskit for using the credentials in
72 your IBM Q account:
73
74 #### Configure your IBMQ credentials
75
76 1. Create an _[IBM Q](https://quantumexperience.ng.bluemix.net) > Account_ if you haven't already done so.
77
78 2. Get an API token from the IBM Q website under _My Account > Advanced > API Token_.
79
80 3. Take your token from step 2, here called `MY_API_TOKEN`, and run:
81
82 ```python
83 >>> from qiskit import IBMQ
84 >>> IBMQ.save_account('MY_API_TOKEN')
85 ```
86
87 4. If you have access to the IBM Q Network features, you also need to pass the
88 url listed on your IBM Q account page to `save_account`.
89
90 After calling `IBMQ.save_account()`, your credentials will be stored on disk.
91 Once they are stored, at any point in the future you can load and use them
92 in your program simply via:
93
94 ```python
95 >>> from qiskit import IBMQ
96 >>> IBMQ.load_accounts()
97 ```
98
99 For those who do not want to save there credentials to disk please use
100
101 ```python
102 >>> from qiskit import IBMQ
103 >>> IBMQ.enable_account('MY_API_TOKEN')
104 ```
105
106 and the token will only be active for the session. For examples using Terra with real
107 devices we have provided a set of examples in **examples/python** and we suggest starting with [using_qiskit_terra_level_0.py](examples/python/using_qiskit_terra_level_0.py) and working up in
108 the levels.
109
110 ## Contribution guidelines
111
112 If you'd like to contribute to Qiskit, please take a look at our
113 [contribution guidelines](.github/CONTRIBUTING.rst). This project adheres to Qiskit's [code of conduct](.github/CODE_OF_CONDUCT.rst). By participating, you are expect to uphold to this code.
114
115 We use [GitHub issues](https://github.com/Qiskit/qiskit-terra/issues) for tracking requests and bugs.
116 Please use our [slack](https://qiskit.slack.com) for discussion. To join our Slack community use the [link](https://join.slack.com/t/qiskit/shared_invite/enQtNDc2NjUzMjE4Mzc0LTMwZmE0YTM4ZThiNGJmODkzN2Y2NTNlMDIwYWNjYzA2ZmM1YTRlZGQ3OGM0NjcwMjZkZGE0MTA4MGQ1ZTVmYzk). To ask questions to [Stack Overflow](https://stackoverflow.com/questions/tagged/qiskit).
117
118
119
120 ### Next Steps
121
122 Now you're set up and ready to check out some of the other examples from our
123 [Qiskit Tutorial](https://github.com/Qiskit/qiskit-tutorial) repository.
124
125
126 ## Authors
127
128 Qiskit Terra is the work of [many people](https://github.com/Qiskit/qiskit-terra/graphs/contributors) who contribute
129 to the project at different levels.
130
131 ## License
132
133 [Apache License 2.0](LICENSE.txt)
[end of README.md]
[start of qiskit/backends/ibmq/api/ibmqconnector.py]
1 # -*- coding: utf-8 -*-
2
3 # Copyright 2018, IBM.
4 #
5 # This source code is licensed under the Apache License, Version 2.0 found in
6 # the LICENSE.txt file in the root directory of this source tree.
7
8 """IBM Q API connector."""
9
10 import json
11 import logging
12 import re
13 import time
14
15 import requests
16 from requests_ntlm import HttpNtlmAuth
17
18 logger = logging.getLogger(__name__)
19 CLIENT_APPLICATION = 'qiskit-api-py'
20
21
22 def get_job_url(config, hub, group, project):
23 """
24 Util method to get job url
25 """
26 if (config is not None) and ('hub' in config) and (hub is None):
27 hub = config["hub"]
28 if (config is not None) and ('group' in config) and (group is None):
29 group = config["group"]
30 if (config is not None) and ('project' in config) and (project is None):
31 project = config["project"]
32 if (hub is not None) and (group is not None) and (project is not None):
33 return '/Network/{}/Groups/{}/Projects/{}/jobs'.format(hub, group, project)
34 return '/Jobs'
35
36
37 def get_backend_stats_url(config, hub, backend_type):
38 """
39 Util method to get backend stats url
40 """
41 if (config is not None) and ('hub' in config) and (hub is None):
42 hub = config["hub"]
43 if hub is not None:
44 return '/Network/{}/devices/{}'.format(hub, backend_type)
45 return '/Backends/{}'.format(backend_type)
46
47
48 def get_backend_url(config, hub, group, project):
49 """
50 Util method to get backend url
51 """
52 if (config is not None) and ('hub' in config) and (hub is None):
53 hub = config["hub"]
54 if (config is not None) and ('group' in config) and (group is None):
55 group = config["group"]
56 if (config is not None) and ('project' in config) and (project is None):
57 project = config["project"]
58 if (hub is not None) and (group is not None) and (project is not None):
59 return '/Network/{}/Groups/{}/Projects/{}/devices'.format(hub, group, project)
60 return '/Backends'
61
62
63 class _Credentials(object):
64 """
65 The Credential class to manage the tokens
66 """
67 config_base = {'url': 'https://quantumexperience.ng.bluemix.net/api'}
68
69 def __init__(self, token, config=None, verify=True, proxy_urls=None,
70 ntlm_credentials=None):
71 self.token_unique = token
72 self.verify = verify
73 self.config = config
74 self.proxy_urls = proxy_urls
75 self.ntlm_credentials = ntlm_credentials
76
77 # Set the extra arguments to requests (proxy and auth).
78 self.extra_args = {}
79 if self.proxy_urls:
80 self.extra_args['proxies'] = self.proxy_urls
81 if self.ntlm_credentials:
82 self.extra_args['auth'] = HttpNtlmAuth(
83 self.ntlm_credentials['username'],
84 self.ntlm_credentials['password'])
85
86 if not verify:
87 # pylint: disable=import-error
88 import requests.packages.urllib3 as urllib3
89 urllib3.disable_warnings()
90 print('-- Ignoring SSL errors. This is not recommended --')
91 if self.config and ("url" not in self.config):
92 self.config["url"] = self.config_base["url"]
93 elif not self.config:
94 self.config = self.config_base
95
96 self.data_credentials = {}
97 if token:
98 self.obtain_token(config=self.config)
99 else:
100 access_token = self.config.get('access_token', None)
101 if access_token:
102 user_id = self.config.get('user_id', None)
103 if access_token:
104 self.set_token(access_token)
105 if user_id:
106 self.set_user_id(user_id)
107 else:
108 self.obtain_token(config=self.config)
109
110 def obtain_token(self, config=None):
111 """Obtain the token to access to QX Platform.
112
113 Raises:
114 CredentialsError: when token is invalid or the user has not
115 accepted the license.
116 ApiError: when the response from the server couldn't be parsed.
117 """
118 client_application = CLIENT_APPLICATION
119 if self.config and ("client_application" in self.config):
120 client_application += ':' + self.config["client_application"]
121 headers = {'x-qx-client-application': client_application}
122
123 if self.token_unique:
124 try:
125 response = requests.post(str(self.config.get('url') +
126 "/users/loginWithToken"),
127 data={'apiToken': self.token_unique},
128 verify=self.verify,
129 headers=headers,
130 **self.extra_args)
131 except requests.RequestException as ex:
132 raise ApiError('error during login: %s' % str(ex))
133 elif config and ("email" in config) and ("password" in config):
134 email = config.get('email', None)
135 password = config.get('password', None)
136 credentials = {
137 'email': email,
138 'password': password
139 }
140 try:
141 response = requests.post(str(self.config.get('url') +
142 "/users/login"),
143 data=credentials,
144 verify=self.verify,
145 headers=headers,
146 **self.extra_args)
147 except requests.RequestException as ex:
148 raise ApiError('error during login: %s' % str(ex))
149 else:
150 raise CredentialsError('invalid token')
151
152 if response.status_code == 401:
153 error_message = None
154 try:
155 # For 401: ACCEPT_LICENSE_REQUIRED, a detailed message is
156 # present in the response and passed to the exception.
157 error_message = response.json()['error']['message']
158 except Exception: # pylint: disable=broad-except
159 pass
160
161 if error_message:
162 raise CredentialsError('error during login: %s' % error_message)
163 else:
164 raise CredentialsError('invalid token')
165 try:
166 response.raise_for_status()
167 self.data_credentials = response.json()
168 except (requests.HTTPError, ValueError) as ex:
169 raise ApiError('error during login: %s' % str(ex))
170
171 if self.get_token() is None:
172 raise CredentialsError('invalid token')
173
174 def get_token(self):
175 """
176 Get Authenticated Token to connect with QX Platform
177 """
178 return self.data_credentials.get('id', None)
179
180 def get_user_id(self):
181 """
182 Get User Id in QX Platform
183 """
184 return self.data_credentials.get('userId', None)
185
186 def get_config(self):
187 """
188 Get Configuration setted to connect with QX Platform
189 """
190 return self.config
191
192 def set_token(self, access_token):
193 """
194 Set Access Token to connect with QX Platform API
195 """
196 self.data_credentials['id'] = access_token
197
198 def set_user_id(self, user_id):
199 """
200 Set Access Token to connect with QX Platform API
201 """
202 self.data_credentials['userId'] = user_id
203
204
205 class _Request(object):
206 """
207 The Request class to manage the methods
208 """
209 def __init__(self, token, config=None, verify=True, retries=5,
210 timeout_interval=1.0):
211 self.verify = verify
212 self.client_application = CLIENT_APPLICATION
213 self.config = config
214 self.errors_not_retry = [401, 403, 413]
215
216 # Set the proxy information, if present, from the configuration,
217 # with the following format:
218 # config = {
219 # 'proxies': {
220 # # If using 'urls', assume basic auth or no auth.
221 # 'urls': {
222 # 'http': 'http://user:password@1.2.3.4:5678',
223 # 'https': 'http://user:password@1.2.3.4:5678',
224 # }
225 # # If using 'ntlm', assume NTLM authentication.
226 # 'username_ntlm': 'domain\\username',
227 # 'password_ntlm': 'password'
228 # }
229 # }
230
231 # Set the basic proxy settings, if present.
232 self.proxy_urls = None
233 self.ntlm_credentials = None
234 if config and 'proxies' in config:
235 if 'urls' in config['proxies']:
236 self.proxy_urls = self.config['proxies']['urls']
237 if 'username_ntlm' and 'password_ntlm' in config['proxies']:
238 self.ntlm_credentials = {
239 'username': self.config['proxies']['username_ntlm'],
240 'password': self.config['proxies']['password_ntlm']
241 }
242
243 # Set the extra arguments to requests (proxy and auth).
244 self.extra_args = {}
245 if self.proxy_urls:
246 self.extra_args['proxies'] = self.proxy_urls
247 if self.ntlm_credentials:
248 self.extra_args['auth'] = HttpNtlmAuth(
249 self.ntlm_credentials['username'],
250 self.ntlm_credentials['password'])
251
252 if self.config and ("client_application" in self.config):
253 self.client_application += ':' + self.config["client_application"]
254 self.credential = _Credentials(token, self.config, verify,
255 proxy_urls=self.proxy_urls,
256 ntlm_credentials=self.ntlm_credentials)
257
258 if not isinstance(retries, int):
259 raise TypeError('post retries must be positive integer')
260 self.retries = retries
261 self.timeout_interval = timeout_interval
262 self.result = None
263 self._max_qubit_error_re = re.compile(
264 r".*registers exceed the number of qubits, "
265 r"it can\'t be greater than (\d+).*")
266
267 def check_token(self, respond):
268 """
269 Check is the user's token is valid
270 """
271 if respond.status_code == 401:
272 self.credential.obtain_token(config=self.config)
273 return False
274 return True
275
276 def post(self, path, params='', data=None):
277 """
278 POST Method Wrapper of the REST API
279 """
280 self.result = None
281 data = data or {}
282 headers = {'Content-Type': 'application/json',
283 'x-qx-client-application': self.client_application}
284 url = str(self.credential.config['url'] + path + '?access_token=' +
285 self.credential.get_token() + params)
286 retries = self.retries
287 while retries > 0:
288 respond = requests.post(url, data=data, headers=headers,
289 verify=self.verify, **self.extra_args)
290 if not self.check_token(respond):
291 respond = requests.post(url, data=data, headers=headers,
292 verify=self.verify,
293 **self.extra_args)
294
295 if self._response_good(respond):
296 if self.result:
297 return self.result
298 elif retries < 2:
299 return respond.json()
300 else:
301 retries -= 1
302 else:
303 retries -= 1
304 time.sleep(self.timeout_interval)
305
306 # timed out
307 raise ApiError(usr_msg='Failed to get proper ' +
308 'response from backend.')
309
310 def put(self, path, params='', data=None):
311 """
312 PUT Method Wrapper of the REST API
313 """
314 self.result = None
315 data = data or {}
316 headers = {'Content-Type': 'application/json',
317 'x-qx-client-application': self.client_application}
318 url = str(self.credential.config['url'] + path + '?access_token=' +
319 self.credential.get_token() + params)
320 retries = self.retries
321 while retries > 0:
322 respond = requests.put(url, data=data, headers=headers,
323 verify=self.verify, **self.extra_args)
324 if not self.check_token(respond):
325 respond = requests.put(url, data=data, headers=headers,
326 verify=self.verify,
327 **self.extra_args)
328 if self._response_good(respond):
329 if self.result:
330 return self.result
331 elif retries < 2:
332 return respond.json()
333 else:
334 retries -= 1
335 else:
336 retries -= 1
337 time.sleep(self.timeout_interval)
338 # timed out
339 raise ApiError(usr_msg='Failed to get proper ' +
340 'response from backend.')
341
342 def get(self, path, params='', with_token=True):
343 """
344 GET Method Wrapper of the REST API
345 """
346 self.result = None
347 access_token = ''
348 if with_token:
349 access_token = self.credential.get_token() or ''
350 if access_token:
351 access_token = '?access_token=' + str(access_token)
352 url = self.credential.config['url'] + path + access_token + params
353 retries = self.retries
354 headers = {'x-qx-client-application': self.client_application}
355 while retries > 0: # Repeat until no error
356 respond = requests.get(url, verify=self.verify, headers=headers,
357 **self.extra_args)
358 if not self.check_token(respond):
359 respond = requests.get(url, verify=self.verify,
360 headers=headers, **self.extra_args)
361 if self._response_good(respond):
362 if self.result:
363 return self.result
364 elif retries < 2:
365 return respond.json()
366 else:
367 retries -= 1
368 else:
369 retries -= 1
370 time.sleep(self.timeout_interval)
371 # timed out
372 raise ApiError(usr_msg='Failed to get proper ' +
373 'response from backend.')
374
375 def _response_good(self, respond):
376 """check response
377
378 Args:
379 respond (requests.Response): HTTP response.
380
381 Returns:
382 bool: True if the response is good, else False.
383
384 Raises:
385 ApiError: response isn't formatted properly.
386 """
387 if respond.status_code != requests.codes.ok:
388 logger.warning('Got a %s code response to %s: %s',
389 respond.status_code,
390 respond.url,
391 respond.text)
392 if respond.status_code in self.errors_not_retry:
393 raise ApiError(usr_msg='Got a {} code response to {}: {}'.format(
394 respond.status_code,
395 respond.url,
396 respond.text))
397 else:
398 return self._parse_response(respond)
399 try:
400 if str(respond.headers['content-type']).startswith("text/html;"):
401 self.result = respond.text
402 return True
403 else:
404 self.result = respond.json()
405 except (json.JSONDecodeError, ValueError):
406 usr_msg = 'device server returned unexpected http response'
407 dev_msg = usr_msg + ': ' + respond.text
408 raise ApiError(usr_msg=usr_msg, dev_msg=dev_msg)
409 if not isinstance(self.result, (list, dict)):
410 msg = ('JSON not a list or dict: url: {0},'
411 'status: {1}, reason: {2}, text: {3}')
412 raise ApiError(
413 usr_msg=msg.format(respond.url,
414 respond.status_code,
415 respond.reason, respond.text))
416 if ('error' not in self.result or
417 ('status' not in self.result['error'] or
418 self.result['error']['status'] != 400)):
419 return True
420
421 logger.warning("Got a 400 code JSON response to %s", respond.url)
422 return False
423
424 def _parse_response(self, respond):
425 """parse text of response for HTTP errors
426
427 This parses the text of the response to decide whether to
428 retry request or raise exception. At the moment this only
429 detects an exception condition.
430
431 Args:
432 respond (Response): requests.Response object
433
434 Returns:
435 bool: False if the request should be retried, True
436 if not.
437
438 Raises:
439 RegisterSizeError: if invalid device register size.
440 """
441 # convert error messages into exceptions
442 mobj = self._max_qubit_error_re.match(respond.text)
443 if mobj:
444 raise RegisterSizeError(
445 'device register size must be <= {}'.format(mobj.group(1)))
446 return True
447
448
449 class IBMQConnector(object):
450 """
451 The Connector Class to do request to QX Platform
452 """
453 __names_backend_ibmqxv2 = ['ibmqx5qv2', 'ibmqx2', 'qx5qv2', 'qx5q', 'real']
454 __names_backend_ibmqxv3 = ['ibmqx3']
455 __names_backend_simulator = ['simulator', 'sim_trivial_2',
456 'ibmqx_qasm_simulator', 'ibmq_qasm_simulator']
457
458 def __init__(self, token=None, config=None, verify=True):
459 """ If verify is set to false, ignore SSL certificate errors """
460 self.config = config
461
462 if self.config and ('url' in self.config):
463 url_parsed = self.config['url'].split('/api')
464 if len(url_parsed) == 2:
465 hub = group = project = None
466 project_parse = url_parsed[1].split('/Projects/')
467 if len(project_parse) == 2:
468 project = project_parse[1]
469 group_parse = project_parse[0].split('/Groups/')
470 if len(group_parse) == 2:
471 group = group_parse[1]
472 hub_parse = group_parse[0].split('/Hubs/')
473 if len(hub_parse) == 2:
474 hub = hub_parse[1]
475 if hub and group and project:
476 self.config['project'] = project
477 self.config['group'] = group
478 self.config['hub'] = hub
479 self.config['url'] = url_parsed[0] + '/api'
480
481 self.req = _Request(token, config=config, verify=verify)
482
483 def _check_backend(self, backend, endpoint):
484 """
485 Check if the name of a backend is valid to run in QX Platform
486 """
487 # First check against hacks for old backend names
488 original_backend = backend
489 backend = backend.lower()
490 if endpoint == 'experiment':
491 if backend in self.__names_backend_ibmqxv2:
492 return 'real'
493 elif backend in self.__names_backend_ibmqxv3:
494 return 'ibmqx3'
495 elif backend in self.__names_backend_simulator:
496 return 'sim_trivial_2'
497
498 # Check for new-style backends
499 backends = self.available_backends()
500 for backend_ in backends:
501 if backend_['name'] == original_backend:
502 return original_backend
503 # backend unrecognized
504 return None
505
506 def check_credentials(self):
507 """
508 Check if the user has permission in QX platform
509 """
510 return bool(self.req.credential.get_token())
511
512 def run_job(self, job, backend='simulator', shots=1,
513 max_credits=None, seed=None, hub=None, group=None,
514 project=None, hpc=None, access_token=None, user_id=None):
515 """
516 Execute a job
517 """
518 if access_token:
519 self.req.credential.set_token(access_token)
520 if user_id:
521 self.req.credential.set_user_id(user_id)
522 if not self.check_credentials():
523 return {"error": "Not credentials valid"}
524
525 backend_type = self._check_backend(backend, 'job')
526
527 if not backend_type:
528 raise BadBackendError(backend)
529
530 if isinstance(job, (list, tuple)):
531 qasms = job
532 for qasm in qasms:
533 qasm['qasm'] = qasm['qasm'].replace('IBMQASM 2.0;', '')
534 qasm['qasm'] = qasm['qasm'].replace('OPENQASM 2.0;', '')
535
536 data = {'qasms': qasms,
537 'shots': shots,
538 'backend': {}}
539
540 if max_credits:
541 data['maxCredits'] = max_credits
542
543 if seed and len(str(seed)) < 11 and str(seed).isdigit():
544 data['seed'] = seed
545 elif seed:
546 return {"error": "Not seed allowed. Max 10 digits."}
547
548 data['backend']['name'] = backend_type
549 elif isinstance(job, dict):
550 q_obj = job
551 data = {'qObject': q_obj,
552 'backend': {}}
553
554 data['backend']['name'] = backend_type
555 else:
556 return {"error": "Not a valid data to send"}
557
558 if hpc:
559 data['hpc'] = hpc
560
561 url = get_job_url(self.config, hub, group, project)
562
563 job = self.req.post(url, data=json.dumps(data))
564
565 return job
566
567 def get_job(self, id_job, hub=None, group=None, project=None,
568 access_token=None, user_id=None):
569 """
570 Get the information about a job, by its id
571 """
572 if access_token:
573 self.req.credential.set_token(access_token)
574 if user_id:
575 self.req.credential.set_user_id(user_id)
576 if not self.check_credentials():
577 respond = {}
578 respond["status"] = 'Error'
579 respond["error"] = "Not credentials valid"
580 return respond
581 if not id_job:
582 respond = {}
583 respond["status"] = 'Error'
584 respond["error"] = "Job ID not specified"
585 return respond
586
587 url = get_job_url(self.config, hub, group, project)
588
589 url += '/' + id_job
590
591 job = self.req.get(url)
592
593 if 'qasms' in job:
594 for qasm in job['qasms']:
595 if ('result' in qasm) and ('data' in qasm['result']):
596 qasm['data'] = qasm['result']['data']
597 del qasm['result']['data']
598 for key in qasm['result']:
599 qasm['data'][key] = qasm['result'][key]
600 del qasm['result']
601
602 return job
603
604 def get_jobs(self, limit=10, skip=0, backend=None, only_completed=False,
605 filter=None, hub=None, group=None, project=None,
606 access_token=None, user_id=None):
607 """
608 Get the information about the user jobs
609 """
610 # pylint: disable=redefined-builtin
611
612 if access_token:
613 self.req.credential.set_token(access_token)
614 if user_id:
615 self.req.credential.set_user_id(user_id)
616 if not self.check_credentials():
617 return {"error": "Not credentials valid"}
618
619 url = get_job_url(self.config, hub, group, project)
620 url_filter = '&filter='
621 query = {
622 "order": "creationDate DESC",
623 "limit": limit,
624 "skip": skip,
625 "where": {}
626 }
627 if filter is not None:
628 query['where'] = filter
629 else:
630 if backend is not None:
631 query['where']['backend.name'] = backend
632 if only_completed:
633 query['where']['status'] = 'COMPLETED'
634
635 url_filter = url_filter + json.dumps(query)
636 jobs = self.req.get(url, url_filter)
637 return jobs
638
639 def get_status_job(self, id_job, hub=None, group=None, project=None,
640 access_token=None, user_id=None):
641 """
642 Get the status about a job, by its id
643 """
644 if access_token:
645 self.req.credential.set_token(access_token)
646 if user_id:
647 self.req.credential.set_user_id(user_id)
648 if not self.check_credentials():
649 respond = {}
650 respond["status"] = 'Error'
651 respond["error"] = "Not credentials valid"
652 return respond
653 if not id_job:
654 respond = {}
655 respond["status"] = 'Error'
656 respond["error"] = "Job ID not specified"
657 return respond
658
659 url = get_job_url(self.config, hub, group, project)
660
661 url += '/' + id_job + '/status'
662
663 status = self.req.get(url)
664
665 return status
666
667 def get_status_jobs(self, limit=10, skip=0, backend=None, filter=None,
668 hub=None, group=None, project=None, access_token=None,
669 user_id=None):
670 """
671 Get the information about the user jobs
672 """
673 # pylint: disable=redefined-builtin
674
675 if access_token:
676 self.req.credential.set_token(access_token)
677 if user_id:
678 self.req.credential.set_user_id(user_id)
679 if not self.check_credentials():
680 return {"error": "Not credentials valid"}
681
682 url = get_job_url(self.config, hub, group, project)
683 url_filter = '&filter='
684 query = {
685 "order": "creationDate DESC",
686 "limit": limit,
687 "skip": skip,
688 "where": {}
689 }
690 if filter is not None:
691 query['where'] = filter
692 else:
693 if backend is not None:
694 query['where']['backend.name'] = backend
695
696 url += '/status'
697
698 url_filter = url_filter + json.dumps(query)
699
700 jobs = self.req.get(url, url_filter)
701
702 return jobs
703
704 def cancel_job(self, id_job, hub=None, group=None, project=None,
705 access_token=None, user_id=None):
706 """
707 Cancel the information about a job, by its id
708 """
709 if access_token:
710 self.req.credential.set_token(access_token)
711 if user_id:
712 self.req.credential.set_user_id(user_id)
713 if not self.check_credentials():
714 respond = {}
715 respond["status"] = 'Error'
716 respond["error"] = "Not credentials valid"
717 return respond
718 if not id_job:
719 respond = {}
720 respond["status"] = 'Error'
721 respond["error"] = "Job ID not specified"
722 return respond
723
724 url = get_job_url(self.config, hub, group, project)
725
726 url += '/{}/cancel'.format(id_job)
727
728 res = self.req.post(url)
729
730 return res
731
732 def backend_status(self, backend='ibmqx4', access_token=None, user_id=None):
733 """
734 Get the status of a chip
735 """
736 if access_token:
737 self.req.credential.set_token(access_token)
738 if user_id:
739 self.req.credential.set_user_id(user_id)
740 backend_type = self._check_backend(backend, 'status')
741 if not backend_type:
742 raise BadBackendError(backend)
743
744 status = self.req.get('/Backends/' + backend_type + '/queue/status',
745 with_token=False)
746
747 ret = {}
748 if 'state' in status:
749 ret['available'] = bool(status['state'])
750 if 'busy' in status:
751 ret['busy'] = bool(status['busy'])
752 if 'lengthQueue' in status:
753 ret['pending_jobs'] = status['lengthQueue']
754
755 ret['backend'] = backend_type
756
757 return ret
758
759 def backend_calibration(self, backend='ibmqx4', hub=None, access_token=None, user_id=None):
760 """
761 Get the calibration of a real chip
762 """
763 if access_token:
764 self.req.credential.set_token(access_token)
765 if user_id:
766 self.req.credential.set_user_id(user_id)
767 if not self.check_credentials():
768 raise CredentialsError('credentials invalid')
769
770 backend_type = self._check_backend(backend, 'calibration')
771
772 if not backend_type:
773 raise BadBackendError(backend)
774
775 if backend_type in self.__names_backend_simulator:
776 ret = {}
777 return ret
778
779 url = get_backend_stats_url(self.config, hub, backend_type)
780
781 ret = self.req.get(url + '/calibration')
782 if not bool(ret):
783 ret = {}
784 else:
785 ret["backend"] = backend_type
786 return ret
787
788 def backend_parameters(self, backend='ibmqx4', hub=None, access_token=None, user_id=None):
789 """
790 Get the parameters of calibration of a real chip
791 """
792 if access_token:
793 self.req.credential.set_token(access_token)
794 if user_id:
795 self.req.credential.set_user_id(user_id)
796 if not self.check_credentials():
797 raise CredentialsError('credentials invalid')
798
799 backend_type = self._check_backend(backend, 'calibration')
800
801 if not backend_type:
802 raise BadBackendError(backend)
803
804 if backend_type in self.__names_backend_simulator:
805 ret = {}
806 return ret
807
808 url = get_backend_stats_url(self.config, hub, backend_type)
809
810 ret = self.req.get(url + '/parameters')
811 if not bool(ret):
812 ret = {}
813 else:
814 ret["backend"] = backend_type
815 return ret
816
817 def available_backends(self, hub=None, group=None, project=None,
818 access_token=None, user_id=None):
819 """
820 Get the backends available to use in the QX Platform
821 """
822 if access_token:
823 self.req.credential.set_token(access_token)
824 if user_id:
825 self.req.credential.set_user_id(user_id)
826 if not self.check_credentials():
827 raise CredentialsError('credentials invalid')
828 else:
829
830 url = get_backend_url(self.config, hub, group, project)
831
832 ret = self.req.get(url)
833 if (ret is not None) and (isinstance(ret, dict)):
834 return []
835 return [backend for backend in ret
836 if backend.get('status') == 'on']
837
838 def api_version(self):
839 """
840 Get the API Version of the QX Platform
841 """
842 return self.req.get('/version')
843
844
845 class ApiError(Exception):
846 """
847 IBMQConnector API error handling base class.
848 """
849 def __init__(self, usr_msg=None, dev_msg=None):
850 """
851 Args:
852 usr_msg (str): Short user facing message describing error.
853 dev_msg (str or None): More detailed message to assist
854 developer with resolving issue.
855 """
856 Exception.__init__(self, usr_msg)
857 self.usr_msg = usr_msg
858 self.dev_msg = dev_msg
859
860 def __repr__(self):
861 return repr(self.dev_msg)
862
863 def __str__(self):
864 return str(self.usr_msg)
865
866
867 class BadBackendError(ApiError):
868 """
869 Unavailable backend error.
870 """
871 def __init__(self, backend):
872 """
873 Args:
874 backend (str): name of backend.
875 """
876 usr_msg = ('Could not find backend "{0}" available.').format(backend)
877 dev_msg = ('Backend "{0}" does not exist. Please use '
878 'available_backends to see options').format(backend)
879 ApiError.__init__(self, usr_msg=usr_msg,
880 dev_msg=dev_msg)
881
882
883 class CredentialsError(ApiError):
884 """Exception associated with bad server credentials."""
885 pass
886
887
888 class RegisterSizeError(ApiError):
889 """Exception due to exceeding the maximum number of allowed qubits."""
890 pass
891
[end of qiskit/backends/ibmq/api/ibmqconnector.py]
[start of qiskit/backends/ibmq/ibmqprovider.py]
1 # -*- coding: utf-8 -*-
2
3 # Copyright 2018, IBM.
4 #
5 # This source code is licensed under the Apache License, Version 2.0 found in
6 # the LICENSE.txt file in the root directory of this source tree.
7
8 """Provider for remote IBMQ backends with admin features."""
9
10 import warnings
11 from collections import OrderedDict
12
13 from qiskit.backends import BaseProvider
14
15 from .credentials._configrc import remove_credentials
16 from .credentials import (Credentials,
17 read_credentials_from_qiskitrc, store_credentials, discover_credentials)
18 from .ibmqaccounterror import IBMQAccountError
19 from .ibmqsingleprovider import IBMQSingleProvider
20
21 QE_URL = 'https://quantumexperience.ng.bluemix.net/api'
22
23
24 class IBMQProvider(BaseProvider):
25 """Provider for remote IBMQ backends with admin features.
26
27 This class is the entry point for handling backends from IBMQ, allowing
28 using different accounts.
29 """
30 def __init__(self):
31 super().__init__()
32
33 # dict[credentials_unique_id: IBMQSingleProvider]
34 # This attribute stores a reference to the different accounts. The
35 # keys are tuples (hub, group, project), as the convention is that
36 # that tuple uniquely identifies a set of credentials.
37 self._accounts = OrderedDict()
38
39 def backends(self, name=None, filters=None, **kwargs):
40 """Return all backends accessible via IBMQ provider, subject to optional filtering.
41
42 Args:
43 name (str): backend name to filter by
44 filters (callable): more complex filters, such as lambda functions
45 e.g. IBMQ.backends(filters=lambda b: b.configuration['n_qubits'] > 5)
46 kwargs: simple filters specifying a true/false criteria in the
47 backend configuration or backend status or provider credentials
48 e.g. IBMQ.backends(n_qubits=5, operational=True, hub='internal')
49
50 Returns:
51 list[IBMQBackend]: list of backends available that match the filter
52
53 Raises:
54 IBMQAccountError: if no account matched the filter.
55 """
56 # pylint: disable=arguments-differ
57
58 # Special handling of the credentials filters: match and prune from kwargs
59 credentials_filter = {}
60 for key in ['token', 'url', 'hub', 'group', 'project', 'proxies', 'verify']:
61 if key in kwargs:
62 credentials_filter[key] = kwargs.pop(key)
63 providers = [provider for provider in self._accounts.values() if
64 self._credentials_match_filter(provider.credentials,
65 credentials_filter)]
66
67 # Special handling of the `name` parameter, to support alias resolution.
68 if name:
69 aliases = self.aliased_backend_names()
70 aliases.update(self.deprecated_backend_names())
71 name = aliases.get(name, name)
72
73 # Aggregate the list of filtered backends.
74 backends = []
75 for provider in providers:
76 backends = backends + provider.backends(
77 name=name, filters=filters, **kwargs)
78
79 return backends
80
81 @staticmethod
82 def deprecated_backend_names():
83 """Returns deprecated backend names."""
84 return {
85 'ibmqx_qasm_simulator': 'ibmq_qasm_simulator',
86 'ibmqx_hpc_qasm_simulator': 'ibmq_qasm_simulator',
87 'real': 'ibmqx1'
88 }
89
90 @staticmethod
91 def aliased_backend_names():
92 """Returns aliased backend names."""
93 return {
94 'ibmq_5_yorktown': 'ibmqx2',
95 'ibmq_5_tenerife': 'ibmqx4',
96 'ibmq_16_rueschlikon': 'ibmqx5',
97 'ibmq_20_austin': 'QS1_1'
98 }
99
100 def enable_account(self, token, url=QE_URL, **kwargs):
101 """Authenticate a new IBMQ account and add for use during this session.
102
103 Login into Quantum Experience or IBMQ using the provided credentials,
104 adding the account to the current session. The account is not stored
105 in disk.
106
107 Args:
108 token (str): Quantum Experience or IBM Q API token.
109 url (str): URL for Quantum Experience or IBM Q (for IBM Q,
110 including the hub, group and project in the URL).
111 **kwargs (dict):
112 * proxies (dict): Proxy configuration for the API.
113 * verify (bool): If False, ignores SSL certificates errors
114 """
115 credentials = Credentials(token, url, **kwargs)
116
117 self._append_account(credentials)
118
119 def save_account(self, token, url=QE_URL, **kwargs):
120 """Save the account to disk for future use.
121
122 Login into Quantum Experience or IBMQ using the provided credentials,
123 adding the account to the current session. The account is stored in
124 disk for future use.
125
126 Args:
127 token (str): Quantum Experience or IBM Q API token.
128 url (str): URL for Quantum Experience or IBM Q (for IBM Q,
129 including the hub, group and project in the URL).
130 **kwargs (dict):
131 * proxies (dict): Proxy configuration for the API.
132 * verify (bool): If False, ignores SSL certificates errors
133 """
134 credentials = Credentials(token, url, **kwargs)
135
136 # Check if duplicated credentials are already stored. By convention,
137 # we assume (hub, group, project) is always unique.
138 stored_credentials = read_credentials_from_qiskitrc()
139
140 if credentials.unique_id() in stored_credentials.keys():
141 warnings.warn('Credentials are already stored.')
142 else:
143 store_credentials(credentials)
144
145 def active_accounts(self):
146 """List all accounts currently in the session.
147
148 Returns:
149 list[dict]: a list with information about the accounts currently
150 in the session.
151 """
152 information = []
153 for provider in self._accounts.values():
154 information.append({
155 'token': provider.credentials.token,
156 'url': provider.credentials.url,
157 })
158
159 return information
160
161 def stored_accounts(self):
162 """List all accounts stored to disk.
163
164 Returns:
165 list[dict]: a list with information about the accounts stored
166 on disk.
167 """
168 information = []
169 stored_creds = read_credentials_from_qiskitrc()
170 for creds in stored_creds:
171 information.append({
172 'token': stored_creds[creds].token,
173 'url': stored_creds[creds].url
174 })
175
176 return information
177
178 def load_accounts(self, **kwargs):
179 """Load IBMQ accounts found in the system into current session,
180 subject to optional filtering.
181
182 Automatically load the accounts found in the system. This method
183 looks for credentials in the following locations, in order, and
184 returns as soon as credentials are found:
185
186 1. in the `Qconfig.py` file in the current working directory.
187 2. in the environment variables.
188 3. in the `qiskitrc` configuration file
189
190 Raises:
191 IBMQAccountError: if no credentials are found.
192 """
193 for credentials in discover_credentials().values():
194 if self._credentials_match_filter(credentials, kwargs):
195 self._append_account(credentials)
196
197 if not self._accounts:
198 raise IBMQAccountError('No IBMQ credentials found on disk.')
199
200 def disable_accounts(self, **kwargs):
201 """Disable accounts in the current session, subject to optional filtering.
202
203 The filter kwargs can be `token`, `url`, `hub`, `group`, `project`.
204 If no filter is passed, all accounts in the current session will be disabled.
205
206 Raises:
207 IBMQAccountError: if no account matched the filter.
208 """
209 disabled = False
210
211 # Try to remove from session.
212 current_creds = self._accounts.copy()
213 for creds in current_creds:
214 credentials = Credentials(current_creds[creds].credentials.token,
215 current_creds[creds].credentials.url)
216 if self._credentials_match_filter(credentials, kwargs):
217 del self._accounts[credentials.unique_id()]
218 disabled = True
219
220 if not disabled:
221 raise IBMQAccountError('No matching account to disable in current session.')
222
223 def delete_accounts(self, **kwargs):
224 """Delete saved accounts from disk, subject to optional filtering.
225
226 The filter kwargs can be `token`, `url`, `hub`, `group`, `project`.
227 If no filter is passed, all accounts will be deleted from disk.
228
229 Raises:
230 IBMQAccountError: if no account matched the filter.
231 """
232 deleted = False
233
234 # Try to delete from disk.
235 stored_creds = read_credentials_from_qiskitrc()
236 for creds in stored_creds:
237 credentials = Credentials(stored_creds[creds].token,
238 stored_creds[creds].url)
239 if self._credentials_match_filter(credentials, kwargs):
240 remove_credentials(credentials)
241 deleted = True
242
243 if not deleted:
244 raise IBMQAccountError('No matching account to delete from disk.')
245
246 def _append_account(self, credentials):
247 """Append an account with the specified credentials to the session.
248
249 Args:
250 credentials (Credentials): set of credentials.
251
252 Returns:
253 IBMQSingleProvider: new single-account provider.
254 """
255 # Check if duplicated credentials are already in use. By convention,
256 # we assume (hub, group, project) is always unique.
257 if credentials.unique_id() in self._accounts.keys():
258 warnings.warn('Credentials are already in use.')
259
260 single_provider = IBMQSingleProvider(credentials, self)
261 self._accounts[credentials.unique_id()] = single_provider
262
263 return single_provider
264
265 def _credentials_match_filter(self, credentials, filter_dict):
266 """Return True if the credentials match a filter.
267
268 These filters apply on properties of a Credentials object:
269 token, url, hub, group, project, proxies, verify
270 Any other filter has no effect.
271
272 Args:
273 credentials (Credentials): IBMQ credentials object
274 filter_dict (dict): dictionary of filter conditions
275
276 Returns:
277 bool: True if the credentials meet all the filter conditions
278 """
279 return all(getattr(credentials, key_, None) == value_ for
280 key_, value_ in filter_dict.items())
281
[end of qiskit/backends/ibmq/ibmqprovider.py]
</code>
I need you to solve this issue by generating a single patch file that I can apply directly to this repository using git apply. Please respond with a single patch file in the following format.
<patch>
--- a/file.py
+++ b/file.py
@@ -1,27 +1,35 @@
def euclidean(a, b):
- while b:
- a, b = b, a % b
- return a
+ if b == 0:
+ return a
+ return euclidean(b, a % b)
def bresenham(x0, y0, x1, y1):
points = []
dx = abs(x1 - x0)
dy = abs(y1 - y0)
- sx = 1 if x0 < x1 else -1
- sy = 1 if y0 < y1 else -1
- err = dx - dy
+ x, y = x0, y0
+ sx = -1 if x0 > x1 else 1
+ sy = -1 if y0 > y1 else 1
- while True:
- points.append((x0, y0))
- if x0 == x1 and y0 == y1:
- break
- e2 = 2 * err
- if e2 > -dy:
+ if dx > dy:
+ err = dx / 2.0
+ while x != x1:
+ points.append((x, y))
err -= dy
- x0 += sx
- if e2 < dx:
- err += dx
- y0 += sy
+ if err < 0:
+ y += sy
+ err += dx
+ x += sx
+ else:
+ err = dy / 2.0
+ while y != y1:
+ points.append((x, y))
+ err -= dx
+ if err < 0:
+ x += sx
+ err += dy
+ y += sy
+ points.append((x, y))
return points
</patch>
| Qiskit/qiskit | 77dc51b93e7312bbff8f5acf7d8242232bd6624f | credentials failed for qiskit ver 0.6.1
<!-- ⚠️ If you do not respect this template, your issue will be closed -->
<!-- ⚠️ Make sure to browse the opened and closed issues -->
### Informations
- **Qiskit Terra version**: 0.6.1
- **Python version**: 3.7.0
- **Operating system**:MAC OSX 10.13.6
### What is the current behavior?
After I acquired fresh token from https://quantumexperience.ng.bluemix.net/qx/account/advanced
IBMQ.load_accounts() fails.
### Steps to reproduce the problem
```
from qiskit import IBMQ
myToken='b6abe11442c9a...'
IBMQ.save_account(myToken)
IBMQ.load_accounts()
```
Results with
```
Traceback (most recent call last):
File "/anaconda3/lib/python3.7/site-packages/qiskit/backends/ibmq/ibmqsingleprovider.py", line 71, in _authenticate
credentials.verify)
File "/anaconda3/lib/python3.7/site-packages/IBMQuantumExperience/IBMQuantumExperience.py", line 478, in __init__
self.req = _Request(token, config=config, verify=verify)
File "/anaconda3/lib/python3.7/site-packages/IBMQuantumExperience/IBMQuantumExperience.py", line 253, in __init__
ntlm_credentials=self.ntlm_credentials)
File "/anaconda3/lib/python3.7/site-packages/IBMQuantumExperience/IBMQuantumExperience.py", line 95, in __init__
self.obtain_token(config=self.config)
File "/anaconda3/lib/python3.7/site-packages/IBMQuantumExperience/IBMQuantumExperience.py", line 159, in obtain_token
raise CredentialsError('error during login: %s' % error_message)
IBMQuantumExperience.IBMQuantumExperience.CredentialsError: error during login: Wrong user or password, check your credentials.
```
### What is the expected behavior?
Would be better if IBMQ.load_accounts() accepted me. All worked well w/ ver 0.5.
### Suggested solutions
| Can you try enable_account or regenerating the token. Your code should work. If you type `IBMQ.stored_accounts()` do you see the account.
@pacomf I can confirm this has happened to me today as well.
I cant reproduce the bug, i regenerate my APIToken and it works fine using qiskit terra... is it still happening? Can you send me more details?
It happened for about 5 hours on the weekend. However, @nonhermitian could run at the same time and then it started working again.
Mmmm, maybe an issue with the API... we will investigate it
I will add that, when it happened to me, I could log into some accounts and not others.
Hi @jaygambetta,
your tip helped. IBMQ.stored_accounts() has returned some old token, not the new one.
Looks like IBMQ.save_account(myToken) is unable to replace token if it exist - I leave it to you to decide if it is a bug or a feature.
My hack around it is to execute first: IBMQ.delete_accounts()
to clear my old token. So this sequence always works:
`
IBMQ.delete_accounts()
myToken='b6abe11442c9a...'
IBMQ.save_account(myToken)
IBMQ.load_accounts()
`
I can move on, closing thus ticket.
Thanks for help
Jan
Let's leave this open and investigate whether there's a bug with `IBMQ.save_account()` re-writing old tokens.
@diego-plan9 can you please have a look?
Yes - thanks @balewski for the information, which is spot on - currently, `IBMQ.save_account()` will just print a warning and do nothing else if old credentials are present:
https://github.com/Qiskit/qiskit-terra/blob/master/qiskit/backends/ibmq/ibmqprovider.py#L140-L143
> Looks like IBMQ.save_account(myToken) is unable to replace token if it exist - I leave it to you to decide if it is a bug or a feature.
Actually ... I can't decide if it is a bug or a feature either! :thinking: In the original draft implementation, the `.save_account()` (`.add_account()` by that time) method was [raising an Exception](https://github.com/Qiskit/qiskit-terra/blob/746245e29c5cadc44dc37851b19a4150b4e86cd8/qiskit/backends/ibmq/ibmqprovider.py#L111) in the case of trying to store a duplicate account. This was later changed to a warning, I'm unsure if by design and as a hard requisite from Jupyter-users needs, or also related to the slight tuning of the method functionality (ie. not authenticating during the call, just storing in disk). So I'm actually de-assigning myself, as probably the rest of the team has a more fresh view of the design decisions related to #1000.
I think we have several options:
* consider that not overwriting and raising a warning is indeed the desired behavior: the main drawback is that the warning might be easy to miss (and was probably the source of confusion in this issue).
* tune the method a bit in order to accept an `overwrite=True` optional parameter or a similar approach: the `credentials` module already has the needed parts in place, the main drawback would be that we touch a bit the public API.
* be a bit more restrictive and promote the warning back to an exception: it might affect users running the method twice and already used to not raising a warning (ie. maybe notebook users).
One way or the other, I think we need to make sure that the flow for updating an existing stored token is a bit smoother than the delete-save workaround proposed by @balewski, as it seems a relatively common use case.
From external user perspective:
It happens rather often that the ibmq_16_melbourne or even sometimes ibmqx4 does not accept the job, throws some 'general error', despite your web-page says both hardwares are operational.
Then, it is natural to (wrongly?) guess perhaps my token is invalid.
Then, I'd ask for a new token and try to use it - hoping it will help.
For such train of though the natural solution is assume 'user knows what he wants'. If user wants to replace the token by calling save_account(), just replace it. You can issue a warning that there was an old token (still valid), but why not just replace token each time user calls IBMQ.save_account(myToken) ?
Would this have any negative effect on your end?
Thanks
Jan
I think save_account should not raise an exception. Overwriting is not bad behavior. Similar to overwriting a key in a dict or something. Should just work.
@ajavadia is there an update.
Hi,
there is some inconsistency between the devices status you show here:
https://quantumexperience.ng.bluemix.net/qx/account/advanced
and actual avaliability.
At this moment, both ibmqx4 and ibmq_16_melbourne are reported to work.
However,. when I try to submit my circuit using Qiskit ver: 0.6.1 I get the error below for either.
Got a 400 code response to https://quantumexperience.ng.bluemix.net/api/Jobs?access_token=VCgYWnMUUBaYeT5gSmGO14cX93Foo4rccsLUVvIjf3bwYEZNjxlDcRmPArS2wZ25: {"error":{"status":400,"message":"Generic error","code":"GENERIC_ERROR"}}
Note, my token is correct, because I can submit the circuit to your simulator
'backend': 'ibmq_qasm_simulator',
'jobId2': '1814808',
'startTime': '2018-11-09 17:53:28'}
Can you have a look ?
Thanks
Jan | 2018-11-19T08:27:15Z | <patch>
diff --git a/qiskit/backends/ibmq/credentials/_configrc.py b/qiskit/backends/ibmq/credentials/_configrc.py
--- a/qiskit/backends/ibmq/credentials/_configrc.py
+++ b/qiskit/backends/ibmq/credentials/_configrc.py
@@ -9,6 +9,7 @@
Utilities for reading and writing credentials from and to configuration files.
"""
+import warnings
import os
from ast import literal_eval
from collections import OrderedDict
@@ -116,15 +117,17 @@ def store_credentials(credentials, overwrite=False, filename=None):
location is used (`HOME/.qiskit/qiskitrc`).
Raises:
- QISKitError: If credentials already exists and overwrite=False; or if
- the account_name could not be assigned.
+ QISKitError: if the account_name could not be assigned.
"""
# Read the current providers stored in the configuration file.
filename = filename or DEFAULT_QISKITRC_FILE
stored_credentials = read_credentials_from_qiskitrc(filename)
+ # Check if duplicated credentials are already stored. By convention,
+ # we assume (hub, group, project) is always unique.
if credentials.unique_id() in stored_credentials and not overwrite:
- raise QISKitError('Credentials already present and overwrite=False')
+ warnings.warn('Credentials already present. Set overwrite=True to overwrite.')
+ return
# Append and write the credentials to file.
stored_credentials[credentials.unique_id()] = credentials
diff --git a/qiskit/backends/ibmq/credentials/credentials.py b/qiskit/backends/ibmq/credentials/credentials.py
--- a/qiskit/backends/ibmq/credentials/credentials.py
+++ b/qiskit/backends/ibmq/credentials/credentials.py
@@ -22,7 +22,7 @@ class Credentials(object):
"""IBM Q account credentials.
Note that, by convention, two credentials that have the same hub, group
- and token (regardless of other attributes) are considered equivalent.
+ and project (regardless of other attributes) are considered equivalent.
The `unique_id()` returns the unique identifier.
"""
diff --git a/qiskit/backends/ibmq/ibmqprovider.py b/qiskit/backends/ibmq/ibmqprovider.py
--- a/qiskit/backends/ibmq/ibmqprovider.py
+++ b/qiskit/backends/ibmq/ibmqprovider.py
@@ -116,7 +116,7 @@ def enable_account(self, token, url=QE_URL, **kwargs):
self._append_account(credentials)
- def save_account(self, token, url=QE_URL, **kwargs):
+ def save_account(self, token, url=QE_URL, overwrite=False, **kwargs):
"""Save the account to disk for future use.
Login into Quantum Experience or IBMQ using the provided credentials,
@@ -127,20 +127,13 @@ def save_account(self, token, url=QE_URL, **kwargs):
token (str): Quantum Experience or IBM Q API token.
url (str): URL for Quantum Experience or IBM Q (for IBM Q,
including the hub, group and project in the URL).
+ overwrite (bool): overwrite existing credentials.
**kwargs (dict):
* proxies (dict): Proxy configuration for the API.
* verify (bool): If False, ignores SSL certificates errors
"""
credentials = Credentials(token, url, **kwargs)
-
- # Check if duplicated credentials are already stored. By convention,
- # we assume (hub, group, project) is always unique.
- stored_credentials = read_credentials_from_qiskitrc()
-
- if credentials.unique_id() in stored_credentials.keys():
- warnings.warn('Credentials are already stored.')
- else:
- store_credentials(credentials)
+ store_credentials(credentials, overwrite=overwrite)
def active_accounts(self):
"""List all accounts currently in the session.
</patch> | [] | [] | |||
docker__compose-6410 | "You will be provided with a partial code base and an issue statement explaining a problem to resolv(...TRUNCATED) | docker/compose | 14e7a11b3c96f0ea818c8c28d84a1aff7967e579 | "Upgrade `events` to use the new API fields\nIn API version 1.22 the events structure was updated to(...TRUNCATED) | "This upgrade may also allow us to handle image events. Since we won't need to inspect every event, (...TRUNCATED) | 2018-12-11T01:55:02Z | "<patch>\ndiff --git a/compose/cli/log_printer.py b/compose/cli/log_printer.py\n--- a/compose/cli/lo(...TRUNCATED) | [] | [] | |||
ytdl-org__youtube-dl-1591 | "You will be provided with a partial code base and an issue statement explaining a problem to resolv(...TRUNCATED) | ytdl-org/youtube-dl | b4cdc245cf0af0672207a5090cb6eb6c29606cdb | "Opus audio conversion failure\nWhen trying to extract and convert audio from a youtube video into a(...TRUNCATED) | "I had the same issue and after an hour-long debug session with a friend of mine we found out that t(...TRUNCATED) | 2013-10-12T11:32:27Z | "<patch>\ndiff --git a/youtube_dl/PostProcessor.py b/youtube_dl/PostProcessor.py\n--- a/youtube_dl/P(...TRUNCATED) | [] | [] | |||
numpy__numpy-13703 | "You will be provided with a partial code base and an issue statement explaining a problem to resolv(...TRUNCATED) | numpy/numpy | 40ada70d9efc903097b2ff3f968c23a7e2f14296 | "Dtype.base attribute not documented\ndtype instances have a `base` attribute that, I think, is mean(...TRUNCATED) | "I've found myself using `.subdtype` instead, which contains the same info\nI think base also means (...TRUNCATED) | 2019-06-03T20:15:13Z | "<patch>\ndiff --git a/numpy/core/_add_newdocs.py b/numpy/core/_add_newdocs.py\n--- a/numpy/core/_ad(...TRUNCATED) | [] | [] | |||
wagtail__wagtail-7855 | "You will be provided with a partial code base and an issue statement explaining a problem to resolv(...TRUNCATED) | wagtail/wagtail | 4550bba562286992b27e667b071451e6886fbf44 | "Use html_url in alias_of API serialisation\nAs per https://github.com/wagtail/wagtail/pull/7669#iss(...TRUNCATED) | 2022-01-13T15:50:23Z | "<patch>\ndiff --git a/wagtail/api/v2/serializers.py b/wagtail/api/v2/serializers.py\n--- a/wagtail/(...TRUNCATED) | [] | [] | ||||
pandas-dev__pandas-27237 | "You will be provided with a partial code base and an issue statement explaining a problem to resolv(...TRUNCATED) | pandas-dev/pandas | f683473a156f032a64a1d7edcebde21c42a8702d | "Add key to sorting functions\nMany python functions (sorting, max/min) accept a key argument, perh(...TRUNCATED) | "Here's a specific use case that came up on [StackOverflow](http://stackoverflow.com/questions/29580(...TRUNCATED) | 2019-07-04T23:04:26Z | "<patch>\ndiff --git a/doc/source/user_guide/basics.rst b/doc/source/user_guide/basics.rst\n--- a/do(...TRUNCATED) | [] | [] | |||
conan-io__conan-3187 | "You will be provided with a partial code base and an issue statement explaining a problem to resolv(...TRUNCATED) | conan-io/conan | c3baafb780b6e5498f8bd460426901d9d5ab10e1 | "Using \"?\" in a tools.get() URL will fail, while using it in a tools.download() will succeed.\nTo (...TRUNCATED) | "Verified: ``tools.get()`` uses the last part of the URL as the name of the file to be saved.\r\n\r\(...TRUNCATED) | 2018-07-10T10:30:23Z | "<patch>\ndiff --git a/conans/client/tools/net.py b/conans/client/tools/net.py\n--- a/conans/client/(...TRUNCATED) | [] | [] | |||
googleapis__google-cloud-python-3348 | "You will be provided with a partial code base and an issue statement explaining a problem to resolv(...TRUNCATED) | googleapis/google-cloud-python | 520637c245d461db8ee45ba466d763036b82ea42 | Error reporting system tests needed
Follow up to #3263.
| 2017-05-01T22:40:28Z | "<patch>\ndiff --git a/error_reporting/nox.py b/error_reporting/nox.py\n--- a/error_reporting/nox.py(...TRUNCATED) | [] | [] |
End of preview. Expand
in Dataset Viewer.
Dataset Card for "SWE-bench_bm25_13K"
Dataset Summary
SWE-bench is a dataset that tests systems’ ability to solve GitHub issues automatically. The dataset collects 2,294 Issue-Pull Request pairs from 12 popular Python. Evaluation is performed by unit test verification using post-PR behavior as the reference solution.
The dataset was released as part of SWE-bench: Can Language Models Resolve Real-World GitHub Issues?
This dataset SWE-bench_bm25_13K includes a formatting of each instance using Pyserini's BM25 retrieval as described in the paper. The code context size limit is 13,000 cl100k_base tokens from the tiktoken tokenization package used for OpenAI models.
The text column can be used directly with LMs to generate patch files.
Models are instructed to generate patch formatted file using the following template:
<patch>
diff
--- a/path/to/file.py
--- b/path/to/file.py
@@ -1,3 +1,3 @@
This is a test file.
-It contains several lines.
+It has been modified.
This is the third line.
</patch>
This format can be used directly with the SWE-bench inference scripts. Please refer to these scripts for more details on inference.
Supported Tasks and Leaderboards
SWE-bench proposes a new task: issue resolution provided a full repository and GitHub issue. The leaderboard can be found at www.swebench.com
Languages
The text of the dataset is primarily English, but we make no effort to filter or otherwise clean based on language type.
Dataset Structure
Data Instances
An example of a SWE-bench datum is as follows:
instance_id: (str) - A formatted instance identifier, usually as repo_owner__repo_name-PR-number.
text: (str) - The input text including instructions, the "Oracle" retrieved file, and an example of the patch format for output.
patch: (str) - The gold patch, the patch generated by the PR (minus test-related code), that resolved the issue.
repo: (str) - The repository owner/name identifier from GitHub.
base_commit: (str) - The commit hash of the repository representing the HEAD of the repository before the solution PR is applied.
hints_text: (str) - Comments made on the issue prior to the creation of the solution PR’s first commit creation date.
created_at: (str) - The creation date of the pull request.
test_patch: (str) - A test-file patch that was contributed by the solution PR.
problem_statement: (str) - The issue title and body.
version: (str) - Installation version to use for running evaluation.
environment_setup_commit: (str) - commit hash to use for environment setup and installation.
FAIL_TO_PASS: (str) - A json list of strings that represent the set of tests resolved by the PR and tied to the issue resolution.
PASS_TO_PASS: (str) - A json list of strings that represent tests that should pass before and after the PR application.
- Downloads last month
- 224