예제 #1
0
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)
예제 #2
0
def constructor(ctx, libctx, template, pattern, ncopies, imports, exports,
                entries, exits):
    def verify_path(path):
        if isinstance(path, (str, int)):
            return (path, )
        assert isinstance(path, (list, tuple)), type(path)
        for attr in path:
            assert isinstance(attr, (str, int)), path
        return path

    for k, path in list(entries.items()):
        assert k in imports, k
        entries[k] = verify_path(path)
    for k, path in list(exits.items()):
        assert k in exports, k
        exits[k] = verify_path(path)
    for n in range(ncopies):
        name = "{}{}".format(pattern, n + 1)
        instance = Context()
        instance.set_graph(template)
        setattr(ctx, name, instance)
        instance = getattr(ctx, name)  # SubContext
        for k, path in entries.items():
            import_cell = imports[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)))
            import_cell.connect(subinstance, source_path=name)
        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)
예제 #3
0
def bind_status_graph(ctx, status_graph, *, zips=None, mounts=False, shares=True):
    """"Creates context that will monitor the status of ctx

The context is loaded from status_graph, which must be a graph in JSON format.
It uses the same manager as ctx.
The status graph's underlying buffers must be available already
(from add_zip or via Seamless database)
The status graph must have a cell called "graph",
 and normally, also a cell shared as "index.html"
The status graph will receive the share namespace "status"

mounts and shares have the same meaning as in from_graph

Additional zips can be provided.
They will be passed to ctx.add_zip before the graph is loaded
"""
    from seamless.highlevel import Context
    ctx2 = Context()
    if zips is not None:
        for zipf in zips:
            ctx2.add_zip(zipf)
    ctx2.share_namespace="status"
    ctx2.set_graph(
        status_graph,
        mounts=mounts,
        shares=shares
    )
    assert "graph" in ctx2.get_children()
    observe_graph_bound = partial(
        observe_graph, ctx, ctx2
    )
    ctx2.translate()
    params = {"runtime": True}
    ctx.observe(("get_graph",), observe_graph_bound, OBSERVE_GRAPH_DELAY, params=params)
    def observe2(graph):
        try:
            graph_rt = ctx2.graph_rt
        except AttributeError:
            graph_rt = None
        if not isinstance(graph_rt, Cell):
            return
        ctx2.graph.set(deepcopy(graph))
    ctx.observe(("get_graph",), observe2, OBSERVE_GRAPH_DELAY)
    return ctx2
예제 #4
0
async def load():
    from seamless.metalevel.bind_status_graph import bind_status_graph_async
    import json

    global ctx, webctx, save
    graph = json.load(open("graph/" + PROJNAME + ".seamless"))
    for f in ("web/index.html", "web/index.js", "web/index-CONFLICT.html",
              "web/index-CONFLICT.js", "web/webform.json",
              "web/webform-CONFLICT.txt"):
        if os.path.exists(f):
            dest = f + "-BAK"
            if os.path.exists(dest):
                os.remove(dest)
            shutil.move(f, dest)
    ctx = Context()
    ctx.load_vault("vault")
    ctx.set_graph(graph, mounts=True, shares=True)
    await ctx.translation(force=True)

    status_graph = json.load(open("graph/" + PROJNAME + "-webctx.seamless"))

    webctx = await bind_status_graph_async(ctx,
                                           status_graph,
                                           mounts=True,
                                           shares=True)

    def save():
        import os, itertools, shutil

        def backup(filename):
            if not os.path.exists(filename):
                return filename
            for n in itertools.count():
                n2 = n if n else ""
                new_filename = "{}.bak{}".format(filename, n2)
                if not os.path.exists(new_filename):
                    break
            shutil.move(filename, new_filename)
            return filename

        ctx.save_graph(backup("graph/" + PROJNAME + ".seamless"))
        webctx.save_graph(backup("graph/" + PROJNAME + "-monitoring.seamless"))
        ctx.save_vault("vault")
        webctx.save_vault("vault")

    print("""Project loaded.

    Main context is "ctx"
    Web/status context is "webctx"

    Open http://localhost:<REST server port> to see the web page
    Open http://localhost:<REST server port>/status/status.html to see the status

    Run save() to save the project
    """)
