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