Quote:(GPE) peterr@peterr-Modern-15-B7M:~/PVE$ pip install pygame
Requirement already satisfied: pygame in ./GPE/lib/python3.12/site-packages (2.6.1)
(GPE) peterr@peterr-Modern-15-B7M:~/PVE$

Quote:(GPE) peterr@peterr-Modern-15-B7M:~/PVE$ games/versuch1.py
Traceback (most recent call last):
File "/home/peterr/PVE/games/versuch1.py", line 3, in <module>
import pygame
ModuleNotFoundError: No module named 'pygame'
(GPE) peterr@peterr-Modern-15-B7M:~/PVE$

Quote:#! /usr/bin/python3

Quote:#! /home/peterr/PVE/GPE/python3.12/bin/python3

Quote:#! GPE/python3.12/bin/python3

import pygame
pygame 2.6.1 (SDL 2.28.4, Python 3.12.3)
Hello from the pygame community. https://www.pygame.org/contribute.html

Quote:GPE/lib/python3.12/site-packages

class MessageLoop(object):
    """A class representing a message loop."""

    #: The message that signals this loop to terminate
    WM_STOP = 0x0401

    _LPMSG = ctypes.POINTER(wintypes.MSG)

    _GetMessage = windll.user32.GetMessageW
    _GetMessage.argtypes = (
        ctypes.c_voidp,  # Really _LPMSG
        wintypes.HWND,
        wintypes.UINT,
        wintypes.UINT,
    )
    _PeekMessage = windll.user32.PeekMessageW
    _PeekMessage.argtypes = (
        ctypes.c_voidp,  # Really _LPMSG
        wintypes.HWND,
        wintypes.UINT,
        wintypes.UINT,
        wintypes.UINT,
    )
    _PostThreadMessage = windll.user32.PostThreadMessageW
    _PostThreadMessage.argtypes = (
        wintypes.DWORD,
        wintypes.UINT,
        wintypes.WPARAM,
        wintypes.LPARAM,
    )

    PM_NOREMOVE = 0

    def __init__(self):
        self._threadid = None
        self._event = threading.Event()
        self.thread = None

    def __iter__(self):
        """Initialises the message loop and yields all messages until
        :meth:`stop` is called.

        :raises AssertionError: if :meth:`start` has not been called
        """
        assert self._threadid is not None

        try:
            # Pump messages until WM_STOP
            while True:
                msg = wintypes.MSG()
                lpmsg = ctypes.byref(msg)
                r = self._GetMessage(lpmsg, None, 0, 0)
                if r <= 0 or msg.message == self.WM_STOP:
                    break
                else:
                    yield msg

        finally:
            self._threadid = None
            self.thread = None

    def start(self):
        """Starts the message loop.

        This method must be called before iterating over messages, and it must
        be called from the same thread.
        """
        self._threadid = GetCurrentThreadId()
        self.thread = threading.current_thread()

        # Create the message loop
        msg = wintypes.MSG()
        lpmsg = ctypes.byref(msg)
        self._PeekMessage(lpmsg, None, 0x0400, 0x0400, self.PM_NOREMOVE)

        # Set the event to signal to other threads that the loop is created
        self._event.set()

    def stop(self):
        """Stops the message loop."""
        self._event.wait()
        if self._threadid:
            self.post(self.WM_STOP, 0, 0)

    def post(self, msg, wparam, lparam):
        """Posts a message to this message loop.

        :param ctypes.wintypes.UINT msg: The message.

        :param ctypes.wintypes.WPARAM wparam: The value of ``wParam``.

        :param ctypes.wintypes.LPARAM lparam: The value of ``lParam``.
        """
        self._PostThreadMessage(self._threadid, msg, wparam, lparam)

import ctypes
import sys
from collections.abc import Callable, Generator
from ctypes import wintypes
from ctypes.wintypes import MSG
from enum import IntEnum
from threading import Thread, current_thread
from typing import Any


