pandify 0.1.0__py3-none-any.whl

pandify/__init__.py

@@ -0,0 +1,36 @@
+"""Pandify: Private AI chat library powered by Google Gemini.
+
+Importable Python library providing secure, multimodal conversational workflows with minimal terminal UI.
+"""
+
+__version__ = "0.1.0"
+
+from pandify.api.auth import auth
+from pandify.api.chat import chat
+from pandify.api.configure import configure
+from pandify.api.help import pandify_help
+from pandify.api.history import history
+from pandify.api.keys import clear_keys, download_keys, keys
+from pandify.api.memory import clear_memory, remember, templates
+from pandify.api.session import clear, exit, new
+from pandify.api.upload import upload
+
+__all__ = [
+    "__version__",
+    "auth",
+    "chat",
+    "upload",
+    "new",
+    "clear",
+    "exit",
+    "history",
+    "keys",
+    "download_keys",
+    "clear_keys",
+    "configure",
+    "pandify_help",
+    "remember",
+    "templates",
+    "clear_memory",
+]
+

pandify/api/__init__.py

@@ -0,0 +1,24 @@
+"""API package for Pandify."""
+
+from pandify.api.auth import auth
+from pandify.api.chat import chat
+from pandify.api.configure import configure
+from pandify.api.help import pandify_help
+from pandify.api.history import history
+from pandify.api.keys import keys
+from pandify.api.session import clear, exit, new
+from pandify.api.upload import upload
+
+__all__ = [
+    "auth",
+    "chat",
+    "upload",
+    "new",
+    "clear",
+    "exit",
+    "history",
+    "keys",
+    "configure",
+    "pandify_help",
+]
+

pandify/api/auth.py

@@ -0,0 +1,46 @@
+"""Public API: pandify.auth()"""
+
+from pathlib import Path
+from typing import Optional
+from pandify.core.session import SessionManager
+
+
+def auth(
+    password: Optional[str] = None,
+    key: Optional[str] = None,
+    keys_file: Optional[str] = None,
+) -> bool:
+    """Authenticate the user session with optional direct key or keys_file injection.
+    
+    Args:
+        password (str, optional): Explicit master password.
+        key (str, optional): Direct Gemini API key secret to register for this session.
+        keys_file (str, optional): Path to a .txt file containing Gemini API key(s).
+    """
+    session = SessionManager.get_instance()
+    if not session.is_authenticated:
+        session.ensure_authenticated(explicit_password=password)
+
+    if key:
+        session.key_manager.add_key(secret=key.strip(), label="inline-auth-key")
+        session.renderer.print_info("Loaded API key from auth argument.")
+
+    if keys_file:
+        p = Path(keys_file)
+        if p.exists():
+            loaded_count = 0
+            with open(p, "r", encoding="utf-8") as f:
+                content = f.read()
+            for line in content.splitlines():
+                for part in line.split(","):
+                    k = part.strip()
+                    if k and not k.startswith("#"):
+                        session.key_manager.add_key(secret=k, label=f"file-key-{loaded_count+1}")
+                        loaded_count += 1
+            if loaded_count > 0:
+                session.renderer.print_info(f"Loaded {loaded_count} API key(s) from '{keys_file}'.")
+        else:
+            session.renderer.print_error(f"Keys file '{keys_file}' not found.")
+
+    return session.is_authenticated
+

pandify/api/chat.py

