Package: cwltool
PyPI:Conda:Debian:Quay.io (Docker):This is the reference implementation of theCommon Workflow Language open
standards.  It is intended to be feature complete
and provide comprehensive validation of CWL
files as well as provide other tools related to working with CWL.cwltoolis written and tested forPython3.x {x = 6, 8, 9, 10, 11}The reference implementation consists of two packages.  Thecwltoolpackage
is the primary Python module containing the reference implementation in thecwltoolmodule and console executable by the same name.Thecwlref-runnerpackage is optional and provides an additional entry point
under the aliascwl-runner, which is the implementation-agnostic name for the
default CWL interpreter installed on a host.cwltoolis provided by the CWL project,a member project of Software Freedom Conservancyand ourmany contributors.Table of ContentsInstallcwltoolpackagesMS Windows userscwltooldevelopment versionRecommended SoftwareRun on the command lineUse with boot2docker on macOSUsing uDockerUsing SingularityRunning a tool or workflow from remote or local locationsOverriding workflow requirements at load timeCombining parts of a workflow into a single documentRunning only part of a workflowVisualizing a CWL documentModeling a CWL document as RDFEnvironment Variables in cwltoolLeveraging SoftwareRequirements (Beta)Use with GA4GH Tool Registry APIRunning MPI-based tools that need to be launchedEnabling Fast Parser (experimental)DevelopmentRunning tests locallyImport as a moduleCWL Tool Control FlowExtension pointsInstallcwltoolpackagesYour operating system may offer cwltool directly. ForDebian,Ubuntu,
and similar Linux distribution trysudoapt-getinstallcwltoolIf you encounter an error, first try to update package information by usingsudoapt-getupdateIf you are running macOS X or other UNIXes and you want to use packages prepared by the conda-forge project, then
please follow the install instructions forconda-forge(if you haven’t already) and thencondainstall-cconda-forgecwltoolAll of the above methods of installingcwltooluse packages that might contain bugs already fixed in newer versions or be missing desired features.
If the packaged version ofcwltoolavailable to you is too old, then we recommend installing usingpipandvenvpython3-mvenvenv# Create a virtual environment named 'env' in the current directorysourceenv/bin/activate# Activate environment before installing `cwltool`Then install the latestcwlref-runnerpackage from PyPi (which will install the latestcwltoolpackage as
well)pipinstallcwlref-runnerIf installing alongside another CWL implementation (liketoil-cwl-runnerorarvados-cwl-runner) then instead runpipinstallcwltoolMS Windows usersInstall Windows Subsystem for Linux 2 and Docker Desktop.Install Debian from the Microsoft Store.Set Debian as your default WSL 2 distro:wsl--set-defaultdebian.Return to the Docker Desktop, chooseSettings→Resources→WSL Integrationand under “Enable integration with additional distros” select “Debian”,Reboot if you have not yet already.Launch Debian and follow the Linux instructions above (apt-getinstall cwltoolor use thevenvmethod)Network problems from within WSL2? Trythese instructionsfollowed bywsl--shutdown.cwltooldevelopment versionOr you can skip the directpipcommands above and install the latest development version ofcwltool:gitclonehttps://github.com/common-workflow-language/cwltool.git# clone (copy) the cwltool git repositorycdcwltool# Change to source directory that git clone just downloadedpipinstall.[deps]# Installs ``cwltool`` from sourcecwltool--version# Check if the installation works correctlyRemember, if co-installing multiple CWL implementations, then you need to
maintain which implementationcwl-runnerpoints to via a symbolic file
system link oranother facility.Recommended SoftwareWe strongly suggested to have the following installed:One of the following software container enginesPodmanDockerSingularity/Apptainer: SeeUsing Singularityudocker: SeeUsing uDockernode.jsfor evaluating CWL Expressions quickly
(required forudockerusers, optional but recommended for the other container engines).Without these, some examples in the CWL tutorials athttp://www.commonwl.org/user_guide/may not work.Run on the command lineSimple command:cwl-runner my_workflow.cwl my_inputs.yamlOr if you have multiple CWL implementations installed and you want to override
the default cwl-runner then use:cwltool my_workflow.cwl my_inputs.ymlYou can set cwltool options in the environment withCWLTOOL_OPTIONS,
these will be inserted at the beginning of the command line:export CWLTOOL_OPTIONS="--debug"Use with boot2docker on macOSboot2docker runs Docker inside a virtual machine, and it only mountsUserson it. The default behavior of CWL is to create temporary directories under e.g./Varwhich is not accessible to Docker containers.To run CWL successfully with boot2docker you need to set the--tmpdir-prefixand--tmp-outdir-prefixto somewhere under/Users:$ cwl-runner --tmp-outdir-prefix=/Users/username/project --tmpdir-prefix=/Users/username/project wc-tool.cwl wc-job.jsonUsing uDockerSome shared computing environments don’t support Docker software containers for technical or policy reasons.
As a workaround, the CWL reference runner supports using theudockerprogram on Linux using--udocker.udocker installation:https://indigo-dc.github.io/udocker/installation_manual.htmlRuncwltooljust as you usually would, but with--udockerprior to the workflow path:cwltool--udockerhttps://github.com/common-workflow-language/common-workflow-language/raw/main/v1.0/v1.0/test-cwl-out2.cwlhttps://github.com/common-workflow-language/common-workflow-language/raw/main/v1.0/v1.0/empty.jsonAs was mentioned in theRecommended Softwaresection,Using Singularitycwltoolcan also useSingularityversion 2.6.1
or later as a Docker container runtime.cwltoolwith Singularity will run software containers specified inDockerRequirementand therefore works with Docker images only, native
Singularity images are not supported. To use Singularity as the Docker container
runtime, provide--singularitycommand line option tocwltool.
With Singularity,cwltoolcan pass all CWL v1.0 conformance tests, except
those involving Docker container ENTRYPOINTs.Examplecwltool--singularityhttps://github.com/common-workflow-language/common-workflow-language/raw/main/v1.0/v1.0/cat3-tool-mediumcut.cwlhttps://github.com/common-workflow-language/common-workflow-language/raw/main/v1.0/v1.0/cat-job.jsonRunning a tool or workflow from remote or local locationscwltoolcan run tool and workflow descriptions on both local and remote
systems via its support for HTTP[S] URLs.Input job files and Workflow steps (via therundirective) can reference CWL
documents using absolute or relative local filesystem paths. If a relative path
is referenced and that document isn’t found in the current directory, then the
following locations will be searched:http://www.commonwl.org/v1.0/CommandLineTool.html#Discovering_CWL_documents_on_a_local_filesystemYou can also usecwldepto manage dependencies on external tools and workflows.Overriding workflow requirements at load timeSometimes a workflow needs additional requirements to run in a particular
environment or with a particular dataset.  To avoid the need to modify the
underlying workflow, cwltool supports requirement “overrides”.The format of the “overrides” object is a mapping of item identifier (workflow,
workflow step, or command line tool) to the process requirements that should be applied.cwltool:overrides:echo.cwl:requirements:EnvVarRequirement:envDef:MESSAGE:override_valueOverrides can be specified either on the command line, or as part of the job
input document.  Workflow steps are identified using the name of the workflow
file followed by the step name as a document fragment identifier “#id”.
Override identifiers are relative to the top-level workflow document.cwltool--overridesoverrides.ymlmy-tool.cwlmy-job.ymlinput_parameter1:value1input_parameter2:value2cwltool:overrides:workflow.cwl#step1:requirements:EnvVarRequirement:envDef:MESSAGE:override_valuecwltoolmy-tool.cwlmy-job-with-overrides.ymlCombining parts of a workflow into a single documentUse--packto combine a workflow made up of multiple files into a
single compound document.  This operation takes all the CWL files
referenced by a workflow and builds a new CWL document with all
Process objects (CommandLineTool and Workflow) in a list in the$graphfield.  Cross references (such asrun:andsource:fields) are updated to internal references within the new packed
document.  The top-level workflow is named#main.cwltool--packmy-wf.cwl>my-packed-wf.cwlRunning only part of a workflowYou can run a partial workflow with the--target(-t) option.  This
takes the name of an output parameter, workflow step, or input
parameter in the top-level workflow.  You may provide multiple
targets.cwltool--targetstep3my-wf.cwlIf a target is an output parameter, it will only run only the steps
that contribute to that output.  If a target is a workflow step, it
will run the workflow starting from that step.  If a target is an
input parameter, it will only run the steps connected to
that input.Use--print-targetsto get a listing of the targets of a workflow.
To see which steps will run, use--print-subgraphwith--targetto get a printout of the workflow subgraph for the
selected targets.cwltool--print-targetsmy-wf.cwlcwltool--targetstep3--print-subgraphmy-wf.cwl>my-wf-starting-from-step3.cwlVisualizing a CWL documentThe--print-dotoption will print a file suitable for Graphvizdotprogram.  Here is a bash onliner to generate a Scalable Vector Graphic (SVG) file:cwltool--print-dotmy-wf.cwl|dot-Tsvg>my-wf.svgModeling a CWL document as RDFCWL documents can be expressed as RDF triple graphs.cwltool--print-rdf--rdf-serializer=turtlemywf.cwlEnvironment Variables in cwltoolThis reference implementation supports several ways of setting
environment variables for tools, in addition to the standardEnvVarRequirement. The sequence of steps applied to create the
environment is:If the--preserve-entire-environmentflag is present, then begin with the current
environment, else begin with an empty environment.Add any variables specified by--preserve-environmentoption(s).SetTMPDIRandHOMEperthe CWL v1.0+ CommandLineTool specification.Apply anyEnvVarRequirementfrom theCommandLineTooldescription.Apply any manipulations required by anycwltool:MPIRequirementextensions.Substitute any secrets required bySecretsextension.Modify the environment in response toSoftwareRequirement(see below).Leveraging SoftwareRequirements (Beta)CWL tools may be decorated withSoftwareRequirementhints that cwltool
may in turn use to resolve to packages in various package managers or
dependency management systems such asEnvironment Modules.UtilizingSoftwareRequirementhints using cwltool requires an optional
dependency, for this reason be sure to use specify thedepsmodifier when
installing cwltool. For instance:$ pip install 'cwltool[deps]'Installing cwltool in this fashion enables several new command line options.
The most general of these options is--beta-dependency-resolvers-configuration.
This option allows one to specify a dependency resolver’s configuration file.
This file may be specified as either XML or YAML and very simply describes various
plugins to enable to “resolve”SoftwareRequirementdependencies.Using these hints will allow cwltool to modify the environment in
which your tool runs, for example by loading one or more Environment
Modules. The environment is constructed as above, then the environment
may modified by the selected tool resolver.  This currently means that
you cannot override any environment variables set by the selected tool
resolver. Note that the environment given to the configured dependency
resolver has the variable_CWLTOOLset to1to allow introspection.To discuss some of these plugins and how to configure them, first consider the
followinghintdefinition for an example CWL tool.SoftwareRequirement:packages:-package:seqtkversion:-r93Now imagine deploying cwltool on a cluster with Software Modules installed
and that aseqtkmodule is available at versionr93. This means cluster
users likely won’t have the binaryseqtkon theirPATHby default, but after
sourcing this module with the commandmodulecmd sh load seqtk/r93seqtkis
available on thePATH. A simple dependency resolvers configuration file, calleddependency-resolvers-conf.ymlfor instance, that would enable cwltool to source
the correct module environment before executing the above tool would simply be:-type:modulesThe outer list indicates that one plugin is being enabled, the plugin parameters are
defined as a dictionary for this one list item. There is only one required parameter
for the plugin above, this istypeand defines the plugin type. This parameter
is required for all plugins. The available plugins and the parameters
available for each are documented (incompletely)here.
Unfortunately, this documentation is in the context of Galaxy toolrequirements instead of CWLSoftwareRequirements, but the concepts map fairly directly.cwltool is distributed with an example of such seqtk tool and sample corresponding
job. It could executed from the cwltool root using a dependency resolvers
configuration file such as the above one using the command:cwltool --beta-dependency-resolvers-configuration /path/to/dependency-resolvers-conf.yml \
    tests/seqtk_seq.cwl \
    tests/seqtk_seq_job.jsonThis example demonstrates both that cwltool can leverage
