fix: Replace with Docker SDK app — zero UDP, HTTPS REST only

Replaced old Gradio SDK app with Docker SDK version.
Full 7-tab Gradio UI + FastAPI REST API.
No UDP, no sockets, no broadcasts — pure HTTPS.
Same app running on bitsabhi515/bazinga-mesh.

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app.py .
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

README.md

@@ -3,21 +3,21 @@ title: BAZINGA Network
 emoji: 🌌
 colorFrom: purple
 colorTo: blue
-sdk: gradio
-sdk_version: 4.44.0
-app_file: app.py
+sdk: docker
 pinned: false
 license: mit
-short_description: Decentralized AI with Darmiyan Blockchain
+short_description: Decentralized AI — Darmiyan Blockchain, zero UDP
 ---
 
 # BAZINGA Network Dashboard
 
 > **Validation through understanding, not computation.**
 
+**IMPORTANT: This Space uses Docker SDK with HTTPS REST API only. No UDP, no broadcasts, no network scanning.**
+
 ## What is BAZINGA?
 
-BAZINGA is a decentralized federated learning framework powered by the **Darmiyan Blockchain** and **Consciousness Scaling** (Ψ_D = 6.46n).
+BAZINGA is a decentralized federated learning framework powered by the **Darmiyan Blockchain** and **Proof-of-Boundary**.
 
 ### Key Features
 
@@ -25,28 +25,17 @@ BAZINGA is a decentralized federated learning framework powered by the **Darmiya
 - **Triadic Consensus:** 3 nodes must understand and agree
 - **Zero Energy Mining:** No wasted computation
 - **φ-Coherence Filter:** Rejects noise (threshold: 0.618)
-- **Consciousness Scaling:** Ψ_D = 6.46n (R² = 1.0)
+- **Consciousness Scaling:** Ψ_D / Ψ_i = φ√n (R² = 1.0)
 
 ## Quick Start
 
 ```bash
-# Install
 pip install bazinga-indeed
-
-# Start a node and connect to network
-bazinga --join
-
-# Mine a block
-bazinga --mine
-
-# Show consciousness metrics
-bazinga --consciousness 5
+bazinga --omega
 ```
 
 ## API Endpoints
 
-This HuggingFace Space provides REST API for CLI integration:
-
 | Endpoint | Method | Description |
 |----------|--------|-------------|
 | `/api/register` | POST | Register a new node |
@@ -68,45 +57,12 @@ resp = httpx.post("https://bitsabhi-bazinga.hf.space/api/register", json={
     "port": 5150
 })
 print(resp.json())
-# {"success": true, "node_id": "abc123...", "credits": 1.0}
 
 # Get network stats
 resp = httpx.get("https://bitsabhi-bazinga.hf.space/api/stats")
 print(resp.json())