@@ -0,0 +1,118 @@
+"""Public API: pandify.chat()"""
+
+from typing import Optional
+from pandify.core.session import SessionManager
+from pandify.errors.exceptions import PandifyError
+
+
+def chat(message: str, stream: Optional[bool] = None) -> str:
+    """Send a message to Gemini with conversation context and any staged attachments.
+    
+    Parameters:
+        message (str): The prompt message to send.
+        stream (bool, optional): Stream response tokens to terminal. Defaults to config setting.
+        
+    Returns:
+        str: The full generated assistant response.
+    """
+    if not message or not message.strip():
+        raise ValueError("Message cannot be empty.")
+
+    session = SessionManager.get_instance()
+    session.ensure_authenticated()
+
+    renderer = session.renderer
+    conv_repo = session.conv_repo
+    conv_id = session.get_active_conversation_id()
+
+    # Flush any staged attachments
+    staged = session.staging.flush()
+    attachments_meta = [att.to_dict() for att in staged] if staged else None
+
+    # Print user prompt in minimal format
+    renderer.print_user_message(message.strip())
+
+    # Record user message in repository
+    conv_repo.add_message(
+        conversation_id=conv_id,
+        role="user",
+        content=message.strip(),
+        attachments=attachments_meta,
+    )
+
+    # Fetch prior conversation history
+    history = conv_repo.get_messages(conv_id)
+    # Exclude current user message from prior history as build_contents appends it with attachments
+    prior_messages = history[:-1] if len(history) > 1 else []
+
+    # Determine streaming preference
+    is_streaming = stream if stream is not None else bool(session.config_mgr.get("general", "stream", True))
+    current_model = str(session.config_mgr.get("general", "model", "gemini-3.5-flash"))
+    max_retries = int(session.config_mgr.get("gemini", "max_retries", 3))
+
+    def _notify_key_switch(label: str, msg: str) -> None:
+        renderer.print_info(f"[{msg}]")
+
+    # Inspect persistent SQLite code templates
+    active_templates = session.template_repo.get_active_templates()
+    if active_templates:
+        template_blocks = []
+        for tpl in active_templates:
+            template_blocks.append(
+                f"--- MANDATORY CODE TEMPLATE: {tpl['name']} ---\n{tpl['content']}"
+            )
+        template_context = "\n\n".join(template_blocks)
+        effective_prompt = (
+            f"[MANDATORY REFERENCE TEMPLATE & ARCHITECTURE]\n"
+            f"{template_context}\n\n"
+            f"[STRICT INSTRUCTION]\n"
+            f"You must strictly adhere to the architecture, imports, class structure, and naming conventions provided in the template above. "
+            f"Only provide the missing logic or syntax fitted directly into this template format.\n\n"
+            f"[USER REQUEST]\n"
+            f"{message.strip()}"
+        )
+    else:
+        effective_prompt = message.strip()
+
+    try:
+        if is_streaming:
+            tokens_gen = session.gemini_client.generate_chat_stream(
+                history_messages=prior_messages,
+                prompt=effective_prompt,
+                attachments=staged,
+                model=current_model,
+                max_retries=max_retries,
+                notify_switch=_notify_key_switch,
+            )
+            response_text = renderer.print_assistant_response(
+                text="",
+                stream=True,
+                token_generator=tokens_gen,
+            )
+        else:
+            response_text = session.gemini_client.generate_chat_sync(
+                history_messages=prior_messages,
+                prompt=effective_prompt,
+                attachments=staged,
+                model=current_model,
+                max_retries=max_retries,
+                notify_switch=_notify_key_switch,
+            )
+            renderer.print_assistant_response(response_text, stream=False)
+
+        # Record assistant turn in repository
+        conv_repo.add_message(
+            conversation_id=conv_id,
+            role="model",
+            content=response_text,
+        )
+
+        return response_text
+
+    except PandifyError as e:
+        renderer.print_error(str(e))
+        raise
+    except Exception as e:
+        renderer.print_error(f"Unexpected error: {e}")
+        raise PandifyError(f"Chat operation failed: {e}") from e
+

pandify/api/configure.py

@@ -0,0 +1,55 @@
+"""Public API: pandify.configure()"""
+
+from typing import Any
+from rich.table import Table
+from pandify.core.session import SessionManager
+
+
+def configure(**kwargs: Any) -> dict[str, Any]:
+    """Inspect or update Pandify configuration parameters.
+    
+    Supported parameters:
+        model (str): Default Gemini model (e.g. 'gemini-2.5-flash', 'gemini-2.5-pro')
+        stream (bool): Whether to stream chat tokens
+        max_retries (int): Maximum key rotation retries
+        max_file_size_mb (int): Maximum upload file size in MB
+        theme (str): UI theme styling
+        session_timeout_minutes (int): Inactivity minutes before re-authentication
+        retention_days (int): Days to retain conversation logs
+        
+    Returns:
+        dict: The updated active configuration dictionary.
+    """
+    session = SessionManager.get_instance()
+    session.ensure_authenticated()
+
+    config_mgr = session.config_mgr
+    console = session.renderer.console
+
+    if kwargs:
+        updated = config_mgr.update(**kwargs)
+        # Propagate changes to active components
+        if "model" in kwargs:
+            session.gemini_client.default_model = str(kwargs["model"])
+        if "max_file_size_mb" in kwargs:
+            session.file_validator.max_size_mb = int(kwargs["max_file_size_mb"])
+        session.renderer.print_info("Configuration updated successfully.")
+        return updated
+
+    # If no arguments provided, print current settings
+    current = config_mgr.as_dict()
+    table = Table(title="Pandify Active Configuration", show_header=True, header_style="bold blue")
+    table.add_column("Section", style="dim")
+    table.add_column("Setting", style="bold white")
+    table.add_column("Value", style="cyan")
+
+    for section, values in current.items():
+        if isinstance(values, dict):
+            for k, v in values.items():
+                table.add_row(section, k, str(v))
+        else:
+            table.add_row("root", section, str(values))
+
+    console.print(table)
+    return current
+