existing software installations and also handle workflows with dependencies
on different versions of the same software and libraries. However the above
example does require an existing module setup so it is impossible to test this example
“out of the box” with cwltool. For a more isolated test that demonstrates all
the same concepts - the resolver plugin typegalaxy_packagescan be used.“Galaxy packages” are a lighter-weight alternative to Environment Modules that are
really just defined by a way to lay out directories into packages and versions
to find little scripts that are sourced to modify the environment. They have
been used for years in Galaxy community to adapt Galaxy tools to cluster
environments but require neither knowledge of Galaxy nor any special tools to
setup. These should work just fine for CWL tools.The cwltool source code repository’s test directory is setup with a very simple
directory that defines a set of “Galaxy  packages” (but really just defines one
package namedrandom-lines). The directory layout is simply:tests/test_deps_env/
  random-lines/
    1.0/
      env.shIf thegalaxy_packagesplugin is enabled and pointed at thetests/test_deps_envdirectory in cwltool’s root and aSoftwareRequirementsuch as the following is encountered.hints:SoftwareRequirement:packages:-package:'random-lines'version:-'1.0'Then cwltool will simply find thatenv.shfile and source it before executing
the corresponding tool. Thatenv.shscript is only responsible for modifying
the job’sPATHto add the required binaries.This is a full example that works since resolving “Galaxy packages” has no
external requirements. Try it out by executing the following command from cwltool’s
root directory:cwltool --beta-dependency-resolvers-configuration tests/test_deps_env_resolvers_conf.yml \
    tests/random_lines.cwl \
    tests/random_lines_job.jsonThe resolvers configuration file in the above example was simply:-type:galaxy_packagesbase_path:./tests/test_deps_envIt is possible that theSoftwareRequirements in a given CWL tool will not
