Spaces:

1hitonline
/

flaskdockernew

Sleeping

App Files Files Community

MySafeCode commited on Jan 30

Commit

632d781

verified ·

1 Parent(s): a29c634

Update app.py

Browse files

Files changed (1) hide show

app.py +207 -107

app.py CHANGED Viewed

@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
-# reliable_30fps_numpy.py - PyGame + Flask with NumPy surface arrays
 import pygame
-import numpy as np
 import time
 import threading
 import base64
 import os
 import io
-from flask import Flask, Response, render_template_string
 # ===== 1. SETUP =====
 os.environ['SDL_VIDEODRIVER'] = 'dummy'
@@ -27,7 +27,9 @@ shared = {
     "capture_fps": 0,
     "streaming": True,
     "last_frame_time": time.time(),
-    "frames_this_second": 0
 }
 # ===== 2. CREATE FLASK APP =====
@@ -40,7 +42,7 @@ HTML = '''
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>PyGame + NumPy Streaming</title>
     <style>
         body { font-family: Arial; background: #0f172a; color: white; padding: 20px; margin: 0; }
         .container { max-width: 800px; margin: 0 auto; text-align: center; }
@@ -51,31 +53,29 @@ HTML = '''
             margin: 20px auto;
             border: 3px solid #60a5fa;
             background: #000;
-            overflow: hidden;
         }
         #streamImg {
             width: 100%;
             height: 100%;
             object-fit: contain;
-            image-rendering: pixelated;
         }
         .stats {
-            display: inline-block;
             background: #1e293b;
             padding: 20px;
             border-radius: 10px;
-            margin: 10px;
             text-align: left;
         }
         .stat-row { margin: 10px 0; display: flex; justify-content: space-between; min-width: 200px; }
         .stat-value { font-weight: bold; color: #60a5fa; }
-        .info { color: #94a3b8; margin-top: 20px; font-size: 0.9em; }
     </style>
 </head>
 <body>
     <div class="container">
-        <h1>PyGame + NumPy Surface Array Streaming</h1>
-        <p class="info">Using NumPy arrays for pixel manipulation</p>
         <div class="image-container">
             <img id="streamImg" src="/stream" alt="Live Stream">
@@ -85,25 +85,24 @@ HTML = '''
             <div class="stat-row"><span>Capture FPS:</span><span class="stat-value" id="captureFps">0.0</span></div>
             <div class="stat-row"><span>Total Frames:</span><span class="stat-value" id="totalFrames">0</span></div>
             <div class="stat-row"><span>Stream FPS:</span><span class="stat-value" id="streamFps">0.0</span></div>
-            <div class="stat-row"><span>Latency:</span><span class="stat-value" id="latency">-- ms</span></div>
-        </div>
-        <div class="info">
-            Rendering with NumPy arrays • Port: ''' + str(PORT) + ''' • Target: 30 FPS
         </div>
     </div>
     <script>
         let streamFrameCount = 0;
         let lastStreamUpdate = Date.now();
-        let lastFrameTimestamp = 0;
         function updateStream() {
             const now = Date.now();
             const img = document.getElementById('streamImg');
-            // Update image with anti-cache timestamp
-            img.src = '/stream?_=' + now;
             // Calculate stream FPS
             streamFrameCount++;
@@ -114,24 +113,45 @@ HTML = '''
                 lastStreamUpdate = now;
             }
-            // Get stats
-            fetch('/stats')
                 .then(r => r.json())
                 .then(data => {
                     document.getElementById('captureFps').textContent = data.capture_fps.toFixed(1);
                     document.getElementById('totalFrames').textContent = data.frame_count;
-                    if (lastFrameTimestamp > 0) {
-                        const latency = now - (data.timestamp * 1000);
-                        document.getElementById('latency').textContent = Math.round(latency) + ' ms';
                     }
-                    lastFrameTimestamp = data.timestamp * 1000;
                 });
         }
-        // Start polling at 30 FPS
-        setInterval(updateStream, 33);
         updateStream();
     </script>
 </body>
 </html>
