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
""")
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
if shareserver_address is not None:
if shareserver_address == "HOSTNAME":
shareserver_address = subprocess.getoutput("hostname -I | awk '{print $1}'")
seamless.shareserver.DEFAULT_ADDRESS = shareserver_address
print("Setting shareserver address to: {}".format(shareserver_address))
import seamless.stdlib
from seamless.highlevel import load_graph, Context
graph = json.load(args.graph)
if args.zipfile is None and not args.add_zip:
ctx = load_graph(graph, mounts=args.mounts, shares=args.shares)
else:
ctx = Context()
if args.zipfile is not None:
ctx.add_zip(args.zipfile)
for zipf in args.add_zip:
ctx.add_zip(zipf)
ctx.set_graph(graph, mounts=args.mounts, shares=args.shares)
if args.database:
params = {}
db_host = env.get("SEAMLESS_DATABASE_HOST")
if db_host is not None:
params["host"] = db_host
db_port = env.get("SEAMLESS_DATABASE_PORT")
if db_port is not None:
params["port"] = db_port
seamless.database_sink.connect(**params)
seamless.database_cache.connect(**params)
ctx.translate()
import seamless
from seamless.core.cache.buffer_cache import buffer_cache
import os
env = os.environ
params = {}
db_host = env.get("SEAMLESS_DATABASE_HOST")
if db_host is not None:
params["host"] = db_host
db_port = env.get("SEAMLESS_DATABASE_PORT")
if db_port is not None:
params["port"] = db_port
seamless.database_sink.connect(**params)
# TODO: proper command line options (also for mounts)
import sys
from seamless.highlevel import Context
zipfile = sys.argv[1]
ctx = Context()
checksums = ctx.add_zip(zipfile, incref=True)
for checksum in checksums:
buffer_cache.decref(bytes.fromhex(checksum))
import json
import seamless
from seamless.highlevel import load_graph, Context
graph = json.load(open("twopi-result.seamless"))
zipfile = "twopi-result.zip"
""" # Does not work well...
ctx = load_graph(graph)
ctx.add_zip(zipfile)
ctx.translate(force=True)
print(ctx.pi.value)
"""
ctx = Context()
ctx.add_zip(zipfile) # for now, should be before set_graph to avoid glitches
ctx.set_graph(graph)
ctx.translate()
print(ctx.pi.value.unsilk
) # For now, None; could be defined immediately in future
print(ctx.twopi.value.unsilk) # set to None, because of independence
ctx.compute() # re-runs the computation;
# in the future, the graph will be loaded more smartly
# so that this is either not needed, or runs instantly (cache hit)
print(ctx.twopi.value.unsilk)
print()
import seamless
seamless_dir = os.path.dirname(seamless.__file__)
empty = Context()
empty.save_graph("graph/{0}.seamless".format(project_name))
del empty
f = "webgen.seamless"
source = os.path.join(seamless_dir, "graphs", f)
dest = os.path.join("graph", "{0}-webctx.seamless".format(project_name))
shutil.copy(source, dest)
graph = json.load(open(dest))
ctx = Context()
ctx.add_zip(os.path.join(seamless_dir, "graphs", "webgen.zip"))
ctx.set_graph(graph)
ctx.save_vault("vault")
gitignore = """# Seamless vault files and backups
# 1. Independent, big buffers. Uncomment the following line to remove them from version control
### vault/independent/big/*
# 2. Dependent, big buffers. Comment out the following line to put them under version control
vault/dependent/big/*
# 3. Dependent, small buffers. Comment out the following line to put them under version control
vault/dependent/small/*
# 4. Backups of the Seamless graph. Comment out the following line to put them under version control
from seamless.core.cache.transformation_cache import transformation_cache
if os.path.exists(result_cache):
with open(result_cache) as f:
for line in f:
tf_checksum, result_checksum = line.split()
tf_checksum = bytes.fromhex(tf_checksum)
result_checksum = bytes.fromhex(result_checksum)
transformation_cache.transformation_results[tf_checksum] = \
result_checksum, False
# /TODO
ctx = Context()
if os.path.exists(buffer_cache):
ctx.add_zip(buffer_cache)
ctx.pandoc = """
ln -s inputfile input.md
pandoc --standalone --to man input.md -o /dev/stdout
"""
for f in docfiles:
setattr(ctx, f, Context())
sctx = getattr(ctx, f)
md = "{}/{}.md".format(docdir, f)
sctx.md = Cell("text").set(open(md).read())
tf = sctx.tf = Transformer()
tf.language = "bash"
tf.scriptname = f
tf.inputfile = sctx.md
tf.code = ctx.pandoc
from seamless.highlevel import Context, Transformer, Cell
from seamless import stdlib
import json
import os
os.chdir(os.path.dirname(os.path.abspath(__file__)))
os.system("rm -rf web")
os.system("mkdir web")
os.system("cp -r components web/components")
graph = json.load(open("../status-visualization.seamless"))
ctx = Context()
ctx.add_zip("../status-visualization.zip")
ctx.set_graph(graph)
ctx.gen_vis_status.code.mount("web/gen_vis_status.py")
ctx.include(stdlib.merge)
ctx.seamless2webform = Cell("code")
ctx.seamless2webform = open("seamless2webform.py").read()
ctx.seamless2webform.mount("web/seamless2webform.py")
ctx.generate_webform = Transformer()
ctx.generate_webform.graph = ctx.graph
ctx.generate_webform.pins.graph.celltype = "plain"
ctx.generate_webform.code = ctx.seamless2webform
ctx.autogen_webform = ctx.generate_webform
ctx.autogen_webform.celltype = "plain"
ctx.autogen_webform.mount("web/webform-AUTOGEN.json", "w")
ctx.autogen_webform0 = Cell("text")
ctx.autogen_webform0 = ctx.autogen_webform
