示例#1
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    old_module = pipeline.modules[module_id]
    if old_module.name == "JSONFile" and old_module.version != "0.1.5" and old_module.namespace == "read":
        from vistrails.core.db.action import create_action
        from vistrails.core.modules.module_registry import get_module_registry
        from .read.read_json import JSONObject

        reg = get_module_registry()
        new_desc = reg.get_descriptor(JSONObject)
        new_module = controller.create_module_from_descriptor(new_desc, old_module.location.x, old_module.location.y)
        actions = UpgradeWorkflowHandler.replace_generic(controller, pipeline, old_module, new_module)

        new_function = controller.create_function(new_module, "key_name", ["_key"])
        actions.append(create_action([("add", new_function, "module", new_module.id)]))
        return actions

    module_remap = {
        "read|csv|CSVFile": [(None, "0.1.1", "read|CSVFile", {"src_port_remap": {"self": "value"}})],
        "read|numpy|NumPyArray": [(None, "0.1.1", "read|NumPyArray", {"src_port_remap": {"self": "value"}})],
        "read|CSVFile": [("0.1.1", "0.1.2", None, {"src_port_remap": {"self": "value"}}), ("0.1.3", "0.1.5", None, {})],
        "read|NumPyArray": [("0.1.1", "0.1.2", None, {"src_port_remap": {"self": "value"}})],
        "read|ExcelSpreadsheet": [
            ("0.1.1", "0.1.2", None, {"src_port_remap": {"self": "value"}}),
            ("0.1.3", "0.1.4", None, {}),
        ],
        "read|JSONFile": [(None, "0.1.5", "read|JSONObject")],
    }

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline, module_remap)
示例#2
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    old_module = pipeline.modules[module_id]
    # first check package
    # v1.0 types:
    if old_module.package == 'edu.utah.sci.vistrails.sudswebservices':
        wsdl = old_module.namespace.split('|')[0]
        namespace = old_module.namespace.split('|')[1]
    else:
        wsdl = toAddress(old_module.package)
        namespace = old_module.namespace
    name = old_module.name

    wsdlList = []
    if configuration.check('wsdlList'):
        wsdlList = configuration.wsdlList.split(";")
    if not wsdl in wsdlList:
        service = Service(wsdl)
        if not service.service:
            return []
        webServicesDict[wsdl] = service
        wsdlList.append(wsdl)
        configuration.wsdlList = ';'.join(wsdlList)

    if old_module.package == 'edu.utah.sci.vistrails.sudswebservices':
        reg = vistrails.core.modules.module_registry.get_module_registry()
        new_descriptor = reg.get_descriptor_by_name(toSignature(wsdl), name,
                                                    namespace)
        if not new_descriptor:
            return []
        return UpgradeWorkflowHandler.replace_module(controller, pipeline,
                                                     module_id, new_descriptor)

    return UpgradeWorkflowHandler.attempt_automatic_upgrade(
        controller, pipeline, module_id)
示例#3
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    old_module = pipeline.modules[module_id]
    # first check package
    # v1.0 types:
    if old_module.package == 'edu.utah.sci.vistrails.sudswebservices':
        wsdl = old_module.namespace.split('|')[0]
        namespace = old_module.namespace.split('|')[1]
    else:
        wsdl = toAddress(old_module.package)
        namespace = old_module.namespace
    name = old_module.name

    wsdlList = []
    if configuration.check('wsdlList'):
        wsdlList = configuration.wsdlList.split(";")
    if not wsdl in wsdlList:
        service = Service(wsdl)
        if not service.service:
            return []
        webServicesDict[wsdl] = service
        wsdlList.append(wsdl)
        configuration.wsdlList = ';'.join(wsdlList)

    if old_module.package == 'edu.utah.sci.vistrails.sudswebservices':
        reg = vistrails.core.modules.module_registry.get_module_registry()
        new_descriptor = reg.get_descriptor_by_name(toSignature(wsdl), name,
                                                    namespace)
        if not new_descriptor:
            return []
        return UpgradeWorkflowHandler.replace_module(controller, pipeline,
                                                module_id, new_descriptor)

    return UpgradeWorkflowHandler.attempt_automatic_upgrade(controller, 
                                                            pipeline,
                                                            module_id)
示例#4
0
文件: init.py 项目: licode/VisTrails
 def product_change_connection(old_conn, new_module):
     src_module = pipeline.modules[old_conn.source.moduleId]
     new_x = (src_module.location.x + new_module.location.x) / 2.0
     new_y = (src_module.location.y + new_module.location.y) / 2.0
     Not_desc = reg.get_descriptor(Not)
     not_mod = controller.create_module_from_descriptor(
         Not_desc, new_x, new_y)
     conn1 = UpgradeWorkflowHandler.create_new_connection(
         controller, src_module, old_conn.source, not_mod, 'input')
     conn2 = UpgradeWorkflowHandler.create_new_connection(
         controller, not_mod, 'value', new_module, 'NumericalProduct')
     return [('add', not_mod), ('add', conn1), ('add', conn2)]
示例#5
0
 def product_change_connection(old_conn, new_module):
     src_module = pipeline.modules[old_conn.source.moduleId]
     new_x = (src_module.location.x + new_module.location.x) / 2.0
     new_y = (src_module.location.y + new_module.location.y) / 2.0
     Not_desc = reg.get_descriptor(Not)
     not_mod = controller.create_module_from_descriptor(Not_desc,
                                                        new_x, new_y)
     conn1 = UpgradeWorkflowHandler.create_new_connection(
             controller,
             src_module, old_conn.source,
             not_mod, 'input')
     conn2 = UpgradeWorkflowHandler.create_new_connection(
             controller,
             not_mod, 'value',
             new_module, 'NumericalProduct')
     return [('add', not_mod), ('add', conn1), ('add', conn2)]
