dfdfdf

ProviderCore/__init__.py

@@ -0,0 +1,5 @@
+"""Provider core modules.
+
+This package contains the provider framework (base types, registry, and shared helpers).
+Concrete provider implementations live in the `Provider/` package.
+"""

ProviderCore/base.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+
+@dataclass
+class SearchResult:
+    """Unified search result format across all search providers."""
+
+    table: str  # Provider name: "libgen", "soulseek", "bandcamp", "youtube", etc.
+    title: str  # Display title/filename
+    path: str  # Download target (URL, path, magnet, identifier)
+
+    detail: str = ""  # Additional description
+    annotations: List[str] = field(default_factory=list)  # Tags: ["120MB", "flac", "ready"]
+    media_kind: str = "other"  # Type: "book", "audio", "video", "game", "magnet"
+    size_bytes: Optional[int] = None
+    tag: set[str] = field(default_factory=set)  # Searchable tag values
+    columns: List[Tuple[str, str]] = field(default_factory=list)  # Display columns
+    full_metadata: Dict[str, Any] = field(default_factory=dict)  # Extra metadata
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for pipeline processing."""
+
+        return {
+            "table": self.table,
+            "title": self.title,
+            "path": self.path,
+            "detail": self.detail,
+            "annotations": self.annotations,
+            "media_kind": self.media_kind,
+            "size_bytes": self.size_bytes,
+            "tag": list(self.tag),
+            "columns": list(self.columns),
+            "full_metadata": self.full_metadata,
+        }
+
+
+class SearchProvider(ABC):
+    """Base class for search providers."""
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        self.config = config or {}
+        self.name = self.__class__.__name__.lower()
+
+    @abstractmethod
+    def search(
+        self,
+        query: str,
+        limit: int = 50,
+        filters: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> List[SearchResult]:
+        """Search for items matching the query."""
+
+    def download(self, result: SearchResult, output_dir: Path) -> Optional[Path]:
+        """Download an item from a search result."""
+
+        return None
+
+    def validate(self) -> bool:
+        """Check if provider is available and properly configured."""
+
+        return True
+
+
+class FileProvider(ABC):
+    """Base class for file upload providers."""
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        self.config = config or {}
+        self.name = self.__class__.__name__.lower()
+
+    @abstractmethod
+    def upload(self, file_path: str, **kwargs: Any) -> str:
+        """Upload a file and return the URL."""
+
+    def validate(self) -> bool:
+        """Check if provider is available/configured."""
+
+        return True

ProviderCore/download.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import requests
+
+
+def sanitize_filename(name: str, *, max_len: int = 150) -> str:
+    text = str(name or "").strip()
+    if not text:
+        return "download"
+
+    forbidden = set('<>:"/\\|?*')
+    cleaned = "".join("_" if c in forbidden else c for c in text)
+    cleaned = " ".join(cleaned.split()).strip().strip(".")
+    if not cleaned:
+        cleaned = "download"
+    return cleaned[:max_len]
+
+
+def download_file(url: str, output_path: Path, *, session: Optional[requests.Session] = None, timeout_s: float = 30.0) -> bool:
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    s = session or requests.Session()
+
+    try:
+        with s.get(url, stream=True, timeout=timeout_s) as resp:
+            resp.raise_for_status()
+            with open(output_path, "wb") as f:
+                for chunk in resp.iter_content(chunk_size=1024 * 256):
+                    if chunk:
+                        f.write(chunk)
+        return output_path.exists() and output_path.stat().st_size > 0
+    except Exception:
+        try:
+            if output_path.exists():
+                output_path.unlink()
+        except Exception:
+            pass
+        return False

ProviderCore/registry.py

@@ -0,0 +1,112 @@
+"""Provider registry.
+
+Concrete provider implementations live in the `Provider/` package.
+This module is the single source of truth for provider discovery.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, Type
+import sys
+
+from SYS.logger import log
+
+from ProviderCore.base import FileProvider, SearchProvider, SearchResult
+from Provider.bandcamp import Bandcamp
+from Provider.libgen import Libgen
+from Provider.matrix import Matrix
+from Provider.openlibrary import OpenLibrary
+from Provider.soulseek import Soulseek, download_soulseek_file
+from Provider.youtube import YouTube
+from Provider.zeroxzero import ZeroXZero
+
+
+_SEARCH_PROVIDERS: Dict[str, Type[SearchProvider]] = {
+    "libgen": Libgen,
+    "openlibrary": OpenLibrary,
+    "soulseek": Soulseek,
+    "bandcamp": Bandcamp,
+    "youtube": YouTube,
+}
+
+
+def get_search_provider(name: str, config: Optional[Dict[str, Any]] = None) -> Optional[SearchProvider]:
+    """Get a search provider by name."""
+
+    provider_class = _SEARCH_PROVIDERS.get((name or "").lower())
+    if provider_class is None:
+        log(f"[provider] Unknown search provider: {name}", file=sys.stderr)
+        return None
+
+    try:
+        provider = provider_class(config)
+        if not provider.validate():
+            log(f"[provider] Provider '{name}' is not available", file=sys.stderr)
+            return None
+        return provider
+    except Exception as exc:
+        log(f"[provider] Error initializing '{name}': {exc}", file=sys.stderr)
+        return None
+
+
+def list_search_providers(config: Optional[Dict[str, Any]] = None) -> Dict[str, bool]:
+    """List all search providers and their availability."""
+
+    availability: Dict[str, bool] = {}
+    for name, provider_class in _SEARCH_PROVIDERS.items():
+        try:
+            provider = provider_class(config)
+            availability[name] = provider.validate()
+        except Exception:
+            availability[name] = False
+    return availability
+
+
+_FILE_PROVIDERS: Dict[str, Type[FileProvider]] = {
+    "0x0": ZeroXZero,
+    "matrix": Matrix,
+}
+
+
+def get_file_provider(name: str, config: Optional[Dict[str, Any]] = None) -> Optional[FileProvider]:
+    """Get a file provider by name."""
+
+    provider_class = _FILE_PROVIDERS.get((name or "").lower())
+    if provider_class is None:
+        log(f"[provider] Unknown file provider: {name}", file=sys.stderr)
+        return None
+
+    try:
+        provider = provider_class(config)
+        if not provider.validate():
+            log(f"[provider] File provider '{name}' is not available", file=sys.stderr)
+            return None
+        return provider
+    except Exception as exc:
+        log(f"[provider] Error initializing file provider '{name}': {exc}", file=sys.stderr)
+        return None
+
+
+def list_file_providers(config: Optional[Dict[str, Any]] = None) -> Dict[str, bool]:
+    """List all file providers and their availability."""
+
+    availability: Dict[str, bool] = {}
+    for name, provider_class in _FILE_PROVIDERS.items():
+        try:
+            provider = provider_class(config)
+            availability[name] = provider.validate()
+        except Exception:
+            availability[name] = False
+    return availability
+
+
+__all__ = [
+    "SearchResult",
+    "SearchProvider",
+    "FileProvider",
+    "get_search_provider",
+    "list_search_providers",
+    "get_file_provider",
+    "list_file_providers",
+    "download_soulseek_file",
+]