def create_from_file(session, pth, user):
"""Create a RO from a a file.
Notes: if pth is a zipfile, it will be extracted and
a ROContainer will be created with he content
Args:
session (DBSession):
pth (str): path to file to read
user (str): id of user
Returns:
(ResearchObject): or None if nothing has been recognized in
the file
"""
# try to unpack zip files
try:
with ZipFile(pth, "r") as myzip:
myzip.extractall(pj(dirname(pth), "archive"))
remove(pth)
# explore directory
ros = []
for fpth, fname in find_files(pj(dirname(pth), "archive"), ["*.wkf"]):
ro_type = validate(fpth)
if ro_type is not None:
ros.append(create(session, fpth, ro_type))
if len(ros) == 0:
return None
else:
name = splitext(basename(pth))[0]
cont = ROContainer()
cont.init(session, dict(id=uuid1().hex, owner=user, name=name))
for ro in ros:
ROLink.connect(session, cont.id, ro.id, "contains")
# search for project avatar
avatar = fetch_avatar(pj(dirname(pth), "archive"))
if avatar is not None:
upload_ro_avatar(avatar, cont)
# search project description in README
descr = fetch_readme(pj(dirname(pth), "archive"))
cont.store_description(descr)
return cont
except BadZipfile:
# not a zip file, try to import single file
ro_type = validate(pth)
if ro_type is None:
return None
else:
ro = create(session, pth, ro_type)
return ro
def main(session):
ro_top = ROContainer()
ro_top.init(session, dict(owner=users[0].id,
name="sample"))
ro_top.public = True
containers.append(ro_top)
ro1 = ResearchObject()
ro1.init(session, dict(owner=users[0].id, name="RO one"))
ro1.add_policy(session, users[0], Role.view)
ro1.add_policy(session, teams[2], Role.edit)
ro2 = ResearchObject()
ro2.init(session, dict(owner=users[0].id, name="RO two"))
ROLink.connect(session, ro1.id, ro2.id, "contains")
ro3 = ResearchObject()
ro3.init(session, dict(owner=users[0].id, name="RO three"))
ros = []
for i in range(5):
ro = ResearchObject()
ro.init(session, dict(owner=users[0].id, name="RO%d" % i))
ros.append(ro)
roc = ROContainer()
roc.init(session, dict(owner=users[0].id,
name="myproject",
remote="https://github.com/revesansparole/roc",
contents=ros))
ROLink.connect(session, ro_top.id, roc.id, 'contains')
ros = []
for i in range(5):
ro = ResearchObject()
ro.init(session, dict(owner=users[1].id, name="ROcp%d" % i))
ros.append(ro)
ro = ROArticle()
ro.init(session, dict(owner=users[2].id, name="cp article"))
ro.add_policy(session, users[0], Role.view)
ros.append(ro)
roc2 = ROContainer()
roc2.init(session, dict(owner=users[2].id,
name="CPproject",
contents=ros))
ROLink.connect(session, ro_top.id, roc2.id, 'contains')
roa = ROArticle()
roa.init(session, dict(owner=users[0].id, name="test article"))
roa.doi = "10.1016/S0304-3800(98)00100-8"
descr = dedent("""
We present a new approach to simulate the distribution of natural
light within plant canopies. The canopy is described in 3D, each
organ being represented by a set of polygons. Our model calculates
the light incident on each polygon. The principle is to distinguish
for each polygon the contribution of the light coming directly from
light sources, the light scattered from close polygons and that
scattered from far polygons. Close polygons are defined as located
inside a sphere surrounding the studied polygon and having a
diameter Ds. The direct light is computed by projection. The
exchanges between close polygons are computed by the radiosity
method, whereas the contribution from far polygons is estimated by
a multi-layer model. The main part of computing time corresponds to
the calculations of the geometric coefficients of the radiosity
system. Then radiative exchanges can be quickly simulated for
various conditions of the angular distribution of incoming light
and various optical properties of soil and phytolelements.
Simulations compare satisfactorily with those produced by a Monte
Carlo ray tracing. They show that considering explicitly the close
neighboring of each polygon improves the estimation of organs
irradiance, by taking into account the local variability of fluxes.
For a virtual maize canopy, these estimations are satisfying with
Ds=0.5 m; in these conditions, the simulation time on a workstation
was 25 min for a canopy of 100 plants.""")
roa.store_description(descr)
ROLink.connect(session, roc.id, roa.id, "contains")
ROLink.connect(session, ro3.id, roa.id, "use")
def main(session, user, container):
"""Create ROs to test auth policies.
Args:
session (DBSession):
user (User): default user
container (ROContainer): top level container
Returns:
None
"""
# create another user
other = User.create(session,
uid='other',
name="Other User",
email="*****@*****.**")
img = Image.open("seeweb/scripts/avatar/sartzet.png")
upload_user_avatar(img, other)
# user can view RO in container owner by other
roa = ROArticle()
roa.init(session, dict(owner=other.id, name="other article"))
roa.store_description("Title\n=====\n\nLorem Ipsum\nlorem ipsum")
roa.add_policy(session, user, Role.view)
road = ROArticle()
road.init(session, dict(owner=other.id, name="other editable article"))
road.store_description("Title\n=====\n\nLorem Ipsum\nlorem ipsum")
road.add_policy(session, user, Role.edit)
roc = ROContainer()
roc.init(session, dict(owner=other.id,
name="other project",
contents=[roa, road]))
ROLink.connect(session, container.id, roc.id, 'contains')
# access granted to ROs through their container policy
roa = ROArticle()
roa.init(session, dict(owner=other.id, name="other 'private' article"))
roa.store_description("Title\n=====\n\nLorem Ipsum\nlorem ipsum")
roc = ROContainer()
roc.init(session, dict(owner=other.id,
name="other 'denied' project",
contents=[roa]))
roc.add_policy(session, user, Role.denied)
ROLink.connect(session, container.id, roc.id, 'contains')
roc = ROContainer()
roc.init(session, dict(owner=other.id,
name="other project",
contents=[roa]))
roc.add_policy(session, user, Role.edit)
ROLink.connect(session, container.id, roc.id, 'contains')
# public container
roa = ROArticle()
roa.init(session, dict(owner=other.id, name="other article"))
roa.store_description("Title\n=====\n\nLorem Ipsum\nlorem ipsum")
road = ROArticle()
road.init(session, dict(owner=other.id, name="other denied article"))
road.store_description("Title\n=====\n\nLorem Ipsum\nlorem ipsum")
road.add_policy(session, user, Role.denied)
roc = ROContainer()
roc.init(session, dict(owner=other.id,
name="other 'public' project",
contents=[roa, road]))
roc.public = True
ROLink.connect(session, container.id, roc.id, 'contains')
def main(session, user, container):
"""Create workflow related projects.
Args:
session (DBSession):
user (User): owner of created project
container (ROContainer): top level container
Returns:
None
"""
# default interfaces for openalea
roa = ROContainer()
roa.init(session, dict(owner=user.id, name="openalea.interfaces"))
top = ROContainer()
top.init(session, dict(owner=user.id, name="openalea", contents=[roa]))
itrans = {}
for iname in ("IBool", "ICodeStr", "IColor", "IData", "IDateTime",
"IDict", "IDirStr",
"IEnumStr", "IFileStr", "IFloat",
"IFunction", "IImage", "IInt", "IRef", "IRGBColor",
"ISequence", "ISlice", "IStr", "ITextStr",
"ITuple", "ITuple3"):
standard_interface = get_interface_by_name(session, iname[1:].lower())
if standard_interface is not None:
ancestors = [standard_interface.id]
else:
ancestors = []
roi = ROInterface()
roi.init(session, dict(owner=user.id, name=iname, ancestors=ancestors))
ROLink.connect(session, roa.id, roi.id, "contains")
itrans[iname] = roi.id
roc = ROContainer()
roc.init(session, dict(owner=user.id, name="nodelib"))
ROLink.connect(session, container.id, roc.id, 'contains')
ndefs = []
for i in range(3):
node_def = dict(name="read%d" % i,
description="toto was here",
owner=user.id,
function="testio:read",
inputs=[dict(name="in1", interface=itrans["IInt"],
default="0", description="counter"),
dict(name="in2", interface=itrans["IStr"],
default="a", description="unit")],
outputs=[dict(name="ret", interface=itrans["IInt"],
description="important result")])
rown = ROWorkflowNode()
rown.init(session, node_def)
ndefs.append(rown)
ROLink.connect(session, roc.id, rown.id, "contains")
# alias = ContentItem.create(session, uuid1().hex, "alias", nodelib)
# alias.author = "revesansparole"
# alias.name = ndefs[2]['id']
workflow_def = dict(name="sample_workflow",
description="trying some stuff",
owner="revesansparole",
nodes=[dict(id=ndefs[0].id, label="node1",
x=-50, y=-80),
dict(id=ndefs[1].id, label=None,
x=50, y=-80),
dict(id=ndefs[2].id, label=None,
x=0, y=0),
dict(id='4094cf5a490711e6aa4cd4bed973e64a',
label="fail",
x=0, y=80)],
links=[dict(source=0, source_port="ret",
target=2, target_port="in1"),
dict(source=1, source_port="ret",
target=2, target_port="in2"),
dict(source=2, source_port="ret",
target=3, target_port="in")])
row = ROWorkflow()
row.init(session, workflow_def)
ROLink.connect(session, roc.id, row.id, "contains")
roc = ROContainer()
roc.init(session, dict(owner=user.id, name="provenance"))
ROLink.connect(session, container.id, roc.id, 'contains')
with open("seeweb/scripts/gallery/graph_pulse.png", 'rb') as f:
graph_pulse = b64encode(f.read())
with open("seeweb/scripts/sphere.json", 'r') as f:
sphere = json.load(f)
data = [dict(id=uuid1().hex, type="ref", value=itrans["IInt"]),
dict(id=uuid1().hex, type="int", value=10),
dict(id=uuid1().hex, type="str", value="Killroy was here"),
dict(id=uuid1().hex, type="image", value=graph_pulse),
dict(id=uuid1().hex, type="scene3d", value=sphere)
]
prov_def = dict(name="sample_provenance",
description="trying some stuff",
owner=user.id,
workflow=row.id,
time_init=10,
time_end=14,
data=data,
parameters=[dict(node=0, port="in1", data=data[0]['id']),
dict(node=0, port="in2", data=data[2]['id'])
],
executions=[
dict(node=0, time_init=10, time_end=11,
inputs=[
{"port": "in1", "data": data[0]['id']},
{"port": "in2", "data": data[2]['id']}
],
outputs=[
{"port": "ret", "data": data[1]['id']}
]),
dict(node=1, time_init=10, time_end=11,
inputs=[
{"port": "in1", "data": data[0]['id']}
],
outputs=[
{"port": "ret", "data": data[3]['id']}
]),
dict(node=2, time_init=12, time_end=13,
inputs=[
{"port": "in1", "data": data[1]['id']},
{"port": "in2", "data": data[3]['id']}
],
outputs=[
{"port": "ret", "data": data[4]['id']}
])
]
)
with open("../prov.wkf", 'w') as f:
json.dump(prov_def, f)
rop = ROWorkflowProv()
rop.init(session, prov_def)
ROLink.connect(session, roc.id, rop.id, "contains")
def main(session, user, container):
"""Create a project that contains different types of data
Args:
session (DBSession):
user (User): owner of created project
container (ROContainer): top level container
Returns:
None
"""
# register common data interfaces
roc = ROContainer()
roc.init(
session,
dict(
id="81c69a8558a311e6afb6d4bed973e64a",
owner=user.id,
name="interfaces",
public=True,
description="Store commonly used interfaces",
),
)
roi = ROInterface()
roi.init(
session,
dict(
id=ROData.implements,
owner=user.id,
name="any",
public=True,
description="Interface used for data that don't " "have a specific interface",
),
)
ROLink.connect(session, roc.id, roi.id, "contains")
ropy = ROInterface()
ropy.init(session, dict(id="dc5b10c858a611e6afb6d4bed973e64a", owner=user.id, name="pyobj", public=True))
ROLink.connect(session, roc.id, ropy.id, "contains")
schema = dict(
title="Interface for data of type 'string'", description="Just a simple chain of characters", type="string"
)
roi = ROInterface()
roi.init(
session,
dict(
id="006bca4c58a311e6afb6d4bed973e64a",
owner=user.id,
name="string",
public=True,
schema=cvt_schema(schema),
ancestors=[ropy.id],
),
)
ROLink.connect(session, roc.id, roi.id, "contains")
sid = roi.id
for name in ("code", "path", "ref", "text"):
roi = ROInterface()
roi.init(session, dict(owner=user.id, name=name, public=True, ancestors=[sid]))
ROLink.connect(session, roc.id, roi.id, "contains")
schema = dict(title="Interface for data of type 'number'", description="Just a simple number", type="number")
roi = ROInterface()
roi.init(
session,
dict(
id="c7f6a30a58a511e6afb6d4bed973e64a",
owner=user.id,
name="number",
public=True,
schema=cvt_schema(schema),
ancestors=[ropy.id],
),
)
ROLink.connect(session, roc.id, roi.id, "contains")
sid = roi.id
for name in ("complex", "int", "float"):
roi = ROInterface()
roi.init(session, dict(owner=user.id, name=name, public=True, ancestors=[sid]))
ROLink.connect(session, roc.id, roi.id, "contains")
rgba_schema = dict(
title="Interface for color of type rgba",
description="Just a simple array of rgba quadruplets",
type="array",
minLength=4,
maxLength=4,
items=dict(type="int"),
)
roi = ROInterface()
roi.init(
session,
dict(
id="256203e058b911e6afb6d4bed973e64a",
owner=user.id,
name="rgba",
public=True,
schema=cvt_schema(rgba_schema),
ancestors=[],
),
)
ROLink.connect(session, roc.id, roi.id, "contains")
schema = dict(
title="Interface for data of type 2D images",
description="Just a simple 2d array of rgba quadruplets",
type="array",
minLength=1,
items=dict(type="array", minLength=1, items=rgba_schema),
)
roi = ROInterface()
roi.init(
session,
dict(id=ROImage.implements, owner=user.id, name="image", public=True, schema=cvt_schema(schema), ancestors=[]),
)
ROLink.connect(session, roc.id, roi.id, "contains")
schema = dict(
title="Interface for data of type 3D scenes",
description="Json description of a 3D scene",
type="array",
minLength=1,
items=dict(type="array", minLength=1, items=rgba_schema),
)
roi = ROInterface()
roi.init(
session,
dict(
id=ROScene3d.implements, owner=user.id, name="scene3d", public=True, schema=cvt_schema(schema), ancestors=[]
),
)
ROLink.connect(session, roc.id, roi.id, "contains")
# create a sample project with some common data examples
roc = ROContainer()
roc.init(session, dict(id="0a73ad11596111e6a3a6d4bed973e64a", owner=user.id, name="data", ctype="project"))
ROLink.connect(session, container.id, roc.id, "contains")
# raw data
rod = ROData()
rod.init(session, dict(owner=user.id, name="test number", value=3.14159))
ROLink.connect(session, roc.id, rod.id, "contains")
with open("seeweb/ro/data/static/default_avatar.png", "rb") as f:
value = b64encode(f.read())
rod = ROData()
rod.init(session, dict(owner=user.id, name="test data", value=value))
ROLink.connect(session, roc.id, rod.id, "contains")
# image
with open("seeweb/ro/data/static/default_avatar.png", "rb") as f:
value = b64encode(f.read())
roi = ROImage()
roi.init(
session,
dict(
id="03faa88158bb11e6afb6d4bed973e64a",
owner=user.id,
name="test image",
value=value,
description="Sample image for testing purpose",
),
)
ROLink.connect(session, roc.id, roi.id, "contains")
# scene3D
with open("seeweb/scripts/scene.json", "r") as f:
sc = json.load(f)
rosc = ROScene3d()
rosc.init(session, dict(owner=user.id, name="test scene", value=sc))
ROLink.connect(session, roc.id, rosc.id, "contains")