pandify/api/help.py

@@ -0,0 +1,158 @@
+"""Public API: pandify.pandify_help()"""
+
+from rich.markdown import Markdown
+from pandify.core.session import SessionManager
+
+HELP_MARKDOWN = """
+# Pandify API Reference & Guide
+
+Pandify is a private AI chat library powered by Google Gemini designed to be imported directly into Python applications.
+
+---
+
+## 1. Quick Start
+
+```python
+import pandify
+
+# Authenticate or complete initial master password setup
+pandify.auth()
+
+# Normal conversation
+pandify.chat("Hello, how are you?")
+
+# Attach code, documents, or images
+pandify.upload("main.py")
+pandify.upload("diagram.png")
+pandify.chat("Explain this code and the architecture shown in the diagram.")
+
+# Check documentation
+pandify.pandify_help()
+
+# Safely close session
+pandify.exit()
+```
+
+---
+
+## 2. Core Functions
+
+### `pandify.auth(password: Optional[str] = None, key: Optional[str] = None, keys_file: Optional[str] = None) -> bool`
+- **Purpose**: Authenticates the current process session using Argon2id.
+- **Arguments**:
+  - `password`: Explicit master password (if omitted, prompts on a clean blank line).
+  - `key`: Direct API key string to load into in-memory session (useful on restricted lab PCs).
+  - `keys_file`: Path to a text file (e.g. `'keys.txt'`) containing API key(s) to load.
+
+### `pandify.chat(message: str, stream: Optional[bool] = None) -> str`
+- **Purpose**: Sends prompt and any staged attachments to Gemini.
+- **Returns**: Complete generated assistant response text.
+- **Features**: Automatic API key rotation on 429/errors, persistent context history, token streaming.
+
+### `pandify.upload(path: Union[str, Path, Iterable]) -> list[str]`
+- **Purpose**: Validates and stages files to be included with the next `chat()` prompt.
+- **Supported Formats**:
+  - Documents: `.pdf`, `.docx`, `.xlsx`, `.csv`, `.txt`
+  - Images: `.png`, `.jpg`, `.jpeg`, `.webp`
+  - Code & Markup: `.py`, `.js`, `.ts`, `.jsx`, `.tsx`, `.java`, `.c`, `.cpp`, `.html`, `.css`, `.json`, `.xml`, `.sql`, `.php`, `.go`, `.rs`, `.md`, `.log`
+- **Note**: Attachments are automatically sent with your next message and cleared after sending.
+
+### `pandify.new(title: Optional[str] = None) -> str`
+- **Purpose**: Initiates a fresh conversation thread with a new UUID and resets context.
+
+### `pandify.history(limit: int = 20, export_path: Optional[str] = None) -> list[dict]`
+- **Purpose**: View past conversations and message counts, or export to Markdown (`.md`) or JSON (`.json`).
+
+### `pandify.keys(action: Optional[str] = None, **kwargs) -> Any`
+- **Purpose**: Securely configure and rotate $N$ Gemini API keys.
+- **Actions**:
+  - `pandify.keys('add', key='...', label='work', project_id='proj-1')`
+  - `pandify.keys('sync', url='https://krishnahere.pythonanywhere.com', password='...')`: Download keys from remote Flask server into OS Keyring.
+  - `pandify.keys('list')` or `pandify.keys()`
+  - `pandify.keys('remove', key_id='...')`
+  - `pandify.keys('clear')` or `pandify.clear_keys()`: **Purge all API keys** completely from the OS Keyring and local database after your exam.
+- **Shortcut**: `pandify.download_keys(url='https://krishnahere.pythonanywhere.com', password='...', save_file='keys.txt')`, `pandify.clear_keys()`
+- **Security**: Raw API keys are stored exclusively in the OS secure keyring and never stored in `.env`, SQLite, or logs.
+
+### `pandify.configure(**kwargs) -> dict`
+- **Purpose**: Inspect or adjust settings (e.g. `model='gemini-2.5-pro'`, `stream=True`, `max_file_size_mb=30`).
+
+### `pandify.remember(content, name='mentor_template') -> str`
+- **Purpose**: Saves a mentor code template or architecture boilerplate into SQLite memory.
+- **Effect**: All subsequent queries automatically ground Gemini in this exact code format.
+
+### `pandify.templates(action='list', **kwargs) -> Any`
+- **Purpose**: View, activate, deactivate, or delete stored templates.
+
+### `pandify.clear_memory(name: Optional[str] = None) -> bool`
+- **Purpose**: Clears a specific template or all templates from SQLite memory.
+
+### `pandify.clear() -> bool`
+- **Purpose**: Clears messages and unstages files for the current conversation.
+
+### `pandify.exit(delete_files: Optional[Union[str, list[str]]] = None) -> None`
+- **Purpose**: Cleans up runtime memory, invalidates active session token, restores terminal, and safely deletes temporary files (e.g. `delete_files=['keys.txt']`).
+
+---
+
+## 3. Exam & Lab PC Workflow Guide
+
+### A. Pre-Saving Mentor Format (Tonight)
+```python
+pandify.remember('''
+# PASTE MENTOR BOILERPLATE HERE
+class BaseHandler: pass
+''', name="mentor_template")
+```
+
+### B. Remote Key Sync (Exam Morning)
+```python
+# Pulls keys from your PythonAnywhere server directly into OS Keyring or In-Memory RAM:
+pandify.download_keys(url="https://krishnahere.pythonanywhere.com", password="pandify123")
+```
+
+### C. College PC Restricted Keyring Fallback
+If the college PC blocks Windows Credential Manager:
+- Pandify automatically keeps keys in Python RAM with zero errors.
+- Or pass keys directly at login:
+  ```python
+  pandify.auth(keys_file="keys.txt")  # or pandify.auth(key="AIzaSy...")
+  ```
+
+### D. Asking Exam Questions
+```python
+# stream=False renders beautiful syntax-highlighted code blocks:
+pandify.chat("Write a handler for UDP packets", stream=False)
+```
+
+### E. Complete Post-Exam Cleanup
+Wipes all keys, mentor templates, and temporary files when you finish:
+```python
+pandify.clear_keys()
+pandify.clear_memory()
+pandify.clear()
+pandify.exit(delete_files=["keys.txt"])
+```
+
+---
+
+## 4. Error Handling
+
+Pandify raises structured exceptions under `pandify.errors`:
+- `AuthenticationError`: Invalid password or account lockout.
+- `NoAPIKeysConfiguredError`: No keys registered in system.
+- `AllKeysExhaustedError`: All keys are rate-limited (HTTP 429) or cooling down.
+- `FileValidationError`: File not found, unsupported format, or size exceeded.
+- `PathTraversalError`: Attempted directory traversal detected.
+"""
+
+
+def pandify_help() -> None:
+    """Display authenticated Pandify documentation and API reference."""
+    session = SessionManager.get_instance()
+    # Requirement: Authenticate before showing help if no valid session exists
+    session.ensure_authenticated()
+
+    md = Markdown(HELP_MARKDOWN)
+    session.renderer.console.print(md)
+

