/
template_container.py
executable file
·179 lines (141 loc) · 8.18 KB
/
template_container.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
#!/usr/bin/env python3
"""Module containing the TemplateContainer class and the command line interface."""
import argparse
from biobb_common.generic.biobb_object import BiobbObject
from biobb_common.configuration import settings
from biobb_common.tools import file_utils as fu
from biobb_common.tools.file_utils import launchlogger
# 1. Rename class as required
class TemplateContainer(BiobbObject):
"""
| biobb_template TemplateContainer
| Short description for the `template container <http://templatedocumentation.org>`_ module in Restructured Text (reST) syntax. Mandatory.
| Long description for the `template container <http://templatedocumentation.org>`_ module in Restructured Text (reST) syntax. Optional.
Args:
input_file_path1 (str): Description for the first input file path. File type: input. `Sample file <https://urlto.sample>`_. Accepted formats: top (edam:format_3881).
input_file_path2 (str) (Optional): Description for the second input file path (optional). File type: input. `Sample file <https://urlto.sample>`_. Accepted formats: dcd (edam:format_3878).
output_file_path (str): Description for the output file path. File type: output. `Sample file <https://urlto.sample>`_. Accepted formats: zip (edam:format_3987).
properties (dic):
* **boolean_property** (*bool*) - (True) Example of boolean property.
* **binary_path** (*str*) - ("zip") Example of executable binary property.
* **remove_tmp** (*bool*) - (True) [WF property] Remove temporal files.
* **restart** (*bool*) - (False) [WF property] Do not execute if output files exist.
* **container_path** (*str*) - (None) Container path definition.
* **container_image** (*str*) - ('mmbirb/zip:latest') Container image definition.
* **container_volume_path** (*str*) - ('/tmp') Container volume path definition.
* **container_working_dir** (*str*) - (None) Container working directory definition.
* **container_user_id** (*str*) - (None) Container user_id definition.
* **container_shell_path** (*str*) - ('/bin/bash') Path to default shell inside the container.
Examples:
This is a use example of how to use the building block from Python::
from biobb_template.template.template_container import template_container
prop = {
'boolean_property': True,
'container_path': 'docker',
'container_image': 'mmbirb/zip:latest',
'container_volume_path': '/tmp'
}
template_container(input_file_path1='/path/to/myTopology.top',
output_file_path='/path/to/newCompressedFile.zip',
input_file_path2='/path/to/mytrajectory.dcd',
properties=prop)
Info:
* wrapped_software:
* name: Zip
* version: >=3.0
* license: BSD 3-Clause
* ontology:
* name: EDAM
* schema: http://edamontology.org/EDAM.owl
"""
# 2. Adapt input and output file paths as required. Include all files, even optional ones
def __init__(self, input_file_path1, output_file_path, input_file_path2=None, properties=None, **kwargs) -> None:
properties = properties or {}
# 2.0 Call parent class constructor
super().__init__(properties)
self.locals_var_dict = locals().copy()
# 2.1 Modify to match constructor parameters
# Input/Output files
self.io_dict = {
'in': {'input_file_path1': input_file_path1, 'input_file_path2': input_file_path2},
'out': {'output_file_path': output_file_path}
}
# 3. Include all relevant properties here as
# self.property_name = properties.get('property_name', property_default_value)
# Properties specific for BB
self.boolean_property = properties.get('boolean_property', True)
self.binary_path = properties.get('binary_path', 'zip')
self.properties = properties
# Check the properties
self.check_properties(properties)
# Check the arguments
self.check_arguments()
@launchlogger
def launch(self) -> int:
"""Execute the :class:`TemplateContainer <template.template_container.TemplateContainer>` object."""
# 4. Setup Biobb
if self.check_restart():
return 0
self.stage_files()
# Creating temporary folder
self.tmp_folder = fu.create_unique_dir()
fu.log('Creating %s temporary folder' % self.tmp_folder, self.out_log)
# 5. Prepare the command line parameters as instructions list
instructions = ['-j']
if self.boolean_property:
instructions.append('-v')
fu.log('Appending optional boolean property', self.out_log, self.global_log)
# 6. Build the actual command line as a list of items (elements order will be maintained)
self.cmd = [self.binary_path,
' '.join(instructions),
self.stage_io_dict['out']['output_file_path'],
self.stage_io_dict['in']['input_file_path1']]
fu.log('Creating command line with instructions and required arguments', self.out_log, self.global_log)
# 7. Repeat for optional input files if provided
if self.stage_io_dict['in']['input_file_path2']:
# Append optional input_file_path2 to cmd
self.cmd.append(self.stage_io_dict['in']['input_file_path2'])
fu.log('Appending optional argument to command line', self.out_log, self.global_log)
# 8. Uncomment to check the command line
# print(' '.join(cmd))
# Run Biobb block
self.run_biobb()
# Copy files to host
self.copy_to_host()
# Remove temporary file(s)
self.tmp_files.extend([
self.stage_io_dict.get("unique_dir"),
self.tmp_folder
])
self.remove_tmp_files()
# Check output arguments
self.check_arguments(output_files_created=True, raise_exception=False)
return self.return_code
def template_container(input_file_path1: str, output_file_path: str, input_file_path2: str = None, properties: dict = None, **kwargs) -> int:
"""Create :class:`TemplateContainer <template.template_container.TemplateContainer>` class and
execute the :meth:`launch() <template.template_container.TemplateContainer.launch>` method."""
return TemplateContainer(input_file_path1=input_file_path1,
output_file_path=output_file_path,
input_file_path2=input_file_path2,
properties=properties, **kwargs).launch()
def main():
"""Command line execution of this building block. Please check the command line documentation."""
parser = argparse.ArgumentParser(description='Description for the template container module.', formatter_class=lambda prog: argparse.RawTextHelpFormatter(prog, width=99999))
parser.add_argument('--config', required=False, help='Configuration file')
# 10. Include specific args of each building block following the examples. They should match step 2
required_args = parser.add_argument_group('required arguments')
required_args.add_argument('--input_file_path1', required=True, help='Description for the first input file path. Accepted formats: top.')
parser.add_argument('--input_file_path2', required=False, help='Description for the second input file path (optional). Accepted formats: dcd.')
required_args.add_argument('--output_file_path', required=True, help='Description for the output file path. Accepted formats: zip.')
args = parser.parse_args()
args.config = args.config or "{}"
properties = settings.ConfReader(config=args.config).get_prop_dic()
# 11. Adapt to match Class constructor (step 2)
# Specific call of each building block
template_container(input_file_path1=args.input_file_path1,
output_file_path=args.output_file_path,
input_file_path2=args.input_file_path2,
properties=properties)
if __name__ == '__main__':
main()
# 13. Complete documentation strings