Deploying TechHub Prototype

.dockerignore

@@ -0,0 +1,7 @@
+.git
+.env
+__pycache__
+node_modules
+dist
+venv
+*.md

.gitattributes

@@ -33,3 +33,53 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/__pycache__/typing_extensions.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/anyio/_backends/__pycache__/_asyncio.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/charset_normalizer/md__mypyc.cp312-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/click/__pycache__/core.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/google/_upb/_message.pyd filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/google/genai/__pycache__/models.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/google/genai/__pycache__/types.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/google/protobuf/__pycache__/descriptor_pb2.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/idna/__pycache__/idnadata.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/idna/__pycache__/uts46data.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pip/_vendor/__pycache__/typing_extensions.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pip/_vendor/distlib/t64-arm.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pip/_vendor/distlib/t64.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pip/_vendor/distlib/w64-arm.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pip/_vendor/distlib/w64.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pip/_vendor/rich/__pycache__/_emoji_codes.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pip/_vendor/rich/__pycache__/console.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pyasn1/type/__pycache__/univ.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pyaudio/_portaudio.cp312-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pydantic/__pycache__/json_schema.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pydantic/_internal/__pycache__/_generate_schema.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pydantic_core/__pycache__/core_schema.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pydantic_core/_pydantic_core.cp312-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pydantic_settings/__pycache__/sources.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Lib/site-packages/pygments/lexers/__pycache__/lisp.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/dotenv.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/fastapi.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/httpx.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/normalizer.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/pip.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/pip3.12.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/pip3.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/py.test.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/pygmentize.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/pyrsa-decrypt.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/pyrsa-encrypt.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/pyrsa-keygen.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/pyrsa-priv2pub.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/pyrsa-sign.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/pyrsa-verify.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/pytest.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/python.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/pythonw.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/uvicorn.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucbackend/venv/Scripts/websockets.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucfrontend/node_modules/@esbuild/win32-x64/esbuild.exe filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucfrontend/node_modules/@rollup/rollup-win32-x64-gnu/rollup.win32-x64-gnu.node filter=lfs diff=lfs merge=lfs -text
+techhubprototypeucfrontend/node_modules/@rollup/rollup-win32-x64-msvc/rollup.win32-x64-msvc.node filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,33 @@
+# Stage 1: Build Frontend
+FROM node:20 as frontend-builder
+
+WORKDIR /app/frontend
+COPY techhubprototypeucfrontend/package*.json ./
+RUN npm install
+COPY techhubprototypeucfrontend/ .
+RUN npm run build
+
+# Stage 2: Backend
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies if needed
+# RUN apt-get update && apt-get install -y --no-install-recommends gcc && rm -rf /var/lib/apt/lists/*
+
+COPY techhubprototypeucbackend/requirements.txt .
+# Remove pyaudio from requirements if it's there, as it requires system dependencies and we removed usage
+RUN sed -i '/pyaudio/d' requirements.txt
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY techhubprototypeucbackend/ .
+
+# Copy frontend build to static folder
+COPY --from=frontend-builder /app/frontend/dist ./static
+
+# Expose port 7860 (Hugging Face Spaces default)
+EXPOSE 7860
+
+# Run the app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

referenceDocs/Get_started_LiveAPI.py