pandify/api/history.py

@@ -0,0 +1,62 @@
+"""Public API: pandify.history()"""
+
+from pathlib import Path
+from typing import Optional, Union
+from rich.table import Table
+from pandify.core.session import SessionManager
+from pandify.errors.exceptions import StorageError
+
+
+def history(limit: int = 20, export_path: Optional[Union[str, Path]] = None) -> list[dict]:
+    """View recent conversations or export the active conversation history.
+    
+    Parameters:
+        limit (int): Maximum number of recent conversations to display. Defaults to 20.
+        export_path (str or Path, optional): File destination to export active conversation (.json or .md).
+        
+    Returns:
+        list[dict]: List of conversation summaries.
+    """
+    session = SessionManager.get_instance()
+    session.ensure_authenticated()
+
+    conv_repo = session.conv_repo
+    active_conv_id = session.get_active_conversation_id()
+
+    # If export requested
+    if export_path:
+        target = Path(export_path)
+        ext = target.suffix.lower()
+        fmt = "markdown" if ext in (".md", ".markdown") else "json"
+        exported_str = conv_repo.export_conversation(active_conv_id, format=fmt)
+        if not exported_str:
+            raise StorageError(f"No conversation history found to export for ID '{active_conv_id}'.")
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(exported_str, encoding="utf-8")
+        session.renderer.print_info(f"Exported conversation to: {target.resolve()}")
+        return [{"id": active_conv_id, "exported_to": str(target.resolve())}]
+
+    # Otherwise list recent conversations
+    conversations = conv_repo.list_conversations(limit=limit)
+
+    if not conversations:
+        session.renderer.print_info("No conversation history found.")
+        return []
+
+    table = Table(title="Conversation History", show_header=True, header_style="bold cyan")
+    table.add_column("ID", style="dim", width=36)
+    table.add_column("Title", style="bold white")
+    table.add_column("Messages", justify="right")
+    table.add_column("Last Active", style="dim")
+
+    for c in conversations:
+        table.add_row(
+            c["id"],
+            c["title"],
+            str(c.get("message_count", 0)),
+            str(c.get("updated_at", "")),
+        )
+
+    session.renderer.console.print(table)
+    return conversations
+

