class ScorePoseTask(taskbase.TaskBase): weights = traitlets.CUnicode(allow_none=True) patch = traitlets.CUnicode(allow_none=True) def __init__(self, weights=None, patch=None): super().__init__(weights=weights, patch=patch) def setup(self): self.protocol_lock = threading.Lock() @property @pyrosetta.distributed.requires_init @pyrosetta.distributed.with_lock def score_function(self): if not self.weights: return scoring.get_score_function() elif not self.patch: sff = scoring.ScoreFunctionFactory() return sff.create_score_function(self.weights) else: sff = scoring.ScoreFunctionFactory() return sff.create_score_function(self.weights, self.patch) @pyrosetta.distributed.requires_init def execute(self, pack_or_pose): work_pose = packed_pose.to_packed(pack_or_pose).pose with self.protocol_lock: self.score_function(work_pose) return packed_pose.PackedPose(work_pose)
class Bus(t.HasTraits): '''Bus Model''' name = t.CUnicode(default_value='Bus1', help='Name of Generator (str)') bus_type = t.Enum( values=['SWING', 'PQ', 'PV'], default_value='PQ', help='Bus type', ) real_power_demand = tt.Array(default_value=[0.0], minlen=1, help='Active power demand (MW)') imag_power_demand = tt.Array(default_value=[0.0], minlen=1, help='Reactive power demand (MVAR)') shunt_conductance = t.CFloat(default_value=0, help='Shunt Conductance (TODO: units)') shunt_susceptance = t.CFloat(default_value=0, help='Shunt Susceptance (TODO: units)') area = t.CUnicode(default_value='0', help='Area the bus is located in') voltage_magnitude = t.CFloat(default_value=1.0, help='Voltage magnitude (p.u.)') voltage_angle = t.CFloat(default_value=0.0, help='Voltage angle (deg)') base_voltage = t.CFloat(default_value=230, help='Base voltage (kV)') zone = t.CUnicode(default_value='0', help='Zone the bus is located in') maximum_voltage = t.CFloat(default_value=1.05, help='Maximum voltage') minimum_voltage = t.CFloat(default_value=0.95, help='Minimum voltage') def __init__(self, **kwargs): v = kwargs.pop('real_power_demand', None) v = self._coerce_value_to_list({'value': v}) kwargs['real_power_demand'] = v v = kwargs.pop('imag_power_demand', None) v = self._coerce_value_to_list({'value': v}) kwargs['imag_power_demand'] = v super(Bus, self).__init__(**kwargs) @t.validate('real_power_demand', 'imag_power_demand') def _coerce_value_to_list(self, proposal): v = proposal['value'] if (v is not None and (isinstance(v, int) or isinstance(v, float))): v = [ v, ] elif v is None: v = [ 0.0, ] return v
class IDObject(widgets.Widget): """ an object with an id """ id = HashableType() groups = trait.List(trait=trait.CUnicode(), default_value=("all", ), help='the groups that this object belongs to') other_info = trait.CUnicode( '', help='other information about the object as HTML').tag(sync=True) @trait.default('id') def _default_id(self): return uuid.uuid4() def get_object_trait_names(self): """ get trait names which are only associated with the object, i.e. not from the ipywidgets base class """ base_ipywidget_traits = set(widgets.Widget().trait_names()) all_traits = set(self.trait_names()) return list(all_traits.difference(base_ipywidget_traits)) def trait_series(self): """ create pandas.Series of objects traits Examples -------- >>> obj = IDObject(id=1,other_info='test') >>> obj.trait_series() groups (all,) id 1 other_info test dtype: object """ trait_dict = {} for name in self.get_object_trait_names(): value = getattr(self, name) # might break series if cell value is a list value = tuple(value) if isinstance(value, list) else value trait_dict[name] = value return pd.Series(trait_dict) # def _repr_latex_(self): # """ # """ # return self.trait_series().to_latex() def __repr__(self): """ visualising in jupyter notebook """ return self.trait_series().to_string()
class TriclinicSolid(GeometricObject): """ a wireframe object Examples -------- >>> box = TriclinicSolid() >>> box.position (0.0, 0.0, 0.0) >>> box.a (1.0, 0.0, 0.0) >>> try: ... box.pivot = '' ... except Exception as err: ... print(err) pivot must be at the centre or corner """ a = Vector3(default_value=(1, 0, 0), help='box vector a').tag(sync=True) b = Vector3(default_value=(0, 1, 0), help='box vector b').tag(sync=True) c = Vector3(default_value=(0, 0, 1), help='box vector c').tag(sync=True) pivot = trait.CUnicode('centre', help='pivot about centre or corner').tag(sync=True) @trait.validate('pivot') def _valid_pivot(self, proposal): pivot = proposal['value'] if pivot not in ['centre', 'corner']: raise trait.TraitError('pivot must be at the centre or corner') return proposal['value']
class BaseRosettaScriptsTask(taskbase.TaskBase): @property @pyrosetta.distributed.requires_init @pyrosetta.distributed.with_lock def parser(self): if not getattr(self, "_parser", None): BaseRosettaScriptsTask._parser = \ rosetta_scripts.RosettaScriptsParser() return self._parser protocol_xml = traitlets.CUnicode() def __init__(self, protocol_xml): super().__init__(protocol_xml=protocol_xml) @pyrosetta.distributed.requires_init @pyrosetta.distributed.with_lock def setup(self): self.default_options = pyrosetta.rosetta.basic.options.process() self.tag = self.parser.create_tag_from_xml_string( self.protocol_xml, self.default_options) # Validate by parsing self.parser.parse_protocol_tag(self.tag, self.default_options) self.protocol_lock = threading.Lock() @property @pyrosetta.distributed.requires_init @pyrosetta.distributed.with_lock def parsed_protocol(self): return self.parser.parse_protocol_tag(self.tag, self.default_options) def execute(self, pack_or_pose): return packed_pose.to_packed(self.apply(pack_or_pose))
class VertexAttribute(traitlets.HasTraits): name = traitlets.CUnicode("attr") id = traitlets.CInt(-1) data = traittypes.Array(None, allow_none=True) each = traitlets.CInt(-1) opengl_type = traitlets.CInt(GL.GL_FLOAT) divisor = traitlets.CInt(0) @traitlets.default("id") def _id_default(self): return GL.glGenBuffers(1) @contextmanager def bind(self, program=None): loc = -1 if program is not None: loc = GL.glGetAttribLocation(program.program, self.name) if loc >= 0: GL.glVertexAttribDivisor(loc, self.divisor) _ = GL.glEnableVertexAttribArray(loc) _ = GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.id) if loc >= 0: GL.glVertexAttribPointer(loc, self.each, self.opengl_type, False, 0, None) yield if loc >= 0: GL.glDisableVertexAttribArray(loc) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0) @traitlets.observe("data") def _set_data(self, change): arr = change["new"] self.each = arr.shape[-1] self.opengl_type = np_to_gl[arr.dtype.name] with self.bind(): GL.glBufferData(GL.GL_ARRAY_BUFFER, arr.nbytes, arr, GL.GL_STATIC_DRAW)
class VertexArray(traitlets.HasTraits): name = traitlets.CUnicode("vertex") id = traitlets.CInt(-1) indices = traittypes.Array(None, allow_none=True) index_id = traitlets.CInt(-1) attributes = traitlets.List(trait=traitlets.Instance(VertexAttribute)) each = traitlets.CInt(-1) @traitlets.default("id") def _id_default(self): return GL.glGenVertexArrays(1) @contextmanager def bind(self, program=None): GL.glBindVertexArray(self.id) if self.index_id != -1: GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, self.index_id) # We only bind the attributes if we have a program too if program is None: attrs = [] else: attrs = self.attributes with ExitStack() as stack: _ = [stack.enter_context(_.bind(program)) for _ in attrs] yield if self.index_id != -1: GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0) GL.glBindVertexArray(0) @traitlets.observe("indices") def _set_indices(self, change): arr = change["new"] self.index_id = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, self.index_id) GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, arr.nbytes, arr, GL.GL_STATIC_DRAW)
class WorkflowWidget(ipywidgets.VBox): """ Widget for displaying a single `Workflow` object, with a table of its versions. `version` holds the currently-selected version name as a string, and can be modified. `current_vg` is a read-only trait holding the currently-selected `~.VersionedGraft`. """ flow = traitlets.Instance(klass=Workflow, allow_none=True) version = traitlets.CUnicode(allow_none=True) current_vg = traitlets.Instance(klass=VersionedGraft, read_only=True, allow_none=True) def __init__(self, **kwargs): self._version_selector = ipywidgets.Select(layout=ipywidgets.Layout( width="initial")) super().__init__(**kwargs) ipywidgets.link((self._version_selector, "value"), (self, "version")) @traitlets.observe("flow") def _update_flow(self, change): flow = self.flow if flow is None: self.children = [] self.version = None return info = ipywidgets.HTML(f""" <h2>{flow.title}</h2> <p><code>{flow.id}</p></code> <p>{"<i class='fa fa-unlock'></i> Public" if flow.has_public_reader() else "<i class='fa fa-lock'></i> Private"}</p> # noqa: E501 <p><b>Labels:</b> <code>{flow.labels}</code></p> <p><b>Tags:</b> <code>{flow.tags}</code></p> """) latest = flow.versions[-1] if flow.versions else None self._version_selector.options = flow.version_names[::-1] self._version_selector.value = latest.version if latest else None self._version_selector.rows = min(5, len(flow.versions)) self.set_trait("current_vg", latest) # in case version name was the same desc = ipywidgets.HTML(value=_strong_to_b.sub( r"<\1b>", markdowner.convert(flow.description))) self.children = [ info, self._version_selector, ipywidgets.HTML("<hr>"), desc ] @traitlets.observe("version") def _update_version(self, change): vg = (self.flow[self.version] if self.flow is not None and self.version is not None else None) self.set_trait("current_vg", vg)
class Branch(t.HasTraits): "Branch model" name = t.CUnicode(default_value='Branch1', help='Name of Branch (str)') from_bus = t.CUnicode(default_value='Bus1', help='Name of From Bus') to_bus = t.CUnicode(default_value='Bus2', help='Name of To Bus') resistance = t.CFloat(default_value=0, help='Branch resistance (p.u.)') reactance = t.CFloat(default_value=0, help='Branch reactance (p.u.)') susceptance = t.CFloat(default_value=0, help='Branch susceptance (p.u.)') rating = t.CFloat(default_value=M, help='Branch Rating') status = t.CBool(default_value=1, help='Branch status') angle_minimum = t.CFloat(default_value=0.0, help='Branch angle minimum') angle_maximum = t.CFloat(default_value=0.0, help='Branch angle maximum') tap = t.CFloat(default_value=None, allow_none=True) shift = t.CFloat(default_value=None, allow_none=True) from_real_power_flow = t.CFloat(default_value=None, allow_none=True, help='From active power flow (MW)') from_imag_power_flow = t.CFloat(default_value=None, allow_none=True, help='From reactive power flow (MVAR)') to_real_power_flow = t.CFloat(default_value=None, allow_none=True, help='To active power flow (MW)') to_imag_power_flow = t.CFloat(default_value=None, allow_none=True, help='To reactive power flow (MVAR)')
class Base(WXYZBase): """Utility traitlets, primarily based around - development convenience - ipywidgets conventions - integration with wxyz.lab.DockBox, mostly lumino Widget.label attrs """ _model_module = T.Unicode(module_name).tag(sync=True) _model_module_version = T.Unicode(module_version).tag(sync=True) _view_module = T.Unicode(module_name).tag(sync=True) _view_module_version = T.Unicode(module_version).tag(sync=True) error = T.CUnicode("").tag(sync=True) # type: str description = T.Unicode("An Undescribed Widget").tag( sync=True) # type: str icon_class = T.Unicode("jp-CircleIcon").tag(sync=True) # type: str closable = T.Bool(default_value=True).tag(sync=True) # type: bool
class TextAnnotation(SceneAnnotation): name = "text_annotation" data = traitlets.Instance(TextCharacters) text = traitlets.CUnicode() draw_instructions = traitlets.List() origin = traitlets.Tuple(traitlets.CFloat(), traitlets.CFloat(), default_value=(-1, -1)) scale = traitlets.CFloat(1.0) @traitlets.observe("text") def _observe_text(self, change): text = change["new"] lines = text.split("\n") draw_instructions = [] y = 0 for line in reversed(lines): x = 0 dy = 0 for c in line: e = self.data.characters[c] draw_instructions.append((x, y, e.texture, e.vbo_offset)) dy = max(dy, e.vert_advance) x += e.hori_advance y += dy self.draw_instructions = draw_instructions def _set_uniforms(self, scene, shader_program): pass def draw(self, scene, program): viewport = np.array(GL.glGetIntegerv(GL.GL_VIEWPORT), dtype="f4") program._set_uniform("viewport", viewport) each = self.data.vertex_array.each for x, y, tex, vbo_offset in self.draw_instructions: with tex.bind(0): program._set_uniform("x_offset", float(x)) program._set_uniform("y_offset", float(y)) program._set_uniform("x_origin", self.origin[0]) program._set_uniform("y_origin", self.origin[1]) program._set_uniform("scale", self.scale) GL.glDrawArrays(GL.GL_TRIANGLES, vbo_offset * each, each)
class ColormapTexture(Texture1D): colormap_name = traitlets.CUnicode() def __init__(self, *args, **kwargs): # Override... kwargs["boundary_x"] = "clamp" super(ColormapTexture, self).__init__(*args, **kwargs) @traitlets.validate("colormap_name") def _validate_name(self, proposal): try: cm.get_cmap(proposal["value"]) except ValueError: raise traitlets.TraitError( "Colormap name needs to be known by" "matplotlib" ) return proposal["value"] @traitlets.observe("colormap_name") def _observe_colormap_name(self, change): cmap = cm.get_cmap(change["new"]) cmap_vals = np.array(cmap(np.linspace(0, 1, 256)), dtype="f4") self.data = cmap_vals
class GeometricObject(IDObject): """ a geometric object x,y,z should represent the centre of volume Examples -------- >>> gobject = GeometricObject() >>> gobject.position (0.0, 0.0, 0.0) """ position = Vector3(default_value=(0, 0, 0), help='cartesian coordinate of pivot').tag(sync=True) visible = trait.Bool(True).tag(sync=True) color = Color('red').tag(sync=True) transparency = trait.CFloat(1, min=0.0, max=1.0).tag(sync=True) label = trait.CUnicode('-').tag(sync=True).tag(sync=True) label_visible = trait.Bool(False).tag(sync=True) label_color = Color('red').tag(sync=True) label_transparency = trait.CFloat(1, min=0.0, max=1.0).tag(sync=True)
class CText(widgets.Text): value = traitlets.CUnicode(help="String value", allow_none=True).tag(sync=True)
class Shader(traitlets.HasTraits): """ Creates a shader from source Parameters ---------- source : str This can either be a string containing a full source of a shader, an absolute path to a source file or a filename of a shader residing in the ./shaders/ directory. """ _shader = None source = traitlets.Any() shader_name = traitlets.CUnicode() info = traitlets.CUnicode() shader_type = traitlets.CaselessStrEnum(("vertex", "fragment", "geometry")) blend_func = traitlets.Tuple(GLValue(), GLValue(), default_value=("src alpha", "dst alpha")) blend_equation = GLValue("func add") depth_test = GLValue("always") use_separate_blend = traitlets.Bool(False) blend_equation_separate = traitlets.Tuple(GLValue(), GLValue(), default_value=("none", "none")) blend_func_separate = traitlets.Tuple( GLValue(), GLValue(), GLValue(), GLValue(), default_value=("none", "none", "none", "none"), ) def _get_source(self, source): if ";" in source: # This is probably safe, right? Enh, probably. return source # What this does is concatenate multiple (if available) source files. # This gets around GLSL's composition issues, which means we can have # functions that get called at each step in a ray tracing process, for # instance, that can still share ray tracing code between multiple # files. if not isinstance(source, (tuple, list)): source = (source, ) source = ( "header.inc.glsl", "known_uniforms.inc.glsl", ) + tuple(source) full_source = [] for fn in source: if os.path.isfile(fn): sh_directory = "" else: sh_directory = os.path.join(os.path.dirname(__file__), "shaders") fn = os.path.join(sh_directory, fn) if not os.path.isfile(fn): raise YTInvalidShaderType(fn) full_source.append(open(fn, "r").read()) return "\n\n".join(full_source) def _enable_null_shader(self): source = _NULL_SOURCES[self.shader_type] self.compile(source=source) def compile(self, source=None, parameters=None): if source is None: source = self.source if source is None: raise RuntimeError if parameters is not None: raise NotImplementedError source = self._get_source(source) shader_type_enum = getattr(GL, f"GL_{self.shader_type.upper()}_SHADER") shader = GL.glCreateShader(shader_type_enum) # We could do templating here if we wanted. self.shader_source = source GL.glShaderSource(shader, source) GL.glCompileShader(shader) result = GL.glGetShaderiv(shader, GL.GL_COMPILE_STATUS) if not (result): raise RuntimeError(GL.glGetShaderInfoLog(shader)) self._shader = shader def setup_blend(self): GL.glEnable(GL.GL_BLEND) if self.use_separate_blend: GL.glBlendEquationSeparate(*self.blend_equation_separate) GL.glBlendFuncSeparate(*self.blend_func_separate) else: GL.glBlendEquation(self.blend_equation) GL.glBlendFunc(*self.blend_func) GL.glEnable(GL.GL_DEPTH_TEST) GL.glDepthFunc(self.depth_test) @property def shader(self): if self._shader is None: try: self.compile() except RuntimeError as exc: print(exc) for line_num, line in enumerate( self.shader_source.split("\n")): print(f"{line_num + 1:05}: {line}") self._enable_null_shader() return self._shader def delete_shader(self): if None not in (self._shader, GL.glDeleteShader): GL.glDeleteShader(self._shader) self._shader = None def __del__(self): # This is not guaranteed to be called self.delete_shader()
class Generator(t.HasTraits): '''Generator Model''' name = t.CUnicode(default_value='GenCo0', help='Name of Generator (str)') generator_bus = t.CUnicode(default_value='Bus0', help='Bus of Generator (str)') generator_voltage = t.CFloat( default_value=1.0, help='Nominal voltage of the generator (p.u.)') base_power = t.CFloat(default_value=100.0, help='Base power of the generator (MVA)') generation_type = t.Enum(['COAL', 'NATURALGAS', 'WIND'], default_value='COAL') minimum_up_time = t.CInt(default_value=0, min=0, help='Minimum up time (hrs)') minimum_down_time = t.CInt(default_value=0, min=0, help='Minimum down time (hrs)') ramp_up_rate = t.CFloat(default_value=0, min=0, help='Ramp up rate (MW/hr)') ramp_down_rate = t.CFloat(default_value=0, min=0, help='Ramp down rate (MW/hr)') maximum_real_power = t.CFloat(default_value=0, min=0, help='Capacity of Generator (MW)') minimum_real_power = t.CFloat(default_value=0, min=0, help='Minimum generation (MW)') maximum_imag_power = t.CFloat(default_value=0, help='Maximum reactive generation (MVAR)') minimum_imag_power = t.CFloat(default_value=0, help='Minimum reactive generation (MVAR)') initial_real_power = t.CFloat(default_value=0, min=0, help='Initial power generation (MW)') initial_imag_power = t.CFloat(default_value=0, min=0, help='Initial power generation (MVAR)') initial_status = t.CBool(default_value=True, min=0, help='Initial status (bool)') startup_time = t.CInt(default_value=0, min=0, help='Startup time (hrs)') shutdown_time = t.CInt(default_value=0, min=0, help='Shutdown time (hrs)') nsegments = t.CInt(default_value=2, min=MINIMUM_COST_CURVE_SEGMENTS, max=MAXIMUM_COST_CURVE_SEGMENTS, help='Number of data points for piecewise linear') cost_curve_points = tt.Array(default_value=[0, 0, 0], minlen=(MINIMUM_COST_CURVE_SEGMENTS + 1), maxlen=(MAXIMUM_COST_CURVE_SEGMENTS + 1)) cost_curve_values = tt.Array(default_value=[0, 0, 0], minlen=(MINIMUM_COST_CURVE_SEGMENTS + 1), maxlen=(MAXIMUM_COST_CURVE_SEGMENTS + 1)) noload_cost = t.CFloat(default_value=0, min=0, help='No-Load Cost of a Generator ($/hr)') startup_cost = t.CFloat(default_value=0, min=0, help='Startup Cost of a Generator ($/hr)') inertia = t.CFloat(allow_none=True, default_value=None, min=0, help='Inertia of generator (NotImplemented)') droop = t.CFloat(allow_none=True, default_value=None, min=0, help='Droop of generator (NotImplemented)') def __init__(self, *args, **kwargs): super(Generator, self).__init__(*args, **kwargs) @property def _npoints(self): return self.nsegments + 1 @property def ramp_rate(self): raise AttributeError( "'{class_name}' object has no attribute 'ramp_rate'. Try 'ramp_up_rate' or 'ramp_down_rate'." .format(class_name=self.__class__.__name__)) @ramp_rate.setter def ramp_rate(self, v): self.ramp_up_rate = v self.ramp_down_rate = v @t.observe('noload_cost') def _callback_noload_cost_update_points_values(self, change): self.cost_curve_values = [change['new']] * self._npoints return change['new'] @t.observe('minimum_real_power') def _callback_minimum_real_power_update_points_values(self, change): self.cost_curve_points = np.linspace(change['new'], self.maximum_real_power, self._npoints) return change['new'] @t.observe('maximum_real_power') def _callback_maximum_real_power_update_points_values(self, change): self.cost_curve_points = np.linspace(self.minimum_real_power, change['new'], self._npoints) self.ramp_rate = self.maximum_real_power return change['new'] @t.observe('nsegments') def _callback_nsegments_update_points_values(self, change): self.cost_curve_points = np.linspace(self.minimum_real_power, self.maximum_real_power, change['new'] + 1) self.cost_curve_values = [self.noload_cost] * (change['new'] + 1) return change['new'] @t.validate('cost_curve_points', 'cost_curve_values') def _validate_max_length(self, proposal): if not len(proposal['value']) == self._npoints: raise t.TraitError( 'len({class_name}().{trait_name}) must be equal to {class_name}().nsegments + 1. Proposed {trait_name} is {proposal}' .format(class_name=proposal['owner'].__class__.__name__, trait_name=proposal['trait'].name, proposal=proposal['value'])) return proposal['value'] @t.validate('ramp_up_rate', 'ramp_down_rate', 'initial_real_power', 'initial_imag_power') def _less_than_maximum_real_power_check(self, proposal): if not proposal['value'] <= self.maximum_real_power: raise t.TraitError( '{class_name}().{trait_name} must be a less than or equal to {class_name}().maximum_real_power.' .format(class_name=proposal['owner'].__class__.__name__, trait_name=proposal['trait'].name)) else: return proposal['value']
class Watchdog(widgets.Widget): path = traitlets.CUnicode(".", sync=True) description = traitlets.CUnicode(sync=True) value = traitlets.Any(sync=True) recursive = traitlets.CBool(False, sync=True) watching = traitlets.CBool(False, sync=True) poll_interval = traitlets.CInt(1, sync=True) last_event = traitlets.Dict(sync=True) file = traitlets.CUnicode(sync=True) def __init__(self, *args, **kwargs): super(Watchdog, self).__init__(*args, **kwargs) self._wd_handlers = widgets.CallbackDispatcher() self._wd_observer = None self.on_msg(self._handle_wd_msg) def __del__(self): self.stop() super(Watchdog, self).__del__() def _handle_wd_msg(self, _, content, buffers): """ Be very careful here: inspecting the messages in the browser may be the only way to find problems """ self.last_event = content event = content.get('event', None) if event is None: return if (not self.file) or fnmatch(content["src_path"], self.file): self._wd_handlers(self, content) def on_any(self, callback, remove=False): self._wd_handlers.register_callback(callback, remove=remove) def ls(self): return glob.glob(os.path.join(self.path, self.file or "*.*")) def touch(self, idx=0): os.utime(self.ls()[idx], None) def start(self): self.stop() ip = get_ipython() self._wd_observer = subprocess.Popen(map(str, [ sys.executable, "-m", "ipywatchdogwidget.observe", "--model-id", self.model_id, "--path", os.path.abspath(self.path), "--poll-interval", self.poll_interval, "--port", ip.kernel._recorded_ports["shell"], "--recursive", self.recursive, "--session-key", ip.kernel.session.key.decode() ]), stderr=subprocess.STDOUT) self.watching = True def stop(self): if self._wd_observer: parent = psutil.Process(self._wd_observer.pid) [child.kill() for child in parent.children(recursive=True)] parent.kill() self._wd_observer = None self.watching = False
def create_jsmesh_view(gobject, mapping=None, jslink=False): """create PyThreeJS Mesh for GeometricObjects and with one-way synchronisation Properties ---------- gobject : GeometricObject mapping : None or dict if None, use default gobject->jsobject mapping jslink : bool if True, where possible, create client side links http://ipywidgets.readthedocs.io/en/latest/examples/Widget%20Events.html#The-difference-between-linking-in-the-kernel-and-linking-in-the-client Examples -------- >>> import pandas3js as pjs >>> sphere = pjs.models.Sphere() >>> mesh = pjs.views.create_jsmesh_view(sphere) >>> mesh.position [0.0, 0.0, 0.0] >>> str(mesh.material.color) '#ff0000' >>> sphere.position = (1,0,0) >>> mesh.position [1.0, 0.0, 0.0] >>> sphere.color = (1,1,1) >>> str(mesh.material.color) '#ffffff' >>> lmesh = create_jsmesh_view(pjs.models.Box()) >>> lmesh = create_jsmesh_view(pjs.models.Line()) >>> bsmesh = create_jsmesh_view(pjs.models.TriclinicSolid()) >>> bwmesh = create_jsmesh_view(pjs.models.TriclinicWire()) >>> cmesh = create_jsmesh_view(pjs.models.Circle()) >>> mesh = create_jsmesh_view(pjs.models.Octahedron()) >>> mesh = create_jsmesh_view(pjs.models.Icosahedron()) >>> mesh = create_jsmesh_view(pjs.models.Plane()) """ if jslink: direct_link = widget.jsdlink else: direct_link = trait.dlink class_str = obj_to_str(gobject) if hasattr(gobject, '_use_default_viewmap'): class_map = copy.deepcopy(gobject_jsmapping['default']) class_map['grep'] = 'pythreejs.{}Geometry'.format( class_str.split('.')[-1]) # directly link all traits to geometry object traits for trait_name in gobject.class_own_traits(): class_map['gdmap'][trait_name] = trait_name if gobject._use_default_viewmap is not None: class_map['show_label'] = True class_map['label_height'] = gobject._use_default_viewmap elif not class_str in gobject_jsmapping: raise ValueError( 'No pythreejs mapping available for {}'.format(class_str)) else: class_map = gobject_jsmapping[class_str] # create geometry geometry = str_to_obj(class_map['grep'])() for key, val in class_map['gvar'].items(): geometry.set_trait(key, val) for key, val in class_map['gdmap'].items(): direct_link((gobject, val), (geometry, key)) for gkey, gdic in class_map['gfmap'].items(): handle = _create_trait_dlink(gdic, gkey, gobject, geometry) gobject.observe(handle, names=gdic['vars']) # create material material = str_to_obj(class_map['matrep'])() for key, val in class_map['matvar'].items(): material.set_trait(key, val) for key, val in class_map['matdmap'].items(): direct_link((gobject, val), (material, key)) for mkey, mdic in class_map['matfmap'].items(): handle = _create_trait_dlink(mdic, mkey, gobject, material) gobject.observe(handle, names=mdic['vars']) # create mesh mesh = str_to_obj(class_map['meshrep'])(geometry=geometry, material=material) for key, val in class_map['meshvar'].items(): mesh.set_trait(key, val) for key, val in class_map['meshdmap'].items(): direct_link((gobject, val), (mesh, key)) for skey, sdic in class_map['meshfmap'].items(): handle = _create_trait_dlink(sdic, skey, gobject, mesh) gobject.observe(handle, names=sdic['vars']) # add special traits mesh.add_traits(gobject_id=HashableType()) mesh.gobject_id = gobject.id mesh.add_traits(other_info=trait.CUnicode().tag(sync=True)) direct_link((gobject, 'other_info'), (mesh, 'other_info')) return mesh
def create_jslabelmesh_view(gobject, mapping=None, jslink=False): """create PyThreeJS Text Mesh for GeometricObject and with one-way synchronisation Properties ---------- gobject : GeometricObject mapping : None or dict if None, use default gobject->jsobject mapping jslink : bool if True, where possible, create client side links http://ipywidgets.readthedocs.io/en/latest/examples/Widget%20Events.html#The-difference-between-linking-in-the-kernel-and-linking-in-the-client Examples -------- >>> import pandas3js as pjs >>> sphere = pjs.models.Sphere() >>> lmesh = pjs.views.create_jslabelmesh_view(sphere) >>> lmesh.position [0.0, 0.0, 0.0] >>> str(lmesh.material.map.string) '-' >>> lmesh.scale [1.0, 1.0, 1.0] >>> sphere.position = (1,0,0) >>> lmesh.position [1.0, 0.0, 0.0] >>> sphere.label = 'test' >>> str(lmesh.material.map.string) 'test' >>> sphere.radius = 3.0 >>> lmesh.scale [1.0, 3.0, 1.0] """ if jslink: direct_link = widget.jsdlink else: direct_link = trait.dlink class_str = obj_to_str(gobject) if hasattr(gobject, '_use_default_viewmap'): class_map = copy.deepcopy(gobject_jsmapping['default']) class_map['grep'] = 'pythreejs.' + class_str.split('.')[-1] # directly link all traits to geometry object for trait_name in gobject.class_own_traits(): class_map['gdmap'][trait_name] = trait_name if gobject._use_default_viewmap is not None: class_map['show_label'] = True class_map['label_height'] = gobject._use_default_viewmap elif not class_str in gobject_jsmapping: raise ValueError( 'No pythreejs mapping available for {}'.format(class_str)) else: class_map = gobject_jsmapping[class_str] text_map = js.TextTexture(string=gobject.label, color=colors.to_hex(gobject.label_color), size=100, squareTexture=False) material = js.SpriteMaterial(map=text_map, opacity=gobject.label_transparency, transparent=False, depthTest=False, depthWrite=True) height = class_map['label_height'] height_attr = getattr(gobject, height) if isinstance( height, basestring) else height mesh = js.Sprite(material=material, position=gobject.position, scaleToTexture=True, scale=[1, height_attr, 1]) # add special traits mesh.add_traits(gobject_id=HashableType()) mesh.gobject_id = gobject.id mesh.add_traits(other_info=trait.CUnicode().tag(sync=True)) if not class_map['show_label']: mesh.visible = False return mesh # add directional synchronisation direct_link((gobject, 'other_info'), (mesh, 'other_info')) direct_link((gobject, 'label'), (text_map, 'string')) direct_link((gobject, 'position'), (mesh, 'position')) direct_link((gobject, 'label_visible'), (mesh, 'visible')) direct_link((gobject, 'label_transparency'), (material, 'opacity')) trait.dlink((gobject, 'label_color'), (text_map, 'color'), colors.to_hex) trait.dlink((gobject, 'label_transparency'), (material, 'transparent'), lambda t: True if t <= 0.999 else False) if isinstance(height, basestring): def change_height(change): mesh.scale = [1, change.new, 1] gobject.observe(change_height, names=height) return mesh
import os import argparse import traitlets as ts ts.CUnicode('Ni').tag(sync=True) def reverse_str(s): if not isinstance(s, str): return None res = "" for i in range(len(s)): res = res + s[len(s) - i - 1] return res VOWEL_LETTERS = ('a', 'e', 'i', 'o', 'u') def pig(s): if not isinstance(s, str): return None res = "" for i in range(len(s)): res = res + s[len(s) - i - 1] return res if __name__ == "__main__": s = input("Please input a string: \n") print(reverse_str(s))