445 Fix ultra-wide tables (again)

backend/.gitignore

@@ -9,6 +9,7 @@
 !user_data/workflows/only_import.yaml
 !user_data/workflows/only_import_and_filter_proteins.yaml
 !user_data/workflows/standard.yaml
+!user_data/workflows/cl_monomer.yaml
 !user_data/workflows/.test-run-empty.yaml
 !user_data/example_dataset
 

backend/main/urls.py

@@ -49,6 +49,16 @@
     path("api/save_workflow/", views.save_workflow, name="save_workflow"),
     path("api/get_step_form/", views.get_step_form, name="get_step_form"),
     path("api/get_step_plots/", views.get_step_plots, name="get_step_plots"),
+    path(
+        "api/get_step_visualizations/",
+        views.get_step_visualizations,
+        name="get_step_visualizations",
+    ),
+    path(
+        "api/get_downloads_from_step/",
+        views.get_downloads_from_step,
+        name="get_downloads_from_step",
+    ),
     path(
         "api/get_current_step_output_labels/",
         views.get_current_step_output_labels,
@@ -76,6 +86,61 @@
     path("api/get_databases", views_settings.get_databases, name="get_databases"),
     path("api/upload_database", views_settings.database_upload, name="database_upload"),
     path("api/delete_database", views_settings.database_delete, name="database_delete"),
+    path(
+        "api/get_monomer_structure",
+        views_settings.get_monomer_structure,
+        name="get_monomer_structure",
+    ),
+    path(
+        "api/upload_monomer_structure",
+        views_settings.upload_monomer_structure,
+        name="upload_monomer_structure",
+    ),
+    path(
+        "api/delete_monomer_structure",
+        views_settings.delete_monomer_structure,
+        name="delete_monomer_structure",
+    ),
+    path(
+        "api/get_multimer_structure",
+        views_settings.get_multimer_structure,
+        name="get_multimer_structure",
+    ),
+    path(
+        "api/upload_multimer_structure",
+        views_settings.upload_multimer_structure,
+        name="upload_multimer_structure",
+    ),
+    path(
+        "api/delete_multimer_structure",
+        views_settings.delete_multimer_structure,
+        name="delete_multimer_structure",
+    ),
+    path(
+        "api/get_cl_defaults",
+        views_settings.get_cl_defaults,
+        name="get_cl_defaults",
+    ),
+    path(
+        "api/update_cl_default",
+        views_settings.update_cl_default,
+        name="update_cl_default",
+    ),
+    path(
+        "api/delete_cl_default",
+        views_settings.delete_cl_default,
+        name="delete_cl_default",
+    ),
+    path(
+        "api/get_cl_colors",
+        views_settings.get_cl_colors,
+        name="get_cl_colors",
+    ),
+    path(
+        "api/update_cl_colors",
+        views_settings.update_cl_colors,
+        name="update_cl_colors",
+    ),
     path(
         "api/load_ptm_settings",
         views_settings.load_ptm_settings,

backend/main/views.py

@@ -3,6 +3,7 @@
 import traceback
 from zipfile import ZipFile
 import re
+import traceback
 import logging
 
 from plotly.io import to_json
@@ -41,6 +42,7 @@
     parameters_from_post,
     sanitize_name,
     _dataframe_as_datagrid_rows,
+    create_visualization,
 )
 from backend.protzilla.all_steps import get_all_possible_steps
 
@@ -686,6 +688,70 @@ def get_step_plots(request):
         )
 
 
