# Clone the repository
git clone https://github.com/burkaslarry/python_mysql_http.git
cd python_mysql_http

# Create virtual environment
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

cat > .env << EOF
# Database Type: mysql or postgresql
DB_TYPE=mysql

# MySQL Configuration
DB_HOST=localhost
DB_PORT=3306
DB_USER=root
DB_PASSWORD=your_password
DB_NAME=test_db
EOF

cat > .env << EOF
# Database Type: mysql or postgresql
DB_TYPE=postgresql

# PostgreSQL Configuration
DB_POSTGRES_HOST=localhost
DB_POSTGRES_PORT=5432
DB_POSTGRES_USER=postgres
DB_POSTGRES_PASSWORD=your_password
DB_POSTGRES_NAME=test_db
EOF

# For MySQL: Create test database
mysql -u root -p -e "CREATE DATABASE test_db;"

# For PostgreSQL: Create test database
psql -U postgres -c "CREATE DATABASE test_db;"

# Start the API server
python main.py
# or with auto-reload:
uvicorn main:app --reload --host 0.0.0.0 --port 8000

# Test the API
curl http://localhost:8000/
# Expected response: {"message": "Hello, World"}

# .env file configuration
cat > .env << EOF
DB_TYPE=mysql
DB_HOST=mydb.xxxxxxxxxxxx.us-east-1.rds.amazonaws.com
DB_PORT=3306
DB_USER=admin
DB_PASSWORD=YourSecurePassword123
DB_NAME=production_db
EOF

# .env file configuration
cat > .env << EOF
DB_TYPE=postgresql
DB_POSTGRES_HOST=mydb.xxxxxxxxxxxx.us-east-1.rds.amazonaws.com
DB_POSTGRES_PORT=5432
DB_POSTGRES_USER=postgres
DB_POSTGRES_PASSWORD=YourSecurePassword123
DB_POSTGRES_NAME=production_db
EOF

# Database Selection
DB_TYPE=mysql              # mysql or postgresql

# MySQL Settings (if DB_TYPE=mysql)
DB_HOST=localhost
DB_PORT=3306
DB_USER=root
DB_PASSWORD=password
DB_NAME=test_db

# PostgreSQL Settings (if DB_TYPE=postgresql)
DB_POSTGRES_HOST=localhost
DB_POSTGRES_PORT=5432
DB_POSTGRES_USER=postgres
DB_POSTGRES_PASSWORD=password
DB_POSTGRES_NAME=test_db

# API Server Settings
PORT=8000
ENVIRONMENT=development    # development or production
LOG_LEVEL=INFO

#!/bin/bash

RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

echo -e "${YELLOW}=== Python MySQL/PostgreSQL FastAPI Deployment ===${NC}\n"

show_menu() {
    echo "Choose an option:"
    echo "1. Run locally (development)"
    echo "2. Run tests"
    echo "3. Build Docker image"
    echo "4. Deploy to remote server"
    echo "5. Deploy to Heroku"
    echo "6. Exit"
    read -p "Enter choice [1-6]: " choice
}

run_local() {
    echo -e "${YELLOW}Starting API server locally...${NC}"
    python3 main.py
}

run_tests() {
    echo -e "${YELLOW}Running test suite...${NC}"
    python3 -m pytest test_main.py test_comprehensive.py -v --tb=short
    if [ $? -eq 0 ]; then
        echo -e "${GREEN}✓ All tests passed!${NC}\n"
    else
        echo -e "${RED}✗ Tests failed!${NC}\n"
    fi
}

build_docker() {
    echo -e "${YELLOW}Building Docker image...${NC}"
    read -p "Enter Docker image name (default: my-api): " image_name
    image_name=${image_name:-my-api}
    
    docker build -t $image_name:latest .
    
    if [ $? -eq 0 ]; then
        echo -e "${GREEN}✓ Docker image built: $image_name:latest${NC}"
        echo "To run: docker run -p 8000:8000 -e DB_HOST=... $image_name:latest"
    else
        echo -e "${RED}✗ Docker build failed!${NC}"
    fi
}

deploy_aws_ec2() {
    read -p "Enter EC2 instance IP/hostname: " ec2_host
    read -p "Enter SSH key path (default: ~/.ssh/id_rsa): " ssh_key
    ssh_key=${ssh_key:-~/.ssh/id_rsa}
    
    echo -e "${YELLOW}Deploying to AWS EC2: $ec2_host${NC}"
    
    ssh -i $ssh_key ec2-user@$ec2_host << 'DEPLOY'
        # Install Docker on Amazon Linux
        sudo yum update -y
        sudo amazon-linux-extras install docker -y
        sudo systemctl start docker
        sudo systemctl enable docker
        
        # Create app directory
        mkdir -p ~/app && cd ~/app
        
        # Create .env file (customize these values)
        cat > .env << 'ENV'
DB_TYPE=mysql
DB_HOST=your_remote_db_host
DB_PORT=3306
DB_USER=your_user
DB_PASSWORD=your_password
DB_NAME=your_database
PORT=8000
ENV
        
        # Pull and run Docker image
        docker pull your_docker_registry/my-api:latest
        docker run -d --restart always \
            --name my-api \
            -p 8000:8000 \
            --env-file .env \
            your_docker_registry/my-api:latest
DEPLOY
    
    echo -e "${GREEN}✓ Deployed to AWS EC2${NC}"
    echo "API available at: http://$ec2_host:8000"
}