match the module names for a given cluster. Such requirements can be re-mapped
to specific deployed packages or versions using another file specified using
the resolver plugin parametermapping_files. We will
demonstrate this usinggalaxy_packages,but the concepts apply equally well
to Environment Modules or Conda packages (described below), for instance.So consider the resolvers configuration file.
(tests/test_deps_env_resolvers_conf_rewrite.yml):-type:galaxy_packagesbase_path:./tests/test_deps_envmapping_files:./tests/test_deps_mapping.ymlAnd the corresponding mapping configuration file (tests/test_deps_mapping.yml):-from:name:randomLinesversion:1.0.0-rc1to:name:random-linesversion:'1.0'This is saying if cwltool encounters a requirement ofrandomLinesat version1.0.0-rc1in a tool, to rewrite to our specific plugin asrandom-linesat
version1.0. cwltool has such a test tool calledrandom_lines_mapping.cwlthat contains such a sourceSoftwareRequirement. To try out this example with
mapping, execute the following command from the cwltool root directory:cwltool --beta-dependency-resolvers-configuration tests/test_deps_env_resolvers_conf_rewrite.yml \
    tests/random_lines_mapping.cwl \
    tests/random_lines_job.jsonThe previous examples demonstrated leveraging existing infrastructure to
provide requirements for CWL tools. If instead a real package manager is used
cwltool has the opportunity to install requirements as needed. While initial
support for Homebrew/Linuxbrew plugins is available, the most developed such
plugin is for theCondapackage manager. Conda has the nice properties
of allowing multiple versions of a package to be installed simultaneously,
not requiring evaluated permissions to install Conda itself or packages using
Conda, and being cross-platform. For these reasons, cwltool may run as a normal
user, install its own Conda environment and manage multiple versions of Conda packages
on Linux and Mac OS X.The Conda plugin can be endlessly configured, but a sensible set of defaults
that has proven a powerful stack for dependency management within the Galaxy tool
development ecosystem can be enabled by simply passing cwltool the--beta-conda-dependenciesflag.With this, we can use the seqtk example above without Docker or any externally managed services - cwltool should install everything it needs
and create an environment for the tool. Try it out with the following command:cwltool --beta-conda-dependencies tests/seqtk_seq.cwl tests/seqtk_seq_job.jsonThe CWL specification allows URIs to be attached toSoftwareRequirements
that allow disambiguation of package names. If the mapping files described above
allow deployers to adapt tools to their infrastructure, this mechanism allows
tools to adapt their requirements to multiple package managers. To demonstrate
this within the context of the seqtk, we can simply break the package name we
use and then specify a specific Conda package as follows:hints:SoftwareRequirement:packages:-package:seqtk_seqversion:-'1.2'specs:-https://anaconda.org/bioconda/seqtk-https://packages.debian.org/sid/seqtkThe example can be executed using the command:cwltool --beta-conda-dependencies tests/seqtk_seq_wrong_name.cwl tests/seqtk_seq_job.jsonThe plugin framework for managing the resolution of these software requirements
as maintained as part ofgalaxy-tool-util- a small,
portable subset of the Galaxy project. More information on configuration and implementation can be found
at the following links:Dependency Resolvers in GalaxyConda for [Galaxy] Tool DependenciesMapping Files - ImplementationSpecifications - ImplementationInitial cwltool Integration Pull RequestUse with GA4GH Tool Registry APICwltool can launch tools directly fromGA4GH Tool Registry APIendpoints.By default, cwltool searcheshttps://dockstore.org/.  Use--add-tool-registryto add other registries to the search path.For examplecwltool quay.io/collaboratory/dockstore-tool-bamstats:develop test.jsonand (defaults to latest when a version is not specified)cwltool quay.io/collaboratory/dockstore-tool-bamstats test.jsonFor this example, grab the test.json (and input file) fromhttps://github.com/CancerCollaboratory/dockstore-tool-bamstatswget https://dockstore.org/api/api/ga4gh/v2/tools/quay.io%2Fbriandoconnor%2Fdockstore-tool-bamstats/versions/develop/PLAIN-CWL/descriptor/test.json
wget https://github.com/CancerCollaboratory/dockstore-tool-bamstats/raw/develop/rna.SRR948778.bamRunning MPI-based tools that need to be launchedCwltool supports an extension to the CWL spechttp://commonwl.org/cwltool#MPIRequirement. When the tool
definition has this in itsrequirements/hintssection, and
cwltool has been run with--enable-ext, then the tool’s command
line will be extended with the commands needed to launch it withmpirunor similar. You can specify the number of processes to
start as either a literal integer or an expression (that will result
in an integer). For example:#!/usr/bin/env cwl-runner
cwlVersion: v1.1
class: CommandLineTool
$namespaces:
  cwltool: "http://commonwl.org/cwltool#"
