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