示例#6
0
文件: init.py 项目: hjanime/VisTrails
def handle_module_upgrade_request(controller, module_id, pipeline):
    module_remap = {
            'CellLocation': [
                (None, '0.9.3', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
            ],
            'SheetReference': [
                (None, '0.9.3', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
            ],
            'SingleCellSheetReference': [
                (None, '0.9.3', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
            ],
        }

    module_remap = upgrade_cell_to_output(
            module_remap, module_id, pipeline,
            'RichTextCell', 'org.vistrails.vistrails.basic:RichTextOutput',
            '0.9.4', 'File')
    module_remap = upgrade_cell_to_output(
            module_remap, module_id, pipeline,
            'ImageViewerCell', 'org.vistrails.vistrails.basic:ImageOutput',
            '0.9.4', 'File')

    return UpgradeWorkflowHandler.remap_module(controller,
                                               module_id,
                                               pipeline,
                                               module_remap)
示例#7
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    def add_keyname(fname, module):
        new_function = controller.create_function(module, "key_name", ["_key"])
        return [("add", new_function, "module", module.id)]

    module_remap = {
        "read|csv|CSVFile": [(None, "0.1.1", "read|CSVFile", {"src_port_remap": {"self": "value"}})],
        "read|numpy|NumPyArray": [(None, "0.1.1", "read|NumPyArray", {"src_port_remap": {"self": "value"}})],
        "read|CSVFile": [("0.1.1", "0.1.2", None, {"src_port_remap": {"self": "value"}}), ("0.1.3", "0.1.5", None, {})],
        "read|NumPyArray": [("0.1.1", "0.1.2", None, {"src_port_remap": {"self": "value"}})],
        "read|ExcelSpreadsheet": [
            ("0.1.1", "0.1.2", None, {"src_port_remap": {"self": "value"}}),
            ("0.1.3", "0.1.4", None, {}),
        ],
        "read|JSONFile": [(None, "0.1.5", "read|JSONObject", {"function_remap": {None: add_keyname}})],
    }

    try:
        from vistrails.packages.spreadsheet.init import upgrade_cell_to_output
    except ImportError:
        pass
    else:
        module_remap = upgrade_cell_to_output(
            module_remap, module_id, pipeline, "TableCell", "TableOutput", "0.1.6", "table"
        )

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline, module_remap)
示例#8
0
文件: init.py 项目: Nikea/VisTrails
def handle_module_upgrade_request(controller, module_id, pipeline):
    module_remap = {
            'CellLocation': [
                (None, '0.9.3', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
            ],
            'SheetReference': [
                (None, '0.9.3', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
            ],
            'SingleCellSheetReference': [
                (None, '0.9.3', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
            ],
        }

    return UpgradeWorkflowHandler.remap_module(controller,
                                               module_id,
                                               pipeline,
                                               module_remap)
示例#9
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    module_remap = {
            'CellLocation': [
                (None, '0.9.3', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
            ],
            'SheetReference': [
                (None, '0.9.3', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
            ],
            'SingleCellSheetReference': [
                (None, '0.9.3', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
            ],
        }

    module_remap = upgrade_cell_to_output(
            module_remap, module_id, pipeline,
            'RichTextCell', 'org.vistrails.vistrails.basic:RichTextOutput',
            '0.9.4', 'File')
    module_remap = upgrade_cell_to_output(
            module_remap, module_id, pipeline,
            'ImageViewerCell', 'org.vistrails.vistrails.basic:ImageOutput',
            '0.9.4', 'File')

    return UpgradeWorkflowHandler.remap_module(controller,
                                               module_id,
                                               pipeline,
                                               module_remap)
示例#10
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    module_remap = {
        'CellLocation': [
            (None, '0.9.3', None, {
                'src_port_remap': {
                    'self': 'value'
                },
            }),
        ],
        'SheetReference': [
            (None, '0.9.3', None, {
                'src_port_remap': {
                    'self': 'value'
                },
            }),
        ],
        'SingleCellSheetReference': [
            (None, '0.9.3', None, {
                'src_port_remap': {
                    'self': 'value'
                },
            }),
        ],
    }

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
                                               module_remap)
示例#11
0
文件: init.py 项目: sguzwf/VisTrails
def handle_module_upgrade_request(controller, module_id, pipeline):
    module_remap = {
        # HTTPFile was renamed DownloadFile
        'HTTPFile': [(None, '1.0.0', 'DownloadFile', {})],
    }

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
                                               module_remap)
示例#12
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    # Before 0.0.3, SQLSource's resultSet output was type ListOfElements (which
    #   doesn't exist anymore)
    # In 0.0.3, SQLSource's resultSet output was type List
    # In 0.1.0, SQLSource's output was renamed to result and is now a Table;
    #   this is totally incompatible and no upgrade code is possible
    #   the resultSet is kept for now for compatibility

    # Up to 0.0.4, DBConnection would ask for a password if one was necessary;
    #   this behavior has not been kept. There is now a password input port, to
    #   which you can connect a PasswordDialog from package dialogs if needed

    old_module = pipeline.modules[module_id]
    # DBConnection module from before 0.1.0: automatically add the password
    # prompt module
    if (old_module.name == 'DBConnection'
            and versions_increasing(old_module.version, '0.1.0')):
        reg = get_module_registry()
        # Creates the new module
        new_module = controller.create_module_from_descriptor(
            reg.get_descriptor(DBConnection))
        # Create the password module
        mod_desc = reg.get_descriptor_by_name(
            'org.vistrails.vistrails.dialogs', 'PasswordDialog')
        mod = controller.create_module_from_descriptor(mod_desc)
        # Adds a 'label' function to the password module
        ops = [('add', mod)]
        ops.extend(
            controller.update_function_ops(mod, 'label', ['Server password']))
        # Connects the password module to the new module
        conn = controller.create_connection(mod, 'result', new_module,
                                            'password')
        ops.append(('add', conn))
        # Replaces the old module with the new one
        upgrade_actions = UpgradeWorkflowHandler.replace_generic(
            controller,
            pipeline,
            old_module,
            new_module,
            src_port_remap={'self': 'connection'})
        password_fix_action = create_action(ops)
        return upgrade_actions + [password_fix_action]

    return UpgradeWorkflowHandler.attempt_automatic_upgrade(
        controller, pipeline, module_id)
示例#13
0
文件: init.py 项目: Nikea/VisTrails
def handle_module_upgrade_request(controller, module_id, pipeline):
    # Before 0.0.3, SQLSource's resultSet output was type ListOfElements (which
    #   doesn't exist anymore)
    # In 0.0.3, SQLSource's resultSet output was type List
    # In 0.1.0, SQLSource's output was renamed to result and is now a Table;
    #   this is totally incompatible and no upgrade code is possible
    #   the resultSet is kept for now for compatibility

    # Up to 0.0.4, DBConnection would ask for a password if one was necessary;
    #   this behavior has not been kept. There is now a password input port, to
    #   which you can connect a PasswordDialog from package dialogs if needed

    old_module = pipeline.modules[module_id]
    # DBConnection module from before 0.1.0: automatically add the password
    # prompt module
    if (old_module.name == 'DBConnection' and
            versions_increasing(old_module.version, '0.1.0')):
        reg = get_module_registry()
        # Creates the new module
        new_module = controller.create_module_from_descriptor(
                reg.get_descriptor(DBConnection))
        # Create the password module
        mod_desc = reg.get_descriptor_by_name(
                'org.vistrails.vistrails.dialogs', 'PasswordDialog')
        mod = controller.create_module_from_descriptor(mod_desc)
        # Adds a 'label' function to the password module
        ops = [('add', mod)]
        ops.extend(controller.update_function_ops(mod,
                                                  'label', ['Server password']))
        # Connects the password module to the new module
        conn = controller.create_connection(mod, 'result',
                                            new_module, 'password')
        ops.append(('add', conn))
        # Replaces the old module with the new one
        upgrade_actions = UpgradeWorkflowHandler.replace_generic(
                controller, pipeline,
                old_module, new_module,
                src_port_remap={'self': 'connection'})
        password_fix_action = create_action(ops)
        return upgrade_actions + [password_fix_action]

    return UpgradeWorkflowHandler.attempt_automatic_upgrade(
            controller, pipeline,
            module_id)
示例#14
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    module_remap = {
            # HTTPFile was renamed DownloadFile
            'HTTPFile': [
                (None, '1.0.0', 'DownloadFile', {})
            ],
        }

    return UpgradeWorkflowHandler.remap_module(controller,
                                               module_id,
                                               pipeline,
                                               module_remap)
示例#15
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    global _remap, _controller, _pipeline

    if _remap is None:
        _remap = UpgradePackageRemap()
        remap = UpgradeModuleRemap(None, '1.0.0', '1.0.0',
                                   module_name='vtkInteractionHandler')
        remap.add_remap('src_port_remap', 'self', 'Instance')
        _remap.add_module_remap(remap)
        remap = UpgradeModuleRemap(None, '1.0.0', '1.0.0',
                                   module_name='VTKCell')
        remap.add_remap('src_port_remap', 'self', 'Instance')
        _remap.add_module_remap(remap)
        remap = UpgradeModuleRemap(None, '1.0.0', '1.0.0',
                                   module_name='VTKViewCell',
                                   new_module='VTKCell')
        _remap.add_module_remap(remap)

    _controller = controller
    _pipeline = pipeline
    module_name = pipeline.modules[module_id].name
    module_name = module_name_remap.get(module_name, module_name)
    if not _remap.has_module_remaps(module_name):
        build_remap(module_name)

    try:
        from vistrails.packages.spreadsheet.init import upgrade_cell_to_output
    except ImportError:
        # Manually upgrade to 1.0.1
        if _remap.get_module_remaps(module_name):
            module_remap = copy.copy(_remap)
            module_remap.add_module_remap(
                    UpgradeModuleRemap('1.0.0', '1.0.1', '1.0.1',
                                       module_name=module_name))
        else:
            module_remap = _remap
    else:
        module_remap = upgrade_cell_to_output(
                _remap, module_id, pipeline,
                'VTKCell', 'vtkRendererOutput',
                '1.0.1', 'AddRenderer',
                start_version='1.0.0')
        if _remap.get_module_remaps(module_name):
            remap = module_remap.get_module_upgrade(module_name, '1.0.0')
            if remap is None:
                # Manually upgrade to 1.0.1
                module_remap.add_module_remap(
                        UpgradeModuleRemap('1.0.0', '1.0.1', '1.0.1',
                                           module_name=module_name))

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
                                               module_remap)
示例#16
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    def add_keyname(fname, module):
        new_function = controller.create_function(module, 
                                                  "key_name",
                                                  ["_key"])
        return [('add', new_function, 'module', module.id)]

    module_remap = {
            'read|csv|CSVFile': [
                (None, '0.1.1', 'read|CSVFile', {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
            'read|numpy|NumPyArray': [
                (None, '0.1.1', 'read|NumPyArray', {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
            'read|CSVFile': [
                ('0.1.1', '0.1.2', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
                ('0.1.3', '0.1.5', None, {})
            ],
            'read|NumPyArray': [
                ('0.1.1', '0.1.2', None, {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
            'read|ExcelSpreadsheet': [
                ('0.1.1', '0.1.2', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
                ('0.1.3', '0.1.4', None, {})
            ],
            'read|JSONFile': [
                (None, '0.1.5', 'read|JSONObject', {
                    'function_remap': {
                        None: add_keyname},
                })
            ],
        }

    return UpgradeWorkflowHandler.remap_module(controller,
                                               module_id,
                                               pipeline,
                                               module_remap)
示例#17
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    def add_keyname(fname, module):
        new_function = controller.create_function(module, 
                                                  "key_name",
                                                  ["_key"])
        return [('add', new_function, 'module', module.id)]

    module_remap = {
            'read|csv|CSVFile': [
                (None, '0.1.1', 'read|CSVFile', {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
            'read|numpy|NumPyArray': [
                (None, '0.1.1', 'read|NumPyArray', {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
            'read|CSVFile': [
                ('0.1.1', '0.1.2', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
                ('0.1.3', '0.1.5', None, {})
            ],
            'read|NumPyArray': [
                ('0.1.1', '0.1.2', None, {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
            'read|ExcelSpreadsheet': [
                ('0.1.1', '0.1.2', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
                ('0.1.3', '0.1.4', None, {})
            ],
            'read|JSONFile': [
                (None, '0.1.5', 'read|JSONObject', {
                    'function_remap': {
                        None: add_keyname},
                })
            ],
        }

    return UpgradeWorkflowHandler.remap_module(controller,
                                               module_id,
                                               pipeline,
                                               module_remap)
示例#18
0
文件: init.py 项目: cjh1/VisTrails
def handle_module_upgrade_request(controller, module_id, pipeline):
    module_remap = {
            'read|csv|CSVFile': [
                (None, '0.1.1', 'read|CSVFile', {})
            ],
            'read|numpy|NumPyArray': [
                (None, '0.1.1', 'read|NumPyArray', {})
            ],
        }

    return UpgradeWorkflowHandler.remap_module(controller,
                                               module_id,
                                               pipeline,
                                               module_remap)
示例#19
0
文件: init.py 项目: hjanime/VisTrails
def handle_module_upgrade_request(controller, module_id, pipeline):
    # prepend 'hadoop|' to hadoop modules < 0.3.1
    reg = get_module_registry()

    hadoop_remaps = ['PythonSourceToFile', 'HDFSPut', 'HDFSGet',
                     'HDFSEnsureNew', 'URICreator', 'HadoopStreaming']

    module_remap = {}
    for name in hadoop_remaps:
        module_remap[name] = [(None, '0.3.0', "hadoop|%s" % name, {})]
    return UpgradeWorkflowHandler.remap_module(controller,
                                               module_id,
                                               pipeline,
                                               module_remap)
示例#20
0
文件: init.py 项目: hjanime/VisTrails
def handle_module_upgrade_request(controller, module_id, pipeline):
    # prepend 'hadoop|' to hadoop modules < 0.3.1
    reg = get_module_registry()

    hadoop_remaps = [
        'PythonSourceToFile', 'HDFSPut', 'HDFSGet', 'HDFSEnsureNew',
        'URICreator', 'HadoopStreaming'
    ]

    module_remap = {}
    for name in hadoop_remaps:
        module_remap[name] = [(None, '0.3.0', "hadoop|%s" % name, {})]
    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
                                               module_remap)
示例#21
0
文件: init.py 项目: hjanime/VisTrails
def handle_module_upgrade_request(controller, module_id, pipeline):
    def add_keyname(fname, module):
        new_function = controller.create_function(module, "key_name", ["_key"])
        return [('add', new_function, 'module', module.id)]

    module_remap = {
        'read|csv|CSVFile': [(None, '0.1.1', 'read|CSVFile', {
            'src_port_remap': {
                'self': 'value'
            },
        })],
        'read|numpy|NumPyArray': [(None, '0.1.1', 'read|NumPyArray', {
            'src_port_remap': {
                'self': 'value'
            },
        })],
        'read|CSVFile': [('0.1.1', '0.1.2', None, {
            'src_port_remap': {
                'self': 'value'
            },
        }), ('0.1.3', '0.1.5', None, {})],
        'read|NumPyArray': [('0.1.1', '0.1.2', None, {
            'src_port_remap': {
                'self': 'value'
            },
        })],
        'read|ExcelSpreadsheet': [('0.1.1', '0.1.2', None, {
            'src_port_remap': {
                'self': 'value'
            },
        }), ('0.1.3', '0.1.4', None, {})],
        'read|JSONFile': [(None, '0.1.5', 'read|JSONObject', {
            'function_remap': {
                None: add_keyname
            },
        })],
    }

    try:
        from vistrails.packages.spreadsheet.init import upgrade_cell_to_output
    except ImportError:
        pass
    else:
        module_remap = upgrade_cell_to_output(module_remap, module_id,
                                              pipeline, 'TableCell',
                                              'TableOutput', '0.1.6', 'table')

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
                                               module_remap)
示例#22
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    module_remap = {
            # HTTPFile was renamed DownloadFile
            'HTTPFile': [
                (None, '1.0.0', 'DownloadFile'),
            ],
            'RepoSync': [
                (None, '1.1.0', 'org.vistrails.vistrails.reposync:RepoSync'),
            ]
        }

    return UpgradeWorkflowHandler.remap_module(controller,
                                               module_id,
                                               pipeline,
                                               module_remap)
示例#23
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    module_remap = {
            # Migrates from pre-0.1.0 to 0.2.0+
            'PersistentFile': [
                (None, '0.1.0', 'PersistentIntermediateFile', {
                    'dst_port_remap': {
                        'compress': None}})],
            'PersistentDirectory': [
                (None, '0.1.0', 'PersistentIntermediateDir', {
                    'dst_port_remap': {
                        'compress': None}})],
            # Migrates from persistence_exp (0.1.0-0.2.0) to 0.2.0+
            'ManagedRef': [
                ('0.1.0', None, 'persistence:PersistentRef', {})],
            'ManagedPath': [
                ('0.1.0', None, 'persistence:PersistentPath', {})],
            'ManagedFile': [
                ('0.1.0', None, 'persistence:PersistentFile', {})],
            'ManagedDir': [
                ('0.1.0', None, 'persistence:PersistentDir', {})],
            'ManagedInputFile': [
                ('0.1.0', None, 'persistence:PersistentInputFile', {})],
            'ManagedOutputFile': [
                ('0.1.0', None, 'persistence:PersistentOutputFile', {})],
            'ManagedIntermediateFile': [
                ('0.1.0', None, 'persistence:PersistentIntermediateFile', {})],
            'ManagedInputDir': [
                ('0.1.0', None, 'persistence:PersistentInputDir', {})],
            'ManagedOutputDir': [
                ('0.1.0', None, 'persistence:PersistentOutputDir', {})],
            'ManagedIntermediateDir': [
                ('0.1.0', None, 'persistence:PersistentIntermediateDir', {})]
        }
    for module in ['PersistentPath', 'PersistentFile', 'PersistentDir',
                   'PersistentInputFile', 'PersistentOutputFile',
                   'PersistentIntermediateFile',
                   'PersistentInputDir', 'PersistentOutputDir',
                   'PersistentIntermediateDir']:
        upgrade = ('0.2.0', '0.2.2', None,
                   {'dst_port_remap': {'ref': 'ref'}})
        if module in module_remap:
            module_remap[module].append(upgrade)
        else:
            module_remap[module] = [upgrade]

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
                                               module_remap)
示例#24
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    module_remap = {
        # Migrates from pre-0.1.0 to 0.2.0+
        'PersistentFile': [(None, '0.1.0', 'PersistentIntermediateFile', {
            'dst_port_remap': {
                'compress': None
            }
        })],
        'PersistentDirectory': [(None, '0.1.0', 'PersistentIntermediateDir', {
            'dst_port_remap': {
                'compress': None
            }
        })],
        # Migrates from persistence_exp (0.1.0-0.2.0) to 0.2.0+
        'ManagedRef': [('0.1.0', None, 'persistence:PersistentRef', {})],
        'ManagedPath': [('0.1.0', None, 'persistence:PersistentPath', {})],
        'ManagedFile': [('0.1.0', None, 'persistence:PersistentFile', {})],
        'ManagedDir': [('0.1.0', None, 'persistence:PersistentDir', {})],
        'ManagedInputFile':
        [('0.1.0', None, 'persistence:PersistentInputFile', {})],
        'ManagedOutputFile':
        [('0.1.0', None, 'persistence:PersistentOutputFile', {})],
        'ManagedIntermediateFile':
        [('0.1.0', None, 'persistence:PersistentIntermediateFile', {})],
        'ManagedInputDir': [('0.1.0', None, 'persistence:PersistentInputDir',
                             {})],
        'ManagedOutputDir': [('0.1.0', None, 'persistence:PersistentOutputDir',
                              {})],
        'ManagedIntermediateDir':
        [('0.1.0', None, 'persistence:PersistentIntermediateDir', {})]
    }
    for module in [
            'PersistentPath', 'PersistentFile', 'PersistentDir',
            'PersistentInputFile', 'PersistentOutputFile',
            'PersistentIntermediateFile', 'PersistentInputDir',
            'PersistentOutputDir', 'PersistentIntermediateDir'
    ]:
        upgrade = ('0.2.0', '0.2.2', None, {'dst_port_remap': {'ref': 'ref'}})
        if module in module_remap:
            module_remap[module].append(upgrade)
        else:
            module_remap[module] = [upgrade]

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
                                               module_remap)
示例#25
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    module_remap = {
            'read|csv|CSVFile': [
                (None, '0.1.1', 'read|CSVFile', {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
            'read|numpy|NumPyArray': [
                (None, '0.1.1', 'read|NumPyArray', {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
            'read|CSVFile': [
                ('0.1.1', '0.1.2', None, {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
            'read|NumPyArray': [
                ('0.1.1', '0.1.2', None, {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
            'read|ExcelSpreadsheet': [
                ('0.1.1', '0.1.2', None, {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
        }

    return UpgradeWorkflowHandler.remap_module(controller,
                                               module_id,
                                               pipeline,
                                               module_remap)
示例#26
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    module_remap = {'SQLSource': [(None, '0.0.3', None, {})]}

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
                                               module_remap)
示例#27
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    from vistrails.core.upgradeworkflow import UpgradeWorkflowHandler
    create_new_connection = UpgradeWorkflowHandler.create_new_connection
    reg = vistrails.core.modules.module_registry.get_module_registry()

    def find_module_in_upgrade_action(action):
        for op in action.operations:
            if isinstance(op, AddOp):
                if op.what == Module.vtType:
                    return op.data
        return None

    def find_inputs(m):
        functions = {}
        for f in m.functions:
            if f.name not in functions:
                functions[f.name] = [f]
            else:
                functions[f.name].append(f)
        connections = {}
        for edge in pipeline.graph.iter_edges_to(m.id):
            c = pipeline.connections[edge[2]]
            if c.destination.name not in connections:
                connections[c.destination.name] = [c]
            else:
                connections[c.destination.name].append(c)
        return (functions, connections)

    def find_figure(m):
        for edge in pipeline.graph.iter_edges_from(m.id):
            to_m = pipeline.modules[edge[1]]
            if to_m.name == 'MplFigure':
                # !!! assume only a single down-stream MplFigure !!!
                # may have old or new module...
                if pipeline.connections[edge[2]].destination.name == 'addPlot':
                    return (to_m, None)
                else:
                    return (to_m, edge)
        return (None, None)

    def attach_inputs(new_module, inputs, selected_inputs):
        conns = []
        for port_name in selected_inputs:
            if port_name in inputs[0]:
                for f in inputs[0][port_name]:
                    if len(f.parameters) > 0:
                        new_param_vals, aliases = zip(*[(p.strValue, p.alias)
                                                        for p in f.parameters])
                    else:
                        new_param_vals = []
                        aliases = []
                    new_f = controller.create_function(new_module, port_name,
                                                       new_param_vals, aliases)
                    new_module.add_function(new_f)
            if port_name in inputs[1]:
                for c in inputs[1][port_name]:
                    source_module = pipeline.modules[c.source.id]
                    new_conn = create_new_connection(controller, source_module,
                                                     c.source, new_module,
                                                     port_name)
                    conns.append(new_conn)
        return conns

    module = pipeline.modules[module_id]
    to_properties = []
    to_axes = []
    old_figure = (None, None)
    props_name = None
    if module.name == 'MplScatterplot':
        props_name = 'MplPathCollectionProperties'
        props_input = 'pathCollectionProperties'
        to_properties = ['facecolor']
        to_axes = ['title', 'xlabel', 'ylabel']
        inputs = find_inputs(module)
        old_loc = module.location
        old_figure = find_figure(module)
    elif module.name == 'MplHistogram':
        props_name = 'MplRectangleProperties'
        props_input = 'rectangleProperties'
        to_properties = ['facecolor']
        to_axes = ['title', 'xlabel', 'ylabel']
        inputs = find_inputs(module)
        old_loc = module.location
        old_figure = find_figure(module)

    module_remap = {
        'MplPlot': [(None, '1.0.0', 'MplSource', {
            'dst_port_remap': {
                'source': 'source',
                'Hide Toolbar': None
            },
            'src_port_remap': {
                'source': 'value',
                'self': 'value'
            }
        })],
        'MplFigure': [(None, '1.0.0', None, {
            'dst_port_remap': {
                'Script': 'addPlot'
            },
            'src_port_remap': {
                'FigureManager': 'figure',
                'File': 'file'
            }
        }), ('1.0.0', '1.0.6', None, {
            'src_port_remap': {
                'self': 'figure'
            }
        })],
        'MplFigureCell': [(None, '1.0.0', None, {
            'dst_port_remap': {
                'FigureManager': 'figure'
            }
        })],
        # we will delete parts of this but add back later
        'MplScatterplot': [(None, '1.0.0', 'MplScatter', {
            'dst_port_remap': {
                'xData': 'x',
                'yData': 'y',
                'facecolor': None,
                'title': None,
                'xlabel': None,
                'ylabel': None,
                'self': 'value'
            },
            'src_port_remap': {
                'source': 'value'
            }
        })],
        'MplHistogram': [(None, '1.0.0', 'MplHist', {
            'dst_port_remap': {
                'columnData': 'x',
                'bins': 'bins',
                'facecolor': None,
                'title': None,
                'xlabel': None,
                'ylabel': None,
                'self': 'value'
            },
            'src_port_remap': {
                'source': 'value'
            }
        })],
    }

    # '1.0.2' -> '1.0.3' changes 'self' output port to 'value'
    module_remap.setdefault('MplSource', []).append((None, '1.0.3', None, {
        'src_port_remap': {
            'self': 'value'
        }
    }))
    if module.name in (m.__name__ for m in _plot_modules + _artist_modules):
        module_remap.setdefault(module.name, []).append((None, '1.0.3', None, {
            'src_port_remap': {
                'self': 'value'
            }
        }))

    action_list = []
    if old_figure[1] is not None and \
       any(p in inputs[0] or p in inputs[1] for p in to_axes):
        # need to remove the edge between plot and figure
        pipeline.graph.delete_edge(*old_figure[1])
        conn = pipeline.connections[old_figure[1][2]]
        action = vistrails.core.db.action.create_action([('delete', conn)])
        action_list.append(action)

    try:
        from vistrails.packages.spreadsheet.init import upgrade_cell_to_output
    except ImportError:
        pass
    else:
        module_remap = upgrade_cell_to_output(module_remap, module_id,
                                              pipeline, 'MplFigureCell',
                                              'MplFigureOutput', '1.0.5',
                                              'figure')

    normal_actions = UpgradeWorkflowHandler.remap_module(
        controller, module_id, pipeline, module_remap)
    action_list.extend(normal_actions)

    more_ops = []
    if any(p in inputs[0] or p in inputs[1] for p in to_properties):
        # create props module
        if props_name is None:
            raise RuntimeError("properties module needed for unknown module "
                               "%s" % module.name)
        desc = reg.get_descriptor_by_name(identifier, props_name)
        props_module = \
            controller.create_module_from_descriptor(desc,
                                                     old_loc.x + 100,
                                                     old_loc.y + 100)
        more_ops.append(('add', props_module))

        # attach functions/connections
        conns = attach_inputs(props_module, inputs, to_properties)
        more_ops.extend([('add', c) for c in conns])

        # attach into pipeline
        new_plot_module = find_module_in_upgrade_action(normal_actions[0])
        assert new_plot_module is not None
        new_conn = create_new_connection(controller, props_module, 'self',
                                         new_plot_module, props_input)
        more_ops.append(('add', new_conn))

    if any(p in inputs[0] or p in inputs[1] for p in to_axes):
        # create axes module
        desc = reg.get_descriptor_by_name(identifier, "MplAxesProperties")
        if old_figure[0] is not None:
            old_loc = old_figure[0].location
        axes_module = \
            controller.create_module_from_descriptor(desc,
                                                     old_loc.x + 100,
                                                     old_loc.y + 100)
        more_ops.append(('add', axes_module))

        # attach functions/connections
        conns = attach_inputs(axes_module, inputs, to_axes)
        more_ops.extend([('add', c) for c in conns])

        # attach axes properties to new figure
        if old_figure[0] is not None and old_figure[1] is not None:
            # remap figure
            fig_action = UpgradeWorkflowHandler.remap_module(
                controller, old_figure[0].id, pipeline, module_remap)
            fig_module = find_module_in_upgrade_action(fig_action[0])
            assert fig_module is not None
            # add the removed edge back in
            pipeline.graph.add_edge(*old_figure[1])
            action_list.extend(fig_action)

            new_plot_module = find_module_in_upgrade_action(normal_actions[0])
            assert new_plot_module is not None
            conn = create_new_connection(controller, new_plot_module, 'self',
                                         fig_module, 'addPlot')
            action = vistrails.core.db.action.create_action([('add', conn)])
            action_list.append(action)
        else:
            fig_module = old_figure[0]
        new_conn = create_new_connection(controller, axes_module, 'self',
                                         fig_module, 'axesProperties')
        more_ops.append(('add', new_conn))

    return action_list
示例#28
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    print "upgrading %s" % pipeline.modules[module_id].name
    reg = get_module_registry()

    # format is {<old module name>: (<new_module_klass>, <remap_dictionary>}}
    # where remap_dictionary is {<remap_type>: <name_changes>}
    # and <name_changes> is a map from <old_name> to <new_name>
    module_remap = {
        'AlpsApplication': (applications.RunAlpsApplication, {}),
        'AlpsEvaluate': (applications.AlpsEvaluate, {}),
        'AppSpinMC': (applications.RunSpinMC, {}),
        'AppLoop': (applications.RunLoop, {}),
        'AppDirLoopSSE': (applications.RunDirLoopSSE, {}),
        'AppWorm': (applications.RunWorm, {}),
        'AppDWA': (applications.RunDWA, {}),
        'AppFullDiag': (applications.RunFullDiag, {}),
        'AppSparseDiag': (applications.RunSparseDiag, {}),
        'AppDMRG': (applications.RunDMRG, {}),
        'AppTEBD': (applications.RunTEBD, {}),
        'AppQWL': (applications.RunQWL, {}),
        'EvaluateFullDiagT': (applications.EvaluateFullDiagVersusT, {}),
        'EvaluateFullDiagH': (applications.EvaluateFullDiagVersusH, {}),
        'MonteCarloSimulation': (system.PrepareMonteCarlo, {}),
        'DiagonalizationSimulation': (system.PrepareDiagonalization, {}),
        'DMRGSimulation': (system.PrepareDMRG, {}),
        'TEBDSimulation': (system.PrepareTEBD, {}),
        'SimulationID': (system.SimulationName, {
            'dst_port_remap': {
                'value': 'value'
            },
            'src_port_remap': {
                'value': 'value'
            }
        }),
        'Applications|SimulationName': (system.SimulationName, {
            'dst_port_remap': {
                'value': 'value'
            },
            'src_port_remap': {
                'value': 'value'
            }
        }),
        'SimulationName': (system.SimulationName, {
            'dst_port_remap': {
                'value': 'value'
            },
            'dst_port_remap': {
                'value': 'value'
            }
        }),
        'LatticeModel': (system.LatticeModel, {}),
        'LatticeParameters': (lattices.Lattice, {}),
        'square_lattice': (lattices.SquareLattice, {}),
        'simple_cubic_lattice': (lattices.SimpleCubicLattice, {}),
        'ladder': (lattices.LadderLattice, {}),
        'open_ladder': (lattices.OpenLadderLattice, {}),
        'chain_lattice': (lattices.ChainLattice, {}),
        'open_chain_lattice': (lattices.OpenChainLattice, {}),
        'ModelParameters': (models.Model, {}),
        'ClassicalSpinModel': (models.ClassicalSpinModel, {}),
        'SpinModel': (models.SpinModel, {}),
        'BosonHubbardModel': (models.BosonHubbardModel, {}),
        'HardcoreBosonModel': (models.HardcoreBosonModel, {}),
        'CombineParameters': (parameters.ConcatenateParameters, {}),
        'Parameter': (parameters.Parameter, {}),
        'ConservedQuantumnumbers':
        (alpsparameters.ConservedQuantumNumbers, {}),
        'SystemParameters': (alpsparameters.SystemParameters, {}),
        'MakeParameterFile': (tools.WriteParameterFile, {
            'dst_port_remap': {
                'simulationid': 'simulationid'
            }
        }),
        'MakeParameterXMLFiles': (tools.WriteInputFiles, {
            'dst_port_remap': {
                'simulationid': 'simulationid'
            }
        }),
        'WriteInputFiles': (tools.WriteInputFiles, {
            'dst_port_remap': {
                'simulationid': 'simulationid'
            }
        }),
        'GetRunFiles': (tools.GetCloneFiles, {}),
        'GetResultFiles': (tools.GetResultFiles, {}),
        'GetCloneFiles': (tools.GetCloneFiles, {}),
        'XML2HTML': (tools.ConvertXML2HTML, {}),
        'ConvertXML2HTML': (tools.ConvertXML2HTML, {}),
        'GetSimulationInDir': (tools.GetJobFile, {}),
        'OpenHTML': (alpscore.DisplayInBrowser, {}),
        'TextFile': (alpscore.WriteTextFile, {}),
        'GenerateDataSet': (dataset.PrepareDataSets, {}),
        'LoadDataSet': (dataset.LoadDataSetsFromTextFile, {}),
        'CustomLoader': (dataset.LoadCustomFile, {}),
        'CollectXY': (dataset.CollectDataSets, {
            'dst_port_remap': {
                'for-each': 'for-each'
            }
        }),
        'Parameters|CollectDataSets': (dataset.CollectDataSets, {
            'dst_port_remap': {
                'for-each': 'for-each'
            }
        }),
        'LoadProperties': (dataset.LoadAlpsProperties, {}),
        'LoadAlpsHdf5': (dataset.LoadAlpsMeasurements, {}),
        'LoadAlpsMeasurements': (dataset.LoadAlpsMeasurements, {}),
        'LoadSpectrumHdf5': (dataset.LoadAlpsSpectra, {}),
        'LoadBinningAnalysis': (dataset.LoadBinningAnalysis, {}),
        'LoadAlpsDiagData': (dataset.LoadAlpsEigenstateMeasurements, {}),
        'LoadAlpsEigenstateMeasurements':
        (dataset.LoadAlpsEigenstateMeasurements, {}),
        'Transform': (dataset.TransformEachDataSet, {}),
        'PlotDescriptor': (dataset.PreparePlot, {}),
        'PreparePlot': (dataset.PreparePlot, {}),
        'AxisDescriptor': (dataset.Axis, {}),
        'Axis': (dataset.Axis, {}),
        'LegendDescriptor': (dataset.Legend, {}),
        'Legend': (dataset.Legend, {}),
        'Convert2Text': (dataset.WriteTextFile, {}),
        'Convert2Grace': (dataset.WriteGraceFile, {}),
        'DisplayXMGRPlot': (plots.DisplayGracePlot, {}),
        'GraceXYPlot': (dataset.WriteGraceFile, {}),
        'MplXYPlot': (dataset.MplXYPlot, {
            'dst_port_remap': {
                'plot': 'plot'
            },
            'src_port_remap': {
                'unused': 'value',
                'self': 'value'
            }
        }),
        'DataSet|Plot|MplXYPlot': (dataset.MplXYPlot, {
            'dst_port_remap': {
                'plot': 'plot'
            },
            'src_port_remap': {
                'unused': 'value',
                'self': 'value'
            }
        }),
        'Select': (dataset.Select, {}),
        'And': (dataset.And, {}),
        'Or': (dataset.Or, {}),
        'PolyFit': (dataset.DoPolynomialFit, {}),
        'NonlinearFit': (dataset.DoNonlinearFit, {}),
        'DoNonlinearFit': (dataset.DoNonlinearFit, {}),
        'SortByX': (dataset.SortEachDataSet, {}),
        'SelectXRange': (dataset.RestrictXRange, {}),
        'SetLabels': (dataset.SetLabels, {}),
        'MakeScatter': (dataset.SetPlotStyle, {}),
        'Selector': (dataset.Predicate, {}),
        'PropertySelector': (dataset.PropertyPredicate, {}),
        'PropertyRangeSelector': (dataset.PropertyRangePredicate, {}),
        'ObservableSelector': (dataset.ObservablePredicate, {}),
        'GroupBy': (dataset.GroupDataSets, {
            'dst_port_remap': {
                'for-each': 'for-each'
            }
        }),
        'GroupDataSets': (dataset.GroupDataSets, {
            'dst_port_remap': {
                'for-each': 'for-each'
            }
        }),
        'GroupedTransform': (dataset.TransformGroupedDataSets, {}),
        'GenerateDataSet': (dataset.PrepareDataSets, {}),
        'GenerateDataSet': (dataset.PrepareDataSets, {}),
        'CycleColors': (dataset.CycleColors, {}),
        'CycleMarkers': (dataset.CycleMarkers, {}),
        'Convert2XML': (tools.Convert2XML, {}),
        'IterateValue': (parameters.IterateValue, {
            'dst_port_remap': {
                'value_list': 'value_list'
            }
        }),
        'IterateParameter': (parameters.IterateParameter, {
            'dst_port_remap': {
                'value_list': 'value_list'
            }
        })
    }

    # remaps for move of List in VT
    new_remap = {
        'DataSet|Fit|DoNonlinearFit': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'parameters': 'parameters'
            }
        })],
        'Tools|GetResultFiles': [(None, '2.2.1', None, {
            'src_port_remap': {
                'value': 'value'
            }
        })],
        'Plots|ExtractText': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'data': 'data'
            }
        })],
        'DataSet|Hierarchy|GroupDataSets': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'for-each': 'for-each'
            }
        })],
        'DataSet|Plot|SetLabels': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'label_props': 'label_props'
            }
        })],
        'DataSet|Load|LoadTimeEvolution': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'Measurements': 'Measurements'
            }
        })],
        'DataSet|Load|LoadDataSetsFromTextFile': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'y-columns': 'y-columns'
            }
        })],
        'Tools|ShowListOfXMLFiles': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'InputList': 'InputList'
            }
        })],
        'Plots|ExtractAnything': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'data': 'data'
            }
        })],
        'Tools|GetCloneFiles': [(None, '2.2.1', None, {
            'src_port_remap': {
                'value': 'value'
            }
        })],
        'Plots|ExtractMpl': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'data': 'data'
            }
        })],
        'Tools|Convert2XML': [(None, '2.2.1', None, {
            'src_port_remap': {
                'value': 'value'
            },
            'dst_port_remap': {
                'input_file': 'input_file'
            }
        })],
        'Tools|ConcatenatePathList': [(None, '2.2.1', None, {
            'src_port_remap': {
                'files': 'files',
                'paths': 'paths',
                'directories': 'directories'
            },
            'dst_port_remap': {
                'leafs': 'leafs'
            }
        })],
        'Parameters|IterateValue': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'value_list': 'value_list'
            }
        })],
        'DataSet|Load|LoadAlpsEigenstateMeasurements': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'Measurements': 'Measurements'
            }
        })],
        'DataSet|DataSets': [(None, '2.2.1', None, {
            'src_port_remap': {
                'value': 'value'
            },
            'dst_port_remap': {
                'tail': 'tail',
                'value': 'value'
            }
        })],
        'Tools|DisplayInBrowser': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'files': 'files'
            }
        })],
        'DataSet|Plot|CycleMarkers': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'for-each': 'for-each',
                'markers': 'markers'
            }
        })],
        'DataSet|Load|LoadAlpsMeasurements': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'Measurements': 'Measurements'
            }
        })],
        'Plots|ExtractXMGR': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'data': 'data'
            }
        })],
        'DataSet|Plot|CycleColors': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'for-each': 'for-each',
                'colors': 'colors'
            }
        })],
        'Tools|Glob': [(None, '2.2.1', None, {
            'src_port_remap': {
                'value': 'value'
            }
        })],
        'Tools|ConvertXML2HTML': [(None, '2.2.1', None, {
            'src_port_remap': {
                'output_files': 'output_files'
            },
            'dst_port_remap': {
                'input_files': 'input_files'
            }
        })],
        'Parameters|IterateParameter': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'value_list': 'value_list'
            }
        })],
        'DataSet|Load|CollectDataSets': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'for-each': 'for-each'
            }
        })],
        'DataSet|ResultFiles': [(None, '2.2.1', None, {
            'src_port_remap': {
                'value': 'value',
                'filenames': 'filenames'
            },
            'dst_port_remap': {
                'tail': 'tail',
                'value': 'value',
                'filenames': 'filenames'
            }
        })],
        'Dataset|Plot|ShowListOfPlots': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'InputList': 'InputList'
            }
        })],
        'DataSet|Load|LoadBinningAnalysis': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'Measurements': 'Measurements'
            }
        })],
        'Tools|PickFileFromList': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'files': 'files'
            }
        })],
        'Tools|ShowListOfHTMLFiles': [(None, '2.2.1', None, {
            'dst_port_remap': {
                'InputList': 'InputList'
            }
        })]
    }

    for name, (new_module, d) in module_remap.iteritems():
        new_remap[name] = [(None, '2.2.1', new_module, d)]

    # [(<start_version>, <end_version>, <new_module (None=same module, new version)>, <remap_dict>)]
    new_remap['ShowListOfHTMLFiles'] = [(None, '2.2.1', None, {})]
    new_remap['Tools|ShowListOfXMLFiles'] = [(None, '2.2.1', None, {})]
    new_remap['ShowListOfPlots'] = [(None, '2.2.1', None, {})]
    new_remap['DataSet|Plot|ShowListOfPlots'] = [(None, '2.2.1', None, {})]
    new_remap['Dataset|Plot|ShowListOfPlots'] = [
        (None, '2.2.1', 'DataSet|Plot|ShowListOfPlots', {})
    ]
    new_remap['DataSet|Plot|ShowMplPlot'] = [(None, '2.2.1', None, {})]
    new_remap['Dataset|Plot|ShowMplPlot'] = [(None, '2.2.1',
                                              'DataSet|Plot|ShowMplPlot', {})]
    new_remap['MplXYPlotCell'] = [(None, '2.2.1', None, {})]
    new_remap['Tools|MplXYPlotCell'] = [(None, '2.2.1', None, {})]
    new_remap['DataSet|Plot|MplXYPlot'] = [(None, '2.2.1', None, {})]
    new_remap['Tools|WriteInputFiles'] = [(None, '2.2.1', None, {
        'dst_port_remap': {
            'simulationid': 'simulationid'
        }
    })]
    new_remap['SimulationName'] = [(None, '2.2.1', None, {
        'dst_port_remap': {
            'value': 'value'
        },
        'src_port_remap': {
            'value': 'value'
        }
    })]
    new_remap['Applications|SimulationName'] = [(None, '2.2.1', None, {
        'dst_port_remap': {
            'value': 'value'
        },
        'src_port_remap': {
            'value': 'value'
        }
    })]
    new_remap['MplXYPlot'] = [(None, '2.2.1', dataset.MplXYPlot, {
        'dst_port_remap': {
            'plot': 'plot'
        },
        'src_port_remap': {
            'unused': 'value',
            'self': 'value'
        }
    })]
    new_remap['DataSet|Plot|MplXYPlot'] = [(None, '2.2.1', dataset.MplXYPlot, {
        'dst_port_remap': {
            'plot': 'plot'
        },
        'src_port_remap': {
            'unused': 'value',
            'self': 'value'
        }
    })]

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
                                               new_remap)