# @formatter:off
class WM(IntEnum):
    CLOSE         = 0x0010
    QUIT          = 0x0012
    TIMER         = 0x0113
    USER          = 0x0400

    APP           = 0x8000
    REGISTER      = APP + 1

    START         = APP + 2
    CLOSE_THREAD  = APP + 3

    PRINT         = APP + 4


class PM(IntEnum):
    NOREMOVE = 0


class CtrlType(IntEnum):
    CTRL_C_EVENT     = 0
    CTRL_BREAK_EVENT = 1
    CTRL_CLOSE_EVENT = 2
# @formatter:on


# Provides strict type signatures so static analyzers treat the ctypes bindings as native methods rather than opaque _NamedFuncPointer objects.
def override_api_stubs(cls):
    kernel32 = ctypes.WinDLL('kernel32', use_last_error = True)
    user32 = ctypes.WinDLL('user32', use_last_error = True)

    cls.phandler_routine = ctypes.WINFUNCTYPE(
        wintypes.BOOL,
        wintypes.DWORD
    )

    cls.set_console_ctrl_handler = kernel32.SetConsoleCtrlHandler
    cls.set_console_ctrl_handler.argtypes = (cls.phandler_routine, wintypes.BOOL)
    cls.set_console_ctrl_handler.restype = wintypes.BOOL

    cls.get_message = user32.GetMessageW
    cls.get_message.argtypes = (ctypes.c_void_p, wintypes.HWND, wintypes.UINT, wintypes.UINT)
    cls.get_message.restype = wintypes.INT

    cls.peek_message = user32.PeekMessageW
    cls.peek_message.argtypes = (ctypes.c_void_p, wintypes.HWND, wintypes.UINT, wintypes.UINT, wintypes.UINT)
    cls.peek_message.restype = wintypes.BOOL

    cls.post_thread_message = user32.PostThreadMessageW
    cls.post_thread_message.argtypes = (wintypes.DWORD, wintypes.UINT, wintypes.WPARAM, wintypes.LPARAM)
    cls.post_thread_message.restype = wintypes.BOOL

    cls.set_timer = user32.SetTimer
    cls.set_timer.argtypes = (wintypes.HWND, ctypes.c_size_t, wintypes.UINT, ctypes.c_void_p)
    cls.set_timer.restype = ctypes.c_size_t

    cls.kill_timer = user32.KillTimer
    cls.kill_timer.argtypes = (wintypes.HWND, ctypes.c_size_t)
    cls.kill_timer.restype = wintypes.BOOL

    return cls


@override_api_stubs
class APIMixin:
    # Provides strict type signatures so static analyzers treat the ctypes bindings as native methods rather than opaque _NamedFuncPointer objects.

    _thread: Thread

    def __iter__(self) -> Generator[MSG, None, None]:
        try:

            msg = MSG()
            lpmsg = ctypes.byref(msg)

            # Windows uses lazy memory allocation for thread queues.
            # We query WM_USER to forcefully allocate the queue in RAM before listening.
            self.peek_message(
                lpmsg,
                None, WM.USER,
                WM.USER,
                PM.NOREMOVE
            )

            # GetMessageW acts as a zero-CPU thread blocker.
            # It sleeps natively at the OS level until message is received.
            while self.get_message(lpmsg, None, 0, 0) > 0:
                if msg.message == WM.QUIT:
                    break

                else:
                    yield msg

        finally:
            self._thread = None

    def post(self, tid: int, msg: int, wparam: int, lparam: int):
        self.post_thread_message(tid, msg, wparam, lparam)

    def phandler_routine(self, func: Callable[[int], bool]) -> Any: ...
    def set_console_ctrl_handler(self, handler_routine: Any, add: bool) -> bool: ...
    def get_message(self, msg: Any, hwnd: None, msg_filter_min: int, msg_filter_max: int) -> int: ...
    def peek_message(self, msg: Any, hwnd: int, msg_filter_min: int, msg_filter_max: int, remove_msg: int) -> bool: ...
    def post_thread_message(self, thread_id: int, msg: int, wparam: int, lparam: int) -> bool: ...
    def set_timer(self, hwnd: int, event_id: int, elapse: int, timer_func: Any) -> int: ...
    def kill_timer(self, hwnd: int, event_id: int) -> int: ...


