def test_map_list(mylib): from seamless.highlevel import Context, Cell ctx = Context() ctx.include(mylib.map_list) ctx.add = Context() ctx.add.inp = Cell("mixed") def add(a, b): print("ADD", a, b) return a + b ctx.add.tf = add ctx.add.tf.debug = True ctx.add.tf.a = ctx.add.inp ctx.add.tf.b = 1000 ctx.add.result = ctx.add.tf ctx.add.result.celltype = "int" ctx.compute() ctx.inp = [10, 20, 30, 40] ctx.inp.hash_pattern = {"!": "#"} ctx.result = Cell() ctx.mapping = ctx.lib.map_list(context_graph=ctx.add, inp=ctx.inp, result=ctx.result, elision=True, elision_chunksize=2) ctx.compute() print(ctx.mapping.ctx.m.exception) print(ctx.result.value) ctx.inp += [80, 12, 1, 1, 10, 20, 30, 40] ctx.compute() print(ctx.result.value)
def test_map_dict_chunk(mylib): from seamless.highlevel import Context, Cell ctx = Context() ctx.include(mylib.map_dict_chunk) ctx.mul = Context() ctx.mul.inp = Cell("mixed") def mul(a, factor): print("MUL", a) result = {} for key in a: result[key] = a[key] * factor return result ctx.mul.tf = mul ctx.mul.tf.debug = True ctx.mul.tf.a = ctx.mul.inp ctx.mul.tf.factor = 3 ctx.mul.result = ctx.mul.tf ctx.mul.result.celltype = "mixed" ctx.compute() ctx.inp = {"key1": 10, "key2": 220, "key3": 30, "key4": 40} ctx.inp.hash_pattern = {"*": "#"} ctx.result = Cell() ctx.keyorder = Cell("plain") ctx.mapping = ctx.lib.map_dict_chunk(context_graph=ctx.mul, inp=ctx.inp, chunksize=2, keyorder0=[], keyorder=ctx.keyorder, result=ctx.result, elision=True, elision_chunksize=3) ctx.compute() print(ctx.mapping.ctx.status) print(ctx.mapping.ctx.m.ctx.top.exception) print(ctx.result.value) ctx.mapping.keyorder0 = ctx.keyorder.value ctx.compute() print(ctx.result.value) print("UP") inp = ctx.inp.value inp.update({ "a": 80, "b": 30, "c": 999, "d": -1, }) ctx.inp = inp ctx.compute() print(ctx.result.value) print(ctx.keyorder.value)
def constructor_switch(ctx, libctx, celltype, input, selected, outputs): ctx.input = Cell(celltype) input.connect(ctx.input) ctx.selected = Cell("str") selected.connect(ctx.selected) macro_pins = { "celltype": { "io": "parameter", "celltype": "str", }, "input": { "io": "input", "celltype": celltype, }, "selected": { "io": "parameter", "celltype": "str", }, "options": { "io": "parameter", "celltype": "plain", } } """ Create one macro output pin per cell in the outputs dict This will populate the ctx passed to switch_func with output cells that can be connected to """ options = [] for output_name in outputs: assert isinstance(output_name, str), output_name if output_name in macro_pins or output_name == "switch_macro": msg = "You cannot switch to a cell under the selector '{}'" raise Exception(msg.format(output_name)) options.append(output_name) pin = { "io": "output", "celltype": celltype } macro_pins[output_name] = pin ctx.switch_macro = Macro(pins=macro_pins) ctx.switch_macro.code = libctx.switch_code.value ctx.switch_macro.celltype = celltype ctx.switch_macro.input = ctx.input ctx.switch_macro.selected = ctx.selected ctx.switch_macro.options = options for output_name in outputs: macro_pin = getattr(ctx.switch_macro, output_name) output_cell = Cell(celltype) setattr(ctx, output_name, output_cell) setattr(ctx, output_name, macro_pin) outputs[output_name].connect_from(output_cell)
def constructor_join(ctx, libctx, celltype, inputs, selected, output): ctx.output = Cell(celltype) output.connect_from(ctx.output) ctx.selected = Cell("str") selected.connect(ctx.selected) macro_pins = { "celltype": { "io": "parameter", "celltype": "str", }, "output": { "io": "output", "celltype": celltype, }, "selected": { "io": "parameter", "celltype": "str", }, "options": { "io": "parameter", "celltype": "plain", } } """ Create one macro input pin per cell in the inputs dict This will populate the ctx passed to join_func with input cells that can be connected to """ options = [] for input_name in inputs: assert isinstance(input_name, str), input_name if input_name in macro_pins or input_name == "join_macro": msg = "You cannot join from a cell under the selector '{}'" raise Exception(msg.format(input_name)) options.append(input_name) pin = { "io": "input", "celltype": celltype } macro_pins[input_name] = pin ctx.join_macro = Macro(pins=macro_pins) ctx.join_macro.code = libctx.join_code.value ctx.join_macro.celltype = celltype ctx.join_macro.selected = ctx.selected ctx.join_macro.options = options for input_name in inputs: input_cell = Cell(celltype) setattr(ctx, input_name, input_cell) setattr(ctx.join_macro, input_name, input_cell) inputs[input_name].connect(input_cell) ctx.output = ctx.join_macro.output
def test_map_dict(mylib): from seamless.highlevel import Context, Cell ctx = Context() ctx.include(mylib.map_dict) ctx.add = Context() ctx.add.inp = Cell("mixed") def add(a, b): print("ADD", a, b) return a + b ctx.add.tf = add ctx.add.tf.debug = True ctx.add.tf.a = ctx.add.inp ctx.add.tf.b = 1000 ctx.add.result = ctx.add.tf ctx.add.result.celltype = "int" ctx.compute() ctx.inp = {"key1": 10, "key2": 220, "key3": 30, "key4": 40} ctx.inp.hash_pattern = {"*": "#"} ctx.result = Cell() ctx.keyorder = Cell("plain") ctx.mapping = ctx.lib.map_dict(context_graph=ctx.add, inp=ctx.inp, keyorder0=[], keyorder=ctx.keyorder, result=ctx.result, elision=True, elision_chunksize=2) ctx.compute() print(ctx.mapping.ctx.status) print(ctx.mapping.ctx.m.ctx.top.exception) print(ctx.result.value) ctx.mapping.keyorder0 = ctx.keyorder.value ctx.compute() print(ctx.result.value) inp = ctx.inp.value inp.update({ "a": 80, "b": 30, "c": 999, "d": -1, }) ctx.inp = inp ctx.compute() print(ctx.result.value) print(ctx.keyorder.value)
def serve(filename, sharename=None, mount=False): import os cell = Cell() cell.celltype = "text" _, ext = os.path.splitext(filename) cell.mimetype = ext[1:] if mount: cell.mount(filename, mode="rw", authority="file") else: data = open(filename, "rb").read() cell.set(data) if sharename is None: sharename = filename cell.share(path=sharename, readonly=True) return cell
def build_transformer(): del ctx.transform ctx.transform = lambda a, b: a + b ctx.translate() ctx.transform.example.a = 0 ctx.transform.example.b = 0 ctx.result = ctx.transform ctx.result.celltype = "plain" ctx.transform.a = ctx.a ctx.transform.b = ctx.b ctx.transform.language = "cpp" ctx.transform.main_module.compiler_verbose = False ctx.code = ctx.transform.code.pull() ctx.code = """ extern "C" double add(int a, int b); extern "C" int transform(int a, int b, double *result) { *result = add(a,b); return 0; }""" ctx.translate() ctx.transform.result.example = 0.0 #example, just to fill the schema ctx.transform.main_module.add.language = "c" code = """ int add(int a, int b, double *result) {*result = a+b;}; """ ctx.add_code = Cell("code") ctx.add_code.language = "c" ctx.transform.main_module.add.code = ctx.add_code ctx.add_code.set(code) ctx.translate()
def constructor(ctx, libctx, result): ctx.sub_inner = ctx.lib.subtract() if result is not None: ctx.result = ctx.sub_inner.result result.connect_from(ctx.result) else: ctx.result = Cell()
def test_map_list_N_uniform(mylib): from seamless.highlevel import Context, Cell ctx = Context() ctx.include(mylib.map_list_N) ctx.add = Context() ctx.add.uniform = Cell("mixed") ctx.add.inp = Context() ctx.add.inp.a = Cell("mixed") ctx.add.inp.b = Cell("mixed") def add(a, b, c): print("ADD", a, b, c) return a + b + c ctx.add.tf = add ctx.add.tf.debug = True ctx.add.tf.a = ctx.add.inp.a ctx.add.tf.b = ctx.add.inp.b ctx.add.tf.c = ctx.add.uniform ctx.add.result = ctx.add.tf ctx.add.result.celltype = "int" ctx.compute() ctx.a = [110, 120, 130, 140] ctx.a.hash_pattern = {"!": "#"} ctx.b = [2, 4, 8, 12] ctx.b.hash_pattern = {"!": "#"} ctx.c = 7000 ctx.result = Cell() ctx.mapping = ctx.lib.map_list_N(context_graph=ctx.add, inp={ "a": ctx.a, "b": ctx.b, }, uniform=ctx.c, result=ctx.result, elision=True, elision_chunksize=2) ctx.compute() print(ctx.result.value) ctx.c = 8000 ctx.compute() print(ctx.result.value)
def constructor(ctx, libctx, celltype, a, b, c): assert celltype in ("int", "float"), celltype ctx.a = Cell(celltype) ctx.b = Cell(celltype) ctx.c = Cell(celltype) a.connect(ctx.a) b.connect(ctx.b) c.connect_from(ctx.c) ctx.subtract = Transformer() ctx.subtract_code = Cell("code") ctx.subtract_code = libctx.subtract_code.value ctx.subtract.code = ctx.subtract_code ctx.subtract.a = ctx.a ctx.subtract.pins.a.celltype = celltype ctx.subtract.b = ctx.b ctx.subtract.pins.b.celltype = celltype ctx.c = ctx.subtract
def constructor( ctx, libctx, fallback_mode, upstream, modified, conflict, merged, state ): assert fallback_mode in ("upstream", "modified", "no"), fallback_mode m = ctx.m = Macro() m.code = libctx.macro_code.value m.fallback_mode = fallback_mode m.code_start = libctx.code_start.value m.code_update = libctx.code_update.value ctx.upstream = Cell("text") upstream.connect(ctx.upstream) m.pins.upstream = {"io": "input", "celltype": "text"} m.upstream = ctx.upstream ctx.modified = Cell("text") modified.link(ctx.modified) m.pins.modified = {"io": "edit", "celltype": "text"} m.modified = ctx.modified ctx.conflict = Cell("text") conflict.link(ctx.conflict) m.pins.conflict = {"io": "edit", "celltype": "text"} m.conflict = ctx.conflict ctx.merged = Cell("text") merged.connect_from(ctx.merged) m.pins.merged = {"io": "output", "celltype": "text"} ctx.merged = m.merged ctx.state = Cell("text") state.connect_from(ctx.state) m.pins.state = {"io": "output", "celltype": "text"} ctx.state = m.state
def constructor(ctx, libctx, result, state={}, **kw): ctx.result = Cell("mixed") if state is None: return startvalue = state.get("startvalue") if startvalue is not None: ctx.startvalue = Cell("mixed").set(startvalue) channel_contents = ctx.startvalue for step, operator in enumerate(state.get("operators", [])): opname, op_params = operator subctxname = "step%d_%s" % (step + 1, opname) ctx[subctxname] = Context() subctx = ctx[subctxname] if opname in ("filter", "first"): subctx.tf = Transformer() subctx.tf.code = op_params subctx.tf.channel_contents = channel_contents subctx.result = subctx.tf subctx.result.celltype = "mixed" channel_contents = subctx.result else: raise NotImplementedError(opname) ctx.result = channel_contents result.connect_from(ctx.result)
def constructor(ctx, libctx, context_graph, inp, result, elision, elision_chunksize): m = ctx.m = Macro() m.elision = elision m.graph = context_graph m.pins.graph.celltype = "plain" m.pins.result = { "io": "output", "celltype": "mixed", "hash_pattern": { "!": "#" } } ctx.inp = Context() ctx.cs_inp = Context() inp_prefix = "INPUT_" m.inp_prefix = inp_prefix m.pins.inp_prefix.celltype = "str" m.elision_chunksize = elision_chunksize m.pins.elision_chunksize.celltype = "int" for key in inp: c = Cell() ctx.inp[key] = c c.hash_pattern = {"!": "#"} inp[key].connect(c) ctx.cs_inp[key] = Cell("checksum") ctx.cs_inp[key] = ctx.inp[key] setattr(m, inp_prefix + key, ctx.cs_inp[key]) macro_code_lib_code = libctx.map_list_N.value + "\n\n" + libctx.map_list_N_nested.value macro_code_lib = { "type": "interpreted", "language": "python", "code": macro_code_lib_code } ctx.macro_code_lib = Cell("plain").set(macro_code_lib) ctx.macro_code_lib_code = Cell("code").set(macro_code_lib_code) m.macro_code_lib = ctx.macro_code_lib m.pins.macro_code_lib.celltype = "plain" m.pins.macro_code_lib.subcelltype = "module" m.macro_code_lib_code = ctx.macro_code_lib_code m.pins.macro_code_lib_code.celltype = "plain" m.map_list_N_nested_code = libctx.map_list_N_nested.value ###m.pins.map_list_N_nested_code.celltype = "python" m.code = libctx.main.value ctx.result = Cell() ctx.result.hash_pattern = {"!": "#"} ctx.result = m.result result.connect_from(ctx.result)
def constructor( ctx, libctx, package_dirdict, package_name, package, ): mod = ctx.analyze_dependencies = Module() mod.code = libctx.code.analyze_dependencies.value tf = ctx.build_package = Transformer() tf.code = libctx.code.build_package.value ctx.package_dirdict = Cell("plain") tf.package_dirdict = ctx.package_dirdict package_dirdict.connect(ctx.package_dirdict) tf.analyze_dependencies = mod tf.package_name = package_name ctx.package = tf ctx.package.celltype = "plain" package.connect_from(ctx.package)
from seamless.highlevel import Context, Cell import traceback ctx = Context() ctx.a = Cell("int").set(20) ctx.b = ctx.a ctx.b.celltype = "int" ctx.compute() print(ctx.b.value) try: ctx.b.mount("/tmp/x") except Exception: traceback.print_exc() try: ctx.b.share(readonly=False) except Exception: traceback.print_exc() ctx.compute()
from seamless.highlevel import Context, Cell, Macro ctx = Context() ctx.a = Cell("int") ctx.b = Cell("int") def add(a,b): return a+b ctx.add = add ctx.add.a = ctx.a ctx.add.b = ctx.b ctx.result = ctx.add ctx.result.celltype = "int" ctx.compute() graph = ctx.get_graph(runtime=True) ctx = Context() ctx.graph = Cell("plain").set(graph) m = ctx.m = Macro() ctx.par_static = 100 ctx.par_dynamic = 20 m.par_static = ctx.par_static m.graph = ctx.graph m.pins.par_dynamic = {"io": "input", "celltype": "int"} m.pins.graph_result = {"io": "output", "celltype": "int"} def run_macro(ctx, par_static, graph): print("RUN MACRO", par_static) ctx.subctx = HighLevelContext(graph) ctx.subctx.a.set(par_static) ctx.par_dynamic = cell("int") ctx.par_dynamic.connect(ctx.subctx.b)
def constructor(ctx, libctx, context_graph, inp, result): m = ctx.m = Macro() m.graph = context_graph m.pins.result = { "io": "output", "celltype": "mixed", "hash_pattern": { "!": "#" } } ctx.inp = Context() ctx.cs_inp = Context() inp_prefix = "INPUT_" m.inp_prefix = inp_prefix for key in inp: c = Cell() ctx.inp[key] = c c.hash_pattern = {"!": "#"} inp[key].connect(c) ctx.cs_inp[key] = Cell("checksum") ctx.cs_inp[key] = ctx.inp[key] setattr(m, inp_prefix + key, ctx.cs_inp[key]) def map_list_N(ctx, inp_prefix, graph, **inp): first_k = list(inp.keys())[0] length = len(inp[first_k]) first_k = first_k[len(inp_prefix):] for k0 in inp: k = k0[len(inp_prefix):] if len(inp[k0]) != length: err = "all cells in inp must have the same length, but '{}' has length {} while '{}' has length {}" raise ValueError(err.format(k, len(inp[k0]), first_k, length)) from seamless.core import Cell as CoreCell from seamless.core.unbound_context import UnboundContext pseudo_connections = [] ctx.result = cell("mixed", hash_pattern={"!": "#"}) ctx.sc_data = cell("mixed", hash_pattern={"!": "#"}) ctx.sc_buffer = cell("mixed", hash_pattern={"!": "#"}) ctx.sc = StructuredCell(data=ctx.sc_data, buffer=ctx.sc_buffer, inchannels=[(n, ) for n in range(length)], outchannels=[()], hash_pattern={"!": "#"}) for n in range(length): hc = HighLevelContext(graph) subctx = "subctx%d" % (n + 1) setattr(ctx, subctx, hc) if not hasattr(hc, "inp"): raise TypeError( "map_list_N context must have a subcontext called 'inp'") hci = hc.inp if not isinstance(hci, UnboundContext): raise TypeError( "map_list_N context must have an attribute 'inp' that is a context, not a {}" .format(type(hci))) for k0 in inp: k = k0[len(inp_prefix):] if not hasattr(hci, k): raise TypeError( "map_list_N context must have a cell called inp.'{}'". format(k)) if isinstance(hci[k], StructuredCell): raise TypeError( "map_list_N context has a cell called inp.'{}', but its celltype must be mixed, not structured" .format(k)) if not isinstance(hci[k], CoreCell): raise TypeError( "map_list_N context must have an attribute inp.'{}' that is a cell, not a {}" .format(k, type(hci[k]))) if hci[k].celltype != "mixed": raise TypeError( "map_list_N context has a cell called inp.'{}', but its celltype must be mixed, not {}" .format(k, hci[k].celltype)) con = [".." + k], ["ctx", subctx, "inp", k] pseudo_connections.append(con) cs = inp[k0][n] hci[k].set_checksum(cs) resultname = "result%d" % (n + 1) setattr(ctx, resultname, cell("int")) c = getattr(ctx, resultname) hc.result.connect(c) c.connect(ctx.sc.inchannels[(n, )]) con = ["ctx", subctx, "result"], ["..result"] pseudo_connections.append(con) ctx.sc.outchannels[()].connect(ctx.result) ctx._pseudo_connections = pseudo_connections m.code = map_list_N ctx.result = Cell() ctx.result.hash_pattern = {"!": "#"} ctx.result = m.result result.connect_from(ctx.result)
"context_graph": "context", "inp": { "type": "celldict", "io": "input" }, "result": { "type": "cell", "io": "output" }, } ctx = Context() ctx.adder = Context() sctx = ctx.adder sctx.inp = Context() sctx.inp.a = Cell("mixed") sctx.inp.b = Cell("mixed") sctx.a = Cell("int") sctx.b = Cell("int") sctx.a = sctx.inp.a sctx.b = sctx.inp.b def add(a, b): return a + b sctx.add = add sctx.add.a = sctx.a sctx.add.b = sctx.b sctx.result = sctx.add
for k, path in exits.items(): export_cell = exports[k] subinstance = instance for subpathnr, subpath in enumerate(path): if subpath not in subinstance.get_children(): curr_path = path[:subpathnr + 1] raise AttributeError("Invalid path {} ({})" % (path, curr_path)) subinstance = getattr(subinstance, subpath) if not isinstance(subinstance, Cell): raise TypeError("Invalid path {} is {} instead of Cell" % (path, type(subinstance))) export_cell.connect_from(subinstance, target_path=name) ctx.constructor_code = Cell("code").set(constructor) ctx.constructor_params = { "template": "context", "pattern": "value", "ncopies": "value", "imports": { "type": "celldict", "io": "input" }, "exports": { "type": "celldict", "io": "output" }, "entries": "value", "exits": "value", }
ctx.a = 0 ctx.translate() ctx.a = 2 ctx.compute() ctx.get_graph() print(ctx.a.schema) print(ctx.a.value) print(ctx.a.exception) ctx.a = 1 ctx.a.example = 0 ctx.compute() print(ctx.a.schema) print(ctx.a.value) ctx.a = Cell() ctx.compute() print(ctx.a.schema) print(ctx.a.value) ctx.a.example = 50 print(ctx.a.value) print(ctx.a.schema) ctx.a.set(12) ctx.compute() print(ctx.a.value) ctx.a = 1.2 ctx.compute() print(ctx.a.exception)
merge.set_pin("mode", io="output") merge.fallback = "no" #TODO: add the validator to the schema of the .fallback property, instead of the main schema # (requires that .add_validator and ._set_property/._set_method become schema methods) def validate_fallback(self): assert self.fallback in ("upstream", "modified", "no"), self.fallback merge.io.handle.add_validator(validate_fallback) merge.code_start = set_resource("cell-merge-START.py") merge.code_update = set_resource("cell-merge-UPDATE.py") merge.code_stop = "" # Public cells ctx.upstream = Cell() ctx.upstream.celltype = "text" merge.upstream = ctx.upstream ctx.modified = Cell() ctx.modified.celltype = "text" ctx.link_modified = Link(ctx.modified, merge.modified) ctx.conflict = Cell() ctx.conflict.celltype = "text" ctx.link_conflict = Link(ctx.conflict, merge.conflict) ctx.fallback = merge.fallback.value ctx.fallback.celltype = "text" merge.fallback = ctx.fallback
from seamless.highlevel import Context, Cell, Transformer ctx = Context() ctx.a = Cell() ctx.a.celltype = "int" ctx.compute() ctx.a.set(1) ctx.compute() ctx.a.set("test") ctx.compute() print("*" * 80) print(ctx.a.exception) print(ctx.a.value) print("*" * 80) ctx.a = 12 ctx.compute() ctx.a.celltype = "str" ctx.b = ctx.a ctx.b.celltype = "int" ctx.compute() print("*" * 80) print("a", ctx.a.exception) print("a", ctx.a.value) print("*" * 80) print("b", ctx.b.exception) print("b", ctx.b.value) print("*" * 80) ctx.a = "test2" ctx.compute()
from seamless.highlevel import Context, Cell ctx = Context() ctx.v = "test" ctx.v_schema = Cell() ctx.v_schema.celltype = "plain" ###ctx.mount("/tmp/mount-test") ctx.translate() ctx.link(ctx.v.schema, ctx.v_schema) ctx.translate() ctx.v_schema.set({'type': 'integer'}) ctx.compute() print(ctx.v.schema) print("*" * 50) print(ctx.v.exception) print("*" * 50) ctx.v.schema.set({}) ctx.compute() # this is needed, else the 1.2 below might take effect first, # and then be overwritten by this. Seamless is async!! print(ctx.v.schema) print(ctx.v_schema.value) ctx.v.example.set(1.2) ctx.compute() print("value:", ctx.v.value) print("data:", ctx.v.data) print("buffered:", ctx.v.buffered) print(ctx.v_schema.value) print("*" * 50) print(ctx.v.exception) print("*" * 50) ctx.v_schema.set({"type": "string"})
from seamless.highlevel import Context, Cell ctx = Context() ctx.a = Cell("int").set(10) ctx.c = Cell("int").set(30) ctx.s = Cell() ctx.translate() ctx.s.a = ctx.a ctx.s.c = ctx.c ctx.ss = ctx.s ctx.ss.celltype = "plain" ctx.compute() print(ctx.s.value) print(ctx.ss.value) ctx.s.set("NOT TO BE PRINTED") ctx.compute() print(ctx.s.value) print(ctx.ss.value) print(ctx.s.exception) print("") ctx.s = "NOT TO BE PRINTED 2" ctx.s.a = ctx.a ctx.s.c = ctx.c ctx.compute() print(ctx.s.value) print(ctx.ss.value) print(ctx.s.exception) print("") ctx.s.set({}) ctx.compute() print(ctx.s.value) print(ctx.ss.value)
""" import seamless from seamless.highlevel import Context, Cell import json, os cache = seamless.RedisCache() print("Load graph...") graph = json.load(open("snakegraph.seamless")) ctx = seamless.highlevel.load_graph(graph) print("Bind files...") # HACK: Keep the large pairwise lrmsd file out of the virtual file system # To be eliminated when deep cells are there in Seamless ctx.pw_lrmsd = Cell() file = "docking-result-pairwise-lrmsd.txt" print(file) data = open(file).read() ctx.pw_lrmsd = data ctx.jobs.cluster_struc.inputfile_pairwise_lrmsd = ctx.pw_lrmsd inputs = ( "params/cluster-cutoff", "params/selected-cluster", "receptor.pdb", "ligand.pdb", "receptor-bound.pdb", "ligand-bound.pdb", "docking-result.dat", #"docking-result-pairwise-lrmsd.txt"
ctx = Context() ctx.txt = "not OK" ctx.txt.celltype = "text" ctx.txt.mount("mount.txt", authority="file") ctx.compute() print(ctx.txt.value) ###ctx.mount("mount-test", persistent=False) ctx.intcell = 780 ctx.intcell.celltype = "int" ctx.intcell.mount("/tmp/intcell.txt") ctx.cpp_cell = """ #include <iostream> using namespace std; int main() { cout << "Hello, World!"; return 0; } """ ctx.cpp_cell.celltype = "code" ctx.cpp_cell.language = "cpp" ctx.cpp_cell.mount("/tmp/cpp_cell.cpp") ctx.txt2 = Cell() ctx.txt2.celltype = "text" ctx.link(ctx.txt2, ctx.txt) ctx.compute() # continue in interactive mode...
mylib.channel = ctx0 mylib.channel.constructor = constructor mylib.channel.params = parameters mylib.channel.api_schema = api_schema ctx = Context() ctx.include(mylib.channel) def filter_code(key, value): import os return os.path.splitext(key)[1] == "" ctx.filter_code = Cell("code").set(filter_code) ctx.inst = (ctx.lib.channel().fromPath("./*", is_text=True).filter(filter_code)) ctx.result = ctx.inst.result ctx.result.celltype = "plain" ctx.compute() print(ctx.result.value) ctx.inst.first(lambda k, v: k == "./b") ctx.compute() print(ctx.result.value) print(ctx.inst.ctx.step2_first.tf.status) print(ctx.inst.ctx.step2_first.tf.exception) """
ctx.conflict = Cell("text") conflict.link(ctx.conflict) m.pins.conflict = {"io": "edit", "celltype": "text"} m.conflict = ctx.conflict ctx.merged = Cell("text") merged.connect_from(ctx.merged) m.pins.merged = {"io": "output", "celltype": "text"} ctx.merged = m.merged ctx.state = Cell("text") state.connect_from(ctx.state) m.pins.state = {"io": "output", "celltype": "text"} ctx.state = m.state ctx.constructor_code = Cell("code").set(constructor) constructor_params = { "fallback_mode": { "type": "value", "default": "modified" }, "upstream": { "type": "cell", "celltype": "text", "io": "input" }, "modified": { "type": "cell", "celltype": "text", "io": "edit" },
ctx2.graph.share() ctx2.graph_rt = {} ctx2.graph_rt.celltype = "plain" ctx2.status_ = {} ctx2.status_data = ctx2.status_ ctx2.status_data.celltype = "plain" gvs = ctx2.gen_vis_status = Transformer() gvs.graph = ctx2.graph_rt gvs.status_ = ctx2.status_ gvs.code.mount("gen_vis_status.py", authority="file") ctx2.vis_status = ctx2.gen_vis_status ctx2.vis_status.celltype = "plain" ctx2.vis_status.share(readonly=True) c = ctx2.html = Cell() c.set(open("status-visualization.html").read()) c.celltype = "text" c.mimetype = "text/html" c.share(path="index.html") import seamless, os seamless_dir = os.path.dirname(seamless.__file__) c = ctx2.seamless_client_js = Cell() c.celltype = "text" c.set(open(seamless_dir + "/js/seamless-client.js").read()) c.mimetype = "text/javascript" c.share(path="seamless-client.js") c = ctx2.status_visualization_js = Cell() c.celltype = "text"
import seamless from seamless.highlevel import load_graph, Cell import os, sys initial_graphfile = sys.argv[1] initial_zipfile = sys.argv[2] output_graphfile = sys.argv[3] output_zipfile = sys.argv[4] ctx = load_graph(initial_graphfile, zip=initial_zipfile) ctx.html = Cell("text").mount("index.html", authority="file").share("index.html") ctx.html.mimetype = "html" ctx.js = Cell("text").mount("index.js", authority="file").share("index.js") ctx.js.mimetype = "js" seamless_dir = os.path.dirname(seamless.__file__) seamless_client = open(seamless_dir + "/js/seamless-client.js").read() ctx.seamless_js = Cell("text").set(seamless_client).share("seamless-client.js") ctx.seamless_js.mimetype = "js" ctx.compute() ctx.save_graph(output_graphfile) ctx.save_zip(output_zipfile)