Mercurial > repos > shellac > guppy_basecaller

comparison env/lib/python3.7/site-packages/cwltool/schemas/v1.0/Process.yml @ 0:26e78fe6e8c4 draft

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