Merge pull request entropicalabs#225 from entropicalabs/bugfix_dump_methods

Bugfix dump methods

Author: vishal-ph

.github/workflows/test_main_linux.yml

@@ -46,7 +46,7 @@ jobs:
         run: |
           IBMQ_TOKEN=$IBMQ_TOKEN
           source env/bin/activate
-          python -c'from qiskit import IBMQ; import os; IBMQ.save_account(os.environ.get("IBMQ_TOKEN"))'
+          python -c'from qiskit_ibm_provider import IBMProvider; import os; IBMProvider.save_account(os.environ.get("IBMQ_TOKEN"))'
       - name: Setup AWS
         env:
           ACCESS_KEY: ${{ secrets.ACCESS_KEY }} 

src/openqaoa-core/algorithms/baseworkflow.py

@@ -107,7 +107,6 @@ def __init__(self, device=DeviceLocal("vectorized")):
             "target": None,
             "cloud": None,
             "client": None,
-            "qubit_number": None,  # it is set automatically in the compilation from the problem object
             "execution_time_start": None,
             "execution_time_end": None,
         }
@@ -131,13 +130,13 @@ def __setattr__(self, __name, __value):
 
     def set_header(
         self,
-        project_id: str,
-        description: str,
-        run_by: str,
-        provider: str,
-        target: str,
-        cloud: str,
-        client: str,
+        project_id: str = None,
+        description: str = None,
+        run_by: str = None,
+        provider: str = None,
+        target: str = None,
+        cloud: str = None,
+        client: str = None,
         experiment_id: str = None,
     ):
         """
@@ -147,16 +146,17 @@ def set_header(
         ----------
         TODO : document the parameters
         """
+        if project_id is not None:
+            if not is_valid_uuid(project_id):
+                raise ValueError(
+                    "The project_id is not a valid uuid, example of a valid uuid: 8353185c-b175-4eda-9628-b4e58cb0e41b"
+                )
 
-        if not is_valid_uuid(project_id):
-            raise ValueError(
-                "The project_id is not a valid uuid, example of a valid uuid: 8353185c-b175-4eda-9628-b4e58cb0e41b"
-            )
-
-        if experiment_id != None:
+        if experiment_id is not None:
             if not is_valid_uuid(experiment_id):
                 raise ValueError(
-                    "The experiment_id is not a valid uuid, example of a valid uuid: 8353185c-b175-4eda-9628-b4e58cb0e41b"
+                    "The experiment_id is not a valid uuid, \
+                        example of a valid uuid: 8353185c-b175-4eda-9628-b4e58cb0e41b"
                 )
             else:
                 self.header["experiment_id"] = experiment_id
@@ -335,13 +335,13 @@ def compile(self, problem: QUBO):
         self.header["atomic_id"] = generate_uuid()
 
         # header is updated with the qubit number of the problem
-        self.header["qubit_number"] = self.problem.n
+        self.set_exp_tags({"qubit_number": self.problem.n})
 
     def optimize():
         raise NotImplementedError
 
     def _serializable_dict(
-        self, complex_to_string: bool = False, intermediate_mesurements: bool = True
+        self, complex_to_string: bool = False, intermediate_measurements: bool = True
     ):
         """
         Returns a dictionary with all values and attributes of the object that we want to
@@ -355,7 +355,7 @@ def _serializable_dict(
         complex_to_string: bool
             If True, converts all complex numbers to strings. This is useful for
             JSON serialization, for the `dump(s)` methods.
-        intermediate_mesurements: bool
+        intermediate_measurements: bool
             If True, intermediate measurements are included in the dump.
             If False, intermediate measurements are not included in the dump.
             Default is True.
@@ -381,8 +381,8 @@ def _serializable_dict(
                 )
 
         data["result"] = (
-            self.result.asdict(False, complex_to_string, intermediate_mesurements)
-            if not self.result in [None, {}]
+            self.result.asdict(False, complex_to_string, intermediate_measurements)
+            if self.result not in [None, {}]
             else None
         )
 
@@ -437,7 +437,7 @@ def asdict(self, exclude_keys: List[str] = [], options: dict = {}):
                 complex_to_string : bool
                     If True, converts complex numbers to strings. If False,
                     complex numbers are not converted to strings.
-                intermediate_mesurements : bool
+                intermediate_measurements : bool
                     If True, includes the intermediate measurements in the results.
                     If False, only the final measurements are included.
 
@@ -469,7 +469,7 @@ def dumps(self, indent: int = 2, exclude_keys: List[str] = [], options: dict = {
         options : dict
             A dictionary of options to pass to the method that creates
             the dictionary to dump.
-        intermediate_mesurements : bool
+        intermediate_measurements : bool
             If True, includes the intermediate measurements in the results.
             If False, only the final measurements are included.
 
@@ -530,7 +530,7 @@ def dump(
             raises an error if the file already exists.
         options : dict
             A dictionary of options to pass to the method that creates the dictionary to dump.
-        intermediate_mesurements : bool
+        intermediate_measurements : bool
             If True, includes the intermediate measurements in the results.
             If False, only the final measurements are included.
         """
@@ -544,11 +544,11 @@ def dump(
         )
 
         # get the full name
-        if prepend_id == False and file_name == "":
+        if prepend_id is False and file_name == "":
             raise ValueError(
                 "dump method missing argument: 'file_name'. Otherwise 'prepend_id' must be specified as True."
             )
