WIP new archive/run selection

protzilla/data_analysis/protein_graphs.py

@@ -12,7 +12,7 @@
 from logging import INFO, ERROR
 
 
-def variation_graph(protein_id: str, run_name: str):
+def variation_graph(protein_id: str, run_name="Protgraph"):
     """
     Wrapper function for creating a Protein-Variation-Graph for a given UniProt Protein.
     VARIANT feature entries inserting amino acids are filtered out before graph creation
@@ -76,14 +76,24 @@ def _create_protein_variation_graph(protein_id: str, run_name: str) -> dict:
             messages=[dict(level=ERROR, msg=msg, trace=request.__dict__)],
         )
 
+    bingbong = Path(RUNS_PATH, "Protgraph/graphs/", f"{protein_id}.txt")
+
+
     output_folder_path = run_path / "graphs"
     output_csv = output_folder_path / f"{protein_id}.csv"
     graph_path = output_folder_path / f"{protein_id}.graphml"
-    cmd_str = f"protgraph -egraphml {path_to_protein_file} \
+    """cmd_str = f"protgraph {bingbong} \
+                -egraphml \
                 --export_output_folder={output_folder_path} \
                 --output_csv={output_csv} \
                 -ft VARIANT \
-                -d skip"
+                -d skip" """
+    cmd_str = f"""protgraph "{bingbong}" \
+    -egraphml \
+    --export_output_folder="{output_folder_path}" \
+    --output_csv="{output_csv}" \
+    --feature_table VARIANT \
+    --digestion skip"""
 
     subprocess.run(cmd_str, shell=True)
 

protzilla/disk_operator.py

@@ -6,7 +6,7 @@
 
 import pandas as pd
 import yaml
-from plotly.io import read_json, write_json
+from plotly.io import read_json, write_json, write_image
 
 import protzilla.utilities as utilities
 from protzilla.constants import paths
@@ -126,6 +126,7 @@ def read_run(self, file: Path | None = None) -> StepManager:
             return step_manager
 
     def write_run(self, step_manager: StepManager) -> None:
+        print("i try to wrtie")
         with ErrorHandler():
             if not self.run_dir.exists():
                 self.run_dir.mkdir(parents=True, exist_ok=True)
@@ -139,6 +140,9 @@ def write_run(self, step_manager: StepManager) -> None:
             for step in step_manager.all_steps:
                 run[KEYS.STEPS].append(self._write_step(step))
             self.yaml_operator.write(self.run_file, run)
+            print("i wrote the run!")
+
+
 
     def read_workflow(self) -> StepManager:
         return self.read_run(self.workflow_file)
@@ -223,22 +227,27 @@ def _write_step(self, step: Step, workflow_mode: bool = False) -> dict:
             step_data[KEYS.STEP_TYPE] = step.__class__.__name__
             step_data[KEYS.STEP_INSTANCE_IDENTIFIER] = step.instance_identifier
             step_data[KEYS.STEP_FORM_INPUTS] = sanitize_inputs(step.form_inputs)
+            print("write step:", step)
             if not workflow_mode:
+                print("write step 2")
                 step_data[KEYS.STEP_INPUTS] = sanitize_inputs(step.inputs)