class Supervisor(APIMixin):

    @property
    def children(self) -> list[int]:
        return self._children

    def __init__(self):
        super().__init__()

        self._thread = current_thread()
        self._thread_name = self._thread.name

        self._children = []

        # Hooks into the console to intercept Ctrl+C/Close events for a clean teardown.
        self._handler_routine = self.phandler_routine(self.console_stop_event_handler)
        self.set_console_ctrl_handler(self._handler_routine, True)

    def spin(self):
        self._clear_terminal()
        self._hide_cursor()

        for i in range(10):
            Worker(main_tid = self._thread.native_id, name = f'Worker {i + 1:02}').start()

        for msg in self:
            if msg.message == WM.REGISTER:
                self.register(msg.wParam)

            elif msg.message == WM.PRINT:
                text = self._extract_text(msg.wParam)

                print(f'Pulse sent from thread: {text!r}')

            elif msg.message == WM.CLOSE:
                self.close_children()

            elif msg.message == WM.CLOSE_THREAD:
                text = self._extract_text(msg.wParam)
                child_id = msg.lParam

                print(f'Closing {text!r}')

                self.send_quit(child_id)

                if len(self.children) == 0:
                    break

        print(f'Closing {self._thread_name!r}')
        self._show_cursor()

    def send_quit(self, tid: int):
        self.children.remove(tid)
        self.post(tid, WM.QUIT, 0, 0)

    def close(self):
        self.post(self._thread.native_id, WM.CLOSE, 0, 0)

    def close_children(self):
        for tid in self._children:
            self.post(tid, WM.CLOSE, 0, 0)

    def register(self, tid: int):
        self._children.append(tid)
        self.post(tid, WM.START, 0, 0)

    @staticmethod
    def _extract_text(memory_address: int) -> str:
        return ctypes.wstring_at(memory_address)

    def _clear_terminal(self):
        self._write('\x1b[2J', f'\x1b[3J', f'\x1b[H')

    def _hide_cursor(self):
        self._write('\x1b[?25l')

    def _show_cursor(self):
        self._write('\x1b[?25h')

    @staticmethod
    def _write(*lines: str):
        for line in lines:
            sys.stdout.write(line)

        sys.stdout.flush()

    def console_stop_event_handler(self, ctrl_type: int) -> bool:

        try:
            event = CtrlType(ctrl_type)

            print(f"\nShutdown signal detected {event.name!r}.\nIssuing a 'WM_CLOSE' message to main thread . . .\n")
            self.close()
            return True  # Tell Windows we handled the signal

        except ValueError:
            return False


class Worker(Thread, APIMixin):
    def __init__(self, main_tid: int, name: str):
        super(Worker, self).__init__(name = name)

        self._main_tid = main_tid
        self._timer: int = None

        self._name_buffer = ctypes.create_unicode_buffer(self.name)
        self._name_pointer = ctypes.addressof(self._name_buffer)

    def run(self):
        self.send_register()

        for msg in self:
            if msg.message == WM.START:
                self.start_timer()

            elif msg.message == WM.TIMER:
                self.send_print()

            elif msg.message == WM.CLOSE:
                self.send_closing()

    def send_print(self) -> None:
        self.post(self._main_tid, WM.PRINT, self._name_pointer, 0)

    def send_closing(self):
        self.stop_timer()
        self.post(self._main_tid, WM.CLOSE_THREAD, self._name_pointer, self.native_id)

    def send_register(self):
        self.post(self._main_tid, WM.REGISTER, self.native_id, 0)

    def start_timer(self):
        self._timer = self.set_timer(None, 0, 1000, None)

    def stop_timer(self):
        self.kill_timer(None, self._timer)


