Replace with updated NoteGenie version

.dockerignore

@@ -0,0 +1,14 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.env
+.venv
+env/
+venv/
+ENV/
+.idea/
+.vscode/
+.git/
+flask_session/
+*.log

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,2 +1,5 @@
-flask_session/
-utils/_pycache_/
+# Ignore Flask session data
+/flask_session/
+
+# Ignore Python cache files
+/utils/__pycache__/

Dockerfile

@@ -12,8 +12,10 @@ COPY . .
 # Create necessary directories
 RUN mkdir -p flask_session
 
-# Set permissions for flask_session directory
-RUN chmod -R 777 flask_session
+# Set permissions for flask_session directory and touch API key file
+RUN chmod -R 777 flask_session && \
+    touch api_key.txt && \
+    chmod 666 api_key.txt
 
 # Set environment variables
 ENV FLASK_APP=app.py

README.md

@@ -21,6 +21,15 @@ NoteGenie is an AI-powered Jupyter notebook generator that uses Google's Gemini
 - Download notebooks as .ipynb files
 - Streaming responses for a better user experience
 
+## Deployment on Hugging Face Spaces
+
+1. Create a new Space on Hugging Face
+2. Choose Docker template
+3. Upload this repository to the Space
+4. Set the following environment variables in your Space settings:
+   - SECRET_KEY: A secure random string for Flask sessions
+   - PORT: 7860 (default for Hugging Face Spaces)
+
 ## Local Development
 
 1. Install dependencies:
@@ -35,6 +44,21 @@ NoteGenie is an AI-powered Jupyter notebook generator that uses Google's Gemini
 
 3. Open http://localhost:5000 in your browser
 
+## Using Docker
+
+Build and run the Docker container:
+
+```bash
+docker build -t notegenie .
+docker run -p 7860:7860 -e SECRET_KEY=your_secret_key notegenie
+```
+
+## Environment Variables
+
+- SECRET_KEY: Secret key for Flask session encryption
+- PORT: Port to run the application on (defaults to 5000 locally, 7860 for Hugging Face)
+- FLASK_ENV: Set to "development" for debug mode, "production" for production
+
 ## API Key Setup
 
 NoteGenie requires a Google Gemini API key. Users can set their own API key in the web interface.

app.py

@@ -4,9 +4,17 @@ import google.generativeai as genai
 import json
 import uuid
 import os
+import logging
 from utils.ai_helpers import generate_notebook, stream_notebook_generation, stream_notebook_edit, edit_notebook
 from utils.notebook_helpers import format_notebook, extract_notebook_info
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - notegenie - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger()
+
 app = Flask(__name__)
 app.config["SECRET_KEY"] = os.environ.get("SECRET_KEY", "notegenie-secret-key-change-in-production")
 app.config["SESSION_TYPE"] = "filesystem"
@@ -16,6 +24,9 @@ app.config["PERMANENT_SESSION_LIFETIME"] = 60 * 60 * 24 * 30  # 30 days
 app.config["SESSION_FILE_DIR"] = os.path.join(os.path.dirname(os.path.abspath(__file__)), "flask_session")
 os.makedirs(app.config["SESSION_FILE_DIR"], exist_ok=True)  # Ensure directory exists
 
+# Set a more permissive file mode for session files to avoid permission issues
+app.config["SESSION_FILE_MODE"] = 0o666
+
 Session(app)
 
 # Map front-end model names to API model names
