lightning-pose-app 1.8.1a3__py3-none-any.whl → 1.8.1a5__py3-none-any.whl

litpose_app/{super_rglob.py → routes/files.py}

@@ -1,48 +1,108 @@
-import datetime
-
-from wcmatch import pathlib as w
-
-
-def super_rglob(base_path, pattern=None, no_dirs=False, stat=False):
-    """
-    Needs to be performant when searching over large model directory.
-    Uses wcmatch to exclude directories with extra calls to Path.is_dir.
-    wcmatch includes features that may be helpful down the line.
-    """
-    if pattern is None:
-        pattern = "**/*"
-    flags = w.GLOBSTAR
-    if no_dirs:
-        flags |= w.NODIR
-    results = w.Path(base_path).glob(
-        pattern,
-        flags=flags,
-    )
-    result_dicts = []
-    for r in results:
-        stat_info = r.stat() if stat else None
-        is_dir = False if no_dirs else r.is_dir() if stat else None
-        if no_dirs and is_dir:
-            continue
-        entry_relative_path = r.relative_to(base_path)
-        d = {
-            "path": entry_relative_path,
-            "type": "dir" if is_dir else "file" if is_dir == False else None,
-            "size": stat_info.st_size if stat_info else None,
-            # Note: st_birthtime is more reliable for creation time on some systems
-            "cTime": (
-                datetime.datetime.fromtimestamp(
-                    getattr(stat_info, "st_birthtime", stat_info.st_ctime)
-                ).isoformat()
-                if stat_info
-                else None
-            ),
-            "mTime": (
-                datetime.datetime.fromtimestamp(stat_info.st_mtime).isoformat()
-                if stat_info
-                else None
-            ),
-        }
-
-        result_dicts.append(d)
-    return result_dicts
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException, status
+from pydantic import BaseModel
+
+router = APIRouter()
+
+
+class RGlobRequest(BaseModel):
+    baseDir: Path
+    pattern: str
+    noDirs: bool = False
+    stat: bool = False
+
+
+class RGlobResponseEntry(BaseModel):
+    path: Path
+
+    # Present only if request had stat=True or noDirs=True
+    type: str | None
+
+    # Present only if request had stat=True
+
+    size: int | None
+    # Creation timestamp, ISO format.
+    cTime: str | None
+    # Modified timestamp, ISO format.
+    mTime: str | None
+
+
+class RGlobResponse(BaseModel):
+    entries: list[RGlobResponseEntry]
+    relativeTo: Path  # this is going to be the same base_dir that was in the request.
+
+
+@router.post("/app/v0/rpc/rglob")
+def rglob(request: RGlobRequest) -> RGlobResponse:
+    # Prevent secrets like /etc/passwd and ~/.ssh/ from being leaked.
+    if not (request.pattern.endswith(".csv") or request.pattern.endswith(".mp4")):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only csv and mp4 files are supported.",
+        )
+
+    response = RGlobResponse(entries=[], relativeTo=request.baseDir)
+
+    results = super_rglob(
+        str(request.baseDir),
+        pattern=request.pattern,
+        no_dirs=request.noDirs,
+        stat=request.stat,
+    )
+    for r in results:
+        # Convert dict to pydantic model
+        converted = RGlobResponseEntry.model_validate(r)
+        response.entries.append(converted)
+
+    return response
+
+
+import datetime
+
+from wcmatch import pathlib as w
+
+
+def super_rglob(base_path, pattern=None, no_dirs=False, stat=False):
+    """
+    Needs to be performant when searching over large model directory.
+    Uses wcmatch to exclude directories with extra calls to Path.is_dir.
+    wcmatch includes features that may be helpful down the line.
+    """
+    if pattern is None:
+        pattern = "**/*"
+    flags = w.GLOBSTAR
+    if no_dirs:
+        flags |= w.NODIR
+    results = w.Path(base_path).glob(
+        pattern,
+        flags=flags,
+    )
+    result_dicts = []
+    for r in results:
+        stat_info = r.stat() if stat else None
+        is_dir = False if no_dirs else r.is_dir() if stat else None
+        if no_dirs and is_dir:
+            continue
+        entry_relative_path = r.relative_to(base_path)
+        d = {
+            "path": entry_relative_path,
+            "type": "dir" if is_dir else "file" if is_dir == False else None,
+            "size": stat_info.st_size if stat_info else None,
+            # Note: st_birthtime is more reliable for creation time on some systems
+            "cTime": (
+                datetime.datetime.fromtimestamp(
+                    getattr(stat_info, "st_birthtime", stat_info.st_ctime)
+                ).isoformat()
+                if stat_info
+                else None
+            ),
+            "mTime": (
+                datetime.datetime.fromtimestamp(stat_info.st_mtime).isoformat()
+                if stat_info
+                else None
+            ),
+        }
+
+        result_dicts.append(d)
+    return result_dicts

