leostudio 0.1.0__tar.gz

leostudio-0.1.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: leostudio
+Version: 0.1.0
+Summary: Leo Studio Pro — Remote Worker Backend for GPU Inference & Training for LeoStudio Pro
+Author-email: Leo Studio Pro <admin@ray.ac>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi
+Requires-Dist: uvicorn[standard]
+Requires-Dist: python-socketio
+Requires-Dist: aiohttp
+Requires-Dist: aiofiles
+Requires-Dist: python-multipart
+Requires-Dist: soundfile
+Requires-Dist: librosa
+Requires-Dist: ffmpeg-python
+Requires-Dist: av
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: tqdm
+Requires-Dist: faiss-cpu
+Requires-Dist: praat-parselmouth
+Requires-Dist: pyworld
+Requires-Dist: torchcrepe
+Requires-Dist: fairseq
+Requires-Dist: gradio
+Requires-Dist: pyngrok
+Requires-Dist: psutil
+
+# Leo Studio Pro — Remote Worker
+
+Remote Worker package for offloading RVC voice conversion, dataset prep, and training to remote GPU servers (Google Colab, Kaggle, RunPod, Vast.ai, Linux VPS).
+
+## Quick Start
+
+```bash
+# Install
+pip install leostudio
+
+# Run
+leostudio --secret Your_secure_token --raytunnel-server your-server.domain.com --raytunnel-token Your_secure_token --raytunnel-subdomain rvc
+```

leostudio-0.1.0/README.md

@@ -0,0 +1,13 @@
+# Leo Studio Pro — Remote Worker
+
+Remote Worker package for offloading RVC voice conversion, dataset prep, and training to remote GPU servers (Google Colab, Kaggle, RunPod, Vast.ai, Linux VPS).
+
+## Quick Start
+
+```bash
+# Install
+pip install leostudio
+
+# Run
+leostudio --secret Your_secure_token --raytunnel-server your-server.domain.com --raytunnel-token Your_secure_token --raytunnel-subdomain rvc
+```

leostudio-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "leostudio"
+version = "0.1.0"
+description = "Leo Studio Pro — Remote Worker Backend for GPU Inference & Training for LeoStudio Pro"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [
+    {name = "Leo Studio Pro", email = "admin@ray.ac"}
+]
+
+dependencies = [
+    "fastapi",
+    "uvicorn[standard]",
+    "python-socketio",
+    "aiohttp",
+    "aiofiles",
+    "python-multipart",
+    "soundfile",
+    "librosa",
+    "ffmpeg-python",
+    "av",
+    "numpy",
+    "scipy",
+    "tqdm",
+    "faiss-cpu",
+    "praat-parselmouth",
+    "pyworld",
+    "torchcrepe",
+    "fairseq",
+    "gradio",
+    "pyngrok",
+    "psutil",
+]
+
+[project.scripts]
+leostudio = "leostudio.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+leostudio = ["rvc/configs/*.json", "rvc/configs/**/*.json"]

leostudio-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

leostudio-0.1.0/src/leostudio/__init__.py

@@ -0,0 +1,7 @@
+"""
+Leo Studio Pro — Remote Worker Library
+"""
+
+from leostudio.cli import main as start_worker
+
+__all__ = ["start_worker"]

leostudio-0.1.0/src/leostudio/__main__.py

@@ -0,0 +1,8 @@
+"""
+Enable `python -m leostudio`
+"""
+
+from leostudio.cli import main
+
+if __name__ == "__main__":
+    main()

leostudio-0.1.0/src/leostudio/cli.py