示例#29
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    from vistrails.core.modules.module_descriptor import ModuleDescriptor
    from vistrails.core.upgradeworkflow import UpgradeWorkflowHandler, \
        UpgradePackageRemap, UpgradeModuleRemap
    from vistrails.core.modules.basic_modules import identifier as basic_pkg

    def remap_functions(old_module, new_module, function_remap):
        # FIXME need use_registry flag passed through!
        use_registry = True
        function_ops = []
        for function in old_module.functions:
            if function.name in function_remap:
                remap = function_remap[function.name]
                if remap is None:
                    # don't add the function back in
                    continue
                elif not isinstance(remap, basestring):
                    function_ops.extend(remap(function, new_module))
                    continue
                else:
                    function_name = remap

                if len(function.parameters) > 0:
                    new_param_vals, aliases = zip(
                        *[(p.strValue, p.alias) for p in function.parameters])
                else:
                    new_param_vals = []
                    aliases = []
                if use_registry:
                    function_port_spec = function_name
                else:

                    def mk_psi(pos):
                        psi = PortSpecItem(module="Module",
                                           package=basic_pkg,
                                           namespace="",
                                           pos=pos)
                        return psi

                    n_items = len(new_param_vals)
                    function_port_spec = PortSpec(
                        name=function_name,
                        items=[mk_psi(i) for i in xrange(n_items)])
                new_function = controller.create_function(
                    new_module, function_port_spec, new_param_vals, aliases)
                new_module.add_function(new_function)

        if None in function_remap:
            # used to add new functions
            remap = function_remap[None]
            function_ops.extend(remap(None, new_module))
        return function_ops

    def remap_dst_connections(old_module, new_module, port_remap):
        # FIXME need use_registry flag passed through!
        use_registry = True
        create_new_connection = UpgradeWorkflowHandler.create_new_connection

        ops = []
        for _, conn_id in pipeline.graph.edges_to(old_module.id):
            old_conn = pipeline.connections[conn_id]
            if old_conn.destination.name in port_remap:
                remap = port_remap[old_conn.destination.name]
                if remap is None:
                    # don't add this connection back in
                    continue
                elif not isinstance(remap, basestring):
                    ops.extend(remap(old_conn, new_module))
                    continue
                else:
                    destination_name = remap

                old_src_module = pipeline.modules[old_conn.source.moduleId]
                if use_registry:
                    destination_port = destination_name
                else:
                    destination_port = Port(name=destination_name,
                                            type='destination',
                                            signature=create_port_spec_string([
                                                (basic_pkg, 'Variant', '')
                                            ]))

                new_conn = create_new_connection(controller, old_src_module,
                                                 old_conn.source, new_module,
                                                 destination_port)
                ops.append(('add', new_conn))
        return ops

    def insert_vis(vis_name, vis_port_remap):
        def remap_vis(old_conn, new_cell_module):
            ops = []
            old_src_module = pipeline.modules[old_conn.source.moduleId]
            old_cell_module = pipeline.modules[old_conn.destination.moduleId]

            new_x = (old_src_module.location.x +
                     new_cell_module.location.x) / 2.0
            new_y = (old_src_module.location.y +
                     new_cell_module.location.y) / 2.0

            new_vis_desc = ModuleDescriptor(package=identifier,
                                            name=vis_name,
                                            version='0.3.0')
            new_vis_module = \
                controller.create_module_from_descriptor(new_vis_desc,
                                                         new_x, new_y)

            function_ops = remap_functions(old_cell_module, new_vis_module,
                                           vis_port_remap)
            ops.append(('add', new_vis_module))
            ops.extend(function_ops)
            ops.extend(
                remap_dst_connections(old_cell_module, new_vis_module,
                                      vis_port_remap))

            create_new_connection = UpgradeWorkflowHandler.create_new_connection
            new_conn_1 = create_new_connection(controller, old_src_module,
                                               old_conn.source, new_vis_module,
                                               "table")
            ops.append(('add', new_conn_1))
            new_conn_2 = create_new_connection(controller, new_vis_module,
                                               "self", new_cell_module,
                                               "layers")
            ops.append(('add', new_conn_2))
            return ops

        # returns the actual remap function
        return remap_vis

    # zoom gets moved for free from old cell to new cell
    remap = UpgradePackageRemap()

    def add_legacy(fname, module):
        new_function = controller.create_function(module, "allowLegacy",
                                                  ["True"])
        return [('add', new_function, 'module', module.id)]

    remap.add_module_remap(
        UpgradeModuleRemap('0.1.0',
                           '0.3.0',
                           '0.3.0',
                           new_module="GMapCell",
                           module_name="GMapCell",
                           dst_port_remap={
                               'table':
                               insert_vis("GMapSymbols", {None: add_legacy}),
                               'colormapName':
                               None
                           }))
    remap.add_module_remap(
        UpgradeModuleRemap('0.1.0',
                           '0.3.0',
                           '0.3.0',
                           new_module="GMapCell",
                           module_name="GMapHeatmapCell",
                           dst_port_remap={
                               'table':
                               insert_vis(
                                   "GMapHeatmap", {
                                       'dissipating': 'dissipating',
                                       'maxIntensity': 'maxIntensity',
                                       'opacity': 'opacity',
                                       'radius': 'radius'
                                   }),
                               'dissipating':
                               None,
                               'maxIntensity':
                               None,
                               'opacity':
                               None,
                               'radius':
                               None,
                           }))
    remap.add_module_remap(
        UpgradeModuleRemap('0.1.0',
                           '0.3.0',
                           '0.3.0',
                           new_module="GMapCell",
                           module_name="GMapCircleCell",
                           dst_port_remap={
                               'table':
                               insert_vis(
                                   "GMapCircles", {
                                       'strokeColor': 'strokeColor',
                                       'strokeWeight': 'strokeWeight',
                                       'strokeOpacity': 'strokeOpacity',
                                       'fillColor': 'fillColor',
                                       'fillOpacity': 'fillOpacity'
                                   }),
                               'strokeColor':
                               None,
                               'strokeWeight':
                               None,
                               'strokeOpacity':
                               None,
                               'fillColor':
                               None,
                               'fillOpacity':
                               None,
                           }))
    remap.add_module_remap(
        UpgradeModuleRemap('0.1.0',
                           '0.3.0',
                           '0.3.0',
                           new_module="GMapCell",
                           module_name="GMapSymbolCell",
                           dst_port_remap={
                               'table':
                               insert_vis(
                                   "GMapSymbols", {
                                       'strokeColor': 'strokeColor',
                                       'strokeWeight': 'strokeWeight',
                                       'strokeOpacity': 'strokeOpacity',
                                       'fillStartColor': 'fillStartColor',
                                       'fillEndColor': 'fillEndColor',
                                       'fillOpacity': 'fillOpacity',
                                       'scale': 'scale'
                                   }),
                               'strokeColor':
                               None,
                               'strokeWeight':
                               None,
                               'strokeOpacity':
                               None,
                               'fillStartColor':
                               None,
                               'fillEndColor':
                               None,
                               'fillOpacity':
                               None,
                               'scale':
                               None,
                           }))

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
                                               remap)