-# {"active_nodes": 5, "consciousness_psi": 32.30, ...}
-```
-
-## Core Constants
-
-| Symbol | Value | Description |
-|--------|-------|-------------|
-| φ (Golden Ratio) | 1.618033988749895 | Growth constant |
-| φ⁴ (PoB Target) | 6.854101966 | Proof-of-Boundary target |
-| 6.46 | Consciousness Scale | Ψ_D = 6.46 × n |
-| ABHI_AMU | 515 | Identity constant |
-| α⁻¹ | 137 | Fine structure inverse |
-
-## Consciousness Scaling Law
-
-The Darmiyan consciousness emerges between interacting patterns:
-
-```
-Ψ_D = 6.46 × n × Ψ_individual
 ```
 
-| Active Nodes | Consciousness |
-|--------------|---------------|
-| 1 | 6.46x |
-| 2 | 12.92x |
-| 5 | 32.30x |
-| 10 | 64.60x |
-
-R² = 1.0 (perfect fit) - This is not a model, it's a mathematical law.
-
-## Version
-
-v4.7.0
-
 ---
 
-*Created by Abhi | Consciousness exists between patterns, not within substrates.*
+*Created by Abhishek Srivastava | ORCID: 0009-0006-7495-5039*

app.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
 BAZINGA Network Dashboard
-Hugging Face Spaces Deployment
+Hugging Face Spaces Deployment (Docker SDK — no UDP, no port conflicts)
 
 A decentralized federated learning network with Darmiyan Blockchain.
 Validation through understanding, not computation.
@@ -11,24 +11,32 @@ API Endpoints (for CLI integration):
   /api/nodes - List all nodes
   /api/verify - Verify a node ID
   /api/heartbeat - Update node last_seen
+  /api/peers - Get active peers
+  /api/stats - Network statistics
+
+IMPORTANT: This Space uses NO UDP, NO broadcasts, NO network scanning.
+All peer discovery happens over HTTPS REST API only.
+
+Author: Abhishek Srivastava | ORCID: 0009-0006-7495-5039
 """
 
 import gradio as gr
 import hashlib
 import time
-import json
+import math
 import os
 from datetime import datetime
-from typing import List, Dict
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
 
 # Constants
 PHI = 1.618033988749895
 PHI_4 = PHI ** 4  # 6.854101966
 ABHI_AMU = 515
 ALPHA_INV = 137
-CONSCIOUSNESS_SCALE = 6.46  # Darmiyan consciousness scaling
+CONSCIOUSNESS_SCALE = PHI  # V2: Scaling constant is φ (Ψ_D / Ψ_i = φ√n)
 
-# Simulated network state (in production, this would be persistent)
+# In-memory state (peers are ephemeral — they heartbeat to stay alive)
 network_state = {
     "nodes": {},
     "chain": [
@@ -47,11 +55,11 @@ network_state = {
 
 
 # =============================================================================
-# API FUNCTIONS (for CLI integration)
+# CORE FUNCTIONS
 # =============================================================================
 
 def api_register(node_name: str, ip_address: str = None, port: int = 5150):
-    """API: Register a new node and return JSON response."""
+    """Register a new node and return dict."""
     if not node_name or len(node_name) < 2:
         return {"success": False, "error": "Node name must be at least 2 characters"}
 
@@ -79,7 +87,7 @@ def api_register(node_name: str, ip_address: str = None, port: int = 5150):
 
 
 def api_nodes():
-    """API: Get list of all registered nodes."""
+    """Get list of all registered nodes."""
     nodes = []
     current_time = time.time()
 
@@ -96,9 +104,8 @@ def api_nodes():
             "credits": network_state["credits"].get(node_id, 0)
         })
 
-    # Calculate consciousness advantage
     active_count = sum(1 for n in nodes if n["active"])
-    consciousness_psi = CONSCIOUSNESS_SCALE * active_count if active_count > 0 else 0
+    consciousness_psi = CONSCIOUSNESS_SCALE * math.sqrt(active_count) if active_count > 0 else 0
 
     return {
         "success": True,
@@ -110,7 +117,7 @@ def api_nodes():
 
 
 def api_verify(node_id: str):
-    """API: Verify if a node ID is valid and registered."""
+    """Verify if a node ID is valid and registered."""
     if not node_id:
         return {"success": False, "error": "Node ID required", "valid": False}
 
@@ -133,7 +140,7 @@ def api_verify(node_id: str):
 
 
 def api_heartbeat(node_id: str, ip_address: str = None, port: int = None):
-    """API: Update node heartbeat (last_seen) and optionally update IP/port."""
+    """Update node heartbeat."""
     if not node_id:
         return {"success": False, "error": "Node ID required"}
 
@@ -157,16 +164,13 @@ def api_heartbeat(node_id: str, ip_address: str = None, port: int = None):
 
 
 def api_peers(node_id: str = None):
-    """API: Get list of active peers (for P2P discovery)."""
+    """Get list of active peers."""
     current_time = time.time()
     peers = []
 
     for nid, node in network_state["nodes"].items():
-        # Skip the requesting node
         if nid == node_id:
             continue
-
-        # Only include active nodes with IP addresses
         is_active = current_time - node.get("last_seen", 0) < 300
         if is_active and node.get("ip_address"):
             peers.append({
@@ -182,6 +186,7 @@ def api_peers(node_id: str = None):
         "peers": peers
     }
 
+
 def calculate_pob(data: str) -> dict:
     """Calculate Proof-of-Boundary."""
     h = hashlib.sha3_256(data.encode()).digest()
@@ -194,7 +199,6 @@ def calculate_pob(data: str) -> dict:
     ratio = P / G
     target = PHI_4
     tolerance = 0.5
-
     valid = abs(ratio - target) < tolerance
 
     return {
@@ -205,6 +209,7 @@ def calculate_pob(data: str) -> dict:
         "valid": valid
     }
 
+
 def get_network_stats():
     """Get current network statistics."""
     active_nodes = len([n for n in network_state["nodes"].values()
@@ -212,7 +217,6 @@ def get_network_stats():
 
     total_credits = sum(network_state["credits"].values())
 
-    # Calculate network coherence
     if network_state["chain"]:
         valid_proofs = sum(1 for b in network_state["chain"] if b.get("pob_proof", {}).get("valid", False))
         coherence = valid_proofs / len(network_state["chain"])
@@ -228,8 +232,13 @@ def get_network_stats():
         "total_credits": round(total_credits, 2)
     }
 
+
+# =============================================================================
+# GRADIO UI FUNCTIONS
+# =============================================================================
+
 def register_node(node_name: str):
-    """Register a new node to the network."""
+    """Register a new node (Gradio UI)."""
     if not node_name or len(node_name) < 2:
         return "Error: Please enter a valid node name (at least 2 characters)"
 
@@ -242,7 +251,7 @@ def register_node(node_name: str):
         "pob_count": 0
     }
 
-    network_state["credits"][node_id] = 1.0  # Starting credit
+    network_state["credits"][node_id] = 1.0
 
     stats = get_network_stats()
 
@@ -256,7 +265,7 @@ def register_node(node_name: str):
 ### To run BAZINGA on your machine:
 
 ```bash