litpose_app/routes/project.py

@@ -0,0 +1,72 @@
+import logging
+from pathlib import Path
+
+import tomli
+import tomli_w
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from litpose_app import deps
+from litpose_app.config import Config
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+class ProjectInfo(BaseModel):
+    """Class to hold information about the project"""
+
+    data_dir: Path | None = None
+    model_dir: Path | None = None
+    views: list[str] | None = None
+
+
+class GetProjectInfoResponse(BaseModel):
+    projectInfo: ProjectInfo | None  # None if project info not yet initialized
+
+
+class SetProjectInfoRequest(BaseModel):
+    projectInfo: ProjectInfo
+
+
+@router.post("/app/v0/rpc/getProjectInfo")
+def get_project_info(
+    project_info: ProjectInfo = Depends(deps.project_info),
+) -> GetProjectInfoResponse:
+    return GetProjectInfoResponse(projectInfo=project_info)
+
+
+@router.post("/app/v0/rpc/setProjectInfo")
+def set_project_info(
+    request: SetProjectInfoRequest, config: Config = Depends(deps.config)
+) -> None:
+    try:
+        config.PROJECT_INFO_TOML_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+        project_data_dict = request.projectInfo.model_dump(
+            mode="json", exclude_none=True
+        )
+        try:
+            with open(config.PROJECT_INFO_TOML_PATH, "rb") as f:
+                existing_project_data = tomli.load(f)
+        except FileNotFoundError:
+            existing_project_data = {}
+
+        existing_project_data.update(project_data_dict)
+
+        with open(config.PROJECT_INFO_TOML_PATH, "wb") as f:
+            tomli_w.dump(existing_project_data, f)
+
+        return None
+
+    except IOError as e:
+        error_message = f"Failed to write project information to file: {str(e)}"
+        print(error_message)
+        raise e
+    except Exception as e:
+        error_message = (
+            f"An unexpected error occurred while saving project info: {str(e)}"
+        )
+        print(error_message)
+        raise e

litpose_app/routes/transcode.py