예제 #5
0
async def load():
    from seamless.metalevel.bind_status_graph import bind_status_graph_async
    import json

    global ctx, ctx2, save
    graph = json.load(open("graph/" + PROJNAME + ".seamless"))
    ctx = Context()
    ctx.add_zip("graph/" + PROJNAME + ".zip")
    ctx.set_graph(graph, mounts=True, shares=True)
    await ctx.translation(force=True)

    status_graph = json.load(open("graph/" + PROJNAME +
                                  "-monitoring.seamless"))

    ctx2 = await bind_status_graph_async(
        ctx,
        status_graph,
        mounts=True,
        shares=True,
        zips=["graph/" + PROJNAME + "-monitoring.zip"],
    )

    def save():
        import os, itertools, shutil

        def backup(filename):
            if not os.path.exists(filename):
                return filename
            for n in itertools.count():
                n2 = n if n else ""
                new_filename = "{}.bak{}".format(filename, n2)
                if not os.path.exists(new_filename):
                    break
            shutil.move(filename, new_filename)
            return filename

        ctx.save_graph(backup("graph/" + PROJNAME + ".seamless"))
        ctx2.save_graph(backup("graph/" + PROJNAME + "-monitoring.seamless"))
        ctx.save_zip(backup("graph/" + PROJNAME + ".zip"))
        ctx2.save_zip(backup("graph/" + PROJNAME + "-monitoring.zip"))

    print("""Project loaded.

    Main context is "ctx"
    Status context is "ctx2"
    Run save() to save the context
    """)
예제 #6
0
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)
예제 #7
0
from seamless.highlevel import Context
import time

ctx = Context()
ctx.pdbcodes = ["1AVX", "1ACB"]
#ctx.pdbcodes.celltype = "plain"
ctx.test = ["1BBB"]
#ctx.test.celltype = "plain"
t = ctx.pdbcodes.traitlet()
ctx.compute()

def obs(change):
    print("OBS", change)
t.observe(obs)

print("start")
print(t.value)
t.value = ["1ZZZ"]
time.sleep(0.2) #value update takes 0.1 sec
ctx.compute()
print(t.value)
print(ctx.pdbcodes.value)
print("#2")
ctx.pdbcodes = ["1AAA"]
ctx.compute()
print(t.value)
print(ctx.pdbcodes.value)
print("#3")
t.value = ["1QQQ"]
time.sleep(0.2) #value update takes 0.1 sec
ctx.compute()
예제 #8
0
from seamless.highlevel import Context, Transformer

try:
    import seamless
    redis_sink = seamless.RedisSink()
    import asyncio
    asyncio.get_event_loop().run_until_complete(asyncio.sleep(0.5))
    redis_sink.connection.info()
except:
    print("No Redis found!")

ctx = Context()

ctx.pdb0 = open("1crn.pdb").read()
ctx.pdb0.celltype = "text"
ctx.pdb0.share()

ctx.filter_pdb = Transformer()
ctx.filter_pdb.language = "bash"
ctx.filter_pdb.code = 'grep ATOM pdb0 | awk \'$3 == "CA" || $3 == "C" || $3 == "O" || $3 == "N"\' '
ctx.filter_pdb.pdb0 = ctx.pdb0

ctx.bb_pdb = ctx.filter_pdb
ctx.bb_pdb.celltype = "text"
ctx.bb_pdb.share()

ctx.bb_pdb = ctx.filter_pdb
ctx.bb_pdb.celltype = "text"
ctx.bb_pdb.share()

ctx.fix_pdb = Transformer()
예제 #9
0
    return 3 * a + b


