import os import sys import time from seamless import context, cell, transformer, reactor, macro from seamless.lib.gui.basic_editor import edit from seamless.lib.gui.basic_display import display ctx = context() @macro({"formula": {"type": "str", "default": "return value*2"}}) def operator(ctx, formula ): from seamless import cell, transformer tparams = ctx.tparams = cell("object").set( { "value": { "pin": "input", "dtype": "int" }, "output": { "pin": "output", "dtype": "int" } } ) cont = ctx.cont = transformer(tparams) c_code = cont.code.cell() c_code.set(formula) ctx.export(cont) op = ctx.op = operator()
"array": {"pin": "input", "dtype": "array"}, "title": {"pin": "input", "dtype": "str"}, }) ctx.registrar.python.connect("AspectLayout", ctx.display_numpy) ctx.array.connect(ctx.display_numpy.array) ctx.title.connect(ctx.display_numpy.title) ctx.display_numpy.code_update.set("update()") ctx.display_numpy.code_stop.set("destroy()") ctx.code = pythoncell() ctx.code.connect(ctx.display_numpy.code_start) ctx.code.fromfile("cell-display-numpy.py") first = False ctx_bak = ctx ctx.display_numpy = context() ctx = ctx.display_numpy load_display_numpy() ctx = ctx_bak ctx_bak = ctx ctx.display_numpy2 = context() ctx = ctx.display_numpy2 load_display_numpy() ctx = ctx_bak ### ctx.texture = cell("array") ctx.texture.set_store("GLTex", 2)
print("In the 3D window, press key 1-4 to change the states") """ #even the kludge does not work... troubles when updating macro #ctx.display_numpy = ctx.fromfile("../display-numpy/display_numpy.seamless") #KLUDGE ctx = ctx.fromfile("../display-numpy/display_numpy.seamless") ctx.rc_display_numpy = ctx.display_numpy ctx.display_numpy = context() ctx.display_numpy.array = ctx.array ctx.display_numpy.title = ctx.title #/KLUDGE seamless.core.context.set_active_context(ctx) #does not help """ ctx_bak = ctx ctx.display_numpy = context() ctx = ctx.display_numpy ### ctx.array = cell("array") ctx.title = cell("str").set("Numpy array") ctx.aspect_layout = pythoncell().fromfile("AspectLayout.py") ctx.registrar.python.register(ctx.aspect_layout) ctx.display_numpy = reactor({ "array": { "pin": "input", "dtype": "array" }, "title": { "pin": "input", "dtype": "str" },
import seamless f = "test-tofromfile.seamless" f2 = "test-tofromfile-reload.seamless" ctx = seamless.context() from seamless.core.macro import _macros _macros.clear() ctx = seamless.fromfile(f) ctx.equilibrate() c_output = ctx.cont.output.cell() print(c_output.data) ctx.cont.value.cell().set(10) ctx.equilibrate() print(c_output.data) ctx.cont.code.cell().set("return value**2") ctx.equilibrate() print(c_output.data) ctx.tofile(f2, backup=False) ctx = seamless.fromfile(f2) ctx.equilibrate() c_output = ctx.cont.output.cell() print(c_output.data) ctx.cont.code.cell().set("return value*2") ctx.equilibrate() print(c_output.data) ctx.cont.value.cell().set(4) ctx.equilibrate() print(c_output.data)
#TODO: more complicated graph, run gc, etc. from seamless import context ctx = context() silkmodel = """Type Foo { Integer x Integer y }""" ctx.registrar.silk.register(silkmodel) ctx.destroy() ctx2 = context() ctx2.registrar.silk.register(silkmodel)
#!/usr/bin/env ipython """Basic example Sets up a transformer that computes a result based on two inputs The input and the transformation code is edited live in a GUI """ from seamless import context, cell, pythoncell, transformer from seamless.lib import edit, display ctx = context() # Create 3 int cells: a=2, b=3, and result ctx.a = cell("int").set(2) ctx.b = cell("int").set(3) ctx.result = cell("int") # Set up a transformer that computes "result" as a function of "a" and "b" t = ctx.transform = transformer({ "a": { "pin": "input", "dtype": "int" }, "b": { "pin": "input", "dtype": "int" }, "result": { "pin": "output", "dtype": "int" }
import seamless from seamless import context, cell, transformer from seamless.lib.filelink import link ctx = context() ctx.value = cell("int") ctx.result = cell("int") #ctx.result.resource.save_policy = 4 #always save value ctx.result.resource.save_policy = 2 #always save hash ctx.tf = transformer({ "value": { "pin": "input", "dtype": "int" }, "result": { "pin": "output", "dtype": "int" }, }) ctx.tf.code.cell().set("""print("evaluate!"); return value""") ctx.value.connect(ctx.tf.value) ctx.tf.result.connect(ctx.result) ctx.value.set(42) ctx.link_value = link(ctx.value, ".", "hashcache-value.txt") ctx.link_result = link(ctx.result, ".", "hashcache-result.txt", file_dominant=True) ctx.equilibrate() ctx.tofile("test-hashcache.seamless", backup=False) ctx = seamless.fromfile("test-hashcache.seamless") ctx.equilibrate()
from seamless import context, cell, transformer, reactor from seamless.lib import edit, display, link from seamless.lib.gui.gl import glprogram, glwindow import numpy as np ctx = context() ctx.params = context() ctx.links = context() ctx.code = context() #for now, gen_sphere must be a reactor, because it has multiple outputs #TODO: make it a transformer in a future version of seamless c = ctx.params.gen_sphere = cell(("cson", "seamless", "reactor_params")) ctx.links.params_gen_sphere = link(c, ".", "params-gen-sphere.cson") rc = ctx.gen_sphere = reactor(c) c = ctx.code.gen_sphere = cell(("text", "code", "python")) ctx.links.code_gen_sphere = link(c, ".", "cell-gen-sphere.py") rc.code_start.cell().set("") c.connect(rc.code_update) rc.code_stop.cell().set("") ctx.subdivisions = cell("int").set(3) ctx.minimizations = cell("int").set(20) ctx.coordinates = cell("array").set_store("GL") ctx.normals = cell("array").set_store("GL") ctx.edges = cell("array").set_store("GL") ctx.triangle_indices = cell("array").set_store("GL") ctx.triangle_normals = cell("array").set_store("GL") ctx.triangle_coordinates = cell("array").set_store("GL")
from seamless import cell, pythoncell, context, reactor, transformer from seamless.silk import Silk import seamless.lib from seamless.lib.gui.basic_editor import edit from seamless.lib.gui.basic_display import display from seamless.lib import link from seamless.lib.gui.gl import glprogram ctx = context() file_dominant = False # Vertexdata Silk model ctx.silk_vertexdata = cell(("text", "code", "silk")) ctx.link_silk_vertexdata = link( ctx.silk_vertexdata, ".", "vertexdata.silk", file_dominant=file_dominant ) ctx.registrar.silk.register(ctx.silk_vertexdata) # Shaders ctx.vert_shader = cell(("text", "code", "vertexshader")) ctx.frag_shader = cell(("text", "code", "fragmentshader")) ctx.link_vert_shader = link(ctx.vert_shader, ".", "vert_shader.glsl", file_dominant=file_dominant) ctx.link_frag_shader = link(ctx.frag_shader, ".", "frag_shader.glsl", file_dominant=file_dominant) # Program template ctx.program_template = cell("cson") ctx.link_program_template = link(ctx.program_template,
def plotly(ctx, *, dynamic_html, mode): from seamless import context, cell, transformer from seamless.lib.templateer import templateer from seamless.core.worker import \ ExportedInputPin, ExportedOutputPin assert mode in ("nx", "nxy", "manual"), mode data_dtype = "json" if mode == "manual" else "text" #csv # Subcontexts ctx.values = context() ctx.templates = context() ctx.params = context() ctx.code = context() # Static HTML output ctx.values.html = cell(("text", "html")) ctx.html = ExportedOutputPin(ctx.values.html) # Templates ctx.templates.html_head_body = cell(("text", "html"))\ .fromfile("template-html-head-body.jinja") ctx.templates.head = cell("text")\ .fromfile("template-head.jinja") ctx.templates.body = cell("text")\ .fromfile("template-body.jinja") ctx.templates.body_dynamic = cell("text")\ .fromfile("template-body-dynamic.jinja") # Values: here is where all authoritative state goes ctx.values.title = cell("str").set("Seamless Plotly") ctx.values.data = cell(data_dtype) ctx.values.attrib = cell("json") ctx.values.layout = cell("json") ctx.values.config = cell("json").set({}) ctx.values.width = cell("int").set(500) ctx.values.height = cell("int").set(500) ctx.values.divname = cell("str").set("plotlydiv") # Input pins ctx.title = ExportedInputPin(ctx.values.title) ctx.data = ExportedInputPin(ctx.values.data) ctx.attrib = ExportedInputPin(ctx.values.attrib) ctx.layout = ExportedInputPin(ctx.values.layout) ctx.config = ExportedInputPin(ctx.values.config) # Static HTML: templateer_static params_static = {"environment": {"title": "str", "divname": "str", "width": "int", "height": "int", "plotly_data": "json", "layout": "json", "config": "json", }, "templates": ["body", "head", "head_body"], "result": "head_body"} ctx.params.templateer_static = cell("json").set(params_static) ctx.templateer_static = templateer(ctx.params.templateer_static) ctx.values.height.connect(ctx.templateer_static.height) ctx.values.width.connect(ctx.templateer_static.width) ctx.values.divname.connect(ctx.templateer_static.divname) ctx.values.config.connect(ctx.templateer_static.config) ctx.values.layout.connect(ctx.templateer_static.layout) ctx.values.title.connect(ctx.templateer_static.title) ctx.templates.body.connect(ctx.templateer_static.body) ctx.templates.head.connect(ctx.templateer_static.head) ctx.templates.html_head_body.connect(ctx.templateer_static.head_body) ctx.templateer_static.RESULT.connect(ctx.values.html) #plotly_data temporary ctx.temp_plotly_data = cell("json") ctx.temp_plotly_data.connect(ctx.templateer_static.plotly_data) # Data integrator ctx.integrate_data = transformer({ "data": {"pin": "input", "dtype": "json"}, "attrib": {"pin": "input", "dtype": "json"}, "plotly_data": {"pin": "output", "dtype": "json"}, }) ctx.code.integrate_data = cell(("text", "code","python"))\ .fromfile("cell-integrate-data.py") ctx.code.integrate_data.connect(ctx.integrate_data.code) ctx.values.attrib.connect(ctx.integrate_data.attrib) ctx.integrate_data.plotly_data.connect(ctx.temp_plotly_data) if mode != "manual": #loaded_data temporary ctx.temp_loaded_data = cell("json") ctx.temp_loaded_data.connect(ctx.integrate_data.data) # Pandas data loader ctx.load_data = transformer({ "csv": {"pin": "input", "dtype": "text"}, "data": {"pin": "output", "dtype": "json"}, }) c = ctx.code.load_data = cell(("text", "code","python")) if mode == "nxy": c.fromfile("cell-load-data-nxy.py") elif mode == "nx": c.fromfile("cell-load-data-nx.py") ctx.code.load_data.connect(ctx.load_data.code) ctx.values.data.connect(ctx.load_data.csv) ctx.load_data.data.connect(ctx.temp_loaded_data) else: ctx.values.data.connect(ctx.integrate_data.data) if not dynamic_html: return from seamless.lib.dynamic_html import dynamic_html # Dynamic HTML output ctx.values.dynamic_html = cell(("text", "html")) ctx.dynamic_html = ExportedOutputPin(ctx.values.dynamic_html) # Dynamic HTML: templateer_dynamic ctx.params.templateer_dynamic = cell("json") params = {"environment": {"title": "text", "divname": "text", "width": "int", "height": "int", "dynamic_html": ("text","html") }, "templates": ["body", "head", "head_body"], "result": "head_body"} ctx.params.templateer_dynamic.set(params) ctx.templateer_dynamic = templateer(ctx.params.templateer_dynamic) ctx.values.height.connect(ctx.templateer_dynamic.height) ctx.values.width.connect(ctx.templateer_dynamic.width) ctx.values.divname.connect(ctx.templateer_dynamic.divname) ctx.values.title.connect(ctx.templateer_dynamic.title) ctx.templates.body_dynamic.connect(ctx.templateer_dynamic.body) ctx.templates.head.connect(ctx.templateer_dynamic.head) ctx.templates.html_head_body.connect(ctx.templateer_dynamic.head_body) ctx.templateer_dynamic.RESULT.connect(ctx.values.dynamic_html) # Dynamic HTML maker # TODO: more efficient plot regeneration ctx.params.dynamic_html_maker = cell("json") dynamic_html_params = { "divname": {"type": "var", "dtype": "str"}, "plotly_data": {"type": "var", "dtype": "json", "evals":["make_plot"]}, #"data": {"type": "var", "dtype": "json", "evals":["update_data"]}, #"attrib": {"type": "var", "dtype": "json", "evals":["update_attrib"]}, #"layout": {"type": "var", "dtype": "json", "evals":["update_layout"]}, "data": {"type": "var", "dtype": "json"}, "attrib": {"type": "var", "dtype": "json", "evals":["make_plot"]}, "layout": {"type": "var", "dtype": "json", "evals":["make_plot"]}, "config": {"type": "var", "dtype": "json", "evals":["make_plot"]}, "update_data": {"type": "eval", "on_start": False}, "update_attrib": {"type": "eval", "on_start": False}, "update_layout": {"type": "eval", "on_start": False}, "make_plot": {"type": "eval", "on_start": True}, } ctx.params.dynamic_html_maker.set(dynamic_html_params) ctx.dynamic_html_maker = dynamic_html(ctx.params.dynamic_html_maker) ctx.dynamic_html_maker.dynamic_html.cell().connect( ctx.templateer_dynamic.dynamic_html ) ctx.temp_plotly_data.connect(ctx.dynamic_html_maker.plotly_data) if mode == "manual": ctx.values.data.connect(ctx.dynamic_html_maker.data) else: ctx.temp_loaded_data.connect(ctx.dynamic_html_maker.data) ctx.values.attrib.connect(ctx.dynamic_html_maker.attrib) ctx.values.config.connect(ctx.dynamic_html_maker.config) ctx.values.layout.connect(ctx.dynamic_html_maker.layout) ctx.dynamic_html_maker.make_plot.cell().set(""" Plotly.newPlot(divname, plotly_data, layout, config); """) ctx.dynamic_html_maker.update_data.cell().set(""" var i, ii, subdata, update, attribname; for (i = 0; i < plotly_data.length; i++) { subdata = data[i]; update = {}; for (var attribname in subdata) { update[attribname] = [subdata[attribname]]; } /*if (i==0) { x = document.getElementById("echo"); x.innerHTML = "<pre>" + JSON.stringify(update) + "</pre>"; }*/ Plotly.restyle(divname, update, [i]); } """) ctx.dynamic_html_maker.update_attrib.cell().set(""" var i; for (i = 0; i < plotly_data.length; i++) { Plotly.restyle(divname, attrib[i], [i]); } """) ctx.dynamic_html_maker.update_layout.cell().set(""" Plotly.relayout(divname, layout); """) ctx.values.divname.connect(ctx.dynamic_html_maker.divname)
from seamless import context, cell, transformer, reactor from seamless.lib import edit, display, link from seamless.lib.gui.gl import glprogram, glwindow import numpy as np from scipy.spatial.distance import cdist ctx = context() ctx.params = context() ctx.links = context() ctx.code = context() file_dominant = True #for now, gen_sphere must be a reactor, because it has multiple outputs #TODO: make it a transformer in a future version of seamless c = ctx.params.gen_sphere = cell(("cson", "seamless", "reactor_params")) ctx.links.params_gen_sphere = link(c, ".", "params-gen-sphere.cson", file_dominant=file_dominant) rc = ctx.gen_sphere = reactor(c) c = ctx.code.gen_sphere = cell(("text", "code", "python")) ctx.links.code_gen_sphere = link(c, ".", "cell-gen-sphere.py", file_dominant=file_dominant) rc.code_start.cell().set("") c.connect(rc.code_update) rc.code_stop.cell().set("") do_scale_params = { "input":{"pin": "input", "dtype": "array"}, "scale":{"pin": "input", "dtype": "float"}, "output":{"pin": "output", "dtype": "array"} } ctx.subdivisions = cell("int").set(3)
#!/usr/bin/env ipython """Basic example Sets up a transformer that computes a result based on two inputs The input and the transformation code is edited live in a GUI """ from seamless import context, cell, pythoncell, transformer from seamless.lib import edit, display ctx = context() # Create 3 int cells: a=2, b=3, and result ctx.a = cell("int").set(2) ctx.b = cell("int").set(3) ctx.result = cell("int") # Set up a transformer that computes "result" as a function of "a" and "b" t = ctx.transform = transformer({ "a": {"pin": "input", "dtype": "int"}, "b": {"pin": "input", "dtype": "int"}, "result": {"pin": "output", "dtype": "int"} }) # Connect the cells to the transformer pins ctx.a.connect(t.a) ctx.b.connect(t.b) t.result.connect(ctx.result) # Every transformer has an implicit extra input pin, called "code"
def slash0(ctx, code, extern_map={}, **macro_args): import os, seamless, hashlib from seamless import context, cell, pythoncell, reactor, transformer from seamless.core.cell import Cell from seamless.core.worker import ExportedInputPin, ExportedOutputPin from seamless.lib.filehash import filehash from seamless.slash.parse_slash0 import parse_slash0 from seamless.slash.ast_slash0_validate import ast_slash0_validate from seamless.slash.slash0_standard_command import make_cmd_params ctx.cell_cmd_std = seamless.pythoncell().fromfile( "cell-command-standard.py") ast = parse_slash0(code) symbols = ast_slash0_validate(ast) env = {} variables = {} docs = {} contexts = {} filehashes = 0 def make_cmd_std(cmd_params): nonlocal filehashes tf_params = { "PARAMS": { "pin": "input", "dtype": "json", }, } in_connections = [] out_connections = [] for file_ in cmd_params["files"]: fh = filehash(file_) filehashes += 1 fhname = "filehash_%d" % filehashes tf_params[fhname] = {"pin": "input", "dtype": "str"} fhname = "filehash_%d" % filehashes setattr(ctx, fhname, fh) in_connections.append((fh.filehash.cell(), fhname)) for inp, typ in cmd_params["inputs"].items(): if typ == "doc": dtype = "text" prefix = "doc_" elif typ == "variable": dtype = "str" prefix = "var_" else: raise TypeError((cmd_params["lineno"], cmd_params["source"], inp, typ)) #must be a bug tf_params[inp] = { "pin": "input", "dtype": dtype, } in_connections.append((ctx.CHILDREN[prefix + inp], inp)) if len(cmd_params["outputs"]) > 1: raise NotImplementedError("Multiple outputs not yet implemented") for output in cmd_params["outputs"]: if hasattr(ctx, "ctx_" + output): dtype = "json" prefix = "ctx_" else: dtype = "text" prefix = "doc_" tf_params[output] = { "pin": "output", "dtype": dtype, } #TODO: in case of multiple outputs => single JSON cell + subcells (to be implemented) out_connections.append((output, ctx.CHILDREN[prefix + output])) tf = transformer(tf_params) tf.PARAMS.cell().set(cmd_params) for con in in_connections: pin = getattr(tf, con[1]) con[0].connect(pin) for con in out_connections: pin = getattr(tf, con[0]) pin.connect(con[1]) ctx.cell_cmd_std.connect(tf.code) return tf for node in ast["nodes"]["env"]: envname = node["name"] assert envname in os.environ, envname env[envname] = os.environ[envname] for node in ast["nodes"]["file"]: filename = node["name"] assert os.path.exists(filename), filename for node in ast["nodes"]["context"]: name = "ctx_" + node["name"] if node["is_json"]: c = cell("json") c.resource.save_policy = 2 else: c = context() contexts[node["name"]] = c setattr(ctx, name, c) for node in ast["nodes"]["variable"]: name = "var_" + node["name"] c = cell("str") c.resource.save_policy = 2 variables[node["name"]] = c setattr(ctx, name, c) origin = node["origin"] if origin == "intern": pass #nothing to do elif origin == "extern": raise NotImplementedError #c.set(...) using extern_mapping + macro_args elif origin == "input": pin = ExportedInputPin(c) setattr(ctx, node["name"], pin) else: raise ValueError(origin) for node in ast["nodes"]["doc"]: name = "doc_" + node["name"] c = cell("text") c.resource.save_policy = 2 docs[node["name"]] = c setattr(ctx, name, c) origin = node["origin"] if origin == "intern": pass #nothing to do elif origin == "extern": raise NotImplementedError #c.set(...) using extern_mapping + macro_args elif origin == "input": pin = ExportedInputPin(c) setattr(ctx, node["name"], pin) else: raise ValueError(origin) nodes = ast["nodes"] for noderef in ast["exports"]: node_type = noderef["type"] node = nodes[node_type][noderef["index"]] name = node["name"] if node_type == "context": c = contexts[name] assert isinstance(c, Cell) #TODO: export static subcontexts elif node_type == "variable": c = variables[name] elif node_type == "doc": c = docs[name] pin = ExportedOutputPin(c) setattr(ctx, name, pin) for command in ast["commands"]: source = command["cmd"]["source"] sourcehash = hashlib.md5(source.encode("utf-8")).hexdigest() cmd_type = command["cmd"]["command"] if cmd_type == "standard": cmd_params = make_cmd_params(command, nodes, env, sourcehash) command_worker = make_cmd_std(cmd_params) name = "cmd-" + sourcehash setattr(ctx, name, command_worker) setattr(ctx, name + "-PARAMS", command_worker.PARAMS.cell()) else: raise NotImplementedError(cmd_type)
from seamless import cell, pythoncell, context, reactor, transformer from seamless.silk import Silk import seamless.lib from seamless.lib.gui.basic_editor import edit from seamless.lib.gui.basic_display import display from seamless.lib import link from seamless.lib.gui.gl import glprogram ctx = context() file_dominant = False # Vertexdata Silk model ctx.silk_vertexdata = cell(("text", "code", "silk")) ctx.link_silk_vertexdata = link(ctx.silk_vertexdata, ".", "vertexdata.silk", file_dominant=file_dominant) ctx.registrar.silk.register(ctx.silk_vertexdata) # Shaders ctx.vert_shader = cell(("text", "code", "vertexshader")) ctx.frag_shader = cell(("text", "code", "fragmentshader")) ctx.link_vert_shader = link(ctx.vert_shader, ".", "vert_shader.glsl", file_dominant=file_dominant) ctx.link_frag_shader = link(ctx.frag_shader, ".", "frag_shader.glsl", file_dominant=file_dominant)
def slash0(ctx, code, extern_map = {}, **macro_args): import os, seamless, hashlib from seamless import context, cell, pythoncell, reactor, transformer from seamless.core.cell import Cell from seamless.core.worker import ExportedInputPin, ExportedOutputPin from seamless.lib.filehash import filehash from seamless.slash.parse_slash0 import parse_slash0 from seamless.slash.ast_slash0_validate import ast_slash0_validate from seamless.slash.slash0_standard_command import make_cmd_params ctx.cell_cmd_std = seamless.pythoncell().fromfile("cell-command-standard.py") ast = parse_slash0(code) symbols = ast_slash0_validate(ast) env = {} variables = {} docs = {} contexts = {} filehashes = 0 def make_cmd_std(cmd_params): nonlocal filehashes tf_params = { "PARAMS": { "pin": "input", "dtype": "json", }, } in_connections = [] out_connections = [] for file_ in cmd_params["files"]: fh = filehash(file_) filehashes += 1 fhname = "filehash_%d" % filehashes tf_params[fhname] = { "pin": "input", "dtype": "str" } fhname = "filehash_%d" % filehashes setattr(ctx, fhname, fh) in_connections.append((fh.filehash.cell(), fhname)) for inp,typ in cmd_params["inputs"].items(): if typ == "doc": dtype = "text" prefix = "doc_" elif typ == "variable": dtype = "str" prefix = "var_" else: raise TypeError((cmd_params["lineno"], cmd_params["source"], inp, typ)) #must be a bug tf_params[inp] = { "pin": "input", "dtype": dtype, } in_connections.append((ctx.CHILDREN[prefix + inp], inp)) if len(cmd_params["outputs"]) > 1: raise NotImplementedError("Multiple outputs not yet implemented") for output in cmd_params["outputs"]: if hasattr(ctx, "ctx_" + output): dtype = "json" prefix = "ctx_" else: dtype = "text" prefix = "doc_" tf_params[output] = { "pin": "output", "dtype": dtype, } #TODO: in case of multiple outputs => single JSON cell + subcells (to be implemented) out_connections.append((output, ctx.CHILDREN[prefix + output])) tf = transformer(tf_params) tf.PARAMS.cell().set(cmd_params) for con in in_connections: pin = getattr(tf, con[1]) con[0].connect(pin) for con in out_connections: pin = getattr(tf, con[0]) pin.connect(con[1]) ctx.cell_cmd_std.connect(tf.code) return tf for node in ast["nodes"]["env"]: envname = node["name"] assert envname in os.environ, envname env[envname] = os.environ[envname] for node in ast["nodes"]["file"]: filename = node["name"] assert os.path.exists(filename), filename for node in ast["nodes"]["context"]: name = "ctx_" + node["name"] if node["is_json"]: c = cell("json") c.resource.save_policy = 2 else: c = context() contexts[node["name"]] = c setattr(ctx, name, c) for node in ast["nodes"]["variable"]: name = "var_" + node["name"] c = cell("str") c.resource.save_policy = 2 variables[node["name"]] = c setattr(ctx, name, c) origin = node["origin"] if origin == "intern": pass #nothing to do elif origin == "extern": raise NotImplementedError #c.set(...) using extern_mapping + macro_args elif origin == "input": pin = ExportedInputPin(c) setattr(ctx, node["name"], pin) else: raise ValueError(origin) for node in ast["nodes"]["doc"]: name = "doc_" + node["name"] c = cell("text") c.resource.save_policy = 2 docs[node["name"]] = c setattr(ctx, name, c) origin = node["origin"] if origin == "intern": pass #nothing to do elif origin == "extern": raise NotImplementedError #c.set(...) using extern_mapping + macro_args elif origin == "input": pin = ExportedInputPin(c) setattr(ctx, node["name"], pin) else: raise ValueError(origin) nodes = ast["nodes"] for noderef in ast["exports"]: node_type = noderef["type"] node = nodes[node_type][noderef["index"]] name = node["name"] if node_type == "context": c = contexts[name] assert isinstance(c, Cell) #TODO: export static subcontexts elif node_type == "variable": c = variables[name] elif node_type == "doc": c = docs[name] pin = ExportedOutputPin(c) setattr(ctx, name, pin) for command in ast["commands"]: source = command["cmd"]["source"] sourcehash = hashlib.md5(source.encode("utf-8")).hexdigest() cmd_type = command["cmd"]["command"] if cmd_type == "standard": cmd_params = make_cmd_params(command, nodes, env, sourcehash) command_worker = make_cmd_std(cmd_params) name = "cmd-" + sourcehash setattr(ctx, name, command_worker) setattr(ctx, name +"-PARAMS", command_worker.PARAMS.cell()) else: raise NotImplementedError(cmd_type)