示例#30
0
文件: init.py 项目: licode/VisTrails
    if old_module.package == 'edu.utah.sci.vistrails.sudswebservices':
        reg = vistrails.core.modules.module_registry.get_module_registry()
        new_descriptor = reg.get_descriptor_by_name(toSignature(wsdl), name,
                                                    namespace)
        if not new_descriptor:
            return []
        try:
            return UpgradeWorkflowHandler.replace_module(
                controller, pipeline, module_id, new_descriptor)
        except Exception, e:
            import traceback
            traceback.print_exc()
            raise

    return UpgradeWorkflowHandler.attempt_automatic_upgrade(
        controller, pipeline, module_id)


def handle_missing_module(controller, module_id, pipeline):
    global webServicesDict
    global package_cache

    def get_wsdl_from_namespace(m_namespace):
        try:
            wsdl = m_namespace.split("|")
            return wsdl[0]
        except Exception, e:
            debug.unexpected_exception(e)
            return None

    m = pipeline.modules[module_id]
示例#31
0
文件: init.py 项目: licode/VisTrails
def handle_module_upgrade_request(controller, module_id, pipeline):
    reg = get_module_registry()

    # Product modules had a CombineTuple port, which has been replaced with
    # NumericalProduct, with the opposite meaning
    def product_change_connection(old_conn, new_module):
        src_module = pipeline.modules[old_conn.source.moduleId]
        new_x = (src_module.location.x + new_module.location.x) / 2.0
        new_y = (src_module.location.y + new_module.location.y) / 2.0
        Not_desc = reg.get_descriptor(Not)
        not_mod = controller.create_module_from_descriptor(
            Not_desc, new_x, new_y)
        conn1 = UpgradeWorkflowHandler.create_new_connection(
            controller, src_module, old_conn.source, not_mod, 'input')
        conn2 = UpgradeWorkflowHandler.create_new_connection(
            controller, not_mod, 'value', new_module, 'NumericalProduct')
        return [('add', not_mod), ('add', conn1), ('add', conn2)]

    def product_change_function(function, new_module):
        parameter = function.parameters[0]
        if parameter.value():
            value = 'False'
        else:
            value = 'True'
        return controller.update_function_ops(new_module, 'NumericalProduct',
                                              [value])

    module_remap = {
        'ListOfElements': [
            # Any 'ListOfElements' before 0.2.2 gets replaced with List
            (None, '0.2.2', List, {}),
        ],
        'Dot': [
            # The Dot module in 0.2.1 was in fact ElementwiseProduct
            (None, '0.2.2', ElementwiseProduct, {
                'dst_port_remap': {
                    'List_1': 'List1',
                    'List_2': 'List2',
                    'CombineTuple': product_change_connection,
                },
                'function_remap': {
                    'CombineTuple': product_change_function,
                },
            }),
        ],
        'Cross': [
            (None, '0.2.2', CartesianProduct, {
                'dst_port_remap': {
                    'List_1': 'List1',
                    'List_2': 'List2',
                },
            }),
        ],
        'Map': [
            (None, '0.2.4', None, {
                'src_port_remap': {
                    'Result': 'Result'
                }
            }),
        ],
        'Filter': [
            (None, '0.2.4', None, {
                'src_port_remap': {
                    'Result': 'Result'
                }
            }),
        ],
    }

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
                                               module_remap)