if __name__ == "__main__":

    # force the use of processes
    import os
    os.environ["SEAMLESS_USE_PROCESSES"] = "true"

    #set multiprocessing to "spawn", as it would be on Windows
    import multiprocessing
    multiprocessing.set_start_method("spawn")

    from seamless.highlevel import Context

    ctx = Context()
    #ctx.mount("/tmp/mount-test")

    ctx.a = 12

    ctx.transform = triple_it
    ctx.transform.a = ctx.a
    ctx.myresult = ctx.transform
    ctx.equilibrate()
    print(ctx.myresult.value)

    ctx.tfcode >> ctx.transform.code
    print(ctx.tfcode._get_hcell())
    print(ctx.tfcode.value)
    ctx.transform.b = 100
    ctx.tfcode = triple_it_b
예제 #10
0
from seamless.highlevel import Context, Transformer, Cell
from functools import partial

ctx2 = Context()
ctx2.share_namespace = "status"
ctx2.graph = {}
ctx2.graph.celltype = "plain"
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()
예제 #11
0
파일: mime.py 프로젝트: sjdv1982/seamless
from seamless.highlevel import Context, Reactor
ctx = Context()
ctx.test = "<b>This is a test</b>"
print("cell:")
print(ctx.test.mimetype)
ctx.test.datatype = "text"
print(ctx.test.mimetype)
ctx.test.datatype = "html"
print(ctx.test.mimetype)
ctx.test.mimetype = "text/xhtml"
print(ctx.test.mimetype)
print()

ctx.tf = lambda a,b: 10
print("transformer:")
print(ctx.tf.code.mimetype)
print()

ctx.rc = Reactor()
print("reactor:")
print(ctx.rc.code_start.mimetype)
print(ctx.rc.code_update.mimetype)
print(ctx.rc.code_stop.mimetype)
print()

ctx.tf._get_htf()["language"] = "cpp" #hack
print("C++ transformer:")
print(ctx.tf.code.mimetype)
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()
예제 #13
0
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);
예제 #14
0
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()
예제 #15
0
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)
예제 #16
0
import numpy as np
from seamless.highlevel import Context, Cell, stdlib
from seamless.highlevel import set_resource

gen_header_file = "gen_header.py"
compiler_file = "compiler.py"
translator_file = "translator.py"

ctx = Context()

def gen_header(input_schema, result_schema, input_name, result_name, inputpins):
    return None
ctx.gen_header = gen_header
pins = ctx.gen_header._get_htf()["pins"] ###
pins["input_schema"]["access_mode"] = "plain"
pins["result_schema"]["access_mode"] = "plain"
pins["input_name"]["access_mode"] = "text"
pins["result_name"]["access_mode"] = "text"
ctx.gen_header.code = set_resource(gen_header_file)

ctx.compiler = lambda lang, header, compiled_code, main_module, compiler_verbose: None
ctx.compiler.code = set_resource(compiler_file)
pins = ctx.compiler._get_htf()["pins"] ###
pins["lang"]["access_mode"] = "text"
pins["compiled_code"]["access_mode"] = "text"
pins["header"]["access_mode"] = "text"
pins["main_module"]["access_mode"] = "plain"
pins["compiler_verbose"]["access_mode"] = "plain"

def func(binary_module, pins, input_schema, result_schema, input_name, result_name, kwargs):
    None
예제 #17
0
파일: mount.py 프로젝트: sjdv1982/seamless
from seamless.highlevel import Context
ctx = Context()
ctx.txt = "not OK"
ctx.txt.celltype = "text"
ctx.txt.mount("mount.txt", authority="file")
ctx.equilibrate()
print(ctx.txt.value)

ctx.mount("mount-test", persistent=False)
ctx.equilibrate()
예제 #18
0
from seamless.highlevel import Context, mylib

ctx = Context()
ctx.spam = "spam"
mylib.Test = ctx
mylib.Test.set_constructor(
    constructor=lambda ctx: ctx,
    post_constructor=None,
    args=[],
    direct_library_access=True
)
ctx = Context()
ctx.test = mylib.Test()
print(ctx.test.spam)
print(ctx.test.spam.value)
예제 #19
0
import os, tempfile
from seamless.highlevel import Context, Cell

ctx = Context()
ctx.mount(os.path.join(tempfile.gettempdir(), "transformer-compiled"))

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.equilibrate()
print(ctx.result.value)

