class WaitingTask(SimpleTask):
"""Simple Task whose execution can be controlled using events.
"""
check_flag = Bool(True).tag(pref=True)
sync_port = Value(()).tag(pref=True)
sock_id = Unicode().tag(pref=True)
def check(self, *args, **kwargs):
super(WaitingTask, self).check(*args, **kwargs)
return self.check_flag, {'test': 1}
def perform(self):
with socket.socket() as s:
while True:
if s.connect_ex(('localhost', self.sync_port)) == 0:
break
sleep(0.01)
s.sendall(self.sock_id.encode('utf-8'))
s.recv(4096)
s.sendall('Waiting'.encode('utf-8'))
s.recv(4096)
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 SwipeRefreshLayout(ViewGroup):
"""SwipeRefreshLayout is a view group that displays
child views in relative positions.
"""
#: Enabled
enabled = d_(Bool(True))
#: Must be a
indicator_color = d_(Str())
#: Must be a
indicator_background_color = d_(Str())
#: Set the distance to trigger a sync in dips
trigger_distance = d_(Int())
#: Triggered when the user swipes
refreshed = d_(Event())
#: A reference to the proxy object.
proxy = Typed(ProxySwipeRefreshLayout)
# -------------------------------------------------------------------------
# Observers
# -------------------------------------------------------------------------
@observe(
"enabled",
"indicator_color",
"indicator_background_color",
"trigger_distance",
)
def _update_proxy(self, change):
if change["type"] == "event":
self.proxy.set_refreshed(True)
else:
super()._update_proxy(change)
class Splitter(ConstraintsWidget):
""" A widget which displays its children in separate resizable
compartements that are connected with a resizing bar.
A Splitter can have an arbitrary number of Container children.
"""
#: The orientation of the Splitter. 'horizontal' means the children
#: are laid out left to right, 'vertical' means top to bottom.
orientation = d_(Enum('horizontal', 'vertical'))
#: Whether the child widgets resize as a splitter is being dragged
#: (True), or if a simple indicator is drawn until the drag handle
#: is released (False). The default is True.
live_drag = d_(Bool(True))
#: A splitter expands freely in height and width by default.
hug_width = set_default('ignore')
hug_height = set_default('ignore')
#: A reference to the ProxySplitter object.
proxy = Typed(ProxySplitter)
def split_items(self):
""" Get the split item children defined on the splitter.
"""
return [c for c in self.children if isinstance(c, SplitItem)]
#--------------------------------------------------------------------------
# Observers
#--------------------------------------------------------------------------
@observe(('orientation', 'live_drag'))
def _update_proxy(self, change):
""" An observer which sends state change to the proxy.
"""
# The superclass handler implementation is sufficient.
super(Splitter, self)._update_proxy(change)
class Snackbar(ToolkitObject):
""" A toast is a view containing a quick little message for the user.
"""
#: Text to display
#: if this node has a child view this is ignored
text = d_(Unicode())
#: Text to display in the action button
action_text = d_(Unicode())
#: Color for the action text button
action_text_color = d_(Unicode())
#: Duration to display in ms or 0 for infinite
duration = d_(Int(3000))
#: Alias for the action is clicked
clicked = d_(Event(), writable=False)
#: When an action occurs such as swiped out, clicked, timed out, etc..
action = d_(Event(basestring), writable=False)
#: Show the snackbar for the given duration
show = d_(Bool())
#: A reference to the proxy object.
proxy = Typed(ProxySnackbar)
# -------------------------------------------------------------------------
# Observers
# -------------------------------------------------------------------------
@observe('text', 'duration', 'action_text', 'action_text_color', 'show')
def _update_proxy(self, change):
""" An observer which sends the state change to the proxy.
"""
# The superclass implementation is sufficient.
super(Snackbar, self)._update_proxy(change)
class SetRFPulsedTask(InstrumentTask):
"""Set the frequency of the signal delivered by a RF source.
"""
# Whether to start the source in pulsed mode
pulsed = Bool(False).tag(pref=True)
def check(self, *args, **kwargs):
"""Checks if the instrument is connected
"""
test, traceback = super(SetRFPulsedTask, self).check(*args, **kwargs)
return test, traceback
def perform(self):
"""Default interface for simple sources.
"""
if self.pulsed:
self.driver.pm_state = 'ON'
else:
self.driver.pm_state = 'OFF'
class Fit1D(FitObject):
'class for fitting 1d datasets'
parent = ForwardInstance(lambda: ap.data.XYDataObject)
plot = ForwardInstance(lambda: ap.plot.Plot1D)
fitted = Bool(
default=False
) # boolean which indicates if current model and data are fitted
_model = Value()
result = Value()
_fit = Typed(Fit)
def __init__(self, parent, *args, **kwargs):
self.parent = parent
super(Fit1D, self).__init__(*args, **kwargs)
self.result = None
def add_model(self, model):
if self._model: del self._model
if isinstance(model, str):
self._model = get_model(model, self.parent.x, self.parent.y)
else:
self._model = model
self.fitted = False
@observe('parent.x', 'parent.x_updated', 'parent.y', 'parent.y_updated')
def _data_updated(self, change):
self.fitted = False
def execute(self, *options, **kwoptions):
self._fit = Fit(self._model, self.parent.x, self.parent.y)
self.result = self._fit.execute(*options, **kwoptions)
class Channel(Atom):
'''
Every channel has a label and some printers.
'''
label = Str()
enabled = Bool(True)
def __repr__(self):
return str(self)
def __str__(self):
return "{0}: {1}".format(self.__class__.__name__, self.label)
def json_encode(self):
jsonDict = self.__getstate__()
#Strip out pass-through properties
for k, m in self.members().items():
if isinstance(m, Property):
del jsonDict[k]
#Turn instruments back into unicode labels
for member in [
"AWG", "generator", "physChan", "gateChan", "source", "target"
]:
if member in jsonDict:
obj = jsonDict.pop(member)
if obj:
jsonDict[member] = obj.label
#We want the name of shape functions
if "pulseParams" in jsonDict:
pulseParams = deepcopy(jsonDict.pop("pulseParams"))
if "shapeFun" in pulseParams:
pulseParams["shapeFun"] = pulseParams["shapeFun"].__name__
jsonDict["pulseParams"] = pulseParams
return jsonDict
class ExtractEpochs(EpochInput):
queue = d_(Typed(deque, {}))
buffer_size = d_(Float(0)).tag(metadata=True)
#: Defines the size of the epoch (if NaN, this is automatically drawn from
#: the information provided by the queue).
epoch_size = d_(Float(0)).tag(metadata=True)
#: Defines the extra time period to capture beyond the epoch duration.
poststim_time = d_(Float(0).tag(metadata=True))
complete = Bool(False)
def mark_complete(self):
self.complete = True
def configure_callback(self):
#if self.epoch_size == 0:
#raise ValueError('Epoch size not configured')
if np.isinf(self.epoch_size):
m = f'ExtractEpochs {self.name} has an infinite epoch size'
raise ValueError(m)
cb = super().configure_callback()
return extract_epochs(self.fs, self.queue, self.epoch_size,
self.poststim_time, self.buffer_size, cb,
self.mark_complete).send
def _get_duration(self):
return self.epoch_size + self.poststim_time
# force change notification for duration
def _observe_epoch_size(self, event):
self.notify('duration', self.duration)
def _observe_poststim_time(self, event):
self.notify('duration', self.duration)
class BooleanOperation(Operation):
""" A base class for a boolean operation on two or more shapes.
Attributes
----------
shape1: Shape
The first shape argument of the operation.
shape2: Shape
The second shape argument of the operation.
"""
shape1 = d_(Instance(object))
shape2 = d_(Instance(object))
#: Unify using ShapeUpgrade_UnifySameDomain
unify = d_(Bool(False))
@observe('shape1', 'shape2', 'unify')
def _update_proxy(self, change):
super(BooleanOperation, self)._update_proxy(change)
class CustomBlastDB(Atom):
"""Represents parameters of a BLAST database.
"""
fasta = Unicode('test')
query = Unicode('query')
sp_only = Bool(False)
target_name = Unicode()
def run(self):
paths = env.get_db_locations()
try:
result = subprocess.check_output([
'makeblastdb', '-in', self.fasta, '-dbtype', 'prot',
'-parse_seqids', '-title', self.target_name, '-out',
self.target_name
],
cwd=paths[0],
stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
result = e.output
return unicode(result)
class Button(TextView):
""" A simple control for displaying a button.
"""
#: Button is clickable by default
clickable = set_default(True)
#: Use a flat style
flat = d_(Bool())
#: A reference to the proxy object.
proxy = Typed(ProxyButton)
# -------------------------------------------------------------------------
# Observers
# -------------------------------------------------------------------------
@observe('flat')
def _update_proxy(self, change):
""" An observer which sends the state change to the proxy.
"""
# The superclass implementation is sufficient.
super(Button, self)._update_proxy(change)
class FlexboxLayoutParams(FlexParams):
""" A model for flexbox layout parameters """
#: How to align children along the cross axis of their container
align_items = Enum('stretch', 'flex_start', 'flex_end', 'center')
#: Control how multiple lines of content are aligned within a
#: container which uses FlexWrap
align_content = Enum('flex_start', 'flex_end', 'center', 'space_between',
'space_around')
#: Should the layout be a column or a row.
flex_direction = Enum('row', 'column', 'row_reversed', 'column_reversed')
#: Wrap or nowrap
flex_wrap = Bool()
#: How to align children within the main axis of a container
justify_content = Enum('flex_start', 'flex_end', 'center', 'space_between',
'space_around')
#: The Position property tells Flexbox how you want your item to be
#: positioned within its parent.
position = Enum('relative', 'absolute')
class GroupedEpochFFTPlot(EpochGroupMixin, BasePlot):
waveform_averages = d_(Int(1))
apply_calibration = d_(Bool(True))
def _default_name(self):
return self.source_name + '_grouped_epoch_fft_plot'
def _cache_x(self, event=None):
# Cache the frequency points. Must be in units of log for PyQtGraph.
# TODO: This could be a utility function stored in the parent?
if self.source.fs and self.duration:
self._x = get_x_fft(self.source.fs,
self.duration / self.waveform_averages)
def _y(self, epoch):
y = super()._y(epoch)
psd = util.psd(y,
self.source.fs,
waveform_averages=self.waveform_averages)
if self.apply_calibration:
return self.source.calibration.get_db(self._x, psd)
return util.db(psd)
class BFGigEStreamChannel(BFProperty):
"""Class containing the Configuration properties for a Blackfly camera.
Use this as a basis for other settings classes from blackfly. If you mirror
the structure in the reference manual it will make it easy to make the
server.
"""
networkInterfaceIndex = Int(0)
# hostPort = Int(0)
doNotFragment = Bool(False)
packetSize = Int(1224)
interPacketDelay = Int(100)
# destinationIpAddress = Int()
# sourcePort = ()
def __init__(self, name, experiment, description=''):
"""Add in the properties that need to be sent to the camera."""
super(BFGigEStreamChannel, self).__init__(name, experiment,
description)
# things not in the property list are not sent to the camera
self.properties += ['packetSize', 'interPacketDelay']
class CheckTask(SimpleTask):
"""
"""
check_called = Bool()
perform_called = Int()
perform_value = Value()
time = Float(0.01)
def check(self, *args, **kwargs):
self.check_called = True
return True, {}
def perform(self, value=None):
self.perform_called += 1
self.perform_value = value
# Simply allow thread switching
sleep(self.time)
class Parameter(ContextItem):
'''
A context item that can be evaluated dynamically, but cannot be included as
part of a selector. This is typically used for settings that must be
determined before values are drawn from the selectors (e.g., probability of
a go trial).
'''
# Default value of the context item when used as part of a selector.
default = d_(Value())
expression = d_(Str()).tag(preference=True)
# Defines the span over which the item's value does not change:
# * experiment - the value cannot change once the experiment begins
# * trial - The value cannot change once a trial begins. This is the only
# type of item that can be roved using a selector.
# * arbitrary - The value can be changd at any time but it does not make
# sense for it to be a roving item.
scope = d_(Enum('trial', 'experiment', 'arbitrary'))
# Is the value of this item managed by a selector?
rove = d_(Bool()).tag(preference=True)
def _default_expression(self):
return str(self.default)
def _default_dtype(self):
return np.array(self.default).dtype.str
def _default_label(self):
return self.name
def to_expression(self, value):
return str(value)
def set_value(self, value):
self.expression = self.to_expression(value)
class HttpResponse(Atom):
""" The response object returned to an AsyncHttpClient fetch callback.
It is based on the the tornado HttpResponse object.
"""
#: Request that created this response
request = Instance(HttpRequest)
#: Numeric HTTP status code
code = Int()
#: Reason phrase for the status code
reason = Unicode()
#: Response headers list of strings
headers = Dict()
#: Result success
ok = Bool()
#: Response body
#: Note: if a streaming_callback is given to the request
#: then this is NOT used and will be empty
body = Unicode()
#: Size
content_length = Int()
#: Error message
error = Instance(HttpError)
#: Progress
progress = Int()
#: Done time
request_time = Float()
class Output(BaseOutput):
# These two are defined as properties because it's theoretically possible
# for the output to transform these (e.g., an output could upsample
# children or "equalize" something before passing it along).
fs = Property().tag(metadata=True)
calibration = Property().tag(metadata=True)
filter_delay = Property().tag(metadata=True)
# TODO: clean this up. it's sort of hackish.
token = d_(Typed(Declarative)).tag(metadata=True)
# Can the user configure properties (such as the token) via the GUI?
configurable = d_(Bool(True))
callbacks = List()
def connect(self, cb):
self.callbacks.append(cb)
def notify(self, data):
if not self.callbacks:
return
# Correct for filter delay
d = data.copy()
d['t0'] += self.filter_delay
for cb in self.callbacks:
cb(d)
def _get_filter_delay(self):
return self.target.filter_delay
def _get_fs(self):
return self.channel.fs
def _get_calibration(self):
return self.channel.calibration
class DummyMonitor(BaseMonitor):
"""Dummy monitor used for testing.
"""
running = Bool()
monitored_entries = set_default(['default_path'])
received_news = List()
def start(self):
self.running = True
def stop(self):
self.running = False
def refresh_monitored_entries(self, entries=None):
"""Do nothing when refreshing.
"""
pass
def handle_database_entries_change(self, news):
"""Add all entries to the monitored ones.
"""
if news[0] == 'added':
self.monitored_entries = self.monitored_entries + [news[1]]
def handle_database_nodes_change(self, news):
"""Simply ignore nodes updates.
"""
pass
def process_news(self, news):
self.received_news.append(news)
class Markdown(Raw):
""" A block for rendering Markdown source. """
#: Extensions to use when rendering
extensions = d_(
List(default=[
"markdown.extensions.codehilite",
"markdown.extensions.fenced_code",
])).tag(attr=False)
#: Configuration for them
extension_configs = d_(
Dict(default={
'markdown.extensions.codehilite': {
'css_class': 'highlight'
},
})).tag(attr=False)
#: Disallow raw HTMl
safe_mode = d_(Bool()).tag(attr=False)
#: Output format
output_format = d_(
Enum("xhtml1", "xhtml5", "xhtml", "html4", "html5",
"html")).tag(attr=False)
#: Tab size
tab_length = d_(Int(4)).tag(attr=False)
#: Reference to the proxy
proxy = Typed(ProxyMarkdown)
@observe('extensions', 'extension_configs', 'safe_mode', 'output_format',
'tab_length')
def _update_proxy(self, change):
""" The superclass implementation is sufficient. """
super(Markdown, self)._update_proxy(change)
class AbstractConfig(Atom):
"""Root class for all config objects.
"""
#: Exopy_pulses manager, necessary to retrieve item(pulse/sequence)
#: implementations.
manager = ForwardTyped(pulses_manager)
#: Class of the item to create.
sequence_class = Subclass(Item)
#: Root of the sequence in which an item will be added.
root = Typed(Item)
#: Bool indicating if the build can be done.
ready = Bool(False)
def check_parameters(self, change):
"""Check if enough parameters have been provided to build the item.
This method should set the ready flag every time it is called, setting
it to True if everything is allright, False otherwise.
"""
raise NotImplementedError()
def build_sequence(self):
"""This method use the user parameters to build the item object.
Returns
-------
item : Item | None
Item object built using the user parameters. Ready to be
inserted in a sequence. None if errors occured.
"""
raise NotImplementedError()
class StreamInterpolator(Atom):
filespec = Typed(StreamFileSpec)
is_reference = Bool(False)
selector = Enum(*RECORD_SELECTORS)
latency = Float(0.0)
streamfile = Typed(StreamFile)
@property
def fieldname(self):
return self.filespec.fieldname
@property
def datatype(self):
return self.filespec.datatype
@property
def is_array(self):
return self.filespec.is_array
@property
def timestamps(self):
return self.streamfile.timestamps
@property
def interval(self):
return self.streamfile.interval
@property
def record_count(self):
return self.streamfile.count
def _default_streamfile(self):
return self.filespec.getStreamFile()
def get(self, idx, dts):
return self.streamfile.get(idx, dts - self.latency, self.selector)
class Toast(ToolkitObject):
""" A toast is a view containing a quick little message for the user.
"""
#: Text to display
#: if this node has a child view this is ignored
text = d_(Unicode())
#: Duration to display in ms
duration = d_(Int(1000))
#: x position
x = d_(Int())
#: y position
y = d_(Int())
#: Position
gravity = d_(Coerced(int, coercer=coerce_gravity))
#: Show the notification for the given duration
show = d_(Bool())
#: A reference to the proxy object.
proxy = Typed(ProxyToast)
# -------------------------------------------------------------------------
# Observers
# -------------------------------------------------------------------------
@observe('text', 'duration', 'show', 'gravity', 'x', 'y')
def _update_proxy(self, change):
""" An observer which sends the state change to the proxy.
"""
# The superclass implementation is sufficient.
super(Toast, self)._update_proxy(change)
class Clock(Atom):
""" A clock so widgets can observe each field as required. """
year = Int()
month = Int()
day = Int()
hour = Int()
minute = Int()
second = Int()
running = Bool(True)
now = Instance(datetime, factory=lambda: datetime.now())
def _observe_running(self, change):
if self.running:
timed_call(0, self.tick)
def _observe_now(self, change):
t = self.now
self.year, self.month, self.day = t.year, t.month, t.day
self.hour, self.minute, self.second = t.hour, t.minute, t.second
if self.running:
timed_call(1000, self.tick)
def tick(self):
self.now = datetime.now()
class SetRFPowerTask(InterfaceableTaskMixin, InstrumentTask):
"""Set the power of the signal delivered by the source.
"""
# Target power (dynamically evaluated)
power = Unicode().tag(pref=True, feval=LOOP_REAL)
# Whether to start the source if its output is off.
auto_start = Bool(False).tag(pref=True)
database_entries = set_default({'power': -10})
def i_perform(self, power=None):
"""
"""
if self.auto_start:
self.driver.output = 'On'
if power is None:
power = self.format_and_eval_string(self.power)
self.driver.power = power
self.write_in_database('power', power)
class PlotElement(Atom):
"""Element of plot interacting with the backend through a proxy."""
#: Name of the backend to use
backend_name = Str()
#: Backend specific proxy
proxy = Typed(PlotElementProxy)
#: Control the visibility of the element.
visibility = Bool(True)
def initialize(self, resolver):
"""Initialize the element by creating the proxy."""
proxy = resolver.resolve_proxy(self)
proxy.activate()
self.observe("visibility", update_proxy)
def finalize(self):
"""Finalize the element by destroying the proxy."""
self.unobserve("visibility", update_proxy)
self.proxy.deactivate()
del self.proxy.element
del self.proxy
class DropFirstMeasurementsFilter(Analysis):
"""This analysis allows the user to drop the first N measurements in an
iteration, to ensure that all measurements are done at equivalent conditions
."""
version = '2014.06.12'
enable = Bool()
filter_level = Int()
N = Int()
def __init__(self, name, experiment, description=''):
super(DropFirstMeasurementsFilter,
self).__init__(name, experiment, description)
self.properties += ['version', 'enable', 'filter_level', 'N']
def analyzeMeasurement(self, measurementResults, iterationResults,
experimentResults):
if self.enable:
i = measurementResults.attrs['measurement']
if i < self.N:
# User chooses whether or not to delete data.
# max takes care of ComboBox returning -1 for no selection
logger.info('dropping measurement {} of {}'.format(i, self.N))
return max(0, self.filter_level)
class Plot1DLine(Plot1D):
""""""
#: Color of the plot
color = ColorMember()
#: Weight of the line
line_weight = Float(1.0)
#: Style of the line
line_style = Str()
#: Should markers be displayed
markers_enabled = Bool()
#: Size of the markers
markers_size = Float()
#: Shape of the marker
# FIXME complete
marker_shape = Enum((
"*",
"+",
))
class SeekBar(ProgressBar):
""" A simple control for displaying read-only text.
"""
#: Sets the amount of progress changed via the arrow keys.
key_progress_increment = d_(Int())
#: Specifies whether the track should be split by the thumb.
split_track = d_(Bool())
#: A reference to the SeekBar object.
proxy = Typed(ProxySeekBar)
# -------------------------------------------------------------------------
# Observers
# -------------------------------------------------------------------------
@observe('key_progress_increment', 'split_track')
def _update_proxy(self, change):
""" An observer which sends the state change to the proxy.
"""
# The superclass implementation is sufficient.
super(SeekBar, self)._update_proxy(change)
