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)
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 ctx = Context() def code(): import numpy as np a = np.arange(20,80).astype(np.int8) return { "a": a } ctx.tf = code ctx.result = ctx.tf ctx.result2 = ctx.result ctx.result2.celltype = "mixed" ctx.a = ctx.result.a ctx.a.celltype = "bytes" ctx.compute() print(ctx.tf.status) print(ctx.tf.exception) print(ctx.result.value) print(ctx.result2.value) print(ctx.a.value)
import seamless.core.execute seamless.core.execute.DIRECT_PRINT = True from seamless.highlevel import Context from pprint import pprint ctx = Context() ###ctx.mount("/tmp/mount-test") ctx.a = 12 ctx.compute() print(ctx.a.value) print(ctx.a.schema) # None def triple_it(a): return 3 * a def triple_it_b(a, b): print("RUN!") return 3 * a + b ctx.transform = triple_it ctx.transform.hash_pattern = {"*": "#"} ctx.transform.debug = True ctx.transform.a = 1 print("START") 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)
Fortunately, this is easy to spoof for Python. Internally, ptvsd uses code from PyDev to debug the script. It relies on inspect.currentframe().f_code.co_filename to find the filename (although mappings can be defined). This corresponds *exactly* to the identifier of seamless.core.cached_compile. TODO: Therefore, a "virtual filename" attribute will be supported, which will be passed to cached_compile. It is your responsibility that this corresponds to a real file. TODO: interpreted modules will also have a file path in their tree. You can map to their write-only, just as for binary modules, to facilitate visual debugging. File names and paths must be stripped from checksum calculations. """ from seamless.highlevel import Context ctx = Context() ctx.a = 12 def triple_it(a): import sys, pdb class ForkedPdb(pdb.Pdb): """A Pdb subclass that may be used from a forked multiprocessing child """ def interaction(self, *args, **kwargs): _stdin = sys.stdin try: sys.stdin = open('/dev/stdin') super().interaction(*args, **kwargs) finally:
from seamless.highlevel import Context ctx = Context() ctx.a = {"x": 123} z = ctx.get_zip() print("ZIP size:", len(z)) ctx.b = ctx.a.x ctx.compute() print(ctx.b.value, ctx.b.checksum) z = ctx.get_zip() print("ZIP size:", len(z)) ctx.b.scratch = True ctx.compute() print(ctx.b.value, ctx.b.checksum) z = ctx.get_zip() print("ZIP size (should be 448):", len(z))
# Adapted from /seamless/stdlib/switch-join/switch-join.py from seamless.highlevel import Context, Cell from seamless import stdlib ctx = Context() ctx.include(stdlib.switch) ctx.include(stdlib.join) ctx.a = 10.0 ctx.a1 = Cell("float") ctx.a2 = Cell("float") ctx.a3 = Cell("float") ctx.f1 = 2.0 ctx.f2 = 3.0 ctx.f3 = 4.0 def add(a, b): return a + b def sub(a, b): return a - b def mul(a, b): return a * b ctx.op1 = add ctx.op1.a = ctx.a1 ctx.op1.b = ctx.f1
def join(input, which): return input.get(which) def func1(v): return v + 42 def func2(v): return -2 * v ctx = Context() ctx.join = join ctx.a = 1000 ctx.which = "a" ctx.switch = switch ctx.switch.input = ctx.a ctx.switch.which = ctx.which ctx.switched = ctx.switch ctx.func1 = func1 ctx.switched_a = ctx.switched.a ctx.func1.v = ctx.switched_a ctx.func2 = func2 ctx.switched_b = ctx.switched.b ctx.func2.v = ctx.switched_b ctx.tojoin = {} ctx.func1_result = ctx.func1 ctx.func2_result = ctx.func2 ctx.tojoin.a = ctx.func1_result
ctx.compute() print(ctx.tf.status) if ctx.tf.status != "Status: OK": print(ctx.tf.exception) print(ctx.result.value) ctx.tf.a = {"x": 100.1, "y": 200.1, "z": 300.1} ctx.tf.celltypes = {"a": "int"} ctx.b = -1000 ctx.compute() print(ctx.tf.status) if ctx.tf.status != "Status: OK": print(ctx.tf.exception) print(ctx.result.value) ctx.a = {"p": 1000, "q": 2000, "r": 3000} ctx.tf.a = ctx.a ctx.b = 1 ctx.compute() print(ctx.tf.status) if ctx.tf.status != "Status: OK": print(ctx.tf.exception) #print(ctx.tf.ctx.m.exception) #print(ctx.tf.ctx.m.ctx.subctx_p.tf.exception) print(ctx.result.value) ctx.a = {"pp": 100, "qq": 200, "rr": 300} import asyncio asyncio.get_event_loop().run_until_complete( asyncio.sleep(2)) # no re-translation print(ctx.tf.status)
seamless.database_cache.connect() seamless.set_ncores(2) seamless.set_parallel_evaluations(5) """ import logging logging.basicConfig() logging.getLogger("seamless").setLevel(logging.DEBUG) """ from seamless.highlevel import Context, Cell, Macro sctx = Context() sctx.inp = Cell("mixed") sctx.inp2 = Cell() sctx.inp2 = sctx.inp sctx.a = Cell("str") sctx.b = Cell("str") sctx.a = sctx.inp2.a sctx.b = sctx.inp2.b def add(a, b): print("ADD", a[:10], b[:10]) return a + b sctx.add = add sctx.add.a = sctx.a sctx.add.b = sctx.b sctx.result = sctx.add sctx.result.celltype = "str"
from seamless.highlevel import Context, Cell, Macro sctx = Context() sctx.inp = Cell("mixed") sctx.inp2 = Cell() sctx.inp2 = sctx.inp sctx.a = Cell("int") sctx.b = Cell("int") sctx.a = sctx.inp2.a sctx.b = sctx.inp2.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 sctx.result.celltype = "int" sctx.compute() data = [ { "a": 5, "b": 6, }, { "a": -2, "b": 8, }, { "a": 3, "b": 14,
from seamless.highlevel.library import LibraryContainer mylib = LibraryContainer("mylib") mylib.switch = ctx_switch mylib.switch.constructor = ctx_switch.constructor_code.value mylib.switch.params = ctx_switch.constructor_params.value mylib.join = ctx_join mylib.join.constructor = ctx_join.constructor_code.value mylib.join.params = ctx_join.constructor_params.value # 4: Run test example ctx2 = Context() ctx2.include(mylib.switch) ctx2.include(mylib.join) ctx2.a = 10.0 ctx2.a1 = Cell("float") ctx2.a2 = Cell("float") ctx2.a3 = Cell("float") ctx2.f1 = 2.0 ctx2.f2 = 3.0 ctx2.f3 = 4.0 def add(a,b): return a + b def sub(a,b): return a - b def mul(a,b): return a * b ctx2.op1 = add
from seamless.highlevel import Context, Cell ctx = Context() ctx.a_first = Cell("int").set(5) ctx.a_first.share(readonly=False) ctx.a_step = Cell("int").set(3) ctx.a_step.share(readonly=False) ctx.a_length = Cell("int").set(5) ctx.a_length.share(readonly=False) ctx.a = Cell() ctx.a.first = ctx.a_first ctx.a.step = ctx.a_step ctx.a.length = ctx.a_length def validate(self): assert self.first > 0 assert self.step > 0 assert self.length > 0 ctx.schema = Cell("plain") ctx.link(ctx.a.schema, ctx.schema) ctx.a.example.first = 0 ctx.a.example.step = 0 ctx.a.example.length = 0 ctx.a.add_validator(validate, "validate") ctx.b_first = Cell("int").set(8) ctx.b_first.share(readonly=False) ctx.b_step = Cell("int").set(1)
from seamless.highlevel import Context, Macro ctx = Context() m = ctx.m = Macro() m.pins.a = {"io": "input", "celltype": "int"} m.pins.c = {"io": "output", "celltype": "int"} ctx.a = 10 m.a = ctx.a m.b = 20 def run_macro(ctx, b): print("RUN MACRO", b) pins = { "a": "input", "b": "input", "c": "output", } ctx.tf = transformer(pins) ctx.a = cell("int") ctx.a.connect(ctx.tf.a) ctx.tf.b.cell().set(b) ctx.tf.code.cell().set("c = a * b") ctx.c = cell("int") ctx.tf.c.connect(ctx.c) return m.code = run_macro ctx.result = ctx.m.c ctx.compute() print(ctx.result.value)
from seamless.highlevel import Context, Transformer ctx = Context() ctx.a = 12 ipycode = """ %%timeit def triple_it(a): return 3 * a """ ctx.transform = Transformer() ctx.transform.language = "ipython" ctx.transform.code = ipycode ctx.transform.a = ctx.a ctx.myresult = ctx.transform ctx.equilibrate() print(ctx.myresult.value) ctx.a = 13 ctx.equilibrate() print(ctx.myresult.value)
from seamless.highlevel import Context, Cell from pprint import pprint ctx = Context() ###ctx.mount("/tmp/mount-test") 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)
from seamless.highlevel import Context ctx = Context() ctx.a = {} ctx.a.b = {} ctx.a.b.c = {} ctx.a.b.c.d = 10 print(ctx.a.value) def report(a,**args): print("report", a, args) ctx.report = report ctx.report.a = ctx.a ctx.report.b = ctx.a.b ctx.report.c = ctx.a.b.c ctx.report.d = ctx.a.b.c.d ctx.equilibrate() ctx.a.schema["b"].pop("c") ctx.a.b.c = None ctx.equilibrate() print(ctx.report.status()) ctx.a.b.c = {"d": 10, "dd": 20} ctx.equilibrate()
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.core.execute seamless.core.execute.DIRECT_PRINT = True from seamless.highlevel import Context ctx = Context() ctx.a = {} ctx.translate() ctx.a.b = {} ctx.a.b.c = {} ctx.a.b.c.d = 10 ctx.compute() print(ctx.a.value) def report(a,**args): print("report", a, args) ctx.report = report ctx.report.a = ctx.a ctx.report.b = ctx.a.b ctx.report.c = ctx.a.b.c ctx.report.d = ctx.a.b.c.d ctx.compute() print() ctx.a.example = ctx.a.value ctx.compute() ctx.a.example.b = ctx.a.b.value ctx.compute() ctx.a.example.b.c = ctx.a.b.c.value ctx.compute() ctx.a.example.b.c.d = ctx.a.b.c.d.value ctx.compute() print("SCHEMA A", ctx.a.schema) print("SCHEMA B",ctx.a.schema.properties.b)
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()
# 3: Package the contexts in a library from seamless.highlevel.library import LibraryContainer mylib = LibraryContainer("mylib") mylib.instantiate = ctx mylib.instantiate.constructor = ctx.constructor_code.value mylib.instantiate.params = ctx.constructor_params.value # 4: Run test example ctx = Context() ctx.include(mylib.instantiate) ctx.a = Cell().set({ "instance1": 3, "instance2": 5, "instance3": 7, "instance5": 9, }) ctx.b = Cell().set({ "instance1": 8, "instance2": 6, "instance3": 4, "instance5": 2, }) ctx.result = Cell() ctx.result2 = Cell() def mul(fa, fb): return fa * fb
import os, tempfile from seamless.highlevel import Context, Cell ctx = Context() ctx.a = 10 ctx.a.celltype = "plain" ctx.b = 30 ctx.b.celltype = "plain" 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);
from seamless.highlevel import Context ctx = Context() ctx.a = {"test": 1, "test2": 2} ctx.a.hash_pattern = {"*": "#"} print(ctx.a._get_hcell()) ctx.compute() print(ctx.a._get_cell().data) print(ctx.a._get_cell().value) print(ctx.a._get_cell().hash_pattern) print(ctx.a.data) print(ctx.a.value) print(ctx.a.value.unsilk) print(ctx.a.value.test) print() ctx.a.set({"test3": 10, "test4": 11}) ctx.compute() print(ctx.a.data) print(ctx.a.value) print(ctx.a.value.unsilk) print(ctx.a.value.test4)
from seamless.highlevel import Context # 0 ctx = Context() ctx.mount("/tmp/mount-test") # 1 ctx.a = 10 print(ctx.a.value) # 1a ctx.a = 12 ctx.translate() print(ctx.a.value) # 2 def double_it(a): return 2 * a ctx.transform = double_it ctx.transform.a = ctx.a ctx.myresult = ctx.transform ctx.equilibrate() print(ctx.myresult.value) # 3 ctx.a = 12 ctx.equilibrate() print(ctx.myresult.value) # 4
import os, tempfile from seamless.highlevel import Context, Cell ctx = Context() ctx.a = 10 ctx.a.celltype = "json" ctx.b = 30 ctx.b.celltype = "json" def build_transformer(): ctx.transform = lambda a,b: a + b ctx.transform.example.a = 0 ctx.transform.example.b = 0 ctx.result = ctx.transform ctx.result.celltype = "json" 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 ctx.code = """ extern "C" double add(int a, int b); extern "C" double transform(int a, int b) { return add(a,b); }""" ctx.transform.result.example = 0.0 #example, just to fill the schema
from seamless.highlevel import Context ctx = Context() ctx.a = 12 def triple_it(a): import sys, pdb class ForkedPdb(pdb.Pdb): """A Pdb subclass that may be used from a forked multiprocessing child """ def interaction(self, *args, **kwargs): _stdin = sys.stdin try: sys.stdin = open('/dev/stdin') super().interaction(*args, **kwargs) finally: sys.stdin = _stdin #from pdb_clone.pdb import set_trace #from pdb import set_trace #from ipdb import set_trace #set_trace = ForkedPdb().set_trace from seamless.pdb import set_trace set_trace() return 3 * a
import sys print([m for m in sys.modules if m.find("testmodule") > -1]) result = a + b ''' from seamless.highlevel import Transformer, Cell, Context, Module ctx = Context() ctx.testmodule = Module() ctx.testmodule.code = "q = 10" ctx.compute() print(ctx.testmodule.type) print(ctx.testmodule.language) print(ctx.testmodule.code) ctx.a = Cell("text").set("a=42") ctx.testmodule = ctx.a ctx.compute() print(ctx.testmodule.code) ctx.a = "a=43" ctx.compute() print(ctx.testmodule.code) ctx.testmodule.code = "q = 9" ctx.compute() print(ctx.testmodule.code) ctx.testmodule.set("q = 12") ctx.compute() print(ctx.testmodule.code)