vector-inspector 0.3.8__py3-none-any.whl → 0.3.11__py3-none-any.whl

vector_inspector/__init__.py

@@ -1,3 +1,12 @@
 """Vector Inspector - A comprehensive desktop application for vector database visualization."""
 
-__version__ = "0.1.0"
+__version__ = "0.3.11"  # Keep in sync with pyproject.toml for dev mode fallback
+
+
+def get_version():
+    try:
+        from importlib.metadata import version, PackageNotFoundError
+
+        return version("vector-inspector")
+    except Exception:
+        return __version__

vector_inspector/core/connections/pgvector_connection.py

@@ -5,6 +5,8 @@ import json
 import psycopg2
 from psycopg2 import sql
 
+from vector_inspector.core.logging import log_info
+
 ## No need to import register_vector; pgvector extension is enabled at table creation
 from vector_inspector.core.connections.base_connection import VectorDBConnection
 from vector_inspector.core.logging import log_error, log_info
@@ -1043,12 +1045,35 @@ class PgVectorConnection(VectorDBConnection):
         Returns:
             List of floats
         """
+        # log_info("[pgvector] _parse_vector raw value: %r (type: %s)", vector_str, type(vector_str))
         if isinstance(vector_str, list):
+            log_info("[pgvector] _parse_vector: already list, len=%d", len(vector_str))
             return vector_str
+        # Handle numpy arrays
+        try:
+            import numpy as np
+
+            if isinstance(vector_str, np.ndarray):
+                log_info("[pgvector] _parse_vector: numpy array, shape=%s", vector_str.shape)
+                return vector_str.tolist()
+        except ImportError:
+            pass
         if isinstance(vector_str, str):
             # Remove brackets and split by comma
             vector_str = vector_str.strip("[]")
-            return [float(x) for x in vector_str.split(",")]
+            if not vector_str:
+                log_info("[pgvector] _parse_vector: empty string after strip")
+                return []
+            try:
+                parsed = [float(x) for x in vector_str.split(",")]
+                log_info("[pgvector] _parse_vector: parsed list of len %d", len(parsed))
+                return parsed
+            except Exception as e:
+                log_info(
+                    "[pgvector] _parse_vector: failed to parse '%s' with error: %s", vector_str, e
+                )
+                return []
+        log_info("[pgvector] _parse_vector: unhandled type %s, returning []", type(vector_str))
         return []
 
     def compute_embeddings_for_documents(

vector_inspector/extensions/__init__.py

@@ -0,0 +1,111 @@
+"""Extension points for Vector Inspector.
+
+This module provides hooks and callbacks that allow pro versions
+or plugins to extend core functionality without modifying the base code.
+"""
+
+from typing import Any, ClassVar
+from collections.abc import Callable
+from PySide6.QtWidgets import QMenu, QTableWidget
+
+
+class TableContextMenuHook:
+    """Hook for adding custom context menu items to table widgets."""
+
+    _handlers: ClassVar[list[Callable]] = []
+
+    @classmethod
+    def register(cls, handler: Callable):
+        """Register a context menu handler.
+
+        Args:
+            handler: Callable that takes (menu: QMenu, table: QTableWidget, row: int, data: Dict)
+                    and adds menu items to the menu.
+        """
+        if handler not in cls._handlers:
+            cls._handlers.append(handler)
+
+    @classmethod
+    def unregister(cls, handler: Callable):
+        """Unregister a context menu handler."""
+        if handler in cls._handlers:
+            cls._handlers.remove(handler)
+
+    @classmethod
+    def trigger(
+        cls,
+        menu: QMenu,
+        table: QTableWidget,
+        row: int,
+        data: dict[str, Any] | None = None,
+    ):
+        """Trigger all registered handlers.
+
+        Args:
+            menu: The QMenu to add items to
+            table: The QTableWidget that was right-clicked
+            row: The row number that was clicked
+            data: Optional data dictionary with context (ids, documents, metadatas, etc.)
+        """
+        for handler in cls._handlers:
+            try:
+                handler(menu, table, row, data)
+            except Exception as e:
+                # Log but don't break if a handler fails
+                from vector_inspector.core.logging import log_error
+
+                log_error("Context menu handler error: %s", e)
+
+    @classmethod
+    def clear(cls):
+        """Clear all registered handlers."""
+        cls._handlers.clear()
+
+
+# Global singleton instance
+table_context_menu_hook = TableContextMenuHook()
+
+
+class SettingsPanelHook:
+    """Hook for adding custom sections to the Settings/Preferences dialog."""
+
+    _handlers: ClassVar[list[Callable]] = []
+
+    @classmethod
+    def register(cls, handler: Callable):
+        """Register a settings panel provider.
+
+        Handler signature: (parent_layout, settings_service, dialog)
+        where `parent_layout` is a QLayout the handler can add widgets to.
+        """
+        if handler not in cls._handlers:
+            cls._handlers.append(handler)
+
+    @classmethod
+    def unregister(cls, handler: Callable):
+        if handler in cls._handlers:
+            cls._handlers.remove(handler)
+
+    @classmethod
+    def trigger(cls, parent_layout, settings_service, dialog=None):
+        for handler in cls._handlers:
+            try:
+                handler(parent_layout, settings_service, dialog)
+            except Exception as e:
+                from vector_inspector.core.logging import log_error
+
+                log_error("Settings panel handler error: %s", e)
+
+    @classmethod
+    def clear(cls):
+        cls._handlers.clear()
+
+
+# Global singleton instance
+settings_panel_hook = SettingsPanelHook()
+
+# Register built-in settings panel extensions
+try:
+    import vector_inspector.extensions.telemetry_settings_panel
+except Exception:
+    pass

vector_inspector/extensions/telemetry_settings_panel.py

@@ -0,0 +1,25 @@
+from PySide6.QtWidgets import QCheckBox, QHBoxLayout
+from vector_inspector.extensions import settings_panel_hook
+
+
+def add_telemetry_section(parent_layout, settings_service, dialog=None):
+    telemetry_checkbox = QCheckBox("Enable anonymous telemetry (app launch events)")
+    # Default to checked if not set
+    checked = settings_service.get("telemetry.enabled")
+    if checked is None:
+        checked = True
+    telemetry_checkbox.setChecked(checked)
+    telemetry_checkbox.setToolTip(
+        "Allow the app to send anonymous launch events to help improve reliability. No personal or document data is sent."
+    )
+
+    def on_state_changed(state):
+        settings_service.set_telemetry_enabled(bool(state))
+
+    telemetry_checkbox.stateChanged.connect(on_state_changed)
+    layout = QHBoxLayout()
+    layout.addWidget(telemetry_checkbox)
+    parent_layout.addLayout(layout)
+
+
+settings_panel_hook.register(add_telemetry_section)

vector_inspector/main.py

@@ -4,6 +4,7 @@ import sys
 import os
 from PySide6.QtWidgets import QApplication
 from vector_inspector.ui.main_window import MainWindow
+from vector_inspector.core.logging import log_error
 
 # Ensures the app looks in its own folder for the raw libraries
 sys.path.append(os.path.dirname(sys.executable))
@@ -15,6 +16,21 @@ def main():
     app.setApplicationName("Vector Inspector")
     app.setOrganizationName("Vector Inspector")
 
+    # Telemetry: send launch ping if enabled
+    try:
+        from vector_inspector.services.telemetry_service import TelemetryService
+        from vector_inspector import get_version, __version__
+
+        app_version = None
+        try:
+            app_version = get_version()
+        except Exception:
+            app_version = __version__
+        telemetry = TelemetryService()
+        telemetry.send_launch_ping(app_version=app_version)
+    except Exception as e:
+        log_error(f"[Telemetry] Failed to send launch ping: {e}")
+
     window = MainWindow()
     window.show()
 

vector_inspector/services/settings_service.py

@@ -1,6 +1,8 @@
 """Service for persisting application settings."""
 
 import json
+import base64
+from PySide6.QtCore import QObject, Signal
 from pathlib import Path
 from typing import Dict, Any, Optional, List
 from vector_inspector.core.cache_manager import invalidate_cache_on_settings_change
@@ -12,6 +14,18 @@ class SettingsService:
 
     def __init__(self):
         """Initialize settings service."""
+
+        # Expose a shared QObject-based signal emitter so UI can react to
+        # settings changes without polling.
+        class _Signals(QObject):
+            setting_changed = Signal(str, object)
+
+        # singleton-like per-process signals instance
+        try:
+            self.signals
+        except Exception:
+            self.signals = _Signals()
+
         self.settings_dir = Path.home() / ".vector-inspector"
         self.settings_file = self.settings_dir / "settings.json"
         self.settings: Dict[str, Any] = {}
@@ -51,6 +65,62 @@ class SettingsService:
         """Get a setting value."""
         return self.settings.get(key, default)
 
+    # Convenience accessors for common settings
+    def get_breadcrumb_enabled(self) -> bool:
+        return bool(self.settings.get("breadcrumb.enabled", True))
+
+    def set_breadcrumb_enabled(self, enabled: bool):
+        self.set("breadcrumb.enabled", bool(enabled))
+
+    def get_breadcrumb_elide_mode(self) -> str:
+        return str(self.settings.get("breadcrumb.elide_mode", "left"))
+
+    def set_breadcrumb_elide_mode(self, mode: str):
+        if mode not in ("left", "middle"):
+            mode = "left"
+        self.set("breadcrumb.elide_mode", mode)
+
+    def get_default_n_results(self) -> int:
+        return int(self.settings.get("search.default_n_results", 10))
+
+    def set_default_n_results(self, n: int):
+        self.set("search.default_n_results", int(n))
+
+    def get_auto_generate_embeddings(self) -> bool:
+        return bool(self.settings.get("embeddings.auto_generate", True))
+
+    def set_auto_generate_embeddings(self, enabled: bool):
+        self.set("embeddings.auto_generate", bool(enabled))
+
+    def get_window_restore_geometry(self) -> bool:
+        return bool(self.settings.get("window.restore_geometry", True))
+
+    def set_window_restore_geometry(self, enabled: bool):
+        self.set("window.restore_geometry", bool(enabled))
+
+    def set_window_geometry(self, geometry_bytes: bytes):
+        """Save window geometry as base64 string."""
+        try:
+            if isinstance(geometry_bytes, str):
+                # assume base64 already
+                b64 = geometry_bytes
+            else:
+                b64 = base64.b64encode(bytes(geometry_bytes)).decode("ascii")
+            self.set("window.geometry", b64)
+        except Exception as e:
+            log_error("Failed to set window geometry: %s", e)
+
+    def get_window_geometry(self) -> Optional[bytes]:
+        """Return geometry bytes or None."""
+        try:
+            b64 = self.settings.get("window.geometry")
+            if not b64:
+                return None
+            return base64.b64decode(b64)
+        except Exception as e:
+            log_error("Failed to get window geometry: %s", e)
+            return None
+
     def get_cache_enabled(self) -> bool:
         """Get whether caching is enabled (default: True)."""
         return self.settings.get("cache_enabled", True)
@@ -67,6 +137,14 @@ class SettingsService:
         else:
             cache.disable()
 
+    def get_telemetry_enabled(self) -> bool:
+        """Get whether telemetry is enabled (default: True)."""
+        return bool(self.settings.get("telemetry.enabled", True))
+
+    def set_telemetry_enabled(self, enabled: bool):
+        """Set whether telemetry is enabled."""
+        self.set("telemetry.enabled", bool(enabled))
+
     def set(self, key: str, value: Any):
         """Set a setting value."""
         self.settings[key] = value
@@ -74,6 +152,12 @@ class SettingsService:
         # Invalidate cache when settings change (only if cache is enabled)
         if key != "cache_enabled":  # Don't invalidate when toggling cache itself
             invalidate_cache_on_settings_change()
+        # Emit change signal for UI/reactive components
+        try:
+            # Emit the raw python object (value) for convenience
+            self.signals.setting_changed.emit(key, value)
+        except Exception:
+            pass
 
     def clear(self):
         """Clear all settings."""

vector_inspector/services/telemetry_service.py

@@ -0,0 +1,88 @@
+import json
+import platform
+import uuid
+import requests
+from pathlib import Path
+from vector_inspector.services.settings_service import SettingsService
+from vector_inspector.core.logging import log_info, log_error
+
+TELEMETRY_ENDPOINT = "https://api.divinedevops.com/api/v1/telemetry"
+
+
+class TelemetryService:
+    def __init__(self, settings_service=None):
+        self.settings = settings_service or SettingsService()
+        self.queue_file = Path.home() / ".vector-inspector" / "telemetry_queue.json"
+        self._load_queue()
+
+    def _load_queue(self):
+        if self.queue_file.exists():
+            try:
+                with open(self.queue_file, encoding="utf-8") as f:
+                    self.queue = json.load(f)
+            except Exception:
+                self.queue = []
+        else:
+            self.queue = []
+
+    def _save_queue(self):
+        self.queue_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.queue_file, "w", encoding="utf-8") as f:
+            json.dump(self.queue, f, indent=2)
+
+    def is_enabled(self):
+        return bool(self.settings.get("telemetry.enabled", True))
+
+    def get_hwid(self):
+        # Use a persistent UUID for this client
+        hwid = self.settings.get("telemetry.hwid")
+        if not hwid:
+            hwid = str(uuid.uuid4())
+            self.settings.set("telemetry.hwid", hwid)
+        return hwid
+
+    def queue_event(self, event):
+        self.queue.append(event)
+        self._save_queue()
+
+    def send_batch(self):
+        if not self.is_enabled() or not self.queue:
+            return
+        sent = []
+        for event in self.queue:
+            try:
+                log_info(
+                    f"[Telemetry] Sending to {TELEMETRY_ENDPOINT}\nPayload: {json.dumps(event, indent=2)}"
+                )
+                resp = requests.post(TELEMETRY_ENDPOINT, json=event, timeout=5)
+                log_info(f"[Telemetry] Response: {resp.status_code} {resp.text}")
+                if resp.status_code in (200, 201):
+                    sent.append(event)
+            except Exception as e:
+                log_error(f"[Telemetry] Exception: {e}")
+        # Remove sent events
+        self.queue = [e for e in self.queue if e not in sent]
+        self._save_queue()
+
+    def send_launch_ping(self, app_version, client_type="vector-inspector"):
+        log_info("[Telemetry] send_launch_ping called")
+        if not self.is_enabled():
+            log_info("[Telemetry] Telemetry is not enabled; skipping launch ping.")
+            return
+        event = {
+            "hwid": self.get_hwid(),
+            "event_name": "app_launch",
+            "app_version": app_version,
+            "client_type": client_type,
+            "metadata": {"os": platform.system() + "-" + platform.release()},
+        }
+        log_info(f"[Telemetry] Launch event payload: {json.dumps(event, indent=2)}")
+        self.queue_event(event)
+        self.send_batch()
+
+    def purge(self):
+        self.queue = []
+        self._save_queue()
+
+    def get_queue(self):
+        return list(self.queue)

vector_inspector/ui/dialogs/settings_dialog.py

@@ -0,0 +1,124 @@
+from PySide6.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QHBoxLayout,
+    QLabel,
+    QCheckBox,
+    QComboBox,
+    QSpinBox,
+    QPushButton,
+)
+from PySide6.QtCore import Qt
+
+from vector_inspector.services.settings_service import SettingsService
+from vector_inspector.extensions import settings_panel_hook
+
+
+class SettingsDialog(QDialog):
+    """Modal settings dialog backed by SettingsService."""
+
+    def __init__(self, settings_service: SettingsService = None, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Preferences")
+        self.settings = settings_service or SettingsService()
+        self._init_ui()
+        self._load_values()
+
+    def _init_ui(self):
+        layout = QVBoxLayout(self)
+
+        # Breadcrumb controls are provided by pro extensions (vector-studio)
+        # via the settings_panel_hook. Core does not add breadcrumb options.
+
+        # Search defaults
+        search_layout = QHBoxLayout()
+        search_layout.addWidget(QLabel("Default results:"))
+        self.default_results = QSpinBox()
+        self.default_results.setMinimum(1)
+        self.default_results.setMaximum(1000)
+        search_layout.addWidget(self.default_results)
+        layout.addLayout(search_layout)
+
+        # Embeddings
+        self.auto_embed_checkbox = QCheckBox("Auto-generate embeddings for new text")
+        layout.addWidget(self.auto_embed_checkbox)
+
+        # Window geometry
+        self.restore_geometry_checkbox = QCheckBox("Restore window size/position on startup")
+        layout.addWidget(self.restore_geometry_checkbox)
+
+        # Buttons
+        btn_layout = QHBoxLayout()
+        self.apply_btn = QPushButton("Apply")
+        self.ok_btn = QPushButton("OK")
+        self.cancel_btn = QPushButton("Cancel")
+        self.reset_btn = QPushButton("Reset to defaults")
+        btn_layout.addWidget(self.reset_btn)
+        btn_layout.addStretch()
+        btn_layout.addWidget(self.apply_btn)
+        btn_layout.addWidget(self.ok_btn)
+        btn_layout.addWidget(self.cancel_btn)
+        # Allow external extensions to add sections before the buttons
+        try:
+            # Handlers receive (parent_layout, settings_service, dialog)
+            settings_panel_hook.trigger(layout, self.settings, self)
+        except Exception:
+            pass
+
+        layout.addLayout(btn_layout)
+
+        # Signals
+        self.apply_btn.clicked.connect(self._apply)
+        self.ok_btn.clicked.connect(self._ok)
+        self.cancel_btn.clicked.connect(self.reject)
+        self.reset_btn.clicked.connect(self._reset_defaults)
+
+        # Immediate apply on change for some controls
+        self.default_results.valueChanged.connect(lambda v: self.settings.set_default_n_results(v))
+        self.auto_embed_checkbox.stateChanged.connect(
+            lambda s: self.settings.set_auto_generate_embeddings(bool(s))
+        )
+        self.restore_geometry_checkbox.stateChanged.connect(
+            lambda s: self.settings.set_window_restore_geometry(bool(s))
+        )
+
+        # Container for programmatic sections
+        self._extra_sections = []
+
+    def add_section(self, widget_or_layout):
+        """Programmatically add a section (widget or layout) to the dialog.
+
+        `widget_or_layout` can be a QWidget or QLayout. It will be added
+        immediately to the dialog's main layout.
+        """
+        try:
+            if hasattr(widget_or_layout, "setParent"):
+                # QWidget
+                self.layout().addWidget(widget_or_layout)
+            else:
+                # Assume QLayout
+                self.layout().addLayout(widget_or_layout)
+            self._extra_sections.append(widget_or_layout)
+        except Exception:
+            pass
+
+    def _load_values(self):
+        # Breadcrumb controls are not present in core dialog.
+        self.default_results.setValue(self.settings.get_default_n_results())
+        self.auto_embed_checkbox.setChecked(self.settings.get_auto_generate_embeddings())
+        self.restore_geometry_checkbox.setChecked(self.settings.get_window_restore_geometry())
+
+    def _apply(self):
+        # Values are already applied on change; ensure persistence and close
+        self.settings._save_settings()
+
+    def _ok(self):
+        self._apply()
+        self.accept()
+
+    def _reset_defaults(self):
+        # Reset to recommended defaults
+        self.default_results.setValue(10)
+        self.auto_embed_checkbox.setChecked(True)
+        self.restore_geometry_checkbox.setChecked(True)
+        self._apply()

vector_inspector/ui/main_window.py

@@ -8,7 +8,7 @@ from PySide6.QtWidgets import (
     QToolBar,
     QStatusBar,
 )
-from PySide6.QtCore import Qt, QTimer
+from PySide6.QtCore import Qt, QTimer, QByteArray
 from PySide6.QtGui import QAction
 
 from vector_inspector.core.connection_manager import ConnectionManager
@@ -58,6 +58,29 @@ class MainWindow(InspectorShell):
         self._setup_statusbar()
         self._connect_signals()
         self._restore_session()
+        # Listen for settings changes so updates apply immediately
+        try:
+            self.settings_service.signals.setting_changed.connect(self._on_setting_changed)
+        except Exception:
+            pass
+        # Restore window geometry if present
+        try:
+            geom = self.settings_service.get_window_geometry()
+            if geom and self.settings_service.get_window_restore_geometry():
+                try:
+                    # restoreGeometry accepts QByteArray; wrap bytes accordingly
+                    if isinstance(geom, (bytes, bytearray)):
+                        self.restoreGeometry(QByteArray(geom))
+                    else:
+                        self.restoreGeometry(geom)
+                except Exception:
+                    # fallback: try passing raw bytes
+                    try:
+                        self.restoreGeometry(geom)
+                    except Exception:
+                        pass
+        except Exception:
+            pass
         # Show splash after main window is visible
         QTimer.singleShot(0, self._maybe_show_splash)
 
@@ -121,6 +144,13 @@ class MainWindow(InspectorShell):
 
         file_menu.addSeparator()
 
+        prefs_action = QAction("Preferences...", self)
+        prefs_action.setShortcut("Ctrl+,")
+        prefs_action.triggered.connect(self._show_preferences_dialog)
+        file_menu.addAction(prefs_action)
+
+        file_menu.addSeparator()
+
         exit_action = QAction("E&xit", self)
         exit_action.setShortcut("Ctrl+Q")
         exit_action.triggered.connect(self.close)
@@ -249,6 +279,62 @@ class MainWindow(InspectorShell):
 
         threading.Thread(target=check_updates, daemon=True).start()
 
+    def _show_preferences_dialog(self):
+        try:
+            from vector_inspector.ui.dialogs.settings_dialog import SettingsDialog
+
+            dlg = SettingsDialog(self.settings_service, self)
+            if dlg.exec() == QDialog.Accepted:
+                self._apply_settings_to_views()
+        except Exception as e:
+            print(f"Failed to open preferences: {e}")
+
+    def _apply_settings_to_views(self):
+        """Apply relevant settings to existing views."""
+        try:
+            # Breadcrumb visibility
+            enabled = self.settings_service.get_breadcrumb_enabled()
+            if self.search_view is not None and hasattr(self.search_view, "breadcrumb_label"):
+                self.search_view.breadcrumb_label.setVisible(enabled)
+                # also set elide mode
+                mode = self.settings_service.get_breadcrumb_elide_mode()
+                try:
+                    self.search_view.set_elide_mode(mode)
+                except Exception:
+                    pass
+
+            # Default results
+            default_n = self.settings_service.get_default_n_results()
+            if self.search_view is not None and hasattr(self.search_view, "n_results_spin"):
+                try:
+                    self.search_view.n_results_spin.setValue(int(default_n))
+                except Exception:
+                    pass
+
+        except Exception:
+            pass
+
+    def _on_setting_changed(self, key: str, value: object):
+        """Handle granular setting change events."""
+        try:
+            if key == "breadcrumb.enabled":
+                enabled = bool(value)
+                if self.search_view is not None and hasattr(self.search_view, "breadcrumb_label"):
+                    self.search_view.breadcrumb_label.setVisible(enabled)
+            elif key == "breadcrumb.elide_mode":
+                mode = str(value)
+                if self.search_view is not None and hasattr(self.search_view, "set_elide_mode"):
+                    self.search_view.set_elide_mode(mode)
+            elif key == "search.default_n_results":
+                try:
+                    n = int(value)
+                    if self.search_view is not None and hasattr(self.search_view, "n_results_spin"):
+                        self.search_view.n_results_spin.setValue(n)
+                except Exception:
+                    pass
+        except Exception:
+            pass
+
     def _on_update_indicator_clicked(self, event):
         # Show update details dialog
         if not hasattr(self, "_latest_release"):
@@ -467,6 +553,9 @@ class MainWindow(InspectorShell):
                 10000,
             )
 
+        # Apply settings to views after UI is built
+        self._apply_settings_to_views()
+
     def _show_about(self):
         """Show about dialog."""
         DialogService.show_about(self)
@@ -494,6 +583,35 @@ class MainWindow(InspectorShell):
             # Refresh collections after restore
             self._refresh_active_connection()
 
+    def show_search_results(self, collection_name: str, results: dict, context_info: str = ""):
+        """Display search results in the Search tab.
+
+        This is an extension point that allows external code (e.g., pro features)
+        to programmatically display search results.
+
+        Args:
+            collection_name: Name of the collection
+            results: Search results dictionary
+            context_info: Optional context string (e.g., "Similar to: item_123")
+        """
+        # Switch to search tab
+        self.set_main_tab_active(InspectorTabs.SEARCH_TAB)
+
+        # Set the collection if needed
+        if self.search_view.current_collection != collection_name:
+            active = self.connection_manager.get_active_connection()
+            database_name = active.id if active else ""
+            self.search_view.set_collection(collection_name, database_name)
+
+        # Display the results
+        self.search_view.search_results = results
+        self.search_view._display_results(results)
+
+        # Update status with context if provided
+        if context_info:
+            num_results = len(results.get("ids", [[]])[0])
+            self.search_view.results_status.setText(f"{context_info} - Found {num_results} results")
+
     def closeEvent(self, event):
         """Handle application close."""
         # Clean up connection controller
@@ -508,4 +626,23 @@ class MainWindow(InspectorShell):
         # Close all connections
         self.connection_manager.close_all_connections()
 
+        # Save window geometry if enabled
+        try:
+            if self.settings_service.get_window_restore_geometry():
+                geom = self.saveGeometry()
+                # geom may be a QByteArray; convert to raw bytes
+                try:
+                    if isinstance(geom, QByteArray):
+                        b = bytes(geom)
+                    else:
+                        b = bytes(geom)
+                    self.settings_service.set_window_geometry(b)
+                except Exception:
+                    try:
+                        self.settings_service.set_window_geometry(bytes(geom))
+                    except Exception:
+                        pass
+        except Exception:
+            pass
+
         event.accept()

vector_inspector/ui/views/metadata_view.py

@@ -196,6 +196,9 @@ class MetadataView(QWidget):
         self.table.setAlternatingRowColors(True)
         self.table.horizontalHeader().setStretchLastSection(True)
         self.table.doubleClicked.connect(self._on_row_double_clicked)
+        # Enable context menu
+        self.table.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.table.customContextMenuRequested.connect(self._show_context_menu)
         layout.addWidget(self.table)
 
         # Status bar
@@ -962,6 +965,48 @@ class MetadataView(QWidget):
         else:
             QMessageBox.warning(self, "Export Failed", "Failed to export data.")
 
+    def _show_context_menu(self, position):
+        """Show context menu for table rows."""
+        # Get the item at the position
+        item = self.table.itemAt(position)
+        if not item:
+            return
+
+        row = item.row()
+        if row < 0 or row >= self.table.rowCount():
+            return
+
+        # Create context menu
+        menu = QMenu(self)
+
+        # Add standard "Edit" action
+        edit_action = menu.addAction("✏️ Edit")
+        edit_action.triggered.connect(
+            lambda: self._on_row_double_clicked(self.table.model().index(row, 0))
+        )
+
+        # Call extension hooks to add custom menu items
+        try:
+            from vector_inspector.extensions import table_context_menu_hook
+
+            table_context_menu_hook.trigger(
+                menu=menu,
+                table=self.table,
+                row=row,
+                data={
+                    "current_data": self.current_data,
+                    "collection_name": self.current_collection,
+                    "database_name": self.current_database,
+                    "connection": self.connection,
+                    "view_type": "metadata",
+                },
+            )
+        except Exception as e:
+            log_info("Extension hook error: %s", e)
+
+        # Show menu
+        menu.exec(self.table.viewport().mapToGlobal(position))
+
     def _import_data(self, format_type: str):
         """Import data from file into collection."""
         if not self.current_collection:

vector_inspector/ui/views/search_view.py

@@ -8,6 +8,7 @@ from PySide6.QtWidgets import (
     QTextEdit,
     QPushButton,
     QLabel,
+    QSizePolicy,
     QSpinBox,
     QTableWidget,
     QTableWidgetItem,
@@ -15,8 +16,10 @@ from PySide6.QtWidgets import (
     QSplitter,
     QCheckBox,
     QApplication,
+    QMenu,
 )
 from PySide6.QtCore import Qt
+from PySide6.QtGui import QFontMetrics
 
 from vector_inspector.core.connections.base_connection import VectorDBConnection
 from vector_inspector.ui.components.filter_builder import FilterBuilder
@@ -31,6 +34,19 @@ class SearchView(QWidget):
 
     def __init__(self, connection: VectorDBConnection, parent=None):
         super().__init__(parent)
+        # Initialize all UI attributes to None to avoid AttributeError
+        self.breadcrumb_label = None
+        self.query_input = None
+        self.results_table = None
+        self.results_status = None
+        self.refresh_button = None
+        self.n_results_spin = None
+        self.filter_builder = None
+        self.filter_group = None
+        self.search_button = None
+        self.loading_dialog = None
+        self.cache_manager = None
+
         self.connection = connection
         self.current_collection: str = ""
         self.current_database: str = ""
@@ -42,8 +58,32 @@ class SearchView(QWidget):
 
     def _setup_ui(self):
         """Setup widget UI."""
+        # Assign all UI attributes at the top to avoid NoneType errors
+        self.breadcrumb_label = QLabel("")
+        self.query_input = QTextEdit()
+        self.results_table = QTableWidget()
+        self.results_status = QLabel("No search performed")
+        self.refresh_button = QPushButton("Refresh")
+        self.n_results_spin = QSpinBox()
+        self.filter_builder = FilterBuilder()
+        self.filter_group = QGroupBox("Advanced Metadata Filters")
+        self.search_button = QPushButton("Search")
+
         layout = QVBoxLayout(self)
 
+        # Breadcrumb bar (for pro features)
+        self.breadcrumb_label.setStyleSheet(
+            "color: #2980b9; font-weight: bold; padding: 2px 0 4px 0;"
+        )
+        # Configure breadcrumb label sizing
+        self.breadcrumb_label.setWordWrap(False)
+        self.breadcrumb_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+        # Store full breadcrumb text for tooltip and eliding
+        self._full_breadcrumb = ""
+        # Elide mode: 'left' or 'middle'
+        self._elide_mode = "left"
+        layout.addWidget(self.breadcrumb_label)
+
         # Create splitter for query and results
         splitter = QSplitter(Qt.Vertical)
 
@@ -56,7 +96,6 @@ class SearchView(QWidget):
 
         # Query input
         query_group_layout.addWidget(QLabel("Enter search text:"))
-        self.query_input = QTextEdit()
         self.query_input.setMaximumHeight(100)
         self.query_input.setPlaceholderText("Enter text to search for similar vectors...")
         query_group_layout.addWidget(self.query_input)
@@ -65,7 +104,6 @@ class SearchView(QWidget):
         controls_layout = QHBoxLayout()
 
         controls_layout.addWidget(QLabel("Results:"))
-        self.n_results_spin = QSpinBox()
         self.n_results_spin.setMinimum(1)
         self.n_results_spin.setMaximum(100)
         self.n_results_spin.setValue(10)
@@ -73,9 +111,13 @@ class SearchView(QWidget):
 
         controls_layout.addStretch()
 
-        self.search_button = QPushButton("Search")
         self.search_button.clicked.connect(self._perform_search)
         self.search_button.setDefault(True)
+
+        self.refresh_button.setToolTip("Reset search input and results")
+        self.refresh_button.clicked.connect(self._refresh_search)
+        controls_layout.addWidget(self.refresh_button)
+
         controls_layout.addWidget(self.search_button)
 
         query_group_layout.addLayout(controls_layout)
@@ -83,18 +125,15 @@ class SearchView(QWidget):
         query_layout.addWidget(query_group)
 
         # Advanced filters section
-        filter_group = QGroupBox("Advanced Metadata Filters")
-        filter_group.setCheckable(True)
-        filter_group.setChecked(False)
+        self.filter_group.setCheckable(True)
+        self.filter_group.setChecked(False)
         filter_group_layout = QVBoxLayout()
 
-        # Filter builder
-        self.filter_builder = FilterBuilder()
+        # Filter builder (already created at top)
         filter_group_layout.addWidget(self.filter_builder)
 
-        filter_group.setLayout(filter_group_layout)
-        query_layout.addWidget(filter_group)
-        self.filter_group = filter_group
+        self.filter_group.setLayout(filter_group_layout)
+        query_layout.addWidget(self.filter_group)
 
         splitter.addWidget(query_widget)
 
@@ -106,12 +145,13 @@ class SearchView(QWidget):
         results_group = QGroupBox("Search Results")
         results_group_layout = QVBoxLayout()
 
-        self.results_table = QTableWidget()
         self.results_table.setSelectionBehavior(QTableWidget.SelectRows)
         self.results_table.setAlternatingRowColors(True)
+        # Enable context menu
+        self.results_table.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.results_table.customContextMenuRequested.connect(self._show_context_menu)
         results_group_layout.addWidget(self.results_table)
 
-        self.results_status = QLabel("No search performed")
         self.results_status.setStyleSheet("color: gray;")
         results_group_layout.addWidget(self.results_status)
 
@@ -125,6 +165,57 @@ class SearchView(QWidget):
         splitter.setStretchFactor(1, 2)
 
         layout.addWidget(splitter)
+        self.setLayout(layout)
+
+    def set_breadcrumb(self, text: str):
+        """Set the breadcrumb indicator (for pro features)."""
+        # Keep the full breadcrumb for tooltip and compute an elided
+        # display that fits the current label width (elide from the left).
+        self._full_breadcrumb = text or ""
+        self.breadcrumb_label.setToolTip(self._full_breadcrumb)
+        self._update_breadcrumb_display()
+
+    def _update_breadcrumb_display(self):
+        """Compute and apply an elided breadcrumb display based on label width."""
+        if not hasattr(self, "breadcrumb_label") or self.breadcrumb_label is None:
+            return
+
+        fm = QFontMetrics(self.breadcrumb_label.font())
+        avail_width = max(10, self.breadcrumb_label.width())
+        if not self._full_breadcrumb:
+            self.breadcrumb_label.setText("")
+            return
+
+        # Choose elide mode from settings
+        elide_flag = Qt.ElideLeft if self._elide_mode == "left" else Qt.ElideMiddle
+        elided = fm.elidedText(self._full_breadcrumb, elide_flag, avail_width)
+        self.breadcrumb_label.setText(elided)
+
+    def set_elide_mode(self, mode: str):
+        """Set elide mode ('left' or 'middle') and refresh display."""
+        if mode not in ("left", "middle"):
+            mode = "left"
+        self._elide_mode = mode
+        self._update_breadcrumb_display()
+
+    def resizeEvent(self, event):
+        """Handle resize to recompute breadcrumb eliding."""
+        try:
+            super().resizeEvent(event)
+        finally:
+            self._update_breadcrumb_display()
+
+    def clear_breadcrumb(self):
+        """Clear the breadcrumb indicator."""
+        self.breadcrumb_label.setText("")
+
+    def _refresh_search(self):
+        """Reset search input, results, and breadcrumb."""
+        self.query_input.clear()
+        self.results_table.setRowCount(0)
+        self.results_status.setText("No search performed")
+        self.clear_breadcrumb()
+        self.search_results = None
 
     def set_collection(self, collection_name: str, database_name: str = ""):
         """Set the current collection to search."""
@@ -139,6 +230,11 @@ class SearchView(QWidget):
             collection_name,
         )
 
+        # Guard: if results_table is not yet initialized, do nothing
+        if self.results_table is None:
+            log_info("[SearchView] set_collection called before UI setup; skipping.")
+            return
+
         # Check cache first
         cached = self.cache_manager.get(self.current_database, self.current_collection)
         if cached:
@@ -281,6 +377,43 @@ class SearchView(QWidget):
                 },
             )
 
+    def _show_context_menu(self, position):
+        """Show context menu for results table rows."""
+        # Get the item at the position
+        item = self.results_table.itemAt(position)
+        if not item:
+            return
+
+        row = item.row()
+        if row < 0 or row >= self.results_table.rowCount():
+            return
+
+        # Create context menu
+        menu = QMenu(self)
+
+        # Call extension hooks to add custom menu items
+        try:
+            from vector_inspector.extensions import table_context_menu_hook
+
+            table_context_menu_hook.trigger(
+                menu=menu,
+                table=self.results_table,
+                row=row,
+                data={
+                    "current_data": self.search_results,
+                    "collection_name": self.current_collection,
+                    "database_name": self.current_database,
+                    "connection": self.connection,
+                    "view_type": "search",
+                },
+            )
+        except Exception as e:
+            log_info("Extension hook error: %s", e)
+
+        # Only show menu if it has items
+        if not menu.isEmpty():
+            menu.exec(self.results_table.viewport().mapToGlobal(position))
+
     def _display_results(self, results: Dict[str, Any]):
         """Display search results in table."""
         ids = results.get("ids", [[]])[0]

{vector_inspector-0.3.8.dist-info → vector_inspector-0.3.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vector-inspector
-Version: 0.3.8
+Version: 0.3.11
 Summary: A comprehensive desktop application for visualizing, querying, and managing vector database data
 Author-Email: Anthony Dawson <anthonypdawson+github@gmail.com>
 License: MIT
@@ -8,7 +8,7 @@ Project-URL: Homepage, https://vector-inspector.divinedevops.com
 Project-URL: Source, https://github.com/anthonypdawson/vector-inspector
 Project-URL: Issues, https://github.com/anthonypdawson/vector-inspector/issues
 Project-URL: Documentation, https://github.com/anthonypdawson/vector-inspector#readme
-Requires-Python: <3.14,>=3.10
+Requires-Python: >=3.10
 Requires-Dist: chromadb>=0.4.22
 Requires-Dist: qdrant-client>=1.7.0
 Requires-Dist: pyside6>=6.6.0
@@ -32,30 +32,8 @@ Description-Content-Type: text/markdown
 
 # Latest updates
 
-## Vector Inspector 2026.01 Release Notes
-
-### Major Refactor and Studio-Ready Architecture
-- Refactored main window into modular components:
-  - InspectorShell: reusable UI shell (splitter, tabs, layout)
-  - ProviderFactory: centralized connection creation
-  - DialogService: dialog management
-  - ConnectionController: connection lifecycle and threading
-  - InspectorTabs: pluggable tab registry
-- MainWindow now inherits from InspectorShell and is fully reusable as a widget
-- Bootstrap logic is separated from UI logic—Studio can host Inspector as a component
-- Tab system is now pluggable: Studio and Inspector can add, remove, or override tabs via TabDefinition
-- All Inspector UI logic is self-contained; Studio can extend without modifying Inspector code
-
-### Data Browser Improvements
-- Added a checkbox: Generate embeddings on edit (default: checked)
-  - When unchecked, editing a row skips embedding regeneration
-  - Setting is persisted per user
-
-### Developer and Architecture Notes
-- All modules pass syntax checks and are ready for Studio integration
-- No breaking changes for existing Inspector users
-- Inspector is now a true UI module, not just an application
-
+- Added optional telemetry opt-in in settings panel (File -> Preferences -> Telemetry). See docs/telemetry/model_telemetry_and_registry.md and docs/telemetry/unified_telemetry_architecture.md for details.
+  - Currently only 'launch' telemetry is sent. Model registry telemetry will be added later.
 ---
 
 # Vector Inspector
@@ -63,7 +41,7 @@ Description-Content-Type: text/markdown
 > **Disclaimer:** This tool is currently under active development and is **not production ready**. Not all features have been thoroughly tested and code is released frequently. Use with caution in critical or production environments.
 
 [![CI](https://github.com/anthonypdawson/vector-inspector/actions/workflows/ci-tests.yml/badge.svg?branch=master)](https://github.com/anthonypdawson/vector-inspector/actions/workflows/ci-tests.yml)
-[![Publish](https://github.com/anthonypdawson/vector-inspector/actions/workflows/publish%20copy.yml/badge.svg?branch=master)](https://github.com/anthonypdawson/vector-inspector/actions/workflows/publish%20copy.yml)
+[![Publish](https://github.com/anthonypdawson/vector-inspector/actions/workflows/release-and-publish.yml/badge.svg?branch=master)](https://github.com/anthonypdawson/vector-inspector/actions/workflows/release-and-publish.yml)
 
 [![PyPI Version](https://img.shields.io/pypi/v/vector-inspector.svg?cacheSeconds=300)](https://pypi.org/project/vector-inspector/)
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/vector-inspector?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/vector-inspector)
@@ -92,6 +70,8 @@ Vector Inspector bridges the gap between vector databases and user-friendly data
 
 ## Key Features
 
+> **Note:** Some features listed below may be not started or currently in progress.
+
 ### 1. **Multi-Provider Support**
 - Connect to vector databases:
   - ChromaDB (persistent local storage)

{vector_inspector-0.3.8.dist-info → vector_inspector-0.3.11.dist-info}/RECORD

@@ -1,7 +1,7 @@
-vector_inspector-0.3.8.dist-info/METADATA,sha256=efuN0ywBf5QkEwGbRDiOV9YHG9pLNdBWBqnHPDsqUg0,11574
-vector_inspector-0.3.8.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-vector_inspector-0.3.8.dist-info/entry_points.txt,sha256=u96envMI2NFImZUJDFutiiWl7ZoHrrev9joAgtyvTxo,80
-vector_inspector/__init__.py,sha256=Q8XbXn98o0eliQWPePhy-aGUz2KNnVg7bQq-sBPl7zQ,119
+vector_inspector-0.3.11.dist-info/METADATA,sha256=UJw5xL019__f7EIgTcIxAqQ4Wq7SjTXxZJfNLNRwVtY,10781
+vector_inspector-0.3.11.dist-info/WHEEL,sha256=Wb0ASbVj8JvWHpOiIpPi7ucfIgJeCi__PzivviEAQFc,90
+vector_inspector-0.3.11.dist-info/entry_points.txt,sha256=u96envMI2NFImZUJDFutiiWl7ZoHrrev9joAgtyvTxo,80
+vector_inspector/__init__.py,sha256=gBFBsYQUOvdcns7nbI7_gtyUyzNgU6O7XqppKmCQ8f0,370
 vector_inspector/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
 vector_inspector/config/__init__.py,sha256=vHkVsXSUdInsfzWSOLPZzaaELa3SGenAgfpY5EYbsYA,95
 vector_inspector/config/known_embedding_models.json,sha256=tnTWI3OvdL2z0YreL_iBzbceIXR69NDj-0tBcEV6NVM,15701
@@ -11,7 +11,7 @@ vector_inspector/core/connection_manager.py,sha256=xNmgSXqJcMC-iaOY33-Xnfxq4QjUN
 vector_inspector/core/connections/__init__.py,sha256=lDZ-Qv-CbBvVcSlT8K2824zojovEIKhykHVSLARHZWs,345
 vector_inspector/core/connections/base_connection.py,sha256=jDA1cEeNbTghqcCZYoLRpRPXIUteU5mSdpKcjvr4JQI,12236
 vector_inspector/core/connections/chroma_connection.py,sha256=Mks17olaHIxvJAdCVB6EoQa5Tj7ScoD3_b2--Ra0Owk,21006
-vector_inspector/core/connections/pgvector_connection.py,sha256=7xzS3WRaa8IMt-RMU056kzxqiu2SLPgYxDMz_Xw5LVc,43812
+vector_inspector/core/connections/pgvector_connection.py,sha256=7Iq6b1pWB5Rz-zva7ZvDQj098ZVMz0WUkVgarSgTpA4,44940
 vector_inspector/core/connections/pinecone_connection.py,sha256=V6nHLB6DXfQJG8LiH1uPtWFs6otACkaNxeYrM0uY0AQ,26954
 vector_inspector/core/connections/qdrant_connection.py,sha256=GkLmnwnswakSMRM16pmtjkR6QXBszDhvg-aKhmI9jxw,31958
 vector_inspector/core/connections/qdrant_helpers/__init__.py,sha256=u2YNjiW4sbNtqhTNOQr4hmOFqirlNlllsyBK2gWs9eU,262
@@ -27,7 +27,9 @@ vector_inspector/core/embedding_utils.py,sha256=UCnJllDS_YPqbOPVo_kxSCUxM64C5tmc
 vector_inspector/core/logging.py,sha256=HQ6_OZgZmaS3OMFOTAqc0oRbZujqo1W0w8OU4viXP1g,845
 vector_inspector/core/model_registry.py,sha256=fdofceD3iyNpECVC7djTEAaDYgHX_7JQ3ROh5A0plpY,6269
 vector_inspector/core/provider_factory.py,sha256=QFDpJTOBJVYAdOLlY0GxSWl87Yj_UT9ZzOm9cjVsGMU,3924
-vector_inspector/main.py,sha256=iZeMPH94q6Ma92hWQLJ7on3rwxytUoS0V8n9MkAuEaY,595
+vector_inspector/extensions/__init__.py,sha256=cbN22B89XQT7uZRXBujqfbXDWm5w4rao0UHgMsUJqu0,3303
+vector_inspector/extensions/telemetry_settings_panel.py,sha256=uYvxnjBj_sqD18TpxeZP1f1VRbYhSjQV5boVc53dx40,934
+vector_inspector/main.py,sha256=XhoVqZJm49X5n5dGNcuTCJagU3WgCckgO0TifxAhl5A,1182
 vector_inspector/services/__init__.py,sha256=QLgH7oybjHuEYDFNiBgmJxvSpgAzHEuBEPXa3SKJb_I,67
 vector_inspector/services/backup_helpers.py,sha256=aX1ONFegERq6dpoNM1eJrbyE1gWCV3SuUHMyPpnxrYM,2005
 vector_inspector/services/backup_restore_service.py,sha256=8e64C4v8v-5Sw0upC4YaJWlLFkqAkspNt0k7yZjf_zk,7625
@@ -35,7 +37,8 @@ vector_inspector/services/credential_service.py,sha256=Ui4JzivQ5YCytQYsKdzpLs5nZ
 vector_inspector/services/filter_service.py,sha256=xDrMxNWsYzRcR1n0Fd-yp6Fo-4aLbVIDkhj2GKmrw5o,2370
 vector_inspector/services/import_export_service.py,sha256=4NOfAa6ZyvMyj5cDM4xu0Wqx0pgnK3cCNBGo3E6j4LE,10200
 vector_inspector/services/profile_service.py,sha256=AMeC6XOfI6Qumi0bKlTbqU-czMcle0rrHYK68ceK5r8,12856
-vector_inspector/services/settings_service.py,sha256=YfuPK4VIn7Kd36dpGsgzLAJw3fGybopDUcHhR30GSaY,7692
+vector_inspector/services/settings_service.py,sha256=Li1JR_6Ihuta9ifo_heqbjT5e3e26kjcxR8OxPDiN58,10798
+vector_inspector/services/telemetry_service.py,sha256=eWOmQxZjW2v_IK_HQ_uIRi4ostQyvo4ptxK3BB1cdq8,3066
 vector_inspector/services/update_service.py,sha256=B_l0qQUe0L_rYWNYnqvXET4UNf6bCSsl2LTkINtp0GE,2771
 vector_inspector/services/visualization_service.py,sha256=9TOK1S1u1U74wLpF5NdDiryyrjOzFnvE8kwjugf95Wk,4208
 vector_inspector/ui/__init__.py,sha256=262ZiXO6Luk8vZnhCIoYxOtGiny0bXK-BTKjxUNBx-w,43
@@ -54,7 +57,8 @@ vector_inspector/ui/dialogs/__init__.py,sha256=xtT77L91PFfm3zHYRENHkWHJaKPm1htuU
 vector_inspector/ui/dialogs/cross_db_migration.py,sha256=BaUyic8l5Ywwql2hQyxVrCXHMjGtqerNAQHDYxcbQ54,15872
 vector_inspector/ui/dialogs/embedding_config_dialog.py,sha256=1K5LBSBXp590BvKwtHx9qgPwGREsn1mJ8cjFGSZHnMA,12926
 vector_inspector/ui/dialogs/provider_type_dialog.py,sha256=W_FAJuvicwBUJJ7PyvKow9lc8_a5pnE3RIAsh-DVndQ,6809
-vector_inspector/ui/main_window.py,sha256=mZfUm29Ur-dfR4pbHXRSaDsQmIHFY1_SfOahHE_o1DI,21493
+vector_inspector/ui/dialogs/settings_dialog.py,sha256=sMrt1uvkgu0ZPhGClKqtMYkkY2L53LyaQaWO6Cct1qc,4510
+vector_inspector/ui/main_window.py,sha256=L8waeqVndK2YXgaf5bqHOIBbHRrcZuOkg-r_lAtrpeM,27219
 vector_inspector/ui/main_window_shell.py,sha256=0o4KxRc4KXu-mJxni9dv74a5DzP4OIvJoLTX7BLqDoo,3425
 vector_inspector/ui/services/__init__.py,sha256=m2DGkhYlcQQGMtNQsup5eKmhCFhOhXHi-g9Hw0GH1vE,55
 vector_inspector/ui/services/dialog_service.py,sha256=1NHWSMvNadcmoh8tgUMSa8N7g8xYDOTaWMr1G8i9e8A,4261
@@ -63,10 +67,10 @@ vector_inspector/ui/views/__init__.py,sha256=FeMtVzSbVFBMjdwLQSQqD0FRW4ieJ4ZKXtT
 vector_inspector/ui/views/collection_browser.py,sha256=oG9_YGPoVuMs-f_zSd4EcITmEU9caxvwuubsFUrNf-c,3991
 vector_inspector/ui/views/connection_view.py,sha256=3oGbClqwpVuUD3AIT8TuM-8heDvwMYw7RowHT3b1b8o,23749
 vector_inspector/ui/views/info_panel.py,sha256=6LwOQFmRdFOcNZo_BcZ8DZ5a5GTdGLwO2IIHqYWNBdQ,26179
-vector_inspector/ui/views/metadata_view.py,sha256=75ITKS-DPw1GVUBWI1ppTbADb5Ka4d82wPhM7iFxDGo,45776
-vector_inspector/ui/views/search_view.py,sha256=LFGmbyVoB04bE6KX-Gt-WYmFrFfnMy808iHWiWVH-gU,12291
+vector_inspector/ui/views/metadata_view.py,sha256=fmofgvptCjcWrB4-M6kMN3Lbo5DYHn1VulBBrd8OYLQ,47314
+vector_inspector/ui/views/search_view.py,sha256=xhyCf1JrqC1ZMIxTIm8nr5iC8OsbNxx1BCfabM5aRXs,17408
 vector_inspector/ui/views/visualization_view.py,sha256=wgkSkOM-ShOHDj1GCUtKnqH87Io5vYtiOdubGV5rN44,11050
 vector_inspector/utils/__init__.py,sha256=jhHBQC8C8bfhNlf6CAt07ejjStp_YAyleaYr2dm0Dk0,38
 vector_inspector/utils/lazy_imports.py,sha256=2XZ3ZnwTvZ5vvrh36nJ_TUjwwkgjoAED6i6P9yctvt0,1211
 vector_inspector/utils/version.py,sha256=2Xk9DEKlDRGEszNNiYnK7ps1i3OH56H2uZhR0_yZORs,382
-vector_inspector-0.3.8.dist-info/RECORD,,
+vector_inspector-0.3.11.dist-info/RECORD,,

{vector_inspector-0.3.8.dist-info → vector_inspector-0.3.11.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.4.6)
+Generator: pdm-backend (2.4.7)
 Root-Is-Purelib: true
 Tag: py3-none-any