Post updates for tui code

Author: stephen-riggs

src/murfey/client/tui/app.py

@@ -33,7 +33,6 @@
 from murfey.client.watchdir import DirWatcher
 from murfey.client.watchdir_multigrid import MultigridDirWatcher
 from murfey.util import posix_path
-from murfey.util.api import url_path_for
 from murfey.util.client import (
     capture_delete,
     capture_get,
@@ -153,7 +152,10 @@ def _start_rsyncer_multigrid(
         log.info(f"starting multigrid rsyncer: {source}")
         destination_overrides = destination_overrides or {}
         machine_data = capture_get(
-            url=f"{self._environment.url.geturl()}{url_path_for('session_control.router', 'machine_info_by_instrument', instrument_name=instrument_name)}"
+            base_url=str(self._environment.url.geturl()),
+            router_name="session_control.router",
+            function_name="machine_info_by_instrument",
+            instrument_name=instrument_name,
         ).json()
         if destination_overrides.get(source):
             destination = destination_overrides[source] + f"/{extra_directory}"
@@ -205,8 +207,13 @@ def _start_rsyncer(
         log.info(f"starting rsyncer: {source}")
         if transfer:
             # Always make sure the destination directory exists
-            make_directory_url = f"{str(self._url.geturl())}{url_path_for('file_io_instrument.router', 'make_rsyncer_destination', session_id=self._environment.murfey_session)}"
-            capture_post(make_directory_url, json={"destination": destination})
+            capture_post(
+                base_url=str(self._url.geturl()),
+                router_name="file_io_instrument.router",
+                function_name="make_rsyncer_destination",
+                session_id=self._environment.murfey_session,
+                data={"destination": destination},
+            )
         if self._environment:
             self._environment.default_destinations[source] = destination
             if self._environment.gain_ref and visit_path:
@@ -271,14 +278,19 @@ def rsync_result(update: RSyncerUpdate):
                 ),
                 secondary=True,
             )
-            url = f"{str(self._url.geturl())}{url_path_for('session_control.router', 'register_rsyncer', session_id=self._environment.murfey_session)}"
             rsyncer_data = {
                 "source": str(source),
                 "destination": destination,
                 "session_id": self._environment.murfey_session,
                 "transferring": self._do_transfer,
             }
-            capture_post(url=url, json=rsyncer_data)
+            capture_post(
+                base_url=str(self._url.geturl()),
+                router_name="session_control.router",
+                function_name="register_rsyncer",
+                session_id=self._environment.murfey_session,
+                data=rsyncer_data,
+            )
 
         self._environment.watchers[source] = DirWatcher(source, settling_time=30)
 
@@ -341,7 +353,6 @@ def _increment_file_count(
         self, observed_files: List[Path], source: str, destination: str
     ):
         if len(observed_files):
-            url = f"{str(self._url.geturl())}{url_path_for('prometheus.router', 'increment_rsync_file_count', visit_name=self._visit)}"
             num_data_files = len(
                 [
                     f
@@ -357,15 +368,20 @@ def _increment_file_count(
                 "increment_count": len(observed_files),
                 "increment_data_count": num_data_files,
             }
-            capture_post(url=url, json=data)
+            capture_post(
+                base_url=str(self._url.geturl()),
+                router_name="prometheus.router",
+                function_name="increment_rsync_file_count",
+                visit_name=self._visit,
+                data=data,
+            )
 
     # Prometheus can handle higher traffic so update for every transferred file rather
     # than batching as we do for the Murfey database updates in _increment_transferred_files
     def _increment_transferred_files_prometheus(
         self, update: RSyncerUpdate, source: str, destination: str
     ):
         if update.outcome is TransferResult.SUCCESS:
-            url = f"{str(self._url.geturl())}{url_path_for('prometheus.router', 'increment_rsync_transferred_files_prometheus', visit_name=self._visit)}"
             data_files = (
                 [update]
                 if update.file_path.suffix in self._data_suffixes
@@ -384,7 +400,13 @@ def _increment_transferred_files_prometheus(
                 "increment_data_count": len(data_files),
                 "data_bytes": sum(f.file_size for f in data_files),
             }
-            capture_post(url=url, json=data)
+            capture_post(
+                base_url=str(self._url.geturl()),
+                router_name="prometheus.router",
+                function_name="increment_rsync_transferred_files_prometheus",
+                visit_name=self._visit,
+                data=data,
+            )
 
     def _increment_transferred_files(
         self, updates: List[RSyncerUpdate], source: str, destination: str
@@ -394,7 +416,6 @@ def _increment_transferred_files(
         ]
         if not checked_updates:
             return
-        url = f"{str(self._url.geturl())}{url_path_for('prometheus.router', 'increment_rsync_transferred_files', visit_name=self._visit)}"
         data_files = [
             u
             for u in updates
@@ -412,7 +433,13 @@ def _increment_transferred_files(
             "increment_data_count": len(data_files),
             "data_bytes": sum(f.file_size for f in data_files),
         }
-        capture_post(url=url, json=data)
+        capture_post(
+            base_url=str(self._url.geturl()),
+            router_name="prometheus.router",
+            function_name="increment_rsync_transferred_files",
+            visit_name=self._visit,
+            data=data,
+        )
 
     def _set_register_dc(self, response: str):
         if response == "y":
@@ -488,8 +515,12 @@ def _start_dc(self, metadata_json, from_form: bool = False):
             log.info("Registering tomography processing parameters")
             if context.data_collection_parameters.get("num_eer_frames"):
                 eer_response = capture_post(
-                    url=f"{str(self.app._environment.url.geturl())}{url_path_for('file_io_instrument.router', 'write_eer_fractionation_file', visit_name=self.app._environment.visit, session_id=self.app._environment.murfey_session)}",
-                    json={
+                    base_url=str(self.app._environment.url.geturl()),
+                    router_name="file_io_instrument.router",
+                    function_name="write_eer_fractionation_file",
+                    visit_name=self.app._environment.visit,
+                    session_id=self.app._environment.murfey_session,
+                    data={
                         "num_frames": context.data_collection_parameters[
                             "num_eer_frames"
                         ],
@@ -501,16 +532,22 @@ def _start_dc(self, metadata_json, from_form: bool = False):
                 eer_fractionation_file = eer_response.json()["eer_fractionation_file"]
                 metadata_json.update({"eer_fractionation_file": eer_fractionation_file})
             capture_post(
-                url=f"{self.app._environment.url.geturl()}{url_path_for('workflow.tomo_router', 'register_tomo_proc_params', session_id=self.app._environment.murfey_session)}",
-                json=metadata_json,
+                base_url=str(self.app._environment.url.geturl()),
+                router_name="workflow.tomo_router",
+                function_name="register_tomo_proc_params",
+                session_id=self.app._environment.murfey_session,
+                data=metadata_json,
             )
             capture_post(
-                f"{self.app._environment.url.geturl()}{url_path_for('workflow.tomo_router', 'flush_tomography_processing', visit_name=self._visit, session_id=self.app._environment.murfey_session)}",
-                json={"rsync_source": str(source)},
+                base_url=str(self.app._environment.url.geturl()),
+                router_name="workflow.tomo_router",
+                function_name="flush_tomography_processing",
+                visit_name=self._visit,
+                session_id=self.app._environment.murfey_session,
+                data={"rsync_source": str(source)},
             )
             log.info("Tomography processing flushed")
         elif isinstance(context, SPAModularContext):
-            url = f"{str(self._url.geturl())}{url_path_for('workflow.router', 'register_dc_group', visit_name=self._visit, session_id=self._environment.murfey_session)}"
             dcg_data = {
                 "experiment_type": "single particle",
                 "experiment_type_id": 37,
@@ -526,7 +563,14 @@ def _start_dc(self, metadata_json, from_form: bool = False):
                     else None
                 ),
             }
-            capture_post(url, json=dcg_data)
+            capture_post(
+                base_url=str(self._url.geturl()),
+                router_name="workflow.router",
+                function_name="register_dc_group",
+                visit_name=self._visit,
+                session_id=self._environment.murfey_session,
+                data=dcg_data,
+            )
             if from_form:
                 data = {
                     "voltage": metadata_json["voltage"],
@@ -549,8 +593,12 @@ def _start_dc(self, metadata_json, from_form: bool = False):
                     "phase_plate": metadata_json.get("phase_plate", False),
                 }
                 capture_post(
-                    f"{str(self._url.geturl())}{url_path_for('workflow.router', 'start_dc', visit_name=self._visit, session_id=self._environment.murfey_session)}",
-                    json=data,
+                    base_url=str(self._url.geturl()),
+                    router_name="workflow.router",
+                    function_name="start_dc",
+                    visit_name=self._visit,
+                    session_id=self._environment.murfey_session,
+                    data=data,
                 )
                 for recipe in (
                     "em-spa-preprocess",
@@ -560,17 +608,24 @@ def _start_dc(self, metadata_json, from_form: bool = False):
                     "em-spa-refine",
                 ):
                     capture_post(
-                        f"{str(self._url.geturl())}{url_path_for('workflow.router', 'register_proc', visit_name=self._visit, session_id=self._environment.murfey_session)}",
-                        json={
+                        base_url=str(self._url.geturl()),
+                        router_name="workflow.router",
+                        function_name="register_proc",
+                        visit_name=self._visit,
+                        session_id=self._environment.murfey_session,
+                        data={
                             "tag": str(source),
                             "source": str(source),
                             "recipe": recipe,
                         },
                     )
                 log.info(f"Posting SPA processing parameters: {metadata_json}")
                 response = capture_post(
-                    f"{self.app._environment.url.geturl()}{url_path_for('workflow.spa_router', 'register_spa_proc_params', session_id=self.app._environment.murfey_session)}",
-                    json={
+                    base_url=str(self.app._environment.url.geturl()),
+                    router_name="workflow.spa_router",
+                    function_name="register_spa_proc_params",
+                    session_id=self.app._environment.murfey_session,
+                    data={
                         **{
                             k: None if v == "None" else v
                             for k, v in metadata_json.items()
@@ -586,8 +641,12 @@ def _start_dc(self, metadata_json, from_form: bool = False):
                 if not str(response.status_code).startswith("2"):
                     log.warning(f"{response.reason}")
                 capture_post(
-                    f"{self.app._environment.url.geturl()}{url_path_for('workflow.spa_router', 'flush_spa_processing', visit_name=self.app._environment.visit, session_id=self.app._environment.murfey_session)}",
-                    json={"tag": str(source)},
+                    base_url=str(self.app._environment.url.geturl()),
+                    router_name="workflow.spa_router",
+                    function_name="flush_spa_processing",
+                    visit_name=self.app._environment.visit,
+                    session_id=self.app._environment.murfey_session,
+                    data={"tag": str(source)},
                 )
 
     def _set_request_destination(self, response: str):
@@ -618,7 +677,9 @@ async def on_button_pressed(self, event: Button.Pressed):
 
     async def on_mount(self) -> None:
         exisiting_sessions = capture_get(
-            url=f"{self._environment.url.geturl()}{url_path_for('session_control.router', 'get_sessions')}"
+            base_url=str(self._environment.url.geturl()),
+            router_name="session_control.router",
+            function_name="get_sessions",
         ).json()
         if self.visits:
             self.install_screen(VisitSelection(self.visits), "visit-select-screen")
@@ -645,8 +706,12 @@ async def on_mount(self) -> None:
         else:
             session_name = "Client connection"
             resp = capture_post(
-                f"{self._environment.url.geturl()}{url_path_for('session_control.router', 'link_client_to_session', instrument_name=self._environment.instrument_name, client_id=self._environment.client_id)}",
-                json={"session_id": None, "session_name": session_name},
+                base_url=str(self._environment.url.geturl()),
+                router_name="session_control.router",
+                function_name="link_client_to_session",
+                instrument_name=self._environment.instrument_name,
+                client_id=self._environment.client_id,
+                data={"session_id": None, "session_name": session_name},
             )
             if resp:
                 self._environment.murfey_session = resp.json()
@@ -664,7 +729,10 @@ async def reset(self):
             sources = "\n".join(str(k) for k in self.rsync_processes.keys())
             prompt = f"Remove files from the following:\n {sources} \n"
             rsync_instances = capture_get(
-                url=f"{self._environment.url.geturl()}{url_path_for('session_control.router', 'get_rsyncers_for_session', session_id=self._environment.murfey_session)}"
+                base_url=str(self._environment.url.geturl()),
+                router_name="session_control.router",
+                function_name="get_rsyncers_for_session",
+                session_id=self._environment.murfey_session,
             ).json()
             prompt += f"Copied {sum(r['files_counted'] for r in rsync_instances)} / {sum(r['files_transferred'] for r in rsync_instances)}"
             self.install_screen(
@@ -688,7 +756,10 @@ async def action_quit(self) -> None:
 
     async def action_remove_session(self) -> None:
         capture_delete(
-            url=f"{self._environment.url.geturl()}{url_path_for('session_control.router', 'remove_session', session_id=self._environment.murfey_session)}"
+            base_url=str(self._environment.url.geturl()),
+            router_name="session_control.router",
+            function_name="remove_session",
+            session_id=self._environment.murfey_session,
         )
         if self.rsync_processes:
             for rp in self.rsync_processes.values():
@@ -702,7 +773,10 @@ async def action_remove_session(self) -> None:
 
     def clean_up_quit(self) -> None:
         capture_delete(
-            url=f"{self._environment.url.geturl()}{url_path_for('session_control.router', 'remove_session', session_id=self._environment.murfey_session)}"
+            base_url=str(self._environment.url.geturl()),
+            router_name="session_control.router",
+            function_name="remove_session",
+            session_id=self._environment.murfey_session,
         )
         self.exit()
 
@@ -745,10 +819,16 @@ def _remove_data(self, listener: Callable[..., Awaitable[None] | None], **kwargs
             removal_rp.stop()
             log.info(f"rsyncer {rp} rerun with removal")
         capture_post(
-            url=f"{self._environment.url.geturl()}{url_path_for('session_control.router', 'register_processing_success_in_ispyb', session_id=self._environment.murfey_session)}"
+            base_url=str(self._environment.url.geturl()),
+            router_name="session_control.router",
+            function_name="register_processing_success_in_ispyb",
+            session_id=self._environment.murfey_session,
         )
         capture_delete(
-            url=f"{self._environment.url.geturl()}{url_path_for('session_control.router', 'remove_session', session_id=self._environment.murfey_session)}"
+            base_url=str(self._environment.url.geturl()),
+            router_name="session_control.router",
+            function_name="remove_session",
+            session_id=self._environment.murfey_session,
         )
         self.exit()
 

src/murfey/client/tui/main.py

@@ -24,7 +24,6 @@
 from murfey.client.instance_environment import MurfeyInstanceEnvironment
 from murfey.client.tui.app import MurfeyTUI
 from murfey.client.tui.status_bar import StatusBar
-from murfey.util.api import url_path_for
 from murfey.util.client import capture_get, read_config
 from murfey.util.models import Visit
 
@@ -33,10 +32,13 @@
 
 def _get_visit_list(api_base: ParseResult, instrument_name: str):
     proxy_path = api_base.path.rstrip("/")
-    get_visits_url = api_base._replace(
-        path=f"{proxy_path}{url_path_for('session_control.router', 'get_current_visits', instrument_name=instrument_name)}"
+    get_visits_url = api_base._replace(path=f"{proxy_path}")
+    server_reply = capture_get(
+        base_url=str(get_visits_url.geturl()),
+        router_name="session_control.router",
+        function_name="get_current_visits",
+        instrument_name=instrument_name,
     )
-    server_reply = capture_get(url=get_visits_url.geturl())
     if server_reply.status_code != 200:
         raise ValueError(f"Server unreachable ({server_reply.status_code})")
     return [Visit.model_validate(v) for v in server_reply.json()]
@@ -272,7 +274,9 @@ def run():
 
     # Set up websocket app and handler
     client_id_response = capture_get(
-        url=f"{murfey_url.geturl()}{url_path_for('session_control.router', 'new_client_id')}"
+        base_url=str(murfey_url.geturl()),
+        router_name="session_control.router",
+        function_name="new_client_id",
     )
     if client_id_response.status_code == 401:
         exit(
@@ -301,7 +305,10 @@ def run():
 
     # Load machine data for subsequent sections
     machine_data = capture_get(
-        url=f"{murfey_url.geturl()}{url_path_for('session_control.router', 'machine_info_by_instrument', instrument_name=instrument_name)}"
+        base_url=str(murfey_url.geturl()),
+        router_name="session_control.router",
+        function_name="machine_info_by_instrument",
+        instrument_name=instrument_name,
     ).json()
     gain_ref: Path | None = None