Spaces:

Greg-House
/

Simple-piping

Paused

App Files Files Community

Greg-House commited on Nov 14, 2024

Commit

1d78341

verified ·

1 Parent(s): 46496fe

Update app.py

Browse files

Files changed (1) hide show

app.py +33 -126

app.py CHANGED Viewed

@@ -1,11 +1,9 @@
 import asyncio
 import aiohttp
-import time
-import ssl
 from datetime import datetime
 from collections import deque
-import json
-from pathlib import Path
 class EphemeralStreamReader:
     def __init__(self, piping_server_url="https://ppng.io", path="test123", retention_hours=1, show_output=False):
@@ -58,14 +56,8 @@ class EphemeralStreamReader:
                                 try:
                                     text = chunk.decode('utf-8')
                                     self.store_chunk(text, current_time)
-                                    if self.show_output:
-                                        timestamp = datetime.fromtimestamp(current_time).strftime('%Y-%m-%d %H:%M:%S')
-                                        print(f"[{timestamp}] Received: {text}", end='', flush=True)
                                 except UnicodeDecodeError:
                                     self.store_chunk(str(chunk), current_time)
-                                    if self.show_output:
-                                        print(f"Received raw bytes: {chunk}")
             except aiohttp.ClientError as e:
                 if self.show_output:
@@ -74,129 +66,44 @@ class EphemeralStreamReader:
                 if self.show_output:
                     print(f"Error: {e}")
-            if self.show_output:
-                print(f"Connection closed. Reconnecting in {self.reconnect_delay} seconds...")
             await asyncio.sleep(self.reconnect_delay)
-    async def start_http_server(self, host='localhost', port=8000, ssl_context=None):
-        from aiohttp import web
-        async def handle_get(request):
-            data = self.get_stored_data()
-            html = f"""
-            <!DOCTYPE html>
-            <html>
-            <head>
-                <title>Ephemeral Stream Data</title>
-                <style>
-                    body {{
-                        font-family: Arial, sans-serif;
-                        margin: 20px;
-                    }}
-                    .data-container {{
-                        margin: 20px 0;
-                    }}
-                    .timestamp {{
-                        color: #666;
-                        font-size: 0.9em;
-                    }}
-                    .data-item {{
-                        margin: 10px 0;
-                        padding: 10px;
-                        background: #f5f5f5;
-                        border-radius: 4px;
-                    }}
-                    .refresh-btn {{
-                        padding: 10px 20px;
-                        background: #4CAF50;
-                        color: white;
-                        border: none;
-                        border-radius: 4px;
-                        cursor: pointer;
-                    }}
-                    .info {{
-                        margin-bottom: 20px;
-                        color: #666;
-                    }}
-                </style>
-                <script>
-                    function refreshData() {{
-                        window.location.reload();
-                    }}
-                </script>
-            </head>
-            <body>
-                <h1>Ephemeral Stream Data</h1>
-                <div class="info">
-                    <p>Stream Path: {self.path}</p>
-                    <p>Retention Time: {self.retention_hours} hours</p>
-                    <p>To write to this stream: <code>seq inf | curl -T- {self.url}</code></p>
-                </div>
-                <button class="refresh-btn" onclick="refreshData()">Refresh Data</button>
-                <div class="data-container">
-            """
-            for item in reversed(data):
-                html += f"""
-                    <div class="data-item">
-                        <div class="timestamp">{item['formatted_time']}</div>
-                        <pre>{item['data']}</pre>
-                    </div>
-                """
-            html += """
-                </div>
-            </body>
-            </html>
-            """
-            return web.Response(text=html, content_type='text/html')
-        app = web.Application()
-        app.router.add_get('/', handle_get)
-        runner = web.AppRunner(app)
-        await runner.setup()
-        site = web.TCPSite(runner, host, port, ssl_context=ssl_context)
-        await site.start()
-        protocol = "https" if ssl_context else "http"
-        print(f"\nWeb interface available at {protocol}://{host}:{port}")
-        print(f"To write to this stream: seq inf | curl -T- {self.url}")
-def create_ssl_context():
-    """Create SSL context from certificate and key files"""
-    cert_path = Path("./localhost.pem")
-    key_path = Path("./localhost-key.pem")
-    if not cert_path.exists() or not key_path.exists():
-        print("Warning: SSL certificate or key not found. Running in HTTP mode.")
-        return None
-    ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
-    ssl_context.load_cert_chain(str(cert_path), str(key_path))
-    return ssl_context
-async def main():
-    ssl_context = create_ssl_context()
-    reader = EphemeralStreamReader(retention_hours=1, show_output=False)
-    await asyncio.gather(
-        reader.start_reading(),
-        reader.start_http_server(host='localhost', port=8000, ssl_context=ssl_context)
-    )
-if __name__ == "__main__":
-    import argparse
-    parser = argparse.ArgumentParser(description='Ephemeral Stream Reader with HTTPS support')
-    parser.add_argument('--host', default='localhost', help='Host to bind to')
-    parser.add_argument('--port', type=int, default=8000, help='Port to bind to')
-    parser.add_argument('--path', default='test123', help='Path for the stream')
-    args = parser.parse_args()
-    print("Starting Ephemeral Stream Reader with HTTPS support...")
-    try:
-        asyncio.run(main())
-    except KeyboardInterrupt:
-        print("\nStopping server...")

 import asyncio
 import aiohttp
 from datetime import datetime
 from collections import deque
+import time
+import gradio as gr
 class EphemeralStreamReader:
     def __init__(self, piping_server_url="https://ppng.io", path="test123", retention_hours=1, show_output=False):
                                 try:
                                     text = chunk.decode('utf-8')
                                     self.store_chunk(text, current_time)
                                 except UnicodeDecodeError:
                                     self.store_chunk(str(chunk), current_time)
             except aiohttp.ClientError as e:
                 if self.show_output:
                 if self.show_output:
                     print(f"Error: {e}")
             await asyncio.sleep(self.reconnect_delay)
+def format_stored_data(reader):
+    data = reader.get_stored_data()
+    formatted_text = ""
+    for item in reversed(data):
+        formatted_text += f"[{item['formatted_time']}]\n{item['data']}\n\n"
+    return formatted_text
+def create_ui(reader):
+    with gr.Blocks() as demo:
+        gr.Markdown(f"# Ephemeral Stream Reader\nStream Path: {reader.path}\nRetention Time: {reader.retention_hours} hours")
+        gr.Markdown(f"To write to this stream: `seq inf | curl -T- {reader.url}`")
+        output_text = gr.TextArea(label="Stream Output", interactive=False)
+        refresh_btn = gr.Button("Refresh")
+        def update_output():
+            return format_stored_data(reader)
+        refresh_btn.click(fn=update_output, outputs=[output_text])
+        demo.load(fn=update_output, outputs=[output_text])
+        # Auto-refresh every 5 seconds
+        demo.load(fn=update_output, outputs=[output_text], every=5)
+    return demo
+async def start_application():
+    reader = EphemeralStreamReader(retention_hours=1, show_output=True)
+    # Start the stream reader in the background
+    asyncio.create_task(reader.start_reading())
+    # Create and launch the Gradio interface
+    demo = create_ui(reader)
+    return demo
+if __name__ == "__main__":
+    demo = asyncio.run(start_application())
+    demo.launch(server_name="0.0.0.0", server_port=7860)