@@ -0,0 +1,275 @@
+# -*- coding: utf-8 -*-
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+## Setup
+
+To install the dependencies for this script, run:
+
+``` 
+pip install google-genai opencv-python pyaudio pillow mss
+```
+
+Before running this script, ensure the `GOOGLE_API_KEY` environment
+variable is set to the api-key you obtained from Google AI Studio.
+
+Important: **Use headphones**. This script uses the system default audio
+input and output, which often won't include echo cancellation. So to prevent
+the model from interrupting itself it is important that you use headphones. 
+
+## Run
+
+To run the script:
+
+```
+python Get_started_LiveAPI.py
+```
+
+The script takes a video-mode flag `--mode`, this can be "camera", "screen", or "none".
+The default is "camera". To share your screen run:
+
+```
+python Get_started_LiveAPI.py --mode screen
+```
+"""
+
+import asyncio
+import base64
+import io
+import os
+import sys
+import traceback
+
+import cv2
+import pyaudio
+import PIL.Image
+import mss
+
+import argparse
+
+from google import genai
+
+if sys.version_info < (3, 11, 0):
+    import taskgroup, exceptiongroup
+
+    asyncio.TaskGroup = taskgroup.TaskGroup
+    asyncio.ExceptionGroup = exceptiongroup.ExceptionGroup
+
+FORMAT = pyaudio.paInt16
+CHANNELS = 1
+SEND_SAMPLE_RATE = 16000
+RECEIVE_SAMPLE_RATE = 24000
+CHUNK_SIZE = 1024
+
+MODEL = "models/gemini-2.0-flash-live-001"
+
+DEFAULT_MODE = "camera"
+
+client = genai.Client(http_options={"api_version": "v1beta"})
+
+CONFIG = {"response_modalities": ["AUDIO"]}
+
+pya = pyaudio.PyAudio()
+
+
+class AudioLoop:
+    def __init__(self, video_mode=DEFAULT_MODE):
+        self.video_mode = video_mode
+
+        self.audio_in_queue = None
+        self.out_queue = None
+
+        self.session = None
+
+        self.send_text_task = None
+        self.receive_audio_task = None
+        self.play_audio_task = None
+
+    async def send_text(self):
+        while True:
+            text = await asyncio.to_thread(
+                input,
+                "message > ",
+            )
+            if text.lower() == "q":
+                break
+            await self.session.send(input=text or ".", end_of_turn=True)
+
+    def _get_frame(self, cap):
+        # Read the frameq
+        ret, frame = cap.read()
+        # Check if the frame was read successfully
+        if not ret:
+            return None
+        # Fix: Convert BGR to RGB color space
+        # OpenCV captures in BGR but PIL expects RGB format
+        # This prevents the blue tint in the video feed
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        img = PIL.Image.fromarray(frame_rgb)  # Now using RGB frame
+        img.thumbnail([1024, 1024])
+
+        image_io = io.BytesIO()
+        img.save(image_io, format="jpeg")
+        image_io.seek(0)
+
+        mime_type = "image/jpeg"
+        image_bytes = image_io.read()
+        return {"mime_type": mime_type, "data": base64.b64encode(image_bytes).decode()}
+
+    async def get_frames(self):
+        # This takes about a second, and will block the whole program
+        # causing the audio pipeline to overflow if you don't to_thread it.
+        cap = await asyncio.to_thread(
+            cv2.VideoCapture, 0
+        )  # 0 represents the default camera
+
+        while True:
+            frame = await asyncio.to_thread(self._get_frame, cap)
+            if frame is None:
+                break
+
+            await asyncio.sleep(1.0)
+
+            await self.out_queue.put(frame)
+
+        # Release the VideoCapture object
+        cap.release()
+
+    def _get_screen(self):
+        sct = mss.mss()
+        monitor = sct.monitors[0]
+
+        i = sct.grab(monitor)
+
+        mime_type = "image/jpeg"
+        image_bytes = mss.tools.to_png(i.rgb, i.size)
+        img = PIL.Image.open(io.BytesIO(image_bytes))
+
+        image_io = io.BytesIO()
+        img.save(image_io, format="jpeg")
+        image_io.seek(0)
+
+        image_bytes = image_io.read()
+        return {"mime_type": mime_type, "data": base64.b64encode(image_bytes).decode()}
+
+    async def get_screen(self):
+
+        while True:
+            frame = await asyncio.to_thread(self._get_screen)
+            if frame is None:
+                break
+
+            await asyncio.sleep(1.0)
+
+            await self.out_queue.put(frame)
+
+    async def send_realtime(self):
+        while True:
+            msg = await self.out_queue.get()
+            await self.session.send(input=msg)
+
+    async def listen_audio(self):
+        mic_info = pya.get_default_input_device_info()
+        self.audio_stream = await asyncio.to_thread(
+            pya.open,
+            format=FORMAT,
+            channels=CHANNELS,
+            rate=SEND_SAMPLE_RATE,
+            input=True,
+            input_device_index=mic_info["index"],
+            frames_per_buffer=CHUNK_SIZE,
+        )
+        if __debug__:
+            kwargs = {"exception_on_overflow": False}
+        else:
+            kwargs = {}
+        while True:
+            data = await asyncio.to_thread(self.audio_stream.read, CHUNK_SIZE, **kwargs)
+            await self.out_queue.put({"data": data, "mime_type": "audio/pcm"})
+
+    async def receive_audio(self):
+        "Background task to reads from the websocket and write pcm chunks to the output queue"
+        while True:
+            turn = self.session.receive()
+            async for response in turn:
+                if data := response.data:
+                    self.audio_in_queue.put_nowait(data)
+                    continue
+                if text := response.text:
+                    print(text, end="")
+
+            # If you interrupt the model, it sends a turn_complete.
+            # For interruptions to work, we need to stop playback.
+            # So empty out the audio queue because it may have loaded
+            # much more audio than has played yet.
+            while not self.audio_in_queue.empty():
+                self.audio_in_queue.get_nowait()
+
+    async def play_audio(self):
+        stream = await asyncio.to_thread(
+            pya.open,
+            format=FORMAT,
+            channels=CHANNELS,
+            rate=RECEIVE_SAMPLE_RATE,
+            output=True,
+        )
+        while True:
+            bytestream = await self.audio_in_queue.get()
+            await asyncio.to_thread(stream.write, bytestream)
+
+    async def run(self):
+        try:
+            async with (
+                client.aio.live.connect(model=MODEL, config=CONFIG) as session,
+                asyncio.TaskGroup() as tg,
+            ):
+                self.session = session
+
+                self.audio_in_queue = asyncio.Queue()
+                self.out_queue = asyncio.Queue(maxsize=5)
+
+                send_text_task = tg.create_task(self.send_text())
+                tg.create_task(self.send_realtime())
+                tg.create_task(self.listen_audio())
+                if self.video_mode == "camera":
+                    tg.create_task(self.get_frames())
+                elif self.video_mode == "screen":
+                    tg.create_task(self.get_screen())
+
+                tg.create_task(self.receive_audio())
+                tg.create_task(self.play_audio())
+
+                await send_text_task
+                raise asyncio.CancelledError("User requested exit")
+
+        except asyncio.CancelledError:
+            pass
+        except ExceptionGroup as EG:
+            self.audio_stream.close()
+            traceback.print_exception(EG)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--mode",
+        type=str,
+        default=DEFAULT_MODE,
+        help="pixels to stream from",
+        choices=["camera", "screen", "none"],
+    )
+    args = parser.parse_args()
+    main = AudioLoop(video_mode=args.mode)
+    asyncio.run(main.run())

techhubprototypeucbackend/.env

@@ -0,0 +1 @@
+GOOGLE_API_KEY="AIzaSyCdGSqk7pc3yPuftVsP1EKzh4VUeQddya4"

techhubprototypeucbackend/.env.example

@@ -0,0 +1,5 @@
+# Google Generative AI API Key
+GOOGLE_API_KEY="YOUR_API_KEY_HERE"
+
+# Gemini Model to use
+GEMINI_MODEL="models/gemini-2.0-flash-live-001"

techhubprototypeucbackend/.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

techhubprototypeucbackend/.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

techhubprototypeucbackend/.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

techhubprototypeucbackend/.pytest_cache/v/cache/lastfailed

@@ -0,0 +1 @@
+{}

techhubprototypeucbackend/.pytest_cache/v/cache/nodeids

@@ -0,0 +1,4 @@
+[
+  "tests/test_main.py::test_read_main",
+  "tests/test_main.py::test_websocket_connection"
+]

techhubprototypeucbackend/main.py

@@ -0,0 +1,190 @@
+import asyncio
+import logging
+import os
+import sys
+import traceback
+
+from dotenv import load_dotenv
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from google import genai
+from google.api_core import exceptions as google_exceptions
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+if sys.version_info < (3, 11, 0):
+    import taskgroup, exceptiongroup
+
+    asyncio.TaskGroup = taskgroup.TaskGroup
+    asyncio.ExceptionGroup = exceptiongroup.ExceptionGroup
+
+# Audio settings
+# FORMAT = pyaudio.paInt16 # Removed pyaudio dependency
+# CHANNELS = 1
+# SEND_SAMPLE_RATE = 16000
+# RECEIVE_SAMPLE_RATE = 24000
+# CHUNK_SIZE = 1024
+
+# Load configuration from environment variables
+GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
+MODEL = os.environ.get("GEMINI_MODEL", "models/gemini-2.0-flash-live-001")
+
+# Configure the client with the API key
+try:
+    if not GOOGLE_API_KEY or GOOGLE_API_KEY == "YOUR_API_KEY_HERE":
+        # In HF Spaces, we might set this via secrets, so we warn but don't exit immediately if it's missing during build
+        logger.warning("GOOGLE_API_KEY environment variable not set or is a placeholder.")
+    client = genai.Client(api_key=GOOGLE_API_KEY)
+except (KeyError, ValueError) as e:
+    logger.critical(f"Error: {e}. Please set the GOOGLE_API_KEY environment variable.")
+    # sys.exit(1) # Don't exit, let it fail at runtime if key is missing, to allow build to pass
+
+CONFIG = {
+    "response_modalities": ["AUDIO"],
+    "output_audio_transcription": {},
+    "generation_config": {
+        "temperature": 1.0,
+    },
+}
+
+# pya = pyaudio.PyAudio() # Removed pyaudio dependency
+
+app = FastAPI()
+
+# Mount static files
+# We assume the frontend build will be copied to 'static' directory in the container
+if os.path.exists("static"):
+    app.mount("/assets", StaticFiles(directory="static/assets"), name="assets")
+
+@app.get("/")
+async def get():
+    # Serve the index.html from the static directory
+    if os.path.exists("static/index.html"):
+        return FileResponse("static/index.html")
+    return HTMLResponse("<h1>Frontend not found. Please build the frontend.</h1>")
+
+
+class AudioLoop:
+    def __init__(self, websocket: WebSocket):
+        self.websocket = websocket
+        self.session = None
+
+    async def run(self):
+        try:
+            async with client.aio.live.connect(model=MODEL, config=CONFIG) as session:
+                self.session = session
+                logger.info("Gemini Live API session started.")
+
+                async with asyncio.TaskGroup() as tg:
+                    tg.create_task(self.receive_from_gemini())
+                    tg.create_task(self.send_to_gemini())
+
+        except asyncio.CancelledError:
+            logger.info("Audio loop cancelled.")
+        except google_exceptions.GoogleAPICallError as e:
+            logger.error(f"Google API call error in audio loop: {e}")
+            await self.websocket.close(code=1011, reason=f"Google API Error: {e}")
+        except Exception as e:
+            logger.error(f"An error occurred in the audio loop: {e}")
+            traceback.print_exc()
+            await self.websocket.close(code=1011, reason="Internal Server Error")
+
+
+    async def send_to_gemini(self):
+        """Receives audio from the WebSocket and sends it to the Gemini API."""
+        while True:
+            try:
+                data = await self.websocket.receive_bytes()
+                if self.session:
+                    await self.session.send(
+                        input={"data": data, "mime_type": "audio/pcm"}
+                    )
+            except WebSocketDisconnect:
+                logger.info("Client disconnected from WebSocket.")
+                break
+            except Exception as e:
+                logger.error(f"Error receiving from websocket or sending to Gemini: {e}")
+                break
+
+    async def receive_from_gemini(self):
+        """Receives audio and text from the Gemini API and forwards it to the WebSocket."""
+        while True:
+            try:
+                if self.session:
+                    turn = self.session.receive()
+                    async for response in turn:
+                        # Handle audio data directly from response.data
+                        if data := response.data:
+                            await self.websocket.send_bytes(data)
+                            continue
+
+                        # Handle text/transcript and potentially nested audio data
+                        candidate_texts = []
+                        server_content = (
+                            response.server_content.model_turn.parts
+                            if response.server_content
+                            and response.server_content.model_turn
+                            and response.server_content.model_turn.parts
+                            else []
+                        )
+
+                        for part in server_content:
+                            # Check for nested audio data
+                            if inline_data := getattr(part, "inline_data", None):
+                                if data := getattr(inline_data, "data", None):
+                                    await self.websocket.send_bytes(data)
+                            # Check for text
+                            if part_text := getattr(part, "text", None):
+                                candidate_texts.append(part_text)
+
+                        server_content_obj = getattr(response, "server_content", None)
+                        if server_content_obj:
+                            if output_transcription := getattr(server_content_obj, "output_transcription", None):
+                                if trans_text := getattr(output_transcription, "text", None):
+                                    candidate_texts.append(trans_text)
+                            if input_transcription := getattr(server_content_obj, "input_transcription", None):
+                                if trans_text := getattr(input_transcription, "text", None):
+                                    candidate_texts.append(trans_text)
+
+                        if output_text := getattr(response, "output_text", None):
+                            if isinstance(output_text, (list, tuple)):
+                                candidate_texts.extend(output_text)
+                            else:
+                                candidate_texts.append(output_text)
+
+                        if response_text := getattr(response, "text", None):
+                            candidate_texts.append(response_text)
+
+                        for text_chunk in candidate_texts:
+                            if not text_chunk:
+                                continue
+                            normalized = text_chunk.replace("\r", "").replace("\n", " ")
+                            if normalized and normalized.strip():
+                                logger.info(f"Received text: {normalized.strip()}")
+                                await self.websocket.send_text(normalized)
+            except WebSocketDisconnect:
+                logger.info("Client disconnected. Stopping receive loop.")
+                break
+            except Exception as e:
+                logger.error(f"Error receiving from Gemini or sending to websocket: {e}")
+                break
+
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    logger.info("WebSocket connection accepted.")
+    audio_loop = AudioLoop(websocket)
+    try:
+        await audio_loop.run()
+    except WebSocketDisconnect:
+        logger.info("Client disconnected.")
+    except Exception as e:
+        logger.error(f"Error in websocket endpoint: {e}")
+    finally:
+        logger.info("WebSocket connection closed.")

techhubprototypeucbackend/requirements.txt

@@ -0,0 +1,12 @@
+uvicorn>=0.30.5
+google-genai==1.46.0
+google-auth==2.41.1
+google-api-core==2.19.2
+pydantic==2.9.0
+pydantic-settings==2.7.0
+pytest>=8.3
+pytest-asyncio>=0.23
+fastapi
+python-dotenv
+websockets
+pyaudio

techhubprototypeucbackend/tests/test_main.py

@@ -0,0 +1,46 @@
+import pytest
+from fastapi.testclient import TestClient
+from unittest.mock import patch, MagicMock, AsyncMock
+from main import app
+
+client = TestClient(app)
+
+def test_read_main():
+    response = client.get("/")
+    assert response.status_code == 200
+    assert "<h1>Gemini Live API</h1>" in response.text
+
+@pytest.mark.asyncio
+@patch('main.client')
+async def test_websocket_connection(mock_client):
+    # Mock the Gemini client and session
+    mock_session = MagicMock()
+    
+    # Make the mock session an async iterator for the receive method
+    mock_session.receive.return_value = mock_session
+    async def async_iterator():
+        yield MagicMock(text="test", data=b"")
+    mock_session.__aiter__.return_value = async_iterator()
+    mock_session.send = AsyncMock()
+
+    # Create an async context manager for the mock
+    async def async_context_manager(*args, **kwargs):
+        class AsyncContextManager:
+            async def __aenter__(self):
+                return mock_session
+            async def __aexit__(self, exc_type, exc_val, exc_tb):
+                pass
+        return AsyncContextManager()
+
+    mock_client.aio.live.connect.side_effect = async_context_manager
+
+    with client.websocket_connect("/ws") as websocket:
+        # Test connection and initial message
+        assert websocket.scope['path'] == '/ws'
+
+        # Simulate sending audio data
+        audio_data = b'\x01\x02\x03'
+        websocket.send_bytes(audio_data)
+        
+        # Close the connection
+        websocket.close()

techhubprototypeucbackend/venv/Lib/site-packages/PyAudio-0.2.14.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

techhubprototypeucbackend/venv/Lib/site-packages/PyAudio-0.2.14.dist-info/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Hubert Pham
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

techhubprototypeucbackend/venv/Lib/site-packages/PyAudio-0.2.14.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.1
+Name: PyAudio
+Version: 0.2.14
+Summary: Cross-platform audio I/O with PortAudio
+Home-page: https://people.csail.mit.edu/hubert/pyaudio/
+Author: Hubert Pham
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Provides-Extra: test
+Requires-Dist: numpy ; extra == 'test'
+
+<img align="right" width="200" style="margin-left: 3px" src="https://people.csail.mit.edu/hubert/pyaudio/images/snake-300.png">
+
+# PyAudio
+
+PyAudio provides Python bindings for PortAudio v19, the cross-platform audio I/O library. With PyAudio, you can easily use Python to play and record audio on a variety of platforms, such as GNU/Linux, Microsoft Windows, and Apple macOS.
+
+PyAudio is distributed under the MIT License.
+
+* [Homepage](https://people.csail.mit.edu/hubert/pyaudio/)
+* [API Documentation](https://people.csail.mit.edu/hubert/pyaudio/docs/)
+* [PyPi](https://pypi.python.org/pypi/PyAudio)
+
+## Installation
+
+See the INSTALLATION file in the source distribution for details. In summary, install PyAudio using `pip` on most platforms.
+
+### Windows
+
+```sh
+python -m pip install pyaudio
+```
+
+This installs the precompiled PyAudio library with PortAudio v19 19.7.0 included. The library is compiled with support for Windows MME API, DirectSound, WASAPI, and WDM-KS. It does not include support for ASIO. If you require support for APIs not included, you will need to compile PortAudio and PyAudio.
+
+### macOS
+
+Use [Homebrew](https://brew.sh) to install the prerequisite [portaudio](http://portaudio.com) library, then install PyAudio using `pip`:
+
+```sh
+brew install portaudio
+pip install pyaudio
+```
+
+### GNU/Linux
+
+Use the package manager to install PyAudio. For example, on Debian-based systems:
+
+```sh
+sudo apt install python3-pyaudio
+```
+
+Alternatively, if the latest version of PyAudio is not available, install it using `pip`. Be sure to first install development libraries for `portaudio19` and `python3`.
+
+### Building from source
+
+See the INSTALLATION file.
+
+## Documentation & Usage Examples
+
+* Read the [API Documentation](https://people.csail.mit.edu/hubert/pyaudio/docs/), or generate it from the source using [`sphinx`](https://www.sphinx-doc.org/).
+
+* Usage examples are in the `examples` directory of the source distribution, or see the [project homepage](https://people.csail.mit.edu/hubert/pyaudio/).
+
+## License
+
+PyAudio is distributed under the MIT License. See LICENSE.txt.

techhubprototypeucbackend/venv/Lib/site-packages/PyAudio-0.2.14.dist-info/RECORD

@@ -0,0 +1,10 @@
+PyAudio-0.2.14.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+PyAudio-0.2.14.dist-info/LICENSE.txt,sha256=fntVlrMb-hzPD2Nug0TmemhiZeCRwN02DxG2bcgqvFQ,1055
+PyAudio-0.2.14.dist-info/METADATA,sha256=qNNR9Cphk7asLfQ1hbLo3VibawpPaCR2HyufgWYdrwI,2683
+PyAudio-0.2.14.dist-info/RECORD,,
+PyAudio-0.2.14.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+PyAudio-0.2.14.dist-info/WHEEL,sha256=7M9omTteV1AA1lqimSm66FA5mPjaJNBD3zI5eMwtk7s,102
+PyAudio-0.2.14.dist-info/top_level.txt,sha256=jp8bgmWZh435lFm-DsWc00D0k4xj4iAEmWd1L_TpKk8,8
+pyaudio/__init__.py,sha256=7V6ZjNJra5wjKcIoklmSU84UmFMrFm23DT1dtWtxXGU,36914
+pyaudio/__pycache__/__init__.cpython-312.pyc,,
+pyaudio/_portaudio.cp312-win_amd64.pyd,sha256=aKCiqugJeqIL9-m0A6N4KdufANn-sN1ea33C5_vNeBk,301568

techhubprototypeucbackend/venv/Lib/site-packages/PyAudio-0.2.14.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.3)
+Root-Is-Purelib: false
+Tag: cp312-cp312-win_amd64
+

techhubprototypeucbackend/venv/Lib/site-packages/PyAudio-0.2.14.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyaudio

techhubprototypeucbackend/venv/Lib/site-packages/__pycache__/typing_extensions.cpython-312.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff5616ddeb9ff271cbcba20d5201ea1643c2899ba707d028dbb6e58ae95f2eaf
+size 163697

techhubprototypeucbackend/venv/Lib/site-packages/_pytest/__init__.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+
+__all__ = ["__version__", "version_tuple"]
+
+try:
+    from ._version import version as __version__
+    from ._version import version_tuple
+except ImportError:  # pragma: no cover
+    # broken installation, we don't even try
+    # unknown only works because we do poor mans version compare
+    __version__ = "unknown"
+    version_tuple = (0, 0, "unknown")