def test_constructor(self):
m1_param = ModuleParam(val="1.2",
type="Float",
alias="",
)
m1_function = ModuleFunction(name="value",
parameters=[m1_param],
)
m1 = Module(id=0,
name='Float',
functions=[m1_function],
)
m2 = Module()
m2.name = "Float"
m2.id = 0
f = ModuleFunction()
f.name = "value"
m2.functions.append(f)
param = ModuleParam()
param.strValue = "1.2"
param.type = "Float"
param.alias = ""
f.params.append(param)
assert m1 == m2
def test_constructor(self):
m1_param = ModuleParam(
val="1.2",
type="Float",
alias="",
)
m1_function = ModuleFunction(
name="value",
parameters=[m1_param],
)
m1 = Module(
id=0,
name='Float',
functions=[m1_function],
)
m2 = Module()
m2.name = "Float"
m2.id = 0
f = ModuleFunction()
f.name = "value"
m2.functions.append(f)
param = ModuleParam()
param.strValue = "1.2"
param.type = "Float"
param.alias = ""
f.params.append(param)
assert m1 == m2
def convert(_abstraction):
if _abstraction.__class__ == Abstraction:
return
_abstraction.__class__ = Abstraction
if _abstraction.db_location:
Location.convert(_abstraction.db_location)
for _function in _abstraction.db_functions:
ModuleFunction.convert(_function)
for _annotation in _abstraction.db_get_annotations():
Annotation.convert(_annotation)
_abstraction.set_defaults()
def convert(_abstraction):
if _abstraction.__class__ == Abstraction:
return
_abstraction.__class__ = Abstraction
if _abstraction.db_location:
Location.convert(_abstraction.db_location)
for _function in _abstraction.db_functions:
ModuleFunction.convert(_function)
for _annotation in _abstraction.db_get_annotations():
Annotation.convert(_annotation)
_abstraction.set_defaults()
def from_destination_port():
f = ModuleFunction()
f.name = self.name
for descriptor in self._descriptors:
p = ModuleParam()
p.identifier = descriptor.identifier
p.namespace = descriptor.namespace
p.type = descriptor.name
p.name = '<no description>'
f.addParameter(p)
return f
def from_destination_port():
f = ModuleFunction()
f.name = self.name
for descriptor in self._descriptors:
p = ModuleParam()
p.identifier = descriptor.identifier
p.namespace = descriptor.namespace
p.type = descriptor.name
p.name = '<no description>'
f.addParameter(p)
return f
def convert(_module):
if _module.__class__ == Module:
return
_module.__class__ = Module
for _port_spec in _module.db_portSpecs:
PortSpec.convert(_port_spec)
if _module.db_location:
Location.convert(_module.db_location)
for _function in _module.db_functions:
ModuleFunction.convert(_function)
for _annotation in _module.db_get_annotations():
Annotation.convert(_annotation)
_module.set_defaults()
def convert(_abstraction_module):
if _abstraction_module.__class__ == AbstractionModule:
return
_abstraction_module.__class__ = AbstractionModule
if _abstraction_module.db_location:
Location.convert(_abstraction_module.db_location)
for _function in _abstraction_module.db_functions:
ModuleFunction.convert(_function)
for _annotation in _abstraction_module.db_get_annotations():
Annotation.convert(_annotation)
_abstraction_module.portVisible = set()
_abstraction_module._registry = None
_abstraction_module.abstraction = None
def convert(_module):
if _module.__class__ == Module:
return
_module.__class__ = Module
for _port_spec in _module.db_portSpecs:
PortSpec.convert(_port_spec)
if _module.db_location:
Location.convert(_module.db_location)
for _function in _module.db_functions:
ModuleFunction.convert(_function)
for _annotation in _module.db_get_annotations():
Annotation.convert(_annotation)
_module.set_defaults()
def convert(_module):
_module.__class__ = Module
_module.registry = None
for _port_spec in _module.db_portSpecs:
PortSpec.convert(_port_spec)
_module.add_port_to_registry(_port_spec)
if _module.db_location:
Location.convert(_module.db_location)
for _function in _module.db_functions:
ModuleFunction.convert(_function)
for _annotation in _module.db_get_annotations():
Annotation.convert(_annotation)
_module.portVisible = set()
def convert(_group):
if _group.__class__ == Group:
return
_group.__class__ = Group
if _group.db_location:
Location.convert(_group.db_location)
if _group.db_workflow:
from core.vistrail.pipeline import Pipeline
Pipeline.convert(_group.db_workflow)
for _function in _group.db_functions:
ModuleFunction.convert(_function)
for _annotation in _group.db_get_annotations():
Annotation.convert(_annotation)
_group.set_defaults()
def convert(_group):
if _group.__class__ == Group:
return
_group.__class__ = Group
_group._registry = None
_group.portVisible = set()
if _group.db_location:
Location.convert(_group.db_location)
if _group.db_workflow:
from core.vistrail.pipeline import Pipeline
Pipeline.convert(_group.db_workflow)
for _function in _group.db_functions:
ModuleFunction.convert(_function)
for _annotation in _group.db_get_annotations():
Annotation.convert(_annotation)
def create_action(self, id_scope=None):
from core.vistrail.action import Action
from core.vistrail.module import Module
from core.vistrail.module_function import ModuleFunction
from core.vistrail.module_param import ModuleParam
from core.vistrail.operation import AddOp
from db.domain import IdScope
from datetime import datetime
if id_scope is None:
id_scope = IdScope()
param = ModuleParam(id=id_scope.getNewId(ModuleParam.vtType),
type='Integer',
val='1')
function = ModuleFunction(id=id_scope.getNewId(ModuleFunction.vtType),
name='value',
parameters=[param])
m = Module(id=id_scope.getNewId(Module.vtType),
name='Float',
package='edu.utah.sci.vistrails.basic',
functions=[function])
add_op = AddOp(id=id_scope.getNewId('operation'),
what='module',
objectId=m.id,
data=m)
action = Action(id=id_scope.getNewId(Action.vtType),
prevId=0,
date=datetime(2007, 11, 18),
operations=[add_op])
return action
def testIncorrectURL_2(self):
import core.vistrail
from core.db.locator import XMLFileLocator
from core.vistrail.module import Module
from core.vistrail.module_function import ModuleFunction
from core.vistrail.module_param import ModuleParam
import core.interpreter
p = core.vistrail.pipeline.Pipeline()
m_param = ModuleParam(
type='String',
val='http://neitherodesthisohrly',
)
m_function = ModuleFunction(
name='url',
parameters=[m_param],
)
p.add_module(
Module(
name='HTTPFile',
package=identifier,
version=version,
id=0,
functions=[m_function],
))
interpreter = core.interpreter.default.get_default_interpreter()
kwargs = {
'locator': XMLFileLocator('foo'),
'current_version': 1L,
'view': DummyView(),
}
def perform(self, pipeline, step):
""" perform(pipeline: VisPipeline, step: int) -> None
This will takes a pipeline and apply the interpolated values
at step 'step' to the pipeline. Then return the updated
pipeline
"""
m = pipeline.modules[self.module.id]
f = ModuleFunction()
f.name = self.function
f.returnType = 'void'
value = self.values[step]
for v in value:
p = ModuleParam()
convert = {'int':'Integer', 'str':'String',
'float':'Float', 'double':'Float'}
p.type = convert[type(v).__name__]
p.strValue = str(v)
f.params.append(p)
m.functions.append(f)
def test_tuple(self):
from core.vistrail.module_param import ModuleParam
from core.vistrail.module_function import ModuleFunction
from core.utils import DummyView
from core.vistrail.module import Module
import db.domain
id_scope = db.domain.IdScope()
interpreter = core.interpreter.default.get_default_interpreter()
v = DummyView()
p = core.vistrail.pipeline.Pipeline()
params = [
ModuleParam(
id=id_scope.getNewId(ModuleParam.vtType),
pos=0,
type='Float',
val='2.0',
),
ModuleParam(
id=id_scope.getNewId(ModuleParam.vtType),
pos=1,
type='Float',
val='2.0',
)
]
function = ModuleFunction(id=id_scope.getNewId(ModuleFunction.vtType),
name='input')
function.add_parameters(params)
module = Module(id=id_scope.getNewId(Module.vtType),
name='TestTupleExecution',
package='edu.utah.sci.vistrails.console_mode_test',
version='0.9.0')
module.add_function(function)
p.add_module(module)
kwargs = {
'locator': XMLFileLocator('foo'),
'current_version': 1L,
'view': v,
}
def create_ops(self, id_scope=IdScope()):
from core.vistrail.module import Module
from core.vistrail.module_function import ModuleFunction
from core.vistrail.module_param import ModuleParam
from core.vistrail.annotation import Annotation
if id_scope is None:
id_scope = IdScope(
remap={
AddOp.vtType: 'operation',
ChangeOp.vtType: 'operation',
DeleteOp.vtType: 'operation'
})
m = Module(id=id_scope.getNewId(Module.vtType),
name='Float',
package='edu.utah.sci.vistrails.basic')
add_op = AddOp(id=id_scope.getNewId(AddOp.vtType),
what=Module.vtType,
objectId=m.id,
data=m)
function = ModuleFunction(id=id_scope.getNewId(ModuleFunction.vtType),
name='value')
change_op = ChangeOp(id=id_scope.getNewId(ChangeOp.vtType),
what=ModuleFunction.vtType,
oldObjId=2,
newObjId=function.real_id,
parentObjId=m.id,
parentObjType=Module.vtType,
data=function)
param = ModuleParam(id=id_scope.getNewId(ModuleParam.vtType),
type='Float',
val='1.0')
delete_op = DeleteOp(id=id_scope.getNewId(DeleteOp.vtType),
what=ModuleParam.vtType,
objectId=param.real_id,
parentObjId=function.real_id,
parentObjType=ModuleFunction.vtType)
annotation = Annotation(id=id_scope.getNewId(Annotation.vtType),
key='foo',
value='bar')
add_annotation = AddOp(id=id_scope.getNewId(AddOp.vtType),
what=Annotation.vtType,
objectId=m.id,
data=annotation)
return [add_op, change_op, delete_op, add_annotation]
def test_tuple(self):
from core.vistrail.module_param import ModuleParam
from core.vistrail.module_function import ModuleFunction
from core.utils import DummyView
from core.vistrail.module import Module
import db.domain
id_scope = db.domain.IdScope()
interpreter = core.interpreter.default.get_default_interpreter()
v = DummyView()
p = core.vistrail.pipeline.Pipeline()
params = [ModuleParam(id=id_scope.getNewId(ModuleParam.vtType),
pos=0,
type='Float',
val='2.0',
),
ModuleParam(id=id_scope.getNewId(ModuleParam.vtType),
pos=1,
type='Float',
val='2.0',
)]
function = ModuleFunction(id=id_scope.getNewId(ModuleFunction.vtType),
name='input')
function.add_parameters(params)
module = Module(id=id_scope.getNewId(Module.vtType),
name='TestTupleExecution',
package='edu.utah.sci.vistrails.console_mode_test',
version='0.9.0')
module.add_function(function)
p.add_module(module)
kwargs = {'locator': XMLFileLocator('foo'),
'current_version': 1L,
'view': v,
}
def perform(self, pipeline, step):
""" perform(pipeline: VisPipeline, step: int) -> None
This will takes a pipeline and apply the interpolated values
at step 'step' to the pipeline. Then return the updated
pipeline
"""
m = pipeline.modules[self.module.id]
f = ModuleFunction()
f.name = self.function
f.returnType = 'void'
value = self.values[step]
for v in value:
p = ModuleParam()
convert = {
'int': 'Integer',
'str': 'String',
'float': 'Float',
'double': 'Float'
}
p.type = convert[type(v).__name__]
p.strValue = str(v)
f.params.append(p)
m.functions.append(f)
def test_str(self):
m = Module(
id=0,
name='Float',
functions=[
ModuleFunction(
name='value',
parameters=[ModuleParam(
type='Int',
val='1',
)],
)
],
)
str(m)
def updateActionsHandler(self, controller):
oldRegistry = self.module.registry
newPorts = self.newInputOutputPorts()
(deletePorts, addPorts) = self.registryChanges(oldRegistry, newPorts)
for (cid, c) in controller.current_pipeline.connections.items():
if ((c.sourceId==self.module.id and
any([c.source.name==p[1] for p in deletePorts])) or
(c.destinationId==self.module.id and
any([c.destination.name==p[1] for p in deletePorts]))):
controller.delete_connection(cid)
for p in deletePorts:
controller.delete_module_port(self.module.id, p)
for p in addPorts:
controller.add_module_port(self.module.id, p)
if self.codeEditor.document().isModified():
code = urllib.quote(str(self.codeEditor.toPlainText()))
fid = self.findSourceFunction()
# FIXME make sure that this makes sense
if fid==-1:
# do add function
fid = self.module.getNumFunctions()
f = ModuleFunction(pos=fid,
name='source')
param = ModuleParam(type='String',
val=code,
alias='',
name='<no description>',
pos=0)
f.addParameter(param)
controller.add_method(self.module.id, f)
else:
# do change parameter
paramList = [(code, 'String', None,
'edu.utah.sci.vistrails.basic', '')]
controller.replace_method(self.module, fid, paramList)
def create_module(self, id_scope=None):
from db.domain import IdScope
if id_scope is None:
id_scope = IdScope()
params = [
ModuleParam(id=id_scope.getNewId(ModuleParam.vtType),
type='Int',
val='1')
]
functions = [
ModuleFunction(id=id_scope.getNewId(ModuleFunction.vtType),
name='value',
parameters=params)
]
module = Module(id=id_scope.getNewId(Module.vtType),
name='Float',
package='edu.utah.sci.vistrails.basic',
functions=functions)
return module
def create_group(self, id_scope=IdScope()):
from core.vistrail.location import Location
from core.vistrail.module_function import ModuleFunction
from core.vistrail.module_param import ModuleParam
params = [
ModuleParam(id=id_scope.getNewId(ModuleParam.vtType),
type='Int',
val='1')
]
functions = [
ModuleFunction(id=id_scope.getNewId(ModuleFunction.vtType),
name='value',
parameters=params)
]
location = Location(id=id_scope.getNewId(Location.vtType),
x=12.342,
y=-19.432)
module = \
Group(id=id_scope.getNewId(Group.vtType),
location=location,
functions=functions,
)
return module
def from_source_port():
f = ModuleFunction()
f.name = self.name
if len(self._descriptors) > 0:
f.returnType = self._descriptors[0].name
return f
def from_source_port():
f = ModuleFunction()
f.name = self.name
if len(self._descriptors) > 0:
f.returnType = self._descriptors[0].name
return f