pandify/api/keys.py

@@ -0,0 +1,179 @@
+"""Public API: pandify.keys()"""
+
+import getpass
+import json
+import urllib.error
+import urllib.request
+from typing import Any, Optional
+from rich.table import Table
+from pandify.core.session import SessionManager
+from pandify.errors.exceptions import AuthenticationError, PandifyError
+from pandify.security.redactor import mask_secret
+
+
+def keys(action: Optional[str] = None, **kwargs: Any) -> Any:
+    """Manage Gemini API keys securely with automatic rotation and status tracking.
+    
+    Actions:
+        - None / 'list': Display active keys, projects, and usage statistics.
+        - 'add': Register a new key (requires 'secret' or prompts securely, optional 'label', 'project_id').
+        - 'remove': Remove a key by 'key_id'.
+    """
+    session = SessionManager.get_instance()
+    session.ensure_authenticated()
+
+    key_mgr = session.key_manager
+    console = session.renderer.console
+
+    action_norm = (action or "list").lower()
+
+    if action_norm == "add":
+        secret = kwargs.get("secret") or kwargs.get("key")
+        label = kwargs.get("label")
+        project_id = kwargs.get("project_id")
+
+        if not secret:
+            secret = getpass.getpass("Enter Gemini API Key Secret: ")
+        if not label:
+            label = input("Enter Key Label (e.g. personal-dev): ").strip() or "default"
+
+        rec = key_mgr.add_key(secret=secret, label=label, project_id=project_id)
+        session.renderer.print_info(f"Registered API key '{rec.label}' (ID: {rec.id}).")
+        return rec
+
+    elif action_norm in ("sync", "download"):
+        url = kwargs.get("url")
+        password = kwargs.get("password")
+        save_file = kwargs.get("save_file") or kwargs.get("file")
+        if not url:
+            raise ValueError("Backend URL is required. Usage: pandify.keys('sync', url='http://...', password='...')")
+        if not password:
+            password = getpass.getpass("Enter Server Download Password: ")
+        return download_keys(url=url, password=password, save_file=save_file)
+
+    elif action_norm in ("clear", "purge", "wipe"):
+        return clear_keys()
+
+    elif action_norm == "remove" or action_norm == "delete":
+        key_id = kwargs.get("key_id") or kwargs.get("id")
+        if not key_id:
+            raise ValueError("Key ID is required for deletion. Usage: pandify.keys('remove', key_id='...')")
+        success = key_mgr.remove_key(key_id)
+        if success:
+            session.renderer.print_info(f"Key '{key_id}' removed.")
+        else:
+            session.renderer.print_info(f"Key '{key_id}' not found.")
+        return success
+
+    else:
+        # Default: list registered keys
+        records = key_mgr.list_keys()
+        if not records:
+            session.renderer.print_info("No API keys registered. Add one with: pandify.keys('add')")
+            return []
+
+        table = Table(title="Registered Gemini API Keys", show_header=True, header_style="bold magenta")
+        table.add_column("Key ID", style="dim", width=36)
+        table.add_column("Label", style="bold white")
+        table.add_column("Project ID", style="cyan")
+        table.add_column("Status", style="green")
+        table.add_column("Requests", justify="right")
+        table.add_column("Failures", justify="right")
+        table.add_column("Last Used", style="dim")
+
+        for r in records:
+            status_style = "green" if r["status"] == "active" else ("yellow" if r["status"] == "cooling_down" else "red")
+            table.add_row(
+                r["id"],
+                r["label"],
+                r.get("project_id") or "-",
+                f"[{status_style}]{r['status']}[/]",
+                str(r.get("request_count", 0)),
+                str(r.get("failure_count", 0)),
+                str(r.get("last_used_at") or "-"),
+            )
+
+        console.print(table)
+        return records
+
+
+def download_keys(url: str, password: Optional[str] = None, save_file: Optional[str] = None) -> list[str]:
+    """Download and register Gemini API keys from a remote Pandify key server.
+    
+    Args:
+        url (str): The base URL of the remote key server (e.g. 'http://127.0.0.1:5000').
+        password (str, optional): The server's download authorization password.
+        save_file (str, optional): Optional local text file path to also save downloaded keys into (e.g. 'keys.txt').
+        
+    Returns:
+        list[str]: The registered key UUIDs.
+    """
+    session = SessionManager.get_instance()
+    session.ensure_authenticated()
+
+    clean_url = url.rstrip("/")
+    endpoint = f"{clean_url}/api/keys/download"
+
+    if not password:
+        password = getpass.getpass("Enter Server Download Password: ")
+
+    payload = json.dumps({"password": password}).encode("utf-8")
+    req = urllib.request.Request(
+        endpoint,
+        data=payload,
+        headers={"Content-Type": "application/json", "User-Agent": "Pandify-Client/0.1.0"},
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        if e.code == 401:
+            raise AuthenticationError("Remote key server authentication failed: Incorrect password.")
+        err_body = e.read().decode("utf-8", errors="ignore")
+        raise PandifyError(f"Remote key server returned HTTP {e.code}: {err_body}")
+    except Exception as e:
+        raise PandifyError(f"Failed to connect to remote key server at '{endpoint}': {e}")
+
+    keys_list = data.get("keys", [])
+    if not keys_list:
+        session.renderer.print_info("No keys returned by remote server.")
+        return []
+
+    registered_ids = []
+    raw_keys_to_save = []
+    for k in keys_list:
+        secret = k.get("key")
+        label = k.get("label") or "remote-synced-key"
+        project_id = k.get("project_id")
+        if secret:
+            rec = session.key_manager.add_key(secret=secret, label=label, project_id=project_id)
+            registered_ids.append(rec.id)
+            raw_keys_to_save.append(secret)
+
+    if save_file and raw_keys_to_save:
+        try:
+            with open(save_file, "w", encoding="utf-8") as f:
+                f.write("\n".join(raw_keys_to_save) + "\n")
+            session.renderer.print_info(f"Saved {len(raw_keys_to_save)} key(s) to backup file '{save_file}'.")
+        except Exception as e:
+            session.renderer.print_error(f"Failed to write keys to backup file '{save_file}': {e}")
+
+    session.renderer.print_info(f"Successfully loaded and registered {len(registered_ids)} key(s).")
+    return registered_ids
+
+
+def clear_keys() -> int:
+    """Purge all stored Gemini API keys completely from the OS Keyring and SQLite database.
+    
+    Returns:
+        int: Number of keys deleted.
+    """
+    session = SessionManager.get_instance()
+    session.ensure_authenticated()
+
+    count = session.key_manager.purge_all_keys()
+    session.renderer.print_info(f"Purged {count} API key(s) completely from OS Keyring and system database.")
+    return count
+