edsl 0.1.54__py3-none-any.whl → 0.1.55__py3-none-any.whl

edsl/scenarios/file_store.py

@@ -592,6 +592,111 @@ class FileStore(Scenario):
         """
         # Check if the mime type starts with 'image/'
         return self.mime_type.startswith("image/")
+        
+    def is_video(self) -> bool:
+        """
+        Check if the file is a video by examining its MIME type.
+        
+        Returns:
+            bool: True if the file is a video, False otherwise.
+            
+        Examples:
+            >>> fs = FileStore.example("mp4")
+            >>> fs.is_video()
+            True
+            >>> fs = FileStore.example("webm")
+            >>> fs.is_video()
+            True
+            >>> fs = FileStore.example("txt")
+            >>> fs.is_video()
+            False
+        """
+        # Check if the mime type starts with 'video/'
+        return self.mime_type.startswith("video/")
+        
+    def get_video_metadata(self) -> dict:
+        """
+        Get metadata about a video file such as duration, dimensions, codec, etc.
+        Uses FFmpeg to extract the information if available.
+        
+        Returns:
+            dict: A dictionary containing video metadata, or a dictionary with
+                 error information if metadata extraction fails.
+                 
+        Raises:
+            ValueError: If the file is not a video.
+            
+        Example:
+            >>> fs = FileStore.example("mp4")
+            >>> metadata = fs.get_video_metadata()
+            >>> isinstance(metadata, dict)
+            True
+        """
+        if not self.is_video():
+            raise ValueError("This file is not a video")
+            
+        # We'll try to use ffprobe (part of ffmpeg) to get metadata
+        import subprocess
+        import json
+        
+        try:
+            # Run ffprobe to get video metadata in JSON format
+            result = subprocess.run(
+                [
+                    "ffprobe", "-v", "quiet", "-print_format", "json",
+                    "-show_format", "-show_streams", self.path
+                ],
+                capture_output=True, text=True, check=True
+            )
+            
+            # Parse the JSON output
+            metadata = json.loads(result.stdout)
+            
+            # Extract some common useful fields into a more user-friendly format
+            simplified = {
+                "format": metadata.get("format", {}).get("format_name", "unknown"),
+                "duration_seconds": float(metadata.get("format", {}).get("duration", 0)),
+                "size_bytes": int(metadata.get("format", {}).get("size", 0)),
+                "bit_rate": int(metadata.get("format", {}).get("bit_rate", 0)),
+                "streams": len(metadata.get("streams", [])),
+            }
+            
+            # Add video stream info if available
+            video_streams = [s for s in metadata.get("streams", []) if s.get("codec_type") == "video"]
+            if video_streams:
+                video = video_streams[0]  # Get the first video stream
+                simplified["video"] = {
+                    "codec": video.get("codec_name", "unknown"),
+                    "width": video.get("width", 0),
+                    "height": video.get("height", 0),
+                    "frame_rate": eval(video.get("r_frame_rate", "0/1")),  # Convert "30/1" to 30.0
+                    "pixel_format": video.get("pix_fmt", "unknown"),
+                }
+            
+            # Add audio stream info if available
+            audio_streams = [s for s in metadata.get("streams", []) if s.get("codec_type") == "audio"]
+            if audio_streams:
+                audio = audio_streams[0]  # Get the first audio stream
+                simplified["audio"] = {
+                    "codec": audio.get("codec_name", "unknown"),
+                    "channels": audio.get("channels", 0),
+                    "sample_rate": audio.get("sample_rate", "unknown"),
+                }
+                
+            # Return both the complete metadata and simplified version
+            return {
+                "simplified": simplified,
+                "full": metadata
+            }
+            
+        except (subprocess.SubprocessError, FileNotFoundError, json.JSONDecodeError) as e:
+            # If ffprobe is not available or fails, return basic info
+            return {
+                "error": str(e),
+                "format": self.suffix,
+                "mime_type": self.mime_type,
+                "size_bytes": self.size,
+            }
 
     def get_image_dimensions(self) -> tuple:
         """
