Draft: BowtieBuilder status

.github/workflows/test-spras.yml

@@ -85,6 +85,16 @@ jobs:
         docker pull reedcompbio/domino:latest
         docker pull reedcompbio/py4cytoscape:v3
         docker pull reedcompbio/spras:v0.1.0
+        docker pull reedcompbio/bowtiebuilder:v1
+    - name: Build BowtieBuilder Docker Image
+      uses: docker/build-push-action@v1
+      with:
+        path: docker-wrappers/BowTieBuilder
+        dockerfile: docker-wrappers/BowTieBuilder/Dockerfile
+        respository: reedcompbio/bowtiebuilder
+        tags: latest
+        cache_from: reedcompbio/bowtiebuilder:v1
+        push: false    
     - name: Build Omics Integrator 1 Docker image
       uses: docker/build-push-action@v1
       with:

config/config.yaml

@@ -43,6 +43,7 @@ container_registry:
 # careful: too many parameters might make your runs take a long time.
 
 algorithms:
+
       - name: "pathlinker"
         params:
               include: true
@@ -92,6 +93,9 @@ algorithms:
               run1:
                   slice_threshold: [0.3]
                   module_threshold: [0.05]
+      - name: "bowtiebuilder"
+        params:
+              include: true
 
 
 # Here we specify which pathways to run and other file location information.
@@ -116,6 +120,7 @@ datasets:
       # Relative path from the spras directory
       data_dir: "input"
 
+
 # If we want to reconstruct then we should set run to true.
 # TODO: if include is true above but run is false here, algs are not run.
 # is this the behavior we want?

docker-wrappers/BowTieBuilder/Dockerfile

@@ -0,0 +1,5 @@
+FROM python:3.8-bullseye
+
+WORKDIR /btb
+RUN wget https://raw.githubusercontent.com/Reed-CompBio/BowTieBuilder-Algorithm/main/btb.py
+RUN pip install networkx==2.8

docker-wrappers/BowTieBuilder/README.md