示例#32
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    reg = get_module_registry()

    # Product modules had a CombineTuple port, which has been replaced with
    # NumericalProduct, with the opposite meaning
    def product_change_connection(old_conn, new_module):
        src_module = pipeline.modules[old_conn.source.moduleId]
        new_x = (src_module.location.x + new_module.location.x) / 2.0
        new_y = (src_module.location.y + new_module.location.y) / 2.0
        Not_desc = reg.get_descriptor(Not)
        not_mod = controller.create_module_from_descriptor(Not_desc,
                                                           new_x, new_y)
        conn1 = UpgradeWorkflowHandler.create_new_connection(
                controller,
                src_module, old_conn.source,
                not_mod, 'input')
        conn2 = UpgradeWorkflowHandler.create_new_connection(
                controller,
                not_mod, 'value',
                new_module, 'NumericalProduct')
        return [('add', not_mod), ('add', conn1), ('add', conn2)]
    def product_change_function(function, new_module):
        parameter = function.parameters[0]
        if parameter.value():
            value = 'False'
        else:
            value = 'True'
        return controller.update_function_ops(
                new_module, 'NumericalProduct',
                [value])

    module_remap = {
            'ListOfElements': [
                # Any 'ListOfElements' before 0.2.2 gets replaced with List
                (None, '0.2.2', List, {}),
            ],
            'Dot': [
                # The Dot module in 0.2.1 was in fact ElementwiseProduct
                (None, '0.2.2', ElementwiseProduct, {
                    'dst_port_remap': {
                        'List_1': 'List1',
                        'List_2': 'List2',
                        'CombineTuple': product_change_connection,
                    },
                    'function_remap': {
                        'CombineTuple': product_change_function,
                    },
                }),
            ],
            'Cross': [
                (None, '0.2.2', CartesianProduct, {
                    'dst_port_remap': {
                        'List_1': 'List1',
                        'List_2': 'List2',
                    },
                }),
            ],
            'Map': [
                (None, '0.2.4', None, {
                    'src_port_remap': {'Result': 'Result'}
                }),
            ],
            'Filter': [
                (None, '0.2.4', None, {
                    'src_port_remap': {'Result': 'Result'}
                }),
            ],
        }

    return UpgradeWorkflowHandler.remap_module(controller,
                                               module_id,
                                               pipeline,
                                               module_remap)
