rapidfireai 0.9.9__py3-none-any.whl → 0.9.11__py3-none-any.whl

rapidfireai/start.sh

@@ -7,13 +7,15 @@
 set -e  # Exit on any error
 
 # Configuration
-MLFLOW_PORT=5002
-MLFLOW_HOST=127.0.0.1
-FRONTEND_PORT=3000
-FRONTEND_HOST=0.0.0.0
+RF_MLFLOW_PORT=${RF_MLFLOW_PORT:=5002}
+RF_MLFLOW_HOST=${RF_MLFLOW_HOST:=127.0.0.1}
+RF_FRONTEND_PORT=${RF_FRONTEND_PORT:=3000}
+RF_FRONTEND_HOST=${RF_FRONTEND_HOST:=0.0.0.0}
 # API server configuration - these should match DispatcherConfig in constants.py
-API_PORT=8080
-API_HOST=127.0.0.1
+RF_API_PORT=${RF_API_PORT:=8080}
+RF_API_HOST=${RF_API_HOST:=127.0.0.1}
+
+RF_DB_PATH="${RF_DB_PATH:=$HOME/db}"
 
 # Colors for output
 RED='\033[0;31m'
@@ -23,13 +25,25 @@ BLUE='\033[0;34m'
 NC='\033[0m' # No Color
 
 # PID file to track processes
-PID_FILE="rapidfire_pids.txt"
+RF_PID_FILE="${RF_PID_FILE:=rapidfire_pids.txt}"
 
 # Directory paths for pip-installed package
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 DISPATCHER_DIR="$SCRIPT_DIR/dispatcher"
 FRONTEND_DIR="$SCRIPT_DIR/frontend"
 