ctx.transform.language = "cpp"
ctx.code >> ctx.transform.code
ctx.code = """
extern "C" double transform(int a, int b) {
    return a + b;
}"""
ctx.transform.result.example = 0.0 #example, just to fill the schema
ctx.equilibrate()
print(ctx.result.value)

ctx.a = 10
ctx.a.celltype = "json"
ctx.transform.a = ctx.a

ctx.b = 30
ctx.b.celltype = "json"
ctx.transform.b = ctx.b
예제 #20
0
    params["port"] = db_port
seamless.database_sink.connect(**params)
seamless.database_cache.connect(**params)

communion_server.configure_master(
    transformation_job=True,
    transformation_status=True,
)

import asyncio
asyncio.get_event_loop().run_until_complete(asyncio.sleep(2))

import math
from seamless.highlevel import Context, Cell
import json
ctx = Context()
ctx.pi = math.pi
ctx.doubleit = lambda a: 2 * a
ctx.doubleit.a = ctx.pi
ctx.twopi = ctx.doubleit
ctx.translate()

ctx.compute()
print(ctx.pi.value)
print(ctx.twopi.value)

ctx.doubleit.code = lambda a: 42
ctx.compute()
print(ctx.pi.value)
print(ctx.twopi.value)
예제 #21
0
"""
Version of high-in-low5 that maps over N inputs, zipped
"""

from seamless.highlevel import Context, Cell, Macro
from seamless.highlevel.library import LibraryContainer

mylib = LibraryContainer("mylib")
mylib.map_list_N = Context()


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)
예제 #22
0
파일: link.py 프로젝트: sjdv1982/seamless
from seamless.highlevel import Context, Cell, Link, Reactor

ctx = Context()