-                step_data[KEYS.STEP_PLOTS] = self._write_plots(
+                print("write step 3")
+                step_data[KEYS.STEP_PLOTS] = self._write_plots(     #broken - Jannes, 10.04.2025
                     step.instance_identifier, step.plots
                 )
+                print("write step 4")
                 step_data[KEYS.STEP_OUTPUTS] = self._write_output(
                     instance_identifier=step.instance_identifier, output=step.output
                 )
                 step_data[KEYS.STEP_MESSAGES] = step.messages.messages
+                print("write step 5")
             return step_data
 
     def _read_outputs(self, output: dict) -> Output:
         with ErrorHandler():
             step_output = {}
             for key, value in output.items():
-                if isinstance(value, str) and Path(value).exists():
+                if isinstance(value, str) and Path(value).exists() and ".graphml" not in value:
                     step_output[key] = self.dataframe_operator.read(value)
                 else:
                     step_output[key] = value
@@ -266,16 +275,28 @@ def _read_plots(self, plots: dict) -> Plots:
 
     def _write_plots(self, instance_identifier: str, plots: Plots) -> dict:
         with ErrorHandler():
+            print("try to write plots")
+            print(plots)
             plots_data = {}
             for i, plot in enumerate(plots):
+                print(1)
                 file_path = self.plot_dir / f"{instance_identifier}_plot{i}.json"
+                print(2)
                 self.plot_dir.mkdir(parents=True, exist_ok=True)
+                print(3)
                 if not isinstance(
                     plot, bytes
                 ):  # TODO the data integration plots are of type byte, and therefore cannot be written using this methodology
+                    print(4)
                     write_json(plot, file_path)
-                    plot.write_image(str(file_path).replace(".json", ".png"))
+                    try: 
+                        plot.write_image(str(file_path).replace(".json", ".png"))
+                    except Exception as e:
+                        print(e)
+                    print(6)
                     plots_data[i] = str(file_path)
+                    print(7)
+            print("juhu")
             return plots_data
 
     @property

protzilla/methods/data_analysis.py

@@ -769,7 +769,7 @@ class ProteinGraphVariationGraph(DataAnalysisStep):
 
     input_keys = [
         "protein_id",
-        "run_name",
+        #"run_name",
     ]
     output_keys = [
         "graph_path",
@@ -780,8 +780,6 @@ def method(self, inputs: dict) -> dict:
         return variation_graph(**inputs)
 
     def insert_dataframes(self, steps: StepManager, inputs) -> dict:
-        inputs["peptide_df"] = steps.peptide_df
-        inputs["isoform_df"] = steps.isoform_df
         return inputs
 
 

protzilla/run.py

@@ -4,9 +4,14 @@
 import threading
 import traceback
 
+import os
+import shutil
+import datetime
+
 import protzilla.constants.paths as paths
 from protzilla.steps import Messages, Output, Plots, Step
 from protzilla.utilities import format_trace
+from protzilla.disk_operator import DiskOperator, YamlOperator
 
 
 def get_available_run_names() -> list[str]:
@@ -19,6 +24,68 @@ def get_available_run_names() -> list[str]:
         if not directory.name.startswith(".")
     ]
 
+def get_available_runinfo() -> tuple[list[dict[str, str | list[str]]], list[dict[str, str | list[str]]], set[str]]:
+    if not paths.RUNS_PATH.exists():
+        return []
+    runs = []
+    runs_favourited = []
+    all_tags = set()
+    for directory in paths.RUNS_PATH.iterdir():   #not sorted the same for different os?
+        if directory.name.startswith("."):
+            continue
+        name = directory.name
+        creation_time = directory.stat().st_ctime
+        modification_time = directory.stat().st_mtime
+
+        disk_operator = DiskOperator(name, "dummy_workflow_name")
+        directory_path = os.path.join(paths.RUNS_PATH, name)
+        run_yaml_path = os.path.join(directory_path, "run.yaml")
+        step_manager = disk_operator.read_run(run_yaml_path)
+        steps = step_manager.all_steps
+        step_names = []
+        for step in steps:
+            step_names.append(step.display_name)
+
+        # empty initialization to ensure backwardscompatibility for runs without metadata.yaml
+        favourite = False
+        tags = set()
+
+        metadata_yaml_path = os.path.join(directory_path, "metadata.yaml")
+        if os.path.isfile(metadata_yaml_path):
+            yaml_operator = YamlOperator()
+            metadata = yaml_operator.read(metadata_yaml_path)
+            tags = metadata.get("tags", set())
+            favourite = metadata.get("favourite", False)
+
+        for tag in tags:
+            all_tags.add(tag)
+
+        run = { 
+            "run_name": name,
+            "creation_date": datetime.datetime.fromtimestamp(creation_time).strftime("%d %m %Y"), #TODO: reutrn the pure datetime, convert in html)
+            "modification_date": datetime.datetime.fromtimestamp(modification_time).strftime("%d %m %Y"),
+            "memory_mode": step_manager.df_mode,
+            "run_steps" : step_names,
+            "favourite_status" : favourite,
+            "run_tags": tags
+            }
+
+        if favourite: 
+            runs_favourited.append(run)
+        else:
+            runs.append(run)
+
+    for run in runs + runs_favourited:
+        possible_tags = list(all_tags - run["run_tags"])
+        run["addable_tags"] = possible_tags
+
+    return (runs, runs_favourited, all_tags)
+
+def delete_run_folder(run_name) -> None:
+    path = os.path.join(paths.RUNS_PATH, run_name)
+
+    if os.path.isdir(path):
+        shutil.rmtree(path)
 
 class Run:
     class ErrorHandlingContextManager:

protzilla/run_v2.py

@@ -4,9 +4,6 @@
 import threading
 import traceback
 
-import os
-import shutil
-
 import protzilla.constants.paths as paths
 from protzilla.steps import Messages, Output, Plots, Step
 from protzilla.utilities import format_trace
@@ -21,12 +18,6 @@ def get_available_run_names() -> list[str]:
         if not directory.name.startswith(".")
     ]
 
-def delete_run_folder(run_name) -> None:
-    path = os.path.join(paths.RUNS_PATH, run_name)
-
-    if os.path.isdir(path):
-        shutil.rmtree(path)
-
 
 class Run:
     class ErrorHandlingContextManager:

requirements.txt

@@ -25,7 +25,7 @@ umap-learn==0.5.3
 Werkzeug==2.2.3
 numba==0.57.0
 Pillow==9.5.0
-kaleido==0.2.1
+kaleido==0.1.0.post1
 requests==2.31.0
 psutil==5.9.5
 tqdm==4.65.0

ui/runs/forms/data_analysis.py

@@ -1043,7 +1043,7 @@ def fill_form(self, run: Run) -> None:
 
 
 class ProteinGraphPeptidesToIsoformForm(MethodForm):
-    protein_ID = CustomCharField(
+    protein_id = CustomCharField(
         label="Protein ID", initial="Enter the Uniprot-ID of the protein"
     )
     # TODO: workflow_meta line 2255 - 2263
@@ -1058,7 +1058,7 @@ class ProteinGraphPeptidesToIsoformForm(MethodForm):
 
 
 class ProteinGraphVariationGraphForm(MethodForm):
-    protein_ID = CustomCharField(
+    protein_id = CustomCharField(
         label="Protein ID", initial="Enter the Uniprot-ID of the protein"
     )
     # TODO: workflow_meta line 2291 - 2295