requirements:
  cwltool:MPIRequirement:
    processes: $(inputs.nproc)
inputs:
  nproc:
    type: intInteraction with containers: the MPIRequirement currently prepends its
commands to the front of the command line that is constructed. If you
wish to run a containerized application in parallel, for simple use
cases, this does work with Singularity, depending upon the platform
setup. However, this combination should be considered “alpha” – please
do report any issues you have! This does not work with Docker at the
moment. (More precisely, you getncopies of the same single process
image run at the same time that cannot communicate with each other.)The host-specific parameters are configured in a simple YAML file
(specified with the--mpi-config-fileflag). The allowed keys are
given in the following table; all are optional.KeyTypeDefaultDescriptionrunnerstr“mpirun”The primary command to use.nproc_flagstr“-n”Flag to set number of
processes to start.default_nprocint1Default number of processes.extra_flagsList[str][]A list of any other flags to
be added to the runner’s
command line before
thebaseCommand.env_passList[str][]A list of environment
variables that should be
passed from the host
environment through to the
tool (e.g., giving the
node list as set by your
scheduler).env_pass_regexList[str][]A list of python regular
expressions that will be
matched against the host’s
environment. Those that match
will be passed through.env_setMapping[str,str]{}A dictionary whose keys are
the environment variables set
and the values being the
values.Enabling Fast Parser (experimental)For very large workflows,cwltoolcan spend a lot of time in
initialization, before the first step runs.  There is an experimental
flag--fast-parserwhich can dramatically reduce the
initialization overhead, however as of this writing it has several limitations:Error reporting in general is worse than the standard parser, you will want to use it with workflows that you know are already correct.It does not check for dangling links (these will become runtime errors instead of loading errors)Several other cases fail, as documented inhttps://github.com/common-workflow-language/cwltool/pull/1720DevelopmentRunning tests locallyRunning basic tests(/tests):To run the basic tests after installingcwltoolexecute the following:pipinstall-rtest-requirements.txtpytest## N.B. This requires node.js or docker to be availableTo run various tests in all supported Python environments, we usetox. To run the test suite in all supported Python environments
first clone the complete code repository (see thegit cloneinstructions above) and then run
the following in the terminal:pip install "tox<4"; tox-pList of all environment can be seen using:tox--listenvsand running a specific test env using:tox-e<env name>and additionally run a specific test using this format:tox-epy310-unit---vtests/test_examples.py::test_scandepsRunning the entire suite of CWL conformance tests:The GitHub repository for the CWL specifications contains a script that tests a CWL
implementation against a wide array of valid CWL files using thecwltestprogramInstructions for running these tests can be found in the Common Workflow Language Specification repository athttps://github.com/common-workflow-language/common-workflow-language/blob/main/CONFORMANCE_TESTS.md.Import as a moduleAddimportcwltoolto your script.The easiest way to use cwltool to run a tool or workflow from Python is to use a Factoryimportcwltool.factoryfac=cwltool.factory.Factory()echo=fac.make("echo.cwl")result=echo(inp="foo")# result["out"] == "foo"CWL Tool Control FlowTechnical outline of how cwltool works internally, for maintainers.Use CWLload_tool()to load document.Fetches the document from file or URLApplies preprocessing (syntax/identifier expansion and normalization)Validates the document based on cwlVersionIf necessary, updates the document to the latest specConstructs a Process object usingmake_tool()`callback.  This yields a
CommandLineTool, Workflow, or ExpressionTool.  For workflows, this
recursively constructs each workflow step.To construct custom types for CommandLineTool, Workflow, or
ExpressionTool, provide a custommake_tool()Iterate on thejob()method of the Process object to get back runnable jobs.job()is a generator method (uses the Python iterator protocol)Each time thejob()method is invoked in an iteration, it returns one
of: a runnable item (an object with arun()method),None(indicating
there is currently no work ready to run) or end of iteration (indicating
the process is complete.)Invoke the runnable item by callingrun().  This runs the tool and gets output.An output callback reports the output of a process.job()may be iterated over multiple times.  It will yield all the work
that is currently ready to run and then yield None.Workflowobjects create a correspondingWorkflowJobandWorkflowJobStepobjects to hold the workflow state for the duration of the job invocation.The WorkflowJob iterates over each WorkflowJobStep and determines if the
inputs the step are ready.When a step is ready, it constructs an input object for that step and
iterates on thejob()method of the workflow job step.Each runnable item is yielded back up to top-level run loopWhen a step job completes and receives an output callback, the
job outputs are assigned to the output of the workflow step.When all steps are complete, the intermediate files are moved to a final
workflow output, intermediate directories are deleted, and the workflow’s output callback is called.CommandLineTooljob() objects yield a single runnable object.The CommandLineTooljob()method callsmake_job_runner()to create aCommandLineJobobjectThe job method configures the CommandLineJob object by setting public
attributesThe job method iterates over file and directories inputs to the
CommandLineTool and creates a “path map”.Files are mapped from their “resolved” location to a “target” path where
they will appear at tool invocation (for example, a location inside a
Docker container.)  The target paths are used on the command line.Files are staged to targets paths using either Docker volume binds (when
using containers) or symlinks (if not).  This staging step enables files
to be logically rearranged or renamed independent of their source layout.Therun()method of CommandLineJob executes the command line tool or
Docker container, waits for it to complete, collects output, and makes
the output callback.Extension pointsThe following functions can be passed to main() to override or augment
the listed behaviors.executorexecutor(tool, job_order_object, runtimeContext, logger)
  (Process, Dict[Text, Any], RuntimeContext) -> Tuple[Dict[Text, Any], Text]An implementation of the top-level workflow execution loop should
