graph2cwl 0.0.1__tar.gz

graph2cwl-0.0.1/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: graph2cwl
+Version: 0.0.1
+Summary: Helper to generate cwl workflows
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: cwl-utils>=0.40
+
+# graph2cwl
+
+Python module that interfaces with cwl-utils in order to generate cwl files.
+
+## Getting Started
+
+```bash
+pip install graph2cwl
+```
+
+Here is a code snippet :
+
+```python
+from graph2cwl import WorkflowCreator
+
+wf = WorkflowCreator(id="wf")
+wf.add_step(id="step_1", run="./my_file.py")
+wf.add_step(id="step_2", run="./my_file_2.py")
+wf.add_dependency("step_1", "step_2", dep_name="step_1_out")
+wf.add_workflow_input("input_1")
+wf.add_workflow_output("output", outputSource="step_1/step_1_out")
+wf.add_dependency("input_1", "step_2")
+wf.add_dependency("input_1", "step_1")
+
+wf.to_yaml("wf.yaml")
+```
+
+This creates the following valid cwl:
+
+```yaml
+id: w
+class: Workflow
+inputs:
+  - id: input_1
+    type: File
+outputs:
+  - id: output
+    outputSource: step_1/step_1_out
+    type: File
+cwlVersion: v1.2
+steps:
+  - id: step_1
+    in:
+      - id: xehsftvk
+        source: input_1
+    out:
+      - step_1_out
+    run: my_file.py
+  - id: step_2
+    in:
+      - id: fwfmzpkk
+        source: step_1/step_1_out
+      - id: ellhmrzg
+        source: input_1
+    out: []
+    run: my_file_2.py
+```
+
+which can be visualized (see [cwl2nx](https://github.com/mariusgarenaux/cwl2nx)):
+
+```text
+• w/input_1
+├─• w/step_1
+│ ╰─• w/step_1/step_1_out
+│   ├─• w/output
+╰───┴─• w/step_2
+```
+
+## Advanced usage
+
+To embed the cwl with additionnal information, you must follow the cwl specification, implemented in cwl-utils. For example, to insert additional informations to a step, you can add the `hints` argument, or the `extension_field` one :
+
+```python
+from graph2cwl import WorkflowCreator
+
+wf = WorkflowCreator(id="w")
+wf.add_step(id="step_1", run="./my_file.py", hints={"hint1": "value1"})
+wf.add_step(id="step_2", run="./my_file_2.py")
+wf.add_dependency("step_1", "step_2", dep_name="step_1_out")
+wf.add_workflow_input("input_1", extension_fields={"additional_field": "het"})
+wf.add_workflow_output("output", outputSource="step_1/step_1_out")
+wf.add_dependency("input_1", "step_2")
+wf.add_dependency("input_1", "step_1")
+
+wf.to_yaml("wf2.yaml")
+```
+
+See : https://cwl-utils.readthedocs.io/en/latest/autoapi/cwl_utils/parser/cwl_v1_2/index.html#cwl_utils.parser.cwl_v1_2.WorkflowStep for the list of supported arguments.

graph2cwl-0.0.1/README.md

@@ -0,0 +1,88 @@
+# graph2cwl
+
+Python module that interfaces with cwl-utils in order to generate cwl files.
+
+## Getting Started
+
+```bash
+pip install graph2cwl
+```
+
+Here is a code snippet :
+
+```python
+from graph2cwl import WorkflowCreator
+
+wf = WorkflowCreator(id="wf")
+wf.add_step(id="step_1", run="./my_file.py")
+wf.add_step(id="step_2", run="./my_file_2.py")
+wf.add_dependency("step_1", "step_2", dep_name="step_1_out")
+wf.add_workflow_input("input_1")
+wf.add_workflow_output("output", outputSource="step_1/step_1_out")
+wf.add_dependency("input_1", "step_2")
+wf.add_dependency("input_1", "step_1")
+
+wf.to_yaml("wf.yaml")
+```
+
+This creates the following valid cwl:
+
+```yaml
+id: w
+class: Workflow
+inputs:
+  - id: input_1
+    type: File
+outputs:
+  - id: output
+    outputSource: step_1/step_1_out
+    type: File
+cwlVersion: v1.2
+steps:
+  - id: step_1
+    in:
+      - id: xehsftvk
+        source: input_1
+    out:
+      - step_1_out
+    run: my_file.py
+  - id: step_2
+    in:
+      - id: fwfmzpkk
+        source: step_1/step_1_out
+      - id: ellhmrzg
+        source: input_1
+    out: []
+    run: my_file_2.py
+```
+
+which can be visualized (see [cwl2nx](https://github.com/mariusgarenaux/cwl2nx)):
+
+```text
+• w/input_1
+├─• w/step_1
+│ ╰─• w/step_1/step_1_out
+│   ├─• w/output
+╰───┴─• w/step_2
+```
+
+## Advanced usage
+
+To embed the cwl with additionnal information, you must follow the cwl specification, implemented in cwl-utils. For example, to insert additional informations to a step, you can add the `hints` argument, or the `extension_field` one :
+
+```python
+from graph2cwl import WorkflowCreator
+
+wf = WorkflowCreator(id="w")
+wf.add_step(id="step_1", run="./my_file.py", hints={"hint1": "value1"})
+wf.add_step(id="step_2", run="./my_file_2.py")
+wf.add_dependency("step_1", "step_2", dep_name="step_1_out")
+wf.add_workflow_input("input_1", extension_fields={"additional_field": "het"})
+wf.add_workflow_output("output", outputSource="step_1/step_1_out")
+wf.add_dependency("input_1", "step_2")
+wf.add_dependency("input_1", "step_1")
+
+wf.to_yaml("wf2.yaml")
+```
+
+See : https://cwl-utils.readthedocs.io/en/latest/autoapi/cwl_utils/parser/cwl_v1_2/index.html#cwl_utils.parser.cwl_v1_2.WorkflowStep for the list of supported arguments.

graph2cwl-0.0.1/pyproject.toml

@@ -0,0 +1,8 @@
+[project]
+
+name = "graph2cwl"
+version = "0.0.1"
+description = "Helper to generate cwl workflows"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = ["cwl-utils>=0.40"]

graph2cwl-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

graph2cwl-0.0.1/src/graph2cwl/__init__.py

@@ -0,0 +1 @@
+from .creator import WorkflowCreator, WorkflowStepCreator

graph2cwl-0.0.1/src/graph2cwl/creator.py

@@ -0,0 +1,264 @@
+# Base python dependencies
+from typing import Literal, Optional, Any, Type
+import random
+import re
+
+# Externel dependencies
+from ruamel.yaml import YAML
+from cwl_utils.parser import cwl_v1_0, cwl_v1_1, cwl_v1_2
+
+CWLVersion = Literal["v1.0", "v1.1", "v1.2"]
+
+
+def random_name():
+    return "".join(
+        random.choice(re.escape("abcdefghijklmnopqrstuvwxyz")) for _ in range(8)
+    )
+
+
+class WorkflowStepCreator:
+    def __init__(
+        self,
+        WorkflowStep: (
+            Type[cwl_v1_0.WorkflowStep]
+            | Type[cwl_v1_1.WorkflowStep]
+            | Type[cwl_v1_2.WorkflowStep]
+        ),
+        id: str,
+        kwargs: Optional[dict[str, Any]] = None,
+    ):
+        """
+        Buffer class of cwl_utils WorkflowStep; that stores the initialization arguments
+        while the dependencies between task are created.
+        """
+        self.WorkflowStep = WorkflowStep
+        self.id = id
+        if kwargs is None:
+            kwargs = {}
+        self.kwargs = kwargs
+
+        if self.kwargs.get("out", None) is None:
+            self.kwargs["out"] = []
+
+        if self.kwargs.get("in_", None) is None:
+            self.kwargs["in_"] = []
+
+    def create_cwl_utils_obj(
+        self,
+    ) -> cwl_v1_0.WorkflowStep | cwl_v1_1.WorkflowStep | cwl_v1_2.WorkflowStep:
+        return self.WorkflowStep(id=self.id, **self.kwargs)
+
+
+class WorkflowCreator:
+    """
+    Helper class that allows to create cwl files, only from the steps.
+    It deals with WorkflowStepInput, WorkflowStepOutput so that
+    the end user does not have to use them.
+    """
+
+    def __init__(self, cwl_version: CWLVersion = "v1.2", id: Optional[str] = None):
+        if cwl_version not in ["v1.0", "v1.1", "v1.2"]:
+            raise ValueError(
+                f"Unexpected cwl version : `{cwl_version}`. Expected one among `v1.0`, `v1.1`, `v1.2`."
+            )
+        match cwl_version:
+            case "v1.0":
+                self.cwl_module = cwl_v1_0
+            case "v1.1":
+                self.cwl_module = cwl_v1_1
+            case "v1.2":
+                self.cwl_module = cwl_v1_2
+
+        self.cwl_version = cwl_version
+        self.id = id
+        self.WorkflowStep = self.cwl_module.WorkflowStep
+        self.WorkflowOutputParameter = self.cwl_module.WorkflowOutputParameter
+        if hasattr(self.cwl_module, "WorkflowInputParameter"):
+            self.WorkflowInputParameter = (
+                self.cwl_module.WorkflowInputParameter  # pyright: ignore
+            )
+
+        self.WorkflowStepInput = self.cwl_module.WorkflowStepInput
+        self.WorkflowStepOutput = self.cwl_module.WorkflowStepOutput
+        self.Workflow = self.cwl_module.Workflow
+
+        self.all_step_creators: dict[str, WorkflowStepCreator] = {}
+        self.all_workflow_inputs: dict[str, Any] = {}
+        self.all_workflow_outputs: dict[str, Any] = {}
+
+    def add_step(
+        self,
+        id: str,
+        **kwargs,
+    ) -> WorkflowStepCreator:
+        """
+        Adds a step to the workflow creator.
+
+        Parameters :
+        ---
+            - id (str): the name of the step
+            - **kwargs : any named arguments (different of the one above)
+                that will be given to cwl_utils.parser.cwl_<version>.WorkflowStep creator.
+        """
+        new_step = WorkflowStepCreator(self.WorkflowStep, id=id, kwargs=kwargs)
+        self.all_step_creators[id] = new_step
+        return new_step
+
+    def _add_dependency_from_input_param_to_step(
+        self, from_input: str, to_step: str, dep_name: Optional[str] = None
+    ):
+        if from_input not in self.all_workflow_inputs:
+            raise KeyError(
+                f"No workflow input parameter was found with id `{from_input}`. Available inputs are : {self.all_workflow_inputs}"
+            )
+
+        if to_step not in self.all_step_creators:
+            raise KeyError(
+                f"Could not find any step of the workflow with id `{to_step}`"
+            )
+
+        end_step = self.all_step_creators[to_step]
+
+        dep_name = random_name() if dep_name is None else dep_name
+
+        # creates output of start step
+
+        # creates input parameter for the end step
+        step_input = self.WorkflowStepInput(dep_name, source=from_input)
+        end_step.kwargs["in_"].append(step_input)
+
+    def _add_dependency_from_step_to_step(
+        self,
+        from_step: str,
+        to_step: str,
+        dep_name: Optional[str] = None,
+    ):
+        """
+        Creates a dependency between the step with id `from_step` and
+        the one with if `to_step`.
+        """
+        if from_step not in self.all_step_creators:
+            raise KeyError(
+                f"Could not find any step of the workflow with id `{from_step}`"
+            )
+        if to_step not in self.all_step_creators:
+            raise KeyError(
+                f"Could not find any step of the workflow with id `{to_step}`"
+            )
+        start_step = self.all_step_creators[from_step]
+        end_step = self.all_step_creators[to_step]
+
+        dep_name = random_name() if dep_name is None else dep_name
+
+        # creates output of start step
+        start_step.kwargs["out"].append(dep_name)
+
+        # creates input parameter for the end step
+        step_input = self.WorkflowStepInput(
+            random_name(), source=f"{start_step.id}/{dep_name}"
+        )
+        end_step.kwargs["in_"].append(step_input)
+
+    def add_dependency(
+        self, from_elem: str, to_step: str, dep_name: Optional[str] = None
+    ):
+        """
+        Creates a dependency between either :
+            - a workflow input parameter and a step
+            - two steps of the workflow
+
+        Parameters :
+        ---
+            - from_elem (str): either an id of a input parameter of the workflow,
+                or the id of a step. The method first seek for a matching step.
+            - to_step (str): the id of the end step
+            - dep_name (Optional[str] = None): the name of the dependency
+        """
+        if from_elem not in self.all_step_creators:
+            if from_elem in self.all_workflow_inputs:
+                self._add_dependency_from_input_param_to_step(
+                    from_elem, to_step, dep_name
+                )
+                return
+            else:
+                raise ValueError(
+                    f"Could not find any object of the workflow with id `{from_elem}`"
+                )
+
+        self._add_dependency_from_step_to_step(from_elem, to_step, dep_name)
+
+    def add_workflow_input(self, id: str, **kwargs):
+        """
+        Adds an input to the workflow with id. Any keyword argument can be given,
+        it will be forwarded to cwl_utils WorkflowInputParameter constructor.
+        """
+        if "type_" not in kwargs:
+            kwargs["type_"] = "File"
+
+        self.all_workflow_inputs[id] = self.WorkflowInputParameter(id=id, **kwargs)
+
+    def add_workflow_output(self, id: str, **kwargs):
+        """
+        Adds an output to the workflow with id. Any keyword argument can be given,
+        it will be forwarded to cwl_utils WorkflowInputParameter constructor.
+
+        Parameters :
+        ---
+            - id (str) : the id of the Workflow Output Parameter
+        """
+        if "type_" not in kwargs:
+            kwargs["type_"] = "File"
+
+        self.all_workflow_outputs[id] = self.WorkflowOutputParameter(id=id, **kwargs)
+
+    def build(self, **kwargs):
+        """
+        Creates the cwl_utils Workflow Object
+        """
+        all_cwl_steps = []
+        for each_step_id, each_step in self.all_step_creators.items():
+            try:
+                cwl_step = each_step.create_cwl_utils_obj()
+            except Exception as e:
+                raise Exception(
+                    f"Could not create the step with id {each_step_id}"
+                ) from e
+            else:
+                all_cwl_steps.append(cwl_step)
+
+        return self.Workflow(
+            id=self.id,
+            inputs=list(self.all_workflow_inputs.values()),
+            outputs=list(self.all_workflow_outputs.values()),
+            steps=all_cwl_steps,
+            cwlVersion=self.cwl_version,
+            **kwargs,
+        )
+
+    def to_dict(self, **kwargs) -> dict:
+        """
+        Shortcut that calls self.create; followed by cwl_utils save method.
+        Returns a YAML/JSON friendly python dictionnary
+        """
+        return self.build().save(**kwargs)
+
+    def to_yaml(self, file_name: str, **kwargs):
+        """
+        Build the cwl and save it to a yaml file located at `file_name`
+        """
+        yaml = YAML()
+        with open(file_name, "wt") as f:
+            yaml.dump(self.to_dict(**kwargs), f)
+
+
+if __name__ == "__main__":
+    wf = WorkflowCreator(id="w")
+    wf.add_step(id="step_1", run="./my_file.py")
+    wf.add_step(id="step_2", run="./my_file_2.py")
+    wf.add_dependency("step_1", "step_2", dep_name="step_1_out")
+    wf.add_workflow_input("input_1")
+    wf.add_workflow_output("output", outputSource="step_1/step_1_out")
+    wf.add_dependency("input_1", "step_2")
+    wf.add_dependency("input_1", "step_1")
+
+    print(wf.to_dict())

graph2cwl-0.0.1/src/graph2cwl.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: graph2cwl
+Version: 0.0.1
+Summary: Helper to generate cwl workflows
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: cwl-utils>=0.40
+
+# graph2cwl
+
+Python module that interfaces with cwl-utils in order to generate cwl files.
+
+## Getting Started
+
+```bash
+pip install graph2cwl
+```
+
+Here is a code snippet :
+
+```python
+from graph2cwl import WorkflowCreator
+
+wf = WorkflowCreator(id="wf")
+wf.add_step(id="step_1", run="./my_file.py")
+wf.add_step(id="step_2", run="./my_file_2.py")
+wf.add_dependency("step_1", "step_2", dep_name="step_1_out")
+wf.add_workflow_input("input_1")
+wf.add_workflow_output("output", outputSource="step_1/step_1_out")
+wf.add_dependency("input_1", "step_2")
+wf.add_dependency("input_1", "step_1")
+
+wf.to_yaml("wf.yaml")
+```
+
+This creates the following valid cwl:
+
+```yaml
+id: w
+class: Workflow
+inputs:
+  - id: input_1
+    type: File
+outputs:
+  - id: output
+    outputSource: step_1/step_1_out
+    type: File
+cwlVersion: v1.2
+steps:
+  - id: step_1
+    in:
+      - id: xehsftvk
+        source: input_1
+    out:
+      - step_1_out
+    run: my_file.py
+  - id: step_2
+    in:
+      - id: fwfmzpkk
+        source: step_1/step_1_out
+      - id: ellhmrzg
+        source: input_1
+    out: []
+    run: my_file_2.py
+```
+
+which can be visualized (see [cwl2nx](https://github.com/mariusgarenaux/cwl2nx)):
+
+```text
+• w/input_1
+├─• w/step_1
+│ ╰─• w/step_1/step_1_out
+│   ├─• w/output
+╰───┴─• w/step_2
+```
+
+## Advanced usage
+
+To embed the cwl with additionnal information, you must follow the cwl specification, implemented in cwl-utils. For example, to insert additional informations to a step, you can add the `hints` argument, or the `extension_field` one :
+
+```python
+from graph2cwl import WorkflowCreator
+
+wf = WorkflowCreator(id="w")
+wf.add_step(id="step_1", run="./my_file.py", hints={"hint1": "value1"})
+wf.add_step(id="step_2", run="./my_file_2.py")
+wf.add_dependency("step_1", "step_2", dep_name="step_1_out")
+wf.add_workflow_input("input_1", extension_fields={"additional_field": "het"})
+wf.add_workflow_output("output", outputSource="step_1/step_1_out")
+wf.add_dependency("input_1", "step_2")
+wf.add_dependency("input_1", "step_1")
+
+wf.to_yaml("wf2.yaml")
+```
+
+See : https://cwl-utils.readthedocs.io/en/latest/autoapi/cwl_utils/parser/cwl_v1_2/index.html#cwl_utils.parser.cwl_v1_2.WorkflowStep for the list of supported arguments.

graph2cwl-0.0.1/src/graph2cwl.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/graph2cwl/__init__.py
+src/graph2cwl/creator.py
+src/graph2cwl.egg-info/PKG-INFO
+src/graph2cwl.egg-info/SOURCES.txt
+src/graph2cwl.egg-info/dependency_links.txt
+src/graph2cwl.egg-info/requires.txt
+src/graph2cwl.egg-info/top_level.txt

graph2cwl-0.0.1/src/graph2cwl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

graph2cwl-0.0.1/src/graph2cwl.egg-info/requires.txt

@@ -0,0 +1 @@
+cwl-utils>=0.40

graph2cwl-0.0.1/src/graph2cwl.egg-info/top_level.txt

@@ -0,0 +1 @@
+graph2cwl