def loadSettings(self, settings):
self.splitterstate = settings.value('splitter', '', QByteArray)
self.presetdict = {}
# read new format if present
settings.beginGroup('presets_new')
for key in settings.childKeys():
self.presetdict[key] = json.loads(settings.value(key))
settings.endGroup()
# convert old format
try:
presetval = settings.value('presets')
if presetval:
for (name, value) in presetval.items():
if not isinstance(value, bytes):
value = value.encode('latin1')
self.presetdict[name] = pickle.loads(value)
except Exception:
pass
settings.remove('presets')
self.last_views = []
settings.beginGroup('views_new')
for key in settings.childKeys():
try:
info = json.loads(settings.value(key))
self.last_views.append((key, info))
except Exception:
pass
settings.endGroup()
def _refresh_presets(self):
pmenu = self.presetmenu
pmenu.clear()
delmenu = QMenu('Delete', self)
try:
for preset, info in iteritems(self.presetdict):
paction = QAction(preset, self)
pdelaction = QAction(preset, self)
info = pickle.loads(str(info))
def launchpreset(on, info=info):
self._createViewFromDialog(info)
def delpreset(on, name=preset, act=paction, delact=pdelaction):
pmenu.removeAction(act)
delmenu.removeAction(delact)
self.presetdict.pop(name, None)
self._refresh_presets()
paction.triggered[bool].connect(launchpreset)
pmenu.addAction(paction)
pdelaction.triggered[bool].connect(delpreset)
delmenu.addAction(pdelaction)
except AttributeError:
self.presetdict = {}
if self.presetdict:
pmenu.addSeparator()
pmenu.addMenu(delmenu)
else:
pmenu.addAction('(no presets created)')
def test_pickable():
store = {'phi': 3.1415926535897931, 'type': 'e', 'dx': 400, 'chi': 0.0,
'theta': -0.17453292519943295, 'omega': 0.0}
hw = None
pos = residevice.position.PositionFromStorage(hw, store)
proxied = residevice.ResiPositionProxy(pos)
res = pickle.dumps(proxied, protocol=0)
restored = pickle.loads(res)
print(store)
print(restored.storable())
assert restored.storable() == store
def loadSettings(self, settings):
self.splitterstate = settings.value('splitter', '', QByteArray)
presetval = settings.value('presets')
self.presetdict = presetval if presetval is not None else {}
self.last_views = []
settings.beginGroup('views')
for key in settings.childKeys():
try:
info = pickle.loads(bytes(settings.value(key, '', QByteArray)))
self.last_views.append((key, info))
except Exception:
pass
settings.endGroup()
def test_readonly_objects():
d = readonlydict({'a': 1, 'b': 2})
assert raises(TypeError, d.update, {})
# pickle Protocoll 0
unpickled = pickle.loads(pickle.dumps(d))
assert isinstance(unpickled, readonlydict)
assert len(unpickled) == 2
# pickle Protocoll 2
unpickled = pickle.loads(pickle.dumps(d, 2))
assert isinstance(unpickled, readonlydict)
assert len(unpickled) == 2
l = readonlylist([1, 2, 3])
assert raises(TypeError, l.append, 4)
# pickle Protocoll 0
unpickled = pickle.loads(pickle.dumps(l))
assert isinstance(unpickled, readonlylist)
assert len(unpickled) == 3
# pickle Protocoll 2
unpickled = pickle.loads(pickle.dumps(l, 2))
assert isinstance(unpickled, readonlylist)
assert len(unpickled) == 3
def _convert(node):
if isinstance(node, (Str, Bytes)):
return node.s
elif isinstance(node, Num):
return node.n
elif isinstance(node, Tuple):
return tuple(map(_convert, node.elts))
elif isinstance(node, List):
return readonlylist(map(_convert, node.elts))
elif isinstance(node, Dict):
return readonlydict((_convert(k), _convert(v)) for k, v
in zip(node.keys, node.values))
elif isinstance(node, Set):
return frozenset(map(_convert, node.elts))
elif isinstance(node, Name):
if node.id in _safe_names:
return _safe_names[node.id]
elif isinstance(node, NameConstant):
return node.value
elif isinstance(node, UnaryOp) and \
isinstance(node.op, USub) and \
isinstance(node.operand, Name) and \
node.operand.id in _safe_names:
return -_safe_names[node.operand.id]
elif isinstance(node, UnaryOp) and \
isinstance(node.op, USub) and \
isinstance(node.operand, Num):
return -node.operand.n
elif isinstance(node, BinOp) and \
isinstance(node.op, (Add, Sub)) and \
isinstance(node.right, Num) and \
isinstance(node.right.n, complex) and \
isinstance(node.left, Num) and \
isinstance(node.left.n, number_types):
left = node.left.n
right = node.right.n
if isinstance(node.op, Add):
return left + right
else:
return left - right
elif isinstance(node, Call) and node.func.id == 'cache_unpickle':
return pickle.loads(b64decode(ast_eval(node.args[0])))
raise ValueError('malformed literal string with %s' % node)
def _object_hook(self, obj):
if '__pickle__' in obj:
return pickle.loads(obj['__pickle__'].encode('latin1'))
return obj
def deserialize_event(self, data, evtname=None):
return evtname, pickle.loads(data)
def deserialize_reply(self, data, success=None):
assert success is not None
data = pickle.loads(data) if data else None
return success, data
def deserialize_cmd(self, data, cmdname=None):
return cmdname, pickle.loads(data)
def deserialize_event(self, data, evtname=None):
return evtname, pickle.loads(data, encoding='latin1')
def deserialize_cmd(self, data, cmdname=None):
return cmdname, pickle.loads(data, encoding='latin1')
def run(cls, sock, uuid, setups, user, code, quiet=False, debug=False):
session.__class__ = cls
session._is_sandboxed = sock.startswith('ipc://')
session._debug_log = debug
socket = nicos_zmq_ctx.socket(zmq.DEALER)
socket.connect(sock)
# we either get an empty message (retrieve cache data ourselves)
# or a pickled key-value database
data = socket.recv()
db = pickle.loads(data) if data else None
# send log messages back to daemon if requested
session.log_sender = SimLogSender(socket, session, uuid, quiet)
username, level = user.rsplit(',', 1)
session._user = User(username, int(level))
try:
session.__init__(SIMULATION)
except Exception as err:
try:
session.log.exception('Fatal error while initializing')
finally:
print('Fatal error while initializing:', err, file=sys.stderr)
return 1
# Give a sign of life and then tell the log handler to only log
# errors during setup.
session.log.info('setting up dry run...')
session.begin_setup()
# Handle "print" statements in the script.
sys.stdout = LoggingStdout(sys.stdout)
try:
# Initialize the session in simulation mode.
session._mode = SIMULATION
# Load the setups from the original system, this should give the
# information about the cache address.
session.log.info('loading simulation mode setups: %s',
', '.join(setups))
session.loadSetup(setups, allow_startupcode=False)
# Synchronize setups and cache values.
session.log.info('synchronizing to master session')
session.simulationSync(db)
# Set session to always abort on errors.
session.experiment.errorbehavior = 'abort'
except: # really *all* exceptions -- pylint: disable=W0702
session.log.exception('Exception in dry run setup')
session.log_sender.finish()
session.shutdown()
return 1
# Set up log handlers to output everything.
session.log_sender.begin_exec()
# Execute the script code.
exception = False
try:
last_clock = session.clock.time
code, _ = parseScript(code)
for i, c in enumerate(code):
exec_(c, session.namespace)
time = session.clock.time - last_clock
last_clock = session.clock.time
session.log_sender.send_block_result(i, time)
except Abort:
session.log.info('Dry run finished by abort()')
except: # pylint: disable=W0702
session.log.exception('Exception in dry run')
exception = True
else:
session.log.info('Dry run finished')
finally:
session.log_sender.finish(exception)
# Shut down.
session.shutdown()
