Migrated 'Observer' class to 'murfey.util.client' as well

Author: tieneupin

src/murfey/client/analyser.py

@@ -22,8 +22,7 @@
 from murfey.client.instance_environment import MurfeyInstanceEnvironment
 from murfey.client.rsync import RSyncerUpdate, TransferResult
 from murfey.client.tui.forms import FormDependency
-from murfey.util import Observer
-from murfey.util.client import get_machine_config_client
+from murfey.util.client import Observer, get_machine_config_client
 from murfey.util.mdoc import get_block
 from murfey.util.models import PreprocessingParametersTomo, ProcessingParametersSPA
 

src/murfey/client/rsync.py

@@ -19,7 +19,7 @@
 from urllib.parse import ParseResult
 
 from murfey.client.tui.status_bar import StatusBar
-from murfey.util import Observer
+from murfey.util.client import Observer
 
 logger = logging.getLogger("murfey.client.rsync")
 

src/murfey/client/watchdir.py

@@ -14,8 +14,8 @@
 from pathlib import Path
 from typing import List, NamedTuple, Optional
 
-import murfey.util
 from murfey.client.tui.status_bar import StatusBar
+from murfey.util.client import Observer
 
 log = logging.getLogger("murfey.client.watchdir")
 
@@ -26,7 +26,7 @@ class _FileInfo(NamedTuple):
     settling_time: Optional[float] = None
 
 