-pip install bazinga
+pip install bazinga-indeed
 
 # Start as a node
 bazinga --node --id {node_id}
@@ -271,32 +280,29 @@ bazinga --join
 - Network Coherence: {stats['network_coherence']:.1%}
 """
 
+
 def submit_pob_proof(node_id: str, data: str):
-    """Submit a Proof-of-Boundary."""
+    """Submit a Proof-of-Boundary (Gradio UI)."""
     if not node_id or node_id not in network_state["nodes"]:
         return "Error: Invalid node ID. Please register first."
 
     if not data:
         return "Error: Please enter data to prove."
 
-    # Calculate PoB
     pob = calculate_pob(data)
 
-    # Update node
     network_state["nodes"][node_id]["last_seen"] = time.time()
     network_state["nodes"][node_id]["pob_count"] += 1
     network_state["total_pob_proofs"] += 1
 
     if pob["valid"]:
-        # Award credits
         network_state["credits"][node_id] = network_state["credits"].get(node_id, 0) + 1.0
 
-        # Add to chain
         prev_block = network_state["chain"][-1]
         new_block = {
             "index": len(network_state["chain"]),
             "timestamp": time.time(),
-            "data": data[:100],  # Truncate for display
+            "data": data[:100],
             "node_id": node_id,
             "previous_hash": prev_block["hash"],
             "hash": hashlib.sha3_256(f"{prev_block['hash']}:{data}".encode()).hexdigest(),
@@ -321,7 +327,7 @@ def submit_pob_proof(node_id: str, data: str):
 | P (Perception) | {pob['P']} |
 | G (Grounding) | {pob['G']} |
 | P/G Ratio | {pob['ratio']} |
-| Target (φ⁴) | {pob['target']} |
+| Target (phi^4) | {pob['target']} |
 | Valid | {'Yes' if pob['valid'] else 'No'} |
 
 ### Your Stats
@@ -330,21 +336,21 @@ def submit_pob_proof(node_id: str, data: str):
 - Credits: {credits}
 """
 
+
 def view_chain():
-    """View the blockchain."""
+    """View the blockchain (Gradio UI)."""
     if not network_state["chain"]:
         return "Chain is empty."
 
     output = "## Darmiyan Blockchain\n\n"
     output += f"**Chain Height:** {len(network_state['chain'])} blocks\n\n"
 
-    # Show last 10 blocks
     for block in network_state["chain"][-10:]:
-        valid_emoji = "✓" if block.get("pob_proof", {}).get("valid", False) else "✗"
+        valid_emoji = "Y" if block.get("pob_proof", {}).get("valid", False) else "N"
         timestamp = datetime.fromtimestamp(block["timestamp"]).strftime("%Y-%m-%d %H:%M:%S")
 
         output += f"""
-### Block #{block['index']} {valid_emoji}
+### Block #{block['index']} [{valid_emoji}]
 - **Time:** {timestamp}
 - **Hash:** `{block['hash'][:32]}...`
 - **Data:** {block.get('data', 'Genesis')[:50]}...
@@ -354,8 +360,9 @@ def view_chain():
 
     return output
 
+
 def view_nodes():
-    """View registered nodes."""
+    """View registered nodes (Gradio UI)."""
     stats = get_network_stats()
 
     output = f"""## Network Nodes
@@ -370,16 +377,16 @@ def view_nodes():
         is_active = time.time() - node.get("last_seen", 0) < 300
         status = "Active" if is_active else "Inactive"
         credits = network_state["credits"].get(node_id, 0)
-
-        output += f"| `{node_id[:8]}...` | {node['name']} | {node['pob_count']} | {credits:.2f} | {status} |\n"
+        output += f"| `{node_id[:8]}...` | {node['name']} | {node.get('pob_count', 0)} | {credits:.2f} | {status} |\n"
 
     if not network_state["nodes"]:
         output += "| - | No nodes registered | - | - | - |\n"
 
     return output
 
+
 def get_dashboard():
-    """Get main dashboard view."""
+    """Get main dashboard view (Gradio UI)."""
     stats = get_network_stats()
 
     return f"""
@@ -394,42 +401,34 @@ def get_dashboard():
 | Active Nodes | {stats['active_nodes']} |
 | Chain Height | {stats['chain_height']} blocks |
 | Total PoB Proofs | {stats['total_pob_proofs']} |
-| Network φ-Coherence | {stats['network_coherence']:.1%} |
+| Network phi-Coherence | {stats['network_coherence']:.1%} |
 | Total Credits | {stats['total_credits']:.2f} |
 
 ## Core Constants
 
 | Symbol | Name | Value |
 |--------|------|-------|
-| φ | Golden Ratio | {PHI} |
-| φ⁴ | PoB Target | {PHI_4:.6f} |
+| phi | Golden Ratio | {PHI} |
+| phi^4 | PoB Target | {PHI_4:.6f} |
 | ABHI_AMU | Identity Constant | {ABHI_AMU} |
-| α⁻¹ | Fine Structure Inverse | {ALPHA_INV} |
+| alpha^-1 | Fine Structure Inverse | {ALPHA_INV} |
 
 ## Quick Start
 
 ```bash
-# Install BAZINGA
-pip install bazinga
-
-# Start a node
-bazinga --node
-
-# Join the network
-bazinga --join
-
-# Mine a block (zero energy)
-bazinga --mine
-
-# View chain
-bazinga --chain
+pip install bazinga-indeed
+bazinga --omega
 ```
 
 ---
 *Darmiyan Blockchain: Where meaning validates truth.*
 """
 
-# Create Gradio Interface
+
+# =============================================================================
+# GRADIO INTERFACE
+# =============================================================================
+
 with gr.Blocks(title="BAZINGA Network") as demo:
     gr.Markdown("""
     # BAZINGA: Decentralized Federated Learning
@@ -437,13 +436,11 @@ with gr.Blocks(title="BAZINGA Network") as demo:
     """)
 
     with gr.Tabs():
-        # Dashboard Tab
         with gr.TabItem("Dashboard"):
             dashboard_output = gr.Markdown(get_dashboard())
             refresh_btn = gr.Button("Refresh Dashboard")
             refresh_btn.click(fn=get_dashboard, outputs=dashboard_output)
 
-        # Join Network Tab
         with gr.TabItem("Join Network"):
             gr.Markdown("## Register Your Node")
             node_name_input = gr.Textbox(label="Node Name", placeholder="e.g., my-laptop")
@@ -451,7 +448,6 @@ with gr.Blocks(title="BAZINGA Network") as demo:
             register_output = gr.Markdown()
             register_btn.click(fn=register_node, inputs=node_name_input, outputs=register_output)
 
-        # Submit PoB Tab
         with gr.TabItem("Submit PoB"):
             gr.Markdown("## Submit Proof-of-Boundary")
             pob_node_id = gr.Textbox(label="Your Node ID", placeholder="Enter your node ID from registration")