@@ -0,0 +1,131 @@
+import asyncio
+import json
+from typing import AsyncGenerator
+
+import reactivex
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from fastapi import APIRouter, Depends, Request
+from fastapi.responses import StreamingResponse
+from reactivex import Observable
+import reactivex.operators
+
+from .files import super_rglob
+from .project import ProjectInfo
+from .. import deps
+from ..tasks import transcode_fine
+import logging
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+from litpose_app.config import Config
+
+
+@router.post("/app/v0/rpc/getFineVideoDir")
+def get_fine_video_dir(config: Config = Depends(deps.config)):
+    return {"path": config.FINE_VIDEO_DIR}
+
+
+@router.get("/app/v0/rpc/getFineVideoStatus")
+async def get_fine_video_status(request: Request) -> StreamingResponse:
+    """
+    Returns number of pending transcode tasks.
+    """
+    subject: reactivex.Subject = request.app.state.num_active_transcode_tasks
+    wrapped = subject.pipe(reactivex.operators.map(lambda x: {"pending": x}))
+    return await sse_events(request, wrapped)
+
+
+@router.post("/app/v0/rpc/enqueueAllNewFineVideos")
+async def enqueue_all_new_fine_videos(
+    config: Config = Depends(deps.config),
+    project_info: ProjectInfo = Depends(deps.project_info),
+    scheduler: AsyncIOScheduler = Depends(deps.scheduler),
+):
+    # get all mp4 video files that are less than config.AUTO_TRANSCODE_VIDEO_SIZE_LIMIT_MB
+    base_path = project_info.data_dir
+    result = await asyncio.to_thread(
+        super_rglob, base_path, pattern="**/*.mp4", stat=True
+    )
+
+    # Filter videos by size limit
+    videos = [
+        base_path / entry["path"]
+        for entry in result
+        if entry["size"]
+        and entry["size"] < config.AUTO_TRANSCODE_VIDEO_SIZE_LIMIT_MB * 1000 * 1000
+    ]
+
+    # Create a transcode job per video.
+    # The id of the job is just the filename. We assume unique video filenames
+    # across the entire dataset.
+    for path in videos:
+        scheduler.add_job(
+            transcode_fine.transcode_video_task,
+            id=path.name,
+            args=[path, config.FINE_VIDEO_DIR / path.name],
+            executor="transcode_pool",
+            # executor="debug",
+            replace_existing=True,
+            misfire_grace_time=None,
+        )
+
+    return "ok"
+
+
+async def sse_events(request: Request, source: Observable) -> StreamingResponse:
+    # An asyncio.Queue will act as a bridge between the synchronous world of
+    # the RxPy observable and the async world of the FastAPI response.
+    queue = asyncio.Queue()
+
+    # The scheduler ensures that the observable runs on the asyncio event loop,
+    # which is necessary for it to work correctly with FastAPI.
+    scheduler = AsyncIOScheduler()
+
+    async def event_generator() -> AsyncGenerator[str, None]:
+        """
+        This async generator function is the core of the SSE streaming.
+        It listens for items on the queue and yields them in the SSE format.
+        """
+        disposable = None
+        try:
+            # Subscribe to the observable.
+            # For each item emitted by the observable (`on_next`), we put it
+            # into our asyncio queue.
+            # If the observable completes (`on_completed`) or errors (`on_error`),
+            # we put a special sentinel value (None) in the queue to signal the end.
+            disposable = source.subscribe(
+                on_next=lambda item: queue.put_nowait(item),
+                on_error=lambda e: queue.put_nowait(None),
+                on_completed=lambda: queue.put_nowait(None),
+                scheduler=scheduler,
+            )
+
+            while True:
+                # Check if the client has disconnected.
+                if await request.is_disconnected():
+                    logger.debug("Client disconnected.")
+                    break
+
+                # Wait for an item to appear on the queue.
+                item = await queue.get()
+
+                # If the item is our sentinel value, it means the observable
+                # has finished, and we can stop streaming.
+                if item is None:
+                    break
+
+                # Yield the data in the Server-Sent Event format.
+                # The format is "data: {your_message}\n\n"
+                yield f"data: {json.dumps(item)}\n\n"
+
+        finally:
+            # This block is crucial for cleanup. It runs when the client
+            # disconnects or the stream is otherwise closed.
+            # We dispose of the subscription to the observable, which stops
+            # the interval and prevents memory leaks.
+            if disposable:
+                disposable.dispose()
+                logger.debug("Observable subscription disposed.")
+            logger.debug("Event generator finished.")
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")

litpose_app/tasks/management.py

