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