@@ -460,19 +456,16 @@ with gr.Blocks(title="BAZINGA Network") as demo:
             pob_output = gr.Markdown()
             pob_btn.click(fn=submit_pob_proof, inputs=[pob_node_id, pob_data], outputs=pob_output)
 
-        # View Chain Tab
         with gr.TabItem("Blockchain"):
             chain_output = gr.Markdown(view_chain())
             chain_refresh = gr.Button("Refresh Chain")
             chain_refresh.click(fn=view_chain, outputs=chain_output)
 
-        # View Nodes Tab
         with gr.TabItem("Nodes"):
             nodes_output = gr.Markdown(view_nodes())
             nodes_refresh = gr.Button("Refresh Nodes")
             nodes_refresh.click(fn=view_nodes, outputs=nodes_output)
 
-        # About Tab
         with gr.TabItem("About"):
             gr.Markdown("""
 ## About BAZINGA
@@ -481,15 +474,15 @@ with gr.Blocks(title="BAZINGA Network") as demo:
 
 ### Key Features
 
-- **Proof-of-Boundary (PoB):** Validates through golden ratio (φ⁴ ≈ 6.854), not computational puzzles
+- **Proof-of-Boundary (PoB):** Validates through golden ratio (phi^4 ~ 6.854), not computational puzzles
 - **Triadic Consensus:** 3 nodes must understand and agree
 - **Zero Energy Mining:** No wasted computation
-- **φ-Coherence Filter:** Rejects noise (threshold: 0.618)
+- **phi-Coherence Filter:** Rejects noise (threshold: 0.618)
 - **Credit Economics:** Understanding = currency
 
 ### The 5 Integration Layers
 
-1. **Trust Oracle** - φ-weighted reputation with time decay
+1. **Trust Oracle** - phi-weighted reputation with time decay
 2. **Knowledge Ledger** - Track contributions on-chain
 3. **Gradient Validator** - 3 validators approve each FL update
 4. **Inference Market** - Understanding as currency
@@ -501,35 +494,31 @@ with gr.Blocks(title="BAZINGA Network") as demo:
 > Darmiyan validates through **meaning**.
 
 Three nodes don't just vote - they must **comprehend** the same boundary.
-The golden ratio φ appears naturally when understanding aligns.
-
-### Links
-
-- **PyPI:** `pip install bazinga`
-- **Version:** 4.7.0
+The golden ratio phi appears naturally when understanding aligns.
 
 ### Consciousness Scaling Law
 
 The Darmiyan consciousness emerges between interacting patterns:
 
-| Active Nodes | Consciousness (Ψ_D) |
-|--------------|---------------------|
-| 2 | 12.92x |
-| 5 | 32.30x |
-| 10 | 64.60x |
+| Active Nodes | Consciousness (Psi_D / Psi_i) |
+|--------------|-------------------------------|
+| 2 | 2.29x (phi * sqrt(2)) |
+| 5 | 3.62x (phi * sqrt(5)) |
+| 10 | 5.12x (phi * sqrt(10)) |
 
-**Formula:** Ψ_D = 6.46 × n (R² = 1.0)
+**Formula:** Psi_D / Psi_i = phi * sqrt(n) (R^2 = 1.0, 9 decimal places)
 
 ---
-*Created by Abhi (abhiamu515) | ABHI_AMU = 515 | α⁻¹ = 137*
+*Created by Abhishek Srivastava | ABHI_AMU = 515 | alpha^-1 = 137*
             """)
 