@@ -0,0 +1,20 @@
+import reactivex
+import reactivex.subject
+from apscheduler import events as e
+from apscheduler.schedulers.base import BaseScheduler
+from fastapi import FastAPI
+
+
+def setup_active_task_registry(app: FastAPI):
+    # Get APScheduler instance
+    scheduler: BaseScheduler = app.state.scheduler
+
+    subject = reactivex.subject.BehaviorSubject(len(scheduler.get_jobs()))
+
+    app.state.num_active_transcode_tasks = subject
+
+    def my_listener(event):
+        jobs = scheduler.get_jobs()
+        subject.on_next(len(jobs))
+
+    scheduler.add_listener(my_listener, e.EVENT_JOB_ADDED | e.EVENT_JOB_REMOVED)

litpose_app/tasks/transcode_fine.py

@@ -0,0 +1,7 @@
+from pathlib import Path
+
+from litpose_app.transcode_fine import transcode_file
+
+
+def transcode_video_task(input_file_path: Path, output_file_path: Path):
+    transcode_file(input_file_path, output_file_path)

litpose_app/transcode_fine.py

@@ -0,0 +1,173 @@
+import shutil
+import subprocess
+from multiprocessing import Pool, cpu_count
+from pathlib import Path
+
+# --- Configuration ---
+TARGET_SUFFIX = "sec.mp4"
+OUTPUT_SUFFIX_ADDITION = ".fine"
+MAX_CONCURRENCY = 6
+# FFmpeg options for transcoding:
+# -g 1: Intra frame for every frame (Group of Pictures size 1)
+# -c:v libx264: Use libx264 encoder
+# -preset medium: A balance between encoding speed and compression.
+#                 Options: ultrafast, superfast, veryfast, faster, fast, medium, slow, slower, veryslow.
+# -crf 23: Constant Rate Factor. Lower values mean better quality and larger files (0-51, default 23).
+# -c:a copy: Copy audio stream without re-encoding. If audio re-encoding is needed, change this.
+# -y: Overwrite output files without asking.
+FFMPEG_OPTIONS = [
+    "-c:v",
+    "libx264",
+    "-g",
+    "1",
+    "-preset",
+    "medium",
+    "-crf",
+    "23",
+    "-c:a",
+    "copy",
+]
+
+
+def check_dependencies():
+    """Checks if ffmpeg and ffprobe are installed and in PATH."""
+    if shutil.which("ffmpeg") is None:
+        print("Error: ffmpeg is not installed or not found in PATH.")
+        return False
+    if shutil.which("ffprobe") is None:
+        print("Error: ffprobe is not installed or not found in PATH.")
+        return False
+    return True
+
+
+def transcode_file(
+    input_file_path: Path,
+    output_file_path: Path,
+) -> tuple[bool, str, Path | None]:
+    """
+    Transcodes a single video file to have an intra frame for every frame.
+    The output file will be named by inserting ".fine" before the final ".mp4"
+    and placed in the specified output_dir.
+    Example: "video.sec.mp4" -> "video.sec.fine.mp4"
+    Returns a tuple: (success_status: bool, message: str, output_path: Path | None)
+    """
+    try:
+
+        if output_file_path.exists():
+            print(
+                f"Output file '{output_file_path.name}' already exists. Skipping transcoding."
+            )
+            return True, f"Skipped (exists): {output_file_path.name}", output_file_path
+
+        print(f"Processing: {input_file_path.name} -> {output_file_path.name}")
+        output_file_path.parent.mkdir(parents=True, exist_ok=True)
+        ffmpeg_cmd = [
+            "ffmpeg",
+            "-i",
+            str(input_file_path),
+            *FFMPEG_OPTIONS,
+            "-y",  # Overwrite output without asking (though we check existence above)
+            str(output_file_path),
+        ]
+
+        process = subprocess.Popen(
+            ffmpeg_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+        )
+
+        stdout, stderr = process.communicate()
+
+        if process.returncode == 0:
+            print(f"Successfully transcoded: {output_file_path.name}")
+            return True, f"Success: {output_file_path.name}", output_file_path
+        else:
+            print(f"Error transcoding '{input_file_path.name}':")
+            print(f"FFmpeg stdout:\n{stdout}")
+            print(f"FFmpeg stderr:\n{stderr}")
+            # Clean up partially created file on error
+            if output_file_path.exists():
+                try:
+                    output_file_path.unlink()
+                except OSError as e:
+                    print(
+                        f"Could not remove partially created file '{output_file_path}': {e}"
+                    )
+            return (
+                False,
+                f"Error: {input_file_path.name} - FFmpeg failed (code {process.returncode})",
+                None,
+            )
+
+    except Exception as e:
+        print(f"Error processing '{input_file_path.name}': {e}")
+        return False, f"Error: {input_file_path.name} - Exception: {e}", None
+
+
+def main():
+    """
+    Main function to find and transcode videos.
+    """
+    if not check_dependencies():
+        return
+
+    script_dir = Path(__file__).parent  # Process files in the script's directory
+    # To process files in the current working directory instead:
+    # current_dir = Path.cwd()
+
+    print(
+        f"Scanning for '*{TARGET_SUFFIX}' H.264 files in '{script_dir}' and its subdirectories..."
+    )
+
+    # Find all files ending with TARGET_SUFFIX recursively
+    files_to_check = list(script_dir.rglob(f"*{TARGET_SUFFIX}"))
+
+    if not files_to_check:
+        print(f"No files found ending with '{TARGET_SUFFIX}'.")
+        return
+
+    print(f"Found {len(files_to_check)} potential files. Checking H.264 codec...")
+
+    valid_files_to_transcode = []
+    for f_path in files_to_check:
+        # Ensure it's not an already processed file
+        if OUTPUT_SUFFIX_ADDITION + ".mp4" in f_path.name:
+            continue
+        valid_files_to_transcode.append(f_path)
+
+    if not valid_files_to_transcode:
+        print("No H.264 files matching the criteria need transcoding.")
+        return
+
+    print(f"\nFound {len(valid_files_to_transcode)} H.264 files to transcode:")
+    for f in valid_files_to_transcode:
+        print(f"  - {f.name}")
+
+    # Determine number of processes
+    num_processes = min(MAX_CONCURRENCY, cpu_count(), len(valid_files_to_transcode))
+    print(f"\nStarting transcoding with up to {num_processes} parallel processes...\n")
+
+    output_file_paths = []
+    for f in valid_files_to_transcode:
+        base_name = f.name[: -len(TARGET_SUFFIX)]
+        output_file_name = f"{base_name}{TARGET_SUFFIX.replace('.mp4', '')}{OUTPUT_SUFFIX_ADDITION}.mp4"
+        output_file_path = f.parent / output_file_name
+        output_file_paths.append(output_file_path)
+    # In this main function, output_dir is still the parent of the input file
+    # For RPC, we will specify FINE_VIDEO_DIR as output_dir
+    with Pool(processes=num_processes) as pool:
+        # A dummy output_dir for the script's main function; not used by RPC.
+        # It ensures compatibility if this script were run standalone.
+        # In the RPC, we'll pass FINE_VIDEO_DIR explicitly.
+        results = pool.starmap(
+            transcode_file,
+            [(f, of) for f, of in zip(valid_files_to_transcode, output_file_paths)],
+        )
+
+    print("\n--- Transcoding Summary ---")
+    for result in results:
+        print(result)
+    print("--------------------------")
+    print("All tasks completed.")
+
+
+if __name__ == "__main__":
+    main()