@@ -28,8 +39,22 @@ MODEL_MAPPING = {
 def get_api_model_name(frontend_model_name):
     return MODEL_MAPPING.get(frontend_model_name, frontend_model_name)
 
+# Function to get API key from different sources
+def get_api_key():
+    # Try to get from session first
+    api_key = session.get("api_key")
+    
+    # Try to get from request header or param (for direct API calls)
+    if not api_key:
+        api_key = request.headers.get("X-API-Key") or request.args.get("api_key")
+    
+    return api_key
+
 @app.route("/", methods=["GET"])
 def index():
+    # Test session functionality
+    session["session_test"] = True
+    logger.info(f"Session check - variables: {list(session.keys())}")
     return render_template("index.html")
 
 @app.route("/set_api_key", methods=["POST"])
@@ -44,19 +69,26 @@ def set_api_key():
         model = genai.GenerativeModel("gemini-2.0-pro-exp-02-05")
         response = model.generate_content("Say 'API key is valid'")
         
-        # Store API key in session with permanent flag
+        # Store API key in session only
         session.permanent = True
         session["api_key"] = api_key
         
+        logger.info("API key successfully set and validated")
         return jsonify({"success": True})
     except Exception as e:
+        logger.error(f"API key validation error: {str(e)}")
         return jsonify({"success": False, "message": str(e)}), 400
 
 @app.route("/generate_notebook", methods=["GET", "POST"])
 def generate_notebook_route():
-    if "api_key" not in session:
+    api_key = get_api_key()
+    if not api_key:
+        logger.warning("Generate notebook request without API key")
         return jsonify({"success": False, "message": "API key not set"}), 401
     
+    # Always configure genai with the API key for each request
+    genai.configure(api_key=api_key)
+    
     # Handle both GET (for streaming) and POST requests
     if request.method == "GET":
         prompt = request.args.get("prompt")
@@ -75,8 +107,6 @@ def generate_notebook_route():
     # Map the frontend model name to the API model name
     api_model_name = get_api_model_name(model_name)
     
-    genai.configure(api_key=session["api_key"])
-    
     try:
         # OPTIMIZATION: If format_only is True, skip the AI call and just format the provided content
         if request.method == "POST" and format_only:
@@ -105,17 +135,14 @@ def generate_notebook_route():
                 "description": notebook_info["description"]
             })
     except Exception as e:
-        print(f"Error: Failed to generate notebook: {str(e)}")
-        print("Detailed exception information:")
-        import traceback
-        traceback.print_exc()
-        # Still raise the user-friendly message to the UI if needed
-        raise Exception("Failed to generate notebook. Please check terminal for details.")
+        logger.error(f"Error generating notebook: {str(e)}")
+        return jsonify({"success": False, "message": str(e)}), 500
 
 @app.route("/prepare_edit_notebook", methods=["POST"])
 def prepare_edit_notebook():
     """Store the notebook in the session for editing."""
-    if "api_key" not in session:
+    api_key = get_api_key()
+    if not api_key:
         return jsonify({"success": False, "message": "API key not set"}), 401
     
     data = request.json
@@ -125,15 +152,19 @@ def prepare_edit_notebook():
         return jsonify({"success": False, "message": "Notebook content is required"}), 400
     
     # Store the notebook in the session for later access
-    session["current_notebook"] = notebook_json
+    session["current_notebook"] = json.dumps(notebook_json)  # Store as JSON string
     
     return jsonify({"success": True})
 
 @app.route("/edit_notebook", methods=["GET", "POST"])
 def edit_notebook_route():
-    if "api_key" not in session:
+    api_key = get_api_key()
+    if not api_key:
         return jsonify({"success": False, "message": "API key not set"}), 401
     
+    # Always configure genai with the API key for each request
+    genai.configure(api_key=api_key)
+    
     # Get edit prompt and current notebook
     if request.method == "GET":
         edit_prompt = request.args.get("edit_prompt")
@@ -141,6 +172,8 @@ def edit_notebook_route():
         stream = request.args.get("stream", "true").lower() == "true"
         # For GET streaming requests, get notebook from session
         notebook_json = session.get("current_notebook")
+        if notebook_json:
+            notebook_json = json.loads(notebook_json)  # Parse JSON string back to dict
     else:
         data = request.json
         edit_prompt = data.get("edit_prompt")
@@ -157,8 +190,6 @@ def edit_notebook_route():
     # Map the frontend model name to the API model name
     api_model_name = get_api_model_name(model_name)
     
-    genai.configure(api_key=session["api_key"])
-    
     try:
         if stream:
             return stream_notebook_edit(edit_prompt, notebook_json, api_model_name)
@@ -200,6 +231,26 @@ def download_notebook():
     
     return response
 