示例#33
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    def add_keyname(fname, module):
        new_function = controller.create_function(module,
                                                  "key_name",
                                                  ["_key"])
        return [('add', new_function, 'module', module.id)]

    module_remap = {
            'read|csv|CSVFile': [
                (None, '0.1.1', 'read|CSVFile', {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
            'read|numpy|NumPyArray': [
                (None, '0.1.1', 'read|NumPyArray', {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
            'read|CSVFile': [
                ('0.1.1', '0.1.2', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
                ('0.1.3', '0.1.5', None, {})
            ],
            'read|NumPyArray': [
                ('0.1.1', '0.1.2', None, {
                    'src_port_remap': {
                        'self': 'value'},
                })
            ],
            'read|ExcelSpreadsheet': [
                ('0.1.1', '0.1.2', None, {
                    'src_port_remap': {
                        'self': 'value'},
                }),
                ('0.1.3', '0.1.4', None, {})
            ],
            'read|JSONFile': [
                (None, '0.1.5', 'read|JSONObject', {
                    'function_remap': {
                        None: add_keyname},
                })
            ],
        }

    try:
        from vistrails.packages.spreadsheet.init import upgrade_cell_to_output
    except ImportError:
        pass
    else:
        module_remap = upgrade_cell_to_output(
                module_remap, module_id, pipeline,
                'TableCell', 'TableOutput',
                '0.1.6', 'table')

    return UpgradeWorkflowHandler.remap_module(controller,
                                               module_id,
                                               pipeline,
                                               module_remap)
示例#34
0
文件: init.py 项目: Nikea/VisTrails
def handle_module_upgrade_request(controller, module_id, pipeline):
    from vistrails.core.modules.module_descriptor import ModuleDescriptor
    from vistrails.core.upgradeworkflow import UpgradeWorkflowHandler, \
        UpgradePackageRemap, UpgradeModuleRemap
    from vistrails.core.modules.basic_modules import identifier as basic_pkg

    def remap_functions(old_module, new_module, function_remap):
        # FIXME need use_registry flag passed through!
        use_registry = True
        function_ops = []
        for function in old_module.functions:
            if function.name in function_remap:
                remap = function_remap[function.name]
                if remap is None:
                    # don't add the function back in
                    continue
                elif not isinstance(remap, basestring):
                    function_ops.extend(remap(function, new_module))
                    continue
                else:
                    function_name = remap

                if len(function.parameters) > 0:
                    new_param_vals, aliases = zip(*[(p.strValue, p.alias)
                                                    for p in function.parameters])
                else:
                    new_param_vals = []
                    aliases = []
                if use_registry:
                    function_port_spec = function_name
                else:
                    def mk_psi(pos):
                        psi = PortSpecItem(module="Module", package=basic_pkg,
                                           namespace="", pos=pos)
                        return psi
                    n_items = len(new_param_vals)
                    function_port_spec = PortSpec(name=function_name,
                                                  items=[mk_psi(i)
                                                         for i in xrange(n_items)])
                new_function = controller.create_function(new_module,
                                                          function_port_spec,
                                                          new_param_vals,
                                                          aliases)
                new_module.add_function(new_function)

        if None in function_remap:
            # used to add new functions
            remap = function_remap[None]
            function_ops.extend(remap(None, new_module))
        return function_ops

    def remap_dst_connections(old_module, new_module, port_remap):
        # FIXME need use_registry flag passed through!
        use_registry = True
        create_new_connection = UpgradeWorkflowHandler.create_new_connection

        ops = []
        for _, conn_id in pipeline.graph.edges_to(old_module.id):
            old_conn = pipeline.connections[conn_id]
            if old_conn.destination.name in port_remap:
                remap = port_remap[old_conn.destination.name]
                if remap is None:
                    # don't add this connection back in
                    continue
                elif not isinstance(remap, basestring):
                    ops.extend(remap(old_conn, new_module))
                    continue
                else:
                    destination_name = remap

                old_src_module = pipeline.modules[old_conn.source.moduleId]
                if use_registry:
                    destination_port = destination_name
                else:
                    destination_port = Port(name=destination_name,
                                            type='destination',
                                            signature=create_port_spec_string(
                                                [(basic_pkg, 'Variant', '')]))

                new_conn = create_new_connection(controller,
                                                 old_src_module,
                                                 old_conn.source,
                                                 new_module,
                                                 destination_port)
                ops.append(('add', new_conn))
        return ops

    def insert_vis(vis_name, vis_port_remap):
        def remap_vis(old_conn, new_cell_module):
            ops = []
            old_src_module = pipeline.modules[old_conn.source.moduleId]
            old_cell_module = pipeline.modules[old_conn.destination.moduleId]

            new_x = (old_src_module.location.x + new_cell_module.location.x)/2.0
            new_y = (old_src_module.location.y + new_cell_module.location.y)/2.0

            new_vis_desc = ModuleDescriptor(package=identifier,
                                            name=vis_name,
                                            version='0.3')
            new_vis_module = \
                controller.create_module_from_descriptor(new_vis_desc,
                                                         new_x, new_y)

            function_ops = remap_functions(old_cell_module,
                                           new_vis_module,
                                           vis_port_remap)
            ops.append(('add', new_vis_module))
            ops.extend(function_ops)
            ops.extend(remap_dst_connections(old_cell_module,
                                             new_vis_module,
                                             vis_port_remap))

            create_new_connection = UpgradeWorkflowHandler.create_new_connection
            new_conn_1 = create_new_connection(controller,
                                               old_src_module,
                                               old_conn.source,
                                               new_vis_module,
                                               "table")
            ops.append(('add', new_conn_1))
            new_conn_2 = create_new_connection(controller,
                                               new_vis_module,
                                               "self",
                                               new_cell_module,
                                               "layers")
            ops.append(('add', new_conn_2))
            return ops

        # returns the actual remap function
        return remap_vis

    # zoom gets moved for free from old cell to new cell
    remap = UpgradePackageRemap()
    def add_legacy(fname, module):
        new_function = controller.create_function(module,
                                                  "allowLegacy",
                                                  ["True"])
        return [('add', new_function, 'module', module.id)]
    remap.add_module_remap(UpgradeModuleRemap('0.1', '0.3', '0.3',
                                              new_module="GMapCell",
                                              module_name="GMapCell",
                            dst_port_remap={'table': insert_vis("GMapSymbols",
                                            {None: add_legacy}),
                                            'colormapName': None}))
    remap.add_module_remap(UpgradeModuleRemap('0.1', '0.3', '0.3',
                                              new_module="GMapCell",
                                              module_name="GMapHeatmapCell",
                            dst_port_remap={'table': insert_vis("GMapHeatmap",
                                            {'dissipating': 'dissipating',
                                             'maxIntensity': 'maxIntensity',
                                             'opacity': 'opacity',
                                             'radius': 'radius'}),
                                            'dissipating': None,
                                            'maxIntensity': None,
                                            'opacity': None,
                                            'radius': None,
                                            }))
    remap.add_module_remap(UpgradeModuleRemap('0.1', '0.3', '0.3',
                                              new_module="GMapCell",
                                              module_name="GMapCircleCell",
                            dst_port_remap={'table': insert_vis("GMapCircles",
                                            {'strokeColor': 'strokeColor',
                                             'strokeWeight': 'strokeWeight',
                                             'strokeOpacity': 'strokeOpacity',
                                             'fillColor': 'fillColor',
                                             'fillOpacity': 'fillOpacity'}),
                                            'strokeColor': None,
                                            'strokeWeight': None,
                                            'strokeOpacity': None,
                                            'fillColor': None,
                                            'fillOpacity': None,
                                            }))
    remap.add_module_remap(UpgradeModuleRemap('0.1', '0.3', '0.3',
                                              new_module="GMapCell",
                                              module_name="GMapSymbolCell",
                            dst_port_remap={'table': insert_vis("GMapSymbols",
                                            {'strokeColor': 'strokeColor',
                                             'strokeWeight': 'strokeWeight',
                                             'strokeOpacity': 'strokeOpacity',
                                             'fillStartColor': 'fillStartColor',
                                             'fillEndColor': 'fillEndColor',
                                             'fillOpacity': 'fillOpacity',
                                             'scale': 'scale'}),
                                            'strokeColor': None,
                                            'strokeWeight': None,
                                            'strokeOpacity': None,
                                            'fillStartColor': None,
                                            'fillEndColor': None,
                                            'fillOpacity': None,
                                            'scale': None,
                                        }))

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
                                               remap)
示例#35
0
def handle_module_upgrade_request(controller, module_id, pipeline):
    from vistrails.core.upgradeworkflow import UpgradeWorkflowHandler
    create_new_connection = UpgradeWorkflowHandler.create_new_connection
    reg = vistrails.core.modules.module_registry.get_module_registry()

    def find_module_in_upgrade_action(action):
        for op in action.operations:
            if isinstance(op, AddOp):
                if op.what == Module.vtType:
                    return op.data
        return None

    def find_inputs(m):
        functions = {}
        for f in m.functions:
            if f.name not in functions:
                functions[f.name] = [f]
            else:
                functions[f.name].append(f)
        connections = {}
        for edge in pipeline.graph.iter_edges_to(m.id):
            c = pipeline.connections[edge[2]]
            if c.destination.name not in connections:
                connections[c.destination.name] = [c]
            else:
                connections[c.destination.name].append(c)
        return (functions, connections)

    def find_figure(m):
        for edge in pipeline.graph.iter_edges_from(m.id):
            to_m = pipeline.modules[edge[1]]
            if to_m.name == 'MplFigure':
                # !!! assume only a single down-stream MplFigure !!!
                # may have old or new module...
                if pipeline.connections[edge[2]].destination.name == 'addPlot':
                    return (to_m, None)
                else:
                    return (to_m, edge)
        return (None, None)

    def attach_inputs(new_module, inputs, selected_inputs):
        conns = []
        for port_name in selected_inputs:
            if port_name in inputs[0]:
                for f in inputs[0][port_name]:
                    if len(f.parameters) > 0:
                        new_param_vals, aliases = zip(*[(p.strValue, p.alias) 
                                                        for p in f.parameters])
                    else:
                        new_param_vals = []
                        aliases = []
                    new_f = controller.create_function(new_module, 
                                                       port_name,
                                                       new_param_vals,
                                                       aliases)
                    new_module.add_function(new_f)
            if port_name in inputs[1]:
                for c in inputs[1][port_name]:
                    source_module = pipeline.modules[c.source.id]
                    new_conn = create_new_connection(controller,
                                                     source_module,
                                                     c.source,
                                                     new_module,
                                                     port_name)
                    conns.append(new_conn)
        return conns

    module = pipeline.modules[module_id]
    to_properties = []
    to_axes = []
    old_figure = (None, None)
    if module.name == 'MplScatterplot':
        props_name = 'MplPathCollectionProperties'
        props_input = 'pathCollectionProperties'
        to_properties = ['facecolor']
        to_axes = ['title', 'xlabel', 'ylabel']
        inputs = find_inputs(module)
        old_loc = module.location
        old_figure = find_figure(module)
    elif module.name == 'MplHistogram':
        props_name = 'MplRectangleProperties'
        props_input = 'rectangleProperties'
        to_properties = ['facecolor']
        to_axes = ['title', 'xlabel', 'ylabel']
        inputs = find_inputs(module)
        old_loc = module.location
        old_figure = find_figure(module)

    module_remap = {'MplPlot':
                    [(None, '1.0.0', 'MplSource',
                      {'dst_port_remap': {'source': 'source',
                                          'Hide Toolbar': None},
                       'src_port_remap': {'source': 'value',
                                          'self': 'value'}})],
                    'MplFigure':
                    [(None, '1.0.0', None,
                      {'dst_port_remap': {'Script': 'addPlot'},
                       'src_port_remap': {'FigureManager': 'self',
                                          'File': 'file'}})],
                    'MplFigureCell':
                    [(None, '1.0.0', None,
                      {'dst_port_remap': {'FigureManager': 'figure'}})],
                    # we will delete parts of this but add back later
                    'MplScatterplot':
                    [(None, '1.0.0', 'MplScatter',
                      {'dst_port_remap': {'xData': 'x',
                                          'yData': 'y',
                                          'facecolor': None,
                                          'title': None,
                                          'xlabel': None,
                                          'ylabel': None,
                                          'self': 'value'},
                       'src_port_remap': {'source': 'value'}})],
                    'MplHistogram':
                    [(None, '1.0.0', 'MplHist',
                      {'dst_port_remap': {'columnData': 'x',
                                          'bins': 'bins',
                                          'facecolor': None,
                                          'title': None,
                                          'xlabel': None,
                                          'ylabel': None,
                                          'self': 'value'},
                       'src_port_remap': {'source': 'value'}})],
                }

    # '1.0.2' -> '1.0.3' changes 'self' output port to 'value'
    module_remap.setdefault('MplSource', []).append(
                (None, '1.0.3', None, {
                 'src_port_remap': {'self': 'value'}}))
    if module.name in (m.__name__ for m in _plot_modules + _artist_modules):
        module_remap.setdefault(module.name, []).append(
                (None, '1.0.3', None, {
                 'src_port_remap': {'self': 'value'}}))

    action_list = []
    if old_figure[1] is not None and \
       any(p in inputs[0] or p in inputs[1] for p in to_axes):
        # need to remove the edge between plot and figure
        pipeline.graph.delete_edge(*old_figure[1])
        conn = pipeline.connections[old_figure[1][2]]
        action = vistrails.core.db.action.create_action([('delete', conn)])
        action_list.append(action)

    normal_actions = UpgradeWorkflowHandler.remap_module(controller, module_id, 
                                                        pipeline, module_remap)
    action_list.extend(normal_actions)

    more_ops = []
    if any(p in inputs[0] or p in inputs[1] for p in to_properties):
        # create props module
        desc = reg.get_descriptor_by_name(identifier, props_name)
        props_module = \
            controller.create_module_from_descriptor(desc,
                                                     old_loc.x + 100,
                                                     old_loc.y + 100)
        more_ops.append(('add', props_module))

        # attach functions/connections
        conns = attach_inputs(props_module, inputs, to_properties)
        more_ops.extend([('add', c) for c in conns])
        
        # attach into pipeline
        new_plot_module = find_module_in_upgrade_action(normal_actions[0])
        assert new_plot_module is not None
        new_conn = create_new_connection(controller,
                                         props_module,
                                         'self',
                                         new_plot_module,
                                         props_input)
        more_ops.append(('add', new_conn))

    if any(p in inputs[0] or p in inputs[1] for p in to_axes):
        # create axes module
        desc = reg.get_descriptor_by_name(identifier, "MplAxesProperties")
        if old_figure[0] is not None:
            old_loc = old_figure[0].location
        axes_module = \
            controller.create_module_from_descriptor(desc,
                                                     old_loc.x + 100,
                                                     old_loc.y + 100)
        more_ops.append(('add', axes_module))

        # attach functions/connections
        conns = attach_inputs(axes_module, inputs, to_axes)
        more_ops.extend([('add', c) for c in conns])
        
        # attach axes properties to new figure
        if old_figure[0] is not None and old_figure[1] is not None:
            # remap figure
            fig_action = UpgradeWorkflowHandler.remap_module(controller,
                                                             old_figure[0].id,
                                                             pipeline,
                                                             module_remap)
            fig_module = find_module_in_upgrade_action(fig_action[0])
            assert fig_module is not None
            # add the removed edge back in
            pipeline.graph.add_edge(*old_figure[1])
            action_list.extend(fig_action)

            new_plot_module = find_module_in_upgrade_action(normal_actions[0])
            assert new_plot_module is not None
            conn = create_new_connection(controller,
                                         new_plot_module,
                                         'self',
                                         fig_module,
                                         'addPlot')
            action = vistrails.core.db.action.create_action([('add', conn)])
            action_list.append(action)
        else:
            fig_module = old_figure[0]
        new_conn = create_new_connection(controller,
                                         axes_module,
                                         'self',
                                         fig_module,
                                         'axesProperties')
        more_ops.append(('add', new_conn))

    return action_list
示例#36
0
    if old_module.package == 'edu.utah.sci.vistrails.sudswebservices':
        reg = vistrails.core.modules.module_registry.get_module_registry()
        new_descriptor = reg.get_descriptor_by_name(toSignature(wsdl), name,
                                                    namespace)
        if not new_descriptor:
            return []
        try:
            return UpgradeWorkflowHandler.replace_module(controller, pipeline,
                                                    module_id, new_descriptor)
        except Exception, e:
            import traceback
            traceback.print_exc()
            raise

    return UpgradeWorkflowHandler.attempt_automatic_upgrade(controller, 
                                                            pipeline,
                                                            module_id)

def handle_missing_module(controller, module_id, pipeline):
    global webServicesDict
    global package_cache

    def get_wsdl_from_namespace(m_namespace):
        try:
            wsdl = m_namespace.split("|")
            return wsdl[0]
        except:
            return None
    
    m = pipeline.modules[module_id]
    if m.package == identifier:
示例#37
0
文件: init.py 项目: hjanime/VisTrails
def handle_module_upgrade_request(controller, module_id, pipeline):
    global _remap, _controller, _pipeline

    if _remap is None:
        _remap = UpgradePackageRemap()
        remap = UpgradeModuleRemap(None,
                                   '1.0.0',
                                   '1.0.0',
                                   module_name='vtkInteractionHandler')
        remap.add_remap('src_port_remap', 'self', 'Instance')
        _remap.add_module_remap(remap)
        remap = UpgradeModuleRemap(None,
                                   '1.0.0',
                                   '1.0.0',
                                   module_name='VTKCell')
        _remap.add_module_remap(remap)
        remap = UpgradeModuleRemap(None,
                                   '1.0.0',
                                   '1.0.0',
                                   module_name='VTKViewCell',
                                   new_module='VTKCell')
        _remap.add_module_remap(remap)

    _controller = controller
    _pipeline = pipeline
    module_name = pipeline.modules[module_id].name
    module_name = module_name_remap.get(module_name, module_name)
    if not _remap.has_module_remaps(module_name):
        build_remap(module_name)

    try:
        from vistrails.packages.spreadsheet.init import upgrade_cell_to_output
    except ImportError:
        # Manually upgrade to 1.0.1
        if _remap.get_module_remaps(module_name):
            module_remap = copy.copy(_remap)
            module_remap.add_module_remap(
                UpgradeModuleRemap('1.0.0',
                                   '1.0.1',
                                   '1.0.1',
                                   module_name=module_name))
        else:
            module_remap = _remap
    else:
        module_remap = upgrade_cell_to_output(_remap,
                                              module_id,
                                              pipeline,
                                              'VTKCell',
                                              'vtkRendererOutput',
                                              '1.0.1',
                                              'AddRenderer',
                                              start_version='1.0.0')
        if _remap.get_module_remaps(module_name):
            remap = module_remap.get_module_upgrade(module_name, '1.0.0')
            if remap is None:
                # Manually upgrade to 1.0.1
                module_remap.add_module_remap(
                    UpgradeModuleRemap('1.0.0',
                                       '1.0.1',
                                       '1.0.1',
                                       module_name=module_name))

    return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
                                               module_remap)