"""
ctx.tf = lambda a,b: 42
ctx.x = ctx.tf.code
ctx.y = ctx.x
ctx.z = ctx.y
ctx.translate()
print(ctx.tf.code.value)
print(ctx.x.value)
print(ctx.y.value)
print(ctx.z.value)

ctx.x = "blah"
print(ctx.x._get_hcell())
ctx.x.datatype = "text"
print(ctx.tf.code.value)
print(ctx.x.value)
print(ctx.y.value)
print(ctx.z.value)

ctx.tf.code = lambda q,r: 10
print(ctx.tf.code.value)
print(ctx.x.value)

ctx.z = ctx.tf.code
ctx.x = "blah2"
print(ctx.tf.code.value)
print(ctx.x.value)
예제 #23
0
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)
예제 #24
0
from seamless.highlevel import Context, Cell

ctx = Context()
ctx.a = 10
t = ctx.a.traitlet()
ctx.a.set(20)
print(t.value)
t.value = 80
print(ctx.a.value)
예제 #25
0
from seamless.highlevel import Context

ctx = Context()
ctx.mount("/tmp/mount-test")

ctx.a = 12

def triple_it(a, b):
    print("3 * a + b, a = %s, b = %s" % (a, b))
    return 3 * a + b

ctx.transform = triple_it
ctx.transform.a = ctx.a
ctx.transform.b = 6
ctx.myresult = ctx.transform
ctx.equilibrate()
print(ctx.myresult.value)

ctx2 = Context()
ctx2.sub = ctx
ctx2.sub2 = ctx
print(ctx2.sub.myresult.value)
ctx2.equilibrate()
print(ctx2.sub.myresult.value)

ctx2.sub.a = 3
ctx2.sub2.a = 5
ctx2.equilibrate()
print(ctx2.sub.myresult.value)
print(ctx2.sub2.myresult.value)
예제 #26
0
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)
예제 #27
0
NOTE: it is extremely annoying that all debuggers use breakpoints based on file names.
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)
예제 #28
0
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))
예제 #29
0
from seamless.highlevel import Context, Cell, stdlib
from seamless.highlevel import set_resource

executor_file = "executor.py"

ctx = Context()
ctx.executor_code = set_resource(executor_file)
ctx.executor_code._get_hcell()["language"] = "python"
ctx.executor_code._get_hcell()["transformer"] = True
ctx.executor_code.celltype = "code"
ctx.translate()

if __name__ == "__main__":
    #ctx.mount("/tmp/seamless-test", persistent=False) #TODO: persistent=False (does not delete atm)
    ctx.testdata = "a\nb\nc\nd\ne\nf\n"       
    ctx.docker_command = "bash -c 'head -$lines testdata'"
    ctx.executor = lambda docker_command, docker_image, docker_options, testdata, pins, lines: None
    ctx.executor.pins = ["lines", "testdata"]
    ctx.executor.code = ctx.executor_code
    ctx.executor.docker_command = ctx.docker_command
    ctx.executor.docker_image = "ubuntu"
    ctx.executor.docker_options = {}
    ctx.executor.testdata = ctx.testdata
    ctx.executor.lines = 3
    ctx.result = ctx.executor
    ctx.equilibrate()
    print(ctx.result.value)
    ctx.executor_code = ctx.executor_code.value + "\npass"
    ctx.equilibrate()
    print(ctx.result.value)
else:
예제 #30
0
from seamless.highlevel import Context, Reactor, Cell, Link, stdlib
from seamless.highlevel import set_resource

ctx = Context()
merge = ctx.merge = Reactor()
merge._get_hrc()["plain"] = True ### TODO: direct API from highlevel.Reactor

merge.set_pin("fallback", io="input")

merge.set_pin("upstream", io="input", access_mode="text")
merge.set_pin("upstream_stage", io="edit", access_mode="text", must_be_defined=False)
merge.set_pin("base", io="edit", access_mode="text", must_be_defined=False)
merge.set_pin("modified", io="edit", access_mode="text", must_be_defined=False)
merge.set_pin("conflict", io="edit", access_mode="text", must_be_defined=False)
merge.set_pin("merged", io="output", access_mode="text")

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()
예제 #31
0
from seamless.highlevel import Context, mylib

def constructor(ctx, dup):
    for n in range(dup):
        cellname = "dup" + str(n+1)
        setattr(ctx, cellname, ctx.spam.value)
        if n+1 > 2:
            getattr(ctx, cellname).set(n+1)
    return ctx

ctx = Context()
ctx.spam = "spam"
mylib.Test = ctx
mylib.Test.set_constructor(
    constructor=constructor,
    post_constructor=None,
    args=[
      {"name": "dup", "as_cell": False, "auth": True},
    ],
    direct_library_access=False
)
ctx = Context()

ctx.test = mylib.Test(dup=6)
print(ctx.test.spam, ctx.test.spam.value)
print(ctx.test.dup3, ctx.test.dup3.value)
print(ctx.test.dup6, ctx.test.dup6.value)

ctx.test2 = mylib.Test(3)
print(ctx.test2.dup1, ctx.test2.dup1.value)
print(ctx.test2.dup2, ctx.test2.dup2.value)
예제 #32
0
from seamless.highlevel import Context
ctx = Context()
ctx.pdbcodes = ["1AVX", "1ACB"]
t = ctx.pdbcodes.traitlet()
ctx.translate()

def obs(change):
    print("OBS", change)
t.observe(obs)

print("start")
t.value = ["1ZZZ"]
print(t.value)
print(ctx.pdbcodes.value)
print("again") # This will notify once (bug in traitlets?)
ctx.pdbcodes = ["1AAA"]
print(t.value)
print(ctx.pdbcodes.value)
print("again3")
t.receive_update(["1BBB"]) # This will notify twice (bug doesn't trigger here)
예제 #33
0
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"})
예제 #34
0
import math
from seamless.highlevel import Context, Cell
import json
ctx = Context()
ctx.pi = math.pi
ctx.doubleit = lambda a: 2 * a
ctx.doubleit.a = ctx.pi
ctx.twopi = ctx.doubleit
ctx.translate()

graph = ctx.get_graph()
print(json.dumps( graph, indent=2, sort_keys=True))
json.dump(graph, open("twopi.seamless", "w"), indent=2, sort_keys=True)

ctx.equilibrate()
print(ctx.pi.value)
print(ctx.twopi.value)

ctx.doubleit.code = lambda a: 42
ctx.equilibrate()
print(ctx.pi.value)
print(ctx.twopi.value)

ctx.translate(force=True)
ctx.equilibrate()
print(ctx.pi.value)
print(ctx.twopi.value)
print()

ctx.doubleit.code = lambda a: 2 * a
ctx.equilibrate()
예제 #35
0
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()
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
예제 #37
0
파일: merge.py 프로젝트: sjdv1982/seamless
from seamless.highlevel import Context, Cell
from seamless.highlevel import set_resource

# 1: Setup context

ctx = Context()

def macro_code(ctx, fallback_mode, code_start, code_update):
    reactor_params = {
        "fallback_mode": {"io": "input", "celltype": "str"},
        "upstream": {"io": "input", "celltype": "text"},
        "merged":  {"io": "output", "celltype": "text"},
        "state": {"io": "output", "celltype": "str"},
    }
    for k in "upstream_stage", "base", "modified", "conflict":
        reactor_params[k] = {
            "io": "edit",
            "celltype": "text",
            "must_be_defined": False,
        }

    merge = ctx.merge = reactor(reactor_params)
    ctx.fallback_mode = cell("str").set(fallback_mode)
    ctx.fallback_mode.connect(merge.fallback_mode)
    ctx.upstream = cell("text")
    ctx.upstream.connect(merge.upstream)
    ctx.upstream_stage = cell("text")
    ctx.upstream_stage.connect(merge.upstream_stage)
    ctx.base = cell("text")
    ctx.base.connect(merge.base)
    ctx.modified = cell("text")
예제 #38
0
from seamless.highlevel import Context

ctx = Context()
ctx.code = "bash -c 'head -$lines testdata'"
ctx.code.celltype = "text"
ctx.code.mount("/tmp/test.bash")
ctx.tf = lambda lines, testdata: None
ctx.tf.language = "docker"
ctx.tf.docker_image = "ubuntu"
ctx.tf.docker_options = {"name": "ubuntu-container"}
ctx.tf.testdata = "a \nb \nc \nd \ne \nf \n"  
ctx.tf.lines = 3
ctx.tf.code = ctx.code
ctx.result = ctx.tf
ctx.result.mount("/tmp/result")
ctx.translate(force=True)
ctx.equilibrate()
print(ctx.result.value)
예제 #39
0
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()
예제 #40
0
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)
예제 #41
0
파일: simplest.py 프로젝트: xeTaiz/seamless
from seamless.highlevel import Context, mylib

ctx = Context()
ctx.spam = "spam"
mylib.Test = ctx
mylib.Test.set_constructor(constructor=lambda ctx: ctx,
                           post_constructor=None,
                           args=[],
                           direct_library_access=True)
ctx = Context()
ctx.test = mylib.Test()
print(ctx.test.spam)
print(ctx.test.spam.value)
예제 #42
0
import math
from seamless.highlevel import Context, Cell
import json

import seamless
seamless.database_sink.connect()

ctx = Context()
ctx.pi = math.pi
ctx.doubleit = lambda a: 2 * a
ctx.doubleit.a = ctx.pi
ctx.twopi = ctx.doubleit
ctx.translate()

graph = ctx.get_graph()
json.dump(graph,
          open("/tmp/twopi-database.seamless", "w"),
          indent=2,
          sort_keys=True)
import os
os.system("md5sum twopi.seamless /tmp/twopi-database.seamless")
예제 #43
0
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)
예제 #44
0
파일: bash.py 프로젝트: sjdv1982/seamless
from seamless.highlevel import Context

ctx = Context()
ctx.code = "head -$lines testdata"
ctx.code.celltype = "text"
ctx.code.mount("/tmp/test.bash")
ctx.tf = lambda lines, testdata: None
ctx.tf.language = "bash"
ctx.tf.testdata = "a \nb \nc \nd \ne \nf \n"    
ctx.tf.lines = 3
ctx.tf.code = ctx.code
ctx.result = ctx.tf
ctx.result.mount("/tmp/result")
ctx.translate(force=True)
ctx.equilibrate()
print(ctx.result.value)
ctx.code = "tar czf test.tgz testdata; cat test.tgz"
ctx.equilibrate()
print(ctx.result.value)
ctx.code = "python3 -c 'import numpy as np; np.save(\"test\",np.arange(12)*3)'; cat test.npy"
ctx.equilibrate()
print(ctx.result.value)
예제 #45
0
from seamless.highlevel import Context, Reactor, stdlib
from seamless.highlevel import set_resource

ctx = Context()
b = ctx.browser = Reactor()

b.code_start = set_resource("cell-browser.py")
b.code_update = set_resource("cell-browser_UPDATE.py")
b.code_stop = "widget.destroy()"

b.mimetype = "text"
b.charset = "UTF-8" #for text/ ; otherwise, the browser must figure it out
b.title = "Seamless browser"
b.val = "Hello world!"
ctx.equilibrate()

if __name__ == "__main__":
    print(b._get_rc().status())
    print(b._get_rc().io.outchannels)
    print(b._get_rc().io.value)
    print(b.val.mimetype)
    pass
else:
    stdlib.browser = ctx
예제 #46
0
from seamless.highlevel import Context
import json

ctx = Context()
###ctx.mount("/tmp/mount-test")

ctx.a = 12


def triple_it(a):
    print("triple", a)
    return 3 * a


ctx.transform = triple_it
ctx.transform.a = ctx.a
ctx.transform.debug = True
ctx.myresult = ctx.transform
ctx.compute()
print(ctx.myresult.value)

ctx2 = Context()
ctx2.sub = ctx
ctx2.sub2 = ctx
ctx2.translate()
print(ctx2.sub.myresult.value)
ctx2.compute()
print(ctx2.sub.myresult.value)

ctx2.sub.a = 3
ctx2.sub2.a = 5
예제 #47
0
파일: simple.py 프로젝트: xeTaiz/seamless
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
예제 #48
0
from seamless.highlevel import Context, stdlib

ctx = Context()
ctx.a = 12

def triple_it(a, **kwargs):
    print("triple", a, kwargs)
    return 3 * a

ctx.transform = triple_it
ctx.transform.a = ctx.a
ctx.myresult = ctx.transform
###ctx.equilibrate()
print(ctx.myresult.value)

ctx.transform.b = 777
ctx.translate(force=True)
stdlib.triple_it = ctx

print("START")
ctx2 = Context()
ctx2.sub = stdlib.triple_it
ctx2.sub2 = stdlib.triple_it
ctx2.equilibrate()

print(ctx2.sub.myresult.value)
print(ctx2.sub2.myresult.value)
print(ctx2.sub.transform.a.value)
print(ctx2.sub.transform.b.value)

print("UPDATE...")
예제 #49
0
Since Seamless is purely functional, 
there is no such thing as NextFlow queue channels

Work in progress!
"""