+def get_downloads_from_step(request: HttpRequest):
+    if request.method != "POST":
+        return JsonResponse(
+            {"success": False, "message": "Invalid request method"}, status=405
+        )
+
+    data = json.loads(request.body)
+    run_name = data.get("run_name")
+    step_id = data.get("step_id")
+    output_key = data.get("output_key")
+
+    run = Run(run_name)
+    step = run.steps.get_step_by_id(step_id)
+    downloads = step.output.get(output_key)
+    if downloads is None:
+        downloads = {}
+    if not isinstance(downloads, dict):
+        return JsonResponse(
+            {
+                "success": False,
+                "message": f"Requested output must be dict object, is {str(type(downloads))}",
+            },
+            status=405,
+        )
+    return JsonResponse(
+        {
+            "success": True,
+            "message": "Got the available download(s) for the step",
+            "data": {"json_downloads": downloads},
+        }
+    )
+
+
+def get_step_visualizations(request):
+    if request.method == "POST":
+        data = json.loads(request.body)
+        run_name = data.get("run_name")
+        step_id = data.get("step_id")
+        output_key = data.get("output_key")
+
+        run = Run(run_name)
+        step = run.steps.get_step_by_id(step_id)
+        visualization_dict = step.output.get(output_key)
+        if visualization_dict is None:
+            return JsonResponse(
+                {
+                    "success": False,
+                    "message": "Got no available visualization for the step",
+                    "data": {},
+                }
+            )
+        return JsonResponse(
+            {
+                "success": True,
+                "message": "Got the available visualization for the step",
+                "data": create_visualization(**visualization_dict),
+            }
+        )
+    else:
+        return JsonResponse(
+            {"success": False, "message": "Invalid request method"}, status=405
+        )
+
+
 def get_png_from_step(request: HttpRequest):
     """
     API call. Returns a base64-encoded PNG of a step output to the front-end
@@ -713,7 +779,9 @@ def get_png_from_step(request: HttpRequest):
         )
 
     content = output.decode("utf-8")
-    return JsonResponse({"success": True, "message": "OK", "data": content})
+    return JsonResponse(
+        {"success": True, "message": "OK", "data": {"base64image": content}}
+    )
 
 
 def get_current_step_table_data(request):

backend/main/views_helper.py

@@ -1,6 +1,5 @@
 import re
 from pathlib import Path
-from typing import Any
 
 import numpy as np
 import pandas as pd
@@ -203,3 +202,130 @@ def _dataframe_as_datagrid_rows(_data: pd.DataFrame) -> list[dict] | None:
         return cleaned_data.to_dict(orient="records")
     else:
         return None
+
+
+# ------------------------- helper for get_step_visualization: -------------------------
+
+
+def create_visualization(
+    cif_df: pd.DataFrame,
+    structure_entry_id: str,
+    crosslinking_df: pd.DataFrame | None = None,
+) -> dict:
+    """
+    Create visualization data, by packaging a mmCIF string (converted from a CIF DataFrame) with its structure entry ID.
+    Optionally include crosslinks.
+
+    :param cif_df: DataFrame containing mmCIF atom_site information.
+    :param structure_entry_id: Protein identifier to include in the mmCIF header.
+    :param crosslinking_df: Optional DataFrame containing crosslink positions.
+    :return: Dictionary containing:
+             - "structureEntryId" (str)
+             - "cifString" (str)
+             - "crosslinks" (optional, list of dicts)
+    """
+    try:
+        cif_string = convert_cif_df_to_mmcif_for_visualization(
+            cif_df, structure_entry_id
+        )
+    except (ValueError, TypeError):
+        cif_string = ""
+
+    result = {"structureEntryId": structure_entry_id, "cifString": cif_string}
+
+    if crosslinking_df is not None:
+        result["crosslinks"] = extract_relevant_crosslink_information(crosslinking_df)
+
+    return result
+
+
+def convert_cif_df_to_mmcif_for_visualization(
+    cif_df: pd.DataFrame, structure_entry_id: str
+) -> str:
+    """
+    Convert a DataFrame containing mmCIF atom_site information back into a mmCIF string.
+
+    :param cif_df: DataFrame with CIF columns
+    :param structure_entry_id: Optional entry ID for the CIF block
+    :return: A string representing the mmCIF file
+    """
+    if cif_df is None or cif_df.empty:
+        raise ValueError("CIF-DataFrame is empty, cannot create mmCIF content.")
+
+    lines = [
+        f"data_{structure_entry_id}",
+        "#",
+        f"_entry.id {structure_entry_id}",
+        "#",
+        "loop_",
+    ]
+
+    for column in cif_df.columns:
+        lines.append(column)
+
+    for _, row in cif_df.iterrows():
+        row_items = []
+        for column in cif_df.columns:
+            value = row[column]
+            if value is None:
+                value_str = "."
+            else:
+                value_str = str(value)
+                if " " in value_str or any(char in value_str for char in "();,"):
+                    value_str = f"'{value_str}'"
+            row_items.append(value_str)
+        lines.append(" ".join(row_items))
+
+    cif_string = "\n".join(lines)
+    return cif_string
+
+
+def extract_relevant_crosslink_information(
+    crosslinking_df: pd.DataFrame,
+) -> list[dict[str, int]]:
+    """
+    For each crosslink extract its relevant information from a DataFrame.
+    This includes information on where the crosslinker binds on both its ends,
+    such as the chain and the absolute crosslinker position within the chain.
+    As well as a boolean for its validity and wether it is an intra or inter crosslink.
+
+    :param crosslinking_df: DataFrame with columns
+        'crosslinker_position1',
+        'crosslinker_position2',
+        'Chain_id1',
+        'Chain_id2',
+        'valid_crosslink',
+        'Is_intra_crosslink',
+    :return: List of dicts with keys
+        'crosslinkerPosition1',
+        'crosslinkerPosition2',
+        'ChainId1',
+        'ChainId2',
+        'isValid',
+        'isIntraCrosslink',
+    """
+    crosslinks = []
+    for _, row in crosslinking_df.iterrows():
+        position1 = row.get("crosslinker_position1")
+        position2 = row.get("crosslinker_position2")
+        # When the validation is extended to treat multimeres with more than one chain correctly,
+        # it should ideally store chain_id1 and chain_id2 into the crosslinking_df.
+        # Since we already need those chain ids to calculate correct distances in the validation,
+        # it would be unnecessary to determine those again in the visualization.
+        # Therefore we use placeholders for now and need to change the following, when the validation is extended:
+        chain_id1 = row.get("Chain_id1")
+        chain_id2 = row.get("Chain_id2")
+        is_valid = row.get("valid_crosslink")
+        is_intra_crosslink = row.get("Is_intra_crosslink")
+        if pd.notnull(position1) and pd.notnull(position2) and pd.notnull(is_valid):
+            crosslinks.append(
+                {
+                    "crosslinkerPosition1": int(position1),
+                    "crosslinkerPosition2": int(position2),
+                    "chainId1": str(chain_id1),
+                    "chainId2": str(chain_id2),
+                    "isValid": bool(is_valid),
+                    "isIntraCrosslink": bool(is_intra_crosslink),
+                }
+            )
+    return crosslinks