class RuntimeDependency(Declarative):
"""Extension to the 'runtime-dependencies' extensions point of the
TaskManagerPlugin.
Attributes
----------
id : unicode
Unique Id.
walk_members : list(str)
List of members for the walk method of the ComplexTask.
walk_kwargs : dict(str: callable)
Dict of name: callables for the walk method of the ComplexTask.
collect : callable(workbench, flatten_walk)
Callable in charge of collecting the identified build dependencies.
It should take as arguments the workbench of the application, a dict
in the format {name: set()} and the calling plugin id. It should return
a dict holding the dependencies (as dictionaries) in categories. If
there is no dependence for a given category this category should be
absent from the dict.
The input falt_walk should be left untouched. In case of failure it
should raise a value error.
"""
id = d_(Unicode())
walk_members = d_(List(Str()))
walk_callables = d_(Dict(Str(), Callable()))
collect = d_(Callable())
class ExperimentActionBase(Declarative):
# Name of event that triggers command
event = d_(Unicode())
dependencies = List()
match = Callable()
# Defines order of invocation. Less than 100 invokes before default. Higher
# than 100 invokes after default. Note that if concurrent is True, then
# order of execution is not guaranteed.
weight = d_(Int(50))
# Arguments to pass to command by keyword
kwargs = d_(Dict())
def _default_dependencies(self):
return get_dependencies(self.event)
def _default_match(self):
code = compile(self.event, 'dynamic', 'eval')
if len(self.dependencies) == 1:
return partial(simple_match, self.dependencies[0])
else:
return partial(eval, code)
def __str__(self):
return f'{self.event} (weight={self.weight}; kwargs={self.kwargs})'
class Measurement(LogicalChannel):
'''
A class for measurement channels.
Measurements are special because they can be different types:
autodyne which needs an IQ pair or hetero/homodyne which needs just a marker channel.
'''
meas_type = Enum(
'autodyne',
'homodyne').tag(desc='Type of measurement (autodyne, homodyne)')
autodyne_freq = Float(0.0).tag(
desc=
'use to bake the modulation into the pulse, so that it has constant phase'
)
frequency = Float(0.0).tag(
desc='use frequency to asssociate modulation with the channel')
pulse_params = Dict(
default={
'length': 100e-9,
'amp': 1.0,
'shape_fun': PulseShapes.tanh,
'cutoff': 2,
'sigma': 1e-9
})
gate_chan = Instance((str, LogicalMarkerChannel))
trig_chan = Instance((str, LogicalMarkerChannel))
receiver_chan = Instance((str, ReceiverChannel))
def __init__(self, **kwargs):
super(Measurement, self).__init__(**kwargs)
if self.trig_chan is None:
self.trig_chan = LogicalMarkerChannel(label='digitizerTrig')
class ParameterProxyBase(Atom):
_params = Dict()
def __str__(self):
return "ParameterProxy[" + ",".join(
"{0}={1}".format(k, getattr(self, k))
for k in self._params.keys()) + "]"
class Date(HTMLObject):
tag = E.INPUT
text = d_(Unicode())
id = d_(Unicode())
date = d_(Dict())
def initialize(self):
super(Date, self).initialize()
def buildHTML(self, *args):
self.addTags()
self.addText(self.text)
self.addAttributes()
if self.id:
self.addAttributes(type = "date", id = self.id)
return super(Date, self).buildHTML(*args)
#@observe(('date'))
def _update_web(self, change):
super(Date, self)._update_web(change)
class Measurement(LogicalChannel):
'''
A class for measurement channels.
Measurments are special because they can be different types:
autodyne which needs an IQ pair or hetero/homodyne which needs just a marker channel.
'''
measType = Enum(
'autodyne',
'homodyne').tag(desc='Type of measurment (autodyne, homodyne)')
autodyneFreq = Float()
pulseParams = Dict(
default={
'length': 100e-9,
'amp': 1.0,
'shapeFun': PulseShapes.tanh,
'buffer': 0.0,
'cutoff': 2,
'sigma': 1e-9
})
gateChan = Instance((unicode, LogicalMarkerChannel))
def __init__(self, **kwargs):
super(Measurement, self).__init__(**kwargs)
if self.gateChan is None:
self.gateChan = LogicalMarkerChannel(label=kwargs['label'] +
'-gate')
class NoSQLModelManager(ModelManager):
"""A descriptor so you can use this somewhat like Django's models.
Assuming your using motor or txmongo.
Examples
--------
MyModel.objects.find_one({'_id':'someid})
"""
#: Table proxy cache
proxies = Dict()
def __get__(self, obj, cls=None):
"""Handle objects from the class that owns the manager"""
cls = cls or obj.__class__
if not issubclass(cls, Model):
return self # Only return the collection when used from a Model
proxy = self.proxies.get(cls)
if proxy is None:
proxy = self.proxies[cls] = NoSQLDatabaseProxy(
table=self.database[cls.__model__]
)
return proxy
def _default_database(self):
raise EnvironmentError(
"No database has been set. Use "
"NoSQLModelManager.instance().database = <db>"
)
class User(AbstractUser):
id = Typed(int).tag(primary_key=True, name="user_id")
name = Str().tag(length=200)
active = Bool()
age = Int()
settings = Dict()
rating = Instance(float).tag(nullable=True)
class Read_Extension_Test(Read_File):
"""a test class for extending Read_File"""
data=Dict()
def read(self):
self.data={"file_path": self.file_path}
return super(Read_Extension_Test, self).read()
class DocksRenderController(VTKRenderController):
""" Docks model
"""
backgrounds = Dict()
def __init__(self, view=None, bgColor=None, callbacks=None):
"""
default init
"""
super(DocksRenderController, self).__init__(view=view, bgColor=bgColor, callbacks=callbacks)
self.addActors(visquad())
def set_background(self, background):
"""
set models background
"""
self.bgColor = background
if self.view:
deferred_call(self.view.render)
def set_interactor_style(self, style):
"""
set interactor style
"""
self.setInteractorStyle(style)
class Read_HDF5(Filer):
data = Dict()
def open_and_read(self):
with File(self.file_path, 'r') as f:
self.data = self.reread(
f) #print key, item.keys(), isinstance(item, Group)
print "Read data from file: {0}".format(self.file_path)
return self.data
def reread(self, g, md=dict()):
"""recursively reads all data into a dictionary"""
for key, item in g.iteritems():
md[key] = dict()
if isinstance(item, Group):
md[key] = self.reread(item, md[key])
else:
md[key]['data'] = item[:]
if item.attrs.keys() != []:
md[key]['attrs'] = dict()
for akey, aitem in item.attrs.iteritems():
md[key]['attrs'][akey] = aitem
return md
def read_txt(self):
self.data = {"data": loadtxt(self.file_path)}
return self.data
class GlobalConfig(Atom):
domain_name = Str()
setup_name = Str()
user_name = Str()
platform_name = Str()
config_directory = Str()
data_directory = Str()
record_directory = Str()
components_path = Str()
logging_config = Str()
py_logging_config = Str()
plugins = Dict()
devices = Dict()
class ProxyResolver(Atom):
""" An object which resolves requests for proxy objects.
"""
#: A dictionary of factories functions to use when resolving the
#: proxy. The function should take no arguments, and return the
#: proxy class when called.
factories = Dict()
def resolve(self, name):
""" Resolve the given name to a proxy calls.
For example, 'Field' should resolve to a class which implements
the ProxyField interface.
Parameters
----------
name : str
The name of the proxy object to resolve.
Returns
-------
result : type or None
A class which implements the proxy interface, or None if
no class can be found for the given name.
"""
factory = self.factories.get(name)
if factory is not None:
return factory()
class GraphicsNode(GraphicsSceneGraphNode):
#: options to be set before rendering
gl_options = d_(Dict())
antialias = d_(Bool(True))
@observe("gl_options", "antialias")
def _gn_trigger_update(self, change):
self.trigger_update()
def setup_gl(self):
for k, v in self.gl_options.items():
if v is None:
continue
if isinstance(k, basestring):
func = getattr(GL, k)
func(*v)
else:
if v is True:
glEnable(k)
else:
glDisable(k)
def render_node(self, context):
self.setup_gl()
class StoreRecordSource(BaseRecordSource):
fields = Dict()
def _default_max_record_count(self):
return len(self.reference_timestamps)
# XXX missing reference_interval
def __iter__(self):
if len(self.cached_records) > 0:
for cached_record in self.cached_records:
yield cached_record
return
rcls = self.record_class
fields = self.fields
field_names = fields.keys()
for idx, ts in enumerate(self.reference_timestamps):
attrs = dict(timestamp=ts)
for field_name in field_names:
attrs[field_name] = fields[field_name][idx]
record = rcls(**attrs)
self.cached_records.append(record)
yield record
class Markdown(Raw):
""" A block for rendering Markdown source. """
#: Extensions to use when rendering
extensions = d_(
List(basestring, default=["markdown.extensions.codehilite"]))
#: Configuration for them
extension_configs = d_(
Dict(basestring,
dict,
default={
'markdown.extensions.codehilite': {
'css_class': 'highlight'
},
}))
#: Reference to the proxy
proxy = Typed(ProxyMarkdown)
#: Disallow raw HTMl
safe_mode = d_(Bool())
#: Output format
output_format = d_(
Enum("xhtml1", "xhtml5", "xhtml", "html4", "html5", "html"))
#: Tab size
tab_length = d_(Int(4))
@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 OccFillet(OccOperation, ProxyFillet):
shape_types = Dict(default={
'rational':ChFi3d_Rational,
'angular':ChFi3d_QuasiAngular,
'polynomial':ChFi3d_Polynomial
})
def update_shape(self, change={}):
d = self.declaration
#: Get the shape to apply the fillet to
children = [c for c in self.children()]
if not children:
raise ValueError("Fillet must have a child shape to operate on.")
child = children[0]
s = child.shape.Shape()
shape = BRepFilletAPI_MakeFillet(s)#,self.shape_types[d.shape])
edges = d.edges if d.edges else child.topology.edges()
for edge in edges:
shape.Add(d.radius, edge)
#if not shape.HasResult():
# raise ValueError("Could not compute fillet, radius possibly too small?")
self.shape = shape
def set_shape(self, shape):
self._queue_update({})
def set_radius(self, r):
self._queue_update({})
def set_edges(self, edges):
self._queue_update({})
class Console(Container):
""" Console widget """
proxy = Typed(ProxyConsole)
#: Font family, leave blank for default
font_family = d_(Unicode())
#: Font size, leave 0 for default
font_size = d_(Int(0))
#: Default console size in characters
console_size = d_(Coerced(Size,(81,25)))
#: Buffer size, leave 0 for default
buffer_size = d_(Int(0))
#: Display banner like version, etc..
display_banner = d_(Bool(False))
#: Code completion type
#: Only can be set ONCE
completion = d_(Enum('ncurses','plain', 'droplist'))
#: Run the line or callabla
execute = d_(Instance(object))
#: Push variables to the console
#: Note this is WRITE ONLY
scope = d_(Dict(),readable=False)
@observe('font_family','font_size','console_size','buffer_size',
'scope','display_banner','execute','completion')
def _update_proxy(self, change):
super(Console, self)._update_proxy(change)
class DictAtom(Atom):
untyped = Dict()
keytyped = Dict(Int())
valuetyped = Dict(value=Int())
fullytyped = Dict(Int(), Int())
untyped_default = Dict(default={1: 1})
keytyped_default = Dict(Int(), default={1: 1})
valuetyped_default = Dict(value=Int(), default={1: 1})
fullytyped_default = Dict(Int(), Int(), default={1: 1})
class Bookmark(Atom):
#: Name of it
name = Unicode()
#: Bible
bible = ForwardInstance(lambda: Bible)
#: Book
book = Instance(Book)
#: Chapter
chapter = Instance(Chapter)
#: Verse
#verse = Instance(Verse)
#: Save / load state
state = Dict()
def __init__(self, *args, **kwargs):
super(Bookmark, self).__init__(*args, **kwargs)
if kwargs.get('state') is None:
#: If we're not loading from state
self.state = {
'bible': self.bible.version.key,
'book': self.book.name,
'chapter': self.chapter.number,
#'verse': self.verse.number
}
def _default_name(self):
return u"{} {}".format(self.book.name, self.chapter.number)
def _default_bible(self):
try:
#: Prevent loading two bibles if it was bookmarked in a different bible
bible = AppState.instance().bible
if bible is not None:
return bible
return AppState.instance().get_bible(self.state['bible'])
except KeyError:
return None
def _default_book(self):
if not self.bible:
return None
try:
return self.bible.get_book(self.state['book'])
except KeyError:
return None
def _default_chapter(self):
if not self.book:
return None
try:
#: They're supposed to be in order
return self.book.chapters[self.state['chapter'] - 1]
except KeyError:
return None
class User(NoSQLModel):
name = Str()
email = Str()
active = Bool()
settings = Dict()
def _default_settings(self):
return {"font-size": 16, "theme": "maroon"}
class LogicalMarkerChannel(LogicalChannel):
'''
A class for digital channels for gating sources or triggering other things.
'''
pulseParams = Dict(default={
'shapeFun': PulseShapes.square,
'length': 100e-9
})
class Figure(PlotElement):
"""Figure holding possibly multiple axes on a grid."""
#: Set of axes on a grid.
axes_set = Dict(str, Axes)
#: Position of the axes on the grid
grid = Dict(str, GridPosition)
def initialize(self, resolver):
"""Initialize the proxy of the figure and the axes."""
self._resolver = resolver
super().initialize(resolver)
for axes in self.axes_set.values():
axes.figure = self
axes.backend_name = self.backend_name
axes.initialize(resolver)
def finalize(self):
"""Finalize the proxy of the figure."""
for axes in self.axes_set.values():
axes.figure = self
axes.finalize()
super().finalize()
def add_axes(self,
id: str,
position: GridPosition,
axes: Optional[Axes] = None) -> Axes:
"""Add an axes to the figure"""
axes = axes or Axes()
self.axes_set[id] = axes
self.grid[id] = position
if self._resolver:
axes.initialize(self._resolver)
return axes
def remove_axes(self, id: str):
""""""
pass # FIXME not needed as long as we have a single axes per figure
# --- Private API
#: Reference to the backend resolver needed to dynamically add axes
_resolver = Typed(BackendResolver)
class PatternTemplate(UTQLSchemaEntity):
name = Str()
displayName = Str()
description = Str()
nodes = Dict()
constraints = List()
input_edges = List()
output_edges = List()
type_registry = Dict()
references = Dict()
dataflow_config = Typed(DataflowConfiguration)
class OccPipe(OccOperation, ProxyPipe):
reference = set_default('https://dev.opencascade.org/doc/refman/html/'
'class_b_rep_offset_a_p_i___make_pipe.html')
#: References to observed shapes
_old_spline = Instance(OccShape)
_old_profile = Instance(OccShape)
fill_modes = Dict(
default={
'corrected_frenet': GeomFill_IsCorrectedFrenet,
'fixed': GeomFill_IsFixed,
'frenet': GeomFill_IsFrenet,
'constant_normal': GeomFill_IsConstantNormal,
'darboux': GeomFill_IsDarboux,
'guide_ac': GeomFill_IsGuideAC,
'guide_plan': GeomFill_IsGuidePlan,
'guide_ac_contact': GeomFill_IsGuideACWithContact,
'guide_plan_contact': GeomFill_IsGuidePlanWithContact,
'discrete_trihedron': GeomFill_IsDiscreteTrihedron
})
def update_shape(self, change=None):
d = self.declaration
if d.spline and d.profile:
spline, profile = d.spline, d.profile
elif d.spline:
spline = d.spline
profile = self.get_first_child().shape
elif d.profile:
profile = d.profile
spline = self.get_first_child().shape
else:
shapes = [
c.shape for c in self.children() if isinstance(c, OccShape)
]
spline, profile = shapes[0:2]
args = [coerce_shape(spline), coerce_shape(profile)]
# Make sure spline is a wire
if isinstance(args[0], TopoDS_Edge):
args[0] = BRepBuilderAPI_MakeWire(args[0]).Wire()
if d.fill_mode:
args.append(self.fill_modes[d.fill_mode])
pipe = BRepOffsetAPI_MakePipe(*args)
self.shape = pipe.Shape()
def set_spline(self, spline):
self.update_shape()
def set_profile(self, profile):
self.update_shape()
def set_fill_mode(self, mode):
self.update_shape()
class TaskCheckModel(Atom):
"""Simple dialog displaying the errors messages resulting from a failed
check.
Attributes
----------
check_dict_result : dict(str, str)
Dictionnary storing the path of the task in which a check failed and
the associated message.
name_to_path_dict : dict(str, str)
Dictionnary mapping the name of the tasks in which a check failed to its
path.
selected_check : str
Name of the task the user selected from `failed_check_list`.
full_path : str
Path of the selected task.
message : str
Message associated to the selected task.
"""
check_dict_result = Dict(Str(), Str())
name_to_path_dict = Dict(Str(), Str())
selected_check = Str()
full_path = Str()
message = Str()
def __init__(self, check_dict_result):
super(TaskCheckModel, self).__init__()
self.check_dict_result = check_dict_result
self.name_to_path_dict = {
key.rpartition('/')[-1]: key
for key in self.check_dict_result.keys()
}
self.selected_check = self.name_to_path_dict.keys()[0]
self.full_path = self.name_to_path_dict[self.selected_check]
self.message = self.check_dict_result[self.full_path]
@observe('selected_check')
def _update(self, change):
"""Automatically set the `full_path` and `message` attribute when the
user select a new failed check.
"""
new = change['value']
self.full_path = self.name_to_path_dict[new]
self.message = self.check_dict_result[self.full_path]
class ViewerSelectionEvent(Atom):
#: Selected shape or shapes
selection = List()
#: Parameters such as coodrinates or selection area
parameters = Tuple()
#: Selection callback parameters
options = Dict()
class RequestPattern(AbstractPattern):
nodes = Dict()
constraints = List()
input_edges = List()
output_edges = List()
dataflow_config = Typed(DataflowConfiguration)
class RenderViewController(VTKRenderController):
""" render view controller
"""
backgrounds = Dict()
extract_model = Value()
shrink_factor = Int()
radius = Int()
def __init__(self, view=None, bgColor=None, callbacks=None):
"""
default init
"""
super(RenderViewController, self).__init__(view=view, bgColor=bgColor, callbacks=callbacks)
self.shrink_factor = 55
self.radius = 25
self.extract_model = ExtractModel(shrink_factor=self.shrink_factor/100., radius=self.radius/100.)
self.addActors(self.extract_model.get_actors())
def set_background(self, background):
"""
set models background
"""
self.bgColor = background
if self.view:
deferred_call(self.view.render)
def set_interactor_style(self, style):
"""
set interactor style
"""
self.setInteractorStyle(style)
def on_close(self):
"""
on close
"""
pass
def _observe_shrink_factor(self, change):
""" observe change in shrink factor """
if change:
type_ = change.get('type')
if type_ != 'create':
value = change['value']
self.extract_model.shrink_geom.SetShrinkFactor(value/100.)
deferred_call(self.view.render)
def _observe_radius(self, change):
""" observe change in radius """
if change:
type_ = change.get('type')
if type_ != 'create':
value = change['value']
self.extract_model.sphere_geom_1.SetRadius(value/100.)
self.extract_model.sphere_geom_2.SetRadius(value/100.)
deferred_call(self.view.render)
class IconTheme(Declarative):
"""Declaration of an icon theme.
An icon theme should provide the following icons as far as the main
application is concerned:
- folder-open
-
-
-
"""
#: Unique id of the icon theme.
id = d_(Str())
@d_func
def get_icon(self, manager, icon_id):
"""Generate an icon corresponding to an id.
By default an icon theme simply check its children Icons and ask it to
generate the actual icon.
Parameters
----------
manager : IconManagerPlugin
Reference to the plugin manager.
icon_id : unicode
Id of the icon which should be generated.
Returns
-------
icon : enaml.icon.Icon or None
Icon matching the id or None if no icon match the provided id.
"""
if not self._icons and self.children:
self._refresh_children_icons()
if icon_id in self._icons:
return self._icons[icon_id].get_icon(manager, self)
else:
return None
# --- Private API ---------------------------------------------------------
#: Map of id: icon as declared as children to this theme.
_icons = Dict()
def _refresh_children_icons(self):
"""Refresh the mapping of the icons contributed as children.
"""
# HINT when reparenting enaml does not properly update the children
for c in [c for c in self.children if c.parent is self]:
if isinstance(c, Icon):
self._icons[c.id] = c