-class DirWatcher(murfey.util.Observer):
+class DirWatcher(Observer):
     def __init__(
         self,
         path: str | os.PathLike,

src/murfey/client/watchdir_multigrid.py

@@ -7,12 +7,12 @@
 from pathlib import Path
 from typing import List
 
-import murfey.util
+from murfey.util.client import Observer
 
 log = logging.getLogger("murfey.client.watchdir_multigrid")
 
 
-class MultigridDirWatcher(murfey.util.Observer):
+class MultigridDirWatcher(Observer):
     def __init__(
         self,
         path: str | os.PathLike,

src/murfey/util/__init__.py

@@ -1,12 +1,10 @@
 from __future__ import annotations
 
-import asyncio
-import inspect
 import logging
 from pathlib import Path
 from queue import Queue
 from threading import Thread
-from typing import Awaitable, Callable, Optional
+from typing import Optional
 from uuid import uuid4
 
 from werkzeug.utils import secure_filename
@@ -65,75 +63,6 @@ def posix_path(path: Path) -> str:
     return str(path)
 
 
-class Observer:
-    """
-    A helper class implementing the observer pattern supporting both
-    synchronous and asynchronous notification calls and both synchronous and
-    asynchronous callback functions.
-    """
-
-    # The class here should be derived from typing.Generic[P]
-    # with P = ParamSpec("P"), and the notify/anotify functions should use
-    # *args: P.args, **kwargs: P.kwargs.
-    # However, ParamSpec is Python 3.10+ (PEP 612), so we can't use that yet.
-
-    def __init__(self):
-        self._listeners: list[Callable[..., Awaitable[None] | None]] = []
-        self._secondary_listeners: list[Callable[..., Awaitable[None] | None]] = []
-        self._final_listeners: list[Callable[..., Awaitable[None] | None]] = []
-        super().__init__()
-
-    def subscribe(
-        self,
-        fn: Callable[..., Awaitable[None] | None],
-        secondary: bool = False,
-        final: bool = False,
-    ):
-        if final:
-            self._final_listeners.append(fn)
-        elif secondary:
-            self._secondary_listeners.append(fn)
-        else:
-            self._listeners.append(fn)
-
-    async def anotify(
-        self, *args, secondary: bool = False, final: bool = False, **kwargs
-    ) -> None:
-        awaitables: list[Awaitable] = []
-        listeners = (
-            self._secondary_listeners
-            if secondary
-            else self._final_listeners if final else self._listeners
-        )
-        for notify_function in listeners:
-            result = notify_function(*args, **kwargs)
-            if result is not None and inspect.isawaitable(result):
-                awaitables.append(result)
-        if awaitables:
-            await self._await_all(awaitables)
-
-    @staticmethod
-    async def _await_all(awaitables: list[Awaitable]):
-        for awaitable in asyncio.as_completed(awaitables):
-            await awaitable
-
-    def notify(
-        self, *args, secondary: bool = False, final: bool = False, **kwargs
-    ) -> None:
-        awaitables: list[Awaitable] = []
-        listeners = (
-            self._secondary_listeners
-            if secondary
-            else self._final_listeners if final else self._listeners
-        )
-        for notify_function in listeners:
-            result = notify_function(*args, **kwargs)
-            if result is not None and inspect.isawaitable(result):
-                awaitables.append(result)
-        if awaitables:
-            asyncio.run(self._await_all(awaitables))
-
-
 class Processor:
     def __init__(self, name: Optional[str] = None):
         self._in: Queue = Queue()

src/murfey/util/client.py

@@ -4,15 +4,19 @@
 and set default directories to work with.
 """
 
+from __future__ import annotations
+
+import asyncio
 import configparser
 import copy
+import inspect
 import json
 import logging
 import os
 import shutil
 from functools import lru_cache, partial
 from pathlib import Path
-from typing import Callable, Optional, Union
+from typing import Awaitable, Callable, Optional, Union
 from urllib.parse import ParseResult, urlparse, urlunparse
 
 import requests
@@ -169,3 +173,72 @@ def _check_dict_structure(d1: dict, d2: dict) -> bool:
         if _check_dict_structure(settings, settings_copy):
             with open(p, "w") as sf:
                 json.dump(settings_copy, sf)
+
+
+class Observer:
+    """
+    A helper class implementing the observer pattern supporting both
+    synchronous and asynchronous notification calls and both synchronous and
+    asynchronous callback functions.
+    """
+
+    # The class here should be derived from typing.Generic[P]
+    # with P = ParamSpec("P"), and the notify/anotify functions should use
+    # *args: P.args, **kwargs: P.kwargs.
+    # However, ParamSpec is Python 3.10+ (PEP 612), so we can't use that yet.
+
+    def __init__(self):
+        self._listeners: list[Callable[..., Awaitable[None] | None]] = []
+        self._secondary_listeners: list[Callable[..., Awaitable[None] | None]] = []
+        self._final_listeners: list[Callable[..., Awaitable[None] | None]] = []
+        super().__init__()
+
+    def subscribe(
+        self,
+        fn: Callable[..., Awaitable[None] | None],
+        secondary: bool = False,
+        final: bool = False,
+    ):
+        if final:
+            self._final_listeners.append(fn)
+        elif secondary:
+            self._secondary_listeners.append(fn)
+        else:
+            self._listeners.append(fn)
+
+    async def anotify(
+        self, *args, secondary: bool = False, final: bool = False, **kwargs
+    ) -> None:
+        awaitables: list[Awaitable] = []
+        listeners = (
+            self._secondary_listeners
+            if secondary
+            else self._final_listeners if final else self._listeners
+        )
+        for notify_function in listeners:
+            result = notify_function(*args, **kwargs)
+            if result is not None and inspect.isawaitable(result):
+                awaitables.append(result)
+        if awaitables:
+            await self._await_all(awaitables)
+
+    @staticmethod
+    async def _await_all(awaitables: list[Awaitable]):
+        for awaitable in asyncio.as_completed(awaitables):
+            await awaitable
+
+    def notify(
+        self, *args, secondary: bool = False, final: bool = False, **kwargs
+    ) -> None:
+        awaitables: list[Awaitable] = []
+        listeners = (
+            self._secondary_listeners
+            if secondary
+            else self._final_listeners if final else self._listeners
+        )
+        for notify_function in listeners:
+            result = notify_function(*args, **kwargs)
+            if result is not None and inspect.isawaitable(result):
+                awaitables.append(result)
+        if awaitables:
+            asyncio.run(self._await_all(awaitables))