Deployment 1

Dockerfile

@@ -1,26 +1,23 @@
-# Use an official Python runtime as a parent image
-FROM python:3.8-slim
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
 
-# Set the working directory in the container
-WORKDIR /app
-
-# Copy the current directory contents into the container at /app
-COPY . /app
+FROM python:3.9
 
-# Create necessary directories with the correct permissions
-RUN mkdir -p /app/temp_uploads /app/output && chmod -R 777 /app/temp_uploads /app/output
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
 
-# Create a virtual environment
-RUN python -m venv venv
-
-# Activate the virtual environment and install any needed packages specified in requirements.txt
-RUN . venv/bin/activate && pip install --no-cache-dir -r requirements.txt
+WORKDIR /app
 
-# Make port 8080 available to the world outside this container
-EXPOSE 8080
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir numpy && \
+    pip install --no-cache-dir pandas && \
+    pip install --no-cache-dir torch && \
+    pip install --no-cache-dir -r requirements.txt
 
-# Define environment variable
-ENV PORT=8080
+# Make sure directories exist for file operations
+RUN mkdir -p temp_uploads output
 
-# Run app.py with Gunicorn when the container launches
-CMD ["venv/bin/gunicorn", "--bind", "0.0.0.0:8080", "--timeout", "300", "app:app"]
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,31 +1,61 @@
 import os
-from flask import Flask, request, send_file, jsonify
-from flask_cors import CORS
-from werkzeug.utils import secure_filename
-import traceback
+import sys
 import logging
-import shutil
-from synthetic_data_pipeline import SyntheticDataPipeline
-import time
 
-# Setup logging
-logging.basicConfig(level=logging.DEBUG)
+# Set up logging first
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-app = Flask(__name__)
-# Setup CORS with Render domains
-CORS(app, origins=["*"], 
-     supports_credentials=True,
-     methods=["GET", "POST"],
-     allow_headers=["Content-Type"])
-
-app.config['UPLOAD_FOLDER'] = 'temp_uploads'
-app.config['OUTPUT_FOLDER'] = 'output'
-app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max file size
+try:
+    # Check versions before importing other libraries
+    import numpy as np
+    import pandas as pd
+    logger.info(f"NumPy version: {np.__version__}")
+    logger.info(f"Pandas version: {pd.__version__}")
+    
+    try:
+        import torch
+        logger.info(f"PyTorch version: {torch.__version__}")
+    except ImportError as e:
+        logger.warning(f"PyTorch import error: {str(e)}")
+    
+    from fastapi import FastAPI, UploadFile, File, Form
+    from fastapi.responses import FileResponse, JSONResponse
+    from fastapi.middleware.cors import CORSMiddleware
+    import traceback
+    import shutil
+    import tempfile
+    import uvicorn  # Import uvicorn for running the server
+    
+    try:
+        from synthetic_data_pipeline import SyntheticDataPipeline
+        import time
+    except ImportError as e:
+        logger.error(f"Failed to import SyntheticDataPipeline: {str(e)}")
+        raise
+except ImportError as e:
+    logger.error(f"Import error: {str(e)}")
+    logger.error("Try checking package compatibility or downgrading packages")
+    sys.exit(1)
+
+app = FastAPI(title="Synthetic Data Generator")
+
+# Setup CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Configuration
+UPLOAD_FOLDER = 'temp_uploads'
+OUTPUT_FOLDER = 'output'
 
 # Create necessary directories
-os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-os.makedirs(app.config['OUTPUT_FOLDER'], exist_ok=True)
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+os.makedirs(OUTPUT_FOLDER, exist_ok=True)
 
 def cleanup_output_directory(directory):
     """Remove all files in the output directory except .gitkeep"""
@@ -47,95 +77,106 @@ def cleanup_output_directory(directory):
             except Exception as e:
                 logger.error(f'Error deleting {file_path}: {e}')
 
-@app.route('/health', methods=['GET'])
+@app.get("/")
+def root():
+    return {"message": "Synthetic Data Generator API", "numpy_version": np.__version__}
+
+@app.get("/health")
 def health_check():
     try:
-        return jsonify({"status": "healthy"}), 200
+        return {"status": "healthy", "numpy_version": np.__version__}
     except Exception as e:
         logger.error(f"Health check failed: {str(e)}")
-        return jsonify({"status": "unhealthy", "error": str(e)}), 500
+        return JSONResponse(
+            status_code=500,
+            content={"status": "unhealthy", "error": str(e)}
+        )
 
-@app.route('/generate', methods=['POST'])
-def generate_synthetic_data():
+@app.post("/generate")
+async def generate_synthetic_data(
+    file: UploadFile = File(...),
+    categorical_columns: str = Form(...),
+    num_samples: int = Form(1000)
+):
     try:
         # Clean up output directory before starting
-        cleanup_output_directory(app.config['OUTPUT_FOLDER'])
+        cleanup_output_directory(OUTPUT_FOLDER)
         logger.info("Cleaned up output directory")
 
