FirstFrame 1.0.1__tar.gz

firstframe-1.0.1/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: FirstFrame
+Version: 1.0.1
+Summary: FirstFrame is a simple command-line tool for extracting the last frame from MP4 video files using OpenCV (cv2)
+Author-email: Wilgat Wong <wilgat.wong@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Wilgat/FirstFrame
+Project-URL: Repository, https://github.com/Wilgat/FirstFrame
+Project-URL: Issues, https://github.com/Wilgat/FirstFrame/issues
+Keywords: logging,sudo,chronicle,example
+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7
+Description-Content-Type: text/markdown
+Requires-Dist: ChronicleLogger>=1.2.3
+Requires-Dist: opencv-python
+
+# FirstFrame
+
+## Overview
+
+**FirstFrame** is a lightweight command-line tool that extracts the **first frame** from MP4 video files using OpenCV (`cv2`).  
+
+It automatically scans the current directory for `.mp4` files (case-insensitive), displays an interactive numbered list with file sizes, lets the user select a video, and saves the first frame as an image file (PNG by default; supports JPG, JPEG, BMP, TIFF).  
+
+The tool features clear prompts, basic error handling, and a pause at the end — perfect for quick thumbnail generation, cover image creation, or inspecting video starts without loading the entire file.
+
+## Features
+
+- Finds all `.mp4` / `.MP4` / `.Mp4` files in the current folder using `glob`
+- Shows numbered list with file sizes (in MB) for easy selection
+- Extracts the very first frame reliably with a single `cap.read()` call
+- Smart default output filename: `output.png` (if free) or `{video_name}_first.png`
+- Automatically adds `.png` extension if user input lacks an image suffix
+- Clean resource handling (`cap.release()`) — no temporary files
+- User-friendly success/error messages and final confirmation
+
+## Prerequisites
+
+- Python 3.8+ (recommended: 3.10–3.12)
+- `opencv-python` (installed via pip)
+- Optional: virtual environment (`venv` or `uv`)
+
+No C compiler or Cython is required for normal usage — the project is currently pure Python.
+
+## Installation
+
+### Development / Source Install (Editable)
+
+```bash
+# 1. Clone or download the repo
+git clone <your-repo-url>
+cd FirstFrame
+
+# 2. (Recommended) Create & activate virtual environment
+python3 -m venv venv
+source venv/bin/activate    # Windows: venv\Scripts\activate
+
+# 3. Install dependencies
+pip install opencv-python
+# If you later add ChronicleLogger or others → add them here
+
+# 4. Install project in editable mode
+pip install -e .
+```
+
+Now you can run it with:
+
+```bash
+python -m FirstFrame
+```
+
+### Future PyPI Release (when ready)
+
+```bash
+pip install firstframe
+```
+
+(You would then publish it via `python -m build` + twine, and configure `console_scripts` in `pyproject.toml` for a `firstframe` command.)
+
+## Usage
+
+Place your MP4 videos in the current directory and run:
+
+```bash
+python -m FirstFrame
+```
+
+Example session:
+
+```
+Found MP4 videos:
+
+  1. intro.mp4   (12.4 MB)
+  2. demo.MP4    (45.8 MB)
+
+Enter video number (1-2): 1
+
+Selected: intro.mp4
+Enter output image filename [default: output.png]: 
+
+Extracting first frame from 'intro.mp4'...
+Success: First frame saved as 'output.png'
+
+Done! Image saved as: output.png
+
+Press Enter to exit...
+```
+
+Or specify a custom name:
+
+```
+Enter output image filename [default: intro_first.png]: cover.jpg
+```
+
+The tool saves the image and waits for you to press Enter before closing.
+
+For scripting / automation:
+
+```python
+from FirstFrame.__main__ import main
+main()
+```
+
+## Project Structure
+
+Follows modern Python packaging conventions with `src/` layout:
+
+```
+FirstFrame/
+├── README.md
+├── pyproject.toml            # (add when packaging properly)
+├── src/
+│   └── FirstFrame/
+│       ├── __init__.py
+│       └── __main__.py       # Main logic + entry point
+└── (optional future folders)
+    ├── tests/
+    └── docs/
+```
+
+## Development Notes
+
+- The core logic lives in `src/FirstFrame/__main__.py`
+- To add features (batch mode, other formats, progress bar…): edit the `main()` and `get_first_frame()` functions
+- Logging: `ChronicleLogger` is imported but unused — either integrate it or remove the import
+- Tests: Consider adding `tests/` folder + `pytest` later
+- Packaging: When ready, add `pyproject.toml` with `build-system = {requires = ["hatchling"], build-backend = "hatchling.build"}` (or setuptools)
+
+## Troubleshooting
+
+- **Cannot open video** → Check file path, integrity, and codec support in your OpenCV build
+- **No MP4 files found** → Make sure videos are in the current working directory (`pwd`)
+- **OpenCV not found** → `pip install opencv-python`
+- **Permission denied on save** → Check write permissions in current folder
+
+## License
+
+MIT License  
+(Add a `LICENSE` file with the standard MIT text when you publish or share the repo.)