@@ -626,12 +731,18 @@ class FileStore(Scenario):
         """
         Delegate pandas DataFrame methods to the underlying DataFrame if this is a CSV file
         """
-        if self.suffix == "csv":
-            # Get the pandas DataFrame
-            df = self.to_pandas()
-            # Check if the requested attribute exists in the DataFrame
-            if hasattr(df, name):
-                return getattr(df, name)
+        # Special case for pickle protocol
+        if name.startswith("__") and name.endswith("__"):
+            raise AttributeError(name)
+
+        # Only try to access suffix if it's in our __dict__
+        if hasattr(self, "_data") and "suffix" in self._data:
+            if self._data["suffix"] == "csv":
+                # Get the pandas DataFrame
+                df = self.to_pandas()
+                # Check if the requested attribute exists in the DataFrame
+                if hasattr(df, name):
+                    return getattr(df, name)
         # If not a CSV or attribute doesn't exist in DataFrame, raise AttributeError
         raise AttributeError(
             f"'{self.__class__.__name__}' object has no attribute '{name}'"

edsl/scenarios/handlers/__init__.py

@@ -12,7 +12,9 @@ __all__ = [
     "LaTeXMethods",
     "PyMethods",
     "SQLiteMethods",
-    "JpegMethods"
+    "JpegMethods",
+    "Mp4Methods",
+    "WebmMethods"
 ]
 
 from .pdf_file_store import PdfMethods
@@ -29,3 +31,5 @@ from .latex_file_store import LaTeXMethods
 from .py_file_store import PyMethods
 from .sqlite_file_store import SQLiteMethods
 from .jpeg_file_store import JpegMethods
+from .mp4_file_store import Mp4Methods
+from .webm_file_store import WebmMethods

edsl/scenarios/handlers/mp4_file_store.py

@@ -0,0 +1,104 @@
+import tempfile
+from ..file_methods import FileMethods
+
+
+class Mp4Methods(FileMethods):
+    """
+    Handler for MP4 video files.
+    
+    This class provides methods to handle MP4 video files in both notebook
+    and system environments, including viewing and creating example videos.
+    """
+    suffix = "mp4"
+
+    def view_system(self):
+        """
+        Open the MP4 file with the system's default video player.
+        """
+        import os
+        import subprocess
+
+        if os.path.exists(self.path):
+            try:
+                if (os_name := os.name) == "posix":
+                    subprocess.run(["open", self.path], check=True)  # macOS
+                elif os_name == "nt":
+                    os.startfile(self.path)  # Windows
+                else:
+                    subprocess.run(["xdg-open", self.path], check=True)  # Linux
+            except Exception as e:
+                print(f"Error opening MP4: {e}")
+        else:
+            print("MP4 file was not found.")
+
+    def view_notebook(self):
+        """
+        Display the MP4 video in a Jupyter notebook using IPython's HTML display.
+        """
+        from IPython.display import HTML, display
+        import base64
+        
+        # Read the video file and encode it as base64
+        with open(self.path, 'rb') as f:
+            video_data = f.read()
+        
+        video_base64 = base64.b64encode(video_data).decode('utf-8')
+        
+        # Create an HTML5 video element with the base64-encoded video
+        video_html = f"""
+        <video width="640" height="360" controls>
+            <source src="data:video/mp4;base64,{video_base64}" type="video/mp4">
+            Your browser does not support the video tag.
+        </video>
+        """
+        
+        display(HTML(video_html))
+
+    def extract_text(self):
+        """
+        Extract text from the video using subtitle extraction (if available).
+        Currently returns a message that text extraction is not supported for videos.
+        
+        Returns:
+            str: Message indicating text extraction is not supported
+        """
+        return "Text extraction is not supported for video files."
+
+    def example(self):
+        """
+        Create a simple example MP4 file.
+        
+        Uses FFmpeg to generate a test video pattern if available, 
+        otherwise creates a minimal MP4 header.
+        
+        Returns:
+            str: Path to the created example MP4 file
+        """
+        import os
+        import subprocess
+        
+        # Create a temporary file for the output
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as f:
+            output_path = f.name
+        
+        try:
+            # Try to use ffmpeg to generate a test pattern video
+            subprocess.run(
+                [
+                    "ffmpeg", "-y", "-f", "lavfi", "-i", "testsrc=duration=5:size=1280x720:rate=30", 
+                    "-vcodec", "libx264", "-pix_fmt", "yuv420p", output_path
+                ],
+                check=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            return output_path
+        except (subprocess.SubprocessError, FileNotFoundError):
+            # If ffmpeg is not available, create a tiny placeholder MP4 file
+            # Using a simple empty binary file with the .mp4 extension
+            with open(output_path, 'wb') as f:
+                # Just write a simple 1KB file with MP4 signature
+                f.write(b'\x00\x00\x00\x18\x66\x74\x79\x70\x6D\x70\x34\x32')  # MP4 file signature
+                f.write(b'\x00' * 1000)  # Fill with zeros
+            
+            return output_path

edsl/scenarios/handlers/webm_file_store.py

@@ -0,0 +1,104 @@
+import tempfile
+from ..file_methods import FileMethods
+
+
+class WebmMethods(FileMethods):
+    """
+    Handler for WebM video files.
+    
+    This class provides methods to handle WebM video files in both notebook
+    and system environments, including viewing and creating example videos.
+    WebM is an open, royalty-free video format designed for the web.
+    """
+    suffix = "webm"
+
+    def view_system(self):
+        """
+        Open the WebM file with the system's default video player.
+        """
+        import os
+        import subprocess
+
+        if os.path.exists(self.path):
+            try:
+                if (os_name := os.name) == "posix":
+                    subprocess.run(["open", self.path], check=True)  # macOS
+                elif os_name == "nt":
+                    os.startfile(self.path)  # Windows
+                else:
+                    subprocess.run(["xdg-open", self.path], check=True)  # Linux
+            except Exception as e:
+                print(f"Error opening WebM: {e}")
+        else:
+            print("WebM file was not found.")
+
+    def view_notebook(self):
+        """
+        Display the WebM video in a Jupyter notebook using IPython's HTML display.
+        """
+        from IPython.display import HTML, display
+        import base64
+        
+        # Read the video file and encode it as base64
+        with open(self.path, 'rb') as f:
+            video_data = f.read()
+        
+        video_base64 = base64.b64encode(video_data).decode('utf-8')
+        
+        # Create an HTML5 video element with the base64-encoded video
+        video_html = f"""
+        <video width="640" height="360" controls>
+            <source src="data:video/webm;base64,{video_base64}" type="video/webm">
+            Your browser does not support the video tag.
+        </video>
+        """
+        
+        display(HTML(video_html))
+
+    def extract_text(self):
+        """
+        Extract text from the video using subtitle extraction (if available).
+        Currently returns a message that text extraction is not supported for videos.
+        
+        Returns:
+            str: Message indicating text extraction is not supported
+        """
+        return "Text extraction is not supported for video files."
+
+    def example(self):
+        """
+        Create a simple example WebM file.
+        
+        Uses FFmpeg to generate a test video pattern in WebM format if available,
+        otherwise creates a minimal WebM header.
+        
+        Returns:
+            str: Path to the created example WebM file
+        """
+        import os
+        import subprocess
+        
+        # Create a temporary file for the output
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".webm") as f:
+            output_path = f.name
+        
+        try:
+            # Try to use ffmpeg to generate a test pattern video in WebM format
+            subprocess.run(
+                [
+                    "ffmpeg", "-y", "-f", "lavfi", "-i", "testsrc=duration=5:size=1280x720:rate=30", 
+                    "-c:v", "libvpx", "-b:v", "1M", output_path
+                ],
+                check=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            return output_path
+        except (subprocess.SubprocessError, FileNotFoundError):
+            # If ffmpeg is not available, create a minimal WebM file
+            with open(output_path, 'wb') as f:
+                # WebM starts with EBML header (1A 45 DF A3)
+                f.write(b'\x1A\x45\xDF\xA3')  # EBML signature
+                f.write(b'\x00' * 1000)  # Fill with zeros
+            
+            return output_path