@@ -0,0 +1,15 @@
+# BowTieBuilder Docker image
+
+A Docker image for [BowTieBuilder](https://github.com/Reed-CompBio/BowTieBuilder-Algorithm) that is available on [DockerHub](https://hub.docker.com/repository/docker/reedcompbio/bowtiebuilder).
+
+To create the Docker image run:
+```
+docker build -t reedcompbio/bowtiebuilder:v1 -f Dockerfile .
+```
+from this directory.
+
+## Original Paper
+
+The original paper for [BowTieBuilder] can be accessed here:
+
+Supper, J., Spangenberg, L., Planatscher, H. et al. BowTieBuilder: modeling signal transduction pathways. BMC Syst Biol 3, 67 (2009). https://doi.org/10.1186/1752-0509-3-67

spras/btb.py

@@ -0,0 +1,174 @@
+# need to define a new btb class and contain the following functions
+# - generate_inputs
+# - run
+# - parse_output
+
+import warnings
+from pathlib import Path
+
+import pandas as pd
+
+from spras.containers import prepare_volume, run_container
+from spras.interactome import (
+    convert_undirected_to_directed,
+    reinsert_direction_col_directed,
+)
+
+from spras.prm import PRM
+
+__all__ = ['BowtieBuilder']
+
+class BowtieBuilder(PRM):
+    required_inputs = ['sources', 'targets', 'edges']
+
+    #generate input taken from meo.py beacuse they have same input requirements
+    @staticmethod
+    def generate_inputs(data, filename_map):
+        """
+        Access fields from the dataset and write the required input files
+        @param data: dataset
+        @param filename_map: a dict mapping file types in the required_inputs to the filename for that type
+        @return:
+        """
+        for input_type in BowtieBuilder.required_inputs:
+            if input_type not in filename_map:
+                raise ValueError(f"{input_type} filename is missing")
+        print("FILEMAP NAME: ", filename_map)
+        print("DATA HEAD: ")
+        print( data.node_table.head())
+        print("DATA INTERACTOME: ")
+        print(data.interactome.head())
+
+        # Get sources and write to file, repeat for targets
+        # Does not check whether a node is a source and a target
+        for node_type in ['sources', 'targets']:
+            nodes = data.request_node_columns([node_type])
+            if nodes is None:
+                raise ValueError(f'No {node_type} found in the node files')
+
+            # TODO test whether this selection is needed, what values could the column contain that we would want to
+            # include or exclude?
+            nodes = nodes.loc[nodes[node_type]]
+            if(node_type == "sources"):
+                nodes.to_csv(filename_map["sources"], sep= '\t', index=False, columns=['NODEID'], header=False)
+                print("NODES: ")
+                print(nodes)
+            elif(node_type == "targets"):
+                nodes.to_csv(filename_map["targets"], sep= '\t', index=False, columns=['NODEID'], header=False)
+                print("NODES: ")
+                print(nodes)
+
+
+        # Create network file
+        edges = data.get_interactome()
+
+        # Format into directed graph
+        edges = convert_undirected_to_directed(edges)
+
+        edges.to_csv(filename_map['edges'], sep='\t', index=False, header=False)
+
+
+
+    # Skips parameter validation step
+    @staticmethod
+    def run(sources=None, targets=None, edges=None, output_file=None, container_framework="docker"):
+        """
+        Run PathLinker with Docker
+        @param sources:  input source file (required)
+        @param targets:  input target file (required)
+        @param edges:    input edge file (required)
+        @param output_file: path to the output pathway file (required)
+        @param container_framework: choose the container runtime framework, currently supports "docker" or "singularity" (optional)
+        """
+
+        # Tests for pytest (docker container also runs this) 
+        # Testing out here avoids the trouble that container errors provide
+
+        if not sources or not targets or not edges or not output_file:
+            raise ValueError('Required BowtieBuilder arguments are missing')
+
+        if not Path(sources).exists() or not Path(targets).exists() or not Path(edges).exists():
+            raise ValueError('Missing input file')
+
+        # Testing for btb index errors
+        # It's a bit messy, but it works \_('_')_/
+        with open(edges, 'r') as edge_file:
+            try:
+                for line in edge_file:
+                    line = line.strip()
+                    line = line.split('\t')
+                    line = line[2]
+
+            except Exception as err:
+                raise(err)
+
+        work_dir = '/btb'
+
+        # Each volume is a tuple (src, dest)
+        volumes = list()
+
+        bind_path, source_file = prepare_volume(sources, work_dir)
+        volumes.append(bind_path)
+
+        bind_path, target_file = prepare_volume(targets, work_dir)
+        volumes.append(bind_path)
+
+        bind_path, edges_file = prepare_volume(edges, work_dir)
+        volumes.append(bind_path)
+
+        # PathLinker does not provide an argument to set the output directory
+        # Use its --output argument to set the output file prefix to specify an absolute path and prefix
+        out_dir = Path(output_file).parent
+        # PathLinker requires that the output directory exist
+        out_dir.mkdir(parents=True, exist_ok=True)
+        bind_path, mapped_out_dir = prepare_volume(str(out_dir), work_dir)
+        volumes.append(bind_path)
+        mapped_out_prefix = mapped_out_dir + '/raw-pathway.txt'  # Use posix path inside the container
+
+        command = ['python',
+                   'btb.py',
+                   '--edges',
+                   edges_file,
+                   '--sources',
+                   source_file,
+                   '--target',
+                   target_file,
+                   '--output',
+                   mapped_out_prefix]
+        # command = ['ls', '-R']
+
+
+        print('Running BowtieBuilder with arguments: {}'.format(' '.join(command)), flush=True)
+
+        container_suffix = "bowtiebuilder:v1"
+        out = run_container(container_framework,
+                            container_suffix,
+                            command,
+                            volumes,
+                            work_dir)
+        print(out)
+        print("Source file: ", source_file)
+        print("target file: ", target_file)
+        print("edges file: ", edges_file)
+        print("mapped out dir: ", mapped_out_dir)
+        print("mapped out prefix: ", mapped_out_prefix)
+
+
+        # Output is already written to raw-pathway.txt file
+        # output_edges = Path(next(out_dir.glob('out*-ranked-edges.txt')))
+        # output_edges.rename(output_file)
+
+
+    @staticmethod
+    def parse_output(raw_pathway_file, standardized_pathway_file):
+        """
+        Convert a predicted pathway into the universal format
+        @param raw_pathway_file: pathway file produced by an algorithm's run function
+        @param standardized_pathway_file: the same pathway written in the universal format
+        """
+        # What about multiple raw_pathway_files
+        print("PARSING OUTPUT BTB")
+        df = pd.read_csv(raw_pathway_file, sep='\t')
+        df = reinsert_direction_col_directed(df)
+        print(df)
+        df.to_csv(standardized_pathway_file, header=False, index=False, sep='\t')

spras/runner.py

@@ -7,6 +7,7 @@
 from spras.omicsintegrator1 import OmicsIntegrator1 as omicsintegrator1
 from spras.omicsintegrator2 import OmicsIntegrator2 as omicsintegrator2
 from spras.pathlinker import PathLinker as pathlinker
+from spras.btb import BowtieBuilder as bowtiebuilder
 
 
 def run(algorithm, params):

test/BowtieBuilder/expected/output1.txt

@@ -0,0 +1,7 @@
+Node1	Node2
+A	D
+B	D
+C	D
+D	F
+D	G
+D	E

test/BowtieBuilder/input/edges.txt

@@ -0,0 +1,6 @@
+A	D	5
+B	D	1.3
+C	D	0.4
+D	E	4.5
+D	F	2
+D	G	3.2

test/BowtieBuilder/input/edges_bad.txt

@@ -0,0 +1,6 @@
+A	D	5
+B	D	1.3
+C	0.4
+D	E	4.5
+D	F	2
+D	G	3.2

test/LocalNeighborhood/input/ln-nodes.txt → test/BowtieBuilder/input/source.txt

@@ -1,2 +1,3 @@
 A
 B
+C