firstframe-1.0.1/README.md

@@ -0,0 +1,143 @@
+# FirstFrame
+
+## Overview
+
+**FirstFrame** is a lightweight command-line tool that extracts the **first frame** from MP4 video files using OpenCV (`cv2`).  
+
+It automatically scans the current directory for `.mp4` files (case-insensitive), displays an interactive numbered list with file sizes, lets the user select a video, and saves the first frame as an image file (PNG by default; supports JPG, JPEG, BMP, TIFF).  
+
+The tool features clear prompts, basic error handling, and a pause at the end — perfect for quick thumbnail generation, cover image creation, or inspecting video starts without loading the entire file.
+
+## Features
+
+- Finds all `.mp4` / `.MP4` / `.Mp4` files in the current folder using `glob`
+- Shows numbered list with file sizes (in MB) for easy selection
+- Extracts the very first frame reliably with a single `cap.read()` call
+- Smart default output filename: `output.png` (if free) or `{video_name}_first.png`
+- Automatically adds `.png` extension if user input lacks an image suffix
+- Clean resource handling (`cap.release()`) — no temporary files
+- User-friendly success/error messages and final confirmation
+
+## Prerequisites
+
+- Python 3.8+ (recommended: 3.10–3.12)
+- `opencv-python` (installed via pip)
+- Optional: virtual environment (`venv` or `uv`)
+
+No C compiler or Cython is required for normal usage — the project is currently pure Python.
+
+## Installation
+
+### Development / Source Install (Editable)
+
+```bash
+# 1. Clone or download the repo
+git clone <your-repo-url>
+cd FirstFrame
+
+# 2. (Recommended) Create & activate virtual environment
+python3 -m venv venv
+source venv/bin/activate    # Windows: venv\Scripts\activate
+
+# 3. Install dependencies
+pip install opencv-python
+# If you later add ChronicleLogger or others → add them here
+
+# 4. Install project in editable mode
+pip install -e .
+```
+
+Now you can run it with:
+
+```bash
+python -m FirstFrame
+```
+
+### Future PyPI Release (when ready)
+
+```bash
+pip install firstframe
+```
+
+(You would then publish it via `python -m build` + twine, and configure `console_scripts` in `pyproject.toml` for a `firstframe` command.)
+
+## Usage
+
+Place your MP4 videos in the current directory and run:
+
+```bash
+python -m FirstFrame
+```
+
+Example session:
+
+```
+Found MP4 videos:
+
+  1. intro.mp4   (12.4 MB)
+  2. demo.MP4    (45.8 MB)
+
+Enter video number (1-2): 1
+
+Selected: intro.mp4
+Enter output image filename [default: output.png]: 
+
+Extracting first frame from 'intro.mp4'...
+Success: First frame saved as 'output.png'
+
+Done! Image saved as: output.png
+
+Press Enter to exit...
+```
+
+Or specify a custom name:
+
+```
+Enter output image filename [default: intro_first.png]: cover.jpg
+```
+
+The tool saves the image and waits for you to press Enter before closing.
+
+For scripting / automation:
+
+```python
+from FirstFrame.__main__ import main
+main()
+```
+
+## Project Structure
+
+Follows modern Python packaging conventions with `src/` layout:
+
+```
+FirstFrame/
+├── README.md
+├── pyproject.toml            # (add when packaging properly)
+├── src/
+│   └── FirstFrame/
+│       ├── __init__.py
+│       └── __main__.py       # Main logic + entry point
+└── (optional future folders)
+    ├── tests/
+    └── docs/
+```
+
+## Development Notes
+
+- The core logic lives in `src/FirstFrame/__main__.py`
+- To add features (batch mode, other formats, progress bar…): edit the `main()` and `get_first_frame()` functions
+- Logging: `ChronicleLogger` is imported but unused — either integrate it or remove the import
+- Tests: Consider adding `tests/` folder + `pytest` later
+- Packaging: When ready, add `pyproject.toml` with `build-system = {requires = ["hatchling"], build-backend = "hatchling.build"}` (or setuptools)
+
+## Troubleshooting
+
+- **Cannot open video** → Check file path, integrity, and codec support in your OpenCV build
+- **No MP4 files found** → Make sure videos are in the current working directory (`pwd`)
+- **OpenCV not found** → `pip install opencv-python`
+- **Permission denied on save** → Check write permissions in current folder
+
+## License
+
+MIT License  
+(Add a `LICENSE` file with the standard MIT text when you publish or share the repo.)