@@ -0,0 +1,111 @@
+"""
+Leo Studio Pro — Remote Worker CLI Entrypoint
+==============================================
+
+Usage:
+  leostudio --secret Your_secure_token --raytunnel-server s.ray.ac --raytunnel-token Your_secure_token --raytunnel-subdomain rvc
+"""
+
+import argparse
+import os
+import sys
+
+from leostudio.setup_helper import (
+    ensure_asset_models,
+    get_bundled_rvc_dir,
+    patch_fairseq_if_needed,
+)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="leostudio",
+        description="Leo Studio Pro Remote Worker Backend (PyPI Standalone)",
+    )
+    parser.add_argument("--secret", type=str, default="", help="WORKER_SECRET token for authentication")
+    parser.add_argument("--port", type=int, default=7866, help="Port to listen on (default: 7866)")
+    parser.add_argument("--host", type=str, default="0.0.0.0", help="Host address (default: 0.0.0.0)")
+    parser.add_argument("--max-cache", type=str, default="10", help="MAX_CACHE_GB for model caching")
+    parser.add_argument("--raytunnel-server", type=str, default="", help="Raytunnel server address (e.g. s.ray.ac)")
+    parser.add_argument("--raytunnel-token", type=str, default="", help="Raytunnel auth token")
+    parser.add_argument("--raytunnel-subdomain", type=str, default="", help="Raytunnel subdomain")
+    parser.add_argument("--ngrok-token", type=str, default="", help="Ngrok authtoken")
+    parser.add_argument("--gradio", action="store_true", help="Enable Gradio share tunnel")
+    parser.add_argument("--skip-audio-separator", action="store_true", help="Skip audio separator installation")
+
+    args = parser.parse_args()
+
+    # Determine work directory
+    if os.path.isdir("/kaggle/working"):
+        work_dir = "/kaggle/working"
+    elif os.path.isdir("/content"):
+        work_dir = "/content"
+    else:
+        work_dir = os.getcwd()
+
+    if os.getcwd() != work_dir:
+        try:
+            os.chdir(work_dir)
+        except OSError:
+            pass
+
+    print("╔══════════════════════════════════════════════════════════════╗")
+    print("║       Leo Studio Pro — Remote Worker CLI Launcher            ║")
+    print("╚══════════════════════════════════════════════════════════════╝")
+    print(f"  Working Directory : {work_dir}")
+    print(f"  Port              : {args.port}")
+    print(f"  Secret            : {'***' if args.secret else '(none)'}")
+    print(f"  Max Cache GB      : {args.max_cache}")
+    if args.raytunnel_server:
+        print(f"  Tunnel            : raytunnel ({args.raytunnel_server})")
+    elif args.ngrok_token:
+        print(f"  Tunnel            : ngrok")
+    elif args.gradio:
+        print(f"  Tunnel            : gradio")
+    print()
+
+    # Get bundled RVC engine directory
+    rvc_dir = get_bundled_rvc_dir()
+    ensure_asset_models(work_dir)
+    patch_fairseq_if_needed()
+
+    # Add rvc_dir to PYTHONPATH and sys.path
+    if rvc_dir not in sys.path:
+        sys.path.insert(0, rvc_dir)
+    current_pp = os.environ.get("PYTHONPATH", "")
+    if rvc_dir not in current_pp:
+        os.environ["PYTHONPATH"] = f"{rvc_dir}:{current_pp}".rstrip(":")
+
+    # Add package directory to sys.path so leostudio modules can be imported smoothly
+    pkg_dir = os.path.abspath(os.path.dirname(__file__))
+    if pkg_dir not in sys.path:
+        sys.path.insert(0, pkg_dir)
+
+    # Set environment variables for server
+    os.environ["PORT"] = str(args.port)
+    os.environ["MAX_CACHE_GB"] = str(args.max_cache)
+    if args.secret:
+        os.environ["WORKER_SECRET"] = args.secret
+    if args.raytunnel_server:
+        os.environ["RAYTUNNEL_SERVER"] = args.raytunnel_server
+        os.environ["RAYTUNNEL_TOKEN"] = args.raytunnel_token
+        if args.raytunnel_subdomain:
+            os.environ["RAYTUNNEL_SUBDOMAIN"] = args.raytunnel_subdomain
+    if args.ngrok_token:
+        os.environ["NGROK_TOKEN"] = args.ngrok_token
+    if args.gradio:
+        os.environ["GRADIO_TUNNEL"] = "1"
+    if args.skip_audio_separator:
+        os.environ["SKIP_AUDIO_SEPARATOR"] = "true"
+
+    # Launch server from leostudio package
+    try:
+        from leostudio import server
+        server.main()
+    except (ImportError, AttributeError):
+        import server
+        server.main()
+
+
+if __name__ == "__main__":
+    main()

leostudio-0.1.0/src/leostudio/file_cache.py