if __name__ == '__main__':
    supervisor = Supervisor()
    supervisor.spin()

def spam():
    eggs = 'spam local'
    print(eggs)  # Prints 'spam local'

def bacon():
    eggs = 'bacon local'
    print(eggs)  # Prints 'bacon local'
    spam()
    print(eggs)  # Prints 'bacon local'

eggs = 'global'
bacon()
print(eggs)  # Prints 'global'

Output:
bacon local
spam local
bacon local
global

CMD = "dir /AD /OD c:\\".rstrip()
CMD = r"dir /AD /OD c:".rstrip()
CMD = r"dir /AD /OD c:"
CMD = "dir /AD /OD c:"
print(CMD)

p = subprocess.run((['cmd.exe', '/c', 'dir', CMD]), text=True, stdout=subprocess.PIPE, creationflags=subprocess.CREATE_NO_WINDOW)
if p.returncode != 0:
	output = f"ERROR:{p.stderr}"
else:
	output = f"OK: {p.stdout}"
blah = input(f"Output:{output}")

import time, os

DIR=r"c:\temp"
dirs = [s for s in os.listdir(DIR) if os.path.isdir(os.path.join(DIR, s))]
for dir in dirs:
	print(dir, time.ctime(os.path.getmtime(dir)))

import time
from datetime import datetime, timezone
from pathlib import Path

paths = [subdir for subdir in Path(DIR).iterdir() if subdir.is_dir()]
paths = sorted(paths, key=os.path.getmtime)
for path in paths:
	stat_result = path.stat()
	modified = datetime.fromtimestamp(stat_result.st_mtime, tz=timezone.utc).strftime('%Y-%m-%d')
	print(f"{path} {modified}")

1. Create a project directory and name it MarkdownCommander.
   
2. cd to that directory.
   
3. Create a virtual environment, using whatever tool you like. I use pythons venv like so: python -m venv venv
   
4. Start the virtual environment: . ./venv/bin/activate
   
5. install wxpython using the following command: pip install -U -f https://extras.wxpython.org/wxPython4/extras/linux/gtk3/ubuntu-22.04 wxPython
   This command is for Ubuntu system, using gtk which is what linux mint 21.3 uses as it's base. You may have to play with this for your OS. wxpython can be fussy.
   
6. Cleanup apt: sudo apt autoclean
   
7. Update apt: sudo apt update
   
8. Install wxwidgets using: sudo apt install libwxgtk3.0-dev
   
9. Install mistune: pip install mistune
   
10. install sentence_transformers: pip install sentence_transformers
    
11. Create a src directory, and cd to that directory:
    mkdir src
cd src
    
12. create an empty __init__.py file: touch __init__.py
    
