Update app.py

app.py

@@ -2,132 +2,191 @@ from flask import Flask, render_template, request, jsonify, send_file
 import requests
 import base64
 import markdown
-from bs4 import BeautifulSoup
-import os
-import mimetypes
 import json
-from io import BytesIO
-from pathlib import Path
+import mimetypes
+import os
+import io
 
 app = Flask(__name__)
 
 GITHUB_API = "https://api.github.com/repos/"
 HF_API = "https://huggingface.co/api/spaces/"
 
-def generate_file_tree(contents, is_hf=False):
-    """Generate a file structure tree"""
+def generate_file_tree(paths):
+    """Generate a simple file tree from a list of paths."""
     tree = ["📁 Root"]
-    paths = sorted([item['path'] for item in contents if isinstance(item, dict) and 'path' in item])
-    
-    for path in paths:
+    sorted_paths = sorted(paths)
+    for path in sorted_paths:
         parts = path.split('/')
         indent = "  " * (len(parts) - 1)
         tree.append(f"{indent}📄 {parts[-1]}")
-    
     return "\n".join(tree) + "\n\n"
 
+def get_all_files(owner, repo, path="", is_hf=False):
+    """Recursively fetch all files from a repository."""
+    if is_hf:
+        api_url = f"https://huggingface.co/api/spaces/{owner}/{repo}/tree/main/{path}".rstrip('/')
+    else:
+        api_url = f"{GITHUB_API}{owner}/{repo}/contents/{path}".rstrip('/')
+    
+    try:
+        response = requests.get(api_url)
+        response.raise_for_status()
+        items = response.json()
+        
+        files = []
+        for item in items:
+            if item['type'] == 'file':
+                files.append(item)
+            elif item['type'] == 'dir':
+                files.extend(get_all_files(owner, repo, item['path'], is_hf))
+        return files
+    except Exception as e:
+        return None
+
 def get_repo_contents(url):
-    """Extract contents from GitHub or Hugging Face URL"""
+    """Parse URL and fetch repository contents."""
     try:
         if "huggingface.co" in url:
             parts = url.rstrip('/').split('/')
             owner, repo = parts[-2], parts[-1]
-            api_url = f"{HF_API}{owner}/{repo}/files"
-            response = requests.get(api_url)
-            response.raise_for_status()
-            return owner, repo, response.json()["files"], True
-        else:
+            files = get_all_files(owner, repo, "", True)
+            if files is None:
+                raise Exception("Failed to fetch Hugging Face Space contents")
+            return owner, repo, files, True
+        else:  # Assume GitHub URL
             parts = url.rstrip('/').split('/')
             owner, repo = parts[-2], parts[-1]
-            api_url = f"{GITHUB_API}{owner}/{repo}/contents"
-            response = requests.get(api_url)
-            response.raise_for_status()
-            return owner, repo, response.json(), False
+            files = get_all_files(owner, repo, "", False)
+            if files is None:
+                raise Exception("Failed to fetch GitHub repository contents")
+            return owner, repo, files, False
     except Exception as e:
-        return None, None, str(e), False
+        return None, None, f"Error fetching repo contents: {str(e)}", False
 
 def process_file_content(file_info, owner, repo, is_hf=False):
-    """Process individual file content"""
+    """Process individual file content from a repository."""
     content = ""
-    file_path = file_info['path'] if not is_hf else file_info
+    file_path = file_info['path']
     
-    if isinstance(file_info, dict) and 'type' in file_info and file_info['type'] == 'file' or isinstance(file_info, str):
+    try:
         if is_hf:
-            file_url = f"https://huggingface.co/spaces/{owner}/{repo}/raw/main/{file_path}"
+            file_url = f"https://huggingface.co/spaces/{owner}/{repo}/resolve/main/{file_path}"
         else:
             file_url = f"{GITHUB_API}{owner}/{repo}/contents/{file_path}"
         
-        file_response = requests.get(file_url)
+        response = requests.get(file_url)
+        response.raise_for_status()
         
         if is_hf:
-            content_raw = file_response.text
-        else:
-            file_data = file_response.json()
-            if 'content' not in file_data:
-                return f"### File: {file_path}\n[No content available]\n\n"
-            content_raw = base64.b64decode(file_data['content']).decode('utf-8', errors='ignore')
-        
-        file_extension = file_path.split('.')[-1] if '.' in file_path else ''
-        mime_type, _ = mimetypes.guess_type(file_path)
-        is_text = (mime_type and mime_type.startswith('text')) or file_extension in ['py', 'md', 'txt', 'js', 'html', 'css', 'json']
-        
-        if is_text:
-            if file_extension == 'json':
+            content_raw = response.content
+            size = len(content_raw)
+            file_extension = file_path.split('.')[-1] if '.' in file_path else ''
+            mime_type, _ = mimetypes.guess_type(file_path)
+            is_text = (mime_type and mime_type.startswith('text')) or file_extension in ['py', 'md', 'txt', 'js', 'html', 'css', 'json']
+            
+            if is_text:
                 try:
-                    json_data = json.loads(content_raw)
-                    formatted_json = json.dumps(json_data, indent=2)
-                    content = f"### File: {file_path}\n```json\n{formatted_json}\n```\n\n"
-                except json.JSONDecodeError:
-                    content = f"### File: {file_path}\n```json\n{content_raw}\n```\n[Note: Invalid JSON format]\n\n"
+                    text_content = content_raw.decode('utf-8')
+                    if file_extension == 'json':
+                        try:
+                            json_data = json.loads(text_content)
+                            formatted_json = json.dumps(json_data, indent=2)
+                            content = f"### File: {file_path}\n```json\n{formatted_json}\n```\n\n"
+                        except json.JSONDecodeError:
+                            content = f"### File: {file_path}\n```json\n{text_content}\n```\n[Note: Invalid JSON format]\n\n"
+                    else:
+                        content = f"### File: {file_path}\n```{file_extension or 'text'}\n{text_content}\n```\n\n"
+                except UnicodeDecodeError:
+                    content = f"### File: {file_path}\n[Binary file - {size} bytes]\n\n"
             else:
-                content = f"### File: {file_path}\n```{(file_extension if file_extension else 'text')}\n{content_raw}\n```\n\n"
-        else:
-            content = f"### File: {file_path}\n[Binary file]\n\n"
+                content = f"### File: {file_path}\n[Binary file - {size} bytes]\n\n"
+        else:  # GitHub
+            data = response.json()
+            if 'content' in data:
+                content_raw = base64.b64decode(data['content'])
+                size = data['size']
+                file_extension = file_path.split('.')[-1] if '.' in file_path else ''
+                mime_type, _ = mimetypes.guess_type(file_path)
+                is_text = (mime_type and mime_type.startswith('text')) or file_extension in ['py', 'md', 'txt', 'js', 'html', 'css', 'json']
+                
+                if is_text:
+                    try:
+                        text_content = content_raw.decode('utf-8')
+                        if file_extension == 'json':
+                            try:
+                                json_data = json.loads(text_content)
+                                formatted_json = json.dumps(json_data, indent=2)
+                                content = f"### File: {file_path}\n```json\n{formatted_json}\n```\n\n"
+                            except json.JSONDecodeError:
+                                content = f"### File: {file_path}\n```json\n{text_content}\n```\n[Note: Invalid JSON format]\n\n"
+                        else:
+                            content = f"### File: {file_path}\n```{file_extension or 'text'}\n{text_content}\n```\n\n"
+                    except UnicodeDecodeError:
+                        content = f"### File: {file_path}\n[Binary file - {size} bytes]\n\n"
+                else:
+                    content = f"### File: {file_path}\n[Binary file - {size} bytes]\n\n"
+            else:
+                content = f"### File: {file_path}\n[No content available]\n\n"
+    except Exception as e:
+        content = f"### File: {file_path}\n[Error fetching file content: {str(e)}]\n\n"
     
     return content
 
 def process_uploaded_file(file):
-    """Process uploaded file content"""
+    """Process uploaded file content."""
     content = ""
     filename = file.filename
     file_extension = filename.split('.')[-1] if '.' in filename else ''
     
     try:
-        content_raw = file.read().decode('utf-8', errors='ignore')
-        if file_extension == 'json':
+        content_raw = file.read()  # Read file content into memory
+        size = len(content_raw)    # Compute size in bytes
+        
+        mime_type, _ = mimetypes.guess_type(filename)
+        is_text = (mime_type and mime_type.startswith('text')) or file_extension in ['py', 'md', 'txt', 'js', 'html', 'css', 'json']
+        
+        if is_text:
             try:
-                json_data = json.loads(content_raw)
-                formatted_json = json.dumps(json_data, indent=2)
-                content = f"### File: {filename}\n```json\n{formatted_json}\n```\n\n"
-            except json.JSONDecodeError:
-                content = f"### File: {filename}\n```json\n{content_raw}\n```\n[Note: Invalid JSON format]\n\n"
+                text_content = content_raw.decode('utf-8')
+                if file_extension == 'json':
+                    try:
+                        json_data = json.loads(text_content)
+                        formatted_json = json.dumps(json_data, indent=2)
+                        content = f"### File: {filename}\n```json\n{formatted_json}\n```\n\n"
+                    except json.JSONDecodeError:
+                        content = f"### File: {filename}\n```json\n{text_content}\n```\n[Note: Invalid JSON format]\n\n"
+                else:
+                    content = f"### File: {filename}\n```{file_extension or 'text'}\n{text_content}\n```\n\n"
+            except UnicodeDecodeError:
+                content = f"### File: {filename}\n[Binary file - {size} bytes]\n\n"
         else:
-            content = f"### File: {filename}\n```{(file_extension if file_extension else 'text')}\n{content_raw}\n```\n\n"
+            content = f"### File: {filename}\n[Binary file - {size} bytes]\n\n"
     except Exception as e:
         content = f"### File: {filename}\n[Error processing file: {str(e)}]\n\n"
     
     return content
 
 def create_markdown_document(url=None, files=None):
-    """Create markdown document from repo contents or uploaded files"""
+    """Create markdown document from repo contents or uploaded files."""
     if url:
         owner, repo, contents, is_hf = get_repo_contents(url)
         
-        if isinstance(contents, str):
+        if isinstance(contents, str):  # Error case
             return f"Error: {contents}"
         
         markdown_content = f"# {'Space' if is_hf else 'Repository'}: {owner}/{repo}\n\n"
         markdown_content += "## File Structure\n```\n"
-        markdown_content += generate_file_tree(contents, is_hf)
+        markdown_content += generate_file_tree([item['path'] for item in contents])
         markdown_content += "```\n\n"
         markdown_content += f"Below are the contents of all files in the {'space' if is_hf else 'repository'}:\n\n"
         
         for item in contents:
             markdown_content += process_file_content(item, owner, repo, is_hf)
-    else:
+    else:  # Handle uploaded files
         markdown_content = "# Uploaded Files\n\n"
         markdown_content += "## File Structure\n```\n"
-        markdown_content += "📁 Uploads\n" + "\n".join([f"  📄 {file.filename}" for file in files]) + "\n"
+        markdown_content += generate_file_tree([file.filename for file in files])
         markdown_content += "```\n\n"
         markdown_content += "Below are the contents of all uploaded files:\n\n"
         for file in files:
@@ -157,6 +216,8 @@ def process():
         markdown_content = create_markdown_document(repo_url)
         html_content = markdown.markdown(markdown_content)
         owner, repo, _, is_hf = get_repo_contents(repo_url)
+        if not owner:
+            return jsonify({'error': markdown_content}), 400
         filename = f"{owner}_{repo}_summary.md"
     
     return jsonify({
@@ -170,7 +231,7 @@ def download():
     markdown_content = request.json.get('markdown')
     filename = request.json.get('filename')
     
-    buffer = BytesIO()
+    buffer = io.BytesIO()
     buffer.write(markdown_content.encode('utf-8'))
     buffer.seek(0)
     
@@ -238,10 +299,10 @@ html_template = """
 <body>
     <div class="container">
         <h1>Repository & Files to Markdown Converter</h1>
-        <p>Enter a GitHub/Hugging Face Space URL or upload files</p>
+        <p>Enter a GitHub/Hugging Face Space URL (e.g., https://huggingface.co/spaces/username/space)</p>
         <input type="text" id="repoUrl" style="width: 100%; padding: 8px;" placeholder="Enter GitHub or Hugging Face Space URL">
-        <p>OR</p>
-        <input type="file" id="fileInput" multiple style="margin: 10px 0;">
+        <p>OR upload files (select multiple files or a folder - folder upload supported in Chrome)</p>
+        <input type="file" id="fileInput" multiple webkitdirectory style="margin: 10px 0;">
         <br>
         <button onclick="processRepo()">Convert URL</button>
         <button onclick="processFiles()">Convert Files</button>
@@ -266,7 +327,7 @@ html_template = """
         async function processFiles() {
             const files = document.getElementById('fileInput').files;
             if (files.length === 0) {
-                alert('Please select at least one file');
+                alert('Please select at least one file or folder');
                 return;
             }