rp 0.1.1385__tar.gz → 0.1.1387__tar.gz

{rp-0.1.1385 → rp-0.1.1387}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: rp
-Version: 0.1.1385
+Version: 0.1.1387
 Summary: Ryan's Python: IDE + Library + Tools
 Home-page: https://github.com/RyannDaGreat/rp
 Author: Ryan Burgert

{rp-0.1.1385 → rp-0.1.1387}/rp/libs/powerpoint/media_to_slides.py

@@ -140,6 +140,39 @@ def is_media_path(x) -> bool:
     return ext in IMAGE_EXTENSIONS or ext in VIDEO_EXTENSIONS
 
 
+def _parse_labeled_dict(d: dict) -> tuple[list, list]:
+    """Parse {label: path} dict. Returns (paths, labels) or raises if backwards."""
+    labels = []
+    paths = []
+    for label, path in d.items():
+        if is_media_path(path):
+            labels.append(label)
+            paths.append(path)
+    if not paths and d:
+        first_key = next(iter(d.keys()))
+        if is_media_path(first_key):
+            raise ValueError(
+                f"Dict has paths as keys, but expected {{label: path}}. "
+                f"Got {{{repr(first_key)}: ...}}. Flip your dict."
+            )
+    return paths, labels
+
+
+def _parse_content(content, title=None) -> dict | None:
+    """Parse content into a slide dict, or None if no valid paths."""
+    if is_media_path(content):
+        return {"paths": [content], "title": title, "labels": None}
+    if isinstance(content, dict):
+        paths, labels = _parse_labeled_dict(content)
+        if paths:
+            return {"paths": paths, "title": title, "labels": labels}
+    elif rp.is_non_str_iterable(content):
+        paths = [p for p in content if is_media_path(p)]
+        if paths:
+            return {"paths": paths, "title": title, "labels": None}
+    return None
+
+
 def normalize_slides_input(layout) -> list[dict]:
     """
     Normalize flexible input formats into list of slide dicts.
@@ -153,58 +186,22 @@ def normalize_slides_input(layout) -> list[dict]:
         - Dict with nested labels: {'Slide 1': {'vid': 'a.mp4', 'img': 'b.png'}}
         - Single path: 'a.mp4'
     """
-    # Single path
     if is_media_path(layout):
         return [{"paths": [layout], "title": None, "labels": None}]
 
-    # Dict with slide titles
     if isinstance(layout, dict):
         result = []
         for title, content in layout.items():
-            if is_media_path(content):
-                result.append(
-                    {"paths": [content], "title": title, "labels": None}
-                )
-            elif isinstance(content, dict):
-                # {'label1': 'path1', 'label2': 'path2'}
-                labels = []
-                paths = []
-                for label, path in content.items():
-                    if is_media_path(path):
-                        labels.append(label)
-                        paths.append(path)
-                if paths:
-                    result.append(
-                        {"paths": paths, "title": title, "labels": labels}
-                    )
-            elif rp.is_non_str_iterable(content):
-                paths = [p for p in content if is_media_path(p)]
-                if paths:
-                    result.append(
-                        {"paths": paths, "title": title, "labels": None}
-                    )
+            slide = _parse_content(content, title)
+            if slide:
+                result.append(slide)
         return result
 
-    # List input
     result = []
     for item in layout:
-        if isinstance(item, dict):
-            # Dict slide: {'label': 'path', ...}
-            labels = []
-            paths = []
-            for label, path in item.items():
-                if is_media_path(path):
-                    labels.append(label)
-                    paths.append(path)
-            if paths:
-                result.append({"paths": paths, "title": None, "labels": labels})
-        elif rp.is_non_str_iterable(item):
-            paths = [p for p in item if is_media_path(p)]
-            if paths:
-                result.append({"paths": paths, "title": None, "labels": None})
-        elif is_media_path(item):
-            result.append({"paths": [item], "title": None, "labels": None})
-
+        slide = _parse_content(item)
+        if slide:
+            result.append(slide)
     return result
 
 
@@ -278,6 +275,26 @@ def make_file_public(service, file_id: str) -> str:
     return DRIVE_FILE_URL.format(file_id)
 
 