+RF_PYTHON_EXECUTABLE=${RF_PYTHON_EXECUTABLE:-python3}
+RF_PIP_EXECUTABLE=${RF_PIP_EXECUTABLE:-pip3}
+
+if ! command -v $RF_PYTHON_EXECUTABLE &> /dev/null; then
+    RF_PYTHON_EXECUTABLE=python
+fi
+
+if ! command -v $RF_PIP_EXECUTABLE &> /dev/null; then
+    RF_PIP_EXECUTABLE=pip
+fi
+
+
 # Function to print colored output
 print_status() {
     echo -e "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')]${NC} $1"
@@ -50,44 +64,36 @@ print_warning() {
 # Function to setup Python environment
 setup_python_env() {
     print_status "Setting up Python environment..."
-    
+
     # Check if the package can be imported
     print_status "Verifying rapidfireai package availability..."
-    
-    if python3 -c "import rapidfireai; print('Package imported successfully with python3')" 2>/dev/null; then
-        print_success "rapidfireai package is available with python3"
+
+    if ${RF_PYTHON_EXECUTABLE} -c "import rapidfireai; print('Package imported successfully with ${RF_PYTHON_EXECUTABLE}')" 2>/dev/null; then
+        print_success "rapidfireai package is available with ${RF_PYTHON_EXECUTABLE}"
     else
-        print_error "rapidfireai package is not available with python3"
-        
-        # Try with python as fallback
-        print_status "Trying to import with python..."
-        if python -c "import rapidfireai; print('Package imported successfully with python')" 2>/dev/null; then
-            print_success "rapidfireai package is available with python"
-        else
-            print_error "rapidfireai package is not available with python"
-            print_warning "Try reinstalling the package: pip install rapidfireai"
-            return 1
-        fi
+        print_error "rapidfireai package is not available with ${RF_PYTHON_EXECUTABLE}"
+        print_warning "Try reinstalling the package: ${RF_PIP_EXECUTABLE} install rapidfireai"
+        return 1
     fi
-    
+
     # Install any missing dependencies
     print_status "Checking for required dependencies..."
-    if python3 -c "import mlflow, gunicorn, flask" 2>/dev/null; then
+    if ${RF_PYTHON_EXECUTABLE} -c "import mlflow, gunicorn, flask" 2>/dev/null; then
         print_success "All required dependencies are available"
     else
         print_warning "Some dependencies may be missing. Installing requirements..."
-        pip install mlflow gunicorn flask flask-cors
+        ${RF_PIP_EXECUTABLE} install mlflow gunicorn flask flask-cors
     fi
-    
+
     return 0
 }
 
 # Function to cleanup processes on exit
 cleanup() {
     print_warning "Shutting down services..."
-    
+
     # Kill processes by port (more reliable for MLflow)
-    for port in $MLFLOW_PORT $FRONTEND_PORT $API_PORT; do
+    for port in $RF_MLFLOW_PORT $RF_FRONTEND_PORT $RF_API_PORT; do
         local pids=$(lsof -ti :$port 2>/dev/null || true)
         if [[ -n "$pids" ]]; then
             print_status "Killing processes on port $port"
@@ -100,9 +106,9 @@ cleanup() {
             fi
         fi
     done
-    
+
     # Clean up tracked PIDs
-    if [[ -f "$PID_FILE" ]]; then
+    if [[ -f "$RF_PID_FILE" ]]; then
         while read -r pid service; do
             if kill -0 "$pid" 2>/dev/null; then
                 print_status "Stopping $service (PID: $pid)"
@@ -114,25 +120,25 @@ cleanup() {
                     kill -9 -$pid 2>/dev/null || kill -9 $pid 2>/dev/null || true
                 fi
             fi
-        done < "$PID_FILE"
-        rm -f "$PID_FILE"
+        done < "$RF_PID_FILE"
+        rm -f "$RF_PID_FILE"
     fi
-    
+
     # Final cleanup - kill any remaining MLflow, gunicorn, or Flask processes
     pkill -f "mlflow server" 2>/dev/null || true
     pkill -f "gunicorn.*rapidfireai" 2>/dev/null || true
     pkill -f "python3.*server.py" 2>/dev/null || true
     pkill -f "python.*server.py" 2>/dev/null || true
-    
+
     # Additional cleanup for any remaining processes on our ports
-    for port in $MLFLOW_PORT $FRONTEND_PORT $API_PORT; do
+    for port in $RF_MLFLOW_PORT $RF_FRONTEND_PORT $RF_API_PORT; do
         local remaining_pids=$(lsof -ti :$port 2>/dev/null || true)
         if [[ -n "$remaining_pids" ]]; then
             print_status "Force killing remaining processes on port $port"
             echo "$remaining_pids" | xargs kill -9 2>/dev/null || true
         fi
     done
-    
+
     print_success "All services stopped"
     exit 0
 }
@@ -141,7 +147,7 @@ cleanup() {
 check_port() {
     local port=$1
     local service=$2
-    
+
     if lsof -Pi :$port -sTCP:LISTEN -t >/dev/null 2>&1; then
         print_error "Port $port is already in use. Cannot start $service."
         print_status "Processes using port $port:"
@@ -154,40 +160,40 @@ check_port() {
 # Function to check for common startup issues
 check_startup_issues() {
     print_status "Checking for common startup issues..."
-    
+
     # Check Python version and packages
-    if command -v python3 &> /dev/null; then
-        local python_version=$(python3 --version 2>&1)
+    if command -v ${RF_PYTHON_EXECUTABLE} &> /dev/null; then
+        local python_version=$(${RF_PYTHON_EXECUTABLE} --version 2>&1)
         print_status "Python version: $python_version"
-        
+
         # Check for required packages
         local missing_packages=()
         for package in mlflow gunicorn flask; do
-            if ! python3 -c "import $package" 2>/dev/null; then
+            if ! ${RF_PYTHON_EXECUTABLE} -c "import $package" 2>/dev/null; then
                 missing_packages+=("$package")
             fi
         done
-        
+
         if [[ ${#missing_packages[@]} -gt 0 ]]; then
             print_warning "Missing packages: ${missing_packages[*]}"
             print_status "Installing missing packages..."
-            pip3 install "${missing_packages[@]}" || print_error "Failed to install packages"
+            ${RF_PIP_EXECUTABLE} install "${missing_packages[@]}" || print_error "Failed to install packages"
         fi
     fi
-    
+
     # Check disk space
     local available_space=$(df . | awk 'NR==2 {print $4}')
     if [[ $available_space -lt 1000000 ]]; then
         print_warning "Low disk space: ${available_space}KB available"
     fi
-    
+
     # Check if we can write to current directory
     if ! touch "$SCRIPT_DIR/test_write.tmp" 2>/dev/null; then
         print_error "Cannot write to script directory: $SCRIPT_DIR"
         return 1
     fi
     rm -f "$SCRIPT_DIR/test_write.tmp"
-    
+
     return 0
 }
 
@@ -198,18 +204,23 @@ wait_for_service() {
     local service=$3
     local max_attempts=${4:-30}  # Allow custom timeout, default 30 seconds
     local attempt=1
-    
-    print_status "Waiting for $service to be ready on $host:$port (timeout: ${max_attempts}s)..."
-    
+
+    print_status "Waiting for $service to be ready on $host:$port (timeout: ${max_attempts} attempts)..."
+
+    if command -v nc &> /dev/null; then
+        ping_command="$(command -v nc) -z $host $port"
+    else
+        ping_command="$RF_PYTHON_EXECUTABLE -c 'from rapidfireai.utils.ping import ping_server; checker=ping_server(\"${host}\", ${port}); exit(1) if not checker else exit(0)'"
+    fi
     while [ $attempt -le $max_attempts ]; do
-        if nc -z "$host" "$port" 2>/dev/null; then
+        if eval ${ping_command} &>/dev/null; then
             print_success "$service is ready!"
             return 0
         fi
         sleep 1
         ((attempt++))
     done
-    
+
     print_error "$service failed to start within expected time (${max_attempts}s)"
     return 1
 }
@@ -217,50 +228,52 @@ wait_for_service() {
 # Function to start MLflow server
 start_mlflow() {
     print_status "Starting MLflow server..."
-    
-    if ! check_port $MLFLOW_PORT "MLflow server"; then
+    print_status "Making Database directory $RF_DB_PATH..."
+    mkdir -p "$RF_DB_PATH"
+
+    if ! check_port $RF_MLFLOW_PORT "MLflow server"; then
         return 1
     fi
-    
+
     # Start MLflow server in background with logging
     print_status "MLflow logs will be written to: $SCRIPT_DIR/mlflow.log"
-    
+
     # Use setsid on Linux, nohup on macOS
     if command -v setsid &> /dev/null; then
         setsid mlflow server \
-            --host $MLFLOW_HOST \
-            --port $MLFLOW_PORT \
-            --backend-store-uri sqlite:///mlflow.db > "$SCRIPT_DIR/mlflow.log" 2>&1 &
+            --host $RF_MLFLOW_HOST \
+            --port $RF_MLFLOW_PORT \
+            --backend-store-uri sqlite:///${RF_DB_PATH}/mlflow.db > "$SCRIPT_DIR/mlflow.log" 2>&1 &
     else
         nohup mlflow server \
-            --host $MLFLOW_HOST \
-            --port $MLFLOW_PORT \
-            --backend-store-uri sqlite:///mlflow.db > "$SCRIPT_DIR/mlflow.log" 2>&1 &
+            --host $RF_MLFLOW_HOST \
+            --port $RF_MLFLOW_PORT \
+            --backend-store-uri sqlite:///${RF_DB_PATH}/mlflow.db > "$SCRIPT_DIR/mlflow.log" 2>&1 &
     fi
-    
+
     local mlflow_pid=$!
-    echo "$mlflow_pid MLflow" >> "$PID_FILE"
-    
+    echo "$mlflow_pid MLflow" >> "$RF_PID_FILE"
+
     # Wait for MLflow to be ready
-    if wait_for_service $MLFLOW_HOST $MLFLOW_PORT "MLflow server"; then
+    if wait_for_service $RF_MLFLOW_HOST $RF_MLFLOW_PORT "MLflow server"; then
         print_success "MLflow server started (PID: $mlflow_pid)"
         return 0
     else
         print_error "MLflow server failed to start. Checking for errors..."
-        
+
         # Check if process is still running
         if ! kill -0 "$mlflow_pid" 2>/dev/null; then
             print_error "MLflow process has died. Checking logs for startup errors:"
         else
             print_error "MLflow process is running but not responding. Checking logs:"
         fi
-        
+
         if [[ -f "$SCRIPT_DIR/mlflow.log" ]]; then
             echo "=== Last 30 lines of mlflow.log ==="
             tail -30 "$SCRIPT_DIR/mlflow.log"
             echo "=== End of logs ==="
             echo ""
-            
+
             # Look for specific error patterns
             if grep -q "Error\|Exception\|Traceback\|Failed\|ImportError\|ModuleNotFoundError" "$SCRIPT_DIR/mlflow.log"; then
                 print_error "Found error messages in logs:"
@@ -269,13 +282,13 @@ start_mlflow() {
         else
             print_error "No mlflow.log file found"
         fi
-        
+
         # Check if there are any Python errors in the process
         if kill -0 "$mlflow_pid" 2>/dev/null; then
             print_status "MLflow process details:"
             ps -p "$mlflow_pid" -o pid,ppid,cmd,etime 2>/dev/null || true
         fi
-        
+
         return 1
     fi
 }
@@ -283,57 +296,57 @@ start_mlflow() {
 # Function to start API server
 start_api_server() {
     print_status "Starting API server with Gunicorn..."
-    
+
     # Check if dispatcher directory exists
     if [[ ! -d "$DISPATCHER_DIR" ]]; then
         print_error "Dispatcher directory not found at $DISPATCHER_DIR"
         return 1
     fi
-    
+
     # Check if gunicorn config file exists
     if [[ ! -f "$DISPATCHER_DIR/gunicorn.conf.py" ]]; then
         print_error "gunicorn.conf.py not found in dispatcher directory"
         return 1
     fi
-    
+
     # Create database directory
     print_status "Creating database directory..."
     mkdir -p ~/db
     # Ensure proper permissions
     chmod 755 ~/db
-    
+
     # Change to dispatcher directory and start Gunicorn server
     cd "$DISPATCHER_DIR"
-    
+
     # Start Gunicorn server in background with logging
     print_status "API server logs will be written to: $SCRIPT_DIR/api.log"
     gunicorn -c gunicorn.conf.py > "$SCRIPT_DIR/api.log" 2>&1 &
-    
+
     local api_pid=$!
     cd "$SCRIPT_DIR"  # Return to original directory
-    echo "$api_pid API_Server" >> "$PID_FILE"
-    
+    echo "$api_pid API_Server" >> "$RF_PID_FILE"
+
     # Wait for API server to be ready - use longer timeout for API server
-    if wait_for_service $API_HOST $API_PORT "API server" 60; then
+    if wait_for_service $RF_API_HOST $RF_API_PORT "API server" 60; then
         print_success "API server started (PID: $api_pid)"
-        print_status "API server available at: http://$API_HOST:$API_PORT"
+        print_status "API server available at: http://$RF_API_HOST:$RF_API_PORT"
         return 0
     else
         print_error "API server failed to start. Checking for errors..."
-        
+
         # Check if process is still running
         if ! kill -0 "$api_pid" 2>/dev/null; then
             print_error "API process has died. Checking logs for startup errors:"
         else
             print_error "API process is running but not responding. Checking logs:"
         fi
-        
+
         if [[ -f "$SCRIPT_DIR/api.log" ]]; then
             echo "=== Last 30 lines of api.log ==="
             tail -30 "$SCRIPT_DIR/api.log"
             echo "=== End of logs ==="
             echo ""
-            
+
             # Look for specific error patterns
             if grep -q "Error\|Exception\|Traceback\|Failed\|ImportError\|ModuleNotFoundError" "$SCRIPT_DIR/api.log"; then
                 print_error "Found error messages in logs:"
@@ -342,13 +355,13 @@ start_api_server() {
         else
             print_error "No api.log file found"
         fi
-        
+
         # Check if there are any Python errors in the process
         if kill -0 "$api_pid" 2>/dev/null; then
             print_status "API process details:"
             ps -p "$api_pid" -o pid,ppid,cmd,etime 2>/dev/null || true
         fi
-        
+
         return 1
     fi
 }
@@ -356,97 +369,97 @@ start_api_server() {
 # Function to start frontend server
 start_frontend() {
     print_status "Starting frontend tracking server..."
-    
-    if ! check_port $FRONTEND_PORT "Frontend server"; then
+
+    if ! check_port $RF_FRONTEND_PORT "Frontend server"; then
         return 1
     fi
-    
+
     # Check if frontend directory exists
     if [[ ! -d "$FRONTEND_DIR" ]]; then
         print_error "Frontend directory not found at $FRONTEND_DIR"
         return 1
     fi
-    
+
     # Change to frontend directory
     cd "$FRONTEND_DIR"
-    
+
     # Check if build directory exists
     if [[ ! -d "build" ]]; then
         print_error "Build directory not found. Please run 'npm run build' in the frontend directory first."
         cd "$SCRIPT_DIR"
         return 1
     fi
-    
+
     # Check if Flask server exists
     if [[ ! -f "server.py" ]]; then
         print_error "Flask server (server.py) not found in frontend directory"
         cd "$SCRIPT_DIR"
         return 1
     fi
-    
+
     # Test if the server can be imported without errors
     print_status "Testing frontend server imports..."
-    if ! python3 -c "import server" 2>/dev/null; then
+    if ! ${RF_PYTHON_EXECUTABLE} -c "import server" 2>/dev/null; then
         print_error "Frontend server has import errors. Testing with verbose output:"
-        python3 -c "import server" 2>&1 | head -20
+        ${RF_PYTHON_EXECUTABLE} -c "import server" 2>&1 | head -20
         cd "$SCRIPT_DIR"
         return 1
     fi
     print_success "Frontend server imports successfully"
-    
+
     print_status "Starting production frontend server with Flask..."
-    
+
     # Start Flask server in background with process group
     print_status "Frontend logs will be written to: $SCRIPT_DIR/frontend.log"
     cd "$FRONTEND_DIR"
-    
+
     # Use setsid on Linux, nohup on macOS for better process management
     if command -v setsid &> /dev/null; then
-        PORT=$FRONTEND_PORT setsid python3 server.py > "$SCRIPT_DIR/frontend.log" 2>&1 &
+        PORT=$RF_FRONTEND_PORT setsid ${RF_PYTHON_EXECUTABLE} server.py > "$SCRIPT_DIR/frontend.log" 2>&1 &
     else
-        PORT=$FRONTEND_PORT nohup python3 server.py > "$SCRIPT_DIR/frontend.log" 2>&1 &
+        PORT=$RF_FRONTEND_PORT nohup ${RF_PYTHON_EXECUTABLE} server.py > "$SCRIPT_DIR/frontend.log" 2>&1 &
     fi
-    
+
     local frontend_pid=$!
     cd "$SCRIPT_DIR"  # Return to original directory
-    
+
     # Store both PID and process group ID for better cleanup
     if command -v setsid &> /dev/null; then
         # On Linux, we can get the process group ID
-        echo "$frontend_pid Frontend_Flask" >> "$PID_FILE"
+        echo "$frontend_pid Frontend_Flask" >> "$RF_PID_FILE"
     else
         # On macOS, just store the PID
-        echo "$frontend_pid Frontend_Flask" >> "$PID_FILE"
+        echo "$frontend_pid Frontend_Flask" >> "$RF_PID_FILE"
     fi
-    
+
     # Wait for frontend to be ready - check both localhost and 127.0.0.1
     local frontend_ready=false
     local check_hosts=("localhost" "127.0.0.1")
-    
+
     for host in "${check_hosts[@]}"; do
-        if wait_for_service $host $FRONTEND_PORT "Frontend server" 15; then
-            print_success "Frontend Flask server started (PID: $frontend_pid) on $host:$FRONTEND_PORT"
+        if wait_for_service $host $RF_FRONTEND_PORT "Frontend server" 15; then
+            print_success "Frontend Flask server started (PID: $frontend_pid) on $host:$RF_FRONTEND_PORT"
             frontend_ready=true
             break
         fi
     done
-    
+
     if [[ "$frontend_ready" == false ]]; then
         print_error "Frontend Flask server failed to start. Checking for errors..."
-        
+
         # Check if process is still running
         if ! kill -0 "$frontend_pid" 2>/dev/null; then
             print_error "Frontend process has died. Checking logs for startup errors:"
         else
             print_error "Frontend process is running but not responding. Checking logs:"
         fi
-        
+
         if [[ -f "$SCRIPT_DIR/frontend.log" ]]; then
             echo "=== Last 30 lines of frontend.log ==="
             tail -30 "$SCRIPT_DIR/frontend.log"
             echo "=== End of logs ==="
             echo ""
-            
+
             # Look for specific error patterns
             if grep -q "Error\|Exception\|Traceback\|Failed" "$SCRIPT_DIR/frontend.log"; then
                 print_error "Found error messages in logs:"
@@ -455,16 +468,16 @@ start_frontend() {
         else
             print_error "No frontend.log file found"
         fi
-        
+
         # Check if there are any Python errors in the process
         if kill -0 "$frontend_pid" 2>/dev/null; then
             print_status "Frontend process details:"
             ps -p "$frontend_pid" -o pid,ppid,cmd,etime 2>/dev/null || true
         fi
-        
+
         return 1
     fi
-    
+
     return 0
 }
 
@@ -472,24 +485,24 @@ start_frontend() {
 show_status() {
     print_status "RapidFire AI Services Status:"
     echo "=================================="
-    
-    if [[ -f "$PID_FILE" ]]; then
+
+    if [[ -f "$RF_PID_FILE" ]]; then
         while read -r pid service; do
             if kill -0 "$pid" 2>/dev/null; then
                 print_success "$service is running (PID: $pid)"
             else
                 print_error "$service is not running (PID: $pid)"
             fi
-        done < "$PID_FILE"
+        done < "$RF_PID_FILE"
     else
         print_warning "No services are currently tracked"
     fi
-    
+
     echo ""
-    print_status "Available endpoints:"
-    echo "- Frontend: http://$FRONTEND_HOST:$FRONTEND_PORT"
-    echo "- API Server: http://$API_HOST:$API_PORT"
-    
+    print_success "🚀 RapidFire Frontend is ready!"
+    print_status "👉 Open your browser and navigate to: http://$RF_FRONTEND_HOST:$RF_FRONTEND_PORT"
+    print_status "   (Click the link above or copy/paste the URL into your browser)"
+
     # Show log file status
     echo ""
     print_status "Log files:"
@@ -507,41 +520,41 @@ show_status() {
 start_services() {
     local services_started=0
     local total_services=3
-    
+
     # Start MLflow server
     if start_mlflow; then
         ((services_started++))
     else
         print_error "Failed to start MLflow server"
     fi
-    
+
     # Start API server
     if start_api_server; then
         ((services_started++))
     else
         print_error "Failed to start API server"
     fi
-    
+
     # Start frontend server
     if start_frontend; then
         ((services_started++))
     else
         print_error "Failed to start frontend server"
     fi
-    
+
     return $((total_services - services_started))
 }
 
 # Main execution
 main() {
     print_status "Starting RapidFire AI services..."
-    
+
     # Remove old PID file
-    rm -f "$PID_FILE"
-    
+    rm -f "$RF_PID_FILE"
+
     # Set up signal handlers for cleanup
     trap cleanup SIGINT SIGTERM EXIT
-    
+
     # Check for required commands
     for cmd in mlflow gunicorn; do
         if ! command -v $cmd &> /dev/null; then
@@ -549,41 +562,41 @@ main() {
             exit 1
         fi
     done
-    
+
     # Setup Python environment
     if ! setup_python_env; then
         print_error "Failed to setup Python environment"
         exit 1
     fi
-    
+
     # Check for common startup issues
     if ! check_startup_issues; then
         print_error "Startup checks failed"
         exit 1
     fi
-    
+
     # Start services
     if start_services; then
         print_success "All services started successfully!"
         show_status
-        
+
         print_status "Press Ctrl+C to stop all services"
-        
+
         # Keep script running and monitor processes
         while true; do
             sleep 5
             # Check if any process died
-            if [[ -f "$PID_FILE" ]]; then
+            if [[ -f "$RF_PID_FILE" ]]; then
                 while read -r pid service; do
                     if ! kill -0 "$pid" 2>/dev/null; then
                         print_error "$service (PID: $pid) has stopped unexpectedly"
                     fi
-                done < "$PID_FILE"
+                done < "$RF_PID_FILE"
             fi
         done
     else
         print_error "Failed to start one or more services"
-        
+
         # Show summary of all log files for debugging
         print_status "=== Startup Failure Summary ==="
         for log_file in "mlflow.log" "api.log" "frontend.log"; do
@@ -597,7 +610,7 @@ main() {
                 fi
             fi
         done
-        
+
         cleanup
         exit 1
     fi
@@ -631,4 +644,4 @@ case "${1:-start}" in
         echo "  setup   - Setup Python environment only"
         exit 1
         ;;
-esac
+esac