def from_workflow_step( Class, trans, step ):
tool_id = step.tool_id
if trans.app.toolbox and tool_id not in trans.app.toolbox.tools_by_id:
# See if we have access to a different version of the tool.
# TODO: If workflows are ever enhanced to use tool version
# in addition to tool id, enhance the selection process here
# to retrieve the correct version of the tool.
tool_version = Class.__get_tool_version( trans, tool_id )
if tool_version:
tool_version_ids = tool_version.get_version_ids( trans.app )
for tool_version_id in tool_version_ids:
if tool_version_id in trans.app.toolbox.tools_by_id:
tool_id = tool_version_id
break
if ( trans.app.toolbox and tool_id in trans.app.toolbox.tools_by_id ):
module = Class( trans, tool_id )
module.state = DefaultToolState()
module.state.inputs = module.tool.params_from_strings( step.tool_inputs, trans.app, ignore_errors=True )
module.errors = step.tool_errors
# module.post_job_actions = step.post_job_actions
module.workflow_outputs = step.workflow_outputs
pjadict = {}
for pja in step.post_job_actions:
pjadict[pja.action_type] = pja
module.post_job_actions = pjadict
return module
return None
def from_dict(Class, trans, d):
tool_id = d['tool_id']
module = Class(trans, tool_id)
module.state = DefaultToolState()
module.state.decode(d["tool_state"], module.tool, module.trans.app)
module.errors = d.get("tool_errors", None)
return module
def from_dict( Class, trans, repository_id, changeset_revision, step_dict, tools_metadata, secure=True ):
tool_id = step_dict[ 'tool_id' ]
module = Class( trans, repository_id, changeset_revision, tools_metadata, tool_id )
module.state = DefaultToolState()
if module.tool is not None:
module.state.decode( step_dict[ "tool_state" ], module.tool, module.trans.app, secure=secure )
module.errors = step_dict.get( "tool_errors", None )
return module
def from_workflow_step(Class, trans, step):
tool_id = step.tool_id
module = Class(trans, tool_id)
module.state = DefaultToolState()
module.state.inputs = module.tool.params_from_strings(
step.tool_inputs, trans.app, ignore_errors=True)
module.errors = step.tool_errors
return module
def from_workflow_step( Class, trans, repository_id, changeset_revision, tools_metadata, step ):
module = Class( trans, repository_id, changeset_revision, tools_metadata, step.tool_id )
module.state = DefaultToolState()
if module.tool:
module.state.inputs = module.tool.params_from_strings( step.tool_inputs, trans.app, ignore_errors=True )
else:
module.state.inputs = {}
module.errors = step.tool_errors
return module
def from_dict( Class, trans, d, secure=True ):
tool_id = d[ 'tool_id' ]
module = Class( trans, tool_id )
module.state = DefaultToolState()
if module.tool is not None:
module.state.decode( d[ "tool_state" ], module.tool, module.trans.app, secure=secure )
module.errors = d.get( "tool_errors", None )
module.post_job_actions = d.get( "post_job_actions", {} )
module.workflow_outputs = d.get( "workflow_outputs", [] )
return module
def recover_state( self, state, **kwds ):
""" Recover state `dict` from simple dictionary describing configuration
state (potentially from persisted step state).
Sub-classes should supply a `default_state` method which contains the
initial state `dict` with key, value pairs for all available attributes.
"""
self.state = DefaultToolState()
inputs = self.get_inputs()
if inputs:
self.state.decode( state, Bunch( inputs=inputs ), self.trans.app )
else:
self.state.inputs = safe_loads( state ) or {}
def decode_runtime_state( self, trans, string ):
fake_tool = Bunch( inputs = self.get_runtime_inputs() )
state = DefaultToolState()
state.decode( string, fake_tool, trans.app )
return state
def get_runtime_state( self ):
state = DefaultToolState()
state.inputs = dict( input=None )
return state
def __inputs_to_state(self, inputs):
tool_state = DefaultToolState()
tool_state.inputs = inputs
return tool_state
def __string_to_state(self, state_string):
encoded_state = string_to_object(state_string)
state = DefaultToolState()
state.decode(encoded_state, self.tool, self.app)
return state
def upload_async_create(self, trans, tool_id=None, **kwd):
"""
Precreate datasets for asynchronous uploading.
"""
cntrller = kwd.get('cntrller', '')
roles = kwd.get('roles', False)
if roles:
# The user associated the DATASET_ACCESS permission on the uploaded datasets with 1 or more roles.
# We need to ensure that the roles are legitimately derived from the roles associated with the LIBRARY_ACCESS
# permission if the library is not public ( this should always be the case since any ill-legitimate roles
# were filtered out of the roles displayed on the upload form. In addition, we need to ensure that the user
# did not associated roles that would make the dataset in-accessible by everyone.
library_id = trans.app.security.decode_id(kwd.get(
'library_id', ''))
vars = dict(DATASET_ACCESS_in=roles)
permissions, in_roles, error, msg = trans.app.security_agent.derive_roles_from_access(
trans, library_id, cntrller, library=True, **vars)
if error:
return ['error', msg]
def create_dataset(name):
ud = Bunch(name=name, file_type=None, dbkey=None)
if nonfile_params.get('folder_id', False):
replace_id = nonfile_params.get('replace_id', None)
if replace_id not in [None, 'None']:
replace_dataset = trans.sa_session.query(
trans.app.model.LibraryDataset).get(
trans.security.decode_id(replace_id))
else:
replace_dataset = None
# FIXME: instead of passing params here ( chiech have been process by util.Params(), the original kwd
# should be passed so that complex objects that may have been included in the initial request remain.
library_bunch = upload_common.handle_library_params(
trans, nonfile_params, nonfile_params.folder_id,
replace_dataset)
else:
library_bunch = None
return upload_common.new_upload(
trans,
cntrller,
ud,
library_bunch=library_bunch,
state=trans.app.model.HistoryDatasetAssociation.states.UPLOAD)
tool = self.get_toolbox().get_tool(tool_id)
if not tool:
return False # bad tool_id
nonfile_params = galaxy.util.Params(kwd, sanitize=False)
if kwd.get('tool_state', None) not in (None, 'None'):
encoded_state = galaxy.util.string_to_object(kwd["tool_state"])
tool_state = DefaultToolState()
tool_state.decode(encoded_state, tool, trans.app)
else:
tool_state = tool.new_state(trans)
tool.update_state(trans,
tool.inputs,
tool_state.inputs,
kwd,
update_only=True)
datasets = []
dataset_upload_inputs = []
for input_name, input in tool.inputs.iteritems():
if input.type == "upload_dataset":
dataset_upload_inputs.append(input)
assert dataset_upload_inputs, Exception(
"No dataset upload groups were found.")
for dataset_upload_input in dataset_upload_inputs:
d_type = dataset_upload_input.get_datatype(trans, kwd)
if d_type.composite_type is not None:
datasets.append(
create_dataset(
dataset_upload_input.get_composite_dataset_name(kwd)))
else:
params = Bunch(
**tool_state.inputs[dataset_upload_input.name][0])
if params.file_data not in [None, ""]:
name = params.file_data
if name.count('/'):
name = name.rsplit('/', 1)[1]
if name.count('\\'):
name = name.rsplit('\\', 1)[1]
datasets.append(create_dataset(name))
if params.url_paste not in [None, ""]:
url_paste = params.url_paste.replace('\r', '').split('\n')
url = False
for line in url_paste:
line = line.rstrip('\r\n').strip()
if not line:
continue
elif line.lower().startswith('http://') or line.lower(
).startswith('ftp://') or line.lower().startswith(
'https://'):
url = True
datasets.append(create_dataset(line))
else:
if url:
continue # non-url when we've already processed some urls
else:
# pasted data
datasets.append(create_dataset('Pasted Entry'))
break
return [d.id for d in datasets]
def upload_async_create(self, trans, tool_id=None, **kwd):
"""
Precreate datasets for asynchronous uploading.
"""
permissions = trans.app.security_agent.history_get_default_permissions(
trans.history)
def create_dataset(name):
ud = Bunch(name=name, file_type=None, dbkey=None)
if nonfile_params.get('folder_id', False):
replace_id = nonfile_params.get('replace_id', None)
if replace_id not in [None, 'None']:
replace_dataset = trans.sa_session.query(
l.LibraryDataset).get(int(replace_id))
else:
replace_dataset = None
library_bunch = upload_common.handle_library_params(
trans, nonfile_params, nonfile_params.folder_id,
replace_dataset)
else:
library_bunch = None
return upload_common.new_upload(
trans,
ud,
library_bunch=library_bunch,
state=trans.app.model.HistoryDatasetAssociation.states.UPLOAD)
tool = self.get_toolbox().tools_by_id.get(tool_id, None)
if not tool:
return False # bad tool_id
nonfile_params = util.Params(kwd, sanitize=False)
if kwd.get('tool_state', None) not in (None, 'None'):
encoded_state = util.string_to_object(kwd["tool_state"])
tool_state = DefaultToolState()
tool_state.decode(encoded_state, tool, trans.app)
else:
tool_state = tool.new_state(trans)
errors = tool.update_state(trans,
tool.inputs,
tool_state.inputs,
kwd,
update_only=True)
datasets = []
dataset_upload_inputs = []
for input_name, input in tool.inputs.iteritems():
if input.type == "upload_dataset":
dataset_upload_inputs.append(input)
assert dataset_upload_inputs, Exception(
"No dataset upload groups were found.")
for dataset_upload_input in dataset_upload_inputs:
d_type = dataset_upload_input.get_datatype(trans, kwd)
if d_type.composite_type is not None:
datasets.append(
create_dataset(
'Uploaded Composite Dataset (%s)' %
dataset_upload_input.get_datatype_ext(trans, kwd)))
else:
params = Bunch(
**tool_state.inputs[dataset_upload_input.name][0])
if params.file_data not in [None, ""]:
name = params.file_data
if name.count('/'):
name = name.rsplit('/', 1)[1]
if name.count('\\'):
name = name.rsplit('\\', 1)[1]
datasets.append(create_dataset(name))
if params.url_paste not in [None, ""]:
url_paste = params.url_paste.replace('\r', '').split('\n')
url = False
for line in url_paste:
line = line.rstrip('\r\n').strip()
if not line:
continue
elif line.lower().startswith('http://') or line.lower(
).startswith('ftp://'):
url = True
datasets.append(create_dataset(line))
else:
if url:
continue # non-url when we've already processed some urls
else:
# pasted data
datasets.append(create_dataset('Pasted Entry'))
break
return [d.id for d in datasets]
def get_runtime_state( self ):
state = DefaultToolState()
state.inputs = self.state.inputs
return state
def __init__( self, trans, content_id=None, **kwds ):
self.trans = trans
self.content_id = content_id
self.state = DefaultToolState()
def decode_runtime_state( self, runtime_state ):
""" Takes the serialized runtime state and decodes it when running the workflow. """
state = DefaultToolState()
state.decode( runtime_state, Bunch( inputs=self.get_runtime_inputs() ), self.trans.app )
return state