memoryframes 0.5.0__tar.gz → 0.6.0__tar.gz

{memoryframes-0.5.0 → memoryframes-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: memoryframes
-Version: 0.5.0
+Version: 0.6.0
 Summary: Add your description here
 Author: David Brownell
 Author-email: David Brownell <github@DavidBrownell.com>

{memoryframes-0.5.0 → memoryframes-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "MemoryFrames"
-version = "0.5.0"
+version = "0.6.0"
 #          ^^^^^
 # Wheel names will be generated according to this value. Do not manually modify this value; instead
 # update it according to committed changes by running this command from the root of the repository:
@@ -59,7 +59,7 @@ dev = [
 ]
 
 [tool.pytest.ini_options]
-addopts = "--verbose -vv --capture=no --cov=MemoryFrames --cov-report html --cov-report term --cov-report xml:coverage.xml --cov-fail-under=95.0"
+addopts = "--verbose -vv --capture=no --cov=MemoryFrames --cov-report html --cov-report term --cov-report xml:coverage.xml --cov-fail-under=75.0"
 python_files = [
     "**/*Test.py",
 ]

memoryframes-0.6.0/src/MemoryFrames/AppState.py

@@ -0,0 +1,94 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import auto, Enum
+from typing import TYPE_CHECKING
+
+import pluggy
+
+from MemoryFrames import APP_NAME
+from MemoryFrames.PluginInfra import Plugin as PluginModule
+
+if TYPE_CHECKING:
+    from MemoryFrames.PluginInfra.Plugin import Plugin
+    from MemoryFrames.PluginInfra.Settings import Settings
+    from MemoryFrames.PluginInfra.UserExperienceInfo import UserExperienceInfo
+
+
+# ----------------------------------------------------------------------
+class AppStateObserver(ABC):
+    """Observer for AppState changes."""
+
+    # ----------------------------------------------------------------------
+    class EventType(Enum):
+        """Value signaling progress during the creation of an AppState instance."""
+
+        LoadingPlugins = auto()
+
+    # ----------------------------------------------------------------------
+    @abstractmethod
+    def OnEvent(self, event_type: EventType) -> None:
+        """Invoke when a processing event begins."""
+        raise NotImplementedError()  # pragma: no cover
+
+    # ----------------------------------------------------------------------
+    @abstractmethod
+    def OnException(self, exception: Exception) -> None:
+        """Invoke when an exception occurs during processing."""
+        raise NotImplementedError()  # pragma: no cover
+
+
+# ----------------------------------------------------------------------
+@dataclass(frozen=True)
+class AppState:
+    """MemoryFrames application state."""
+
+    # ----------------------------------------------------------------------
+    plugins: list[Plugin]
+
+    # ----------------------------------------------------------------------
+    @classmethod
+    def Create(
+        cls,
+        settings: Settings,
+        user_experience_info: UserExperienceInfo,
+        observer: AppStateObserver,
+    ) -> AppState | None:
+        """Create an AppState instance."""
+
+        # Load the plugins
+        observer.OnEvent(AppStateObserver.EventType.LoadingPlugins)
+
+        try:
+            plugins = LoadPlugins(settings, user_experience_info)
+        except Exception as ex:
+            observer.OnException(ex)
+            return None
+
+        # We want the highest priority plugins first, and then sort by name. We apply the negative so
+        # that higher priority values appear first while still maintaining ascending order for names.
+        plugins.sort(key=lambda plugin: (-(plugin.PLUGIN_PRIORITY or 0), plugin.NAME))
+
+        return cls(plugins)
+
+
+# ----------------------------------------------------------------------
+def LoadPlugins(
+    settings: Settings,
+    user_experience_info: UserExperienceInfo,
+) -> list[Plugin]:
+    """Load the plugins.
+
+    This is implemented as a separate function to make it easier to monkey-patch during testing.
+    """
+
+    plugin_manager = pluggy.PluginManager(APP_NAME)
+
+    plugin_manager.add_hookspecs(PluginModule)
+    plugin_manager.load_setuptools_entrypoints(APP_NAME)
+
+    plugins: list[Plugin] = plugin_manager.hook.GetPlugin(
+        settings=settings,
+        user_experience_info=user_experience_info,
+    )
+
+    return plugins

{memoryframes-0.5.0 → memoryframes-0.6.0}/src/MemoryFrames/PluginInfra/Plugin.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
     from pathlib import Path
 
     from MemoryFrames.PluginInfra.NoteSource import NoteSource, NoteSourceObserver
+    from MemoryFrames.PluginInfra.Settings import Settings
     from MemoryFrames.PluginInfra.UserExperienceInfo import UserExperienceInfo
 
 
@@ -81,8 +82,7 @@ class Plugin:
 # ----------------------------------------------------------------------
 @pluggy.HookspecMarker(APP_NAME)
 def GetPlugin(
-    root_data_dir: Path,
-    all_plugins_settings: dict[str, object],
+    settings: Settings,
     user_experience_info: UserExperienceInfo,
 ) -> Plugin:
     """Return a Plugin instance."""

{memoryframes-0.5.0 → memoryframes-0.6.0}/src/MemoryFrames/PluginInfra/TextualUserExperienceInfo.py

@@ -4,7 +4,7 @@ from MemoryFrames.PluginInfra.UserExperienceInfo import UserExperienceInfo
 
 if TYPE_CHECKING:
     from textual.app import App
-    from textual.containers import Vertical
+    from textual.containers import VerticalScroll
 
 
 # ----------------------------------------------------------------------
@@ -15,7 +15,7 @@ class TextualUserExperienceInfo(UserExperienceInfo):
     def __init__(
         self,
         app: App,
-        hierarchy_container: Vertical,
+        hierarchy_container: VerticalScroll,
     ) -> None:
         super().__init__()
 

memoryframes-0.6.0/src/MemoryFrames/TextualUserExperience.py

@@ -0,0 +1,150 @@
+import traceback
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from dbrownell_Common.Types import override
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Footer, Header, Label, LoadingIndicator
+
+from MemoryFrames import APP_NAME, __version__
+from MemoryFrames.AppState import AppState, AppStateObserver as AppStateObserverBase
+from MemoryFrames.PluginInfra.TextualUserExperienceInfo import TextualUserExperienceInfo
+
+if TYPE_CHECKING:
+    from MemoryFrames.PluginInfra.Settings import Settings
+
+
+# ----------------------------------------------------------------------
+def Execute(settings: Settings) -> None:
+    """Execute the Textual user experience."""
+
+    _App(settings).run()
+
+
+# ----------------------------------------------------------------------
+# ----------------------------------------------------------------------
+# ----------------------------------------------------------------------
+class _App(App):
+    CSS_PATH = Path(__file__).with_suffix(".tcss")
+
+    # ----------------------------------------------------------------------
+    def __init__(self, settings: Settings) -> None:
+        super().__init__()
+
+        self._settings = settings
+
+        self._user_experience = TextualUserExperienceInfo(
+            self.app,
+            VerticalScroll(id="hierarchies"),
+        )
+
+        # The app state is initialized in `on_mount`
+        self._app_state: AppState | None = None
+
+        self.title = "Memory Frames"
+        assert self.title.replace(" ", "") == APP_NAME, (self.title, APP_NAME)
+
+    # ----------------------------------------------------------------------
+    def compose(self) -> ComposeResult:
+        yield Header()
+
+        with Horizontal(id="viewport"):
+            yield self._user_experience.hierarchy_container
+
+        with Horizontal(id="footer"):
+            yield Footer()
+            yield Label(__version__)
+
+    # ----------------------------------------------------------------------
+    def on_mount(self) -> None:
+        # ----------------------------------------------------------------------
+        def OnLoaded(app_state: AppState | None) -> None:
+            if app_state is None:
+                return
+
+            assert self._app_state is None
+            self._app_state = app_state
+
+        # ----------------------------------------------------------------------
+
+        self.push_screen(
+            _LoadingModal(self._settings, self._user_experience),
+            OnLoaded,
+        )
+
+
+# ----------------------------------------------------------------------
+class _LoadingModal(ModalScreen[AppState]):
+    CSS_PATH = Path(__file__).with_suffix(".tcss")
+
+    # ----------------------------------------------------------------------
+    def __init__(
+        self,
+        settings: Settings,
+        user_experience_info: TextualUserExperienceInfo,
+    ) -> None:
+        super().__init__()
+
+        self._settings = settings
+        self._user_experience_info = user_experience_info
+
+        self._status_label = Label("Loading...")
+
+    # ----------------------------------------------------------------------
+    def compose(self) -> ComposeResult:
+        yield LoadingIndicator()
+        yield self._status_label
+
+    # ----------------------------------------------------------------------
+    def on_mount(self) -> None:
+        loading_module = self
+
+        # ----------------------------------------------------------------------
+        def Execute() -> None:
+            current_event: AppStateObserverBase.EventType | None = None
+
+            # ----------------------------------------------------------------------
+            class AppStateObserver(AppStateObserverBase):
+                # ----------------------------------------------------------------------
+                @override
+                def OnEvent(self, event_type: AppStateObserver.EventType) -> None:
+                    nonlocal current_event
+                    current_event = event_type
+
+                    if event_type == AppStateObserver.EventType.LoadingPlugins:
+                        msg = "Loading plugins..."
+                    elif event_type == AppStateObserver.EventType.StartingThreads:
+                        msg = "Starting threads..."
+                    else:
+                        assert False, event_type  # noqa: B011, PT015
+
+                    loading_module._status_label.content = msg  # noqa: SLF001
+
+                # ----------------------------------------------------------------------
+                @override
+                def OnException(self, exception: Exception) -> None:
+                    if loading_module._settings.debug:  # noqa: SLF001
+                        msg = "".join(traceback.format_exception(exception))
+                    else:
+                        msg = str(exception)
+
+                    if current_event == AppStateObserver.EventType.LoadingPlugins:
+                        loading_module.app.panic(msg)
+                        return
+
+                    # Display in a toast
+                    loading_module.notify(msg, severity="error", timeout=10)
+
+            # ----------------------------------------------------------------------
+
+            app_state = AppState.Create(self._settings, self._user_experience_info, AppStateObserver())
+
+            # Return the results
+            self.app.call_from_thread(lambda: self.dismiss(app_state))
+
+        # ----------------------------------------------------------------------
+
+        self.run_worker(Execute, thread=True)

memoryframes-0.6.0/src/MemoryFrames/TextualUserExperience.tcss

@@ -0,0 +1,33 @@
+$version_length: 15;
+
+#footer {
+    height: 1;
+
+    Footer {
+        padding-right: $version_length;
+    }
+
+    Label {
+        background: $footer-background;
+        dock: right;
+        text-align: center;
+        width: $version_length;
+    }
+}
+
+_LoadingModal {
+    align: center middle;
+    background: $panel;
+    height: 2;
+    padding: 1;
+
+    LoadingIndicator {
+        height: 1;
+        margin-bottom: 1;
+    }
+
+    Label {
+        text-align: center;
+        width: 100%;
+    }
+}

{memoryframes-0.5.0 → memoryframes-0.6.0}/src/MemoryFrames/__main__.py

@@ -8,8 +8,8 @@ import typer
 
 from typer.core import TyperGroup
 
-from MemoryFrames.Settings import Settings
 from MemoryFrames import TextualUserExperience
+from MemoryFrames.PluginInfra.Settings import Settings
 
 
 # ----------------------------------------------------------------------

memoryframes-0.5.0/src/MemoryFrames/TextualUserExperience.py

@@ -1,11 +0,0 @@
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from MemoryFrames.Settings import Settings
-
-
-# ----------------------------------------------------------------------
-def Execute(settings: Settings) -> None:
-    """Execute the Textual user experience."""
-
-    print("TextualUserExperience", settings)  # noqa: T201