def quit(self, signum=None): if self._setup is None: return self._quit_master(signum) if self._stoprequest: return # already quitting self.log.info('poller quitting on signal %s...', signum) self._stoprequest = True for worker in itervalues(self._workers): worker.queue.put('quit', False) # wake up to quit for worker in itervalues(self._workers): worker.join() self.log.info('poller finished')
def setCustomStyle(self, font, back): self.user_font = font self.user_color = back for plot in itervalues(self.setplots): plot.setBackgroundColor(back) plot.update() bold = QFont(font) bold.setBold(True) larger = scaledFont(font, 1.6) for plot in itervalues(self.setplots): plot.setFonts(font, bold, larger)
def _update_proposal_info(self): values = self.client.eval( 'session.experiment.proposal, ' 'session.experiment.title, ' 'session.experiment.users, ' 'session.experiment.localcontact, ' 'session.experiment.sample.samplename, ' 'session.experiment.errorbehavior', None) if values: self._orig_proposal_info = values self.proposalNum.setText(values[0]) self.expTitle.setText(decodeAny(values[1])) self.users.setText(decodeAny(values[2])) self.localContact.setText(decodeAny(values[3])) self.sampleName.setText(decodeAny(values[4])) self.errorAbortBox.setChecked(values[5] == 'abort') receiverinfo = self.client.eval( '__import__("nicos").commands.basic._listReceivers(' '"nicos.devices.notifiers.Mailer")', {}) emails = [] for data in itervalues(receiverinfo): for (addr, what) in data: if what == 'receiver' and addr not in emails: emails.append(addr) self._orig_email = emails self.notifEmails.setPlainText(decodeAny('\n'.join(self._orig_email))) propinfo = self.client.eval('session.experiment.propinfo', {}) self._orig_datamails = propinfo.get('user_email', '') if not isinstance(self._orig_datamails, list): self._orig_datamails = self._orig_datamails.splitlines() self.dataEmails.setPlainText(decodeAny('\n'.join( self._orig_datamails)))
def info(*devlist): """Print general information of the given device or all devices. Information is the device value, status and any other parameters that are marked as "interesting" by giving them a category. Examples: >>> info() # show all information >>> info(Sample) # show information relevant to the Sample object """ if not devlist: devlist = [ dev for dev in itervalues(session.devices) if not dev.lowlevel ] bycategory = {} for dev in devlist: for key, _value, strvalue, unit, category in dev.info(): bycategory.setdefault(category, []).append( (str(dev), key + ':', strvalue + ' ' + unit)) for catname, catinfo in INFO_CATEGORIES: if catname not in bycategory: continue session.log.info(catinfo) session.log.info('=' * len(catinfo)) printTable(None, sorted(bycategory[catname]), session.log.info, minlen=8) session.log.info()
def on_client_connected(self): self.clear() state = self.client.ask('getstatus') if not state: return devlist = state['devices'] self._read_setup_info(state['setups']) for devname in devlist: self._create_device_item(devname) # close all control dialogs for now nonexisting devices for ldevname in list(self._control_dialogs): if ldevname not in self._devitems: self._control_dialogs[ldevname].close() # add all toplevel items to the tree, sorted for cat in self._catitems: self.tree.addTopLevelItem(self._catitems[cat]) self._catitems[cat].setExpanded(True) for devitem in itervalues(self._devitems): devitem.setExpanded(True) self.tree.sortItems(0, Qt.AscendingOrder) self._update_view()
def wait(self): if self._setup is None: if os.name == 'nt': return self._wait_master_nt() return self._wait_master() while not self._stoprequest: sleep(1) for worker in itervalues(self._workers): worker.join()
def resolve_devindex(app, doctree, fromdocname): env = app.builder.env for indexnode in doctree.traverse(device_index): table = nodes.table('') group = nodes.tgroup('', nodes.colspec('', colwidth=30), nodes.colspec('', colwidth=30), nodes.colspec('', colwidth=30), cols=3) table.append(group) group.append( nodes.thead( '', nodes.row( '', nodes.entry('', nodes.paragraph('', 'Class')), nodes.entry('', nodes.paragraph('', 'Module')), nodes.entry('', nodes.paragraph('', 'Description')), ))) body = nodes.tbody('') group.append(body) for entry in sorted(itervalues(env.nicos_all_devices), key=lambda v: v['name']): if not entry['module'].startswith('nicos.devices.'): continue row = nodes.row('') reftgt = '%s.%s' % (entry['module'], entry['name']) node = nodes.paragraph( '', '', addnodes.pending_xref('', nodes.Text(entry['name']), refdomain='py', reftype='class', reftarget=reftgt)) env.resolve_references(node, fromdocname, app.builder) row.append(nodes.entry('', node)) row.append( nodes.entry( '', nodes.paragraph('', '', nodes.literal('', entry['module'][6:])))) row.append(nodes.entry('', nodes.paragraph('', entry['blurb']))) body.append(row) indexnode.replace_self([table])
def __new__(mcs, name, bases, attrs): # set source class for parameters if 'parameters' in attrs: for pinfo in itervalues(attrs['parameters']): pinfo.classname = attrs['__module__'] + '.' + name for base in bases: if hasattr(base, 'parameters'): for pinfo in itervalues(base.parameters): if pinfo.classname is None: pinfo.classname = base.__module__ + '.' + base.__name__ newtype = type.__new__(mcs, name, bases, attrs) if '__constructed__' in attrs: return newtype for entry in newtype.__mergedattrs__: newentry = {} for base in reversed(bases): if hasattr(base, entry): newentry.update(getattr(base, entry)) newentry.update(attrs.get(entry, {})) setattr(newtype, entry, newentry) # add usermethods to registry, check names of methods to comply with # coding style for aname in attrs: if aname.startswith(('_', 'do')): continue value = getattr(newtype, aname) if not isinstance(value, (types.FunctionType, types.MethodType)): continue args = formatArgs(value, strip_self=True) if value.__doc__: docline = value.__doc__.strip().splitlines()[0] else: docline = '' newtype.methods[aname] = (args, docline, newtype, hasattr(value, 'is_usermethod')) return newtype
def setall(param, value): """Set the given parameter to the given value for all devices that have it. Example: >>> setall('offset', 0) set the offset for all devices to zero. """ for dev in itervalues(session.devices): if param not in dev.parameters: continue prevalue = getattr(dev, param) setattr(dev, param, value) dev.log.info('%s set to %r (was %r)', param, value, prevalue)
def statusinfo(self): self.log.info('got SIGUSR2') if self._setup is not None: info = [] for worker in itervalues(self._workers): wname = worker.getName() if worker.is_alive(): info.append('%s: alive' % wname) else: info.append('%s: dead' % wname) self.log.info(', '.join(info)) self.log.info('current stacktraces for each thread:') active = threading._active for tid, frame in listitems(sys._current_frames()): if tid in active: name = active[tid].getName() else: name = str(tid) self.log.info('%s: %s', name, ''.join(traceback.format_stack(frame)))
def _handle_control_msg(self, key, value, time, expired): if key == 'watchdog/enable': time = currenttime() for (eid, enabled) in value[1]: entry = self._entries.get(eid) if entry: entry.cond_obj.enabled = enabled entry.cond_obj.update(time, self._keydict) self._check_state(entry, time) self.log.info('updated enabled conditions by user request') elif key == 'watchdog/reset': # reset all condition enables to their initial state # (e.g. due to NewExperiment) for entry in itervalues(self._entries): if entry.enabled != entry.cond_obj.enabled: entry.cond_obj.enabled = entry.enabled entry.cond_obj.update(time, self._keydict) self._check_state(entry, time) self.log.info('enable status of all conditions reset') self._publish_config()
def ExportTuning(mode, wavelength, filename='tuning'): """Export tuning for *mode* and *wavelength* to a CSV file. Mode can be "nrse" or "mieze". """ echotime = session.getDevice('echotime') exp = session.getDevice('Exp') # get the right table try: tables = echotime.tables[mode] except KeyError: printerror('Need a valid mode (mieze or nrse)') return try: table = tables[wavelength] except KeyError: printerror('No table for this wavelength (available: %s)' % ', '.join(map(str, tables))) # build list of devices it = itervalues(table) devices = sorted(it.next()) for otherdevs in it: devices.extend(set(otherdevs) - set(devices)) # export to CSV filename = path.join(exp.dataroot, filename + '_%s_%sA.csv' % (mode, wavelength)) printinfo('Exporting to %s' % filename) if path.exists(filename): printerror('File already exists. Please select another name.') return with open(filename, 'w') as fp: writer = csv.writer(fp) writer.writerow(['echotime'] + devices) for (etime, devs) in iteritems(table): writer.writerow([repr(etime)] + [repr(devs.get(d)) for d in devices]) printinfo('Done.')
def _setups_updated(self, time, new_setups): prev_setups, self._setups = self._setups, new_setups # check if we need to remove some conditions for entry in listvalues(self._entries): if entry.from_setup != 'watchdog': if entry.from_setup not in self._setups: self._remove_entry(entry.id) # check if we need to add some conditions session.readSetups() # refresh setup info for new_setup in self._setups - prev_setups: info = session._setup_info.get(new_setup) if info and info['watch_conditions']: self.log.info('adding conditions from setup %s', new_setup) for entry_dict in info['watch_conditions']: self._add_entry(entry_dict, new_setup) # trigger an update of all conditions for entry in itervalues(self._entries): entry.cond_obj.new_setups(self._setups) entry.cond_obj.update(time, self._keydict) self._check_state(entry, time) # update everyone els self._publish_config() self.log.info('new setups list: %s', ', '.join(self._setups))
def _access_level_list(): return ', '.join(repr(l) for l in itervalues(ACCESS_LEVELS))
def _get_all_widgets(self): yield self.widget for w in itervalues(self._livewidgets): yield w
def _wait_data(self): t = currenttime() for entry in itervalues(self._entries): if entry.cond_obj.tick(t) or entry.cond_obj.is_expired(t): self._check_state(entry, t)
def _publish_config(self): # publish current condition info in the cache self._put_message('configured', None, [c.serialize() for c in itervalues(self._entries)])