def constructor(ctx, libctx, context_graph, inp, result, elision,
elision_chunksize):
m = ctx.m = Macro()
m.elision = elision
m.graph = context_graph
m.pins.graph.celltype = "plain"
m.pins.result = {
"io": "output",
"celltype": "mixed",
"hash_pattern": {
"!": "#"
}
}
ctx.inp = Context()
ctx.cs_inp = Context()
inp_prefix = "INPUT_"
m.inp_prefix = inp_prefix
m.pins.inp_prefix.celltype = "str"
m.elision_chunksize = elision_chunksize
m.pins.elision_chunksize.celltype = "int"
for key in inp:
c = Cell()
ctx.inp[key] = c
c.hash_pattern = {"!": "#"}
inp[key].connect(c)
ctx.cs_inp[key] = Cell("checksum")
ctx.cs_inp[key] = ctx.inp[key]
setattr(m, inp_prefix + key, ctx.cs_inp[key])
macro_code_lib_code = libctx.map_list_N.value + "\n\n" + libctx.map_list_N_nested.value
macro_code_lib = {
"type": "interpreted",
"language": "python",
"code": macro_code_lib_code
}
ctx.macro_code_lib = Cell("plain").set(macro_code_lib)
ctx.macro_code_lib_code = Cell("code").set(macro_code_lib_code)
m.macro_code_lib = ctx.macro_code_lib
m.pins.macro_code_lib.celltype = "plain"
m.pins.macro_code_lib.subcelltype = "module"
m.macro_code_lib_code = ctx.macro_code_lib_code
m.pins.macro_code_lib_code.celltype = "plain"
m.map_list_N_nested_code = libctx.map_list_N_nested.value
###m.pins.map_list_N_nested_code.celltype = "python"
m.code = libctx.main.value
ctx.result = Cell()
ctx.result.hash_pattern = {"!": "#"}
ctx.result = m.result
result.connect_from(ctx.result)
def constructor(ctx, libctx, 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)