Module Biokepi_run_environment.Common.KEDSL (.ml)

module KEDSL: sig .. end

This is an experimental extension of Ketrew's EDSL. If we're happy with it we'll push it upstream.

The idea is carry around a type parameter to have arbitrary products.

include Ketrew.EDSL

module Command: Ketrew_pure.Target.Command

type nothing = <

is_done : Condition.t option;

val nothing : < is_done : 'a option >

val target : 'a -> [> `Please_KEDSL_workflow ]

val file_target : 'a -> [> `Please_KEDSL_workflow ]

type file_workflow = single_file workflow_node

type phony_workflow = nothing workflow_node

type fastq_reads = <

	`escaped_sample_name : string;`
	`fragment_id : string option;`
	`fragment_id_forced : string;`
	`is_done : Ketrew_pure.Target.Condition.t option;`
	`paths : string * string option;`
	`r1 : single_file workflow_node;`
	`r2 : single_file workflow_node option;`
	`sample_name : string;`

val fastq_reads : ?host:Host.t ->
       ?name:string ->
       ?fragment_id:string ->
       string -> string option -> fastq_reads

val fastq_node_of_single_file_nodes : host:Host.t ->
       name:string ->
       ?fragment_id:string ->
       < is_done : Condition.t option; path : string; .. > product workflow_node ->
       < is_done : Condition.t option; path : string; .. > workflow_node option ->
       < escaped_sample_name : string; fragment_id : string option;
         fragment_id_forced : string; is_done : Condition.t option;
         paths : string * string option; r1 : single_file workflow_node;
         r2 : single_file workflow_node option; sample_name : string >
       workflow_node

Create a fastq_reads workflow_node from one or two single_file workflow_node(s).

type bam_file = <

	`host : Host.t;`
	`is_done : Ketrew_pure.Target.Condition.t option;`
	`path : string;`
	`reference_build : string;`
	sorting : [ `Coordinate \| `Read_name ] option;

val bam_file : host:Host.t ->
       ?sorting:[ `Coordinate | `Read_name ] ->
       reference_build:string ->
       string -> bam_file

val transform_bam : ?change_sorting:[ `Coordinate | `Read_name ] ->
       bam_file ->
       path:string -> bam_file

Make a new bam sharing most of the metadata.

type bam_list = <

	`bams : bam_file list;`
	`is_done : Ketrew_pure.Target.Condition.t option;`

val bam_list : bam_file list ->
       bam_list

val explode_bam_list_node : bam_list workflow_node ->
       < host : Host.t; is_done : Condition.t option; path : string;
         reference_build : string; sorting : [ `Coordinate | `Read_name ] option >
       workflow_node list

type '_ bam_or_bams =

`\|`	`Single_bam : bam_file workflow_node -> bam_file workflow_node bam_or_bams`
`\|`	`Bam_workflow_list : bam_file workflow_node list -> bam_list workflow_node bam_or_bams`

val submit : < is_done : Ketrew.EDSL.Condition.t option; .. > Ketrew.EDSL.product
       Ketrew.EDSL.workflow_node -> unit