UsersGuideVisTrailsPackages - Revision history

Remi: /* This page might be outdated */ Fixes link

2014-04-28T17:55:55Z

This page might be outdated: Fixes link

← Older revision		Revision as of 17:55, 28 April 2014
Line 1:		Line 1:
	== This page might be outdated ==		== This page might be outdated ==
	Please go to http://www.vistrails.org/usersguide/packages.html for the most recent version of this page.		Please go to http://www.vistrails.org/usersguide/v2.1/html/packages.html for the most recent version of this page.

	== Introduction ==		== Introduction ==

Emanuele at 15:58, 21 July 2011

2011-07-21T15:58:24Z

← Older revision		Revision as of 15:58, 21 July 2011
Line 1:		Line 1:
			== This page might be outdated ==
			Please go to http://www.vistrails.org/usersguide/packages.html for the most recent version of this page.

	== Introduction ==		== Introduction ==

Ctuttle: /* Adding default values and/or labels for parameters */

2011-03-31T15:24:14Z

Adding default values and/or labels for parameters

← Older revision		Revision as of 15:24, 31 March 2011
Line 224:		Line 224:
	== Adding default values and/or labels for parameters ==		== Adding default values and/or labels for parameters ==

	In versions 1.4 and greater, package developers can add labels and default values for parameters. To add this functionality, you need to use the <code>defaults</code> and <code>labels</code> ~~keyward~~ arguments and pass the values as '''strings'''. For example,		In versions 1.4 and greater, package developers can add labels and default values for parameters. To add this functionality, you need to use the <code>defaults</code> and <code>labels</code> keyword arguments and pass the values as '''strings'''. For example,

	class TestDefaults(Module):		class TestDefaults(Module):

Ctuttle: /* How to make you package reloadable */

2011-03-31T15:23:14Z

How to make you package reloadable

← Older revision		Revision as of 15:23, 31 March 2011
Line 197:		Line 197:
	[[Image:PackageCustomColorShape3.png]]		[[Image:PackageCustomColorShape3.png]]

	== How to make ~~you~~ package reloadable ==		== How to make your package reloadable ==

	You need to move almost everything in the __init__.py file to a new file "init.py", but keep the identifier, name, version, configuration, and package_dependencies fields/methods in the __init__.py file. Specifically, make sure that imports (excluding things like core.configuration) and the initialize method are in the init.py file. For example, take a look at the __init__.py file of the pylab package included in VisTrails:		You need to move almost everything in the __init__.py file to a new file "init.py", but keep the identifier, name, version, configuration, and package_dependencies fields/methods in the __init__.py file. Specifically, make sure that imports (excluding things like core.configuration) and the initialize method are in the init.py file. For example, take a look at the __init__.py file of the pylab package included in VisTrails:

Ctuttle: /* Dealing with command line tools and side effects */

2011-03-31T15:17:41Z

Dealing with command line tools and side effects