-        elif prepend_id == False:
+        elif prepend_id is False:
             file = file_path + file_name
         elif file_name == "":
             file = (
@@ -577,12 +577,12 @@ def dump(
             file = file + ".gz" if ".gz" != file[-3:] else file
 
         # checking if the file already exists, and raising an error if it does and overwrite is False
-        if overwrite == False and exists(file):
+        if overwrite is False and exists(file):
             raise FileExistsError(
                 f"The file {file} already exists. Please change the name of the file or set overwrite=True."
             )
 
-        ## saving the file
+        # saving the file
         if compresslevel == 0:  # if compresslevel is 0, save as json file
             with open(file, "w") as f:
                 if exclude_keys == []:

src/openqaoa-core/algorithms/qaoa/qaoa_result.py

@@ -17,7 +17,9 @@
 
 
 def most_probable_bitstring(cost_hamiltonian, measurement_outcomes):
-
+    """
+    Computing the most probable bitstring
+    """
     mea_out = list(measurement_outcomes.values())
     index_likliest_states = np.argwhere(mea_out == np.max(mea_out))
     # degeneracy = len(index_likliest_states)
@@ -54,7 +56,9 @@ def __init__(
         cost_hamiltonian: Type[Hamiltonian],
         type_backend: Type[QAOABaseBackend],
     ):
-
+        """
+        init method
+        """
         self.__type_backend = type_backend
         self.method = method
         self.cost_hamiltonian = cost_hamiltonian
@@ -116,7 +120,7 @@ def asdict(
         self,
         keep_cost_hamiltonian: bool = True,
         complex_to_string: bool = False,
-        intermediate_mesurements: bool = True,
+        intermediate_measurements: bool = True,
         exclude_keys: List[str] = [],
     ):
         """
@@ -132,7 +136,7 @@ def asdict(
         complex_to_string: `bool`
             If True, the complex numbers are converted to strings. If False, they are kept as complex numbers.
             This is useful for the JSON serialization.
-        intermediate_mesurements: bool, optional
+        intermediate_measurements: bool, optional
             If True, intermediate measurements are included in the dump.
             If False, intermediate measurements are not included in the dump.
             Default is True.
@@ -152,7 +156,7 @@ def asdict(
         return_dict["evals"] = self.evals
         return_dict["most_probable_states"] = self.most_probable_states
 
-        complx_to_str = (
+        complex_to_str = (
             lambda x: str(x)
             if isinstance(x, np.complex128) or isinstance(x, complex)
             else x
@@ -161,43 +165,67 @@ def asdict(
         # if the backend is a statevector backend, the measurement outcomes will be the statevector,
         # meaning that it is a list of complex numbers, which is not serializable.
         # If that is the case, and complex_to_string is true the complex numbers are converted to strings.
-        if complex_to_string and issubclass(
-            self.__type_backend, QAOABaseBackendStatevector
-        ):
+        if complex_to_string:
             return_dict["intermediate"] = {}
             for key, value in self.intermediate.items():
-                if (
-                    intermediate_mesurements == False and "measurement" in key
-                ):  # if intermediate_mesurements is false, the intermediate measurements are not included in the dump
-                    return_dict["intermediate"][key] = []
-                elif "measurement" in key and (
-                    isinstance(value, list) or isinstance(value, np.ndarray)
+                # Measurements and Cost may require casting
+                if "measurement" in key:
+                    if len(value) > 0:
+                        if intermediate_measurements is False:
+                            # if intermediate_measurements is false, the intermediate measurements are not included
+                            return_dict["intermediate"][key] = []
+                        elif isinstance(
+                            value[0], np.ndarray
+                        ):  # Statevector -> convert complex to str
+                            return_dict["intermediate"][key] = [
+                                [complex_to_str(item) for item in list_]
+                                for list_ in value
+                                if (
+                                    isinstance(list_, list)
+                                    or isinstance(list_, np.ndarray)
+                                )
+                            ]
+                        else:  # All other case -> cast numpy into
+                            return_dict["intermediate"][key] = [
+                                {k_: int(v_) for k_, v_ in v.items()} for v in value
+                            ]
+                    else:
+                        pass
+                elif "cost" == key and (
+                    isinstance(value[0], np.float64) or isinstance(value[0], np.float32)
                 ):
-                    return_dict["intermediate"][key] = [
-                        [complx_to_str(item) for item in list_]
-                        for list_ in value
-                        if (isinstance(list_, list) or isinstance(list_, np.ndarray))
-                    ]
+                    return_dict["intermediate"][key] = [float(item) for item in value]
                 else:
                     return_dict["intermediate"][key] = value
 
             return_dict["optimized"] = {}
             for key, value in self.optimized.items():
+                # If wavefunction do complex to str
                 if "measurement" in key and (
                     isinstance(value, list) or isinstance(value, np.ndarray)
                 ):
                     return_dict["optimized"][key] = [
-                        complx_to_str(item) for item in value
+                        complex_to_str(item) for item in value
                     ]
+                # if dictionary, convert measurement values to integers
+                elif "measurement" in key and (isinstance(value, dict)):
+                    return_dict["optimized"][key] = {
+                        k: int(v) for k, v in value.items()
+                    }
                 else:
                     return_dict["optimized"][key] = value
+
+                if "cost" in key and (
+                    isinstance(value, np.float64) or isinstance(value, np.float32)
+                ):
+                    return_dict["optimized"][key] = float(value)
         else:
             return_dict["intermediate"] = self.intermediate
             return_dict["optimized"] = self.optimized
 
         # if we are using a shot adaptive optimizer, we need to add the number of shots to the result,
         # so if attribute n_shots is not empty, it is added to the dictionary
-        if getattr(self, "n_shots", None) != None:
+        if getattr(self, "n_shots", None) is not None:
             return_dict["n_shots"] = self.n_shots
 
         return (
@@ -233,7 +261,7 @@ def from_dict(
             setattr(result, key, value)
 
         # if there is an input cost hamiltonian, it is added to the result
-        if cost_hamiltonian != None:
+        if cost_hamiltonian is not None:
             result.cost_hamiltonian = cost_hamiltonian
 
         # if the measurement_outcomes are strings, they are converted to complex numbers
@@ -281,7 +309,7 @@ def get_counts(measurement_outcomes):
             the actual measurement counts.
         """
 
-        if type(measurement_outcomes) == type(np.array([])):
+        if isinstance(measurement_outcomes, type(np.array([]))):
             measurement_outcomes = qaoa_probabilities(measurement_outcomes)
 
         return measurement_outcomes
@@ -335,7 +363,6 @@ def plot_probabilities(
         color="tab:blue",
         ax=None,
     ):
-
         """
         Helper function to plot the probabilities corresponding to each basis states
         (with prob != 0) obtained from the optimized result
@@ -359,7 +386,7 @@ def plot_probabilities(
         outcome = self.optimized["measurement_outcomes"]
 
         # converting to counts dictionary if outcome is statevector
-        if type(outcome) == type(np.array([])):
+        if isinstance(outcome, type(np.array([]))):
             outcome = self.get_counts(outcome)
             # setting norm to 1 since it might differ slightly for statevectors due to numerical preicision
             norm = np.float64(1)
@@ -407,7 +434,7 @@ def plot_probabilities(
         ]
         labels.append("rest")
 
-        # represent the bar with the addition of all the remaining probabilites
+        # represent the bar with the addition of all the remaining probabilities
         rest = sum(probs[n_states_to_keep:])
 
         if ax is None:
@@ -470,7 +497,7 @@ def plot_n_shots(
         if ax is None:
             ax = plt.subplots(figsize=figsize)[1]
 
-        ## creating a list of parameters to plot
+        # creating a list of parameters to plot
         # if param_to_plot is not given, plot all the parameters
         if param_to_plot is None:
             param_to_plot = list(range(len(self.n_shots[0])))
@@ -504,22 +531,23 @@ def plot_n_shots(
                 color = [color]
 
         # if param_top_plot is a list and label or color are not lists, raise error
-        if (type(label) != list) or (type(color) != list and color != None):
+        if (type(label) != list) or (type(color) != list and color is not None):
             raise TypeError("`label` and `color` must be list of str")
         # if label is a list, check that all the elements are strings
-        for l in label:
-            assert type(l) == str, "`label` must be a list of strings"
+        for lab in label:
+            assert type(lab) == str, "`label` must be a list of strings"
         # if color is a list, check that all the elements are strings
-        if color != None:
+        if color is not None:
             for c in color:
                 assert type(c) == str, "`color` must be a list of strings"
 
         # if label and color are lists, check if they have the same length as param_to_plot
         if len(label) != len(param_to_plot) or (
-            color != None and len(color) != len(param_to_plot)
+            color is not None and len(color) != len(param_to_plot)
         ):
             raise ValueError(
-                f"`param_to_plot`, `label` and `color` must have the same length, `param_to_plot` is a list of {len(param_to_plot)} elements"
+                f"`param_to_plot`, `label` and `color` must have the same length, \
+                    `param_to_plot` is a list of {len(param_to_plot)} elements"
             )
 
         # linestyle must be a string or a list of strings, if it is a string, convert it to a list of strings
@@ -529,7 +557,8 @@ def plot_n_shots(
             linestyle = [linestyle for _ in range(len(param_to_plot))]
         elif len(linestyle) != len(param_to_plot):
             raise ValueError(
-                f"`linestyle` must have the same length as param_to_plot (length of `param_to_plot` is {len(param_to_plot)}), or be a string"
+                f"`linestyle` must have the same length as param_to_plot \
+                    (length of `param_to_plot` is {len(param_to_plot)}), or be a string"
             )
         else:
             for ls in linestyle:

src/openqaoa-core/algorithms/qaoa/qaoa_workflow.py

@@ -5,10 +5,8 @@
 from .qaoa_result import QAOAResult
 from ..workflow_properties import CircuitProperties
 from ..baseworkflow import Workflow, check_compiled
-from ...backends.basebackend import QAOABaseBackendStatevector
 from ...backends import QAOABackendAnalyticalSimulator
-from ...backends.cost_function import cost_function
-from ...backends.devices_core import DeviceLocal, DeviceBase
+from ...backends.devices_core import DeviceLocal
 from ...backends.qaoa_backend import get_qaoa_backend
 from ...problems import QUBO
 from ...qaoa_components import (
@@ -262,11 +260,24 @@ def compile(
             optimizer_dict=self.classical_optimizer.asdict(),
         )
 
+        # Set the header properties
+        self.header["target"] = self.device.device_name
+        self.header["cloud"] = self.device.device_location
+
+        metadata = {
+            "p": self.circuit_properties.p,
+            "param_type": self.circuit_properties.param_type,
+            "init_type": self.circuit_properties.init_type,
+            "optimizer_method": self.classical_optimizer.method,
+        }
+
+        self.set_exp_tags(tags=metadata)
+
         self.compiled = True
 
         if verbose:
             print("\t \033[1m ### Summary ###\033[0m")
-            print(f"OpenQAOA has been compiled with the following properties")
+            print("OpenQAOA has been compiled with the following properties")
             print(
                 f"Solving QAOA with \033[1m {self.device.device_name} \033[0m on"
                 f"\033[1m{self.device.device_location}\033[0m"
@@ -296,7 +307,7 @@ def optimize(self, verbose=False):
         A method running the classical optimisation loop
         """
 
-        if self.compiled == False:
+        if self.compiled is False:
             raise ValueError("Please compile the QAOA before optimizing it!")
 
         # timestamp for the start of the optimization
@@ -310,7 +321,7 @@ def optimize(self, verbose=False):
         self.header["execution_time_end"] = generate_timestamp()
 
         if verbose:
-            print(f"optimization completed.")
+            print("Optimization completed.")
         return
 
     def evaluate_circuit(
@@ -338,10 +349,11 @@ def evaluate_circuit(
         """
 
         # before evaluating the circuit we check that the QAOA object has been compiled
-        if self.compiled == False:
+        if self.compiled is False:
             raise ValueError("Please compile the QAOA before optimizing it!")
 
-        ## Check the type of the input parameters and save them as a QAOAVariationalBaseParams object at the variable `params_obj`
+        # Check the type of the input parameters and save them as a
+        # QAOAVariationalBaseParams object at the variable `params_obj`
 
         # if the parameters are passed as a dictionary we copy and update the variational parameters of the QAOA object
         if isinstance(params, dict):
@@ -382,7 +394,7 @@ def evaluate_circuit(
                 f"The input params must be a list or a dictionary. Instead, received {type(params)}"
             )
 
-        ## Evaluate the QAOA circuit and return the results
+        # Evaluate the QAOA circuit and return the results
         output_dict = {
             "cost": None,
             "uncertainty": None,
@@ -409,7 +421,7 @@ def evaluate_circuit(
         return output_dict
 
     def _serializable_dict(
-        self, complex_to_string: bool = False, intermediate_mesurements: bool = True
+        self, complex_to_string: bool = False, intermediate_measurements: bool = True
     ):
         """
         Returns all values and attributes of the object that we want to return in
@@ -426,7 +438,7 @@ def _serializable_dict(
         serializable_dict: dict
             A dictionary containing all the values and attributes of the object
             that we want to return in `asdict` and `dump(s)` methods.
-        intermediate_mesurements: bool
+        intermediate_measurements: bool
             If True, intermediate measurements are included in the dump.
             If False, intermediate measurements are not included in the dump.
             Default is True.
@@ -435,7 +447,7 @@ def _serializable_dict(
         # we call the _serializable_dict method of the parent class,
         # specifying the keys to delete from the results dictionary
         serializable_dict = super()._serializable_dict(
-            complex_to_string, intermediate_mesurements
+            complex_to_string, intermediate_measurements
         )
 
         # we add the keys of the QAOA object that we want to return

src/openqaoa-core/algorithms/rqaoa/rqaoa_result.py

@@ -18,7 +18,7 @@ def asdict(
         self,
         keep_cost_hamiltonian: bool = True,
         complex_to_string: bool = False,
-        intermediate_mesurements: bool = True,
+        intermediate_measurements: bool = True,
         exclude_keys: List[str] = [],
     ):
         """
@@ -32,7 +32,7 @@ def asdict(
         complex_to_string : bool, optional
             If True, the complex numbers are converted to strings, by default False.
             This is useful for JSON serialization.
-        intermediate_mesurements: bool, optional
+        intermediate_measurements: bool, optional
             If True, intermediate measurements are included in the dump. If False,
             intermediate measurements are not included in the dump.
             Default is True.
@@ -55,7 +55,7 @@ def asdict(
                     "qaoa_results": step["qaoa_results"].asdict(
                         keep_cost_hamiltonian,
                         complex_to_string,
-                        intermediate_mesurements,
+                        intermediate_measurements,
                     ),
                     "exp_vals_z": step["exp_vals_z"].tolist(),
                     "corr_matrix": step["corr_matrix"].tolist(),

src/openqaoa-core/algorithms/rqaoa/rqaoa_utils.py

@@ -65,7 +65,7 @@ def max_terms(exp_vals_z: np.ndarray, corr_matrix: np.ndarray, n_elim: int):
 
     # Flag if we have have not been able to extract any relation for the terms
     if max_terms_and_stats == {}:
-        print(f"All expectation values are 0: Breaking degeneracy by fixing a qubit\n")
+        print("All expectation values are 0: Breaking degeneracy by fixing a qubit\n")
         max_terms_and_stats = {(0,): -1.0}
 
     return max_terms_and_stats
@@ -132,7 +132,7 @@ def ada_max_terms(exp_vals_z: np.ndarray, corr_matrix: np.ndarray, n_max: int):
 
     # Flag if we have have not been able to extract any relation for the terms
     if max_terms_and_stats == {}:
-        print(f"All expectation values are 0: Breaking degeneracy by fixing a qubit\n")
+        print("All expectation values are 0: Breaking degeneracy by fixing a qubit\n")
         max_terms_and_stats = {(0,): -1.0}
 
     # Correlation average magnitude
@@ -395,7 +395,7 @@ def redefine_problem(problem: QUBO, spin_map: dict):
     # get a set of all the spins to be eliminated
     eliminated_spins = set()
     for spin in spin_map.keys():
-        if spin != spin_map[spin][1] or spin_map[spin][1] == None:
+        if spin != spin_map[spin][1] or spin_map[spin][1] is None:
             eliminated_spins.add(spin)
 
     # Scan all terms and weights
@@ -605,7 +605,8 @@ def final_solution(
 
 def solution_for_vanishing_instances(hamiltonian: Hamiltonian, spin_map: dict):
     """
-    Constructs the final solution of the smallest non vanishing problem by fixing the vanishing spins arbitrarily to 1 while obeying the correlations identified by the last run of QAOA before the problem vanished.
+    Constructs the final solution of the smallest non vanishing problem by fixing the vanishing spins arbitrarily to 1
+    while obeying the correlations identified by the last run of QAOA before the problem vanished.
     Computing the classical energy of the generated string.
 
     Parameters
@@ -621,12 +622,14 @@ def solution_for_vanishing_instances(hamiltonian: Hamiltonian, spin_map: dict):
     cl_energy: `float`
         The energy of the solution wrt the cost Hamiltonian.
     cl_ground_state: `list`
-        The (single) classical solution to the problem reconstructed accordingly to the last spin map. Represented as a binary string and then cast to a list to match the output of the `ground_state_hamiltonian` function which is used usually.
+        The (single) classical solution to the problem reconstructed accordingly to the last spin map.
+        Represented as a binary string and then cast to a list to match the output of the
+        `ground_state_hamiltonian` function which is used usually.
     """
     cl_ground_state = ""
 
     for spin in spin_map.keys():
-        if spin_map[spin][1] == None:
+        if spin_map[spin][1] is None:
             cl_ground_state += "1"
         else:
             # fix according to correlation factor

src/openqaoa-core/algorithms/rqaoa/rqaoa_workflow.py

@@ -494,7 +494,7 @@ def optimize(
         # dump the object if dump is true
         if dump:
             self.dump(
-                **{**dump_options, **{"options": {"intermediate_mesurements": False}}}
+                **{**dump_options, **{"options": {"intermediate_measurements": False}}}
             )
 
         if verbose:
@@ -548,7 +548,7 @@ def __n_step(self, n_qubits, n_cutoff, counter):
         return (n_qubits - n_cutoff) if (n_qubits - n_cutoff) < n else n
 
     def _serializable_dict(
-        self, complex_to_string: bool = False, intermediate_mesurements: bool = True
+        self, complex_to_string: bool = False, intermediate_measurements: bool = True
     ):
         """
         Returns all values and attributes of the object that we want to
@@ -565,15 +565,15 @@ def _serializable_dict(
         serializable_dict: dict
             Dictionary containing all the values and attributes of the object
             that we want to return in `asdict` and `dump(s)` methods.
-        intermediate_mesurements: bool
+        intermediate_measurements: bool
             If True, intermediate measurements are included in the dump. If False,
             intermediate measurements are not included in the dump.
             Default is True.
         """
         # we call the _serializable_dict method of the parent class,
         # specifying the keys to delete from the results dictionary
         serializable_dict = super()._serializable_dict(
-            complex_to_string, intermediate_mesurements
+            complex_to_string, intermediate_measurements
         )
 
         # we add the keys of the RQAOA object that we want to return

src/openqaoa-core/algorithms/rqaoa/rqaoa_workflow_properties.py

@@ -53,10 +53,11 @@ def __init__(
         n_max: `int`
             Maximum number of eliminations allowed at each step when using the adaptive method. Defaults to 1.
         steps: `Union[list,int]`
-            Elimination schedule for the RQAOA algorithm. If an integer is passed, it sets the number of spins eliminated
-            at each step. If a list is passed, the algorithm will follow the list to select how many spins to eliminate
-            at each step. Note that the list needs enough elements to specify eliminations from the initial number of qubits
-            up to the cutoff value. If the list contains more, the algorithm will follow instructions until the cutoff value
+            Elimination schedule for the RQAOA algorithm. If an integer is passed, it sets the number of spins
+            eliminated at each step. If a list is passed, the algorithm will follow the list to select
+            how many spins to eliminate at each step. Note that the list needs enough elements to specify
+            eliminations from the initial number of qubits up to the cutoff value. If the list contains more,
+            the algorithm will follow instructions until the cutoff value
             is reached. Defaults to 1.
         n_cutoff: `int`
             Cutoff value at which the RQAOA algorithm obtains the solution classically. Defaults to 5.
@@ -74,7 +75,7 @@ def __init__(
         self.counter = counter
 
         # check if the rqaoa type is correct
-        if not self.rqaoa_type in ALLOWED_RQAOA_TYPES:
+        if self.rqaoa_type not in ALLOWED_RQAOA_TYPES:
             self.compiled = False
             raise Exception(
                 f'rqaoa_type {self.rqaoa_type} is not supported. Please select "adaptive" or "custom".'
@@ -84,16 +85,17 @@ def __init__(
         if self.rqaoa_type == "adaptive":
             if self.steps != 1:
                 raise ValueError(
-                    f"When using the adaptive method, the `steps` parameter is not required.  \
+                    "When using the adaptive method, the `steps` parameter is not required.  \
                     The parameter that specifies the maximum number of eliminations per step is `n_max`."
                 )
             if self.counter != 0:
                 raise ValueError(
-                    f"When using the adaptive method, the `counter` parameter is not required."
+                    "When using the adaptive method, the `counter` parameter is not required."
                 )
         else:
             if self.n_max != 1:
                 raise ValueError(
-                    f"When using the custom method, the `n_max` parameter is not required.  \
-                    The parameter that specifies the number of eliminations is `steps`, which can be a string or a list."
+                    "When using the custom method, the `n_max` parameter is not required.  \
+                    The parameter that specifies the number of eliminations is `steps`,\
+                          which can be a string or a list."
                 )

tests/jobs_test_input/input_data/openqaoa_params.json

@@ -1,7 +1,7 @@
 {
   "header": {
-    "atomic_id": "210a6aaa-932d-45a6-b260-f3fdd085c547",
-    "experiment_id": "74779bb1-867c-4131-89d2-ac9238422cd9",
+    "atomic_id": "386997de-0e90-4e1c-8236-cd722801615f",
+    "experiment_id": "ce2f83d7-4000-4507-9e98-96e3f9afd55e",
     "project_id": null,
     "algorithm": "rqaoa",
     "description": null,
@@ -10,10 +10,10 @@
     "target": null,
     "cloud": null,
     "client": null,
-    "qubit_number": 10,
     "execution_time_start": null,
     "execution_time_end": null,
     "metadata": {
+      "qubit_number": 10,
       "problem_type": "minimum_vertex_cover",
       "n_shots": 100,
       "optimizer_method": "cobyla",
@@ -22,11 +22,13 @@
       "p": 1,
       "rqaoa_type": "custom",
       "rqaoa_n_max": 1,
-      "rqaoa_n_cutoff": 3
+      "rqaoa_n_cutoff": 6
     }
   },
   "data": {
-    "exp_tags": {},
+    "exp_tags": {
+      "qubit_number": 10
+    },
     "input_problem": {
       "terms": [
         [
@@ -212,8 +214,8 @@
     },
     "input_parameters": {
       "device": {
-        "device_location": "local",
-        "device_name": "vectorized"
+        "device_location": "aws",
+        "device_name": "arn:aws:braket:::device/quantum-simulator/amazon/sv1"
       },
       "backend_properties": {
         "init_hadamard": true,
@@ -268,15 +270,12 @@
         "rqaoa_type": "custom",
         "n_max": 1,
         "steps": [
-          2,
-          2,
-          2,
-          2,
-          2,
-          2,
-          2
+          1,
+          1,
+          1,
+          1
         ],
-        "n_cutoff": 3,
+        "n_cutoff": 6,
         "original_hamiltonian": null,
         "counter": 0
       }

tests/test_backends.py

@@ -1,6 +1,5 @@
 import unittest
 import json
-import os
 import pytest
 import subprocess
 
@@ -38,12 +37,13 @@ class TestingBackendLocal(unittest.TestCase):
 
     def test_get_counts_and_expectation_n_shots(self):
         """
-        Check that the .get_counts admit n_shots as an argument, and works properly for the backend of all local devices.
-        Also check that .expectation and .expecation_w_uncertainty methods admit n_shots as an argument for the QAOABaseBackendShotBased backends.
+        Check that the .get_counts admit n_shots as an argument, and works properly for
+          the backend of all local devices.
+        Also check that .expectation and .expecation_w_uncertainty methods admit n_shots
+         as an argument for the QAOABaseBackendShotBased backends.
         """
 
         for device_name in DEVICE_NAME_TO_OBJECT_MAPPER.keys():
-
             # Analytical device doesn't have any of those so we are skipping it in the tests.
             if device_name in ["analytical_simulator"]:
                 continue
@@ -62,15 +62,17 @@ def test_get_counts_and_expectation_n_shots(self):
                     ).values()
                 )
                 == 58
-            ), "`n_shots` is not being respected for the local simulator `{}` when calling backend.get_counts(n_shots=58).".format(
+            ), "`n_shots` is not being respected for the local simulator `{}` when \
+                calling backend.get_counts(n_shots=58).".format(
                 device_name
             )
             if isinstance(backend, QAOABaseBackendShotBased):
                 try:
                     backend.expectation(params=variational_params_std, n_shots=58)
                 except Exception:
                     raise Exception(
-                        "backend.expectation does not admit `n_shots` as an argument for the local simulator `{}`.".format(
+                        "backend.expectation does not admit `n_shots` as an argument \
+                            for the local simulator `{}`.".format(
                             device_name
                         )
                     )
@@ -80,7 +82,8 @@ def test_get_counts_and_expectation_n_shots(self):
                     )
                 except Exception:
                     raise Exception(
-                        "backend.expectation_w_uncertainty does not admit `n_shots` as an argument for the local simulator `{}`.".format(
+                        "backend.expectation_w_uncertainty does not admit `n_shots` \
+                            as an argument for the local simulator `{}`.".format(
                             device_name
                         )
                     )
@@ -96,7 +99,6 @@ class TestingBackendQPUs(unittest.TestCase):
 
     @pytest.mark.qpu
     def setUp(self):
-
         self.HUB = "ibm-q"
         self.GROUP = "open"
         self.PROJECT = "main"
@@ -123,9 +125,11 @@ def setUp(self):
     @pytest.mark.qpu
     def test_get_counts_and_expectation_n_shots(self):
         """
-        TODO: test needs to be updated as DEVICE_ACCESS_OBJECT_MAPPER is now dynamically filled based on whether a module exists.
-        
-        Check that the .get_counts, .expectation and .expecation_w_uncertainty methods admit n_shots as an argument for the backends of all QPUs.
+        TODO: test needs to be updated as DEVICE_ACCESS_OBJECT_MAPPER is now dynamically filled
+        based on whether a module exists.
+
+        Check that the .get_counts, .expectation and .expecation_w_uncertainty methods
+        admit n_shots as an argument for the backends of all QPUs.
         """
 
         list_device_attributes = [
@@ -134,7 +138,7 @@ def test_get_counts_and_expectation_n_shots(self):
                 "device_name": "rigetti.sim.qvm",
                 "resource_id": self.RESOURCE_ID,
                 "az_location": self.AZ_LOCATION,
-            }, 
+            },
             {
                 "QPU": "AWS",
                 "device_name": "arn:aws:braket:::device/quantum-simulator/amazon/sv1",
@@ -157,12 +161,12 @@ def test_get_counts_and_expectation_n_shots(self):
 
         assert len(list_device_attributes) == len(
             DEVICE_ACCESS_OBJECT_MAPPER
-        ), "The number of QPUs in the list of tests is not the same as the number of QPUs in the DEVICE_ACCESS_OBJECT_MAPPER. The list should be updated."
+        ), "The number of QPUs in the list of tests is not the same as the number of QPUs in \
+             the DEVICE_ACCESS_OBJECT_MAPPER. The list should be updated."
         print(DEVICE_ACCESS_OBJECT_MAPPER.items(), list_device_attributes)
         for (device, backend), device_attributes in zip(
             DEVICE_ACCESS_OBJECT_MAPPER.items(), list_device_attributes
         ):
-
             qaoa_descriptor, variational_params_std = get_params()
 
             QPU_name = device_attributes.pop("QPU")
@@ -185,15 +189,17 @@ def test_get_counts_and_expectation_n_shots(self):
                     init_hadamard=True,
                 )
 
-                # Check that the .get_counts, .expectation and .expectation_w_variance methods admit n_shots as an argument
+                # Check that the .get_counts, .expectation and .expectation_w_variance methods
+                # admit n_shots as an argument
                 assert (
                     sum(
                         backend.get_counts(
                             params=variational_params_std, n_shots=58
                         ).values()
                     )
                     == 58
-                ), "`n_shots` is not being respected when calling .get_counts(n_shots=58).".format(
+                ), "`n_shots` is not being respected \
+                    when calling .get_counts(n_shots=58) for QPU `{}`.".format(
                     QPU_name
                 )
                 backend.expectation(params=variational_params_std, n_shots=58)
@@ -202,7 +208,6 @@ def test_get_counts_and_expectation_n_shots(self):
                 )
 
             except Exception as e:
-
                 raise e from type(e)(f"Error raised for `{QPU_name}`: " + str(e))
 
             print("Test passed for {} backend.".format(QPU_name))

tests/test_benchmark.py

@@ -1,6 +1,8 @@
 import unittest
 import numpy as np
 import matplotlib.pyplot as plt
+import pytest
+import sys
 
 from openqaoa import QAOA, create_device, QAOABenchmark
 from openqaoa.problems import QUBO
@@ -89,6 +91,10 @@ def test_type_qaoa_reference(self):
             benchmark.reference.backend, type(qaoa_vectorized.backend)
         ), "The qaoa reference should have a vectorized backend."
 
+    @pytest.mark.skipif(
+        sys.platform == "darwin" or sys.platform.startswith("win"),
+        reason="Test does not run on Mac and Windows currently",
+    )
     def __compare_values_benchmark(
         self,
         qaoa,
@@ -196,6 +202,10 @@ def __compare_values_benchmark(
                 n_points_axis, ranges, run_reference
             )
 
+    @pytest.mark.skipif(
+        sys.platform == "darwin" or sys.platform.startswith("win"),
+        reason="Test does not run on Mac and Windows currently",
+    )
     def test_values_1D(self):
         "Test the values of the benchmark for 1D ranges."
 
@@ -234,6 +244,10 @@ def test_values_1D(self):
             ],
         )
 
+    @pytest.mark.skipif(
+        sys.platform == "darwin" or sys.platform.startswith("win"),
+        reason="Test does not run on Mac and Windows currently",
+    )
     def test_values_2D(self):
         "Test the values of the benchmark for 2D ranges."
 
@@ -259,6 +273,10 @@ def test_values_2D(self):
             run_reference=True,
         )
 
+    @pytest.mark.skipif(
+        sys.platform == "darwin" or sys.platform.startswith("win"),
+        reason="Test does not run on Mac and Windows currently",
+    )
     def test_values_3D(self):
         "Test the values of the benchmark for 3D ranges."
 
@@ -284,6 +302,10 @@ def test_values_3D(self):
             run_reference=True,
         )
 
+    @pytest.mark.skipif(
+        sys.platform == "darwin" or sys.platform.startswith("win"),
+        reason="Test does not run on Mac and Windows currently",
+    )
     def test_difference(self):
         "Test the property difference and difference_mean."
 
@@ -353,6 +375,10 @@ def test_difference(self):
             error
         ), "An error should be raised if the difference is called before running the benchmark."
 
+    @pytest.mark.skipif(
+        sys.platform == "darwin" or sys.platform.startswith("win"),
+        reason="Test does not run on Mac and Windows currently",
+    )
     def test_input_checks(self):
         "Test the input assertions of the run method."
 
@@ -437,6 +463,10 @@ def test_input_checks(self):
             benchmark.run, n_points_axis=4, ranges=[(1, 2), (1, 3)], verbose="d"
         ), "An error should be raised when verbose is not a boolean."
 
+    @pytest.mark.skipif(
+        sys.platform == "darwin" or sys.platform.startswith("win"),
+        reason="Test does not run on Mac and Windows currently",
+    )
     def test_plot(self):
         "Test the plot method."
 
@@ -477,6 +507,10 @@ def test_plot(self):
         benchmark.run(n_points_axis=4, ranges=[(0, np.pi), (-5, 9), (0, 1), (1,)])
         benchmark.plot()
 
+    @pytest.mark.skipif(
+        sys.platform == "darwin" or sys.platform.startswith("win"),
+        reason="Test does not run on Mac and Windows currently",
+    )
     def test_plot_inputs(self):
         "Test the plot method with different inputs."
 
@@ -529,6 +563,10 @@ def test_plot_inputs(self):
         plt.show()
         plt.close(fig)
 
+    @pytest.mark.skipif(
+        sys.platform == "darwin" or sys.platform.startswith("win"),
+        reason="Test does not run on Mac and Windows currently",
+    )
     def test_plot_input_checks(self):
         "Test the plot method assertion inputs."
 
@@ -616,8 +654,11 @@ def test_plot_input_checks(self):
             benchmark.plot, main=False, reference=False, difference=True
         ), "An error should be raised when no values are available"
 
+    @pytest.mark.skipif(
+        sys.platform == "darwin" or sys.platform.startswith("win"),
+        reason="Test does not run on Mac and Windows currently",
+    )
     def test_run_w_plots(self):
-
         qaoa = QAOA()
         qaoa.compile(QUBO.random_instance(5))
         benchmark = QAOABenchmark(qaoa)

tests/test_circuit_routing.py

@@ -1,19 +1,18 @@
 # unit testing for circuit routing functionality in OQ
 import unittest
 import numpy as np
-from typing import List, Callable, Optional
+from typing import List, Optional
 import pytest
 
-from openqaoa import QAOA
+from openqaoa import QAOA, create_device, QUBO
 from openqaoa.qaoa_components import (
     create_qaoa_variational_params,
     QAOADescriptor,
     PauliOp,
     Hamiltonian,
 )
 from openqaoa.utilities import X_mixer_hamiltonian
-from openqaoa.backends import QAOAvectorizedBackendSimulator, create_device
-from openqaoa.problems import NumberPartition, QUBO, Knapsack, MaximumCut, ShortestPath
+from openqaoa.problems import NumberPartition, Knapsack, MaximumCut, ShortestPath
 from openqaoa_pyquil.backends import DevicePyquil, QAOAPyQuilQPUBackend
 from openqaoa.backends.devices_core import DeviceBase
 from openqaoa.qaoa_components.ansatz_constructor.gatemap import SWAPGateMap
@@ -35,7 +34,6 @@ def test_no_swap(self):
         """
 
         def routing_function_test1(device, problem_to_solve):
-
             # tuples ordered from 0,n, both SWAP and ising gates
             gate_list_indices = [[0, 1]]
 
@@ -117,7 +115,6 @@ def routing_function_test1(device, problem_to_solve):
         device_pyquil.quantum_computer.qam.random_seed = seed
 
         for i in range(len(p_lst)):
-
             p = p_lst[i]
             args = args_lst[i]
             cost_hamil = cost_hamil_lst[i]
@@ -166,14 +163,13 @@ def routing_function_test1(device, problem_to_solve):
 
     def test_cancelled_swap(self):
         """
-        Tests that QAOADescriptor with a trivial `routing_function` input (with two swaps that cancel each other) returns identical
-        results as QAOADescriptor with no `routing_function` input, by comparing output of seeded QVM run.
-        Different values of p, arguments, and cost hamiltonian coefficients are tested.
-
+        Tests that QAOADescriptor with a trivial `routing_function` input (with two swaps that cancel each other)
+        returns identical results as QAOADescriptor with no `routing_function` input,
+        by comparing output of seeded QVM run. Different values of p, arguments,
+        and cost hamiltonian coefficients are tested.
         """
 
         def routing_function_test1(device, problem_to_solve):
-
             # tuples ordered from 0,n, both SWAP and ising gates
             gate_list_indices = [[0, 1], [0, 1], [0, 1]]
 
@@ -255,7 +251,6 @@ def routing_function_test1(device, problem_to_solve):
         device_pyquil.quantum_computer.qam.random_seed = seed
 
         for i in range(len(p_lst)):
-
             p = p_lst[i]
             args = args_lst[i]
             cost_hamil = cost_hamil_lst[i]
@@ -314,7 +309,6 @@ def test_simplest_swap(self):
         """
 
         def routing_function_test1(device, problem_to_solve):
-
             # tuples ordered from 0,n, both SWAP and ising gates
             gate_list_indices = [[0, 1], [0, 1]]
 
@@ -396,7 +390,6 @@ def routing_function_test1(device, problem_to_solve):
         device_pyquil.quantum_computer.qam.random_seed = seed
 
         for i in range(len(p_lst)):
-
             p = p_lst[i]
             args = args_lst[i]
             cost_hamil = cost_hamil_lst[i]
@@ -454,7 +447,6 @@ def test_different_topologies(self):
         """
 
         def routing_function_test1(device, problem_to_solve):
-
             # tuples ordered from 0,n, both SWAP and ising gates
             gate_list_indices = [[0, 1], [1, 0], [0, 1]]
 
@@ -500,7 +492,6 @@ def routing_function_test1(device, problem_to_solve):
         seed = 1
 
         for i in range(len(p_lst)):
-
             p = p_lst[i]
             args = args_lst[i]
             cost_hamil = cost_hamil_lst[i]
@@ -603,9 +594,10 @@ def values_return(self):
 
 
 class TestingQubitRouting(unittest.TestCase):
-    @pytest.mark.qpu
     def setUp(self):
-
+        """
+        Test edge cases
+        """
         # case qubits device > qubits problem (IBM NAIROBI)
         self.IBM_NAIROBI_KNAPSACK = ExpectedRouting(
             qubo=Knapsack.random_instance(n_items=3, seed=20).qubo,
@@ -882,7 +874,7 @@ def setUp(self):
         )
 
         # case qubits device == qubits problem (RIGETTI)
-        self.RIGETTI_MACUT = ExpectedRouting(
+        self.RIGETTI_MAXCUT = ExpectedRouting(
             qubo=MaximumCut.random_instance(
                 n_nodes=9, edge_probability=0.9, seed=20
             ).qubo,
@@ -1132,7 +1124,6 @@ def __compare_results(self, expected: ExpectedRouting, p: int):
 
     @pytest.mark.qpu
     def test_qubit_routing(self):
-
         for i, case in enumerate(self.list_of_cases):
             print("Test case {} out of {}:".format(i + 1, len(self.list_of_cases)))
             self.__compare_results(case, p=i % 4 + 1)

tests/test_notebooks.py

@@ -6,14 +6,14 @@
 from nbconvert.preprocessors import ExecutePreprocessor
 import pytest
 
-import sys, os
+import sys
+import os
 
 myPath = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, myPath + "/../")
 
 
 def notebook_test_function(name):
-
     with open(name, encoding="utf-8") as f:
         nb = nbformat.read(f, as_version=4)
 
@@ -88,8 +88,7 @@ def test_X_dumping_data():
     notebook_test_function("./examples/X_dumping_data.ipynb")
 
 
-### Community Tutorials
-
+# Community Tutorials
 # @pytest.mark.notebook
 def test_tutorial_quantum_approximate_optimization_algorithm():
     notebook_test_function(

tests/test_qpu_braket.py

@@ -87,7 +87,6 @@ def test_circuit_angle_assignment_qpu_backend(self):
 
         self.assertEqual(main_circuit, qpu_circuit)
 
-
     @pytest.mark.braket_api
     def test_circuit_angle_assignment_qpu_backend_w_hadamard(self):
         """
@@ -150,7 +149,6 @@ def test_circuit_angle_assignment_qpu_backend_w_hadamard(self):
 
         self.assertEqual(main_circuit, qpu_circuit)
 
-
     @pytest.mark.braket_api
     def test_prepend_circuit(self):
         """
@@ -210,7 +208,6 @@ def test_prepend_circuit(self):
 
         self.assertEqual(main_circuit, qpu_circuit)
 
-
     @pytest.mark.braket_api
     def test_append_circuit(self):
         """
@@ -271,10 +268,8 @@ def test_append_circuit(self):
 
         self.assertEqual(main_circuit, qpu_circuit)
 
-
     @pytest.mark.braket_api
     def test_prepend_exception(self):
-
         """
         Test that the error catching for a prepend ciruit larger than the problem
         circuit is invalid
@@ -301,12 +296,15 @@ def test_prepend_exception(self):
         )
         mixer_hamil = X_mixer_hamiltonian(n_qubits=nqubits)
         qaoa_descriptor = QAOADescriptor(cost_hamil, mixer_hamil, p=p)
-        variate_params = QAOAVariationalStandardParams(qaoa_descriptor, betas, gammas)
+
+        # Try to create the variate params
+        _ = QAOAVariationalStandardParams(qaoa_descriptor, betas, gammas)
 
         aws_device = DeviceAWS("arn:aws:braket:::device/quantum-simulator/amazon/sv1")
 
         try:
-            aws_backend = QAOAAWSQPUBackend(
+            # Try to create the AWS backend
+            _ = QAOAAWSQPUBackend(
                 qaoa_descriptor, aws_device, shots, prepend_circuit, None, True, 1.0
             )
         except Exception as e:
@@ -316,7 +314,6 @@ def test_prepend_exception(self):
 
     @pytest.mark.braket_api
     def test_exceptions_in_init(self):
-
         """
         Testing the Exceptions in the init function of the QAOAAWSQPUBackend
         """
@@ -335,7 +332,9 @@ def test_exceptions_in_init(self):
         )
         mixer_hamil = X_mixer_hamiltonian(n_qubits=nqubits)
         qaoa_descriptor = QAOADescriptor(cost_hamil, mixer_hamil, p=p)
-        variate_params = QAOAVariationalStandardParams(qaoa_descriptor, betas, gammas)
+
+        # Try instantiating the variate params
+        _ = QAOAVariationalStandardParams(qaoa_descriptor, betas, gammas)
 
         # If the user's aws credentials is not correct.
         mock_device = Mock()
@@ -383,10 +382,8 @@ def test_exceptions_in_init(self):
 
         QAOAAWSQPUBackend(qaoa_descriptor, aws_device, shots, None, None, True, 1.0)
 
-
-    @pytest.mark.braket_api            
+    @pytest.mark.braket_api
     def test_remote_qubit_overflow(self):
-
         """
         If the user creates a circuit that is larger than the maximum circuit size
         that is supported by the QPU. An Exception should be raised with the
@@ -417,9 +414,8 @@ def test_remote_qubit_overflow(self):
                 "There are lesser qubits on the device than the number of qubits required for the circuit.",
             )
 
-    @pytest.mark.qpu
+    @pytest.mark.sim
     def test_remote_integration_qpu_run(self):
-
         """
         Run a toy example in manual mode to make sure everything works as
         expected for a remote backend

tests/test_qpu_qiskit.py

@@ -26,145 +26,169 @@
 )
 from openqaoa.utilities import X_mixer_hamiltonian
 from openqaoa.problems import NumberPartition
-from openqaoa import QAOA
+from openqaoa import QAOA, create_device
 
 
 class TestingQAOAQiskitQPUBackendAzure(unittest.TestCase):
-    
-    """This Object tests the QAOA Qiskit QPU Backend object with the Azure 
+
+    """This Object tests the QAOA Qiskit QPU Backend object with the Azure
     Device object. This checks that the use of qiskit to send circuits to Azure
     is working as intended.
-    
+
     The Azure CLI has to be configured beforehand to run these tests.
     """
-    
+
     @pytest.mark.api
     def setUp(self):
-        
+        """
+        Setting up the credentials
+        """
         bashCommand = "az resource list"
         process = subprocess.Popen(bashCommand.split(), stdout=subprocess.PIPE)
         output, error = process.communicate()
-        
+
         if error is not None:
             print(error)
-            raise Exception('You must have the Azure CLI installed and must be logged in to use the Azure Quantum Backends')
+            raise Exception(
+                "You must have the Azure CLI installed and must be logged in to use the Azure Quantum Backends"
+            )
         else:
             output_json = json.loads(output)
-            output_json_s = [each_json for each_json in output_json if each_json['name'] == 'TestingOpenQAOA'][0]
-            self.RESOURCE_ID = output_json_s['id']
-            self.AZ_LOCATION = output_json_s['location']
-            
+            output_json_s = [
+                each_json
+                for each_json in output_json
+                if each_json["name"] == "TestingOpenQAOA"
+            ][0]
+            self.RESOURCE_ID = output_json_s["id"]
+            self.AZ_LOCATION = output_json_s["location"]
+
     @pytest.mark.sim
     def check_shots_tally(self):
-        
-        """There is a known bug in the qiskit backend for azure where if the shots 
-        argument might be ignored. This test checks that the output from the azure 
+        """
+        There is a known bug in the qiskit backend for azure where if the shots
+        argument might be ignored. This test checks that the output from the azure
         computation matches the input requirements.
         """
-        
+
         shots = 1024
         problem_qubo = NumberPartition([1, 2, 3]).qubo
-        azure_device = create_device(location='azure', name='rigetti.sim.qvm', 
-                                     resource_id=self.RESOURCE_ID, 
-                                     az_location=self.AZ_LOCATION)
-        
+        azure_device = create_device(
+            location="azure",
+            name="rigetti.sim.qvm",
+            resource_id=self.RESOURCE_ID,
+            az_location=self.AZ_LOCATION,
+        )
+
         q = QAOA()
         q.set_device(azure_device)
         q.set_backend_properties(n_shots=shots)
-        q.set_classical_optimizer(maxiter = 1)
+        q.set_classical_optimizer(maxiter=1)
         q.compile(problem_qubo)
         q.optimize()
-        
-        comp_shots = sum(q.result.optimized['optimized measurement outcomes'].values())
-        
+
+        q.dump(file_name="check_shots_tally", prepend_id=False, overwrite=True)
+
+        comp_shots = sum(q.result.optimized["optimized measurement outcomes"].values())
+
         self.assertEqual(shots, comp_shots)
-        
+
     @pytest.mark.api
     def test_expectations_in_init(self):
-        
         """
         Testing the Exceptions in the init function of the QiskitQPUShotBasedBackend
         """
-        
+
         nqubits = 3
         p = 1
         weights = [1, 1, 1]
-        gammas = [1/8*np.pi]
-        betas = [1/8*np.pi]
+        gammas = [1 / 8 * np.pi]
+        betas = [1 / 8 * np.pi]
         shots = 10000
 
-        cost_hamil = Hamiltonian([PauliOp('ZZ', (0, 1)), PauliOp('ZZ', (1, 2)),
-                                  PauliOp('ZZ', (0, 2))], weights, 1)
+        cost_hamil = Hamiltonian(
+            [PauliOp("ZZ", (0, 1)), PauliOp("ZZ", (1, 2)), PauliOp("ZZ", (0, 2))],
+            weights,
+            1,
+        )
         mixer_hamil = X_mixer_hamiltonian(n_qubits=nqubits)
         qaoa_descriptor = QAOADescriptor(cost_hamil, mixer_hamil, p=p)
-        variate_params = QAOAVariationalStandardParams(qaoa_descriptor,
-                                                       betas, gammas)
-        
+
+        # Try to compute the variate params
+        _ = QAOAVariationalStandardParams(qaoa_descriptor, betas, gammas)
+
         # We mock the potential Exception that could occur in the Device class
-        azure_device = DeviceAzure('', '', '')
+        azure_device = DeviceAzure("", "", "")
         azure_device._check_provider_connection = Mock(return_value=False)
-        
+
         try:
-            QAOAQiskitQPUBackend(qaoa_descriptor, azure_device, 
-                                 shots, None, None, True)
+            QAOAQiskitQPUBackend(qaoa_descriptor, azure_device, shots, None, None, True)
         except Exception as e:
-            self.assertEqual(str(e), 'Error connecting to AZURE.')
-        
+            self.assertEqual(str(e), "Error connecting to AZURE.")
+
         with self.assertRaises(Exception):
             QAOAQiskitQPUBackend(qaoa_descriptor, azure_device, shots, None, None, True)
-        
 
-        azure_device = DeviceAzure(device_name='', resource_id=self.RESOURCE_ID, 
-                                   az_location=self.AZ_LOCATION)
-        
+        azure_device = DeviceAzure(
+            device_name="", resource_id=self.RESOURCE_ID, az_location=self.AZ_LOCATION
+        )
+
         try:
-            QAOAQiskitQPUBackend(qaoa_descriptor, azure_device, 
-                                 shots, None, None, True)
+            QAOAQiskitQPUBackend(qaoa_descriptor, azure_device, shots, None, None, True)
         except Exception as e:
-            self.assertEqual(str(e), 'Connection to AZURE was made. Error connecting to the specified backend.')
-        
+            self.assertEqual(
+                str(e),
+                "Connection to AZURE was made. Error connecting to the specified backend.",
+            )
+
         with self.assertRaises(Exception):
             QAOAQiskitQPUBackend(qaoa_descriptor, azure_device, shots, None, None, True)
-        
+
     @pytest.mark.api
     def test_remote_qubit_overflow(self):
-        
         """
         If the user creates a circuit that is larger than the maximum circuit size
-        that is supported by the QPU. An Exception should be raised with the 
+        that is supported by the QPU. An Exception should be raised with the
         appropriate error message alerting the user to the error.
         """
-        
+
         shots = 100
-        
+
         set_of_numbers = np.random.randint(1, 10, 6).tolist()
         qubo = NumberPartition(set_of_numbers).qubo
 
         mixer_hamil = X_mixer_hamiltonian(n_qubits=6)
         qaoa_descriptor = QAOADescriptor(qubo.hamiltonian, mixer_hamil, p=1)
-        variate_params = create_qaoa_variational_params(qaoa_descriptor, 'standard', 'rand')
 
-        azure_device = DeviceAzure('rigetti.sim.qvm', self.RESOURCE_ID, self.AZ_LOCATION)
-        
+        # Check the creation of the varitional parms
+        _ = create_qaoa_variational_params(qaoa_descriptor, "standard", "rand")
+
+        azure_device = DeviceAzure(
+            "rigetti.sim.qvm", self.RESOURCE_ID, self.AZ_LOCATION
+        )
+
         try:
-            QAOAQiskitQPUBackend(qaoa_descriptor, azure_device, 
-                                 shots, None, None, True)
+            QAOAQiskitQPUBackend(qaoa_descriptor, azure_device, shots, None, None, True)
         except Exception as e:
-            self.assertEqual(str(e), 'There are lesser qubits on the device than the number of qubits required for the circuit.')
+            self.assertEqual(
+                str(e),
+                "There are lesser qubits on the device than the number of qubits required for the circuit.",
+            )
 
 
 class TestingQAOAQiskitQPUBackend(unittest.TestCase):
 
     """This Object tests the QAOA Qiskit QPU Backend objects, which is tasked with the
     creation and execution of a QAOA circuit for the selected QPU provider and
     backend.
-    
+
     IBMQ Account has to be saved locally to run these tests.
     """
 
     @pytest.mark.api
     def setUp(self):
-
+        """
+        Define the credentials
+        """
         self.HUB = "ibm-q"
         self.GROUP = "open"
         self.PROJECT = "main"
@@ -419,7 +443,6 @@ def test_append_circuit(self):
 
     @pytest.mark.api
     def test_expectations_in_init(self):
-
         """
         Testing the Exceptions in the init function of the QiskitQPUShotBasedBackend
         """
@@ -438,7 +461,9 @@ def test_expectations_in_init(self):
         )
         mixer_hamil = X_mixer_hamiltonian(n_qubits=nqubits)
         qaoa_descriptor = QAOADescriptor(cost_hamil, mixer_hamil, p=p)
-        variate_params = QAOAVariationalStandardParams(qaoa_descriptor, betas, gammas)
+
+        # Check the creation of the varitional parms
+        _ = QAOAVariationalStandardParams(qaoa_descriptor, betas, gammas)
 
         # We mock the potential Exception that could occur in the Device class
         qiskit_device = DeviceQiskit("", "", "", "")
@@ -503,7 +528,6 @@ def test_remote_integration_sim_run(self):
         shots = 10000
 
         for i in range(4):
-
             cost_hamil = Hamiltonian(
                 [PauliOp("ZZ", (0, 1)), PauliOp("ZZ", (1, 2)), PauliOp("ZZ", (0, 2))],
                 weights,
@@ -538,7 +562,6 @@ def test_remote_integration_sim_run(self):
 
     @pytest.mark.api
     def test_remote_qubit_overflow(self):
-
         """
         If the user creates a circuit that is larger than the maximum circuit size
         that is supported by the QPU. An Exception should be raised with the
@@ -552,9 +575,9 @@ def test_remote_qubit_overflow(self):
 
         mixer_hamil = X_mixer_hamiltonian(n_qubits=6)
         qaoa_descriptor = QAOADescriptor(qubo.hamiltonian, mixer_hamil, p=1)
-        variate_params = create_qaoa_variational_params(
-            qaoa_descriptor, "standard", "rand"
-        )
+
+        # Check the creation of the varitional parms
+        _ = create_qaoa_variational_params(qaoa_descriptor, "standard", "rand")
 
         qiskit_device = DeviceQiskit("ibmq_manila", self.HUB, self.GROUP, self.PROJECT)