Update app.py

app.py

@@ -562,7 +562,236 @@ def display_settings_tab():
 
 
 
+def get_download_link(file: str, file_type: str = "zip") -> str:
+    """
+    Convert a file to base64 and return an HTML link for download.
+    Supports multiple file types with appropriate MIME types.
+    """
+    try:
+        with open(file, "rb") as f:
+            b64 = base64.b64encode(f.read()).decode()
+        
+        # Get filename for display
+        filename = os.path.basename(file)
+        
+        # Define MIME types and emoji icons for different file types
+        mime_types = {
+            "zip": ("application/zip", "📂"),
+            "mp3": ("audio/mpeg", "🎵"),
+            "wav": ("audio/wav", "🔊"),
+            "md": ("text/markdown", "📝"),
+            "pdf": ("application/pdf", "📄"),
+            "txt": ("text/plain", "📋"),
+            "json": ("application/json", "📊"),
+            "csv": ("text/csv", "📈"),
+            "png": ("image/png", "🖼"),
+            "jpg": ("image/jpeg", "🖼"),
+            "jpeg": ("image/jpeg", "🖼")
+        }
+        
+        # Get MIME type and emoji for file
+        mime_type, emoji = mime_types.get(
+            file_type.lower(), 
+            ("application/octet-stream", "⬇️")
+        )
+        
+        # Create download link with appropriate MIME type
+        link = f'<a href="data:{mime_type};base64,{b64}" download="{filename}">{emoji} Download {filename}</a>'
+        
+        return link
+        
+    except FileNotFoundError:
+        return f"<p style='color: red'>❌ File not found: {file}</p>"
+    except Exception as e:
+        return f"<p style='color: red'>❌ Error creating download link: {str(e)}</p>"
+
+def play_and_download_audio(file_path: str, file_type: str = "mp3"):
+    """
+    Display audio player and download link for audio file.
+    Includes error handling and file validation.
+    """
+    if not file_path:
+        st.warning("No audio file provided.")
+        return
+        
+    if not os.path.exists(file_path):
+        st.error(f"Audio file not found: {file_path}")
+        return
+        
+    try:
+        # Display audio player
+        st.audio(file_path)
+        
+        # Create and display download link
+        dl_link = get_download_link(file_path, file_type=file_type)
+        st.markdown(dl_link, unsafe_allow_html=True)
+        
+    except Exception as e:
+        st.error(f"Error playing audio: {str(e)}")
 
+def get_file_info(file_path: str) -> dict:
+    """
+    Get detailed information about a file.
+    Returns dictionary with size, modification time, and other metadata.
+    """
+    try:
+        stats = os.stat(file_path)
+        
+        # Get basic file information
+        info = {
+            'name': os.path.basename(file_path),
+            'path': file_path,
+            'size': stats.st_size,
+            'modified': datetime.fromtimestamp(stats.st_mtime),
+            'created': datetime.fromtimestamp(stats.st_ctime),
+            'type': os.path.splitext(file_path)[1].lower().strip('.'),
+        }
+        
+        # Add formatted size
+        if info['size'] < 1024:
+            info['size_fmt'] = f"{info['size']} B"
+        elif info['size'] < 1024 * 1024:
+            info['size_fmt'] = f"{info['size']/1024:.1f} KB"
+        else:
+            info['size_fmt'] = f"{info['size']/(1024*1024):.1f} MB"
+        
+        # Add formatted dates
+        info['modified_fmt'] = info['modified'].strftime("%Y-%m-%d %H:%M:%S")
+        info['created_fmt'] = info['created'].strftime("%Y-%m-%d %H:%M:%S")
+        
+        return info
+        
+    except Exception as e:
+        st.error(f"Error getting file info: {str(e)}")
+        return None
+
+def sanitize_filename(filename: str) -> str:
+    """
+    Clean and sanitize a filename to ensure it's safe for filesystem.
+    Removes/replaces unsafe characters and enforces length limits.
+    """
+    # Remove or replace unsafe characters
+    filename = re.sub(r'[<>:"/\\|?*]', '_', filename)
+    
+    # Remove leading/trailing spaces and dots
+    filename = filename.strip('. ')
+    
+    # Limit length (reserving space for extension)
+    max_length = 255
+    name, ext = os.path.splitext(filename)
+    if len(filename) > max_length:
+        return name[:(max_length-len(ext))] + ext
+        
+    return filename
+
+def create_file_with_metadata(filename: str, content: str, metadata: dict = None):
+    """
+    Create a file with optional metadata header.
+    Useful for storing additional information with files.
+    """
+    try:
+        # Sanitize filename
+        safe_filename = sanitize_filename(filename)
+        
+        # Ensure directory exists
+        os.makedirs(os.path.dirname(safe_filename) or '.', exist_ok=True)
+        
+        # Prepare content with metadata
+        if metadata:
+            metadata_str = json.dumps(metadata, indent=2)
+            full_content = f"""---
+{metadata_str}
+---
+{content}"""
+        else:
+            full_content = content
+            
+        # Write file
+        with open(safe_filename, 'w', encoding='utf-8') as f:
+            f.write(full_content)
+            
+        return safe_filename
+        
+    except Exception as e:
+        st.error(f"Error creating file: {str(e)}")
+        return None
+
+def read_file_with_metadata(filename: str) -> tuple:
+    """
+    Read a file and extract any metadata header.
+    Returns tuple of (content, metadata).
+    """
+    try:
+        with open(filename, 'r', encoding='utf-8') as f:
+            content = f.read()
+            
+        # Check for metadata section
+        if content.startswith('---\n'):
+            # Find end of metadata section
+            end_meta = content.find('\n---\n', 4)
+            if end_meta != -1:
+                try:
+                    metadata = json.loads(content[4:end_meta])
+                    content = content[end_meta+5:]
+                    return content, metadata
+                except json.JSONDecodeError:
+                    pass
+                    
+        return content, None
+        
+    except Exception as e:
+        st.error(f"Error reading file: {str(e)}")
+        return None, None
+
+def archive_files(file_paths: list, archive_name: str = None) -> str:
+    """
+    Create a zip archive containing the specified files.
+    Returns path to created archive.
+    """
+    try:
+        # Generate archive name if not provided
+        if not archive_name:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            archive_name = f"archive_{timestamp}.zip"
+            
+        # Create zip file
+        with zipfile.ZipFile(archive_name, 'w', zipfile.ZIP_DEFLATED) as zf:
+            for file_path in file_paths:
+                if os.path.exists(file_path):
+                    zf.write(file_path, os.path.basename(file_path))
+                    
+        return archive_name
+        
+    except Exception as e:
+        st.error(f"Error creating archive: {str(e)}")
+        return None
+
+def list_files_by_type(directory: str = ".", 
+                      extensions: list = None, 
+                      recursive: bool = False) -> dict:
+    """
+    List files in directory filtered by extension.
+    Returns dict grouping files by type.
+    """
+    try:
+        if extensions is None:
+            extensions = ['md', 'mp3', 'wav', 'pdf', 'txt', 'json', 'csv']
+            
+        files = {}
+        pattern = "**/*" if recursive else "*"
+        
+        for ext in extensions:
+            glob_pattern = f"{pattern}.{ext}"
+            matches = glob.glob(os.path.join(directory, glob_pattern), 
+                              recursive=recursive)
+            if matches:
+                files[ext] = matches
+                
+        return files
+        
+    except Exception as e:
+        st.error(f"Error listing files: {str(e)}")
+        return {}