class BaseRecordSource(Atom):
name = Str()
title = Str()
schema = Typed(RecordSchema)
output_fieldnames = List()
max_record_count = Int(0)
reference_timestamps = List()
reference_interval = Float(1.0)
record_class = Value()
cached_records = List()
def _default_output_fieldnames(self):
return ['timestamp'] + [f.name for f in self.schema.fields]
def _default_record_class(self):
attrs = dict(timestamp=Coerced(np.int64), )
for field in self.schema.fields:
if field.name in attrs:
log.warn(
"Duplicate key: %s in field specification for record source: %s - skipping"
% (field.name, self.name))
continue
attrs[field.name] = Value()
return new.classobj("RecordClass_%s" % self.name, (Atom, ), attrs)
def clear_cache(self):
self.cached_records = []
def __iter__(self):
if len(self.cached_records) > 0:
for cached_record in self.cached_records:
yield cached_record
return
raise NotImplemented()
class WhileTask(ComplexTask):
""" Task breaking out of a loop when a condition is met.
See Python break statement documenttaion.
"""
logic_task = True
condition = Str().tag(pref=True)
task_database_entries = set_default({'index' : 1})
def check(self, *args, **kwargs):
"""
"""
test, traceback = super(WhileTask, self).check(*args, **kwargs)
try:
self.format_and_eval_string(self.condition)
except Exception as e:
test = False
mess = 'Task did not succeed to compute the break condition: {}'
traceback[self.task_path + '/' + self.task_name + '-cond'] = \
mess.format(e)
return test, traceback
def perform(self):
"""
"""
i = 1
root = self.root_task
while True:
self.write_in_database('index', i)
i += 1
if not self.format_and_eval_string(self.condition):
break
if handle_stop_pause(root):
return
try:
for child in self.children_task:
child.perform_(child)
except BreakException:
break
except ContinueException:
continue
class Picomotor(Prop):
# must keep track of position changes and send only difference
serial_number = Str()
motor_number = Str()
desired_position = Member()
current_position = Int()
max_angle_error = Float(
0) # necessary so I don't have to define a new enaml container
def __init__(self, name, experiment, description=''):
super(Picomotor, self).__init__(name, experiment, description)
self.desired_position = IntProp('desired_position', experiment,
'the desired position', '0')
self.properties += [
'serial_number', 'motor_number', 'desired_position',
'max_angle_error'
]
self.current_position = self.desired_position.value
def update(self):
# calculate relative move necessary
relative_move = self.desired_position.value - self.current_position
return '{},{},{}'.format(serial_number, motor_number, relative_move)
class ConditionalTask(ComplexTask):
"""Task calling its children only if a given condition is met.
"""
#: Condition to meet in order to perform the children tasks.
condition = Str().tag(pref=True, feval=Feval())
def perform(self):
"""Call the children task if the condition evaluate to True.
"""
if self.format_and_eval_string(self.condition):
for child in self.children:
child.perform_()
class EnvironmentKey(Atom):
is_default = Bool(False)
is_existing = Bool(False)
is_active = Bool(False)
key = Str()
values = List(EnvironmentValue)
def get_value_as_string(self):
return os.pathsep.join([v.value for v in self.values])
def __repr__(self):
return u"Key<%s>:%s" % (self.key, self.values)
class JobFilter(Atom):
#: A fixed type name for the UI to extract without using isinstance
type = ""
#: Name to display in the UI
name = Str()
#: If NOT enabled then apply_filter is called which should return the
#: path with the filtered path elements REMOVED.
enabled = Bool(True)
@classmethod
def get_filter_options(cls, job, doc):
""" Get the list of options that can be filtered from the document
Parameters
----------
job: inkcut.models.Job
The job that is being processed. This should only be used to
reference settings.
doc: QtSvgDoc
The document to filter.
Returns
-------
results: List[cls]
The list of filterable options to choose from.
"""
raise NotImplementedError()
def apply_filter(self, job, doc):
""" Apply the filter to the path by removing paths that are excluded
by this filter. This is only called if the `enabled` is set to false.
Parameters
----------
job: inkcut.models.Job
The job that is being processed. This should only be used to
reference settings.
doc: QtSvgDoc
The document to filter.
Returns
-------
doc: QtSvgDoc
The filtered document.
"""
raise NotImplementedError()
class Plot2D(BasePlot):
""""""
#: Data for the plot.
data = Typed(Plot2DData).tag(sync=True)
#: Colormap to use.
colormap = Str("viridis")
# --- Proxy connection
def _post_setattr_data(self, old, new):
if self.proxy:
self.proxy.set_data(new)
class EnamlDef(ASTNode):
""" An ASTNode representing an enamldef block.
"""
#: The type name given to the enamldef.
typename = Str()
#: The name of the base class which is being inherited.
base = Str()
#: The identifier given to the enamldef.
identifier = Str()
#: The docstring for the enamldef.
docstring = Str()
#: The list of decorator for the enamldef. This will be composed of
#: Python nodes.
decorators = List()
#: The list of body nodes for the enamldef. This will be composed
#: of StorageDef, Binding, and ChildDef nodes.
body = List()
class Person(Atom):
""" A simple class representing a person object.
"""
last_name = Str()
first_name = Str()
age = Range(low=0)
debug = Bool(False)
@observe('age')
def debug_print(self, change):
""" Prints out a debug message whenever the person's age changes.
"""
if self.debug:
templ = "{first} {last} is {age} years old."
s = templ.format(
first=self.first_name, last=self.last_name, age=self.age,
)
print(s)
class IconThemeExtension(Declarative):
"""Declarative object used to contribute new icons to an existing theme.
"""
#: Unicsue id of the extension.
id = d_(Str())
#: Id of the icon theme to which to contribute the children Icon objects.
theme = d_(Str())
def icons(self):
"""List the associated icons.
"""
if not self._icons:
self._icons = [c for c in self.children if isinstance(c, Icon)]
return self._icons
# --- Private API ---------------------------------------------------------
#: Private list of contributed icons.
_icons = List()
class Icon(Declarative):
"""Declarative object used to contribute an icon.
"""
#: Unique id describing the icon. It should provide a clear description
#: of the icon purpose.
id = d_(Str())
@d_func
def get_icon(self, manager, theme):
"""Generate the corresponding enaml icon object.
"""
raise NotImplementedError()
class ApplyMagFieldTask(InstrumentTask):
"""Use a supraconducting magnet to apply a magnetic field. Parallel task.
"""
loopable = True
target_field = Str().tag(pref=True)
rate = Float().tag(pref=True)
auto_stop_heater = Bool(True).tag(pref=True)
task_database_entries = set_default({'Bfield': 0.01})
driver_list = ['IPS12010']
def __init__(self, **kwargs):
super(ApplyMagFieldTask, self).__init__(**kwargs)
self.make_parallel('instr')
@smooth_instr_crash
def process(self, target_value=None):
"""
"""
if not self.driver:
self.start_driver()
if (self.driver.owner != self.task_name
or not self.driver.check_connection()):
self.driver.owner = self.task_name
self.driver.make_ready()
if target_value is None:
target_value = format_and_eval_string(self.target_field,
self.task_path,
self.task_database)
self.driver.go_to_field(target_value, self.rate, self.auto_stop_heater)
self.write_in_database('Bfield', target_value)
def check(self, *args, **kwargs):
"""
"""
test, traceback = super(ApplyMagFieldTask, self).check(*args, **kwargs)
if self.target_field:
try:
val = format_and_eval_string(self.target_field, self.task_path,
self.task_database)
except:
test = False
traceback[self.task_path + '/' + self.task_name + '-field'] = \
'Failed to eval the target field formula {}'.format(
self.target_field)
self.write_in_database('Bfield', val)
return test, traceback
class Part(Shape):
""" A Part is a compound shape. It may contain
any number of nested parts and is typically subclassed.
Attributes
----------
name: String
An optional name for the part
description: String
An optional description for the part
Examples
--------
enamldef Case(Part):
TopCover:
# etc..
BottomCover:
# etc..
"""
#: Reference to the implementation control
proxy = Typed(ProxyPart)
#: Optional name of the part
name = d_(Str())
#: Optional description of the part
description = d_(Str())
#: Cache
cache = {}
@property
def shapes(self):
return [child for child in self.children if isinstance(child, Shape)]
class InsertBorderItem(DockLayoutOp):
""" A layout operation which inserts an item into an area border.
This operation will remove an item from the current layout and
insert it into the border of a dock area. If the item does not
exist, the operation is a no-op.
If the target -
- is a normally docked item
The item is inserted into the border of the dock area containing
the target.
- is docked in a tab group
The item is inserted into the border of the dock area containing
the tab group.
- is docked in a dock bar
The item is inserted into the border of the dock area containing
the dock bar.
- is a floating dock item
A new dock area will be created and the item will be inserted
into the border of the new dock area.
- does not exist
The item is inserted into the border of the primary dock area.
"""
#: The name of the dock item to insert into the layout.
item = Str()
#: The name of the dock item to use as the target location.
target = Str()
#: The border position at which to insert the item.
position = Enum('left', 'top', 'right', 'bottom')
class BaseRule(HasPrefAtom):
"""Base class for all rules implementations.
"""
#: Name of the rule.
id = Str().tag(pref=True)
#: Quick description of what this rule is intended for.
description = d_(Str()).tag(pref=True)
#: List of database entries suffixes used to identify the entries which
#: contributes to the rule.
suffixes = List(default=['']).tag(pref=True)
#: Id of the class used for persistence.
class_id = Str().tag(pref=True)
def try_apply(self, new_entry, monitor):
""" Attempt to apply the rule.
Parameters
----------
new_entry : str
Database path of the newly added entry.
monitor : TextMonitor
Instance of the text monitor trying to apply the rule.
"""
raise NotImplementedError()
def _default_class_id(self):
"""Default factory for the class_id attribute
"""
pack, _ = self.__module__.split('.', 1)
return '.'.join((pack, type(self).__name__))
class FitModel(Atom):
"""Back-end for the FitController
"""
params = Dict()
lmfit_params = Typed(Parameters)
lmfit_model = Typed(Model)
name = Str()
show_advanced = Bool(False)
show_basic = Bool(True)
def __init__(self, lmfit_model, prefix, name=None):
# print(lmfit_model)
if name is None:
name = str(lmfit_model.name)
self.name = name
if type(lmfit_model) is type:
self.lmfit_model = lmfit_model(name=self.name, prefix=prefix)
else:
self.lmfit_model = lmfit_model
# print(self.lmfit_model.name)
# self.lmfit_model.prefix = "1"
self.lmfit_params = self.lmfit_model.make_params()
for name, param in six.iteritems(self.lmfit_params):
p = ParameterModel()
p.set_from_parameter(param)
self.params[name] = p
super(FitModel, self).__init__()
@observe('show_advanced')
def update_view(self, changed):
self.show_basic = not self.show_advanced
print('show_basic: {}'.format(self.show_basic))
print('show_advanced: {}'.format(self.show_advanced))
def update_params(self, params):
"""
Parameters
----------
params : list
List of parameters that the fit model knows about. Silently ignore
any parameters that are passed in that this model doesn't know about
"""
for param in params:
try:
self.params[param.name].set_from_parameter(param)
except KeyError:
# silently ignore keys that are not in this model
pass
class XBM(Atom):
""" A simple class representing an XMB image.
"""
#: The width of the xbm image.
width = Int()
#: The height of the xbm image.
height = Int()
#: The bytestring of image data.
data = Str()
def __init__(self, width, height, data):
""" Initialize an XBM image.
Parameters
----------
width : int
The width of the bitmap.
height : int
The height of the bitmap.
data : list
A list of 1s and 0s which represent the bitmap data.
The length must be equal to width * height.
"""
assert len(data) == (width * height)
bytes = []
for row in xrange(height):
val = 0
offset = row * width
for col in xrange(width):
d = col % 8
if col > 0 and d == 0:
bytes.append(chr(val))
val = 0
v = data[offset + col]
val |= v << (7 - d)
bytes.append(chr(val))
self.width = width
self.height = height
self.data = ''.join(bytes)
def toBitmap(self):
size = QSize(self.width, self.height)
return QBitmap.fromData(size, self.data, QImage.Format_Mono)
class Image(Atom):
""" An object representing an image.
Once an image is created it should be treated as read only. User
code should create a new image object if the parameters need to
be changed.
"""
#: The format of the image. By default, the consumer of the image
#: will probe the header to automatically infer a type.
format = Enum(
'auto', # Automatically determine the image format
'png', # Portable Network Graphics
'jpg', # Joint Photographic Experts Group
'gif', # Graphics Interchange Format
'bmp', # Windows Bitmap
'xpm', # X11 Pixmap
'xbm', # X11 Bitmap
'pbm', # Portable Bitmap
'pgm', # Portable Graymap
'ppm', # Portable Pixmap
'tiff', # Tagged Image File Format
'argb32', # Raw data in the 0xAARRGGBB format.
# The `raw_size` of the image must be provided.
)
#: The (width, height) raw size of the image. This must be provided
#: for images where the size is not encoded in the data stream.
raw_size = Coerced(Size, (0, 0))
#: The (width, height) size of the image. An invalid size indicates
#: that the size of the image should be automatically inferred. A
#: valid size indicates that the toolkit image should be scaled to
#: the specified size.
size = Coerced(Size, (-1, -1))
#: The aspect ratio mode to use when the toolkit scales the image.
aspect_ratio_mode = Enum('ignore', 'keep', 'keep_by_expanding')
#: The transform mode to use when the toolkit scales the image.
transform_mode = Enum('smooth', 'fast')
# XXX this needs to be augmented to support arrays.
#: The bytestring holding the data for the image.
data = Str()
#: Storage space for use by a toolkit backend to use as needed.
#: This should not typically be manipulated by user code.
_tkdata = Value()
class AbstractConfigTask(Atom):
""" Base class for task configurer.
"""
# Task manager, necessary to retrieve task implementations.
manager = ForwardTyped(task_manager)
# Name of the task to create.
task_name = Str('')
# Class of the task to create.
task_class = Subclass(BaseTask)
# Bool indicating if the build can be done.
config_ready = Bool(False)
def check_parameters(self, change):
"""Check if enough parameters have been provided to build the task.
This methodd should fire the config_ready event each time it is called
sending True if everything is allright, False otherwise.
"""
err_str = '''This method should be implemented by subclasses of
AbstractConfigTask. This method is called each time a trait is changed
to check if enough parameters has been provided to build the task.'''
raise NotImplementedError(cleandoc(err_str))
def build_task(self):
"""This method use the user parameters to build the task object
Returns
-------
task : BaseTask
Task object built using the user parameters. Ready to be
inserted in a task hierarchy.
"""
err_str = '''This method should be implemented by subclasses of
AbstractConfigTask. This method is called when the user validate its
choices and that the task must be built.'''
raise NotImplementedError(cleandoc(err_str))
def _default_task_name(self):
names = self.manager.auto_task_names
if names:
return random.choice(names)
else:
return ''
class SetRFOnOffTask(InterfaceableTaskMixin, InstrumentTask):
"""Switch on/off the output of the source.
"""
# Desired state of the output, runtime value can be 0 or 1.
switch = Str('Off').tag(pref=True)
task_database_entries = set_default({'output': 0})
loopable = True
driver_list = ['AgilentE8257D', 'AnritsuMG3694', 'LabBrickLMS103']
def check(self, *args, **kwargs):
"""
"""
test, traceback = super(SetRFOnOffTask, self).check(*args, **kwargs)
if self.switch:
try:
switch = self.format_and_eval_string(self.switch)
self.write_in_database('output', switch)
except Exception as e:
mess = 'Failed to eval the output state {}: {}'
traceback[self.task_path + '/' + self.task_name + '-switch'] =\
mess.format(self.switch, e)
return False, traceback
if switch not in ('Off', 'On', 0, 1):
test = False
traceback[self.task_path + '/' + self.task_name + '-switch'] =\
'{} is not an acceptable value.'.format(self.switch)
return test, traceback
def i_perform(self, switch=None):
"""
"""
if not self.driver:
self.start_driver()
if switch is None:
switch = self.format_and_eval_string(self.switch)
if switch == 'On' or switch == 1:
self.driver.output = 'On'
self.write_in_database('output', 1)
else:
self.driver.output = 'Off'
self.write_in_database('output', 0)
class CompilerBase(ASTVisitor):
""" A base class for defining compilers.
"""
#: The filename for the code being generated.
filename = Str()
#: The code generator to use for this compiler.
code_generator = Typed(CodeGenerator)
def _default_code_generator(self):
""" Create the default code generator instance.
"""
return CodeGenerator(filename=self.filename)
class BasePlot(PlotElement):
"""Base class for plot description."""
#: Id of the plot used to identify it in an axes
id = Str()
#: Reference to the axes to which this plot belongs (or None)
axes = ForwardTyped(_axes)
#: What axes ("left", "bottom", etc) to use for "x", "y" ("x" acts as key)
axes_mapping = Dict(str, str)
#: Z order determining the order in which the plots are drawn.
#: Smaller values are drawn first.
zorder = Int(10)
class ModelExporter(Atom):
extension = ''
path = Str()
filename = Str()
def _default_path(self):
ext = self.extension.lower()
filename = os.path.splitext(self.filename)[0]
return "{}.{}".format(filename, ext)
def export(self):
""" Export a DeclaraCAD model from an enaml file to a 3D model format
with the given options.
"""
raise NotImplementedError
@classmethod
def get_options_view(cls):
""" Return the options view used to define the paramters that can be
used by this exporter.
"""
raise NotImplementedError
class ItemGroup(Declarative):
""" A declarative class for defining an item group in a menu.
"""
#: The identifier of group within the menu.
id = d_(Str())
#: Whether or not the group is visible.
visible = d_(Bool(True))
#: Whether or not the group is enabled.
enabled = d_(Bool(True))
#: Whether or not checkable ations in the group are exclusive.
exclusive = d_(Bool(False))
class Foo(Atom):
name = Str()
a = Int()
b = Int()
c = Int()
groups = [
Group('Ints',
items=[
StrItem('name'),
IntItem('a'),
AltBlue('b'),
IntItem('c', foreground='red', font='bold 12pt arial'),
])
]
class WebView(Control):
""" A widget which displays a web page.
Unlike the simpler `Html` widget, this widget supports the features
of a full web browser.
"""
#: The URL to load in the web view. This can be a path to a remote
#: resource or a path to a file on the local filesystem. This value
#: is mutually exclusive of `html`.
url = d_(Str())
#: The html to load into the web view. This value is mutually
#: exclusive of `url`.
html = d_(Str())
#: The base url for loading content in statically supplied 'html'.
base_url = d_(Str())
#: A web view expands freely in height and width by default.
hug_width = set_default('ignore')
hug_height = set_default('ignore')
#: A reference to the ProxyWebView object.
proxy = Typed(ProxyWebView)
#--------------------------------------------------------------------------
# Observers
#--------------------------------------------------------------------------
@observe('url', 'html')
def _update_proxy(self, change):
""" An observer which sends state change to the proxy.
"""
# The superclass handler implementation is sufficient.
super(WebView, self)._update_proxy(change)
class _Aux(HasPrefAtom):
string = Str().tag(pref=True)
float_n = Float().tag(pref=True)
enum = Enum('a', 'b').tag(pref=True)
enum_float = Enum(1.0, 2.0).tag(pref=True)
list_ = List(Float()).tag(pref=True)
odict_ = Typed(OrderedDict,
()).tag(pref=[ordered_dict_to_pref, ordered_dict_from_pref])
value = Value().tag(pref=True)
const = Constant('r').tag(pref=True)
atom = Typed(_Aaux, ()).tag(pref=True)
no_tag = Int()
class Person(Atom):
name = Str()
# uses static constructor
fido = Typed(Dog)
# uses kwargs provided in the definition
fluffy = Typed(Dog, kwargs=dict(name='Fluffy'))
# uses an object provided in Person constructor
new_dog = Typed(Dog)
def _default_fido(self):
return Dog(name='Fido', owner=self)
class StorageDefConstruct(ConstructNode):
""" A construct node for a storage definition.
"""
#: The kind of the state definition.
kind = Enum('attr', 'event')
#: The name of the state object being defined.
name = Str()
#: The typename of the allowed values for the state object.
typename = Str()
#: The resolved type class for using with the state def. This is
#: updated during the resolution passes over the tree.
typeclass = Typed(type)
@classmethod
def from_dict(cls, dct):
self = super(StorageDefConstruct, cls).from_dict(dct)
self.kind = dct['kind']
self.name = dct['name']
self.typename = dct['typename']
return self
class TTL_filters(Analysis):
"""This analysis monitors the TTL inputs and does either hard or soft cuts of the data accordingly.
Low is good, high is bad."""
text = Str()
lines = Str('PXI1Slot6/port0')
filter_level = Int()
def __init__(self, name, experiment, description=''):
super(TTL_filters, self).__init__(name, experiment, description)
self.properties += ['lines', 'filter_level']
def analyzeMeasurement(self, measurementResults, iterationResults,
experimentResults):
text = 'none'
if self.experiment.LabView.TTL.enable and (
'TTL/data' in measurementResults['data']):
a = measurementResults['data/TTL/data']
#check to see if any of the inputs were True
if numpy.any(a):
#report the true inputs
text = 'TTL Filters failed:\n'
for i, b in enumerate(a):
#print out the row and column of the True input
text += 'Check {}: Laser(s) {}\n'.format(
i,
numpy.arange(len(b))[b])
#record to the log and screen
logger.warning(text)
self.set_gui({'text': text})
# User chooses whether or not to delete data.
# max takes care of ComboBox returning -1 for no selection
return max(0, self.filter_level)
else:
text = 'okay'
self.set_gui({'text': text})