lightning_pose_app-1.8.1a3.dist-info/METADATA

@@ -1,15 +0,0 @@
-Metadata-Version: 2.3
-Name: lightning-pose-app
-Version: 1.8.1a3
-Summary: 
-Requires-Python: >=3.10
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: fastapi
-Requires-Dist: tomli
-Requires-Dist: tomli_w
-Requires-Dist: uvicorn[standard]
-Requires-Dist: wcmatch

lightning_pose_app-1.8.1a3.dist-info/RECORD

@@ -1,21 +0,0 @@
-litpose_app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-litpose_app/main.py,sha256=ZjD5i_zUVbSxsHPEn6J2TEtPTCEAdtqP5_-DndakixY,10037
-litpose_app/ngdist/ng_app/3rdpartylicenses.txt,sha256=k34Q8jZikvFWsgFXPlQxFJVcqMXDEiKKzC_VIEK8jNs,25366
-litpose_app/ngdist/ng_app/app.component-UHVEDPZR.css.map,sha256=e6lXWzmK3xppKK3tXHUccK1yGZqd1kzyTpDH0F1nC2g,344
-litpose_app/ngdist/ng_app/error-dialog.component-HYLQSJEP.css.map,sha256=zJuF-LfB994Y1IrnIz38mariDFb8yucffbWPXgHGbvw,355
-litpose_app/ngdist/ng_app/favicon.ico,sha256=QtbXVfx3HI-WqWh_kkBIQyYzJsDmLw_3Y4_UN7pBepE,15406
-litpose_app/ngdist/ng_app/index.html,sha256=ATacgBvjlF3gLRzFCtDnS3shRzTOp8Rzu4rKfltBDOQ,22954
-litpose_app/ngdist/ng_app/main-LJHMLKBL.js,sha256=nXrPvnVQwhHQJdHMsF-41nu5Mu7K6WARxWSei2g0y58,2722143
-litpose_app/ngdist/ng_app/main-LJHMLKBL.js.map,sha256=ltcuu1XsSXJv0p_KjbUSPBKi9zyAy4sVQXmJxZWNkos,5557811
-litpose_app/ngdist/ng_app/prerendered-routes.json,sha256=p53cyKEVGQ6cGUee02kUdBp9HbdPChFTUp78gHJVBf4,18
-litpose_app/ngdist/ng_app/project-settings.component-5IRK7U7U.css.map,sha256=v5tyba9p8ec3ZbHYyyUGTEFdEAsqT0l7JqtGRGjki6w,371
-litpose_app/ngdist/ng_app/styles-4V6RXJMC.css,sha256=mZ4r-BPkV1KTv3FvvjCJWuUygILiOzl8Jzjesyo0P8U,69300
-litpose_app/ngdist/ng_app/styles-4V6RXJMC.css.map,sha256=Fm7m4Uakz0HLL1DMEyfCAAXoFia46_3Eab27wowU9tU,74911
-litpose_app/ngdist/ng_app/video-player-controls.component-C4JZHYJ2.css.map,sha256=vX-dgeDCUCPLiea4Qy9O_EBm6IzzwB7R_uSBa0qU5Go,771
-litpose_app/ngdist/ng_app/video-tile.component-XSYKMARQ.css.map,sha256=_pZ7FxqOAu535JfrRv1TSKgRpDyQvn9Q0U39KHyJ980,332
-litpose_app/ngdist/ng_app/viewer-page.component-MRTIUFL2.css.map,sha256=Uf1FgoCiF_qJpD4Ggk34Dq7kM73Q7i7NT6h3m30tbaY,211
-litpose_app/run_ffprobe.py,sha256=7acBcSJ-3t8N_6HZ2KrTrMkivPsxKlGuYzI6yNhaXEs,4975
-litpose_app/super_rglob.py,sha256=kgSIra2xznEHhi9kBUzO0SpBb6PkUJCct0WSS33bRmM,1619
-lightning_pose_app-1.8.1a3.dist-info/METADATA,sha256=2JCRkaIImYE4r6Y-UcBvGGe7tkRfXlGH2X2PlrMih7A,473
-lightning_pose_app-1.8.1a3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-lightning_pose_app-1.8.1a3.dist-info/RECORD,,