+def _format_eta(done: int, total: int, elapsed: float) -> str:
+    """Format ETA string based on progress and elapsed time."""
+    if done <= 0 or elapsed <= 0:
+        return ""
+    rate = done / elapsed
+    remaining = total - done
+    eta_seconds = remaining / rate
+    return f", ETA: {int(eta_seconds // 60)}m{int(eta_seconds % 60):02d}s"
+
+
+def _format_progress(index: int, total: int, done: int, total_size: int, elapsed: float, use_bytes: bool = True) -> str:
+    """Format overall progress string."""
+    eta = _format_eta(done, total_size, elapsed)
+    if use_bytes:
+        done_str = rp.human_readable_file_size(done)
+        total_str = rp.human_readable_file_size(total_size)
+        return f"[{index}/{total}] {done_str} / {total_str}{eta}"
+    return f"[{index}/{total}]{eta}"
+
+
 def upload_media_sequential(
     service,
     file_paths: list[str],
@@ -285,14 +302,22 @@ def upload_media_sequential(
 ) -> list[dict]:
     """Upload multiple media files sequentially with progress bars."""
     results = []
+    total_bytes = sum(rp.get_file_size(fp) for fp in file_paths)
+    uploaded_bytes = 0
+    start_time = time.time()
 
-    for fp in file_paths:
+    for i, fp in enumerate(file_paths):
         size = rp.get_file_size(fp)
+        elapsed = time.time() - start_time
+        progress_str = _format_progress(i + 1, len(file_paths), uploaded_bytes, total_bytes, elapsed)
+        rp.fansi_print(f"  {progress_str}", "cyan")
+
         pbar = tqdm(
             total=size,
             desc=rp.get_file_name(fp),
             unit="B",
             unit_scale=True,
+            leave=False,
         )
         last_progress = [0]
 
@@ -302,7 +327,9 @@ def upload_media_sequential(
             last_progress[0] = current
 
         result = upload_media(service, fp, folder_id, progress_cb)
+        pbar.update(size - last_progress[0])  # Ensure 100%
         pbar.close()
+        uploaded_bytes += size
         rp.fansi_print(f"  Uploaded: {result['webViewLink']}", "green")
         results.append(result)
 
@@ -687,7 +714,12 @@ def media_to_slides(
                 all_paths.append(path)
 
     if not all_paths:
-        raise ValueError("No media files provided")
+        raise ValueError(
+            f"No media files found in layout. "
+            f"Got {len(slides)} slides but no valid paths. "
+            f"Layout type: {type(layout).__name__}, "
+            f"Input: {repr(layout)[:500]}"
+        )
 
     if folder_name is None:
         folder_name = f"Media_{time.strftime('%Y%m%d_%H%M%S')}"
@@ -718,9 +750,12 @@ def media_to_slides(
     path_to_media = dict(zip(all_paths, media))
 
     rp.fansi_print("\nMaking files publicly accessible...", "cyan")
-    for m in media:
+    start_time = time.time()
+    for i, m in enumerate(media):
+        elapsed = time.time() - start_time
+        progress_str = _format_progress(i + 1, len(media), i, len(media), elapsed, use_bytes=False)
+        rp.fansi_print(f"  {progress_str} {m['name']}", "cyan")
         make_file_public(drive_service, m["id"])
-        rp.fansi_print(f"  {m['name']}: public", "green")
 
     # Build slides_data for create_slides_with_media_grid
     slides_data = []
@@ -868,7 +903,10 @@ def cli(
             media_paths.append(p)
 
     if not media_paths:
-        raise ValueError("No media files found")
+        raise ValueError(
+            f"No media files found. Searched {len(paths)} paths. "
+            f"Supported formats: {', '.join(MEDIA_EXTENSIONS)}"
+        )
 
     # Split into grids if requested
     if per_slide is not None:

{rp-0.1.1385 → rp-0.1.1387}/rp/r.py

@@ -13748,7 +13748,7 @@ def invert_dict(d: dict, bijection=True, precedence='last') -> dict:
         items = list(d.items())
         if precedence=='first':
             items = items[::-1]
-        return {v:k for v,k in items}
+        return {v:k for k,v in items}
     else:
         # {0: 'a', 1: 'a', 2: 'b'} ⟶ {'a': (0,1), 'b': (2,)}
         out={}
@@ -42789,9 +42789,10 @@ def _get_video_file_framerate_via_ffprobe(path, use_cache=True):
     import subprocess
     import json
 
-    if not 'ffprobe' in get_system_commands():    
+    if not 'ffprobe' in get_system_commands():
         _ensure_ffmpeg_installed()
-        raise RuntimeError('rp.get_video_file_framerate: Please install ffmpeg! Unable to find the ffprobe command')
+        if not 'ffprobe' in get_system_commands():
+            raise RuntimeError('rp.get_video_file_framerate: Please install ffmpeg! Unable to find the ffprobe command')
 
     path = get_absolute_path(path)  # Important for caching
     if use_cache and path in _get_video_file_framerate_cache:
@@ -42828,6 +42829,111 @@ def get_video_file_framerate(path, use_cache=True):
     except Exception:
         return _get_video_file_framerate_via_ffprobe(path, use_cache)
 
+_video_has_audio_cache = {}
+
+def video_has_audio(path, use_cache=True, strict=False, include_silent=True):
+    """
+    Check if a video file contains an audio track.
+
+    Uses ffprobe (part of ffmpeg) to detect audio streams. This is fast (~60ms)
+    and does not require loading the entire video into memory. Time is O(1)
+    regardless of video length.
+
+    Args:
+        path (str): Path to the video file
+        use_cache (bool): If True, caches results to avoid repeated ffprobe calls.
+                          Defaults to True.
+        strict (bool): If False, corrupted or invalid video files return False.
+                       If True, raises RuntimeError on ffprobe failure.
+                       Defaults to False.
+        include_silent (bool): If True, returns True even if the video has an audio track
+                               but that audio track has no audible audio.
+                               If False, returns True only if there is audible audio.
+                               Defaults to True.
+
+    Returns:
+        bool: True if the video has an audio stream (or non-silent audio if include_silent=False)
+
+    Raises:
+        FileNotFoundError: If the video file does not exist
+        RuntimeError: If ffprobe fails or ffmpeg is not installed (only when strict=True)
+
+    EXAMPLE:
+        >>> video_has_audio('/Users/ryan/Downloads/12071694.mp4')
+        True
+        >>> video_has_audio('/Users/ryan/Downloads/000000.mp4')
+        False
+
+    See Also:
+        - is_video_file: Check if a file is a video
+        - is_sound_file: Check if a file is an audio file
+        - get_video_file_framerate: Get framerate of a video
+    """
+    import subprocess
+
+    if not 'ffprobe' in get_system_commands():
+        _ensure_ffmpeg_installed()
+        if not 'ffprobe' in get_system_commands():
+            raise RuntimeError('rp.video_has_audio: Please install ffmpeg! Unable to find the ffprobe command')
+
+    path = get_absolute_path(path)
+
+    if not file_exists(path):
+        raise FileNotFoundError("Video file not found: " + path)
+
+    # Cache key includes include_silent flag
+    cache_key = (path, include_silent)
+    if use_cache and cache_key in _video_has_audio_cache:
+        return _video_has_audio_cache[cache_key]
+
+    # When include_silent=True, check for stream existence (index)
+    # When include_silent=False, check bitrate to detect silent tracks (<5kbps = silent)
+    if include_silent:
+        select_streams = "a"
+        show_entries = "stream=index"
+        output_format = "csv=p=0"
+    else:
+        select_streams = "a:0"
+        show_entries = "stream=bit_rate"
+        output_format = "default=noprint_wrappers=1:nokey=1"
+
+    result = subprocess.run(
+        ["ffprobe", "-v", "error", "-select_streams", select_streams,
+         "-show_entries", show_entries, "-of", output_format, path],
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        if strict:
+            raise RuntimeError("ffprobe failed on " + path + ": " + result.stderr)
+        has_audio = False
+    elif not result.stdout.strip():
+        has_audio = False
+    elif include_silent:
+        has_audio = True
+    else:
+        try:
+            # >5kbps = real audio, <5kbps = silent (silent AAC compresses to ~3.7kbps)
+            has_audio = int(result.stdout.strip()) > 5000
+        except ValueError:
+            # Bitrate metadata unavailable (e.g. VBR without stored bitrate, rare edge case)
+            # Fallback methods in order of speed:
+            #   1. packet_size (~59ms, O(1)): avg packet size >50 bytes = real audio (silent AAC ~10 bytes)
+            #      ffprobe -select_streams a:0 -show_entries packet=size -read_intervals %+#20
+            #   2. pcm_pipe (~58ms, O(1)): pipe 0.5s of PCM, check for samples >100 amplitude
+            #      ffmpeg -i FILE -t 0.5 -f s16le -ac 1 -ar 8000 - | check for non-zero
+            #   3. volumedetect (~104ms, O(1) with -t): check max_volume > -80dB
+            #      ffmpeg -i FILE -t 0.5 -af volumedetect -f null /dev/null
+            #      NOTE: without -t flag this would be O(n) - must decode entire audio
+            fansi_print("WARNING: video_has_audio: bitrate unavailable for " + path + ", assuming has audio", "yellow")
+            has_audio = True
+
+    if use_cache:
+        _video_has_audio_cache[cache_key] = has_audio
+
+    return has_audio
+
 
 #UNCOMMENT ONCE I USE SMART_OPEN SOMEWHERE
 # def _smart_open(path, mode="rb"):

rp-0.1.1387/rp/version.py

@@ -0,0 +1 @@
+1387

{rp-0.1.1385 → rp-0.1.1387}/rp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: rp
-Version: 0.1.1385
+Version: 0.1.1387
 Summary: Ryan's Python: IDE + Library + Tools
 Home-page: https://github.com/RyannDaGreat/rp
 Author: Ryan Burgert

rp-0.1.1387/version.py

@@ -0,0 +1 @@
+1387

rp-0.1.1385/rp/version.py

@@ -1 +0,0 @@
-1385

rp-0.1.1385/version.py

@@ -1 +0,0 @@
-1385