← Older revision		Revision as of 15:17, 31 March 2011
Line 21:		Line 21:
	== Dealing with command line tools and side effects ==		== Dealing with command line tools and side effects ==

	In an ideal world~~, each module would be referentially transparently. In other words,~~ a module's outputs should be completely determined by its inputs. This is important for provenance purposes - if modules have implicit dependencies, it is not possible to be certain that ~~when the process is reexecuted,~~ the same results will be generated.		In an ideal world a module's outputs should be completely determined by its inputs. This is important for provenance purposes - if modules have implicit dependencies, it is not possible to be certain that the same results will be generated when the process is reexecuted.

	However, it is clear that certain modules are inherently side-effectful (reading/writing files, network, etc). For the common case of temporary files, VisTrails provides a convenience layer that removes part of the burden of managing temporary files. As an illustrative example, consider one of the packages we make available for image conversion, using the [http://www.imagemagick.org/ ImageMagick] suite:		However, it is clear that certain modules are inherently side-effectful (reading/writing files, network, etc). For the common case of temporary files, VisTrails provides a convenience layer that removes part of the burden of managing temporary files. As an illustrative example, consider one of the packages we make available for image conversion, using the [http://www.imagemagick.org/ ImageMagick] suite:

Dakoop: /* init.py */

2010-09-21T17:28:12Z

init.py

← Older revision		Revision as of 17:28, 21 September 2010
Line 316:		Line 316:
	if "_doc" in m_dict:		if "_doc" in m_dict:
	del m_dict["_doc"]		del m_dict["_doc"]
	m_class = new_module(Module, m_name, {}, m_doc)		klass_dict = {}
			if "_compute" in m_dict:
			klass_dict["compute"] = m_dict["_compute"]
			del m_dict["_compute"]
			m_class = new_module(Module, m_name, klass_dict, m_doc)
	m_class._input_ports = expand_ports(m_inputs)		m_class._input_ports = expand_ports(m_inputs)
	m_class._output_ports = expand_ports(m_outputs)		m_class._output_ports = expand_ports(m_outputs)
Line 324:		Line 328:
	def initialize():		def initialize():
	global _modules		global _modules
			def a_compute(self):
			a = self.getInputFromPort("a")
			i = 0
			if self.hasInputFromPort("i"):
			i = self.getInputFromPort("i")
			if a == "abc":
			i += 100
			self.setResult("b", i)

	module_descs = [("ModuleA", {"_inputs": [("a", "basic:String")],		module_descs = [("ModuleA", {"_inputs": [("a", "basic:String")],
	"_outputs": [("b", "basic:Integer")],		"_outputs": [("b", "basic:Integer")],
	"_doc": "ModuleA documentation",		"_doc": "ModuleA documentation",
			"_compute": a_compute,
	"namespace": "Test"}),		"namespace": "Test"}),
	("ModuleB", {"_inputs": [("a", "Test\|ModuleA")],		("ModuleB", {"_inputs": [("a", "Test\|ModuleA")],

Dakoop at 00:04, 15 September 2010

2010-09-15T00:04:55Z

← Older revision		Revision as of 00:04, 15 September 2010
Line 240:		Line 240:
	labels=str(["temp", "name"]))		labels=str(["temp", "name"]))

			== Packages that generate modules dynamically ==

			When wrapping existing libraries or trying to generate modules in a more procedural manner, it is useful to dynamically generate modules. In our work, we have created some shortcuts to make this easier. In addition, the list of modules can also be based based on the package configuration. Here is some example code:

			=== __init__.py ===

			from core.configuration import ConfigurationObject

			identifier = "edu.utah.sci.dakoop.auto_example"
			version = "0.0.1"
			name = "AutoExample"

			configuration = ConfigurationObject(use_b=True)

			=== init.py ===

			The <code>expand_ports</code> and <code>build_modules</code> methods are functions to help the construction of the modules easier. The key parts are the <code>new_module</code> call and setting the <code>_modules</code> variable.

			from core.modules.vistrails_module import new_module, Module

			identifier = "edu.utah.sci.dakoop.auto_example"

			def expand_ports(port_list):
			new_port_list = []
			for port in port_list:
			port_spec = port[1]
			if type(port_spec) == str: # or unicode...
			if port_spec.startswith('('):
			port_spec = port_spec[1:]
			if port_spec.endswith(')'):
			port_spec = port_spec[:-1]
			new_spec_list = []
			for spec in port_spec.split(','):
			spec = spec.strip()
			parts = spec.split(':', 1)
			print 'parts:', parts
			namespace = None
			if len(parts) > 1:
			mod_parts = parts[1].rsplit('\|', 1)
			if len(mod_parts) > 1:
			namespace, module_name = mod_parts
			else:
			module_name = parts[1]
			if len(parts[0].split('.')) == 1:
			id_str = 'edu.utah.sci.vistrails.' + parts[0]
			else:
			id_str = parts[0]
			else:
			mod_parts = spec.rsplit('\|', 1)
			if len(mod_parts) > 1:
			namespace, module_name = mod_parts
			else:
			module_name = spec
			id_str = identifier
			if namespace:
			new_spec_list.append(id_str + ':' + module_name + ':' + \
			namespace)
			else:
			new_spec_list.append(id_str + ':' + module_name)
			port_spec = '(' + ','.join(new_spec_list) + ')'
			new_port_list.append((port[0], port_spec) + port[2:])
			print new_port_list
			return new_port_list

			def build_modules(module_descs):
			new_classes = {}
			for m_name, m_dict in module_descs:
			m_doc = m_dict.get("_doc", None)
			m_inputs = m_dict.get("_inputs", [])
			m_outputs = m_dict.get("_outputs", [])
			if "_inputs" in m_dict:
			del m_dict["_inputs"]
			if "_outputs" in m_dict:
			del m_dict["_outputs"]
			if "_doc" in m_dict:
			del m_dict["_doc"]
			m_class = new_module(Module, m_name, {}, m_doc)
			m_class._input_ports = expand_ports(m_inputs)
			m_class._output_ports = expand_ports(m_outputs)
			new_classes[m_name] = (m_class, m_dict)
			return new_classes.values()

			def initialize():
			global _modules
			module_descs = [("ModuleA", {"_inputs": [("a", "basic:String")],
			"_outputs": [("b", "basic:Integer")],
			"_doc": "ModuleA documentation",
			"namespace": "Test"}),
			("ModuleB", {"_inputs": [("a", "Test\|ModuleA")],
			"_outputs": [("b", "Test\|ModuleA")],
			"_doc": "ModuleB documentation"})
			]

			if configuration.use_b:
			_modules = build_modules(module_descs)
			else:
			_modules = build_modules(module_descs[:1])

			_modules = []

	== Help! This documentation wasn't good enough! ==		== Help! This documentation wasn't good enough! ==

	Sorry, it's our fault! If you need help, join the vistrails-users list and post your question there.		Sorry, it's our fault! If you need help, join the vistrails-users list and post your question there.

Dakoop at 21:34, 2 March 2010

2010-03-02T21:34:11Z

← Older revision		Revision as of 21:34, 2 March 2010
Line 221:		Line 221:

	And the init.py contains the other imports, class definitions and the initialize method.		And the init.py contains the other imports, class definitions and the initialize method.

			== Adding default values and/or labels for parameters ==

			In versions 1.4 and greater, package developers can add labels and default values for parameters. To add this functionality, you need to use the <code>defaults</code> and <code>labels</code> keyward arguments and pass the values as '''strings'''. For example,

			class TestDefaults(Module):
			_input_ports = [("f1", "(edu.utah.sci.vistrails.basic:Float)",
			{"defaults": str([1.23]), "labels": str(["temp"])})]
			_modules = [TestDefaults]

			or in the older syntax,

			def initialize():
			reg = core.modules.module_registry.get_module_registry()
			reg.add_module(TestDefaults2)
			reg.add_input_port(TestDefaults2, "f2", [Float, String],
			defaults=str([4.56, "abc"]),
			labels=str(["temp", "name"]))



	== Help! This documentation wasn't good enough! ==		== Help! This documentation wasn't good enough! ==

	Sorry, it's our fault! If you need help~~, email cscheid@sci.utah.edu, or, preferably~~, join the vistrails-users list.		Sorry, it's our fault! If you need help, join the vistrails-users list and post your question there.

Emanuele at 03:27, 26 February 2010

2010-02-26T03:27:36Z

← Older revision		Revision as of 03:27, 26 February 2010
Line 196:		Line 196:

	[[Image:PackageCustomColorShape3.png]]		[[Image:PackageCustomColorShape3.png]]

			== How to make you package reloadable ==

			You need to move almost everything in the __init__.py file to a new file "init.py", but keep the identifier, name, version, configuration, and package_dependencies fields/methods in the __init__.py file. Specifically, make sure that imports (excluding things like core.configuration) and the initialize method are in the init.py file. For example, take a look at the __init__.py file of the pylab package included in VisTrails:

			identifier = 'edu.utah.sci.vistrails.matplotlib'
			name = 'matplotlib'
			version = '0.9.0'

			def package_dependencies():
			import core.packagemanager
			manager = core.packagemanager.get_package_manager()
			if manager.has_package('edu.utah.sci.vistrails.spreadsheet'):
			return ['edu.utah.sci.vistrails.spreadsheet']
			else:
			return []

			def package_requirements():
			import core.requirements
			if not core.requirements.python_module_exists('matplotlib'):
			raise core.requirements.MissingRequirement('matplotlib')
			if not core.requirements.python_module_exists('pylab'):
			raise core.requirements.MissingRequirement('pylab')

			And the init.py contains the other imports, class definitions and the initialize method.

	== Help! This documentation wasn't good enough! ==		== Help! This documentation wasn't good enough! ==

	Sorry, it's our fault! If you need help, email cscheid@sci.utah.edu, or, preferably, join the vistrails-users list.		Sorry, it's our fault! If you need help, email cscheid@sci.utah.edu, or, preferably, join the vistrails-users list.

Juliana: /* Introduction */

2007-05-16T20:28:28Z

Introduction

← Older revision		Revision as of 20:28, 16 May 2007
Line 1:		Line 1:
	== Introduction ==		== Introduction ==

	VisTrails provides infrastructure ~~for~~ user-defined ~~functionality ("wrappers") to be incorporated into the main program~~. Specifically, users can incorporate their own visualization and simulation codes into pipelines by defining custom modules. These modules are bundled in what we call '''packages'''. A VisTrails package is simply a collection of Python classes -- each of these classes will represent a new module -- created by the user that respects a certain convention. Here's a simplified example of a very simple user-defined module:		VisTrails provides a plugin infrastructure to integrate user-defined
			functions and libraries. Specifically, users can incorporate their own visualization and simulation codes into pipelines by defining custom modules (or wrappers). These modules are bundled in what we call '''packages'''. A VisTrails package is simply a collection of Python classes -- each of these classes will represent a new module -- created by the user that respects a certain convention. Here's a simplified example of a very simple user-defined module:

	class Divide(Module):		class Divide(Module):