firstframe-1.0.1/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "FirstFrame"
+version = "1.0.1"
+description = "FirstFrame is a simple command-line tool for extracting the last frame from MP4 video files using OpenCV (cv2)"
+readme = "README.md"
+requires-python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+license = {text = "MIT"}
+authors = [
+    {name = "Wilgat Wong", email = "wilgat.wong@gmail.com"}
+]
+keywords = ["logging", "sudo", "chronicle", "example"]
+
+dependencies = [
+    "ChronicleLogger>=1.2.3",
+    "opencv-python"
+]
+
+# Official project links (this is what shows on PyPI!)
+[project.urls]
+Homepage = "https://github.com/Wilgat/FirstFrame"
+Repository = "https://github.com/Wilgat/FirstFrame"
+Issues = "https://github.com/Wilgat/FirstFrame/issues"
+
+# This makes `first-frame` command available after pip install
+[project.scripts]
+first-frame = "FirstFrame.cli:main"

firstframe-1.0.1/setup.cfg

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

firstframe-1.0.1/src/FirstFrame.egg-info/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: FirstFrame
+Version: 1.0.1
+Summary: FirstFrame is a simple command-line tool for extracting the last frame from MP4 video files using OpenCV (cv2)
+Author-email: Wilgat Wong <wilgat.wong@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Wilgat/FirstFrame
+Project-URL: Repository, https://github.com/Wilgat/FirstFrame
+Project-URL: Issues, https://github.com/Wilgat/FirstFrame/issues
+Keywords: logging,sudo,chronicle,example
+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7
+Description-Content-Type: text/markdown
+Requires-Dist: ChronicleLogger>=1.2.3
+Requires-Dist: opencv-python
+
+# FirstFrame
+
+## Overview
+
+**FirstFrame** is a lightweight command-line tool that extracts the **first frame** from MP4 video files using OpenCV (`cv2`).  
+
+It automatically scans the current directory for `.mp4` files (case-insensitive), displays an interactive numbered list with file sizes, lets the user select a video, and saves the first frame as an image file (PNG by default; supports JPG, JPEG, BMP, TIFF).  
+
+The tool features clear prompts, basic error handling, and a pause at the end — perfect for quick thumbnail generation, cover image creation, or inspecting video starts without loading the entire file.
+
+## Features
+
+- Finds all `.mp4` / `.MP4` / `.Mp4` files in the current folder using `glob`
+- Shows numbered list with file sizes (in MB) for easy selection
+- Extracts the very first frame reliably with a single `cap.read()` call
+- Smart default output filename: `output.png` (if free) or `{video_name}_first.png`
+- Automatically adds `.png` extension if user input lacks an image suffix
+- Clean resource handling (`cap.release()`) — no temporary files
+- User-friendly success/error messages and final confirmation
+
+## Prerequisites
+
+- Python 3.8+ (recommended: 3.10–3.12)
+- `opencv-python` (installed via pip)
+- Optional: virtual environment (`venv` or `uv`)
+
+No C compiler or Cython is required for normal usage — the project is currently pure Python.
+
+## Installation
+
+### Development / Source Install (Editable)
+
+```bash
+# 1. Clone or download the repo
+git clone <your-repo-url>
+cd FirstFrame
+
+# 2. (Recommended) Create & activate virtual environment
+python3 -m venv venv
+source venv/bin/activate    # Windows: venv\Scripts\activate
+
+# 3. Install dependencies
+pip install opencv-python
+# If you later add ChronicleLogger or others → add them here
+
+# 4. Install project in editable mode
+pip install -e .
+```
+
+Now you can run it with:
+
+```bash
+python -m FirstFrame
+```
+
+### Future PyPI Release (when ready)
+
+```bash
+pip install firstframe
+```
+
+(You would then publish it via `python -m build` + twine, and configure `console_scripts` in `pyproject.toml` for a `firstframe` command.)
+
+## Usage
+
+Place your MP4 videos in the current directory and run:
+
+```bash
+python -m FirstFrame
+```
+
+Example session:
+
+```
+Found MP4 videos:
+
+  1. intro.mp4   (12.4 MB)
+  2. demo.MP4    (45.8 MB)
+
+Enter video number (1-2): 1
+
+Selected: intro.mp4
+Enter output image filename [default: output.png]: 
+
+Extracting first frame from 'intro.mp4'...
+Success: First frame saved as 'output.png'
+
+Done! Image saved as: output.png
+
+Press Enter to exit...
+```
+
+Or specify a custom name:
+
+```
+Enter output image filename [default: intro_first.png]: cover.jpg
+```
+
+The tool saves the image and waits for you to press Enter before closing.
+
+For scripting / automation:
+
+```python
+from FirstFrame.__main__ import main
+main()
+```
+
+## Project Structure
+
+Follows modern Python packaging conventions with `src/` layout:
+
+```
+FirstFrame/
+├── README.md
+├── pyproject.toml            # (add when packaging properly)
+├── src/
+│   └── FirstFrame/
+│       ├── __init__.py
+│       └── __main__.py       # Main logic + entry point
+└── (optional future folders)
+    ├── tests/
+    └── docs/
+```
+
+## Development Notes
+
+- The core logic lives in `src/FirstFrame/__main__.py`
+- To add features (batch mode, other formats, progress bar…): edit the `main()` and `get_first_frame()` functions
+- Logging: `ChronicleLogger` is imported but unused — either integrate it or remove the import
+- Tests: Consider adding `tests/` folder + `pytest` later
+- Packaging: When ready, add `pyproject.toml` with `build-system = {requires = ["hatchling"], build-backend = "hatchling.build"}` (or setuptools)
+
+## Troubleshooting
+
+- **Cannot open video** → Check file path, integrity, and codec support in your OpenCV build
+- **No MP4 files found** → Make sure videos are in the current working directory (`pwd`)
+- **OpenCV not found** → `pip install opencv-python`
+- **Permission denied on save** → Check write permissions in current folder
+
+## License
+
+MIT License  
+(Add a `LICENSE` file with the standard MIT text when you publish or share the repo.)

