Update app.py

app.py

@@ -1,19 +1,33 @@
-from flask import Flask, request, send_file, jsonify 
+from flask import Flask, request, send_file, jsonify
 from flask_cors import CORS
 import fitz  # PyMuPDF
 import os
 import tempfile
+import shutil
 
 app = Flask(__name__)
-CORS(app)  # Allow all origins by default (or restrict via origins=["http://localhost:3000"])
+CORS(app)  # This will allow all origins
 
-def compress_pdf(input_path, output_path):
+def compress_pdf(input_path, output_path, compression_level=4):
     """
     Compresses a PDF using PyMuPDF with deflate and garbage collection.
+    Allows adjusting the compression level (1-4, higher = more compression)
     """
-    doc = fitz.open(input_path)
-    doc.save(output_path, garbage=4, deflate=True, clean=True)
-    doc.close()
+    try:
+        doc = fitz.open(input_path)
+        doc.save(
+            output_path, 
+            garbage=compression_level,  # 4 is max compression
+            deflate=True, 
+            clean=True,
+            pretty=False,  # Disable pretty printing for smaller size
+            linear=True    # Create a linearized PDF
+        )
+        doc.close()
+        return True
+    except Exception as e:
+        print(f"Error compressing PDF: {str(e)}")
+        return False
 
 @app.route("/")
 def home():
@@ -21,39 +35,99 @@ def home():
 
 @app.route("/compress", methods=["POST"])
 def compress():
-    if 'pdf' not in request.files:
-        return jsonify({"error": "No PDF file uploaded."}), 400
-
-    target_size_str = request.form.get("target_size")
-    if not target_size_str:
-        return jsonify({"error": "Target size not specified."}), 400
-
+    # Track temporary directories to clean up
+    temp_dirs = []
+    
     try:
-        if target_size_str.lower().endswith("mb"):
-            target_kb = float(target_size_str[:-2]) * 1024
-        elif target_size_str.lower().endswith("kb"):
-            target_kb = float(target_size_str[:-2])
-        else:
-            target_kb = float(target_size_str)
-    except ValueError:
-        return jsonify({"error": "Invalid target size format."}), 400
-
-    pdf_file = request.files['pdf']
-
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as input_temp:
-        pdf_file.save(input_temp.name)
-        input_path = input_temp.name
-
-    output_path = input_path.replace(".pdf", "_compressed.pdf")
-    compress_pdf(input_path, output_path)
-
-    final_size_kb = os.path.getsize(output_path) / 1024
-
-    if final_size_kb > target_kb + 50:
-        os.remove(output_path)
-        return jsonify({"error": f"Unable to compress below {target_kb} KB. Compressed size was {int(final_size_kb)} KB."}), 500
-
-    return send_file(output_path, as_attachment=True, download_name="compressed.pdf")
+        if 'pdf' not in request.files:
+            return jsonify({"error": "No PDF file uploaded."}), 400
+        
+        target_size_str = request.form.get("target_size")
+        if not target_size_str:
+            return jsonify({"error": "Target size not specified."}), 400
+        
+        # Parse target size
+        try:
+            if target_size_str.lower().endswith("mb"):
+                target_kb = float(target_size_str[:-2]) * 1024
+            elif target_size_str.lower().endswith("kb"):
+                target_kb = float(target_size_str[:-2])
+            else:
+                target_kb = float(target_size_str)
+        except ValueError:
+            return jsonify({"error": "Invalid target size format."}), 400
+        
+        # Create a temporary directory
+        temp_dir = tempfile.mkdtemp()
+        temp_dirs.append(temp_dir)
+        
+        # Process PDF
+        pdf_file = request.files['pdf']
+        input_path = os.path.join(temp_dir, "input.pdf")
+        output_path = os.path.join(temp_dir, "compressed.pdf")
+        
+        pdf_file.save(input_path)
+        original_size_kb = os.path.getsize(input_path) / 1024
+        
+        print(f"Original size: {original_size_kb:.2f} KB, Target: {target_kb:.2f} KB")
+        
+        # Try different compression levels if needed
+        for compression_level in [4, 3, 2, 1]:
+            # If original file is already below target, just use it
+            if original_size_kb <= target_kb:
+                shutil.copy(input_path, output_path)
+                break
+                
+            compress_pdf(input_path, output_path, compression_level)
+            final_size_kb = os.path.getsize(output_path) / 1024
+            
+            print(f"Compression level {compression_level} result: {final_size_kb:.2f} KB")
+            
+            # If we reached target or can't compress anymore, stop
+            if final_size_kb <= target_kb or compression_level == 1:
+                break
+        
+        # Get final compressed size
+        final_size_kb = os.path.getsize(output_path) / 1024
+        
+        # If final size is too large, inform but still provide the file
+        if final_size_kb > target_kb:
+            return jsonify({
+                "warning": f"Unable to compress below {target_kb:.2f} KB. Best compressed size is {int(final_size_kb)} KB.",
+                "original_size_kb": round(original_size_kb, 2),
+                "compressed_size_kb": round(final_size_kb, 2),
+                "target_size_kb": round(target_kb, 2),
+                "compression_ratio": round((original_size_kb - final_size_kb) / original_size_kb * 100, 2),
+                "download_available": True
+            }), 200
+            
+        # Return the compressed file
+        response = send_file(output_path, as_attachment=True, download_name="compressed.pdf")
+        
+        # Add cleanup function to be called after response is sent
+        @response.call_on_close
+        def cleanup():
+            for dir_path in temp_dirs:
+                try:
+                    if os.path.exists(dir_path):
+                        shutil.rmtree(dir_path)
+                        print(f"Cleaned up temporary directory: {dir_path}")
+                except Exception as e:
+                    print(f"Error cleaning up {dir_path}: {str(e)}")
+                    
+        return response
+    
+    except Exception as e:
+        # Ensure cleanup in case of errors
+        for dir_path in temp_dirs:
+            try:
+                if os.path.exists(dir_path):
+                    shutil.rmtree(dir_path)
+            except:
+                pass  # Best effort cleanup
+                
+        print(f"Error in compression endpoint: {str(e)}")
+        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860)
+    app.run(host="0.0.0.0", port=7860)