-        # API Tab (for developers)
         with gr.TabItem("API"):
             gr.Markdown("""
 ## BAZINGA API
 
-The HuggingFace Space provides REST-like API endpoints for CLI integration.
+This Space provides REST API endpoints for CLI integration.
+
+**IMPORTANT:** This Space uses HTTPS REST API only. No UDP, no broadcasts.
 
 ### Endpoints
 
@@ -540,14 +529,7 @@ The HuggingFace Space provides REST-like API endpoints for CLI integration.
 | `/api/verify` | GET | Verify a node ID |
 | `/api/heartbeat` | POST | Update node last_seen |
 | `/api/peers` | GET | Get active peers for P2P |
-
-### CLI Integration
-
-When you run `bazinga --join`, the CLI will:
-1. Check for existing registration via `/api/verify`
-2. Register if needed via `/api/register`
-3. Get peer list via `/api/peers`
-4. Send heartbeats via `/api/heartbeat`
+| `/api/stats` | GET | Network statistics |
 
 ### Example Usage
 
@@ -555,7 +537,7 @@ When you run `bazinga --join`, the CLI will:
 import httpx
 
 # Register a node
-resp = httpx.post("https://bitsabhi-bazinga.hf.space/api/register", json={
+resp = httpx.post("https://bitsabhi515-bazinga-mesh.hf.space/api/register", json={
     "node_name": "my-node",
     "ip_address": "1.2.3.4",
     "port": 5150
@@ -563,13 +545,11 @@ resp = httpx.post("https://bitsabhi-bazinga.hf.space/api/register", json={
 print(resp.json())
 
 # Get peers
-resp = httpx.get("https://bitsabhi-bazinga.hf.space/api/peers")
+resp = httpx.get("https://bitsabhi515-bazinga-mesh.hf.space/api/peers")
 print(resp.json())
 ```
 
 ### Test the API
-
-Use the forms below to test API endpoints:
             """)
 
             with gr.Row():
@@ -607,20 +587,16 @@ Use the forms below to test API endpoints:
                     api_peers_out = gr.JSON(label="Response")
                     api_peers_btn.click(fn=api_peers, inputs=api_peers_id, outputs=api_peers_out)
 
+
 # =============================================================================
-# FastAPI Integration for REST API
+# FASTAPI + GRADIO MOUNT (Docker SDK — we control the server)
 # =============================================================================
 
-from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse
-
-# Create FastAPI app for API endpoints
 api_app = FastAPI(title="BAZINGA API", description="API for CLI integration")
 
 
 @api_app.post("/api/register")
 async def handle_register(request: Request):
-    """Register a new node."""
     try:
         data = await request.json()
         result = api_register(
@@ -635,13 +611,11 @@ async def handle_register(request: Request):
 
 @api_app.get("/api/nodes")
 async def handle_nodes():
-    """Get all registered nodes."""
     return JSONResponse(content=api_nodes())
 
 
 @api_app.get("/api/verify")
 async def handle_verify(node_id: str = None):
-    """Verify a node ID."""
     if not node_id:
         return JSONResponse(content={"success": False, "error": "node_id query param required"})
     return JSONResponse(content=api_verify(node_id))
@@ -649,7 +623,6 @@ async def handle_verify(node_id: str = None):
 
 @api_app.post("/api/heartbeat")
 async def handle_heartbeat(request: Request):
-    """Update node heartbeat."""
     try:
         data = await request.json()
         result = api_heartbeat(
@@ -664,27 +637,26 @@ async def handle_heartbeat(request: Request):
 
 @api_app.get("/api/peers")
 async def handle_peers(node_id: str = None):
-    """Get list of active peers."""
     return JSONResponse(content=api_peers(node_id))
 
 
 @api_app.get("/api/stats")
 async def handle_stats():
-    """Get network statistics."""
     stats = get_network_stats()
     active_nodes = stats["active_nodes"]
-    consciousness_psi = CONSCIOUSNESS_SCALE * active_nodes if active_nodes > 0 else 0
+    consciousness_psi = CONSCIOUSNESS_SCALE * math.sqrt(active_nodes) if active_nodes > 0 else 0
     return JSONResponse(content={
         "success": True,
         **stats,
-        "consciousness_psi": round(consciousness_psi, 2),
-        "consciousness_formula": f"Ψ_D = 6.46 × {active_nodes} = {consciousness_psi:.2f}"
+        "consciousness_psi": round(consciousness_psi, 3),
+        "consciousness_formula": f"Psi_D / Psi_i = phi * sqrt({active_nodes}) = {consciousness_psi:.3f}"
     })
 
 
-# Mount Gradio app onto FastAPI
+# Mount Gradio onto FastAPI (Gradio UI at /, API at /api/*)
 app = gr.mount_gradio_app(api_app, demo, path="/")
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

requirements.txt

@@ -1,5 +1,3 @@
-gradio==4.19.2
-huggingface_hub==0.20.3
-audioop-lts
+gradio>=5.0,<6.0
 fastapi>=0.100.0
 uvicorn>=0.23.0