We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Data mingled across columns in dataset
### Steps to reproduce
1. Measure something with `.run(use_threads=True)`

### Expected behaviour
Get a neat dataset

### Actual behaviour
Data mingles across columns in dataset 💘 

### System
**operating system**
Win 10

**qcodes branch**
Master

Two identical measurements:
![image](https://cloud.githubusercontent.com/assets/8595386/26193146/99b0d318-3bb4-11e7-9e93-473d782fe41b.png)



--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `qcodes/actions.py`
Content:
```
1 """Actions, mainly to be executed in measurement Loops."""
2 import time
3 
4 from qcodes.utils.deferred_operations import is_function
5 from qcodes.utils.threading import thread_map
6 
7 
8 _NO_SNAPSHOT = {'type': None, 'description': 'Action without snapshot'}
9 
10 
11 def _actions_snapshot(actions, update):
12     """Make a list of snapshots from a list of actions."""
13     snapshot = []
14     for action in actions:
15         if hasattr(action, 'snapshot'):
16             snapshot.append(action.snapshot(update=update))
17         else:
18             snapshot.append(_NO_SNAPSHOT)
19     return snapshot
20 
21 
22 class Task:
23     """
24     A predefined task to be executed within a measurement Loop.
25 
26     The first argument should be a callable, to which any subsequent
27     args and kwargs (which are evaluated before the loop starts) are passed.
28 
29     The args and kwargs are first evaluated if they are found to be callable.
30 
31     Keyword Args passed when the Task is called are ignored,
32     but are accepted for compatibility with other things happening in a Loop.
33 
34     Args:
35         func (callable): Function to executed
36         *args: pass to func, after evaluation if callable
37         **kwargs: pass to func, after evaluation if callable
38 
39     """
40     def __init__(self, func, *args, **kwargs):
41         self.func = func
42         self.args = args
43         self.kwargs = kwargs
44 
45     def __call__(self, **ignore_kwargs):
46         # If any of the arguments are callable, evaluate them first
47         eval_args = [arg() if callable(arg) else arg for arg in self.args]
48         eval_kwargs = {k: (v() if callable(v) else v) for k, v in self.kwargs.items()}
49 
50         self.func(*eval_args, **eval_kwargs)
51 
52     def snapshot(self, update=False):
53         """
54         Snapshots  task
55         Args:
56             update (bool): TODO not in use
57 
58         Returns:
59             dict: snapshot
60         """
61         return {'type': 'Task', 'func': repr(self.func)}
62 
63 
64 class Wait:
65     """
66     A simple class to tell a Loop to wait <delay> seconds.
67 
68     This is transformed into a Task within the Loop, such that
69     it can do other things (monitor, check for halt) during the delay.
70 
71     But for use outside of a Loop, it is also callable (then it just sleeps)
72 
73     Args:
74         delay: seconds to delay
75 
76     Raises:
77         ValueError: if delay is negative
78     """
79     def __init__(self, delay):
80         if not delay >= 0:
81             raise ValueError('delay must be > 0, not {}'.format(repr(delay)))
82         self.delay = delay
83 
84     def __call__(self):
85         if self.delay:
86             time.sleep(self.delay)
87 
88     def snapshot(self, update=False):
89         """
90         Snapshots  delay
91         Args:
92             update (bool): TODO not in use
93 
94         Returns:
95             dict: snapshot
96         """
97         return {'type': 'Wait', 'delay': self.delay}
98 
99 
100 class _Measure:
101     """
102     A callable collection of parameters to measure.
103 
104     This should not be constructed manually, only by an ActiveLoop.
105     """
106     def __init__(self, params_indices, data_set, use_threads):
107         self.use_threads = use_threads and len(params_indices) > 1
108         # the applicable DataSet.store function
109         self.store = data_set.store
110 
111         # for performance, pre-calculate which params return data for
112         # multiple arrays, and the name mappings
113         self.getters = []
114         self.param_ids = []
115         self.composite = []
116         for param, action_indices in params_indices:
117             self.getters.append(param.get)
118 
119             if hasattr(param, 'names'):
120                 part_ids = []
121                 for i in range(len(param.names)):
122                     param_id = data_set.action_id_map[action_indices + (i,)]
123                     part_ids.append(param_id)
124                 self.param_ids.append(None)
125                 self.composite.append(part_ids)
126             else:
127                 param_id = data_set.action_id_map[action_indices]
128                 self.param_ids.append(param_id)
129                 self.composite.append(False)
130 
131     def __call__(self, loop_indices, **ignore_kwargs):
132         out_dict = {}
133         if self.use_threads:
134             out = thread_map(self.getters)
135         else:
136             out = [g() for g in self.getters]
137 
138         for param_out, param_id, composite in zip(out, self.param_ids,
139                                                   self.composite):
140             if composite:
141                 for val, part_id in zip(param_out, composite):
142                     out_dict[part_id] = val
143             else:
144                 out_dict[param_id] = param_out
145 
146         self.store(loop_indices, out_dict)
147 
148 
149 class _Nest:
150 
151     """
152     Wrapper to make a callable nested ActiveLoop.
153 
154     This should not be constructed manually, only by an ActiveLoop.
155     """
156 
157     def __init__(self, inner_loop, action_indices):
158         self.inner_loop = inner_loop
159         self.action_indices = action_indices
160 
161     def __call__(self, **kwargs):
162         self.inner_loop._run_loop(action_indices=self.action_indices, **kwargs)
163 
164 
165 class BreakIf:
166 
167     """
168     Loop action that breaks out of the loop if a condition is truthy.
169     
170     Args:
171         condition (callable): a callable taking no arguments.
172             Can be a simple function that returns truthy when it's time to quit
173             May also be constructed by deferred operations on `Parameter`.
174     Raises:
175         TypeError: if condition is not a callable with no aguments.
176 
177     Examples:
178             >>> BreakIf(gates.chan1 >= 3)
179             >>> BreakIf(abs(source.I * source.V) >= source.power_limit.get_latest)
180     """
181 
182     def __init__(self, condition):
183         if not is_function(condition, 0):
184             raise TypeError('BreakIf condition must be a callable with '
185                             'no arguments')
186         self.condition = condition
187 
188     def __call__(self, **ignore_kwargs):
189         if self.condition():
190             raise _QcodesBreak
191 
192     def snapshot(self, update=False):
193         # TODO: make nice reprs for DeferredOperations
194         """
195         Snapshots breakif action
196         Args:
197             update (bool): TODO not in use
198 
199         Returns:
200             dict: snapshot
201 
202         """
203         return {'type': 'BreakIf', 'condition': repr(self.condition)}
204 
205 
206 class _QcodesBreak(Exception):
207     pass
208
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/qcodes/actions.py b/qcodes/actions.py
--- a/qcodes/actions.py
+++ b/qcodes/actions.py
@@ -8,6 +8,12 @@
 _NO_SNAPSHOT = {'type': None, 'description': 'Action without snapshot'}
 
 
+# exception when threading is attempted used to simultaneously
+# query the same instrument for several values
+class UnsafeThreadingException(Exception):
+    pass
+
+
 def _actions_snapshot(actions, update):
     """Make a list of snapshots from a list of actions."""
     snapshot = []
@@ -113,9 +119,13 @@
         self.getters = []
         self.param_ids = []
         self.composite = []
+        paramcheck = []  # list to check if parameters are unique
         for param, action_indices in params_indices:
             self.getters.append(param.get)
 
+            if param._instrument:
+                paramcheck.append((param, param._instrument))
+
             if hasattr(param, 'names'):
                 part_ids = []
                 for i in range(len(param.names)):
@@ -128,6 +138,17 @@
                 self.param_ids.append(param_id)
                 self.composite.append(False)
 
+        if self.use_threads:
+            insts = [p[1] for p in paramcheck]
+            if (len(set(insts)) != len(insts)):
+                duplicates = [p for p in paramcheck if insts.count(p[1]) > 1]
+                raise UnsafeThreadingException('Can not use threading to '
+                                               'read '
+                                               'several things from the same '
+                                               'instrument. Specifically, you '
+                                               'asked for'
+                                               ' {}.'.format(duplicates))
+
     def __call__(self, loop_indices, **ignore_kwargs):
         out_dict = {}
         if self.use_threads:
@@ -166,7 +187,7 @@
 
     """
     Loop action that breaks out of the loop if a condition is truthy.
-    
+
     Args:
         condition (callable): a callable taking no arguments.
             Can be a simple function that returns truthy when it's time to quit

{"golden_diff": "diff --git a/qcodes/actions.py b/qcodes/actions.py\n--- a/qcodes/actions.py\n+++ b/qcodes/actions.py\n@@ -8,6 +8,12 @@\n _NO_SNAPSHOT = {'type': None, 'description': 'Action without snapshot'}\n \n \n+# exception when threading is attempted used to simultaneously\n+# query the same instrument for several values\n+class UnsafeThreadingException(Exception):\n+    pass\n+\n+\n def _actions_snapshot(actions, update):\n     \"\"\"Make a list of snapshots from a list of actions.\"\"\"\n     snapshot = []\n@@ -113,9 +119,13 @@\n         self.getters = []\n         self.param_ids = []\n         self.composite = []\n+        paramcheck = []  # list to check if parameters are unique\n         for param, action_indices in params_indices:\n             self.getters.append(param.get)\n \n+            if param._instrument:\n+                paramcheck.append((param, param._instrument))\n+\n             if hasattr(param, 'names'):\n                 part_ids = []\n                 for i in range(len(param.names)):\n@@ -128,6 +138,17 @@\n                 self.param_ids.append(param_id)\n                 self.composite.append(False)\n \n+        if self.use_threads:\n+            insts = [p[1] for p in paramcheck]\n+            if (len(set(insts)) != len(insts)):\n+                duplicates = [p for p in paramcheck if insts.count(p[1]) > 1]\n+                raise UnsafeThreadingException('Can not use threading to '\n+                                               'read '\n+                                               'several things from the same '\n+                                               'instrument. Specifically, you '\n+                                               'asked for'\n+                                               ' {}.'.format(duplicates))\n+\n     def __call__(self, loop_indices, **ignore_kwargs):\n         out_dict = {}\n         if self.use_threads:\n@@ -166,7 +187,7 @@\n \n     \"\"\"\n     Loop action that breaks out of the loop if a condition is truthy.\n-    \n+\n     Args:\n         condition (callable): a callable taking no arguments.\n             Can be a simple function that returns truthy when it's time to quit\n", "issue": "Data mingled across columns in dataset\n### Steps to reproduce\r\n1. Measure something with `.run(use_threads=True)`\r\n\r\n### Expected behaviour\r\nGet a neat dataset\r\n\r\n### Actual behaviour\r\nData mingles across columns in dataset \ud83d\udc98 \r\n\r\n### System\r\n**operating system**\r\nWin 10\r\n\r\n**qcodes branch**\r\nMaster\r\n\r\nTwo identical measurements:\r\n![image](https://cloud.githubusercontent.com/assets/8595386/26193146/99b0d318-3bb4-11e7-9e93-473d782fe41b.png)\r\n\r\n\n", "before_files": [{"content": "\"\"\"Actions, mainly to be executed in measurement Loops.\"\"\"\nimport time\n\nfrom qcodes.utils.deferred_operations import is_function\nfrom qcodes.utils.threading import thread_map\n\n\n_NO_SNAPSHOT = {'type': None, 'description': 'Action without snapshot'}\n\n\ndef _actions_snapshot(actions, update):\n    \"\"\"Make a list of snapshots from a list of actions.\"\"\"\n    snapshot = []\n    for action in actions:\n        if hasattr(action, 'snapshot'):\n            snapshot.append(action.snapshot(update=update))\n        else:\n            snapshot.append(_NO_SNAPSHOT)\n    return snapshot\n\n\nclass Task:\n    \"\"\"\n    A predefined task to be executed within a measurement Loop.\n\n    The first argument should be a callable, to which any subsequent\n    args and kwargs (which are evaluated before the loop starts) are passed.\n\n    The args and kwargs are first evaluated if they are found to be callable.\n\n    Keyword Args passed when the Task is called are ignored,\n    but are accepted for compatibility with other things happening in a Loop.\n\n    Args:\n        func (callable): Function to executed\n        *args: pass to func, after evaluation if callable\n        **kwargs: pass to func, after evaluation if callable\n\n    \"\"\"\n    def __init__(self, func, *args, **kwargs):\n        self.func = func\n        self.args = args\n        self.kwargs = kwargs\n\n    def __call__(self, **ignore_kwargs):\n        # If any of the arguments are callable, evaluate them first\n        eval_args = [arg() if callable(arg) else arg for arg in self.args]\n        eval_kwargs = {k: (v() if callable(v) else v) for k, v in self.kwargs.items()}\n\n        self.func(*eval_args, **eval_kwargs)\n\n    def snapshot(self, update=False):\n        \"\"\"\n        Snapshots  task\n        Args:\n            update (bool): TODO not in use\n\n        Returns:\n            dict: snapshot\n        \"\"\"\n        return {'type': 'Task', 'func': repr(self.func)}\n\n\nclass Wait:\n    \"\"\"\n    A simple class to tell a Loop to wait <delay> seconds.\n\n    This is transformed into a Task within the Loop, such that\n    it can do other things (monitor, check for halt) during the delay.\n\n    But for use outside of a Loop, it is also callable (then it just sleeps)\n\n    Args:\n        delay: seconds to delay\n\n    Raises:\n        ValueError: if delay is negative\n    \"\"\"\n    def __init__(self, delay):\n        if not delay >= 0:\n            raise ValueError('delay must be > 0, not {}'.format(repr(delay)))\n        self.delay = delay\n\n    def __call__(self):\n        if self.delay:\n            time.sleep(self.delay)\n\n    def snapshot(self, update=False):\n        \"\"\"\n        Snapshots  delay\n        Args:\n            update (bool): TODO not in use\n\n        Returns:\n            dict: snapshot\n        \"\"\"\n        return {'type': 'Wait', 'delay': self.delay}\n\n\nclass _Measure:\n    \"\"\"\n    A callable collection of parameters to measure.\n\n    This should not be constructed manually, only by an ActiveLoop.\n    \"\"\"\n    def __init__(self, params_indices, data_set, use_threads):\n        self.use_threads = use_threads and len(params_indices) > 1\n        # the applicable DataSet.store function\n        self.store = data_set.store\n\n        # for performance, pre-calculate which params return data for\n        # multiple arrays, and the name mappings\n        self.getters = []\n        self.param_ids = []\n        self.composite = []\n        for param, action_indices in params_indices:\n            self.getters.append(param.get)\n\n            if hasattr(param, 'names'):\n                part_ids = []\n                for i in range(len(param.names)):\n                    param_id = data_set.action_id_map[action_indices + (i,)]\n                    part_ids.append(param_id)\n                self.param_ids.append(None)\n                self.composite.append(part_ids)\n            else:\n                param_id = data_set.action_id_map[action_indices]\n                self.param_ids.append(param_id)\n                self.composite.append(False)\n\n    def __call__(self, loop_indices, **ignore_kwargs):\n        out_dict = {}\n        if self.use_threads:\n            out = thread_map(self.getters)\n        else:\n            out = [g() for g in self.getters]\n\n        for param_out, param_id, composite in zip(out, self.param_ids,\n                                                  self.composite):\n            if composite:\n                for val, part_id in zip(param_out, composite):\n                    out_dict[part_id] = val\n            else:\n                out_dict[param_id] = param_out\n\n        self.store(loop_indices, out_dict)\n\n\nclass _Nest:\n\n    \"\"\"\n    Wrapper to make a callable nested ActiveLoop.\n\n    This should not be constructed manually, only by an ActiveLoop.\n    \"\"\"\n\n    def __init__(self, inner_loop, action_indices):\n        self.inner_loop = inner_loop\n        self.action_indices = action_indices\n\n    def __call__(self, **kwargs):\n        self.inner_loop._run_loop(action_indices=self.action_indices, **kwargs)\n\n\nclass BreakIf:\n\n    \"\"\"\n    Loop action that breaks out of the loop if a condition is truthy.\n    \n    Args:\n        condition (callable): a callable taking no arguments.\n            Can be a simple function that returns truthy when it's time to quit\n            May also be constructed by deferred operations on `Parameter`.\n    Raises:\n        TypeError: if condition is not a callable with no aguments.\n\n    Examples:\n            >>> BreakIf(gates.chan1 >= 3)\n            >>> BreakIf(abs(source.I * source.V) >= source.power_limit.get_latest)\n    \"\"\"\n\n    def __init__(self, condition):\n        if not is_function(condition, 0):\n            raise TypeError('BreakIf condition must be a callable with '\n                            'no arguments')\n        self.condition = condition\n\n    def __call__(self, **ignore_kwargs):\n        if self.condition():\n            raise _QcodesBreak\n\n    def snapshot(self, update=False):\n        # TODO: make nice reprs for DeferredOperations\n        \"\"\"\n        Snapshots breakif action\n        Args:\n            update (bool): TODO not in use\n\n        Returns:\n            dict: snapshot\n\n        \"\"\"\n        return {'type': 'BreakIf', 'condition': repr(self.condition)}\n\n\nclass _QcodesBreak(Exception):\n    pass\n", "path": "qcodes/actions.py"}], "after_files": [{"content": "\"\"\"Actions, mainly to be executed in measurement Loops.\"\"\"\nimport time\n\nfrom qcodes.utils.deferred_operations import is_function\nfrom qcodes.utils.threading import thread_map\n\n\n_NO_SNAPSHOT = {'type': None, 'description': 'Action without snapshot'}\n\n\n# exception when threading is attempted used to simultaneously\n# query the same instrument for several values\nclass UnsafeThreadingException(Exception):\n    pass\n\n\ndef _actions_snapshot(actions, update):\n    \"\"\"Make a list of snapshots from a list of actions.\"\"\"\n    snapshot = []\n    for action in actions:\n        if hasattr(action, 'snapshot'):\n            snapshot.append(action.snapshot(update=update))\n        else:\n            snapshot.append(_NO_SNAPSHOT)\n    return snapshot\n\n\nclass Task:\n    \"\"\"\n    A predefined task to be executed within a measurement Loop.\n\n    The first argument should be a callable, to which any subsequent\n    args and kwargs (which are evaluated before the loop starts) are passed.\n\n    The args and kwargs are first evaluated if they are found to be callable.\n\n    Keyword Args passed when the Task is called are ignored,\n    but are accepted for compatibility with other things happening in a Loop.\n\n    Args:\n        func (callable): Function to executed\n        *args: pass to func, after evaluation if callable\n        **kwargs: pass to func, after evaluation if callable\n\n    \"\"\"\n    def __init__(self, func, *args, **kwargs):\n        self.func = func\n        self.args = args\n        self.kwargs = kwargs\n\n    def __call__(self, **ignore_kwargs):\n        # If any of the arguments are callable, evaluate them first\n        eval_args = [arg() if callable(arg) else arg for arg in self.args]\n        eval_kwargs = {k: (v() if callable(v) else v) for k, v in self.kwargs.items()}\n\n        self.func(*eval_args, **eval_kwargs)\n\n    def snapshot(self, update=False):\n        \"\"\"\n        Snapshots  task\n        Args:\n            update (bool): TODO not in use\n\n        Returns:\n            dict: snapshot\n        \"\"\"\n        return {'type': 'Task', 'func': repr(self.func)}\n\n\nclass Wait:\n    \"\"\"\n    A simple class to tell a Loop to wait <delay> seconds.\n\n    This is transformed into a Task within the Loop, such that\n    it can do other things (monitor, check for halt) during the delay.\n\n    But for use outside of a Loop, it is also callable (then it just sleeps)\n\n    Args:\n        delay: seconds to delay\n\n    Raises:\n        ValueError: if delay is negative\n    \"\"\"\n    def __init__(self, delay):\n        if not delay >= 0:\n            raise ValueError('delay must be > 0, not {}'.format(repr(delay)))\n        self.delay = delay\n\n    def __call__(self):\n        if self.delay:\n            time.sleep(self.delay)\n\n    def snapshot(self, update=False):\n        \"\"\"\n        Snapshots  delay\n        Args:\n            update (bool): TODO not in use\n\n        Returns:\n            dict: snapshot\n        \"\"\"\n        return {'type': 'Wait', 'delay': self.delay}\n\n\nclass _Measure:\n    \"\"\"\n    A callable collection of parameters to measure.\n\n    This should not be constructed manually, only by an ActiveLoop.\n    \"\"\"\n    def __init__(self, params_indices, data_set, use_threads):\n        self.use_threads = use_threads and len(params_indices) > 1\n        # the applicable DataSet.store function\n        self.store = data_set.store\n\n        # for performance, pre-calculate which params return data for\n        # multiple arrays, and the name mappings\n        self.getters = []\n        self.param_ids = []\n        self.composite = []\n        paramcheck = []  # list to check if parameters are unique\n        for param, action_indices in params_indices:\n            self.getters.append(param.get)\n\n            if param._instrument:\n                paramcheck.append((param, param._instrument))\n\n            if hasattr(param, 'names'):\n                part_ids = []\n                for i in range(len(param.names)):\n                    param_id = data_set.action_id_map[action_indices + (i,)]\n                    part_ids.append(param_id)\n                self.param_ids.append(None)\n                self.composite.append(part_ids)\n            else:\n                param_id = data_set.action_id_map[action_indices]\n                self.param_ids.append(param_id)\n                self.composite.append(False)\n\n        if self.use_threads:\n            insts = [p[1] for p in paramcheck]\n            if (len(set(insts)) != len(insts)):\n                duplicates = [p for p in paramcheck if insts.count(p[1]) > 1]\n                raise UnsafeThreadingException('Can not use threading to '\n                                               'read '\n                                               'several things from the same '\n                                               'instrument. Specifically, you '\n                                               'asked for'\n                                               ' {}.'.format(duplicates))\n\n    def __call__(self, loop_indices, **ignore_kwargs):\n        out_dict = {}\n        if self.use_threads:\n            out = thread_map(self.getters)\n        else:\n            out = [g() for g in self.getters]\n\n        for param_out, param_id, composite in zip(out, self.param_ids,\n                                                  self.composite):\n            if composite:\n                for val, part_id in zip(param_out, composite):\n                    out_dict[part_id] = val\n            else:\n                out_dict[param_id] = param_out\n\n        self.store(loop_indices, out_dict)\n\n\nclass _Nest:\n\n    \"\"\"\n    Wrapper to make a callable nested ActiveLoop.\n\n    This should not be constructed manually, only by an ActiveLoop.\n    \"\"\"\n\n    def __init__(self, inner_loop, action_indices):\n        self.inner_loop = inner_loop\n        self.action_indices = action_indices\n\n    def __call__(self, **kwargs):\n        self.inner_loop._run_loop(action_indices=self.action_indices, **kwargs)\n\n\nclass BreakIf:\n\n    \"\"\"\n    Loop action that breaks out of the loop if a condition is truthy.\n\n    Args:\n        condition (callable): a callable taking no arguments.\n            Can be a simple function that returns truthy when it's time to quit\n            May also be constructed by deferred operations on `Parameter`.\n    Raises:\n        TypeError: if condition is not a callable with no aguments.\n\n    Examples:\n            >>> BreakIf(gates.chan1 >= 3)\n            >>> BreakIf(abs(source.I * source.V) >= source.power_limit.get_latest)\n    \"\"\"\n\n    def __init__(self, condition):\n        if not is_function(condition, 0):\n            raise TypeError('BreakIf condition must be a callable with '\n                            'no arguments')\n        self.condition = condition\n\n    def __call__(self, **ignore_kwargs):\n        if self.condition():\n            raise _QcodesBreak\n\n    def snapshot(self, update=False):\n        # TODO: make nice reprs for DeferredOperations\n        \"\"\"\n        Snapshots breakif action\n        Args:\n            update (bool): TODO not in use\n\n        Returns:\n            dict: snapshot\n\n        \"\"\"\n        return {'type': 'BreakIf', 'condition': repr(self.condition)}\n\n\nclass _QcodesBreak(Exception):\n    pass\n", "path": "qcodes/actions.py"}]}