webscout 8.1__py3-none-any.whl → 8.2__py3-none-any.whl

webscout/Local/model_manager.py

@@ -0,0 +1,205 @@
+"""
+Model management for webscout.local
+"""
+
+import os
+import json
+import datetime
+from pathlib import Path
+from typing import Dict, Any, Optional, List, Tuple
+import shutil
+
+from rich.console import Console
+from rich.prompt import Prompt
+from huggingface_hub import hf_hub_download, HfFileSystem
+
+from .config import config
+
+console = Console()
+
+class ModelManager:
+    """
+    Manager for downloading and managing models.
+    Handles model download, listing, removal, and path resolution.
+    """
+    models_dir: Path
+
+    def __init__(self) -> None:
+        self.models_dir = config.models_dir
+
+    def parse_model_string(self, model_string: str) -> Tuple[str, Optional[str]]:
+        """
+        Parse a model string in the format 'repo_id:filename' or just 'repo_id'.
+        Args:
+            model_string (str): The model string to parse.
+        Returns:
+            Tuple[str, Optional[str]]: (repo_id, filename)
+        """
+        if ":" in model_string:
+            repo_id, filename = model_string.split(":", 1)
+            return repo_id, filename
+        else:
+            return model_string, None
+
+    def list_repo_gguf_files(self, repo_id: str) -> List[str]:
+        """
+        List all GGUF files in a repository.
+        Args:
+            repo_id (str): The Hugging Face repository ID.
+        Returns:
+            List[str]: List of filenames.
+        """
+        fs = HfFileSystem()
+        try:
+            files = fs.ls(repo_id, detail=False)
+            gguf_files = [os.path.basename(f) for f in files if f.endswith(".gguf")]
+            return gguf_files
+        except Exception as e:
+            console.print(f"[bold red]Error listing files in repository {repo_id}: {str(e)}[/bold red]")
+            return []
+
+    def select_file_interactive(self, repo_id: str) -> Optional[str]:
+        """
+        Interactively select a file from a repository.
+        Args:
+            repo_id (str): The Hugging Face repository ID.
+        Returns:
+            Optional[str]: Selected filename or None if cancelled.
+        """
+        gguf_files = self.list_repo_gguf_files(repo_id)
+        if not gguf_files:
+            console.print(f"[bold red]No GGUF files found in repository {repo_id}[/bold red]")
+            return None
+        console.print(f"[bold blue]Available GGUF files in {repo_id}:[/bold blue]")
+        for i, filename in enumerate(gguf_files):
+            console.print(f"  [{i+1}] {filename}")
+        choice = Prompt.ask(
+            "Select a file to download (number or filename)",
+            default="1"
+        )
+        try:
+            idx = int(choice) - 1
+            if 0 <= idx < len(gguf_files):
+                return gguf_files[idx]
+        except ValueError:
+            if choice in gguf_files:
+                return choice
+        console.print(f"[bold red]Invalid selection: {choice}[/bold red]")
+        return None
+
+    def download_model(self, model_string: str, filename: Optional[str] = None) -> Tuple[str, Path]:
+        """
+        Download a model from Hugging Face Hub.
+        Args:
+            model_string (str): The model string in format 'repo_id' or 'repo_id:filename'.
+            filename (Optional[str]): Specific filename to download, overrides filename in model_string.
+        Returns:
+            Tuple[str, Path]: (model_name, model_path)
+        """
+        repo_id, file_from_string = self.parse_model_string(model_string)
+        filename = filename or file_from_string
+        model_name = repo_id.split("/")[-1] if "/" in repo_id else repo_id
+        model_dir = config.get_model_path(model_name)
+        model_dir.mkdir(exist_ok=True, parents=True)
+        model_info: Dict[str, Any] = {
+            "repo_id": repo_id,
+            "name": model_name,
+            "downloaded_at": datetime.datetime.now().isoformat(),
+        }
+        with open(model_dir / "info.json", "w") as f:
+            json.dump(model_info, f, indent=2)
+        if not filename:
+            console.print(f"[yellow]No filename provided, searching for GGUF files in {repo_id}...[/yellow]")
+            filename = self.select_file_interactive(repo_id)
+            if not filename:
+                raise ValueError(f"No GGUF file selected from repository {repo_id}")
+            console.print(f"[green]Selected GGUF file: {filename}[/green]")
+        console.print(f"[bold blue]Downloading {filename} from {repo_id}...[/bold blue]")
+        try:
+            model_path = hf_hub_download(
+                repo_id=repo_id,
+                filename=filename,
+                local_dir=model_dir,
+            )
+        except Exception as e:
+            console.print(f"[bold red]Error downloading file: {str(e)}[/bold red]")
+            raise
+        console.print(f"[bold green]Model downloaded to {model_path}[/bold green]")
+        model_info["filename"] = filename
+        model_info["path"] = str(model_path)
+        with open(model_dir / "info.json", "w") as f:
+            json.dump(model_info, f, indent=2)
+        return model_name, Path(model_path)
+
+    def get_model_info(self, model_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Get information about a downloaded model.
+        Args:
+            model_name (str): Name of the model.
+        Returns:
+            Optional[Dict[str, Any]]: Model info dict or None if not found.
+        """
+        model_dir = config.get_model_path(model_name)
+        info_file = model_dir / "info.json"
+        if not info_file.exists():
+            return None
+        with open(info_file, "r") as f:
+            return json.load(f)
+
+    def list_models(self) -> List[Dict[str, Any]]:
+        """
+        List all downloaded models with their information.
+        Returns:
+            List[Dict[str, Any]]: List of model info dicts.
+        """
+        models: List[Dict[str, Any]] = []
+        seen_paths: set = set()
+        if not config.models_dir.exists():
+            return []
+        model_dirs = [d for d in config.models_dir.iterdir() if d.is_dir()]
+        for model_dir in model_dirs:
+            if ":" in model_dir.name:
+                continue
+            info_file = model_dir / "info.json"
+            if info_file.exists():
+                try:
+                    with open(info_file, "r") as f:
+                        info = json.load(f)
+                    if "path" in info and info["path"] in seen_paths:
+                        continue
+                    if "path" in info:
+                        seen_paths.add(info["path"])
+                    models.append(info)
+                except Exception:
+                    pass
+        return models
+
+    def remove_model(self, model_name: str) -> bool:
+        """
+        Remove a downloaded model.
+        Args:
+            model_name (str): Name of the model to remove.
+        Returns:
+            bool: True if removed, False if not found.
+        """
+        model_dir = config.get_model_path(model_name)
+        if not model_dir.exists():
+            return False
+        shutil.rmtree(model_dir)
+        return True
+
+    def get_model_path(self, model_name: str) -> Optional[str]:
+        """
+        Get the path to a model file.
+        Args:
+            model_name (str): Name or filename of the model.
+        Returns:
+            Optional[str]: Path to the model file or None if not found.
+        """
+        info = self.get_model_info(model_name)
+        if not info or "path" not in info:
+            for model_info in self.list_models():
+                if model_info.get("filename") == model_name:
+                    return model_info.get("path")
+            return None
+        return info["path"]

webscout/Local/server.py

@@ -0,0 +1,187 @@
+"""
+API server with OpenAI compatibility
+"""
+
+import json
+import time
+from typing import Dict, Any, List, Optional, AsyncGenerator
+
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from .config import config
+from .model_manager import ModelManager
+from .llm import LLMInterface
+
+app = FastAPI(title="webscout.local API", description="OpenAI-compatible API for webscout.local")
+
+# Models
+model_manager: ModelManager = ModelManager()
+loaded_models: Dict[str, LLMInterface] = {}  # Cache for loaded models
+
+class ChatMessage(BaseModel):
+    """
+    Represents a single chat message for the chat completion endpoint.
+    """
+    role: str
+    content: str
+
+class ChatCompletionRequest(BaseModel):
+    """
+    Request model for chat completions.
+    """
+    model: str
+    messages: List[ChatMessage]
+    temperature: float = 0.7
+    top_p: float = 0.95
+    max_tokens: int = 256
+    stream: bool = False
+    stop: Optional[List[str]] = None
+
+class CompletionRequest(BaseModel):
+    """
+    Request model for text completions.
+    """
+    model: str
+    prompt: str
+    temperature: float = 0.7
+    top_p: float = 0.95
+    max_tokens: int = 256
+    stream: bool = False
+    stop: Optional[List[str]] = None
+
+class ModelInfo(BaseModel):
+    """
+    Model information for listing available models.
+    """
+    id: str
+    object: str = "model"
+    created: int
+    owned_by: str = "webscout.local"
+
+class ModelList(BaseModel):
+    """
+    List of available models.
+    """
+    object: str = "list"
+    data: List[ModelInfo]
+
+def get_model(model_name: str) -> LLMInterface:
+    """
+    Get or load a model by name, using a cache for efficiency.
+    Args:
+        model_name (str): Name of the model to load.
+    Returns:
+        LLMInterface: Loaded model interface.
+    Raises:
+        HTTPException: If the model cannot be loaded.
+    """
+    if model_name not in loaded_models:
+        try:
+            loaded_models[model_name] = LLMInterface(model_name)
+            loaded_models[model_name].load_model()
+        except Exception as e:
+            raise HTTPException(status_code=404, detail=f"Model {model_name} not found: {str(e)}")
+    return loaded_models[model_name]
+
+@app.get("/v1/models", response_model=ModelList)
+async def list_models() -> ModelList:
+    """
+    List available models.
+    Returns:
+        ModelList: List of available models.
+    """
+    models = model_manager.list_models()
+    model_list: List[ModelInfo] = []
+    for model in models:
+        model_list.append(
+            ModelInfo(
+                id=model["name"],
+                created=int(time.time()),
+            )
+        )
+    return ModelList(object="list", data=model_list)
+
+@app.post("/v1/chat/completions")
+async def create_chat_completion(request: ChatCompletionRequest) -> Any:
+    """
+    Create a chat completion.
+    Args:
+        request (ChatCompletionRequest): Chat completion request.
+    Returns:
+        StreamingResponse or dict: Streaming or regular response.
+    """
+    model = get_model(request.model)
+    messages = [{"role": msg.role, "content": msg.content} for msg in request.messages]
+    if request.stream:
+        async def generate() -> AsyncGenerator[str, None]:
+            stream = model.create_chat_completion(
+                messages=messages,
+                max_tokens=request.max_tokens,
+                temperature=request.temperature,
+                top_p=request.top_p,
+                stream=True,
+                stop=request.stop,
+            )
+            for chunk in stream:
+                yield f"data: {json.dumps(chunk)}\n\n"
+            yield "data: [DONE]\n\n"
+        return StreamingResponse(generate(), media_type="text/event-stream")
+    else:
+        response = model.create_chat_completion(
+            messages=messages,
+            max_tokens=request.max_tokens,
+            temperature=request.temperature,
+            top_p=request.top_p,
+            stream=False,
+            stop=request.stop,
+        )
+        return response
+
+@app.post("/v1/completions")
+async def create_completion(request: CompletionRequest) -> Any:
+    """
+    Create a text completion.
+    Args:
+        request (CompletionRequest): Completion request.
+    Returns:
+        StreamingResponse or dict: Streaming or regular response.
+    """
+    model = get_model(request.model)
+    if request.stream:
+        async def generate() -> AsyncGenerator[str, None]:
+            stream = model.create_completion(
+                prompt=request.prompt,
+                max_tokens=request.max_tokens,
+                temperature=request.temperature,
+                top_p=request.top_p,
+                stream=True,
+                stop=request.stop,
+            )
+            for chunk in stream:
+                yield f"data: {json.dumps(chunk)}\n\n"
+            yield "data: [DONE]\n\n"
+        return StreamingResponse(generate(), media_type="text/event-stream")
+    else:
+        response = model.create_completion(
+            prompt=request.prompt,
+            max_tokens=request.max_tokens,
+            temperature=request.temperature,
+            top_p=request.top_p,
+            stream=False,
+            stop=request.stop,
+        )
+        return response
+
+def start_server(host: Optional[str] = None, port: Optional[int] = None) -> None:
+    """
+    Start the API server.
+    Args:
+        host (Optional[str]): Host to bind the server to.
+        port (Optional[int]): Port to bind the server to.
+    """
+    host = host or config.get("api_host", "127.0.0.1")
+    port = port or config.get("api_port", 8000)
+    uvicorn.run(app, host=host, port=port)

webscout/Local/utils.py

@@ -0,0 +1,93 @@
+"""
+Utility functions for webscout.local
+"""
+
+import base64
+import logging
+
+logger = logging.getLogger(__name__)
+
+def parse_duration(duration_str: str) -> float:
+    """
+    Parse a duration string into seconds.
+    
+    Args:
+        duration_str (str): Duration string (e.g., '5m', '1h', '30s', '500ms', '0').
+    Returns:
+        float: Duration in seconds.
+    """
+    if not duration_str:
+        return 300.0  # Default 5 minutes
+    if duration_str.endswith("ms"):
+        return int(duration_str[:-2]) / 1000.0
+    elif duration_str.endswith("s"):
+        return int(duration_str[:-1])
+    elif duration_str.endswith("m"):
+        return int(duration_str[:-1]) * 60
+    elif duration_str.endswith("h"):
+        return int(duration_str[:-1]) * 3600
+    elif duration_str == "0":
+        return 0.0
+    else:
+        try:
+            return float(duration_str)
+        except ValueError:
+            return 300.0  # Default 5 minutes
+
+def format_duration(seconds: float) -> str:
+    """
+    Format seconds into a human-readable duration string.
+    Args:
+        seconds (float): Duration in seconds.
+    Returns:
+        str: Human-readable duration string.
+    """
+    if seconds < 1:
+        return f"{int(seconds * 1000)}ms"
+    elif seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 3600:
+        return f"{int(seconds / 60)}m"
+    else:
+        return f"{int(seconds / 3600)}h"
+
+def decode_image(image_str: str) -> bytes:
+    """
+    Decode a base64 image string to bytes.
+    Args:
+        image_str (str): Base64-encoded image string (optionally with data URI prefix).
+    Returns:
+        bytes: Decoded image bytes.
+    """
+    if image_str.startswith("data:"):
+        image_str = image_str.split(",", 1)[1]
+    return base64.b64decode(image_str)
+
+def encode_image(image_bytes: bytes, mime_type: str = "image/png") -> str:
+    """
+    Encode image bytes to a base64 data URI.
+    Args:
+        image_bytes (bytes): Image data.
+        mime_type (str): MIME type for the image.
+    Returns:
+        str: Base64-encoded data URI string.
+    """
+    encoded = base64.b64encode(image_bytes).decode("utf-8")
+    return f"data:{mime_type};base64,{encoded}"
+
+def get_file_size_str(size_bytes: int) -> str:
+    """
+    Convert file size in bytes to a human-readable string.
+    Args:
+        size_bytes (int): File size in bytes.
+    Returns:
+        str: Human-readable file size string.
+    """
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.2f} KB"
+    elif size_bytes < 1024 * 1024 * 1024:
+        return f"{size_bytes / (1024 * 1024):.2f} MB"
+    else:
+        return f"{size_bytes / (1024 * 1024 * 1024):.2f} GB"