from cffi import api
from seamless.core.transformer import Transformer
from attr import has
from seamless.highlevel import Context, Cell
from seamless.highlevel.library import LibraryContainer
from silk.Silk import Silk

mylib = LibraryContainer("mylib")

ctx0 = Context()


def fromPath(self, pattern, is_text):
    # Warning: loads everything into memory! Make version that takes a cell...
    import glob
    if not hasattr(self, "state"):
        self.state = {}
    operators = getattr(self.state, "operators", [])
    if len(operators) or hasattr(self.state, "startvalue"):
        raise ValueError("fromPath must be the first operator")
    filenames = glob.glob(pattern)
    if not len(filenames):
        raise ValueError("No files found")
    if is_text:
        mode = "r"
예제 #50
0
파일: mount.py 프로젝트: sjdv1982/seamless
from seamless.highlevel import Context, Cell
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()
예제 #51
0
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

예제 #52
0
import math
from seamless.highlevel import Context, Cell
import json

import seamless
redis_sink = seamless.RedisSink()

ctx = Context()
ctx.pi = math.pi
ctx.doubleit = lambda a: 2 * a
ctx.doubleit.a = ctx.pi
ctx.twopi = ctx.doubleit
ctx.translate()

graph = ctx.get_graph()
json.dump(graph, open("twopi.seamless", "w"), indent=2, sort_keys=True)