-        if 'file' not in request.files:
-            return jsonify({'error': 'No file provided'}), 400
+        # Save uploaded file to temp location
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.csv')
+        try:
+            contents = await file.read()
+            temp_file.write(contents)
+            temp_file.close()
+            filepath = temp_file.name
             
-        file = request.files['file']
-        if file.filename == '':
-            return jsonify({'error': 'No file selected'}), 400
-
-        # Save uploaded file
-        filename = secure_filename(file.filename)
-        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
-        file.save(filepath)
-
-        logger.info(f"File saved to {filepath}")
-
-        # Get configuration from request
-        config = request.form.to_dict()
-        categorical_columns = [
-            col.strip() 
-            for col in config.get('categorical_columns', '').replace('"', '').replace("'", '').split(',')
-            if col.strip()
-        ]
-        
-        if not categorical_columns:
-            return jsonify({'error': 'No valid categorical columns provided'}), 400
+            logger.info(f"File saved to {filepath}")
             
-        try:
-            num_samples = int(config.get('num_samples', 1000))
-        except ValueError:
-            return jsonify({'error': 'Invalid number of samples'}), 400
-
-        logger.info(f"Processing with categorical columns: {categorical_columns}")
-        logger.info(f"Number of samples requested: {num_samples}")
-
-        # Run pipeline with kwargs
-        pipeline = SyntheticDataPipeline(
-            input_file=filepath,
-            categorical_columns=categorical_columns,
-            output_dir=os.path.abspath(app.config['OUTPUT_FOLDER'])
-        )
-        
-        pipeline.run_pipeline(
-            num_samples=num_samples,
-            epochs=100,
-            chunk_size=10000
-        )
-
-        # Get latest generated file
-        output_dir = pipeline.output_dir
-        files = [f for f in os.listdir(output_dir) if f.startswith("synthetic_data_")]
-        
-        if not files:
-            raise Exception("No output file generated")
+            # Parse categorical columns
+            categorical_columns_list = [
+                col.strip() 
+                for col in categorical_columns.replace('"', '').replace("'", '').split(',')
+                if col.strip()
+            ]
             
-        latest_file = sorted(files)[-1]
-        output_path = os.path.join(output_dir, latest_file)
-        
-        logger.info(f"Sending file: {output_path}")
-        
-        # Clean up
-        os.remove(filepath)
-        
-        return send_file(
-            output_path,
-            as_attachment=True,
-            download_name='synthetic_data.csv'
-        )
+            if not categorical_columns_list:
+                return JSONResponse(
+                    status_code=400,
+                    content={"error": "No valid categorical columns provided"}
+                )
+            
+            logger.info(f"Processing with categorical columns: {categorical_columns_list}")
+            logger.info(f"Number of samples requested: {num_samples}")
+            
+            # Run pipeline with kwargs
+            pipeline = SyntheticDataPipeline(
+                input_file=filepath,
+                categorical_columns=categorical_columns_list,
+                output_dir=os.path.abspath(OUTPUT_FOLDER)
+            )
+            
+            pipeline.run_pipeline(
+                num_samples=num_samples,
+                epochs=100,
+                chunk_size=10000
+            )
+            
+            # Get latest generated file
+            output_dir = pipeline.output_dir
+            files = [f for f in os.listdir(output_dir) if f.startswith("synthetic_data_")]
+            
+            if not files:
+                raise Exception("No output file generated")
+                
+            latest_file = sorted(files)[-1]
+            output_path = os.path.join(output_dir, latest_file)
+            
+            logger.info(f"Sending file: {output_path}")
+            
+            return FileResponse(
+                path=output_path,
+                filename="synthetic_data.csv",
+                media_type="text/csv"
+            )
+        finally:
+            # Clean up temp file
+            if os.path.exists(filepath):
+                os.unlink(filepath)
 
     except Exception as e:
         logger.error(f"Error in generate_synthetic_data: {str(e)}")
         logger.error(traceback.format_exc())
-        return jsonify({'error': str(e)}), 500
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )
 
-if __name__ == '__main__':
-    # Use Render's PORT environment variable
-    port = int(os.environ.get('PORT', 8080))
-    logger.info(f"Starting Flask app on port {port}")
-    app.run(host='0.0.0.0', port=port)
+# Add this section to run the server when the script is executed directly
+if __name__ == "__main__":
+    # Get port from environment variable or use default
+    port = int(os.environ.get("PORT", 7860))
+    logger.info(f"Starting FastAPI server on port {port}")
+    
+    # Start the server
+    uvicorn.run("app:app", host="0.0.0.0", port=port, reload=True)

main.py

