Debian Codegraph @

pymeasure/display/manager.py

raw
1 #
2 # This file is part of the PyMeasure package.
3 #
4 # Copyright (c) 2013-2024 PyMeasure Developers
5 #
6 # Permission is hereby granted, free of charge, to any person obtaining a copy
7 # of this software and associated documentation files (the "Software"), to deal
8 # in the Software without restriction, including without limitation the rights
9 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 # copies of the Software, and to permit persons to whom the Software is
11 # furnished to do so, subject to the following conditions:
12 #
13 # The above copyright notice and this permission notice shall be included in
14 # all copies or substantial portions of the Software.
15 #
16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 # THE SOFTWARE.
23 #
24
25 import logging
26
27 from os.path import basename
28
29 from .Qt import QtCore
30 from .listeners import Monitor
31 from ..experiment import Procedure
32 from ..experiment.workers import Worker
33
34 log = logging.getLogger(__name__)
35 log.addHandler(logging.NullHandler())
36
37
38 class Experiment(QtCore.QObject):
39 """ The Experiment class helps group the :class:`.Procedure`,
40 :class:`.Results`, and their display functionality. Its function
41 is only a convenient container.
42
43 :param results: :class:`.Results` object
44 :param curve_list: :class:`.ResultsCurve` list. List of curves associated with
45 an experiment. They could represent different views of the same experiment. Not required
46 for `.ManagedConsole` displayed experiments.
47 :param browser_item: :class:`.BaseBrowserItem` based object
48 """
49
50 def __init__(self, results, curve_list=None, browser_item=None, parent=None):
51 super().__init__(parent)
52 self.results = results
53 self.data_filename = self.results.data_filename
54 self.procedure = self.results.procedure
55 self.curve_list = curve_list
56 self.browser_item = browser_item
57
58
59 class ExperimentQueue(QtCore.QObject):
60 """ Represents a queue of Experiments and allows queries to
61 be easily preformed.
62 """
63
64 def __init__(self):
65 super().__init__()
66 self.queue = []
67
68 def append(self, experiment):
69 self.queue.append(experiment)
70
71 def remove(self, experiment):
72 if experiment not in self.queue:
73 raise Exception("Attempting to remove an Experiment that is "
74 "not in the ExperimentQueue")
75 else:
76 if experiment.procedure.status == Procedure.RUNNING:
77 raise Exception("Attempting to remove a running experiment")
78 else:
79 self.queue.pop(self.queue.index(experiment))
80
81 def __contains__(self, value):
82 if isinstance(value, Experiment):
83 return value in self.queue
84 if isinstance(value, str):
85 for experiment in self.queue:
86 if basename(experiment.data_filename) == basename(value):
87 return True
88 return False
89 return False
90
91 def __getitem__(self, key):
92 return self.queue[key]
93
94 def next(self):
95 """ Returns the next experiment on the queue
96 """
97 for experiment in self.queue:
98 if experiment.procedure.status == Procedure.QUEUED:
99 return experiment
100 raise StopIteration("There are no queued experiments")
101
102 def has_next(self):
103 """ Returns True if another item is on the queue
104 """
105 try:
106 self.next()
107 except StopIteration:
108 return False
109
110 return True
111
112 def with_browser_item(self, item):
113 for experiment in self.queue:
114 if experiment.browser_item is item:
115 return experiment
116 return None
117
118
119 class BaseManager(QtCore.QObject):
120 """Controls the execution of :class:`.Experiment` classes by implementing
121 a queue system in which Experiments are added, removed, executed, or
122 aborted.
123 """
124 _is_continuous = True
125 _start_on_add = True
126 queued = QtCore.Signal(object)
127 running = QtCore.Signal(object)
128 finished = QtCore.Signal(object)
129 failed = QtCore.Signal(object)
130 aborted = QtCore.Signal(object)
131 abort_returned = QtCore.Signal(object)
132 log = QtCore.Signal(object)
133
134 def __init__(self, port=5888, log_level=logging.INFO, parent=None):
135 super().__init__(parent)
136
137 self.experiments = ExperimentQueue()
138 self._worker = None
139 self._running_experiment = None
140 self._monitor = None
141 self.log_level = log_level
142
143 self.port = port
144
145 def is_running(self):
146 """ Returns True if a procedure is currently running
147 """
148 return self._running_experiment is not None
149
150 def running_experiment(self):
151 if self.is_running():
152 return self._running_experiment
153 else:
154 raise Exception("There is no Experiment running")
155
156 def _update_progress(self, progress):
157 if self.is_running():
158 self._running_experiment.browser_item.setProgress(progress)
159
160 def _update_status(self, status):
161 if self.is_running():
162 self._running_experiment.procedure.status = status
163 self._running_experiment.browser_item.setStatus(status)
164
165 def _update_log(self, record):
166 self.log.emit(record)
167
168 def load(self, experiment):
169 """ Load a previously executed Experiment
170 """
171 self.experiments.append(experiment)
172
173 def queue(self, experiment):
174 """ Adds an experiment to the queue.
175 """
176 self.load(experiment)
177 self.queued.emit(experiment)
178 if self._start_on_add and not self.is_running():
179 self.next()
180
181 def remove(self, experiment):
182 """ Removes an Experiment
183 """
184 self.experiments.remove(experiment)
185
186 def clear(self):
187 """ Remove all Experiments
188 """
189 for experiment in self.experiments[:]:
190 self.remove(experiment)
191
192 def next(self):
193 """ Initiates the start of the next experiment in the queue as long
194 as no other experiments are currently running and there is a procedure
195 in the queue.
196 """
197 if self.is_running():
198 raise Exception("Another procedure is already running")
199 else:
200 if self.experiments.has_next():
201 log.debug("Manager is initiating the next experiment")
202 experiment = self.experiments.next()
203 self._running_experiment = experiment
204
205 self._worker = Worker(experiment.results, port=self.port, log_level=self.log_level)
206
207 self._monitor = Monitor(self._worker.monitor_queue)
208 self._monitor.worker_running.connect(self._running)
209 self._monitor.worker_failed.connect(self._failed)
210 self._monitor.worker_abort_returned.connect(self._abort_returned)
211 self._monitor.worker_finished.connect(self._finish)
212 self._monitor.progress.connect(self._update_progress)
213 self._monitor.status.connect(self._update_status)
214 self._monitor.log.connect(self._update_log)
215
216 self._monitor.start()
217 self._worker.start()
218
219 def _running(self):
220 if self.is_running():
221 self.running.emit(self._running_experiment)
222
223 def _clean_up(self):
224 self._worker.join()
225 del self._worker
226 self._monitor.wait()
227 del self._monitor
228 self._worker = None
229 self._running_experiment = None
230 log.debug("Manager has cleaned up after the Worker")
231
232 def _failed(self):
233 log.debug("Manager's running experiment has failed")
234 experiment = self._running_experiment
235 self._clean_up()
236 self.failed.emit(experiment)
237
238 def _abort_returned(self):
239 log.debug("Manager's running experiment has returned after an abort")
240 experiment = self._running_experiment
241 self._clean_up()
242 self.abort_returned.emit(experiment)
243
244 def _finish(self):
245 log.debug("Manager's running experiment has finished")
246 experiment = self._running_experiment
247 self._clean_up()
248 experiment.browser_item.setProgress(100)
249 self.finished.emit(experiment)
250 if self._is_continuous: # Continue running procedures
251 self.next()
252
253 def resume(self):
254 """ Resume processing of the queue.
255 """
256 self._start_on_add = True
257 self._is_continuous = True
258 self.next()
259
260 def abort(self):
261 """ Aborts the currently running Experiment, but raises an exception if
262 there is no running experiment
263 """
264 if not self.is_running():
265 raise Exception("Attempting to abort when no experiment "
266 "is running")
267 else:
268 self._start_on_add = False
269 self._is_continuous = False
270
271 self._worker.stop()
272
273 self.aborted.emit(self._running_experiment)
274
275
276 class Manager(BaseManager):
277 """Controls the execution of :class:`.Experiment` classes by implementing
278 a queue system in which Experiments are added, removed, executed, or
279 aborted. When instantiated, the Manager is linked to a :class:`.Browser`
280 and a PyQtGraph `PlotItem` within the user interface, which are updated
281 in accordance with the execution status of the Experiments.
282 """
283
284 def __init__(self, widget_list, browser, port=5888, log_level=logging.INFO, parent=None):
285 super().__init__(parent)
286
287 self.experiments = ExperimentQueue()
288 self._worker = None
289 self._running_experiment = None
290 self._monitor = None
291 self.log_level = log_level
292
293 self.widget_list = widget_list
294 self.browser = browser
295
296 self.port = port
297
298 def load(self, experiment):
299 """ Load a previously executed Experiment
300 """
301
302 super().load(experiment)
303 self.browser.add(experiment)
304 for curve in experiment.curve_list:
305 if curve:
306 curve.wdg.load(curve)
307
308 def remove(self, experiment):
309 """ Removes an Experiment
310 """
311 super().remove(experiment)
312
313 self.browser.takeTopLevelItem(
314 self.browser.indexOfTopLevelItem(experiment.browser_item))
315
316 for curve in experiment.curve_list:
317 if curve:
318 curve.wdg.remove(curve)
319
320 def _finish(self):
321 log.debug("Manager's running experiment has finished")
322 experiment = self._running_experiment
323 self._clean_up()
324 experiment.browser_item.setProgress(100)
325 for curve in experiment.curve_list:
326 if curve:
327 curve.update_data()
328 self.finished.emit(experiment)
329 if self._is_continuous: # Continue running procedures
330 self.next()