Spaces:

1hitonline
/

flaskdockernew

Sleeping

App Files Files Community

MySafeCode commited on Jan 30

Commit

113839d

verified ·

1 Parent(s): 823b1d6

Update app.py

Browse files

Files changed (1) hide show

app.py +79 -92

app.py CHANGED Viewed

@@ -1,119 +1,106 @@
 #!/usr/bin/env python3
-# fast_noise.py - Optimized for speed
 import numpy as np
 import time
 from flask import Flask, Response
 app = Flask(__name__)
-WIDTH, HEIGHT = 400, 300
-CHUNK_SIZE = 50  # Process in chunks for better performance
 @app.route('/')
 def index():
-    return '''<!DOCTYPE html>
-<html>
-<head>
-    <title>Fast Noise</title>
-    <style>
-        body { margin: 0; padding: 20px; background: #111; color: white; font-family: monospace; text-align: center; }
-        canvas { border: 3px solid #0af; background: black; display: block; margin: 20px auto; }
-        .stats { background: #222; padding: 15px; border-radius: 8px; display: inline-block; margin: 10px; }
-    </style>
-</head>
-<body>
-    <h1 style="color: #0af;">⚡ FAST NOISE</h1>
     <canvas id="canvas" width="400" height="300"></canvas>
-    <div class="stats">
-        <div>FPS: <span id="fps">0</span></div>
-        <div>Latency: <span id="latency">0</span>ms</div>
-    </div>
     <script>
         const canvas = document.getElementById('canvas');
         const ctx = canvas.getContext('2d');
-        let frameCount = 0;
-        let lastTime = performance.now();
-        // Pre-allocate buffers (FASTER)
-        const imageData = new ImageData(400, 300);
-        const rgba = imageData.data;
-        const rgbBuffer = new ArrayBuffer(400*300*3);
-        const rgbView = new Uint8Array(rgbBuffer);
         function loadFrame() {
-            const startTime = performance.now();
-            fetch('/fast_noise')
-                .then(r => {
-                    const reader = r.body.getReader();
-                    return reader.read();
-                })
-                .then(({value, done}) => {
-                    if (value) {
-                        // Direct memory copy (FASTEST)
-                        rgbView.set(new Uint8Array(value));
-                        // Convert RGB to RGBA
-                        for (let i = 0, j = 0; i < rgba.length; i += 4, j += 3) {
-                            rgba[i] = rgbView[j];
-                            rgba[i + 1] = rgbView[j + 1];
-                            rgba[i + 2] = rgbView[j + 2];
-                            rgba[i + 3] = 255;
-                        }
-                        ctx.putImageData(imageData, 0, 0);
-                        // Update stats
-                        frameCount++;
-                        const now = performance.now();
-                        if (now - lastTime >= 1000) {
-                            document.getElementById('fps').textContent = frameCount;
-                            frameCount = 0;
-                            lastTime = now;
-                        }
-                        const latency = now - startTime;
-                        document.getElementById('latency').textContent = Math.round(latency);
                     }
                 });
         }
-        // Start at 10 FPS (more realistic for network)
         setInterval(loadFrame, 100);
-        loadFrame();
     </script>
-</body>
-</html>'''
-@app.route('/fast_noise')
-def fast_noise():
-    """Optimized noise generation"""
-    # Pre-allocate array (FASTER than creating new each time)
-    noise = np.empty((HEIGHT, WIDTH, 3), dtype=np.uint8)
-    # Fill with random values (vectorized - FAST)
-    np.random.randint(0, 256, (HEIGHT, WIDTH, 3), dtype=np.uint8, out=noise)
-    # Add occasional vertical/horizontal lines for TV effect
-    if np.random.random() < 0.1:
-        if np.random.random() < 0.5:
-            # Vertical line
-            x = np.random.randint(0, WIDTH)
-            width = np.random.randint(1, 5)
-            noise[:, x:x+width, :] = 255
-        else:
-            # Horizontal line
-            y = np.random.randint(0, HEIGHT)
-            height = np.random.randint(1, 5)
-            noise[y:y+height, :, :] = 255
-    return Response(
-        noise.tobytes(),
-        mimetype='application/octet-stream',
-        headers={'Cache-Control': 'no-cache'}
-    )
-if __name__ == "__main__":
-    print("⚡ Fast noise server starting...")
-    app.run(host='0.0.0.0', port=7860, threaded=True)

 #!/usr/bin/env python3
+# pygame_to_flask.py - PyGame renders, Flask serves
+import pygame
 import numpy as np
 import time
+import threading
 from flask import Flask, Response
+# Setup
+os.environ['SDL_VIDEODRIVER'] = 'dummy'
+WIDTH, HEIGHT = 400, 300
 app = Flask(__name__)
+# Simple shared state
+current_frame = None
+frame_lock = threading.Lock()
 @app.route('/')
 def index():
+    return '''<html><body>
     <canvas id="canvas" width="400" height="300"></canvas>
     <script>
         const canvas = document.getElementById('canvas');
         const ctx = canvas.getContext('2d');
         function loadFrame() {
+            fetch('/pygame_frame')
+                .then(r => r.arrayBuffer())
+                .then(buffer => {
+                    const imageData = new ImageData(400, 300);
+                    const rgba = imageData.data;
+                    const rgb = new Uint8Array(buffer);
+                    for (let i = 0, j = 0; i < rgba.length; i += 4, j += 3) {
+                        rgba[i] = rgb[j];
+                        rgba[i + 1] = rgb[j + 1];
+                        rgba[i + 2] = rgb[j + 2];
+                        rgba[i + 3] = 255;
                     }
+                    ctx.putImageData(imageData, 0, 0);
                 });
         }
         setInterval(loadFrame, 100);
     </script>
+    </body></html>'''
+@app.route('/pygame_frame')
+def pygame_frame():
+    with frame_lock:
+        if current_frame:
+            return Response(current_frame, mimetype='application/octet-stream')
+    # Fallback: black frame
+    black = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8).tobytes()
+    return Response(black, mimetype='application/octet-stream')
+def pygame_render():
+    """PyGame rendering thread"""
+    print("🎬 Starting PyGame...")
+    try:
+        pygame.init()
+        surface = pygame.Surface((WIDTH, HEIGHT))
+        print("✅ PyGame initialized")
+    except Exception as e:
+        print(f"❌ PyGame failed: {e}")
+        return
+    # Simple animation
+    x, y = 200, 150
+    dx, dy = 3, 2
+    while True:
+        # Clear
+        surface.fill((20, 20, 40))
+        # Update
+        x += dx
+        y += dy
+        if x < 20 or x > 380:
+            dx = -dx
+        if y < 20 or y > 280:
+            dy = -dy
+        # Draw
+        pygame.draw.circle(surface, (255, 100, 100), (int(x), int(y)), 20)
+        # Convert to bytes
+        pixels = pygame.surfarray.pixels3d(surface)
+        with frame_lock:
+            global current_frame
+            current_frame = pixels.tobytes()
+        time.sleep(1/30)
+# Start PyGame thread
+threading.Thread(target=pygame_render, daemon=True).start()
+# Start Flask
+print("🌐 Starting Flask...")
+app.run(host='0.0.0.0', port=7860, threaded=True)