13. Using you favorite text editor, add MarkdownCommander.py:
    

    import wx
    import wx.html2
    import mistune
    from pathlib import Path
    from sentence_transformers import SentenceTransformer, util
    import threading
    import torch
    from datetime import datetime
    
    
    # ====================== SAFE TORCH LOAD ======================
    torch.serialization.add_safe_globals([datetime])
    
    
    class SemanticIndexer:
        def __init__(self, model_name="all-MiniLM-L6-v2"):
            self.model = SentenceTransformer(model_name)
            self.embeddings = None
            self.file_paths = []
            self.file_names = []
            self.file_mtimes = []
            self.source_dir = None
            self.build_time = None
            self.last_update_time = None
            self.exclude_dirs = {'.git', 'node_modules', '__pycache__', 'venv', 'env', '.venv'}
    
        def _get_file_info(self, path: Path):
            try:
                text = path.read_text(encoding='utf-8', errors='ignore')[:12000]
                stat = path.stat()
                return text, stat.st_mtime
            except:
                return None, None
    
        def build_index(self, directory: str):
            directory = Path(directory)
            self.source_dir = directory
            texts = []
            self.file_paths.clear()
            self.file_names.clear()
            self.file_mtimes.clear()
    
            for p in directory.rglob("*.*"):
                if any(ex in p.parts for ex in self.exclude_dirs):
                    continue
                if p.suffix.lower() not in {'.md', '.txt', '.py', '.html', '.rst'}:
                    continue
                text, mtime = self._get_file_info(p)
                if text:
                    texts.append(text)
                    self.file_paths.append(str(p))
                    self.file_names.append(p.name)
                    self.file_mtimes.append(mtime)
    
            print(f"Encoding {len(texts)} documents...")
            self.embeddings = self.model.encode(texts, convert_to_tensor=True, show_progress_bar=True)
            self.build_time = datetime.now()
            self.last_update_time = datetime.now()
    
        def search(self, query: str, top_k=10):
            if self.embeddings is None:
                return []
            query_emb = self.model.encode(query, convert_to_tensor=True)
            hits = util.semantic_search(query_emb, self.embeddings, top_k=top_k)[0]
            return [(self.file_paths[h['corpus_id']], 
                     self.file_names[h['corpus_id']], 
                     h['score']) for h in hits]
    
        def check_and_update(self):
            if not self.source_dir or self.embeddings is None:
                return False, 0
    
            current_files = {}
            for p in self.source_dir.rglob("*.*"):
                if any(ex in p.parts for ex in self.exclude_dirs):
                    continue
                if p.suffix.lower() not in {'.md', '.txt', '.py', '.html', '.rst'}:
                    continue
                _, mtime = self._get_file_info(p)
                if mtime:
                    current_files[str(p)] = (p, mtime)
    
            changed_count = 0
            to_keep = [i for i, path in enumerate(self.file_paths) if path in current_files]
            if len(to_keep) != len(self.file_paths):
                changed_count += len(self.file_paths) - len(to_keep)
                self.file_paths = [self.file_paths[i] for i in to_keep]
                self.file_names = [self.file_names[i] for i in to_keep]
                self.file_mtimes = [self.file_mtimes[i] for i in to_keep]
                self.embeddings = self.embeddings[to_keep]
    
            existing_set = set(self.file_paths)
            to_add_texts = []
            to_add_paths = []
            to_add_names = []
            to_add_mtimes = []
    
            for path_str, (p, mtime) in current_files.items():
                if path_str not in existing_set:
                    text, _ = self._get_file_info(p)
                    if text:
                        to_add_texts.append(text)
                        to_add_paths.append(path_str)
                        to_add_names.append(p.name)
                        to_add_mtimes.append(mtime)
                        changed_count += 1
                else:
                    idx = self.file_paths.index(path_str)
                    if abs(mtime - self.file_mtimes[idx]) > 2.0:
                        text, _ = self._get_file_info(p)
                        if text:
                            to_add_texts.append(text)
                            to_add_paths.append(path_str)
                            to_add_names.append(p.name)
                            to_add_mtimes.append(mtime)
                            self.file_paths.pop(idx)
                            self.file_names.pop(idx)
                            self.file_mtimes.pop(idx)
                            self.embeddings = torch.cat([self.embeddings[:idx], self.embeddings[idx+1:]])
                            changed_count += 1
    
            if to_add_texts:
                new_emb = self.model.encode(to_add_texts, convert_to_tensor=True, show_progress_bar=False)
                self.embeddings = torch.cat([self.embeddings, new_emb]) if len(self.embeddings) > 0 else new_emb
                self.file_paths.extend(to_add_paths)
                self.file_names.extend(to_add_names)
                self.file_mtimes.extend(to_add_mtimes)
    
            if changed_count > 0:
                self.last_update_time = datetime.now()
    
            return changed_count > 0, changed_count
    
        def save(self, save_dir: Path):
            save_dir.mkdir(parents=True, exist_ok=True)
            torch.save({
                'embeddings': self.embeddings,
                'file_paths': self.file_paths,
                'file_names': self.file_names,
                'file_mtimes': self.file_mtimes,
                'source_dir': str(self.source_dir) if self.source_dir else None,
                'build_time': self.build_time,
                'last_update_time': self.last_update_time,
            }, save_dir / "index.pt")
    
        def load(self, save_dir: Path):
            data = torch.load(save_dir / "index.pt", weights_only=True, map_location='cpu')
            self.embeddings = data['embeddings']
            self.file_paths = data['file_paths']
            self.file_names = data['file_names']
            self.file_mtimes = data.get('file_mtimes', [])
            src = data.get('source_dir')
            self.source_dir = Path(src) if src else None
            self.build_time = data.get('build_time')
            self.last_update_time = data.get('last_update_time')
    
    
    # ====================== MAIN APP ======================
    class SemanticSearchApp(wx.Frame):
        INDEX_DIR = Path.home() / "semantic_search_index"
        DARK_BG = wx.Colour(30, 30, 30)
        DARK_FG = wx.Colour(230, 230, 230)
        LIGHT_BG = wx.Colour(255, 255, 255)
        LIGHT_FG = wx.Colour(0, 0, 0)
    
        def __init__(self):
            super().__init__(None, title="Markdown Commander", size=(1280, 820))
            self.indexer = None
            self.current_results = []
            self._update_lock = threading.Lock()
            self.is_dark_mode = False
            
            self._build_ui()
            self._try_auto_load_index()
            self.Show()
    
        def _build_ui(self):
            splitter = wx.SplitterWindow(self, style=wx.SP_LIVE_UPDATE | wx.SP_3D)
            left = wx.Panel(splitter)
            sizer = wx.BoxSizer(wx.VERTICAL)
    
            # Query area
            query_box = wx.BoxSizer(wx.HORIZONTAL)
            wx.StaticText(left, label="Query:", size=(50, -1))
            self.query_ctrl = wx.TextCtrl(left, style=wx.TE_PROCESS_ENTER, size=(-1, 40))
            self.query_ctrl.Bind(wx.EVT_TEXT_ENTER, self.on_search)
            query_box.Add(self.query_ctrl, 1, wx.EXPAND | wx.RIGHT, 8)
    
            self.search_btn = wx.Button(left, label="Search", size=(100, 40))
            self.search_btn.Bind(wx.EVT_BUTTON, self.on_search)
            query_box.Add(self.search_btn, 0, wx.ALIGN_CENTER_VERTICAL)
    
            sizer.Add(query_box, 0, wx.EXPAND | wx.ALL, 10)
    
            wx.StaticText(left, label="Results (double-click to open):")
            self.results_list = wx.ListCtrl(left, style=wx.LC_REPORT | wx.LC_SINGLE_SEL | wx.LC_HRULES)
            self.results_list.InsertColumn(0, "Score", width=90)
            self.results_list.InsertColumn(1, "Document", width=580)
            self.results_list.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.on_result_click)
    
            sizer.Add(self.results_list, 1, wx.EXPAND | wx.ALL, 10)
            left.SetSizer(sizer)
    
            # ==================== RIGHT PANEL - HTML PREVIEW ====================
            right_panel = wx.Panel(splitter)
            right_sizer = wx.BoxSizer(wx.VERTICAL)
            
            toolbar = wx.BoxSizer(wx.HORIZONTAL)
            self.clear_btn = wx.Button(right_panel, label="Clear Preview")
            self.clear_btn.Bind(wx.EVT_BUTTON, self.on_clear_preview)
            toolbar.Add(self.clear_btn, 0, wx.ALL, 5)
            right_sizer.Add(toolbar, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, 5)
    
            # self.preview = wx.html.HtmlWindow(right_panel, style=wx.SUNKEN_BORDER)
            self.preview = wx.html2.WebView.New(right_panel)
            # self.preview.SetStandardFonts(10)
            right_sizer.Add(self.preview, 1, wx.EXPAND | wx.ALL, 5)
            
            right_panel.SetSizer(right_sizer)
    
            splitter.SplitVertically(left, right_panel, 680)
            splitter.SetMinimumPaneSize(400)
    
            # Menu
            menu_bar = wx.MenuBar()
            file_menu = wx.Menu()
            file_menu.Append(101, "&Build/Rebuild Full Index...\tCtrl+B")
            file_menu.Append(102, "&Force Full Rebuild\tCtrl+R")
            file_menu.Append(103, "&Save Current Index\tCtrl+S")
            file_menu.AppendSeparator()
            file_menu.Append(105, "Toggle Dark/Light Mode\tCtrl+T")
            file_menu.AppendSeparator()
            file_menu.Append(104, "E&xit")
            menu_bar.Append(file_menu, "&File")
            self.SetMenuBar(menu_bar)
    
            self.Bind(wx.EVT_MENU, self.on_build_index, id=101)
            self.Bind(wx.EVT_MENU, self.on_force_rebuild, id=102)
            self.Bind(wx.EVT_MENU, self.on_save_index, id=103)
            self.Bind(wx.EVT_MENU, self.on_toggle_theme, id=105)
            self.Bind(wx.EVT_MENU, lambda e: self.Close(), id=104)
    
            self.SetStatusBar(wx.StatusBar(self))
            self.SetStatusText("Ready — Build an index to begin")
            self.apply_theme()
    
        def on_clear_preview(self, event):
            self.preview.SetPage("","")
            self.SetStatusText("Preview cleared")
    
        def apply_theme(self):
            bg = self.DARK_BG if self.is_dark_mode else self.LIGHT_BG
            fg = self.DARK_FG if self.is_dark_mode else self.LIGHT_FG
    
            self.SetBackgroundColour(bg)
            self.query_ctrl.SetBackgroundColour(bg)
            self.query_ctrl.SetForegroundColour(fg)
            self.results_list.SetBackgroundColour(bg)
            self.results_list.SetForegroundColour(fg)
            self.Refresh()
            self.Update()
    
        def on_toggle_theme(self, event):
            self.is_dark_mode = not self.is_dark_mode
            self.apply_theme()
            mode = "Dark" if self.is_dark_mode else "Light"
            self.SetStatusText(f"Switched to {mode} mode")
    
        # ==================== Remaining methods ====================
        def _try_auto_load_index(self):
            if not (self.INDEX_DIR / "index.pt").exists():
                return
            if wx.MessageBox("Saved index found. Load it now?", "Load Index", wx.YES_NO | wx.ICON_QUESTION) == wx.YES:
                try:
                    self.indexer = SemanticIndexer()
                    self.indexer.load(self.INDEX_DIR)
                    self._index_ready()
                except Exception as e:
                    wx.MessageBox(f"Load failed:\n{str(e)}", "Load Error", wx.OK | wx.ICON_ERROR)
    
        def on_build_index(self, event):
            dlg = wx.DirDialog(self, "Select folder with your documents")
            if dlg.ShowModal() == wx.ID_OK:
                path = dlg.GetPath()
                self.SetStatusText("Building full index...")
                threading.Thread(target=self._build_index_thread, args=(path,), daemon=True).start()
            dlg.Destroy()
    
        def _build_index_thread(self, folder):
            if self.indexer is None:
                self.indexer = SemanticIndexer()
            try:
                self.indexer.build_index(folder)
                wx.CallAfter(self._index_ready)
            except Exception as e:
                wx.CallAfter(lambda: wx.MessageBox(str(e), "Error"))
    
        def on_force_rebuild(self, event):
            if not self.indexer or not self.indexer.source_dir:
                wx.MessageBox("Please build an index first.", "Info")
                return
            if wx.MessageBox("Clear current index and rebuild everything?", "Force Rebuild", wx.YES_NO | wx.ICON_WARNING) == wx.YES:
                threading.Thread(target=self._build_index_thread, args=(str(self.indexer.source_dir),), daemon=True).start()
    
        def _index_ready(self):
            count = len(self.indexer.file_paths)
            ts = self.indexer.last_update_time.strftime("%Y-%m-%d %H:%M") if self.indexer.last_update_time else ""
            self.SetStatusText(f"Ready — {count} documents • Last updated: {ts}")
    
        def _check_for_updates(self):
            if not self.indexer:
                return
            with self._update_lock:
                updated, changed = self.indexer.check_and_update()
                if updated:
                    wx.CallAfter(self._index_ready)
                    wx.CallAfter(lambda: self.SetStatusText(f"Auto-updated: {changed} new/changed file{'s' if changed != 1 else ''}"))
    
        def on_search(self, event):
            if not self.indexer or self.indexer.embeddings is None:
                wx.MessageBox("Please build an index first.", "Info")
                return
    
            threading.Thread(target=self._check_for_updates, daemon=True).start()
    
            query = self.query_ctrl.GetValue().strip()
            if not query:
                return
    
            self.SetStatusText("Searching...")
            self.results_list.DeleteAllItems()
    
            results = self.indexer.search(query, top_k=12)
            self.current_results = results
    
            for i, (_, name, score) in enumerate(results):
                self.results_list.InsertItem(i, f"{score:.4f}")
                self.results_list.SetItem(i, 1, name)
    
            self.SetStatusText(f"Found {len(results)} results")
    
        def on_save_index(self, event):
            if not self.indexer or self.indexer.embeddings is None:
                wx.MessageBox("Nothing to save.", "Info")
                return
            try:
                self.indexer.save(self.INDEX_DIR)
                wx.MessageBox(f"Index saved to:\n{self.INDEX_DIR}", "Success")
            except Exception as e:
                wx.MessageBox(str(e), "Save Failed")
    
        def on_result_click(self, event):
            idx = event.GetIndex()
            full_path, name, score = self.current_results[idx]
            fpath = Path(full_path)
            
            try:
                content = fpath.read_text(encoding="utf-8", errors="ignore")
                html_content = mistune.html(content)            
    
                full_html = f"""
                <html>
                <head>
                    <style>
                        body {{ font-family: Arial, Helvetica, sans-serif; padding: 20px; line-height: 1.6; }}
                        pre {{ background: #f4f4f4; padding: 12px; border-radius: 4px; overflow: auto; }}
                        code {{ font-family: monospace; }}
                        h1, h2, h3 {{ color: #2c3e50; }}
                        img {{ max-width: 100%; height: auto; display: block; margin: 15px 0; }}
                    </style>
                </head>
                <body>
                    {html_content}
                </body>
                </html>
                """
    
                # Fix: Use base URL so local images load
                base_url = f"file://{fpath.parent.resolve()}/"
                
                self.preview.SetPage(full_html, base_url)
                self.SetStatusText(f"Opened: {name}  (Score: {score:.4f})")
                
            except Exception as e:
                print(f"Preview error: {e}")  # for your console
                self.SetStatusText(f"Could not open file: {e}")
                self.preview.SetPage(f"<html><body><p>Error: {e}</p></body></html>", "")
            
    if __name__ == "__main__":
        app = wx.App(False)
        frame = SemanticSearchApp()
        app.MainLoop()

14. go back to main directory: cd ..
    
15. create a data directory: mkdir data
    
16. create a markdown sub directory in data: mkdir ./data/markdown
    
17. And an image directory below the markdown directory: mkdir ./data/markdown/images