+# Add a session diagnostic endpoint
+@app.route("/check_session", methods=["GET"])
+def check_session():
+    # For debugging only - would be disabled in production
+    session_data = {
+        "has_api_key": "api_key" in session,
+        "session_vars": list(session.keys()),
+        "session_file_dir_exists": os.path.exists(app.config["SESSION_FILE_DIR"]),
+        "session_file_dir_writable": os.access(app.config["SESSION_FILE_DIR"], os.W_OK),
+    }
+    
+    # Check if running on Hugging Face Spaces
+    is_hf_space = "SPACE_ID" in os.environ
+    session_data["is_huggingface_space"] = is_hf_space
+    
+    if is_hf_space:
+        logger.info("Running on Hugging Face Spaces environment")
+    
+    return jsonify(session_data)
+
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 5000))
     app.run(host="0.0.0.0", port=port, debug=(os.environ.get("FLASK_ENV") == "development"))

static/js/main.js

@@ -111,6 +111,14 @@ document.addEventListener('DOMContentLoaded', function() {
         // Prevent multiple rapid clicks
         if (isActionInProgress) return;
         
+        // Check if API key is set
+        const apiKey = localStorage.getItem('notegenie_api_key');
+        if (!apiKey) {
+            addSystemMessage('<i class="bi bi-exclamation-triangle"></i> API key is not set. Please set your API key first.');
+            showApiKeyModal();
+            return;
+        }
+        
         // Get the prompt text and check if it's empty
         const prompt = promptInputEl.value.trim();
         
@@ -253,12 +261,26 @@ document.addEventListener('DOMContentLoaded', function() {
         const aiMessageId = 'ai-typing-' + Date.now();
         addTypingIndicator(aiMessageId);
         
+        // Update AI message to show we're starting the edit
+        updateAiMessage(aiMessageId, "**NoteGenie:** Starting to edit your notebook...");
+        
         handleEditStreamingResponse(editPrompt, currentNotebook, modelName, aiMessageId);
         
         // Clear the input field after sending
         promptInputEl.value = '';
     }
     
+    // Create a custom EventSource that supports headers 
+    function createEventSourceWithHeaders(url, headers) {
+        if (typeof EventSourcePolyfill !== 'undefined') {
+            return new EventSourcePolyfill(url, { headers: headers });
+        }
+        
+        // If native EventSource is all we have but we need headers, 
+        // we fall back to using URL parameters for authentication
+        return new EventSource(url);
+    }
+
     function handleStreamingResponse(prompt, modelName, aiMessageId) {
         aiResponseText = '';
         
@@ -295,12 +317,29 @@ document.addEventListener('DOMContentLoaded', function() {
             }
         }, 5000); // Check every 5 seconds
         
-        // Create a new event source
-        eventSource = new EventSource(`/generate_notebook?${new URLSearchParams({
+        // Get API key from localStorage as a backup
+        const backupApiKey = localStorage.getItem('notegenie_api_key');
+        
+        // Create URL parameters including API key as fallback
+        const urlParams = new URLSearchParams({
             prompt: prompt,
             model: modelName,
             stream: true
-        }).toString()}`);
+        });
+        
+        // Add API key to URL params if available from localStorage (as a fallback)
+        if (backupApiKey) {
+            urlParams.append('api_key', backupApiKey);
+        }
+        
+        // Set headers with API key if available
+        const headers = {};
+        if (backupApiKey) {
+            headers['X-API-Key'] = backupApiKey;
+        }
+        
+        // Create a new event source with API key included in both URL and headers
+        eventSource = createEventSourceWithHeaders(`/generate_notebook?${urlParams.toString()}`, headers);
         
         eventSource.onmessage = function(event) {
             // Update our last-activity timestamp
@@ -411,14 +450,24 @@ document.addEventListener('DOMContentLoaded', function() {
         let lastPreviewUpdate = 0;
         const PREVIEW_UPDATE_INTERVAL = 1000; // Update preview every 1 second during streaming, same as generate
         
+        // Get API key from localStorage as a backup
+        const backupApiKey = localStorage.getItem('notegenie_api_key');
+        
+        // Make sure notebook is in proper format before sending
+        const notebookToSend = typeof notebook === 'string' ? JSON.parse(notebook) : notebook;
+        
+        console.log('Sending notebook for editing:', notebookToSend); // Debug log
+        
         // First, send the notebook data to the server so it's available in the session
         fetch('/prepare_edit_notebook', {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
+                // Add API key as header if available
+                ...(backupApiKey && {'X-API-Key': backupApiKey})
             },
             body: JSON.stringify({
-                notebook: notebook
+                notebook: notebookToSend
             })
         })
         .then(response => {
@@ -429,12 +478,28 @@ document.addEventListener('DOMContentLoaded', function() {
         })
         .then(data => {
             if (data.success) {
-                // Now create a new event source for editing - the notebook is now in the session
-                eventSource = new EventSource(`/edit_notebook?${new URLSearchParams({
+                updateAiMessage(aiMessageId, "**NoteGenie:** Processing your edit request...");
+                
+                // Create URL parameters including API key as fallback
+                const urlParams = new URLSearchParams({
                     edit_prompt: editPrompt,
                     model: modelName,
                     stream: true
-                }).toString()}`);
+                });
+                
+                // Add API key to URL params if available from localStorage (as a fallback)
+                if (backupApiKey) {
+                    urlParams.append('api_key', backupApiKey);
+                }
+                
+                // Set headers with API key if available
+                const headers = {};
+                if (backupApiKey) {
+                    headers['X-API-Key'] = backupApiKey;
+                }
+                
+                // Now create a new event source for editing with the API key included in both URL and headers
+                eventSource = createEventSourceWithHeaders(`/edit_notebook?${urlParams.toString()}`, headers);
                 
                 // Track the last time we got a chunk - for timeout detection
                 let lastChunkTime = Date.now();
@@ -569,6 +634,7 @@ document.addEventListener('DOMContentLoaded', function() {
         .catch(error => {
             console.error('Error preparing notebook for edit:', error);
             updateAiMessage(aiMessageId, '**Error:** ' + error.message);
+            notebookPreviewEl.innerHTML = '<div class="alert alert-danger">Error: Failed to prepare notebook for editing. Please try regenerating the notebook.</div>';
             setGeneratingState(false);
         });
     }

templates/index.html

@@ -16,6 +16,30 @@
     <link href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism.min.css" rel="stylesheet">
     <!-- Custom styles -->
     <link href="{{ url_for('static', filename='css/style.css') }}" rel="stylesheet">
+    <link rel="icon" type="image/png" href="{{ url_for('static', filename='images/favicon.png') }}">
+    <script>
+    document.fonts.ready.then(() => {
+        var canvas = document.createElement('canvas');
+        canvas.width = 64;
+        canvas.height = 64;
+        var ctx = canvas.getContext('2d');
+        ctx.fillStyle = '#4285f4'; // use desired color matching the logo-icon
+        ctx.font = '48px "Material Icons"';
+        ctx.textAlign = 'center';
+        ctx.textBaseline = 'middle';
+        ctx.fillText('auto_awesome', 32, 32);
+        var dataURL = canvas.toDataURL();
+        var link = document.querySelector('link[rel="icon"]');
+        if(link) {
+            link.href = dataURL;
+        } else {
+            var newLink = document.createElement('link');
+            newLink.rel = 'icon';
+            newLink.href = dataURL;
+            document.head.appendChild(newLink);
+        }
+    });
+    </script>
 </head>
 <body>
     <div class="app-container">

utils/error_handler.py

@@ -1,24 +0,0 @@
-import logging
-import traceback
-import sys
-
-# Configure logging to output to terminal
-logging.basicConfig(
-    level=logging.DEBUG,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    stream=sys.stderr
-)
-
-logger = logging.getLogger('NoteGenie')
-
-def handle_error(func):
-    """Decorator to handle exceptions and log them to terminal"""
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except Exception as e:
-            logger.error(f"Error in {func.__name__}: {str(e)}")
-            logger.error(traceback.format_exc())
-            # You can still raise a user-friendly error for the UI
-            raise Exception("Failed to generate notebook. Please check terminal for details.")
-    return wrapper