feat: generate Makefile with log --format Makefile

Author: jirikuncar

renku/cli/_format.py

@@ -278,6 +278,33 @@ def color(p):
     stream.write('}\n')
 
 
+def makefile(graph):
+    """Format graph as Makefile."""
+    from renku._compat import Path
+    from renku.models.provenance.activities import ProcessRun, WorkflowRun
+
+    for activity in graph.activities.values():
+        if not isinstance(activity, ProcessRun):
+            continue
+        elif isinstance(activity, WorkflowRun):
+            steps = activity.subprocesses.values()
+        else:
+            steps = [activity]
+
+        for step in steps:
+            click.echo(' '.join(step.outputs) + ': ' + ' '.join(step.inputs))
+
+            tool = step.process
+            basedir = Path(step.path).parent
+
+            click.echo(
+                '\t@' + ' '.join(tool.to_argv()) + ' ' + ' '.join(
+                    tool.STD_STREAMS_REPR[key] + ' ' + str(path)
+                    for key, path in tool._std_streams(basedir=basedir).items()
+                )
+            )
+
+
 def jsonld(graph):
     """Format graph as JSON-LD file."""
     click.echo(_jsonld(graph, 'expand'))
@@ -327,6 +354,7 @@ def rdf(graph):
     'dot-debug': dot_debug,
     'json-ld': jsonld,
     'json-ld-graph': jsonld_graph,
+    'Makefile': makefile,
     'nt': nt,
     'rdf': rdf,
 }

renku/models/cwl/command_line_tool.py

@@ -18,6 +18,7 @@
 """Represent a ``CommandLineTool`` from the Common Workflow Language."""
 
 import fnmatch
+import os
 import re
 import shlex
 from contextlib import contextmanager
@@ -50,6 +51,13 @@ def convert_arguments(value):
 class CommandLineTool(Process, CWLClass):
     """Represent a command line tool."""
 
+    STD_STREAMS_REPR = {
+        'stdin': '<',
+        'stdout': '>',
+        'stderr': '2>',
+    }
+    """Format streams for a shell command representation."""
+
     # specialize inputs and outputs with Command{Input,Output}Parameter
 
     baseCommand = attr.ib(
@@ -72,21 +80,32 @@ class CommandLineTool(Process, CWLClass):
     temporaryFailCodes = attr.ib(default=attr.Factory(list))  # list(int)
     permanentFailCodes = attr.ib(default=attr.Factory(list))  # list(int)
 
-    def __str__(self):
-        """Generate a simple representation."""
-        argv = ' '.join(self.to_argv())
+    def _std_streams(self, basedir=None):
+        """Return mapped standard streams."""
+        streams = {}
+
         if self.stdin:
             assert self.stdin.startswith('$(inputs.')
             input_id = self.stdin.split('.')[1]
             for input_ in self.inputs:
                 if input_id == input_.id:
-                    argv += ' < ' + str(input_.default)
+                    streams['stdin'] = os.path.relpath(
+                        str(Path(basedir or '.') / str(input_.default))
+                    )
                     break
         if self.stdout:
-            argv += ' > ' + self.stdout
+            streams['stdout'] = self.stdout
         if self.stderr:
-            argv += ' 2> ' + self.stderr
-        return argv
+            streams['stderr'] = self.stderr
+
+        return streams
+
+    def __str__(self):
+        """Generate a simple representation."""
+        return ' '.join(self.to_argv()) + ' ' + ' '.join(
+            self.STD_STREAMS_REPR[key] + ' ' + str(path)
+            for key, path in self._std_streams().items()
+        )
 
     def create_run(self, **kwargs):
         """Return an instance of process run."""

tests/test_cwl.py

@@ -251,8 +251,10 @@ def test_stdin_and_stdout(argv, instance_path):
 
     tool = factory.generate_tool()
     assert tool.to_argv() == argv
-    std_streams = ' < input.txt > output.txt 2> error.log'
-    assert str(tool) == ' '.join(argv) + std_streams
+    std_streams = (' < input.txt', ' > output.txt', ' 2> error.log')
+    tool_str = str(tool)
+    assert tool_str.startswith(' '.join(argv))
+    assert all(stream in tool_str for stream in std_streams)
 
 
 def test_input_directory(instance_path):