jehoctor-rag-demo 0.1.1.dev1__py3-none-any.whl → 0.2.0__py3-none-any.whl

jehoctor_rag_demo-0.2.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.3
+Name: jehoctor-rag-demo
+Version: 0.2.0
+Summary: Chat with Wikipedia
+Author: James Hoctor
+Author-email: James Hoctor <JEHoctor@protonmail.com>
+Requires-Dist: aiosqlite==0.21.0
+Requires-Dist: chromadb>=1.3.4
+Requires-Dist: datasets>=4.4.1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: huggingface-hub>=0.36.0
+Requires-Dist: langchain>=1.0.5
+Requires-Dist: langchain-anthropic>=1.0.2
+Requires-Dist: langchain-community>=0.4.1
+Requires-Dist: langchain-huggingface>=1.1.0
+Requires-Dist: langchain-ollama>=1.0.0
+Requires-Dist: langchain-openai>=1.0.2
+Requires-Dist: langgraph-checkpoint-sqlite>=3.0.1
+Requires-Dist: llama-cpp-python>=0.3.16
+Requires-Dist: nvidia-ml-py>=13.590.44
+Requires-Dist: ollama>=0.6.0
+Requires-Dist: platformdirs>=4.5.0
+Requires-Dist: psutil>=7.1.3
+Requires-Dist: py-cpuinfo>=9.0.0
+Requires-Dist: pydantic>=2.12.4
+Requires-Dist: pyperclip>=1.11.0
+Requires-Dist: textual>=6.5.0
+Requires-Dist: typer>=0.20.0
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# RAG-demo
+
+Chat with (a small portion of) Wikipedia
+
+⚠️ RAG functionality is still under development. ⚠️
+
+![app screenshot](screenshots/screenshot_062f205a.png "App screenshot (this AI response is not accurate)")
+
+## Requirements
+
+ 1. [uv](https://docs.astral.sh/uv/)
+ 2. At least one of the following:
+    - A suitable terminal emulator. In particular, on macOS consider using [iTerm2](https://iterm2.com/) instead of the default Terminal.app ([explanation](https://textual.textualize.io/FAQ/#why-doesnt-textual-look-good-on-macos)). On Linux, you might want to try [kitty](https://sw.kovidgoyal.net/kitty/), [wezterm](https://wezterm.org/), [alacritty](https://alacritty.org/), or [ghostty](https://ghostty.org/) instead of the terminal that came with your DE ([reason](https://darren.codes/posts/textual-copy-paste/)). Windows Terminal should be fine as far as I know.
+    - Any common web browser
+
+## Optional stuff that could make your experience better
+
+ 1. [Hugging Face login](https://huggingface.co/docs/huggingface_hub/quick-start#login)
+ 2. API key for your favorite LLM provider (support coming soon)
+ 3. Ollama installed on your system if you have a GPU
+ 4. Run RAG-demo on a more capable (bigger GPU) machine over SSH if you can. It is a terminal app after all.
+
+
+## Run from the repository
+
+First, clone this repository. Then, run one of the options below.
+
+Run in a terminal:
+```bash
+uv run chat
+```
+
+Or run in a web browser:
+```bash
+uv run textual serve chat
+```
+
+## Run from the latest version on PyPI
+
+TODO: test uv automatic torch backend selection:
+https://docs.astral.sh/uv/guides/integration/pytorch/#automatic-backend-selection
+
+Run in a terminal:
+```bash
+uvx --from=jehoctor-rag-demo chat
+```
+
+Or run in a web browser:
+```bash
+uvx --from=jehoctor-rag-demo textual serve chat
+```
+
+## CUDA acceleration via Llama.cpp
+
+If you have an NVIDIA GPU with CUDA and build tools installed, you might be able to get CUDA acceleration without installing Ollama.
+
+```bash
+CMAKE_ARGS="-DGGML_CUDA=on" uv run chat
+```
+
+## Metal acceleration via Llama.cpp (on Apple Silicon)
+
+On an Apple Silicon machine, make sure `uv` runs an ARM interpreter as this should cause it to install Llama.cpp with Metal support.
+
+## Ollama on Linux
+
+Remember that you have to keep Ollama up-to-date manually on Linux.
+A recent version of Ollama (v0.11.10 or later) is required to run the [embedding model we use](https://ollama.com/library/embeddinggemma).
+See this FAQ: https://docs.ollama.com/faq#how-can-i-upgrade-ollama.

jehoctor_rag_demo-0.2.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+rag_demo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rag_demo/__main__.py,sha256=Kak0eQWBRHVGDoWgoHs9j-Tvf_9DMzdurMxD7EM4Jr0,1054
+rag_demo/app.py,sha256=xejrtFApeTeyOQvWDq1H0XPyZEr8cQPn7q9KRwnV660,1812
+rag_demo/app.tcss,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rag_demo/db.py,sha256=53n662Hj9sTqPNcCI2Q-6Ca_HXv3kBQdAhXU4DLhwBM,3226
+rag_demo/dirs.py,sha256=b0VR76kXRHSRWzaXzmAhfPr3-8WKY3ZLW8aLlaPI3Do,309
+rag_demo/logic.py,sha256=7PTWPs9xZJ7bbEtNDMQTX6SX4JKG8HMiq2H_YUfM-CI,12602
+rag_demo/markdown.py,sha256=CxzshWfANeiieZkzMlLzpRaz7tBY2_tZQxhs7b2ImKM,551
+rag_demo/modes/__init__.py,sha256=ccvURDWz51_IotzzlO2OH3i4_Ih_MgnGlOK_JCh45dY,91
+rag_demo/modes/_logic_provider.py,sha256=__eO4XVbyRHkjV_D8OHsPJX5f2R8JoJPcNXhi-w_xFY,1277
+rag_demo/modes/chat.py,sha256=VigWSkw6R2ea95-wZ8tgtKIccev9A-ByzJj7nzglsog,13444
+rag_demo/modes/chat.tcss,sha256=YANlgYygiOr-e61N9HaGGdRPM36pdr-l4u72G0ozt4o,1032
+rag_demo/modes/config.py,sha256=0A8IdY-GOeqCd0kMs2KMgQEsFFeVXEcnowOugtR_Q84,2609
+rag_demo/modes/config.tcss,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rag_demo/modes/help.py,sha256=riV8o4WDtsim09R4cRi0xkpYLgj4CL38IrjEz_mrRmk,713
+rag_demo/modes/help.tcss,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rag_demo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rag_demo/widgets/__init__.py,sha256=JQ1KQjdYQ4texHw2iT4IyBKgTW0SzNYbNoHAbrdCwtk,44
+rag_demo/widgets/escapable_input.py,sha256=VfFij4NOtQ4uX3YFETg5YPd0_nBMky9Xz-02oRdHu-w,4240
+jehoctor_rag_demo-0.2.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+jehoctor_rag_demo-0.2.0.dist-info/entry_points.txt,sha256=-nDSFVcIqdTxzYM4fdveDk3xUKRhmlr_cRuqQechYh4,49
+jehoctor_rag_demo-0.2.0.dist-info/METADATA,sha256=wp1mdAqjB0be_1Uly4hwAoz0bjRUDI6gb6gK5SdrHRU,3531
+jehoctor_rag_demo-0.2.0.dist-info/RECORD,,

jehoctor_rag_demo-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+chat = rag_demo.__main__:main
+

rag_demo/__init__.py

@@ -1,2 +0,0 @@
-def main() -> None:
-    print("Hello from rag-demo!")

rag_demo/__main__.py

@@ -0,0 +1,31 @@
+import time
+
+# Measure the application start time.
+APPLICATION_START_TIME = time.time()
+
+# Disable "module import not at top of file" (aka E402) when importing Typer. This is necessary so that Typer's
+# initialization is included in the application startup time.
+import typer  # noqa: E402
+
+
+def _main(
+    name: str | None = typer.Option(None, help="The name you want to want the AI to use with you."),
+) -> None:
+    """Talk to Wikipedia."""
+    # Import here so that imports run within the typer.run context for prettier stack traces if errors occur.
+    # We ignore PLC0415 because we do not want these imports to be at the top of the module as is usually preferred.
+    from rag_demo.app import RAGDemo  # noqa: PLC0415
+    from rag_demo.logic import Logic  # noqa: PLC0415
+
+    logic = Logic(username=name, application_start_time=APPLICATION_START_TIME)
+    app = RAGDemo(logic)
+    app.run()
+
+
+def main() -> None:
+    """Entrypoint for the rag demo, specifically the `chat` command."""
+    typer.run(_main)
+
+
+if __name__ == "__main__":
+    main()

rag_demo/app.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar
+
+from textual.app import App
+from textual.binding import Binding
+
+from rag_demo.modes import ChatScreen, ConfigScreen, HelpScreen
+
+if TYPE_CHECKING:
+    from rag_demo.logic import Logic, Runtime
+
+
+class RAGDemo(App):
+    """Main application UI.
+
+    This class is responsible for creating the modes of the application, which are defined in :mod:`rag_demo.modes`.
+    """
+
+    TITLE = "RAG Demo"
+    CSS_PATH = Path(__file__).parent / "app.tcss"
+    BINDINGS: ClassVar = [
+        Binding("z", "switch_mode('chat')", "chat"),
+        Binding("c", "switch_mode('config')", "configure"),
+        Binding("h", "switch_mode('help')", "help"),
+    ]
+    MODES: ClassVar = {
+        "chat": ChatScreen,
+        "config": ConfigScreen,
+        "help": HelpScreen,
+    }
+
+    def __init__(self, logic: Logic) -> None:
+        """Initialize the main app.
+
+        Args:
+            logic (Logic): Object implementing the application logic.
+        """
+        super().__init__()
+        self.logic = logic
+        self._runtime_future: asyncio.Future[Runtime] = asyncio.Future()
+
+    async def on_mount(self) -> None:
+        """Set the initial mode to chat and initialize async parts of the logic."""
+        self.switch_mode("chat")
+        self.run_worker(self._hold_runtime())
+
+    async def _hold_runtime(self) -> None:
+        async with self.logic.runtime(app_like=self) as runtime:
+            self._runtime_future.set_result(runtime)
+            # Pause the task until Textual cancels it when the application closes.
+            await asyncio.Event().wait()
+
+    async def runtime(self) -> Runtime:
+        """Returns the application runtime logic."""
+        return await self._runtime_future

rag_demo/db.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import aiosqlite
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class AtomicIDManager:
+    """A database manager for managing thread IDs.
+
+    This was written by Claude, and I fixed it up with feedback from Ruff and Flake8.
+    Maybe one day the app logic database will require something fancier, but this gets the job done now.
+
+    As you can see from the conversation with Claude, this was quite a simple task for it:
+    https://claude.ai/share/227d08ff-96a3-495a-9f56-509a1fd528f7
+    """
+
+    def __init__(self, db_path: str | Path) -> None:
+        """Initialize the database manager."""
+        self.db_path = db_path
+
+    async def initialize(self) -> None:
+        """Initialize the database and create the table if it doesn't exist."""
+        async with aiosqlite.connect(self.db_path) as db:
+            # Enable WAL mode for better concurrent access
+            await db.execute("PRAGMA journal_mode=WAL")
+
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS claimed_ids (
+                    id INTEGER PRIMARY KEY
+                )
+            """)
+            await db.commit()
+
+    async def claim_next_id(self) -> int:
+        """Atomically find the max id, increment it, and claim it. Returns the newly claimed ID.
+
+        This operation is atomic and multiprocess-safe because:
+        1. SQLite serializes writes by default
+        2. We use IMMEDIATE transaction to acquire write lock immediately
+        3. The entire operation happens in a single transaction
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            # Start an IMMEDIATE transaction to get write lock right away
+            await db.execute("BEGIN IMMEDIATE")
+
+            try:
+                # Find the current max ID
+                async with db.execute("SELECT MAX(id) FROM claimed_ids") as cursor:
+                    row = await cursor.fetchone()
+                    max_id = row[0] if row is not None and row[0] is not None else 0
+
+                # Calculate next ID
+                next_id = max_id + 1
+
+                # Insert the new ID
+                await db.execute("INSERT INTO claimed_ids (id) VALUES (?)", (next_id,))
+
+                # Commit the transaction
+                await db.commit()
+
+            except Exception:
+                await db.rollback()
+                raise
+
+            else:
+                return next_id
+
+    async def get_all_claimed_ids(self) -> list[int]:
+        """Retrieve all claimed IDs."""
+        async with (
+            aiosqlite.connect(self.db_path) as db,
+            db.execute("SELECT id FROM claimed_ids ORDER BY id") as cursor,
+        ):
+            rows = await cursor.fetchall()
+            return [row[0] for row in rows]
+
+    async def get_count(self) -> int:
+        """Get the total number of claimed IDs."""
+        async with aiosqlite.connect(self.db_path) as db, db.execute("SELECT COUNT(*) FROM claimed_ids") as cursor:
+            row = await cursor.fetchone()
+            if row is None:
+                raise ValueError("A SQL COUNT query should always return at least one row")  # noqa: EM101, TRY003
+            return row[0]

rag_demo/dirs.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+from platformdirs import PlatformDirs
+
+_appdirs = PlatformDirs(appname="jehoctor-rag-demo", ensure_exists=True)
+
+
+def _ensure(dir_: Path) -> Path:
+    dir_.mkdir(parents=True, exist_ok=True)
+    return dir_
+
+
+DATA_DIR = _appdirs.user_data_path
+CONFIG_DIR = _appdirs.user_config_path

rag_demo/logic.py

@@ -0,0 +1,287 @@
+from __future__ import annotations
+
+import contextlib
+import platform
+import time
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import TYPE_CHECKING, Protocol, TypeVar, cast
+
+import aiosqlite
+import cpuinfo
+import httpx
+import huggingface_hub
+import llama_cpp
+import ollama
+import psutil
+import pynvml
+from datasets import Dataset, load_dataset
+from huggingface_hub import hf_hub_download
+from huggingface_hub.constants import HF_HUB_CACHE
+from langchain.agents import create_agent
+from langchain.messages import AIMessageChunk, HumanMessage
+from langchain_community.chat_models import ChatLlamaCpp
+from langchain_community.embeddings import LlamaCppEmbeddings
+from langchain_core.exceptions import LangChainException
+from langchain_ollama import ChatOllama, OllamaEmbeddings
+from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+
+from rag_demo import dirs
+from rag_demo.db import AtomicIDManager
+from rag_demo.modes.chat import Response, StoppedStreamError
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Awaitable
+
+    from textual.worker import Worker
+
+    from rag_demo.modes import ChatScreen
+
+ResultType = TypeVar("ResultType")
+
+
+class AppLike(Protocol):
+    """Protocol for the subset of what the main App can do that the runtime needs."""
+
+    def run_worker(self, work: Awaitable[ResultType]) -> Worker[ResultType]:
+        """Run a coroutine in the background.
+
+        See https://textual.textualize.io/guide/workers/.
+
+        Args:
+            work (Awaitable[ResultType]): The coroutine to run.
+        """
+        ...
+
+
+class Runtime:
+    """The application logic with asynchronously initialized resources."""
+
+    def __init__(
+        self,
+        logic: Logic,
+        checkpoints_conn: aiosqlite.Connection,
+        thread_id_manager: AtomicIDManager,
+        app_like: AppLike,
+    ) -> None:
+        self.runtime_start_time = time.time()
+        self.logic = logic
+        self.checkpoints_conn = checkpoints_conn
+        self.thread_id_manager = thread_id_manager
+        self.app_like = app_like
+
+        self.current_thread: int | None = None
+        self.generating = False
+
+        if self.logic.probe_ollama() is not None:
+            ollama.pull("gemma3:latest")  # 3.3GB
+            ollama.pull("embeddinggemma:latest")  # 621MB
+            self.llm = ChatOllama(
+                model="gemma3:latest",
+                validate_model_on_init=True,
+                temperature=0.5,
+                num_predict=4096,
+            )
+            self.embed = OllamaEmbeddings(model="embeddinggemma:latest")
+        else:
+            model_path = hf_hub_download(
+                repo_id="bartowski/google_gemma-3-4b-it-GGUF",
+                filename="google_gemma-3-4b-it-Q6_K_L.gguf",  # 3.35GB
+                revision="71506238f970075ca85125cd749c28b1b0eee84e",
+            )
+            embedding_model_path = hf_hub_download(
+                repo_id="CompendiumLabs/bge-small-en-v1.5-gguf",
+                filename="bge-small-en-v1.5-q8_0.gguf",  # 36.8MB
+                revision="d32f8c040ea3b516330eeb75b72bcc2d3a780ab7",
+            )
+            self.llm = ChatLlamaCpp(model_path=model_path, verbose=False)
+            self.embed = LlamaCppEmbeddings(model_path=embedding_model_path, verbose=False)  # pyright: ignore[reportCallIssue]
+
+        self.agent = create_agent(
+            model=self.llm,
+            system_prompt="You are a helpful assistant.",
+            checkpointer=AsyncSqliteSaver(self.checkpoints_conn),
+        )
+
+    def get_rag_datasets(self) -> None:
+        self.qa_test: Dataset = cast(
+            "Dataset",
+            load_dataset("rag-datasets/rag-mini-wikipedia", "question-answer", split="test"),
+        )
+        self.corpus: Dataset = cast(
+            "Dataset",
+            load_dataset("rag-datasets/rag-mini-wikipedia", "text-corpus", split="passages"),
+        )
+
+    async def stream_response(self, response_widget: Response, request_text: str, thread: str) -> None:
+        """Worker method for streaming tokens from the active agent to a response widget.
+
+        Args:
+            response_widget (Response): Target response widget for streamed tokens.
+            request_text (str): Text of the user request.
+            thread (str): ID of the current thread.
+        """
+        self.generating = True
+        async with response_widget.stream_writer() as writer:
+            agent_stream = self.agent.astream(
+                {"messages": [HumanMessage(content=request_text)]},
+                {"configurable": {"thread_id": thread}},
+                stream_mode="messages",
+            )
+            try:
+                async for message_chunk, _ in agent_stream:
+                    if isinstance(message_chunk, AIMessageChunk):
+                        token = cast("AIMessageChunk", message_chunk).content
+                        if isinstance(token, str):
+                            await writer.write(token)
+                        else:
+                            response_widget.log.error(f"Received message content of type {type(token)}")
+                    else:
+                        response_widget.log.error(f"Received message chunk of type {type(message_chunk)}")
+            except StoppedStreamError as e:
+                response_widget.set_shown_object(e)
+            except LangChainException as e:
+                response_widget.set_shown_object(e)
+        self.generating = False
+
+    def new_conversation(self, chat_screen: ChatScreen) -> None:
+        self.current_thread = None
+        chat_screen.clear_chats()
+
+    async def submit_request(self, chat_screen: ChatScreen, request_text: str) -> bool:
+        if self.generating:
+            return False
+        self.generating = True
+        if self.current_thread is None:
+            chat_screen.log.info("Starting new thread")
+            self.current_thread = await self.thread_id_manager.claim_next_id()
+            chat_screen.log.info("Claimed thread id", self.current_thread)
+        chat_screen.new_request(request_text)
+        response = chat_screen.new_response()
+        chat_screen.run_worker(self.stream_response(response, request_text, str(self.current_thread)))
+        return True
+
+
+class Logic:
+    """Top-level application logic."""
+
+    def __init__(
+        self,
+        username: str | None = None,
+        application_start_time: float | None = None,
+        checkpoints_sqlite_db: str | Path = dirs.DATA_DIR / "checkpoints.sqlite3",
+        app_sqlite_db: str | Path = dirs.DATA_DIR / "app.sqlite3",
+    ) -> None:
+        """Initialize the application logic.
+
+        Args:
+            username (str | None, optional): The username provided as a command line argument. Defaults to None.
+            application_start_time (float | None, optional): The time when the application started. Defaults to None.
+            checkpoints_sqlite_db (str | Path, optional): The connection string for the SQLite database used for
+                Langchain checkpointing. Defaults to (dirs.DATA_DIR / "checkpoints.sqlite3").
+            app_sqlite_db (str | Path, optional): The connection string for the SQLite database used for application
+                state such a thread metadata. Defaults to (dirs.DATA_DIR / "app.sqlite3").
+        """
+        self.logic_start_time = time.time()
+        self.username = username
+        self.application_start_time = application_start_time
+        self.checkpoints_sqlite_db = checkpoints_sqlite_db
+        self.app_sqlite_db = app_sqlite_db
+
+    @asynccontextmanager
+    async def runtime(self, app_like: AppLike) -> AsyncIterator[Runtime]:
+        """Returns a runtime context for the application."""
+        # TODO: Do I need to set check_same_thread=False in aiosqlite.connect?
+        async with aiosqlite.connect(database=self.checkpoints_sqlite_db) as checkpoints_conn:
+            id_manager = AtomicIDManager(self.app_sqlite_db)
+            await id_manager.initialize()
+            yield Runtime(self, checkpoints_conn, id_manager, app_like)
+
+    def probe_os(self) -> str:
+        """Returns the OS name (eg 'Linux' or 'Windows'), the system name (eg 'Java'), or an empty string if unknown."""
+        return platform.system()
+
+    def probe_architecture(self) -> str:
+        """Returns the machine architecture, such as 'i386'."""
+        return platform.machine()
+
+    def probe_cpu(self) -> str:
+        """Returns the name of the CPU, e.g. "Intel(R) Core(TM) i7-10610U CPU @ 1.80GHz"."""
+        return cpuinfo.get_cpu_info()["brand_raw"]
+
+    def probe_ram(self) -> int:
+        """Returns the total amount of RAM in bytes."""
+        return psutil.virtual_memory().total
+
+    def probe_disk_space(self) -> int:
+        """Returns the amount of free space in the root directory (in bytes)."""
+        return psutil.disk_usage("/").free
+
+    def probe_llamacpp_gpu_support(self) -> bool:
+        """Returns True if LlamaCpp supports GPU offloading, False otherwise."""
+        return llama_cpp.llama_supports_gpu_offload()
+
+    def probe_huggingface_free_cache_space(self) -> int | None:
+        """Returns the amount of free space in the Hugging Face cache (in bytes), or None if it can't be determined."""
+        with contextlib.suppress(FileNotFoundError):
+            return psutil.disk_usage(HF_HUB_CACHE).free
+        for parent_dir in Path(HF_HUB_CACHE).parents:
+            with contextlib.suppress(FileNotFoundError):
+                return psutil.disk_usage(str(parent_dir)).free
+        return None
+
+    def probe_huggingface_cached_models(self) -> list[huggingface_hub.CachedRepoInfo] | None:
+        """Returns a list of models in the Hugging Face cache (possibly empty), or None if the cache doesn't exist."""
+        # The docstring for huggingface_hub.scan_cache_dir says it raises CacheNotFound "if the cache directory does not
+        # exist," and ValueError "if the cache directory is a file, instead of a directory."
+        with contextlib.suppress(ValueError, huggingface_hub.CacheNotFound):
+            return [repo for repo in huggingface_hub.scan_cache_dir().repos if repo.repo_type == "model"]
+        return None  # Isn't it nice to be explicit?
+
+    def probe_huggingface_cached_datasets(self) -> list[huggingface_hub.CachedRepoInfo] | None:
+        """Returns a list of datasets in the Hugging Face cache (possibly empty), or None if the cache doesn't exist."""
+        with contextlib.suppress(ValueError, huggingface_hub.CacheNotFound):
+            return [repo for repo in huggingface_hub.scan_cache_dir().repos if repo.repo_type == "dataset"]
+        return None
+
+    def probe_nvidia(self) -> tuple[int, list[str]]:
+        """Detect available NVIDIA GPUs and CUDA driver version.
+
+        Returns:
+            tuple[int, list[str]]: A tuple (cuda_version, nv_gpus) where cuda_version is the installed CUDA driver
+                version and nv_gpus is a list of GPU models corresponding to installed NVIDIA GPUs
+        """
+        try:
+            pynvml.nvmlInit()
+        except pynvml.NVMLError:
+            return -1, []
+        cuda_version = -1
+        nv_gpus = []
+        try:
+            cuda_version = pynvml.nvmlSystemGetCudaDriverVersion()
+            for i in range(pynvml.nvmlDeviceGetCount()):
+                handle = pynvml.nvmlDeviceGetHandleByIndex(i)
+                nv_gpus.append(pynvml.nvmlDeviceGetName(handle))
+        except pynvml.NVMLError:
+            pass
+        finally:
+            with contextlib.suppress(pynvml.NVMLError):
+                pynvml.nvmlShutdown()
+        return cuda_version, nv_gpus
+
+    def probe_ollama(self) -> list[ollama.ListResponse.Model] | None:
+        """Returns a list of models installed in Ollama, or None if connecting to Ollama fails."""
+        with contextlib.suppress(ConnectionError):
+            return list(ollama.list().models)
+        return None
+
+    def probe_ollama_version(self) -> str | None:
+        """Returns the Ollama version string (e.g. "0.13.5"), or None if connecting to Ollama fails."""
+        # Yes, this uses private attributes, but that lets me use the Ollama Python lib's env var logic. If you use env
+        # vars to direct the app to a different Ollama server, this will query the same Ollama endpoint as the
+        # ollama.list() call above. Therefore I silence SLF001 here.
+        with contextlib.suppress(httpx.HTTPError, KeyError, ValueError):
+            response: httpx.Response = ollama._client._client.request("GET", "/api/version")  # noqa: SLF001
+            response.raise_for_status()
+            return response.json()["version"]
+        return None

rag_demo/markdown.py

@@ -0,0 +1,17 @@
+from markdown_it import MarkdownIt
+from markdown_it.rules_inline import StateInline
+
+
+def soft2hard_break_plugin(md: MarkdownIt) -> None:
+    md.inline.ruler2.push("soft2hard_break", _soft2hard_break_plugin)
+
+
+def _soft2hard_break_plugin(state: StateInline) -> None:
+    for token in state.tokens:
+        if token.type == "softbreak":
+            token.type = "hardbreak"
+
+
+def parser_factory() -> MarkdownIt:
+    """Modified parser that handles newlines according to LLM conventions."""
+    return MarkdownIt("gfm-like").use(soft2hard_break_plugin)

rag_demo/modes/__init__.py

@@ -0,0 +1,3 @@
+from .chat import ChatScreen
+from .config import ConfigScreen
+from .help import HelpScreen

rag_demo/modes/_logic_provider.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol, cast
+
+from textual.screen import Screen
+from textual.widget import Widget
+
+if TYPE_CHECKING:
+    from rag_demo.logic import Logic, Runtime
+
+
+class LogicProvider(Protocol):
+    """ABC for classes that contain application logic."""
+
+    logic: Logic
+
+    async def runtime(self) -> Runtime: ...
+
+
+class LogicProviderScreen(Screen):
+    """A Screen that provides access to the application logic via its parent app."""
+
+    @property
+    def logic(self) -> Logic:
+        """Returns the application logic of the parent app."""
+        return cast("LogicProvider", self.app).logic
+
+    async def runtime(self) -> Runtime:
+        """Returns the application runtime of the parent app."""
+        return await cast("LogicProvider", self.app).runtime()
+
+
+class LogicProviderWidget(Widget):
+    """A Widget that provides access to the application logic via its parent app."""
+
+    @property
+    def logic(self) -> Logic:
+        """Returns the application logic of the parent app."""
+        return cast("LogicProvider", self.app).logic
+
+    async def runtime(self) -> Runtime:
+        """Returns the application runtime of the parent app."""
+        return await cast("LogicProvider", self.app).runtime()

rag_demo/modes/chat.py

@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+import time
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import pyperclip
+from textual.containers import HorizontalGroup, VerticalGroup, VerticalScroll
+from textual.reactive import reactive
+from textual.widgets import Button, Footer, Header, Input, Label, Markdown, Pretty, Static
+from textual.widgets.markdown import MarkdownStream
+
+from rag_demo.markdown import parser_factory
+from rag_demo.modes._logic_provider import LogicProviderScreen, LogicProviderWidget
+from rag_demo.widgets import EscapableInput
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+    from textual.app import ComposeResult
+
+
+class ResponseStreamInProgressError(ValueError):
+    """Exception raised when a Response widget already has an open writer stream."""
+
+    def __init__(self) -> None:  # noqa: D107
+        super().__init__("This Response widget already has an open writer stream.")
+
+
+class StoppedStreamError(ValueError):
+    """Exception raised when a ResponseWriter is asked to write after it has been stopped."""
+
+    def __init__(self) -> None:  # noqa: D107
+        super().__init__("Can't write to a stopped ResponseWriter stream.")
+
+
+class ResponseWriter:
+    """Stream markdown to a Response widget as if it were a simple Markdown widget.
+
+    This handles streaming to the Markdown widget and updating the raw text widget and the generation rate label.
+
+    This class is based on the MarkdownStream class from the Textual library.
+    """
+
+    def __init__(self, response_widget: Response) -> None:
+        """Initialize a new ResponseWriter.
+
+        Args:
+            response_widget (Response): The Response widget to write to.
+        """
+        self.response_widget = response_widget
+        self._markdown_widget = response_widget.query_one("#markdown-view", Markdown)
+        self._markdown_stream = MarkdownStream(self._markdown_widget)
+        self._raw_widget = response_widget.query_one("#raw-view", Label)
+        self._start_time: float | None = None
+        self._n_chunks = 0
+        self._response_text = ""
+        self._stopped = False
+
+    async def stop(self) -> None:
+        """Stop this ResponseWriter, particularly its underlying MarkdownStream."""
+        self._stopped = True
+        # This is safe even if the MarkdownStream has not been started, or has already been stopped.
+        await self._markdown_stream.stop()
+        # Because of the markdown parsing tweaks I made in src/rag_demo/markdown.py, we need to reparse the final
+        # markdown and rerender one more time to clean up small issues with newlines.
+        self._markdown_widget.update(self._response_text)
+
+    async def write(self, markdown_fragment: str) -> None:
+        """Stream a single chunk/fragment to the corresponding Response widget.
+
+        Args:
+            markdown_fragment (str): The new markdown fragment to append to the existing markdown.
+
+        Raises:
+            StoppedStreamError: Raised if the new markdown chunk cannot be accepted because the stream has been stopped.
+        """
+        if self._stopped:
+            raise StoppedStreamError
+        write_time = time.time()
+        self._response_text += markdown_fragment
+        self.response_widget.set_reactive(Response.content, self._response_text)
+        self._raw_widget.update(self._response_text)
+        if self._start_time is None:
+            # The first chunk. Can't set the rate label until we have a second chunk.
+            self._start_time = write_time
+
+            self._markdown_widget.update(markdown_fragment)
+            self._markdown_stream.start()
+        else:
+            # The second and subsequent chunks. Note that self._n_chunks has not been incremented yet because
+            # we are calculating the generation rate excluding the first chunk, which may have required loading a
+            # large model.
+            rate = self._n_chunks / (write_time - self._start_time)
+            self.response_widget.update_rate_label(rate)
+
+            await self._markdown_stream.write(markdown_fragment)
+        self._n_chunks += 1
+
+
+class Response(LogicProviderWidget):
+    """Allow toggling between raw and rendered versions of markdown text."""
+
+    show_raw = reactive(False, layout=True)
+    content = reactive("", layout=True)
+
+    def __init__(self, *, content: str = "", classes: str | None = None) -> None:
+        """Initialize a new Response widget.
+
+        Args:
+            content (str, optional): Initial response text. Defaults to empty string.
+            classes (str | None, optional): Optional widget classes for use with TCSS. Defaults to None.
+        """
+        super().__init__(classes=classes)
+        self.set_reactive(Response.content, content)
+        self._stream: ResponseWriter | None = None
+        self.__object_to_show_sentinel = object()
+        self._object_to_show: Any = self.__object_to_show_sentinel
+
+    def compose(self) -> ComposeResult:
+        """Compose the initial content of the widget."""
+        with VerticalGroup():
+            with HorizontalGroup(id="header"):
+                yield Label("Chunks/s: ???", id="token-rate")
+                with HorizontalGroup(id="buttons"):
+                    yield Button("Stop", id="stop", variant="primary")
+                    yield Button("Show Raw", id="show-raw", variant="primary")
+                    yield Button("Copy", id="copy", variant="primary")
+            yield Markdown(self.content, id="markdown-view", parser_factory=parser_factory)
+            yield Label(self.content, id="raw-view", markup=False)
+            yield Pretty(None, id="object-view")
+
+    def on_mount(self) -> None:
+        """Hide certain elements until they are needed."""
+        self.query_one("#raw-view", Label).display = False
+        self.query_one("#object-view", Pretty).display = False
+        self.query_one("#stop", Button).display = False
+
+    def set_shown_object(self, obj: Any) -> None:  # noqa: ANN401
+        self._object_to_show = obj
+        self.query_one("#markdown-view", Markdown).display = False
+        self.query_one("#raw-view", Label).display = False
+        self.query_one("#show-raw", Button).display = False
+        self.query_one("#object-view", Pretty).update(obj)
+        self.query_one("#object-view", Pretty).display = True
+
+    def clear_shown_object(self) -> None:
+        self._object_to_show = self.__object_to_show_sentinel
+        self.query_one("#object-view", Pretty).display = False
+        if self.show_raw:
+            self.query_one("#raw-view", Label).display = True
+        else:
+            self.query_one("#markdown-view", Markdown).display = True
+        self.query_one("#show-raw", Button).display = True
+
+    @asynccontextmanager
+    async def stream_writer(self) -> AsyncIterator[ResponseWriter]:
+        """Open an exclusive stream to write markdown in chunks.
+
+        Raises:
+            ResponseWriteInProgressError: Raised when there is already an open stream.
+
+        Yields:
+            ResponseWriter: The new stream writer.
+        """
+        if self._stream is not None:
+            raise ResponseStreamInProgressError
+        self._stream = ResponseWriter(self)
+        self.query_one("#stop", Button).display = True
+        try:
+            yield self._stream
+        finally:
+            await self._stream.stop()
+            self.query_one("#stop", Button).display = False
+            self._stream = None
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button press events."""
+        if event.button.id == "stop":
+            if self._stream is not None:
+                await self._stream.stop()
+        elif event.button.id == "show-raw":
+            self.show_raw = not self.show_raw
+        elif event.button.id == "copy":
+            # Textual and Pyperclip use different methods to copy text to the clipboard. Textual uses ANSI escape
+            # sequence magic that is not supported by all terminals. Pyperclip uses OS-specific clipboard APIs, but it
+            # does not work over SSH.
+            start = time.time()
+            self.app.copy_to_clipboard(self.content)
+            checkpoint = time.time()
+            try:
+                pyperclip.copy(self.content)
+            except pyperclip.PyperclipException as e:
+                self.app.log.error(f"Error copying to clipboard with Pyperclip: {e}")
+            checkpoint2 = time.time()
+            self.notify(f"Copied {len(self.content.splitlines())} lines of text to clipboard")
+            end = time.time()
+            self.app.log.info(f"Textual copy took {checkpoint - start:.6f} seconds")
+            self.app.log.info(f"Pyperclip copy took {checkpoint2 - checkpoint:.6f} seconds")
+            self.app.log.info(f"Notify took {end - checkpoint2:.6f} seconds")
+            self.app.log.info(f"Total of {end - start:.6f} seconds")
+
+    def watch_show_raw(self) -> None:
+        """Handle reactive updates to the show_raw attribute by changing the visibility of the child widgets.
+
+        This also keeps the text on the visibility toggle button up-to-date.
+        """
+        if self._object_to_show is not self.__object_to_show_sentinel:
+            return
+        button = self.query_one("#show-raw", Button)
+        markdown_view = self.query_one("#markdown-view", Markdown)
+        raw_view = self.query_one("#raw-view", Label)
+
+        if self.show_raw:
+            button.label = "Show Rendered"
+            markdown_view.display = False
+            raw_view.display = True
+        else:
+            button.label = "Show Raw"
+            markdown_view.display = True
+            raw_view.display = False
+
+    def watch_content(self, content: str) -> None:
+        """Handle reactive updates to the content attribute by updating the markdown and raw views.
+
+        Args:
+            content (str): New content for the widget.
+        """
+        self.query_one("#markdown-view", Markdown).update(content)
+        self.query_one("#raw-view", Label).update(content)
+
+    def update_rate_label(self, rate: float | None) -> None:
+        """Update or reset the generation rate indicator.
+
+        Args:
+            rate (float | None): Generation rate, or None to reset. Defaults to None.
+        """
+        label_text = "Chunks/s: ???" if rate is None else f"Chunks/s: {rate:.2f}"
+        self.query_one("#token-rate", Label).update(label_text)
+
+
+class ChatScreen(LogicProviderScreen):
+    """Main mode of the app. Talk to the AI agent."""
+
+    SUB_TITLE = "Chat"
+    CSS_PATH = Path(__file__).parent / "chat.tcss"
+
+    def compose(self) -> ComposeResult:
+        """Compose the initial content of the chat screen."""
+        yield Header()
+        chats = VerticalScroll(id="chats")
+        with chats:
+            yield HorizontalGroup(id="top-chat-separator")
+        with HorizontalGroup(id="new-request-bar"):
+            yield Static()
+            yield Button("New Conversation", id="new-conversation")
+            yield EscapableInput(placeholder="     What do you want to know?", id="new-request", focus_on_escape=chats)
+            yield Static()
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """When the screen is mounted, focus the input field and enable bottom anchoring for the message view."""
+        self.query_one("#new-request", Input).focus()
+        self.query_one("#chats", VerticalScroll).anchor()
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button press events."""
+        if event.button.id == "new-conversation":
+            (await self.runtime()).new_conversation(self)
+
+    async def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Handle submission of new requests."""
+        if event.input.id == "new-request":
+            accepted = await (await self.runtime()).submit_request(self, event.value)
+            if accepted:
+                self.query_one("#new-request", Input).value = ""
+
+    def clear_chats(self) -> None:
+        """Clear the chat scroll area."""
+        chats = self.query_one("#chats", VerticalScroll)
+        for child in chats.children:
+            if child.id != "top-chat-separator":
+                child.remove()
+
+    def new_request(self, request_text: str) -> Label:
+        """Create a new request element in the chat area.
+
+        Args:
+            request_text (str): The text of the request.
+
+        Returns:
+            Label: The request element.
+        """
+        chats = self.query_one("#chats", VerticalScroll)
+        request = Label(request_text, classes="request")
+        chats.mount(HorizontalGroup(request, classes="request-container"))
+        chats.anchor()
+        return request
+
+    def new_response(self, response_text: str = "Waiting for AI to respond...") -> Response:
+        """Create a new response element in the chat area.
+
+        Args:
+            response_text (str, optional): Initial response text. Usually this is a default message shown before
+                streaming the actual response. Defaults to "Waiting for AI to respond...".
+
+        Returns:
+            Response: The response widget/element.
+        """
+        chats = self.query_one("#chats", VerticalScroll)
+        response = Response(content=response_text, classes="response")
+        chats.mount(HorizontalGroup(response, classes="response-container"))
+        chats.anchor()
+        return response

rag_demo/modes/chat.tcss

@@ -0,0 +1,75 @@
+ToastRack {
+    margin-bottom: 5;
+}
+
+#chats {
+    width: 100%;
+    hatch: left $primary-darken-2 100%;
+}
+
+#top-chat-separator {
+    hatch: left $primary-darken-2 100%;
+    height: 1;
+}
+
+.request {
+    min-width: 30%;
+    max-width: 90%;
+    padding: 1 2 1 2;
+    margin: 0 2 1 0;
+    background: $boost;
+}
+
+.request-container {
+    align-horizontal: right;
+    hatch: left $primary-darken-2 100%;
+}
+
+.response-container {
+    align-horizontal: left;
+    hatch: left $primary-darken-2 100%;
+}
+
+.response {
+    margin: 0 0 1 2;
+    width: 90%;
+    height: auto;
+}
+
+.response #header {
+    background: $primary-darken-3;
+    margin-bottom: 1;
+}
+
+.response #buttons {
+    align-horizontal: right;
+}
+
+.response Button {
+    border: none;
+    min-width: 18;
+    margin-left: 1;
+}
+
+#token-rate {
+    padding-left: 1;
+}
+
+#raw-view {
+    padding: 0 2 1 2;
+}
+
+#new-request-bar > Static {
+    width: 5%;
+    height: 3;
+    hatch: cross $surface 100%;
+}
+
+#new-conversation {
+    min-width: 20;
+}
+
+#new-request {
+    width: 1fr;
+    height: 3;
+}

rag_demo/modes/config.py

@@ -0,0 +1,77 @@
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.widgets import (
+    Button,
+    Footer,
+    Header,
+    Input,
+    Label,
+    RadioButton,
+    RadioSet,
+    Static,
+)
+
+from rag_demo.modes._logic_provider import LogicProviderScreen
+
+
+class ConfigScreen(LogicProviderScreen):
+    SUB_TITLE = "Configure"
+    CSS_PATH = Path(__file__).parent / "config.tcss"
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Container(
+            Static("🤖 LLM Configuration", classes="title"),
+            Label("Select your LLM provider:"),
+            RadioSet(
+                RadioButton("OpenAI (API)", id="openai"),
+                RadioButton("Anthropic Claude (API)", id="anthropic"),
+                RadioButton("Ollama (Local)", id="ollama"),
+                RadioButton("LlamaCpp (Local)", id="llamacpp"),
+                id="provider",
+            ),
+            Label("Model name:"),
+            Input(placeholder="e.g., gpt-4, claude-3-sonnet-20240229", id="model"),
+            Label("API Key (if applicable):"),
+            Input(placeholder="sk-...", password=True, id="api-key"),
+            Label("Base URL (for Ollama):"),
+            Input(placeholder="http://localhost:11434", id="base-url"),
+            Label("Model Path (for LlamaCpp):"),
+            Input(placeholder="/path/to/model.gguf", id="model-path"),
+            Horizontal(
+                Button("Save & Continue", variant="primary", id="save"),
+                Button("Cancel", id="cancel"),
+            ),
+        )
+        yield Footer()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "save":
+            config = self.collect_config()
+            self.app.config_manager.save_config(config)
+            self.app.pop_screen()  # Return to main app
+        elif event.button.id == "cancel":
+            self.app.exit()
+
+    def collect_config(self) -> dict:
+        provider = self.query_one("#provider", RadioSet).pressed_button.id
+        model = self.query_one("#model", Input).value
+        api_key = self.query_one("#api-key", Input).value
+        base_url = self.query_one("#base-url", Input).value
+        model_path = self.query_one("#model-path", Input).value
+
+        config = {
+            "provider": provider,
+            "model": model,
+        }
+
+        if api_key:
+            config["api_key"] = api_key
+        if base_url:
+            config["base_url"] = base_url
+        if model_path:
+            config["model_path"] = model_path
+
+        return config

rag_demo/modes/help.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.widgets import Footer, Header, Label
+
+from rag_demo.modes._logic_provider import LogicProviderScreen
+
+
+class HelpScreen(LogicProviderScreen):
+    """Display information about the application."""
+
+    SUB_TITLE = "Help"
+    CSS_PATH = Path(__file__).parent / "help.tcss"
+
+    def compose(self) -> ComposeResult:
+        """Create the widgets of the help screen.
+
+        Returns:
+            ComposeResult: composition of the help screen
+
+        Yields:
+            Iterator[ComposeResult]: composition of the help screen
+        """
+        yield Header()
+        yield Label("Help Screen (under construction)")
+        yield Footer()

rag_demo/widgets/__init__.py

@@ -0,0 +1 @@
+from .escapable_input import EscapableInput

rag_demo/widgets/escapable_input.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.widgets import Input
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from rich.console import RenderableType
+    from rich.highlighter import Highlighter
+    from textual.events import Key
+    from textual.suggester import Suggester
+    from textual.validation import Validator
+    from textual.widget import Widget
+    from textual.widgets._input import InputType, InputValidationOn
+
+
+class EscapableInput(Input):
+    """An input widget that deselects itself when the user presses escape.
+
+    Inherits all properties and methods from the :class:`textual.widgets.Input` class.
+    """
+
+    def __init__(  # noqa: PLR0913
+        self,
+        value: str | None = None,
+        placeholder: str = "",
+        highlighter: Highlighter | None = None,
+        password: bool = False,  # noqa: FBT001, FBT002
+        *,
+        restrict: str | None = None,
+        type: InputType = "text",  # noqa: A002
+        max_length: int = 0,
+        suggester: Suggester | None = None,
+        validators: Validator | Iterable[Validator] | None = None,
+        validate_on: Iterable[InputValidationOn] | None = None,
+        valid_empty: bool = False,
+        select_on_focus: bool = True,
+        name: str | None = None,
+        id: str | None = None,  # noqa: A002
+        classes: str | None = None,
+        disabled: bool = False,
+        tooltip: RenderableType | None = None,
+        compact: bool = False,
+        focus_on_escape: Widget | None = None,
+    ) -> None:
+        """Initialise the `EscapableInput` widget.
+
+        Args:
+            value: An optional default value for the input.
+            placeholder: Optional placeholder text for the input.
+            highlighter: An optional highlighter for the input.
+            password: Flag to say if the field should obfuscate its content.
+            restrict: A regex to restrict character inputs.
+            type: The type of the input.
+            max_length: The maximum length of the input, or 0 for no maximum length.
+            suggester: [`Suggester`][textual.suggester.Suggester] associated with this
+                input instance.
+            validators: An iterable of validators that the Input value will be checked against.
+            validate_on: Zero or more of the values "blur", "changed", and "submitted",
+                which determine when to do input validation. The default is to do
+                validation for all messages.
+            valid_empty: Empty values are valid.
+            select_on_focus: Whether to select all text on focus.
+            name: Optional name for the input widget.
+            id: Optional ID for the widget.
+            classes: Optional initial classes for the widget.
+            disabled: Whether the input is disabled or not.
+            tooltip: Optional tooltip.
+            compact: Enable compact style (without borders).
+            focus_on_escape: An optional widget to focus on when escape is pressed. Defaults to `None`.
+        """
+        super().__init__(
+            value=value,
+            placeholder=placeholder,
+            highlighter=highlighter,
+            password=password,
+            restrict=restrict,
+            type=type,
+            max_length=max_length,
+            suggester=suggester,
+            validators=validators,
+            validate_on=validate_on,
+            valid_empty=valid_empty,
+            select_on_focus=select_on_focus,
+            name=name,
+            id=id,
+            classes=classes,
+            disabled=disabled,
+            tooltip=tooltip,
+            compact=compact,
+        )
+        self.focus_on_escape = focus_on_escape
+
+    def on_key(self, event: Key) -> None:
+        """Deselect the input if the event is the escape key.
+
+        This method overrides the base :meth:`textual.widgets.Input.on_key` implementation.
+
+        Args:
+            event (Key): Event details, including the key pressed.
+        """
+        if event.key == "escape":
+            if self.focus_on_escape is not None:
+                self.focus_on_escape.focus()
+            else:
+                self.blur()
+            event.prevent_default()
+            event.stop()

jehoctor_rag_demo-0.1.1.dev1.dist-info/METADATA

@@ -1,11 +0,0 @@
-Metadata-Version: 2.3
-Name: jehoctor-rag-demo
-Version: 0.1.1.dev1
-Summary: Chat with Wikipedia
-Author: James Hoctor
-Author-email: James Hoctor <JEHoctor@protonmail.com>
-Requires-Python: >=3.13
-Description-Content-Type: text/markdown
-
-# RAG-demo
-Chat with Wikipedia

jehoctor_rag_demo-0.1.1.dev1.dist-info/RECORD

@@ -1,6 +0,0 @@
-rag_demo/__init__.py,sha256=STIqC0dNmRNCbDeEDuODLXSsOmuQsB5MC9Ii3el0TDk,54
-rag_demo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jehoctor_rag_demo-0.1.1.dev1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-jehoctor_rag_demo-0.1.1.dev1.dist-info/entry_points.txt,sha256=3XjzSTMUH0sKTfuLk5yj8ilz0M-SF4_UuZAu-MVH8qM,40
-jehoctor_rag_demo-0.1.1.dev1.dist-info/METADATA,sha256=drDoEBvOOWd5XW3DCedSPqLq3HXkcJquTJ0A4HLi1EU,265
-jehoctor_rag_demo-0.1.1.dev1.dist-info/RECORD,,

jehoctor_rag_demo-0.1.1.dev1.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-chat = rag_demo:main
-