synchronously run a process object to completion and return the
output object.versionfunc()
  () -> TextReturn version string.logger_handlerlogger_handler
  logging.HandlerHandler object for logging.The following functions can be set in LoadingContext to override or
augment the listed behaviors.fetcher_constructorfetcher_constructor(cache, session)
  (Dict[unicode, unicode], requests.sessions.Session) -> FetcherConstruct a Fetcher object with the supplied cache and HTTP session.resolverresolver(document_loader, document)
  (Loader, Union[Text, dict[Text, Any]]) -> TextResolve a relative document identifier to an absolute one that can be fetched.The following functions can be set in RuntimeContext to override or
augment the listed behaviors.construct_tool_objectconstruct_tool_object(toolpath_object, loadingContext)
  (MutableMapping[Text, Any], LoadingContext) -> ProcessHook to construct a Process object (eg CommandLineTool) object from a document.select_resourcesselectResources(request)
  (Dict[str, int], RuntimeContext) -> Dict[Text, int]Take a resource request and turn it into a concrete resource assignment.make_fs_accessmake_fs_access(basedir)
  (Text) -> StdFsAccessReturn a file system access object.In addition, when providing custom subclasses of Process objects, you can override the following methods:CommandLineTool.make_job_runnermake_job_runner(RuntimeContext)
  (RuntimeContext) -> Type[JobBase]Create and return a job runner object (this implements concrete execution of a command line tool).Workflow.make_workflow_stepmake_workflow_step(toolpath_object, pos, loadingContext, parentworkflowProv)
  (Dict[Text, Any], int, LoadingContext, Optional[ProvenanceProfile]) -> WorkflowStepCreate and return a workflow step object.