firstframe-1.0.1/src/FirstFrame.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/FirstFrame.egg-info/PKG-INFO
+src/FirstFrame.egg-info/SOURCES.txt
+src/FirstFrame.egg-info/dependency_links.txt
+src/FirstFrame.egg-info/entry_points.txt
+src/FirstFrame.egg-info/requires.txt
+src/FirstFrame.egg-info/top_level.txt
+src/LastFrame/__init__.py
+src/LastFrame/__main__.py
+src/LastFrame/cli.py

firstframe-1.0.1/src/FirstFrame.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

firstframe-1.0.1/src/FirstFrame.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+first-frame = FirstFrame.cli:main

firstframe-1.0.1/src/FirstFrame.egg-info/requires.txt

@@ -0,0 +1,2 @@
+ChronicleLogger>=1.2.3
+opencv-python

firstframe-1.0.1/src/FirstFrame.egg-info/top_level.txt

@@ -0,0 +1 @@
+LastFrame

firstframe-1.0.1/src/LastFrame/__init__.py

@@ -0,0 +1,4 @@
+from .cli import ChronicleLogger
+
+__version__ = "1.0.1"
+__all__ = ["ChronicleLogger"]

firstframe-1.0.1/src/LastFrame/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

firstframe-1.0.1/src/LastFrame/cli.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+from __future__ import print_function, unicode_literals
+
+from ChronicleLogger import ChronicleLogger
+import sys
+import cv2
+import os
+import glob
+
+def get_last_frame(video_path, output_path):
+    """Extract the last frame from video and save it."""
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        print("Error: Cannot open video file.")
+        return False
+
+    # Method 1: Try by frame count (most accurate)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    if total_frames > 1:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, total_frames - 1)
+        ret, frame = cap.read()
+        if ret:
+            cv2.imwrite(output_path, frame)
+            cap.release()
+            print(f"Success: Last frame saved as '{output_path}'")
+            return True
+
+    # Method 2: Fallback - seek to 99% of video
+    cap.set(cv2.CAP_PROP_POS_AVI_RATIO, 0.99)
+    ret, frame = cap.read()
+    if ret:
+        cv2.imwrite(output_path, frame)
+        cap.release()
+        print(f"Success: Last frame saved as '{output_path}' (using time-based seek)")
+        return True
+
+    # Method 3: Use millisecond seek
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    if fps > 0:
+        duration_ms = (total_frames / fps) * 1000
+        cap.set(cv2.CAP_PROP_POS_MSEC, duration_ms - 100)  # 0.1s before end
+        ret, frame = cap.read()
+        if ret:
+            cv2.imwrite(output_path, frame)
+            cap.release()
+            print(f"Success: Last frame saved as '{output_path}' (millisecond seek)")
+            return True
+
+    cap.release()
+    print("Failed: Could not extract the last frame.")
+    return False
+
+
+def main():
+    # Find all .mp4 files in current directory (case-insensitive)
+    mp4_files = glob.glob("*.mp4") + glob.glob("*.MP4") + glob.glob("*.Mp4")
+    mp4_files = sorted(set(mp4_files))  # Remove duplicates, sort nicely
+
+    if not mp4_files:
+        print("No .mp4 videos found in the current folder!")
+        print(f"Current directory: {os.getcwd()}")
+        input("\nPress Enter to exit...")
+        return
+
+    # Display numbered list
+    print("\nFound MP4 videos:\n")
+    for i, filename in enumerate(mp4_files, 1):
+        size_mb = os.path.getsize(filename) / (1024 * 1024)
+        print(f"  {i:2d}. {filename}  ({size_mb:.1f} MB)")
+
+    # Get user choice
+    while True:
+        try:
+            choice = input(f"\nEnter video number (1-{len(mp4_files)}): ").strip()
+            if not choice:
+                print("Please enter a number.")
+                continue
+            idx = int(choice) - 1
+            if 0 <= idx < len(mp4_files):
+                selected_video = mp4_files[idx]
+                break
+            else:
+                print(f"Please enter a number between 1 and {len(mp4_files)}.")
+        except ValueError:
+            print("Invalid input. Please type a number.")
+
+    # Suggest default output: either output.png or video_name_last.png
+    base_name = os.path.splitext(selected_video)[0]
+    default_output = "output.png" if os.path.exists("output.png") == False else f"{base_name}_last.png"
+
+    print(f"\nSelected: {selected_video}")
+
+    # Ask for output filename
+    user_output = input(f"Enter output image filename [default: {default_output}]: ").strip()
+    if not user_output:
+        output_path = default_output
+    else:
+        # Ensure it has an image extension
+        if not user_output.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.tiff')):
+            output_path = user_output + ".png"
+        else:
+            output_path = user_output
+
+    print(f"\nExtracting last frame from '{selected_video}'...")
+    get_last_frame(selected_video, output_path)
+
+    print(f"\nDone! Image saved as: {output_path}")
+    input("\nPress Enter to exit...")
+
+
+if __name__ == "__main__":
+    main()
+