@@ -0,0 +1,141 @@
+import os
+from flask import Flask, request, send_file, jsonify
+from flask_cors import CORS
+from werkzeug.utils import secure_filename
+import traceback
+import logging
+import shutil
+from synthetic_data_pipeline import SyntheticDataPipeline
+import time
+
+# Setup logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+# Setup CORS with Render domains
+CORS(app, origins=["*"], 
+     supports_credentials=True,
+     methods=["GET", "POST"],
+     allow_headers=["Content-Type"])
+
+app.config['UPLOAD_FOLDER'] = 'temp_uploads'
+app.config['OUTPUT_FOLDER'] = 'output'
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max file size
+
+# Create necessary directories
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+os.makedirs(app.config['OUTPUT_FOLDER'], exist_ok=True)
+
+def cleanup_output_directory(directory):
+    """Remove all files in the output directory except .gitkeep"""
+    for filename in os.listdir(directory):
+        if filename != '.gitkeep':
+            file_path = os.path.join(directory, filename)
+            try:
+                if os.path.isfile(file_path):
+                    # Add retry logic for locked files
+                    max_retries = 3
+                    for _ in range(max_retries):
+                        try:
+                            os.unlink(file_path)
+                            break
+                        except PermissionError:
+                            time.sleep(1)  # Wait before retry
+                elif os.path.isdir(file_path):
+                    shutil.rmtree(file_path, ignore_errors=True)
+            except Exception as e:
+                logger.error(f'Error deleting {file_path}: {e}')
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    try:
+        return jsonify({"status": "healthy"}), 200
+    except Exception as e:
+        logger.error(f"Health check failed: {str(e)}")
+        return jsonify({"status": "unhealthy", "error": str(e)}), 500
+
+@app.route('/generate', methods=['POST'])
+def generate_synthetic_data():
+    try:
+        # Clean up output directory before starting
+        cleanup_output_directory(app.config['OUTPUT_FOLDER'])
+        logger.info("Cleaned up output directory")
+
+        if 'file' not in request.files:
+            return jsonify({'error': 'No file provided'}), 400
+            
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({'error': 'No file selected'}), 400
+
+        # Save uploaded file
+        filename = secure_filename(file.filename)
+        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(filepath)
+
+        logger.info(f"File saved to {filepath}")
+
+        # Get configuration from request
+        config = request.form.to_dict()
+        categorical_columns = [
+            col.strip() 
+            for col in config.get('categorical_columns', '').replace('"', '').replace("'", '').split(',')
+            if col.strip()
+        ]
+        
+        if not categorical_columns:
+            return jsonify({'error': 'No valid categorical columns provided'}), 400
+            
+        try:
+            num_samples = int(config.get('num_samples', 1000))
+        except ValueError:
+            return jsonify({'error': 'Invalid number of samples'}), 400
+
+        logger.info(f"Processing with categorical columns: {categorical_columns}")
+        logger.info(f"Number of samples requested: {num_samples}")
+
+        # Run pipeline with kwargs
+        pipeline = SyntheticDataPipeline(
+            input_file=filepath,
+            categorical_columns=categorical_columns,
+            output_dir=os.path.abspath(app.config['OUTPUT_FOLDER'])
+        )
+        
+        pipeline.run_pipeline(
+            num_samples=num_samples,
+            epochs=100,
+            chunk_size=10000
+        )
+
+        # Get latest generated file
+        output_dir = pipeline.output_dir
+        files = [f for f in os.listdir(output_dir) if f.startswith("synthetic_data_")]
+        
+        if not files:
+            raise Exception("No output file generated")
+            
+        latest_file = sorted(files)[-1]
+        output_path = os.path.join(output_dir, latest_file)
+        
+        logger.info(f"Sending file: {output_path}")
+        
+        # Clean up
+        os.remove(filepath)
+        
+        return send_file(
+            output_path,
+            as_attachment=True,
+            download_name='synthetic_data.csv'
+        )
+
+    except Exception as e:
+        logger.error(f"Error in generate_synthetic_data: {str(e)}")
+        logger.error(traceback.format_exc())
+        return jsonify({'error': str(e)}), 500
+
+if __name__ == '__main__':
+    # Use Render's PORT environment variable
+    port = int(os.environ.get('PORT', 8080))
+    logger.info(f"Starting Flask app on port {port}")
+    app.run(host='0.0.0.0', port=port)

requirements.txt

@@ -1,12 +1,15 @@
 flask==2.0.1
 flask-cors==3.0.10
-pandas
-numpy
+pandas==2.1.1
+numpy<2.0.0
 --only-binary=:all: scikit-learn
-scikit-learn
+scikit-learn<1.4.0
 ctgan
 rdt==1.13.2
-torch==2.0.1
+torch>=2.2.0
 werkzeug==2.0.3
 gunicorn==21.2.0
-psutil==5.9.4
+psutil==5.9.4
+fastapi
+uvicorn[standard]
+python-multipart

synthetic_data_pipeline.py

@@ -10,6 +10,10 @@ from typing import List, Dict, Optional
 import shutil
 import tempfile
 
+# Check pandas version
+logger = logging.getLogger(__name__)
+logger.info(f"Using pandas version: {pd.__version__}")
+
 class SyntheticDataPipeline:
     def __init__(
         self,