deploy_digitalocean() {
    read -p "Enter Droplet IP address: " do_host
    read -p "Enter SSH key path (default: ~/.ssh/id_rsa): " ssh_key
    ssh_key=${ssh_key:-~/.ssh/id_rsa}
    
    echo -e "${YELLOW}Deploying to DigitalOcean: $do_host${NC}"
    
    ssh -i $ssh_key root@$do_host << 'DEPLOY'
        # Update system
        apt-get update && apt-get upgrade -y
        
        # Install Docker
        curl -fsSL https://get.docker.com -o get-docker.sh
        sh get-docker.sh
        systemctl start docker
        systemctl enable docker
        
        # Create app directory
        mkdir -p /opt/app && cd /opt/app
        
        # Create .env file
        cat > .env << 'ENV'
DB_TYPE=postgresql
DB_POSTGRES_HOST=your_remote_db_host
DB_POSTGRES_PORT=5432
DB_POSTGRES_USER=postgres
DB_POSTGRES_PASSWORD=your_password
DB_POSTGRES_NAME=your_database
PORT=8000
ENV
        
        # Pull and run Docker image
        docker pull your_docker_registry/my-api:latest
        docker run -d --restart always \
            --name my-api \
            -p 8000:8000 \
            --env-file .env \
            your_docker_registry/my-api:latest
DEPLOY
    
    echo -e "${GREEN}✓ Deployed to DigitalOcean${NC}"
    echo "API available at: http://$do_host:8000"
}

deploy_heroku() {
    echo -e "${YELLOW}=== Heroku Deployment ===${NC}\n"
    
    if ! command -v heroku &> /dev/null; then
        echo "Installing Heroku CLI..."
        curl https://cli-assets.heroku.com/install.sh | sh
    fi
    
    read -p "Enter Heroku app name: " heroku_app
    
    echo "Logging into Heroku..."
    heroku login
    
    echo "Creating Heroku app..."
    heroku create $heroku_app 2>/dev/null || true
    
    echo "Setting environment variables..."
    heroku config:set --app $heroku_app \
        DB_TYPE=postgresql \
        DB_POSTGRES_HOST=your_db_host \
        DB_POSTGRES_USER=your_user \
        DB_POSTGRES_PASSWORD=your_password \
        DB_POSTGRES_NAME=your_database
    
    echo "Deploying to Heroku..."
    git push heroku main
    
    echo -e "${GREEN}✓ Deployed to Heroku${NC}"
    echo "API available at: https://$heroku_app.herokuapp.com"
}

# Main loop
while true; do
    show_menu
    
    case $choice in
        1)
            run_local
            ;;
        2)
            run_tests
            ;;
        3)
            build_docker
            ;;
        4)
            echo ""
            echo "Choose deployment platform:"
            echo "1. AWS EC2"
            echo "2. DigitalOcean"
            echo "3. Linode (manual SSH)"
            echo "4. Google Cloud (manual SSH)"
            echo "5. Azure (manual SSH)"
            read -p "Enter choice [1-5]: " deploy_choice
            
            case $deploy_choice in
                1) deploy_aws_ec2 ;;
                2) deploy_digitalocean ;;
                *)
                    echo -e "${YELLOW}For other platforms, use manual SSH deployment${NC}"
                    echo "Commands: git clone, install docker, pull image, run container"
                    ;;
            esac
            ;;
        5)
            deploy_heroku
            ;;
        6)
            echo -e "${GREEN}Goodbye!${NC}"
            exit 0
            ;;
        *)
            echo -e "${RED}Invalid choice. Please try again.${NC}"
            ;;
    esac
done

chmod +x deploy.sh
./deploy.sh

# Start the server in background
python main.py &

# Test root endpoint
curl http://localhost:8000/

# Test with database
curl -X POST http://localhost:8000/api/users \
  -H "Content-Type: application/json" \
  -d '{"input": {"name": "John", "email": "john@example.com"}}'

# Run all tests
python -m pytest test_main.py test_comprehensive.py -v

# Run specific test file
python -m pytest test_comprehensive.py -v

# Run with coverage report
python -m pytest --cov=app test_main.py

docker build -t my-api:latest .

docker run -d \
  -p 8000:8000 \
  -e DB_TYPE=mysql \
  -e DB_HOST=mysql-db \
  -e DB_PORT=3306 \
  -e DB_USER=root \
  -e DB_PASSWORD=password \
  -e DB_NAME=test_db \
  --name my-api \
  my-api:latest

# Check logs
docker logs my-api

# Stop container
docker stop my-api

docker-compose up -d
# API available at: http://localhost:8000
# MySQL: localhost:3306
# PostgreSQL: localhost:5432

curl -X POST http://localhost:8000/api/users \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "name": "John Doe",
      "email": "john@example.com",
      "age": 30
    }
  }'

curl http://localhost:8000/api/users/query

curl -X POST http://localhost:8000/api/users/query \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "age": 30
    }
  }'

curl -X PUT http://localhost:8000/api/users \
  -H "Content-Type: application/json" \
  -d '{
    "input": {"age": 31},
    "where": {"id": 1}
  }'

curl -X DELETE http://localhost:8000/api/users \
  -H "Content-Type: application/json" \
  -d '{
    "input": {"id": 1}
  }'

curl -X POST http://localhost:8000/api/batch/import \
  -F "file=@users.csv"

curl http://localhost:8000/api/batch/users/export -o users.csv