Pretty sure none of this is used

Author: stephen-riggs

src/murfey/client/contexts/spa.py

@@ -326,7 +326,6 @@ def __init__(self, acquisition_software: str, basepath: Path):
         super().__init__("SPA", acquisition_software)
         self._basepath = basepath
         self._processing_job_stash: dict = {}
-        self._preprocessing_triggers: dict = {}
         self._foil_holes: Dict[int, List[int]] = {}
 
     def gather_metadata(

src/murfey/client/contexts/tomo.py

@@ -8,7 +8,6 @@
 
 import requests
 import xmltodict
-from pydantic import BaseModel
 
 import murfey.util.eer
 from murfey.client.context import Context, ProcessingParameter
@@ -17,7 +16,6 @@
     MovieTracker,
     MurfeyID,
     MurfeyInstanceEnvironment,
-    global_env_lock,
 )
 from murfey.util import authorised_requests, capture_post, get_machine_config_client
 from murfey.util.mdoc import get_block, get_global_data, get_num_blocks
@@ -65,15 +63,6 @@ def _construct_tilt_series_name(file_path: Path) -> str:
     return "_".join(split_name[:-5])
 
 
-class ProcessFileIncomplete(BaseModel):
-    dest: Path
-    source: Path
-    image_number: int
-    mc_uuid: int
-    tag: str
-    description: str = ""
-
-
 class TomographyContext(Context):
     user_params = [
         ProcessingParameter(
@@ -101,7 +90,6 @@ def __init__(self, acquisition_software: str, basepath: Path):
         self._aligned_tilt_series: List[str] = []
         self._data_collection_stash: list = []
         self._processing_job_stash: dict = {}
-        self._preprocessing_triggers: dict = {}
         self._lock: RLock = RLock()
 
     def _flush_data_collections(self):
@@ -120,12 +108,6 @@ def _flush_data_collections(self):
             capture_post(dc_data[0], json=data)
         self._data_collection_stash = []
 
-    def _flush_processing_job(self, tag: str):
-        if proc_data := self._processing_job_stash.get(tag):
-            for pd in proc_data:
-                requests.post(pd[0], json=pd[1])
-            self._processing_job_stash.pop(tag)
-
     def _flush_processing_jobs(self):
         logger.info(
             f"Flushing {len(self._processing_job_stash.keys())} processing job API calls"
@@ -135,75 +117,6 @@ def _flush_processing_jobs(self):
                 requests.post(pd[0], json=pd[1])
         self._processing_job_stash = {}
 
-    def _flush_preprocess(self, tag: str, app_id: int):
-        if tag_tr := self._preprocessing_triggers.get(tag):
-            for tr in tag_tr:
-                process_file = self._complete_process_file(tr[1], tr[2], app_id)
-                if process_file:
-                    capture_post(tr[0], json=process_file)
-            self._preprocessing_triggers.pop(tag)
-
-    def _complete_process_file(
-        self,
-        incomplete_process_file: ProcessFileIncomplete,
-        environment: MurfeyInstanceEnvironment,
-        app_id: int,
-    ) -> dict:
-        try:
-            with global_env_lock:
-                tag = incomplete_process_file.tag
-
-                eer_fractionation_file = None
-                if environment.data_collection_parameters.get("num_eer_frames"):
-                    response = requests.post(
-                        f"{str(environment.url.geturl())}/visits/{environment.visit}/{environment.murfey_session}/eer_fractionation_file",
-                        json={
-                            "num_frames": environment.data_collection_parameters[
-                                "num_eer_frames"
-                            ],
-                            "fractionation": environment.data_collection_parameters[
-                                "eer_fractionation"
-                            ],
-                            "dose_per_frame": environment.data_collection_parameters[
-                                "dose_per_frame"
-                            ],
-                            "fractionation_file_name": "eer_fractionation_tomo.txt",
-                        },
-                    )
-                    eer_fractionation_file = response.json()["eer_fractionation_file"]
-
-                new_dict = {
-                    "path": str(incomplete_process_file.dest),
-                    "description": incomplete_process_file.description,
-                    "size": incomplete_process_file.source.stat().st_size,
-                    "timestamp": incomplete_process_file.source.stat().st_ctime,
-                    "processing_job": environment.processing_job_ids[tag][
-                        "em-tomo-preprocess"
-                    ],
-                    "data_collection_id": environment.data_collection_ids[tag],
-                    "image_number": incomplete_process_file.image_number,
-                    "pixel_size": environment.data_collection_parameters[
-                        "pixel_size_on_image"
-                    ],
-                    "autoproc_program_id": app_id,
-                    "mc_uuid": incomplete_process_file.mc_uuid,
-                    "dose_per_frame": environment.data_collection_parameters.get(
-                        "dose_per_frame"
-                    ),
-                    "mc_binning": environment.data_collection_parameters.get(
-                        "motion_corr_binning", 1
-                    ),
-                    "gain_ref": environment.data_collection_parameters.get("gain_ref"),
-                    "voltage": environment.data_collection_parameters.get(
-                        "voltage", 300
-                    ),
-                    "eer_fractionation_file": eer_fractionation_file,
-                }
-                return new_dict
-        except KeyError:
-            logger.warning("Key error encountered in _complete_process_file")
-            return {}
-
     def _file_transferred_to(
         self, environment: MurfeyInstanceEnvironment, source: Path, file_path: Path
     ):
@@ -441,14 +354,10 @@ def _add_tilt(
             preproc_data = {
                 "path": str(file_transferred_to),
                 "description": "",
-                "data_collection_id": environment.data_collection_ids.get(tilt_series),
                 "image_number": environment.movies[file_transferred_to].movie_number,
                 "pixel_size": environment.data_collection_parameters.get(
                     "pixel_size_on_image", 0
                 ),
-                "autoproc_program_id": environment.autoproc_program_ids.get(
-                    tilt_series, {}
-                ).get("em-tomo-preprocess"),
                 "dose_per_frame": environment.data_collection_parameters.get(
                     "dose_per_frame", 0
                 ),

src/murfey/client/instance_environment.py

@@ -5,10 +5,10 @@
 from itertools import count
 from pathlib import Path
 from threading import RLock
-from typing import Callable, Dict, List, NamedTuple, Optional, Set
+from typing import Dict, List, NamedTuple, Optional
 from urllib.parse import ParseResult
 
-from pydantic import BaseModel, validator
+from pydantic import BaseModel
 
 from murfey.client.watchdir import DirWatcher
 
@@ -42,18 +42,8 @@ class MurfeyInstanceEnvironment(BaseModel):
     watchers: Dict[Path, DirWatcher] = {}
     demo: bool = False
     data_collection_group_ids: Dict[str, int] = {}
-    data_collection_ids: Dict[str, int] = {}
-    processing_job_ids: Dict[str, Dict[str, int]] = {}
-    autoproc_program_ids: Dict[str, Dict[str, int]] = {}
-    id_tag_registry: Dict[str, List[str]] = {
-        "data_collection_group": [],
-        "data_collection": [],
-        "processing_job": [],
-        "auto_proc_program": [],
-    }
     data_collection_parameters: dict = {}
     movies: Dict[Path, MovieTracker] = {}
-    listeners: Dict[str, Set[Callable]] = {}
     movie_tilt_pair: Dict[Path, str] = {}
     tilt_angles: Dict[str, List[List[str]]] = {}
     movie_counters: Dict[str, itertools.count] = {}
@@ -68,47 +58,15 @@ class Config:
         validate_assignment: bool = True
         arbitrary_types_allowed: bool = True
 
-    @validator("data_collection_group_ids")
-    def dcg_callback(cls, v, values):
-        with global_env_lock:
-            for l in values.get("listeners", {}).get("data_collection_group_ids", []):
-                for k in v.keys():
-                    if k not in values["id_tag_registry"]["data_collection"]:
-                        l(k)
-        return v
-
-    @validator("data_collection_ids")
-    def dc_callback(cls, v, values):
-        with global_env_lock:
-            for l in values.get("listeners", {}).get("data_collection_ids", []):
-                for k in v.keys():
-                    if k not in values["id_tag_registry"]["processing_job"]:
-                        l(k)
-        return v
-
-    @validator("autoproc_program_ids")
-    def app_callback(cls, v, values):
-        # logger.info(f"autoproc program ids validator: {v}")
-        with global_env_lock:
-            for l in values.get("listeners", {}).get("autoproc_program_ids", []):
-                for k in v.keys():
-                    if v[k].get("em-tomo-preprocess"):
-                        l(k, v[k]["em-tomo-preprocess"])
-        return v
-
     def clear(self):
         self.sources = []
         self.default_destinations = {}
         for w in self.watchers.values():
             w.stop()
         self.watchers = {}
         self.data_collection_group_ids = {}
-        self.data_collection_ids = {}
-        self.processing_job_ids = {}
-        self.autoproc_program_ids = {}
         self.data_collection_parameters = {}
         self.movies = {}
-        self.listeners = {}
         self.movie_tilt_pair = {}
         self.tilt_angles = {}
         self.visit = ""

src/murfey/client/multigrid_control.py

@@ -370,9 +370,6 @@ def _start_dc(self, json, from_form: bool = False):
 
             source = Path(json["source"])
 
-            self._environment.id_tag_registry["data_collection_group"].append(
-                str(source)
-            )
             url = f"{str(self._environment.url.geturl())}/visits/{str(self._environment.visit)}/{self.session_id}/register_data_collection_group"
             dcg_data = {
                 "experiment_type": "tomo",

src/murfey/util/models.py

@@ -312,12 +312,9 @@ class ProcessFile(BaseModel):  # Rename to TomoProcessFile
     path: str
     description: str
     tag: str
-    data_collection_id: Optional[int]
     image_number: int
     pixel_size: float
     dose_per_frame: float
-    processing_job: Optional[int] = None
-    autoproc_program_id: Optional[int] = None
     mc_uuid: Optional[int] = None
     voltage: float = 300
     mc_binning: int = 1