@@ -142,131 +162,210 @@ HTML = '''
 def index():
     return render_template_string(HTML)
-@app.route('/stats')
-def stats():
     return {
         'frame_count': shared['frame_count'],
         'capture_fps': shared['capture_fps'],
         'timestamp': time.time(),
         'has_frame': shared['latest_frame'] is not None
     }
 @app.route('/stream')
 def stream():
-    """Stream endpoint - returns the latest NumPy/surface frame."""
     if shared['latest_frame']:
         try:
-            # Decode base64 and serve
             image_data = base64.b64decode(shared['latest_frame'])
-            return Response(
                 image_data,
                 mimetype='image/jpeg',
                 headers={
-                    'Cache-Control': 'no-cache, no-store, must-revalidate',
                     'Pragma': 'no-cache',
-                    'Expires': '0'
                 }
             )
         except Exception as e:
-            print(f"Stream error: {e}")
-    # Return empty response if no frame
-    return Response(b'', mimetype='image/jpeg')
-# ===== 5. NUMPY SURFACE CAPTURE LOOP =====
-def numpy_capture_loop():
-    """Capture loop using NumPy arrays for pixel manipulation."""
     try:
         pygame.init()
-        print("✅ PyGame initialized for NumPy rendering")
     except Exception as e:
         print(f"❌ PyGame init error: {e}")
         return
-    # Create surfaces
     screen = pygame.Surface((WIDTH, HEIGHT))
-    # Create NumPy array for direct pixel access (optional, for advanced effects)
-    # This creates a 3D array: [height, width, 3] for RGB
-    pixel_array = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)
-    # Animation variables
     circle_x, circle_y = WIDTH // 2, HEIGHT // 2
     circle_r = 30
-    speed_x, speed_y = 4, 3
-    # For gradient effect using NumPy
-    x_coords = np.arange(WIDTH)
-    y_coords = np.arange(HEIGHT)
-    X, Y = np.meshgrid(x_coords, y_coords)
     fps_update_time = time.time()
     frames_since_update = 0
     try:
         while shared["streaming"]:
             start_time = time.time()
-            # === UPDATE POSITION ===
             circle_x += speed_x
             circle_y += speed_y
             if circle_x - circle_r < 0 or circle_x + circle_r > WIDTH:
                 speed_x *= -1
             if circle_y - circle_r < 0 or circle_y + circle_r > HEIGHT:
                 speed_y *= -1
-            # === METHOD 1: Traditional PyGame drawing (simpler) ===
-            screen.fill((25, 25, 45))  # Dark blue background
-            # Draw bouncing circle
-            pygame.draw.circle(screen, (255, 80, 80), (int(circle_x), int(circle_y)), circle_r)
-            pygame.draw.circle(screen, (255, 255, 255), (int(circle_x), int(circle_y)), circle_r, 2)
-            # Draw frame counter
-            font = pygame.font.Font(None, 36)
-            text = font.render(f"Frame: {shared['frame_count']}", True, (100, 255, 100))
-            screen.blit(text, (10, 10))
-            # Draw FPS
-            fps_text = font.render(f"FPS: {shared['capture_fps']:.1f}", True, (100, 255, 100))
-            screen.blit(fps_text, (10, 50))
-            # === OPTIONAL: METHOD 2: NumPy pixel manipulation ===
-            # Uncomment this for advanced NumPy effects
-            """
-            # Clear with gradient using NumPy
-            gradient = 25 + (X * 0.03 + Y * 0.02).astype(np.uint8)
-            pixel_array[:, :, 0] = gradient  # Red channel
-            pixel_array[:, :, 1] = gradient // 2  # Green channel
-            pixel_array[:, :, 2] = 45  # Blue channel
-            # Draw circle using NumPy (distance formula)
-            distance = np.sqrt((X - circle_x)**2 + (Y - circle_y)**2)
-            circle_mask = distance < circle_r
-            # Set circle pixels to red
-            pixel_array[circle_mask, 0] = 255  # Red
-            pixel_array[circle_mask, 1] = 80   # Green
-            pixel_array[circle_mask, 2] = 80   # Blue
-            # Convert NumPy array to PyGame surface
-            pygame.surfarray.blit_array(screen, pixel_array)
-            """
-            # === SCALE AND SAVE FRAME ===
-            # Scale down for streaming
             scaled = pygame.transform.smoothscale(screen, (STREAM_WIDTH, STREAM_HEIGHT))
-            # Save to memory buffer
             buffer = io.BytesIO()
-            pygame.image.save(scaled, buffer, 'JPEG')
             buffer.seek(0)
-            # Encode to base64 for sharing
             image_bytes = buffer.getvalue()
             shared["latest_frame"] = base64.b64encode(image_bytes).decode('utf-8')
             # === UPDATE COUNTERS ===
             shared["frame_count"] += 1
@@ -289,41 +388,44 @@ def numpy_capture_loop():
                 time.sleep(target_time - elapsed)
     except Exception as e:
-        print(f"❌ Capture loop error: {e}")
         import traceback
         traceback.print_exc()
     pygame.quit()
-    print("🛑 NumPy capture loop stopped")
 # ===== 6. MAIN FUNCTION =====
 def main():
     print("=" * 60)
-    print("🚀 PyGame + NumPy Surface Array Streaming")
     print("=" * 60)
     print(f"Port: {PORT}")
-    print(f"Render: {WIDTH}x{HEIGHT} → Stream: {STREAM_WIDTH}x{STREAM_HEIGHT}")
-    print(f"Target FPS: {TARGET_FPS}")
-    print("Using NumPy for pixel manipulation")
     print("=" * 60)
-    # Start capture thread
-    print("Starting NumPy capture thread...")
-    capture_thread = threading.Thread(target=numpy_capture_loop, daemon=True)
     capture_thread.start()
     # Wait for first frame
     print("Waiting for first frame...")
-    for i in range(30):
         if shared['latest_frame']:
-            print(f"✅ First frame ready after {i*0.1:.1f}s")
             break
         time.sleep(0.1)
-    print(f"Starting Flask server on port {PORT}...")
     print("=" * 60)
     try:
         app.run(
             host='0.0.0.0',
             port=PORT,
@@ -331,15 +433,13 @@ def main():
             threaded=True,
             use_reloader=False
         )
-    except KeyboardInterrupt:
-        print("\n👋 Interrupted")
     except Exception as e:
-        print(f"❌ Server error: {e}")
     finally:
         shared['streaming'] = False
         capture_thread.join(timeout=2)
-        print(f"\n📊 Final: {shared['frame_count']} frames @ {shared['capture_fps']:.1f} FPS")
-        print("✅ Shutdown complete")
 if __name__ == "__main__":
     main()

 #!/usr/bin/env python3
+# FIXED VERSION: Flask not updating images
 import pygame
 import time
 import threading
 import base64
 import os
 import io
+import random
+from flask import Flask, Response, render_template_string, request
 # ===== 1. SETUP =====
 os.environ['SDL_VIDEODRIVER'] = 'dummy'
     "capture_fps": 0,
     "streaming": True,
     "last_frame_time": time.time(),
+    "frames_this_second": 0,
+    "frame_id": 0,  # Add frame ID to track updates
+    "frame_timestamps": {}  # Store timestamps for each frame
 }
 # ===== 2. CREATE FLASK APP =====
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>PyGame Streaming - NO CACHE</title>
     <style>
         body { font-family: Arial; background: #0f172a; color: white; padding: 20px; margin: 0; }
         .container { max-width: 800px; margin: 0 auto; text-align: center; }
             margin: 20px auto;
             border: 3px solid #60a5fa;
             background: #000;
         }
         #streamImg {
             width: 100%;
             height: 100%;
             object-fit: contain;
         }
         .stats {
             background: #1e293b;
             padding: 20px;
             border-radius: 10px;
+            margin: 20px auto;
+            display: inline-block;
             text-align: left;
         }
         .stat-row { margin: 10px 0; display: flex; justify-content: space-between; min-width: 200px; }
         .stat-value { font-weight: bold; color: #60a5fa; }
+        .warning { color: #f59e0b; background: rgba(245, 158, 11, 0.1); padding: 10px; border-radius: 5px; margin: 10px 0; }
     </style>
 </head>
 <body>
     <div class="container">
+        <h1>PyGame Streaming - NO CACHE MODE</h1>
+        <div class="warning">Flask caching disabled - should update every frame</div>
         <div class="image-container">
             <img id="streamImg" src="/stream" alt="Live Stream">
             <div class="stat-row"><span>Capture FPS:</span><span class="stat-value" id="captureFps">0.0</span></div>
             <div class="stat-row"><span>Total Frames:</span><span class="stat-value" id="totalFrames">0</span></div>
             <div class="stat-row"><span>Stream FPS:</span><span class="stat-value" id="streamFps">0.0</span></div>
+            <div class="stat-row"><span>Frame ID:</span><span class="stat-value" id="frameId">0</span></div>
+            <div class="stat-row"><span>Cache Status:</span><span class="stat-value" id="cacheStatus">Unknown</span></div>
         </div>
     </div>
     <script>
         let streamFrameCount = 0;
         let lastStreamUpdate = Date.now();
+        let lastFrameId = 0;
+        let cacheMissCount = 0;
         function updateStream() {
             const now = Date.now();
             const img = document.getElementById('streamImg');
+            // CRITICAL: Add random parameter to prevent caching
+            const randomParam = Math.random().toString(36).substring(7);
+            img.src = '/stream?nocache=' + now + '&rand=' + randomParam;
             // Calculate stream FPS
             streamFrameCount++;
                 lastStreamUpdate = now;
             }
+            // Get frame info
+            fetch('/frame_info')
                 .then(r => r.json())
                 .then(data => {
                     document.getElementById('captureFps').textContent = data.capture_fps.toFixed(1);
                     document.getElementById('totalFrames').textContent = data.frame_count;
+                    document.getElementById('frameId').textContent = data.frame_id;
+                    // Check if frame actually updated
+                    if (lastFrameId > 0 && data.frame_id === lastFrameId) {
+                        cacheMissCount++;
+                        document.getElementById('cacheStatus').textContent = 'STUCK! Same frame: ' + cacheMissCount;
+                        document.getElementById('cacheStatus').style.color = '#ef4444';
+                    } else {
+                        cacheMissCount = 0;
+                        document.getElementById('cacheStatus').textContent = 'UPDATING ✓';
+                        document.getElementById('cacheStatus').style.color = '#10b981';
                     }
+                    lastFrameId = data.frame_id;
+                })
+                .catch(err => {
+                    console.error('Fetch error:', err);
                 });
+            // Debug: Check if image actually loaded new data
+            img.onload = function() {
+                console.log('Image loaded at:', new Date().toISOString());
+            };
+            img.onerror = function() {
+                console.error('Image failed to load');
+            };
         }
+        // Poll aggressively
+        setInterval(updateStream, 33); // ~30 FPS
         updateStream();
+        console.log('NO-CACHE streaming client started');
     </script>
 </body>
 </html>
 def index():
     return render_template_string(HTML)
+@app.route('/frame_info')
+def frame_info():
+    """Return frame information including unique frame ID."""
     return {
         'frame_count': shared['frame_count'],
         'capture_fps': shared['capture_fps'],
+        'frame_id': shared['frame_id'],
         'timestamp': time.time(),
         'has_frame': shared['latest_frame'] is not None
     }
 @app.route('/stream')
 def stream():
+    """Stream endpoint - COMPLETELY DISABLED CACHE."""
+    # Get request timestamp for debugging
+    request_time = time.time()
+    client_timestamp = request.args.get('nocache', '0')
     if shared['latest_frame']:
         try:
+            # Decode the frame
             image_data = base64.b64decode(shared['latest_frame'])
+            # Create response with ALL cache-disabling headers
+            response = Response(
                 image_data,
                 mimetype='image/jpeg',
                 headers={
+                    # Disable ALL caching
+                    'Cache-Control': 'no-cache, no-store, must-revalidate, max-age=0',
                     'Pragma': 'no-cache',
+                    'Expires': '0',
+                    'X-Accel-Expires': '0',
+                    # Add unique headers to prevent caching
+                    'Last-Modified': time.strftime('%a, %d %b %Y %H:%M:%S GMT', time.gmtime()),
+                    'ETag': f'"{shared["frame_id"]}-{time.time()}"',
+                    # Debug info
+                    'X-Frame-ID': str(shared['frame_id']),
+                    'X-Frame-Count': str(shared['frame_count']),
+                    'X-Request-Time': str(request_time),
+                    'X-Client-Timestamp': client_timestamp
                 }
             )
+            # Force immediate flush
+            response.direct_passthrough = True
+            print(f"✅ Serving frame {shared['frame_id']} to client {client_timestamp[:10]}...")
+            return response
         except Exception as e:
+            print(f"❌ Stream error: {e}")
+            # Return error image
+            return Response(
+                b'ERROR',
+                mimetype='text/plain',
+                headers={'Cache-Control': 'no-cache'}
+            )
+    # No frame available - return loading image
+    print("⚠️ No frame available yet")
+    loading_img = create_loading_image(shared['frame_id'])
+    return Response(
+        loading_img,
+        mimetype='image/png',
+        headers={'Cache-Control': 'no-cache'}
+    )
+def create_loading_image(frame_id):
+    """Create a simple loading image with frame info."""
+    import pygame as pg_local
+    surface = pg_local.Surface((STREAM_WIDTH, STREAM_HEIGHT))
+    surface.fill((40, 40, 60))
+    # Draw loading text
+    font = pg_local.font.Font(None, 24)
+    text1 = font.render(f"Loading... Frame {frame_id}", True, (255, 255, 255))
+    text2 = font.render(f"Time: {time.strftime('%H:%M:%S')}", True, (200, 200, 255))
+    surface.blit(text1, (STREAM_WIDTH//2 - text1.get_width()//2, STREAM_HEIGHT//2 - 20))
+    surface.blit(text2, (STREAM_WIDTH//2 - text2.get_width()//2, STREAM_HEIGHT//2 + 10))
+    # Save to buffer
+    buffer = io.BytesIO()
+    pg_local.image.save(surface, buffer)
+    buffer.seek(0)
+    return buffer.getvalue()
+# ===== 5. CAPTURE LOOP - WITH VISIBLE CHANGES =====
+def capture_loop():
+    """Capture loop with VISIBLE changes each frame."""
     try:
         pygame.init()
+        print("✅ PyGame initialized")
     except Exception as e:
         print(f"❌ PyGame init error: {e}")
         return
+    # Create surface
     screen = pygame.Surface((WIDTH, HEIGHT))
+    # Animation with CHANGING colors and positions
+    colors = [
+        (255, 80, 80),    # Red
+        (80, 255, 80),    # Green
+        (80, 80, 255),    # Blue
+        (255, 255, 80),   # Yellow
+        (255, 80, 255),   # Magenta
+        (80, 255, 255),   # Cyan
+    ]
     circle_x, circle_y = WIDTH // 2, HEIGHT // 2
     circle_r = 30
+    speed_x, speed_y = 5, 4
+    color_index = 0
+    pulse_size = 0
+    pulse_dir = 1
     fps_update_time = time.time()
     frames_since_update = 0
+    print("🎬 Starting animation with visible changes every frame...")
     try:
         while shared["streaming"]:
             start_time = time.time()
+            # === UPDATE ANIMATION - MAKE CHANGES VISIBLE ===
             circle_x += speed_x
             circle_y += speed_y
+            # Bounce
             if circle_x - circle_r < 0 or circle_x + circle_r > WIDTH:
                 speed_x *= -1
+                color_index = (color_index + 1) % len(colors)
             if circle_y - circle_r < 0 or circle_y + circle_r > HEIGHT:
                 speed_y *= -1
+                color_index = (color_index + 1) % len(colors)
+            # Pulse effect
+            pulse_size += pulse_dir * 0.5
+            if pulse_size > 10 or pulse_size < 0:
+                pulse_dir *= -1
+            # === DRAW FRAME ===
+            # Background with gradient
+            for y in range(HEIGHT):
+                color_val = 25 + int(y / HEIGHT * 30)
+                pygame.draw.line(screen, (color_val, color_val, 65), (0, y), (WIDTH, y))
+            # Draw bouncing circle with current color
+            current_color = colors[color_index]
+            pygame.draw.circle(screen, current_color, (int(circle_x), int(circle_y)), int(circle_r + pulse_size))
+            pygame.draw.circle(screen, (255, 255, 255), (int(circle_x), int(circle_y)), int(circle_r + pulse_size), 3)
+            # Draw trail
+            for i in range(1, 6):
+                trail_x = circle_x - speed_x * i * 0.2
+                trail_y = circle_y - speed_y * i * 0.2
+                trail_alpha = 255 - i * 40
+                trail_color = (current_color[0], current_color[1], current_color[2], trail_alpha)
+                pygame.draw.circle(screen, trail_color[:3], (int(trail_x), int(trail_y)), circle_r - i * 2)
+            # Draw frame info
+            font = pygame.font.Font(None, 32)
+            # Frame counter with changing color
+            counter_color = (100 + (shared['frame_count'] % 155), 255, 100)
+            frame_text = font.render(f"Frame: {shared['frame_count']}", True, counter_color)
+            screen.blit(frame_text, (10, 10))
+            # Position info
+            pos_text = font.render(f"Pos: {int(circle_x)},{int(circle_y)}", True, (200, 200, 255))
+            screen.blit(pos_text, (10, 50))
+            # Color info
+            color_text = font.render(f"Color: {color_index}", True, current_color)
+            screen.blit(color_text, (10, 90))
+            # Time
+            time_text = font.render(time.strftime("%H:%M:%S"), True, (255, 255, 200))
+            screen.blit(time_text, (WIDTH - 150, 10))
+            # === SAVE FRAME ===
+            # Scale
             scaled = pygame.transform.smoothscale(screen, (STREAM_WIDTH, STREAM_HEIGHT))
+            # Save to buffer
             buffer = io.BytesIO()
+            pygame.image.save(scaled, buffer)
             buffer.seek(0)
             image_bytes = buffer.getvalue()
+            # Update shared state
             shared["latest_frame"] = base64.b64encode(image_bytes).decode('utf-8')
+            shared["frame_id"] += 1  # Increment frame ID
+            # Log every 30 frames (1 second at 30 FPS)
+            if shared['frame_count'] % 30 == 0:
+                print(f"📸 Frame {shared['frame_count']}: Pos({int(circle_x)},{int(circle_y)}) Color:{color_index}")
             # === UPDATE COUNTERS ===
             shared["frame_count"] += 1
                 time.sleep(target_time - elapsed)
     except Exception as e:
+        print(f"❌ Capture error: {e}")
         import traceback
         traceback.print_exc()
     pygame.quit()
+    print("🛑 Capture loop stopped")
 # ===== 6. MAIN FUNCTION =====
 def main():
     print("=" * 60)
+    print("🚀 PyGame Streaming - FLASK CACHE FIX")
     print("=" * 60)
     print(f"Port: {PORT}")
+    print(f"Cache: DISABLED (force fresh frames)")
+    print(f"Changes: Color, position, pulse, trail effects")
     print("=" * 60)
+    # Start capture
+    print("Starting capture thread...")
+    capture_thread = threading.Thread(target=capture_loop, daemon=True)
     capture_thread.start()
     # Wait for first frame
     print("Waiting for first frame...")
+    for i in range(50):
         if shared['latest_frame']:
+            print(f"✅ First frame ready!")
             break
         time.sleep(0.1)
+    print(f"Starting Flask on port {PORT}...")
     print("=" * 60)
     try:
+        # Disable Flask caching completely
+        app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
+        app.config['TEMPLATES_AUTO_RELOAD'] = True
         app.run(
             host='0.0.0.0',
             port=PORT,
             threaded=True,
             use_reloader=False
         )
     except Exception as e:
+        print(f"Server error: {e}")
     finally:
         shared['streaming'] = False
         capture_thread.join(timeout=2)
+        print(f"\n🎬 Final: {shared['frame_count']} frames @ {shared['capture_fps']:.1f} FPS")
+        print("✅ Done")
 if __name__ == "__main__":
     main()