Mercurial > repos > shellac > sam_consensus_v3
comparison env/lib/python3.9/site-packages/cwltool/schemas/v1.2/Process.yml @ 0:4f3585e2f14b draft default tip
"planemo upload commit 60cee0fc7c0cda8592644e1aad72851dec82c959"
author | shellac |
---|---|
date | Mon, 22 Mar 2021 18:12:50 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:4f3585e2f14b |
---|---|
1 saladVersion: v1.1 | |
2 $base: "https://w3id.org/cwl/cwl#" | |
3 | |
4 $namespaces: | |
5 cwl: "https://w3id.org/cwl/cwl#" | |
6 sld: "https://w3id.org/cwl/salad#" | |
7 rdfs: "http://www.w3.org/2000/01/rdf-schema#" | |
8 | |
9 $graph: | |
10 | |
11 - name: "Common Workflow Language, v1.2" | |
12 type: documentation | |
13 doc: {$include: concepts.md} | |
14 | |
15 - $import: "salad/schema_salad/metaschema/metaschema_base.yml" | |
16 | |
17 - name: BaseTypesDoc | |
18 type: documentation | |
19 doc: | | |
20 ## Base types | |
21 docChild: | |
22 - "#CWLType" | |
23 - "#Process" | |
24 | |
25 - type: enum | |
26 name: CWLVersion | |
27 doc: "Version symbols for published CWL document versions." | |
28 symbols: | |
29 - cwl:draft-2 | |
30 - cwl:draft-3.dev1 | |
31 - cwl:draft-3.dev2 | |
32 - cwl:draft-3.dev3 | |
33 - cwl:draft-3.dev4 | |
34 - cwl:draft-3.dev5 | |
35 - cwl:draft-3 | |
36 - cwl:draft-4.dev1 | |
37 - cwl:draft-4.dev2 | |
38 - cwl:draft-4.dev3 | |
39 - cwl:v1.0.dev4 | |
40 - cwl:v1.0 | |
41 - cwl:v1.1.0-dev1 # a dash is required by the semver 2.0 rules | |
42 - cwl:v1.1 | |
43 - cwl:v1.2.0-dev1 | |
44 - cwl:v1.2.0-dev2 | |
45 - cwl:v1.2.0-dev3 | |
46 - cwl:v1.2.0-dev4 | |
47 - cwl:v1.2.0-dev5 | |
48 - cwl:v1.2 | |
49 | |
50 - name: CWLType | |
51 type: enum | |
52 extends: "sld:PrimitiveType" | |
53 symbols: | |
54 - cwl:File | |
55 - cwl:Directory | |
56 doc: | |
57 - "Extends primitive types with the concept of a file and directory as a builtin type." | |
58 - "File: A File object" | |
59 - "Directory: A Directory object" | |
60 | |
61 - name: File | |
62 type: record | |
63 docParent: "#CWLType" | |
64 doc: | | |
65 Represents a file (or group of files when `secondaryFiles` is provided) that | |
66 will be accessible by tools using standard POSIX file system call API such as | |
67 open(2) and read(2). | |
68 | |
69 Files are represented as objects with `class` of `File`. File objects have | |
70 a number of properties that provide metadata about the file. | |
71 | |
72 The `location` property of a File is a URI that uniquely identifies the | |
73 file. Implementations must support the file:// URI scheme and may support | |
74 other schemes such as http://. The value of `location` may also be a | |
75 relative reference, in which case it must be resolved relative to the URI | |
76 of the document it appears in. Alternately to `location`, implementations | |
77 must also accept the `path` property on File, which must be a filesystem | |
78 path available on the same host as the CWL runner (for inputs) or the | |
79 runtime environment of a command line tool execution (for command line tool | |
80 outputs). | |
81 | |
82 If no `location` or `path` is specified, a file object must specify | |
83 `contents` with the UTF-8 text content of the file. This is a "file | |
84 literal". File literals do not correspond to external resources, but are | |
85 created on disk with `contents` with when needed for a executing a tool. | |
86 Where appropriate, expressions can return file literals to define new files | |
87 on a runtime. The maximum size of `contents` is 64 kilobytes. | |
88 | |
89 The `basename` property defines the filename on disk where the file is | |
90 staged. This may differ from the resource name. If not provided, | |
91 `basename` must be computed from the last path part of `location` and made | |
92 available to expressions. | |
93 | |
94 The `secondaryFiles` property is a list of File or Directory objects that | |
95 must be staged in the same directory as the primary file. It is an error | |
96 for file names to be duplicated in `secondaryFiles`. | |
97 | |
98 The `size` property is the size in bytes of the File. It must be computed | |
99 from the resource and made available to expressions. The `checksum` field | |
100 contains a cryptographic hash of the file content for use it verifying file | |
101 contents. Implementations may, at user option, enable or disable | |
102 computation of the `checksum` field for performance or other reasons. | |
103 However, the ability to compute output checksums is required to pass the | |
104 CWL conformance test suite. | |
105 | |
106 When executing a CommandLineTool, the files and secondary files may be | |
107 staged to an arbitrary directory, but must use the value of `basename` for | |
108 the filename. The `path` property must be file path in the context of the | |
109 tool execution runtime (local to the compute node, or within the executing | |
110 container). All computed properties should be available to expressions. | |
111 File literals also must be staged and `path` must be set. | |
112 | |
113 When collecting CommandLineTool outputs, `glob` matching returns file paths | |
114 (with the `path` property) and the derived properties. This can all be | |
115 modified by `outputEval`. Alternately, if the file `cwl.output.json` is | |
116 present in the output, `outputBinding` is ignored. | |
117 | |
118 File objects in the output must provide either a `location` URI or a `path` | |
119 property in the context of the tool execution runtime (local to the compute | |
120 node, or within the executing container). | |
121 | |
122 When evaluating an ExpressionTool, file objects must be referenced via | |
123 `location` (the expression tool does not have access to files on disk so | |
124 `path` is meaningless) or as file literals. It is legal to return a file | |
125 object with an existing `location` but a different `basename`. The | |
126 `loadContents` field of ExpressionTool inputs behaves the same as on | |
127 CommandLineTool inputs, however it is not meaningful on the outputs. | |
128 | |
129 An ExpressionTool may forward file references from input to output by using | |
130 the same value for `location`. | |
131 | |
132 fields: | |
133 - name: class | |
134 type: | |
135 type: enum | |
136 name: File_class | |
137 symbols: | |
138 - cwl:File | |
139 jsonldPredicate: | |
140 _id: "@type" | |
141 _type: "@vocab" | |
142 doc: Must be `File` to indicate this object describes a file. | |
143 - name: location | |
144 type: string? | |
145 doc: | | |
146 An IRI that identifies the file resource. This may be a relative | |
147 reference, in which case it must be resolved using the base IRI of the | |
148 document. The location may refer to a local or remote resource; the | |
149 implementation must use the IRI to retrieve file content. If an | |
150 implementation is unable to retrieve the file content stored at a | |
151 remote resource (due to unsupported protocol, access denied, or other | |
152 issue) it must signal an error. | |
153 | |
154 If the `location` field is not provided, the `contents` field must be | |
155 provided. The implementation must assign a unique identifier for | |
156 the `location` field. | |
157 | |
158 If the `path` field is provided but the `location` field is not, an | |
159 implementation may assign the value of the `path` field to `location`, | |
160 then follow the rules above. | |
161 jsonldPredicate: | |
162 _id: "@id" | |
163 _type: "@id" | |
164 - name: path | |
165 type: string? | |
166 doc: | | |
167 The local host path where the File is available when a CommandLineTool is | |
168 executed. This field must be set by the implementation. The final | |
169 path component must match the value of `basename`. This field | |
170 must not be used in any other context. The command line tool being | |
171 executed must be able to to access the file at `path` using the POSIX | |
172 `open(2)` syscall. | |
173 | |
174 As a special case, if the `path` field is provided but the `location` | |
175 field is not, an implementation may assign the value of the `path` | |
176 field to `location`, and remove the `path` field. | |
177 | |
178 If the `path` contains [POSIX shell metacharacters](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_02) | |
179 (`|`,`&`, `;`, `<`, `>`, `(`,`)`, `$`,`` ` ``, `\`, `"`, `'`, | |
180 `<space>`, `<tab>`, and `<newline>`) or characters | |
181 [not allowed](http://www.iana.org/assignments/idna-tables-6.3.0/idna-tables-6.3.0.xhtml) | |
182 for [Internationalized Domain Names for Applications](https://tools.ietf.org/html/rfc6452) | |
183 then implementations may terminate the process with a | |
184 `permanentFailure`. | |
185 jsonldPredicate: | |
186 "_id": "cwl:path" | |
187 "_type": "@id" | |
188 - name: basename | |
189 type: string? | |
190 doc: | | |
191 The base name of the file, that is, the name of the file without any | |
192 leading directory path. The base name must not contain a slash `/`. | |
193 | |
194 If not provided, the implementation must set this field based on the | |
195 `location` field by taking the final path component after parsing | |
196 `location` as an IRI. If `basename` is provided, it is not required to | |
197 match the value from `location`. | |
198 | |
199 When this file is made available to a CommandLineTool, it must be named | |
200 with `basename`, i.e. the final component of the `path` field must match | |
201 `basename`. | |
202 jsonldPredicate: "cwl:basename" | |
203 - name: dirname | |
204 type: string? | |
205 doc: | | |
206 The name of the directory containing file, that is, the path leading up | |
207 to the final slash in the path such that `dirname + '/' + basename == | |
208 path`. | |
209 | |
210 The implementation must set this field based on the value of `path` | |
211 prior to evaluating parameter references or expressions in a | |
212 CommandLineTool document. This field must not be used in any other | |
213 context. | |
214 - name: nameroot | |
215 type: string? | |
216 doc: | | |
217 The basename root such that `nameroot + nameext == basename`, and | |
218 `nameext` is empty or begins with a period and contains at most one | |
219 period. For the purposess of path splitting leading periods on the | |
220 basename are ignored; a basename of `.cshrc` will have a nameroot of | |
221 `.cshrc`. | |
222 | |
223 The implementation must set this field automatically based on the value | |
224 of `basename` prior to evaluating parameter references or expressions. | |
225 - name: nameext | |
226 type: string? | |
227 doc: | | |
228 The basename extension such that `nameroot + nameext == basename`, and | |
229 `nameext` is empty or begins with a period and contains at most one | |
230 period. Leading periods on the basename are ignored; a basename of | |
231 `.cshrc` will have an empty `nameext`. | |
232 | |
233 The implementation must set this field automatically based on the value | |
234 of `basename` prior to evaluating parameter references or expressions. | |
235 - name: checksum | |
236 type: string? | |
237 doc: | | |
238 Optional hash code for validating file integrity. Currently must be in the form | |
239 "sha1$ + hexadecimal string" using the SHA-1 algorithm. | |
240 - name: size | |
241 type: long? | |
242 doc: Optional file size | |
243 - name: "secondaryFiles" | |
244 type: | |
245 - "null" | |
246 - type: array | |
247 items: [File, Directory] | |
248 jsonldPredicate: | |
249 _id: "cwl:secondaryFiles" | |
250 secondaryFilesDSL: true | |
251 doc: | | |
252 A list of additional files or directories that are associated with the | |
253 primary file and must be transferred alongside the primary file. | |
254 Examples include indexes of the primary file, or external references | |
255 which must be included when loading primary document. A file object | |
256 listed in `secondaryFiles` may itself include `secondaryFiles` for | |
257 which the same rules apply. | |
258 - name: format | |
259 type: string? | |
260 jsonldPredicate: | |
261 _id: cwl:format | |
262 _type: "@id" | |
263 identity: true | |
264 doc: | | |
265 The format of the file: this must be an IRI of a concept node that | |
266 represents the file format, preferrably defined within an ontology. | |
267 If no ontology is available, file formats may be tested by exact match. | |
268 | |
269 Reasoning about format compatability must be done by checking that an | |
270 input file format is the same, `owl:equivalentClass` or | |
271 `rdfs:subClassOf` the format required by the input parameter. | |
272 `owl:equivalentClass` is transitive with `rdfs:subClassOf`, e.g. if | |
273 `<B> owl:equivalentClass <C>` and `<B> owl:subclassOf <A>` then infer | |
274 `<C> owl:subclassOf <A>`. | |
275 | |
276 File format ontologies may be provided in the "$schema" metadata at the | |
277 root of the document. If no ontologies are specified in `$schema`, the | |
278 runtime may perform exact file format matches. | |
279 - name: contents | |
280 type: string? | |
281 doc: | | |
282 File contents literal. | |
283 | |
284 If neither `location` nor `path` is provided, `contents` must be | |
285 non-null. The implementation must assign a unique identifier for the | |
286 `location` field. When the file is staged as input to CommandLineTool, | |
287 the value of `contents` must be written to a file. | |
288 | |
289 If `contents` is set as a result of an Javascript expression, | |
290 an `entry` in `InitialWorkDirRequirement`, or read in from | |
291 `cwl.output.json`, there is no specified upper limit on the | |
292 size of `contents`. Implementations may have practical limits | |
293 on the size of `contents` based on memory and storage | |
294 available to the workflow runner or other factors. | |
295 | |
296 If the `loadContents` field of an `InputParameter` or | |
297 `OutputParameter` is true, and the input or output File object | |
298 `location` is valid, the file must be a UTF-8 text file 64 KiB | |
299 or smaller, and the implementation must read the entire | |
300 contents of the file and place it in the `contents` field. If | |
301 the size of the file is greater than 64 KiB, the | |
302 implementation must raise a fatal error. | |
303 | |
304 | |
305 - name: Directory | |
306 type: record | |
307 docAfter: "#File" | |
308 doc: | | |
309 Represents a directory to present to a command line tool. | |
310 | |
311 Directories are represented as objects with `class` of `Directory`. Directory objects have | |
312 a number of properties that provide metadata about the directory. | |
313 | |
314 The `location` property of a Directory is a URI that uniquely identifies | |
315 the directory. Implementations must support the file:// URI scheme and may | |
316 support other schemes such as http://. Alternately to `location`, | |
317 implementations must also accept the `path` property on Directory, which | |
318 must be a filesystem path available on the same host as the CWL runner (for | |
319 inputs) or the runtime environment of a command line tool execution (for | |
320 command line tool outputs). | |
321 | |
322 A Directory object may have a `listing` field. This is a list of File and | |
323 Directory objects that are contained in the Directory. For each entry in | |
324 `listing`, the `basename` property defines the name of the File or | |
325 Subdirectory when staged to disk. If `listing` is not provided, the | |
326 implementation must have some way of fetching the Directory listing at | |
327 runtime based on the `location` field. | |
328 | |
329 If a Directory does not have `location`, it is a Directory literal. A | |
330 Directory literal must provide `listing`. Directory literals must be | |
331 created on disk at runtime as needed. | |
332 | |
333 The resources in a Directory literal do not need to have any implied | |
334 relationship in their `location`. For example, a Directory listing may | |
335 contain two files located on different hosts. It is the responsibility of | |
336 the runtime to ensure that those files are staged to disk appropriately. | |
337 Secondary files associated with files in `listing` must also be staged to | |
338 the same Directory. | |
339 | |
340 When executing a CommandLineTool, Directories must be recursively staged | |
341 first and have local values of `path` assigend. | |
342 | |
343 Directory objects in CommandLineTool output must provide either a | |
344 `location` URI or a `path` property in the context of the tool execution | |
345 runtime (local to the compute node, or within the executing container). | |
346 | |
347 An ExpressionTool may forward file references from input to output by using | |
348 the same value for `location`. | |
349 | |
350 Name conflicts (the same `basename` appearing multiple times in `listing` | |
351 or in any entry in `secondaryFiles` in the listing) is a fatal error. | |
352 | |
353 fields: | |
354 - name: class | |
355 type: | |
356 type: enum | |
357 name: Directory_class | |
358 symbols: | |
359 - cwl:Directory | |
360 jsonldPredicate: | |
361 _id: "@type" | |
362 _type: "@vocab" | |
363 doc: Must be `Directory` to indicate this object describes a Directory. | |
364 - name: location | |
365 type: string? | |
366 doc: | | |
367 An IRI that identifies the directory resource. This may be a relative | |
368 reference, in which case it must be resolved using the base IRI of the | |
369 document. The location may refer to a local or remote resource. If | |
370 the `listing` field is not set, the implementation must use the | |
371 location IRI to retrieve directory listing. If an implementation is | |
372 unable to retrieve the directory listing stored at a remote resource (due to | |
373 unsupported protocol, access denied, or other issue) it must signal an | |
374 error. | |
375 | |
376 If the `location` field is not provided, the `listing` field must be | |
377 provided. The implementation must assign a unique identifier for | |
378 the `location` field. | |
379 | |
380 If the `path` field is provided but the `location` field is not, an | |
381 implementation may assign the value of the `path` field to `location`, | |
382 then follow the rules above. | |
383 jsonldPredicate: | |
384 _id: "@id" | |
385 _type: "@id" | |
386 - name: path | |
387 type: string? | |
388 doc: | | |
389 The local path where the Directory is made available prior to executing a | |
390 CommandLineTool. This must be set by the implementation. This field | |
391 must not be used in any other context. The command line tool being | |
392 executed must be able to to access the directory at `path` using the POSIX | |
393 `opendir(2)` syscall. | |
394 | |
395 If the `path` contains [POSIX shell metacharacters](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_02) | |
396 (`|`,`&`, `;`, `<`, `>`, `(`,`)`, `$`,`` ` ``, `\`, `"`, `'`, | |
397 `<space>`, `<tab>`, and `<newline>`) or characters | |
398 [not allowed](http://www.iana.org/assignments/idna-tables-6.3.0/idna-tables-6.3.0.xhtml) | |
399 for [Internationalized Domain Names for Applications](https://tools.ietf.org/html/rfc6452) | |
400 then implementations may terminate the process with a | |
401 `permanentFailure`. | |
402 jsonldPredicate: | |
403 _id: "cwl:path" | |
404 _type: "@id" | |
405 - name: basename | |
406 type: string? | |
407 doc: | | |
408 The base name of the directory, that is, the name of the file without any | |
409 leading directory path. The base name must not contain a slash `/`. | |
410 | |
411 If not provided, the implementation must set this field based on the | |
412 `location` field by taking the final path component after parsing | |
413 `location` as an IRI. If `basename` is provided, it is not required to | |
414 match the value from `location`. | |
415 | |
416 When this file is made available to a CommandLineTool, it must be named | |
417 with `basename`, i.e. the final component of the `path` field must match | |
418 `basename`. | |
419 jsonldPredicate: "cwl:basename" | |
420 - name: listing | |
421 type: | |
422 - "null" | |
423 - type: array | |
424 items: [File, Directory] | |
425 doc: | | |
426 List of files or subdirectories contained in this directory. The name | |
427 of each file or subdirectory is determined by the `basename` field of | |
428 each `File` or `Directory` object. It is an error if a `File` shares a | |
429 `basename` with any other entry in `listing`. If two or more | |
430 `Directory` object share the same `basename`, this must be treated as | |
431 equivalent to a single subdirectory with the listings recursively | |
432 merged. | |
433 jsonldPredicate: | |
434 _id: "cwl:listing" | |
435 | |
436 - name: Labeled | |
437 type: record | |
438 abstract: true | |
439 fields: | |
440 - name: label | |
441 type: | |
442 - "null" | |
443 - string | |
444 jsonldPredicate: "rdfs:label" | |
445 doc: "A short, human-readable label of this object." | |
446 | |
447 | |
448 - name: Identified | |
449 type: record | |
450 abstract: true | |
451 fields: | |
452 - name: id | |
453 type: string? | |
454 jsonldPredicate: "@id" | |
455 doc: "The unique identifier for this object." | |
456 | |
457 | |
458 - name: LoadListingEnum | |
459 type: enum | |
460 symbols: [no_listing, shallow_listing, deep_listing] | |
461 doc: | |
462 - | | |
463 Specify the desired behavior for loading the `listing` field of | |
464 a Directory object for use by expressions. | |
465 - "no_listing: Do not load the directory listing." | |
466 - "shallow_listing: Only load the top level listing, do not recurse into subdirectories." | |
467 - "deep_listing: Load the directory listing and recursively load all subdirectories as well." | |
468 | |
469 | |
470 - name: LoadContents | |
471 type: record | |
472 abstract: true | |
473 fields: | |
474 - name: loadContents | |
475 type: boolean? | |
476 jsonldPredicate: "cwl:loadContents" | |
477 doc: | | |
478 Only valid when `type: File` or is an array of `items: File`. | |
479 | |
480 If true, the file (or each file in the array) must be a UTF-8 | |
481 text file 64 KiB or smaller, and the implementation must read | |
482 the entire contents of the file (or file array) and place it | |
483 in the `contents` field of the File object for use by | |
484 expressions. If the size of the file is greater than 64 KiB, | |
485 the implementation must raise a fatal error. | |
486 | |
487 - name: loadListing | |
488 type: LoadListingEnum? | |
489 jsonldPredicate: "cwl:loadListing" | |
490 doc: | | |
491 Only valid when `type: Directory` or is an array of `items: Directory`. | |
492 | |
493 Specify the desired behavior for loading the `listing` field of | |
494 a Directory object for use by expressions. | |
495 | |
496 The order of precedence for loadListing is: | |
497 | |
498 1. `loadListing` on an individual parameter | |
499 2. Inherited from `LoadListingRequirement` | |
500 3. By default: `no_listing` | |
501 | |
502 - name: FieldBase | |
503 type: record | |
504 extends: Labeled | |
505 abstract: true | |
506 fields: | |
507 secondaryFiles: | |
508 type: | |
509 - "null" | |
510 - SecondaryFileSchema | |
511 - type: array | |
512 items: SecondaryFileSchema | |
513 jsonldPredicate: | |
514 _id: "cwl:secondaryFiles" | |
515 secondaryFilesDSL: true | |
516 doc: | | |
517 Only valid when `type: File` or is an array of `items: File`. | |
518 | |
519 Provides a pattern or expression specifying files or | |
520 directories that should be included alongside the primary | |
521 file. Secondary files may be required or optional. When not | |
522 explicitly specified, secondary files specified for `inputs` | |
523 are required and `outputs` are optional. An implementation | |
524 must include matching Files and Directories in the | |
525 `secondaryFiles` property of the primary file. These Files | |
526 and Directories must be transferred and staged alongside the | |
527 primary file. An implementation may fail workflow execution | |
528 if a required secondary file does not exist. | |
529 | |
530 If the value is an expression, the value of `self` in the expression | |
531 must be the primary input or output File object to which this binding | |
532 applies. The `basename`, `nameroot` and `nameext` fields must be | |
533 present in `self`. For `CommandLineTool` outputs the `path` field must | |
534 also be present. The expression must return a filename string relative | |
535 to the path to the primary File, a File or Directory object with either | |
536 `path` or `location` and `basename` fields set, or an array consisting | |
537 of strings or File or Directory objects. It is legal to reference an | |
538 unchanged File or Directory object taken from input as a secondaryFile. | |
539 The expression may return "null" in which case there is no secondaryFile | |
540 from that expression. | |
541 | |
542 To work on non-filename-preserving storage systems, portable tool | |
543 descriptions should avoid constructing new values from `location`, but | |
544 should construct relative references using `basename` or `nameroot` | |
545 instead. | |
546 | |
547 If a value in `secondaryFiles` is a string that is not an expression, | |
548 it specifies that the following pattern should be applied to the path | |
549 of the primary file to yield a filename relative to the primary File: | |
550 | |
551 1. If string ends with `?` character, remove the last `?` and mark | |
552 the resulting secondary file as optional. | |
553 2. If string begins with one or more caret `^` characters, for each | |
554 caret, remove the last file extension from the path (the last | |
555 period `.` and all following characters). If there are no file | |
556 extensions, the path is unchanged. | |
557 3. Append the remainder of the string to the end of the file path. | |
558 | |
559 streamable: | |
560 type: boolean? | |
561 doc: | | |
562 Only valid when `type: File` or is an array of `items: File`. | |
563 | |
564 A value of `true` indicates that the file is read or written | |
565 sequentially without seeking. An implementation may use this flag to | |
566 indicate whether it is valid to stream file contents using a named | |
567 pipe. Default: `false`. | |
568 | |
569 | |
570 - name: InputFormat | |
571 type: record | |
572 abstract: true | |
573 fields: | |
574 format: | |
575 type: | |
576 - "null" | |
577 - string | |
578 - type: array | |
579 items: string | |
580 - Expression | |
581 jsonldPredicate: | |
582 _id: cwl:format | |
583 _type: "@id" | |
584 identity: true | |
585 doc: | | |
586 Only valid when `type: File` or is an array of `items: File`. | |
587 | |
588 This must be one or more IRIs of concept nodes | |
589 that represents file formats which are allowed as input to this | |
590 parameter, preferrably defined within an ontology. If no ontology is | |
591 available, file formats may be tested by exact match. | |
592 | |
593 | |
594 - name: OutputFormat | |
595 type: record | |
596 abstract: true | |
597 fields: | |
598 format: | |
599 type: | |
600 - "null" | |
601 - string | |
602 - Expression | |
603 jsonldPredicate: | |
604 _id: cwl:format | |
605 _type: "@id" | |
606 identity: true | |
607 doc: | | |
608 Only valid when `type: File` or is an array of `items: File`. | |
609 | |
610 This is the file format that will be assigned to the output | |
611 File object. | |
612 | |
613 | |
614 - name: Parameter | |
615 type: record | |
616 extends: [FieldBase, sld:Documented, Identified] | |
617 abstract: true | |
618 doc: | | |
619 Define an input or output parameter to a process. | |
620 | |
621 | |
622 - type: enum | |
623 name: Expression | |
624 doc: | | |
625 'Expression' is not a real type. It indicates that a field must allow | |
626 runtime parameter references. If [InlineJavascriptRequirement](#InlineJavascriptRequirement) | |
627 is declared and supported by the platform, the field must also allow | |
628 Javascript expressions. | |
629 symbols: | |
630 - cwl:ExpressionPlaceholder | |
631 | |
632 | |
633 - name: InputBinding | |
634 type: record | |
635 fields: | |
636 - name: loadContents | |
637 type: | |
638 - "null" | |
639 - boolean | |
640 jsonldPredicate: "cwl:loadContents" | |
641 doc: | | |
642 Use of `loadContents` in `InputBinding` is deprecated. | |
643 Preserved for v1.0 backwards compatability. Will be removed in | |
644 CWL v2.0. Use `InputParameter.loadContents` instead. | |
645 | |
646 - name: IOSchema | |
647 extends: [Labeled, sld:Documented] | |
648 type: record | |
649 abstract: true | |
650 fields: | |
651 - name: name | |
652 type: string? | |
653 jsonldPredicate: "@id" | |
654 doc: "The identifier for this type" | |
655 | |
656 - name: InputSchema | |
657 extends: [IOSchema] | |
658 type: record | |
659 abstract: true | |
660 | |
661 - name: OutputSchema | |
662 extends: [IOSchema] | |
663 type: record | |
664 abstract: true | |
665 | |
666 | |
667 - name: InputRecordField | |
668 type: record | |
669 extends: [sld:RecordField, FieldBase, InputFormat, LoadContents] | |
670 specialize: | |
671 - specializeFrom: "sld:RecordSchema" | |
672 specializeTo: InputRecordSchema | |
673 - specializeFrom: "sld:EnumSchema" | |
674 specializeTo: InputEnumSchema | |
675 - specializeFrom: "sld:ArraySchema" | |
676 specializeTo: InputArraySchema | |
677 - specializeFrom: "sld:PrimitiveType" | |
678 specializeTo: CWLType | |
679 | |
680 | |
681 - name: InputRecordSchema | |
682 type: record | |
683 extends: ["sld:RecordSchema", InputSchema] | |
684 specialize: | |
685 - specializeFrom: "sld:RecordField" | |
686 specializeTo: InputRecordField | |
687 | |
688 | |
689 - name: InputEnumSchema | |
690 type: record | |
691 extends: ["sld:EnumSchema", InputSchema] | |
692 | |
693 | |
694 - name: InputArraySchema | |
695 type: record | |
696 extends: ["sld:ArraySchema", InputSchema] | |
697 specialize: | |
698 - specializeFrom: "sld:RecordSchema" | |
699 specializeTo: InputRecordSchema | |
700 - specializeFrom: "sld:EnumSchema" | |
701 specializeTo: InputEnumSchema | |
702 - specializeFrom: "sld:ArraySchema" | |
703 specializeTo: InputArraySchema | |
704 - specializeFrom: "sld:PrimitiveType" | |
705 specializeTo: CWLType | |
706 | |
707 | |
708 - name: OutputRecordField | |
709 type: record | |
710 extends: [sld:RecordField, FieldBase, OutputFormat] | |
711 specialize: | |
712 - specializeFrom: "sld:RecordSchema" | |
713 specializeTo: OutputRecordSchema | |
714 - specializeFrom: "sld:EnumSchema" | |
715 specializeTo: OutputEnumSchema | |
716 - specializeFrom: "sld:ArraySchema" | |
717 specializeTo: OutputArraySchema | |
718 - specializeFrom: "sld:PrimitiveType" | |
719 specializeTo: CWLType | |
720 | |
721 | |
722 - name: OutputRecordSchema | |
723 type: record | |
724 extends: ["sld:RecordSchema", "#OutputSchema"] | |
725 docParent: "#OutputParameter" | |
726 specialize: | |
727 - specializeFrom: "sld:RecordField" | |
728 specializeTo: OutputRecordField | |
729 | |
730 | |
731 - name: OutputEnumSchema | |
732 type: record | |
733 extends: ["sld:EnumSchema", OutputSchema] | |
734 docParent: "#OutputParameter" | |
735 | |
736 | |
737 - name: OutputArraySchema | |
738 type: record | |
739 extends: ["sld:ArraySchema", OutputSchema] | |
740 docParent: "#OutputParameter" | |
741 specialize: | |
742 - specializeFrom: "sld:RecordSchema" | |
743 specializeTo: OutputRecordSchema | |
744 - specializeFrom: "sld:EnumSchema" | |
745 specializeTo: OutputEnumSchema | |
746 - specializeFrom: "sld:ArraySchema" | |
747 specializeTo: OutputArraySchema | |
748 - specializeFrom: "sld:PrimitiveType" | |
749 specializeTo: CWLType | |
750 | |
751 | |
752 - name: InputParameter | |
753 type: record | |
754 abstract: true | |
755 extends: [Parameter, InputFormat, LoadContents] | |
756 fields: | |
757 - name: default | |
758 type: Any? | |
759 jsonldPredicate: | |
760 _id: sld:default | |
761 noLinkCheck: true | |
762 doc: | | |
763 The default value to use for this parameter if the parameter is missing | |
764 from the input object, or if the value of the parameter in the input | |
765 object is `null`. Default values are applied before evaluating expressions | |
766 (e.g. dependent `valueFrom` fields). | |
767 | |
768 | |
769 - name: OutputParameter | |
770 type: record | |
771 extends: [Parameter, OutputFormat] | |
772 abstract: true | |
773 | |
774 | |
775 - type: record | |
776 name: ProcessRequirement | |
777 abstract: true | |
778 doc: | | |
779 A process requirement declares a prerequisite that may or must be fulfilled | |
780 before executing a process. See [`Process.hints`](#process) and | |
781 [`Process.requirements`](#process). | |
782 | |
783 Process requirements are the primary mechanism for specifying extensions to | |
784 the CWL core specification. | |
785 | |
786 | |
787 - type: record | |
788 name: Process | |
789 extends: [Identified, Labeled, sld:Documented] | |
790 abstract: true | |
791 doc: | | |
792 | |
793 The base executable type in CWL is the `Process` object defined by the | |
794 document. Note that the `Process` object is abstract and cannot be | |
795 directly executed. | |
796 | |
797 fields: | |
798 - name: inputs | |
799 type: | |
800 type: array | |
801 items: InputParameter | |
802 jsonldPredicate: | |
803 _id: "cwl:inputs" | |
804 mapSubject: id | |
805 mapPredicate: type | |
806 doc: | | |
807 Defines the input parameters of the process. The process is ready to | |
808 run when all required input parameters are associated with concrete | |
809 values. Input parameters include a schema for each parameter which is | |
810 used to validate the input object. It may also be used to build a user | |
811 interface for constructing the input object. | |
812 | |
813 When accepting an input object, all input parameters must have a value. | |
814 If an input parameter is missing from the input object, it must be | |
815 assigned a value of `null` (or the value of `default` for that | |
816 parameter, if provided) for the purposes of validation and evaluation | |
817 of expressions. | |
818 | |
819 - name: outputs | |
820 type: | |
821 type: array | |
822 items: OutputParameter | |
823 jsonldPredicate: | |
824 _id: "cwl:outputs" | |
825 mapSubject: id | |
826 mapPredicate: type | |
827 doc: | | |
828 Defines the parameters representing the output of the process. May be | |
829 used to generate and/or validate the output object. | |
830 - name: requirements | |
831 type: ProcessRequirement[]? | |
832 jsonldPredicate: | |
833 _id: "cwl:requirements" | |
834 mapSubject: class | |
835 doc: | | |
836 Declares requirements that apply to either the runtime environment or the | |
837 workflow engine that must be met in order to execute this process. If | |
838 an implementation cannot satisfy all requirements, or a requirement is | |
839 listed which is not recognized by the implementation, it is a fatal | |
840 error and the implementation must not attempt to run the process, | |
841 unless overridden at user option. | |
842 - name: hints | |
843 type: Any[]? | |
844 doc: | | |
845 Declares hints applying to either the runtime environment or the | |
846 workflow engine that may be helpful in executing this process. It is | |
847 not an error if an implementation cannot satisfy all hints, however | |
848 the implementation may report a warning. | |
849 jsonldPredicate: | |
850 _id: cwl:hints | |
851 noLinkCheck: true | |
852 mapSubject: class | |
853 - name: cwlVersion | |
854 type: CWLVersion? | |
855 doc: | | |
856 CWL document version. Always required at the document root. Not | |
857 required for a Process embedded inside another Process. | |
858 jsonldPredicate: | |
859 "_id": "cwl:cwlVersion" | |
860 "_type": "@vocab" | |
861 - name: intent | |
862 type: string[]? | |
863 jsonldPredicate: | |
864 _type: "@id" | |
865 identity: true | |
866 doc: | | |
867 An identifier for the type of computational operation, of this Process. | |
868 Especially useful for "class: Operation", but can also be used for | |
869 CommandLineTool, Workflow, or ExpressionTool. | |
870 | |
871 If provided, then this must be an IRI of a concept node that | |
872 represents the type of operation, preferrably defined within an ontology. | |
873 | |
874 For example, in the domain of bioinformatics, one can use an IRI from | |
875 the EDAM Ontology's [Operation concept nodes](http://edamontology.org/operation_0004), | |
876 like [Alignment](http://edamontology.org/operation_2928), | |
877 or [Clustering](http://edamontology.org/operation_3432); or a more | |
878 specific Operation concept like | |
879 [Split read mapping](http://edamontology.org/operation_3199). | |
880 | |
881 - name: InlineJavascriptRequirement | |
882 type: record | |
883 extends: ProcessRequirement | |
884 doc: | | |
885 Indicates that the workflow platform must support inline Javascript expressions. | |
886 If this requirement is not present, the workflow platform must not perform expression | |
887 interpolatation. | |
888 fields: | |
889 - name: class | |
890 type: string | |
891 doc: "Always 'InlineJavascriptRequirement'" | |
892 jsonldPredicate: | |
893 "_id": "@type" | |
894 "_type": "@vocab" | |
895 - name: expressionLib | |
896 type: string[]? | |
897 doc: | | |
898 Additional code fragments that will also be inserted | |
899 before executing the expression code. Allows for function definitions that may | |
900 be called from CWL expressions. | |
901 | |
902 | |
903 - name: CommandInputSchema | |
904 type: record | |
905 abstract: true | |
906 | |
907 - name: SchemaDefRequirement | |
908 type: record | |
909 extends: ProcessRequirement | |
910 doc: | | |
911 This field consists of an array of type definitions which must be used when | |
912 interpreting the `inputs` and `outputs` fields. When a `type` field | |
913 contain a IRI, the implementation must check if the type is defined in | |
914 `schemaDefs` and use that definition. If the type is not found in | |
915 `schemaDefs`, it is an error. The entries in `schemaDefs` must be | |
916 processed in the order listed such that later schema definitions may refer | |
917 to earlier schema definitions. | |
918 | |
919 - **Type definitions are allowed for `enum` and `record` types only.** | |
920 - Type definitions may be shared by defining them in a file and then | |
921 `$include`-ing them in the `types` field. | |
922 - A file can contain a list of type definitions | |
923 | |
924 fields: | |
925 - name: class | |
926 type: string | |
927 doc: "Always 'SchemaDefRequirement'" | |
928 jsonldPredicate: | |
929 "_id": "@type" | |
930 "_type": "@vocab" | |
931 - name: types | |
932 type: | |
933 type: array | |
934 items: CommandInputSchema | |
935 doc: The list of type definitions. | |
936 | |
937 - name: SecondaryFileSchema | |
938 type: record | |
939 fields: | |
940 - name: pattern | |
941 type: | |
942 - string | |
943 - Expression | |
944 doc: | | |
945 Provides a pattern or expression specifying files or directories that | |
946 should be included alongside the primary file. | |
947 | |
948 If the value is an expression, the value of `self` in the | |
949 expression must be the primary input or output File object to | |
950 which this binding applies. The `basename`, `nameroot` and | |
951 `nameext` fields must be present in `self`. For | |
952 `CommandLineTool` inputs the `location` field must also be | |
953 present. For `CommandLineTool` outputs the `path` field must | |
954 also be present. If secondary files were included on an input | |
955 File object as part of the Process invocation, they must also | |
956 be present in `secondaryFiles` on `self`. | |
957 | |
958 The expression must return either: a filename string relative | |
959 to the path to the primary File, a File or Directory object | |
960 (`class: File` or 'class: Directory`) with either `location` | |
961 (for inputs) or `path` (for outputs) and `basename` fields | |
962 set, or an array consisting of strings or File or Directory | |
963 objects as previously described. | |
964 | |
965 It is legal to use `location` from a File or Directory object | |
966 passed in as input, including `location` from secondary files | |
967 on `self`. If an expression returns a File object with the | |
968 same `location` but a different `basename` as a secondary file | |
969 that was passed in, the expression result takes precedence. | |
970 Setting the basename with an expression this way affects the | |
971 `path` where the secondary file will be staged to in the | |
972 CommandLineTool. | |
973 | |
974 The expression may return "null" in which case there is no | |
975 secondary file from that expression. | |
976 | |
977 To work on non-filename-preserving storage systems, portable | |
978 tool descriptions should treat `location` as an opaque | |
979 identifier and avoid constructing new values from `location`, | |
980 but should construct relative references using `basename` or | |
981 `nameroot` instead, or propagate `location` from defined inputs. | |
982 | |
983 If a value in `secondaryFiles` is a string that is not an expression, | |
984 it specifies that the following pattern should be applied to the path | |
985 of the primary file to yield a filename relative to the primary File: | |
986 | |
987 1. If string ends with `?` character, remove the last `?` and mark | |
988 the resulting secondary file as optional. | |
989 2. If string begins with one or more caret `^` characters, for each | |
990 caret, remove the last file extension from the path (the last | |
991 period `.` and all following characters). If there are no file | |
992 extensions, the path is unchanged. | |
993 3. Append the remainder of the string to the end of the file path. | |
994 - name: required | |
995 type: ["null", boolean, Expression] | |
996 doc: | | |
997 An implementation must not fail workflow execution if `required` is | |
998 set to `false` and the expected secondary file does not exist. | |
999 Default value for `required` field is `true` for secondary files on | |
1000 input and `false` for secondary files on output. | |
1001 doc: | | |
1002 Secondary files are specified using the following micro-DSL for secondary files: | |
1003 | |
1004 * If the value is a string, it is transformed to an object with two fields | |
1005 `pattern` and `required` | |
1006 * By default, the value of `required` is `null` | |
1007 (this indicates default behavior, which may be based on the context) | |
1008 * If the value ends with a question mark `?` the question mark is | |
1009 stripped off and the value of the field `required` is set to `False` | |
1010 * The remaining value is assigned to the field `pattern` | |
1011 | |
1012 For implementation details and examples, please see | |
1013 [this section](SchemaSalad.html#Domain_Specific_Language_for_secondary_files) | |
1014 in the Schema Salad specification. | |
1015 | |
1016 - name: LoadListingRequirement | |
1017 type: record | |
1018 extends: ProcessRequirement | |
1019 doc: | | |
1020 Specify the desired behavior for loading the `listing` field of | |
1021 a Directory object for use by expressions. | |
1022 fields: | |
1023 class: | |
1024 type: string | |
1025 doc: "Always 'LoadListingRequirement'" | |
1026 jsonldPredicate: | |
1027 "_id": "@type" | |
1028 "_type": "@vocab" | |
1029 loadListing: | |
1030 type: LoadListingEnum? | |
1031 jsonldPredicate: "cwl:loadListing" |