@@ -0,0 +1,243 @@
+"""
+Leo Studio Pro — Remote Worker File Cache
+==========================================
+SHA-256 keyed LRU cache for uploaded model files.
+
+Usage:
+    from file_cache import init_cache, resolve_model_file, get_cache_stats
+
+    # Call once at startup (e.g., from server.py):
+    init_cache(models_dir="/path/to/models", max_cache_gb=4.0)
+
+    # In an endpoint:
+    path = await resolve_model_file(upload_file, model_hash)
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import aiofiles
+
+if TYPE_CHECKING:
+    from fastapi import UploadFile
+
+logger = logging.getLogger("remote_worker.file_cache")
+
+# ---------------------------------------------------------------------------
+# Module-level state — overridden by init_cache()
+# ---------------------------------------------------------------------------
+
+_cache_dir: Path = Path("models") / "_upload_cache"
+_max_cache_bytes: int = 4 * 1024**3  # 4 GB default
+
+# sha256_hex → local Path
+_model_cache: dict[str, Path] = {}
+
+
+# ---------------------------------------------------------------------------
+# Initialisation
+# ---------------------------------------------------------------------------
+
+
+def init_cache(models_dir: str | Path, max_cache_gb: float) -> None:
+    """Configure the cache directory and size limit.
+
+    Call this once at worker startup before any upload is handled.
+    Thread-safe for read-heavy workloads; writes are serialised by the
+    single-threaded asyncio event loop.
+    """
+    global _cache_dir, _max_cache_bytes  # noqa: PLW0603
+
+    _cache_dir = Path(models_dir) / "_upload_cache"
+    _cache_dir.mkdir(parents=True, exist_ok=True)
+    _max_cache_bytes = int(max_cache_gb * 1024**3)
+
+    logger.info(
+        "File cache initialised: dir=%s  limit=%.2f GB",
+        _cache_dir,
+        max_cache_gb,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Core API
+# ---------------------------------------------------------------------------
+
+
+async def resolve_model_file(upload: "UploadFile", model_hash: str) -> Path:
+    """Return a local Path for *upload*, writing to disk only on cache miss.
+
+    Args:
+        upload: FastAPI ``UploadFile`` object (the file body will be read if
+                there is a cache miss).
+        model_hash: SHA-256 hex digest of the file, supplied by the caller.
+                    If empty / falsy the file is always written fresh (no
+                    caching).
+
+    Returns:
+        Absolute ``Path`` to the locally cached file.
+    """
+    # ---- Cache hit -------------------------------------------------------
+    if model_hash and model_hash in _model_cache:
+        cached_path = _model_cache[model_hash]
+        if cached_path.exists():
+            _touch_lru(model_hash)
+            logger.debug("Cache hit: hash=%s path=%s", model_hash[:12], cached_path)
+            return cached_path
+        # File was deleted externally — remove stale entry and fall through
+        logger.warning("Stale cache entry removed: hash=%s path=%s", model_hash[:12], cached_path)
+        del _model_cache[model_hash]
+
+    # ---- Cache miss — write to disk -------------------------------------
+    _cache_dir.mkdir(parents=True, exist_ok=True)
+
+    filename = upload.filename or "unknown"
+    if model_hash:
+        dest = _cache_dir / f"{model_hash}_{filename}"
+    else:
+        # No hash supplied — use timestamp to avoid collisions
+        dest = _cache_dir / f"nohash_{int(time.time() * 1000)}_{filename}"
+
+    data = await upload.read()
+    async with aiofiles.open(dest, "wb") as f:
+        await f.write(data)
+
+    logger.info(
+        "Cache miss — written: hash=%s  size=%d bytes  path=%s",
+        (model_hash[:12] if model_hash else "N/A"),
+        len(data),
+        dest,
+    )
+
+    if model_hash:
+        _model_cache[model_hash] = dest
+
+    _evict_if_needed()
+    return dest
+
+
+# ---------------------------------------------------------------------------
+# LRU helpers
+# ---------------------------------------------------------------------------
+
+
+def _touch_lru(model_hash: str) -> None:
+    """Update the mtime of the cached file to mark it as recently used."""
+    path = _model_cache.get(model_hash)
+    if path and path.exists():
+        now = time.time()
+        try:
+            os.utime(path, (now, now))
+        except OSError as exc:
+            logger.warning("Could not touch LRU file %s: %s", path, exc)
+
+
+def _evict_if_needed() -> None:
+    """Remove least-recently-used cache files until total size ≤ limit.
+
+    Ordering is determined by ``os.path.getmtime`` (oldest = LRU).
+    Only files whose hash is tracked in ``_model_cache`` are candidates
+    for eviction; untracked files in the directory are left untouched.
+    """
+    if not _model_cache:
+        return
+
+    # Build list of (mtime, hash, path) for tracked files that exist
+    entries: list[tuple[float, str, Path]] = []
+    for h, p in list(_model_cache.items()):
+        if p.exists():
+            try:
+                mtime = os.path.getmtime(p)
+            except OSError:
+                mtime = 0.0
+            entries.append((mtime, h, p))
+
+    # Sort oldest-first (LRU at front)
+    entries.sort(key=lambda e: e[0])
+
+    total_bytes = sum(p.stat().st_size for _, _, p in entries if p.exists())
+
+    if total_bytes <= _max_cache_bytes:
+        return
+
+    logger.info(
+        "Cache eviction triggered: total=%.2f GB  limit=%.2f GB",
+        total_bytes / 1024**3,
+        _max_cache_bytes / 1024**3,
+    )
+
+    for mtime, h, p in entries:
+        if total_bytes <= _max_cache_bytes:
+            break
+        try:
+            file_size = p.stat().st_size
+            p.unlink()
+            del _model_cache[h]
+            total_bytes -= file_size
+            logger.info(
+                "Evicted (LRU): hash=%s  size=%d bytes  mtime=%s",
+                h[:12],
+                file_size,
+                time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(mtime)),
+            )
+        except OSError as exc:
+            logger.warning("Could not evict %s: %s", p, exc)
+
+
+# ---------------------------------------------------------------------------
+# Stats
+# ---------------------------------------------------------------------------
+
+
+def get_cache_stats() -> dict:
+    """Return a snapshot of cache state for logging / health endpoints.
+
+    Returns:
+        dict with keys:
+            ``num_entries``   — number of tracked cache entries
+            ``total_bytes``   — combined size of all tracked files on disk
+            ``total_gb``      — same in gigabytes (float, 4 dp)
+            ``max_bytes``     — configured limit
+            ``max_gb``        — configured limit in gigabytes
+            ``cache_dir``     — absolute path to cache directory (str)
+            ``entries``       — list of {hash_prefix, filename, size_bytes,
+                                last_used} sorted newest-first
+    """
+    entries_detail: list[dict] = []
+    total_bytes = 0
+
+    for h, p in list(_model_cache.items()):
+        if p.exists():
+            try:
+                size = p.stat().st_size
+                mtime = os.path.getmtime(p)
+            except OSError:
+                size = 0
+                mtime = 0.0
+            total_bytes += size
+            entries_detail.append(
+                {
+                    "hash_prefix": h[:16],
+                    "filename": p.name,
+                    "size_bytes": size,
+                    "last_used": time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime(mtime)),
+                }
+            )
+
+    # Sort newest-first for readability
+    entries_detail.sort(key=lambda e: e["last_used"], reverse=True)
+
+    return {
+        "num_entries": len(entries_detail),
+        "total_bytes": total_bytes,
+        "total_gb": round(total_bytes / 1024**3, 4),
+        "max_bytes": _max_cache_bytes,
+        "max_gb": round(_max_cache_bytes / 1024**3, 4),
+        "cache_dir": str(_cache_dir),
+        "entries": entries_detail,
+    }

leostudio-0.1.0/src/leostudio/rvc/configs/config.json

@@ -0,0 +1 @@
+{"pth_path": "assets/weights/kikiV1.pth", "index_path": "logs/kikiV1.index", "sg_hostapi": "MME", "sg_wasapi_exclusive": false, "sg_input_device": "VoiceMeeter Output (VB-Audio Vo", "sg_output_device": "VoiceMeeter Input (VB-Audio Voi", "sr_type": "sr_device", "threhold": -60.0, "pitch": 12.0, "formant": 0.0, "rms_mix_rate": 0.5, "index_rate": 0.0, "block_time": 0.15, "crossfade_length": 0.08, "extra_time": 2.0, "n_cpu": 4.0, "use_jit": false, "use_pv": false, "f0method": "fcpe"}