update-tansc

src/server/main.py

@@ -444,73 +444,6 @@ async def chat(
         logger.error(f"Error processing request: {str(e)}")
         raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
 
-@app.post("/v1/process_audio/", 
-          response_model=AudioProcessingResponse,
-          summary="Process Audio File",
-          description="Process an uploaded audio file in the specified language. Rate limited to 100 requests per minute per user. Requires authentication.",
-          tags=["Audio"],
-          responses={
-              200: {"description": "Processed result", "model": AudioProcessingResponse},
-              401: {"description": "Unauthorized - Token required"},
-              429: {"description": "Rate limit exceeded"},
-              504: {"description": "Audio processing timeout"}
-          })
-@limiter.limit(settings.chat_rate_limit)
-async def process_audio(
-    request: Request,
-    file: UploadFile = File(..., description="Audio file to process"),
-    language: str = Query(..., description="Base64-encoded encrypted language of the audio (kannada, hindi, tamil after decryption)"),
-    credentials: HTTPAuthorizationCredentials = Depends(bearer_scheme),
-    x_session_key: str = Header(..., alias="X-Session-Key")
-):
-    user_id = await get_current_user(credentials)
-    session_key = base64.b64decode(x_session_key)
-    
-    # Decrypt the language
-    try:
-        encrypted_language = base64.b64decode(language)
-        decrypted_language = decrypt_data(encrypted_language, session_key).decode("utf-8")
-    except Exception as e:
-        logger.error(f"Language decryption failed: {str(e)}")
-        raise HTTPException(status_code=400, detail="Invalid encrypted language")
-    
-    # Validate language
-    allowed_languages = ["kannada", "hindi", "tamil"]
-    if decrypted_language not in allowed_languages:
-        raise HTTPException(status_code=400, detail=f"Language must be one of {allowed_languages}")
-    
-    logger.debug("Processing audio processing request", extra={
-        "endpoint": "/v1/process_audio",
-        "filename": file.filename,
-        "language": decrypted_language,
-        "client_ip": get_remote_address(request),
-        "user_id": user_id
-    })
-    
-    start_time = time()
-    try:
-        file_content = await file.read()
-        files = {"file": (file.filename, file_content, file.content_type)}
-        
-        external_url = f"{settings.external_api_base_url}/process_audio/?language={decrypted_language}"
-        response = requests.post(
-            external_url,
-            files=files,
-            headers={"accept": "application/json"},
-            timeout=60
-        )
-        response.raise_for_status()
-        
-        processed_result = response.json().get("result", "")
-        logger.debug(f"Audio processing completed in {time() - start_time:.2f} seconds")
-        return AudioProcessingResponse(result=processed_result)
-    
-    except requests.Timeout:
-        raise HTTPException(status_code=504, detail="Audio processing service timeout")
-    except requests.RequestException as e:
-        logger.error(f"Audio processing request failed: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Audio processing failed: {str(e)}")
-
 @app.post("/v1/transcribe/", 
           response_model=TranscriptionResponse,
           summary="Transcribe Audio File",
@@ -548,6 +481,15 @@ async def transcribe_audio(
     try:
         encrypted_content = await file.read()
         file_content = decrypt_data(encrypted_content, session_key)
+
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=file.filename) as temp_file:
+        # Write the decrypted content to the temp file
+            #decrypted_content = await file.read()  # Assuming decrypted_content is the file content
+            temp_file.write(file_content)
+            temp_file_path = temp_file.name
+
+        '''
         files = {"file": (file.filename, file_content, file.content_type)}
         
         external_url = f"{settings.external_api_base_url}/v1/transcribe/?language={decrypted_language}"
@@ -560,6 +502,11 @@ async def transcribe_audio(
         response.raise_for_status()
         
         transcription = response.json().get("text", "")
+        '''
+        response = dwani.ASR.transcribe(file_path=temp_file_path, language=decrypted_language)
+
+        transcription = response.get("text","")
+        
         logger.debug(f"Transcription completed in {time() - start_time:.2f} seconds")
         return TranscriptionResponse(text=transcription)
     
@@ -572,44 +519,6 @@ async def transcribe_audio(
         logger.error(f"Transcription request failed: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Transcription failed: {str(e)}")
 
-@app.post("/v1/chat_v2", 
-          response_model=TranscriptionResponse,
-          summary="Chat with Image (V2)",
-          description="Generate a response from a text prompt and optional image. Rate limited to 100 requests per minute per user. Requires authentication.",
-          tags=["Chat"],
-          responses={
-              200: {"description": "Chat response", "model": TranscriptionResponse},
-              400: {"description": "Invalid prompt"},
-              401: {"description": "Unauthorized - Token required"},
-              429: {"description": "Rate limit exceeded"}
-          })
-@limiter.limit(settings.chat_rate_limit)
-async def chat_v2(
-    request: Request,
-    prompt: str = Form(..., description="Text prompt for chat"),
-    image: UploadFile = File(default=None, description="Optional image to accompany the prompt"),
-    credentials: HTTPAuthorizationCredentials = Depends(bearer_scheme)
-):
-    user_id = await get_current_user(credentials)
-    if not prompt:
-        raise HTTPException(status_code=400, detail="Prompt cannot be empty")
-    
-    logger.debug("Processing chat_v2 request", extra={
-        "endpoint": "/v1/chat_v2",
-        "prompt_length": len(prompt),
-        "has_image": bool(image),
-        "client_ip": get_remote_address(request),
-        "user_id": user_id
-    })
-    
-    try:
-        image_data = Image.open(await image.read()) if image else None
-        response_text = f"Processed: {prompt}" + (" with image" if image_data else "")
-        return TranscriptionResponse(text=response_text)
-    except Exception as e:
-        logger.error(f"Chat_v2 processing failed: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
-
 @app.post("/v1/translate", 
           response_model=TranslationResponse,
           summary="Translate Text",
@@ -1030,78 +939,6 @@ async def speech_to_speech(
         raise HTTPException(status_code=500, detail=f"External API error: {str(e)}")
 
 
-@app.post("/v1/speech_to_speech_v2",
-          summary="Speech-to-Speech Conversion",
-          description="Convert input encrypted speech to processed speech in the specified encrypted language by calling an external speech-to-speech API. Rate limited to 5 requests per minute per user. Requires authentication and X-Session-Key header.",
-          tags=["Audio"],
-          responses={
-              200: {"description": "Audio stream", "content": {"audio/mp3": {"example": "Binary audio data"}}},
-              400: {"description": "Invalid input, encrypted audio, or language"},
-              401: {"description": "Unauthorized - Token required"},
-              429: {"description": "Rate limit exceeded"},
-              504: {"description": "External API timeout"},
-              500: {"description": "External API error"}
-          })
-async def speech_to_speech_v2(
-    request: Request,
-    file: UploadFile = File(..., description="Encrypted audio file to process"),
-    language: str = Query(..., description="Base64-encoded encrypted language of the audio (kannada, hindi, tamil after decryption)"),
-) -> StreamingResponse:
-    
-    # Decrypt the language
-    try:
-        encrypted_language = language
-        decrypted_language = encrypted_language
-    except Exception as e:
-        logger.error(f"Language decryption failed: {str(e)}")
-        raise HTTPException(status_code=400, detail="Invalid encrypted language")
-    
-    # Validate language
-    allowed_languages = [lang.value for lang in SupportedLanguage]
-    if decrypted_language not in allowed_languages:
-        raise HTTPException(status_code=400, detail=f"Language must be one of {allowed_languages}")
-    
-    logger.debug("Processing speech-to-speech request", extra={
-        "endpoint": "/v1/speech_to_speech",
-        "audio_filename": file.filename,
-        "language": decrypted_language,
-        "client_ip": get_remote_address(request),
-    })
-
-    try:
-        encrypted_content = await file.read()
-        file_content = encrypted_content
-        files = {"file": (file.filename, file_content, file.content_type)}
-        external_url = f"{settings.external_api_base_url}/v1/speech_to_speech?language={decrypted_language}"
-
-        response = requests.post(
-            external_url,
-            files=files,
-            headers={"accept": "application/json"},
-            stream=True,
-            timeout=60
-        )
-        response.raise_for_status()
-
-        headers = {
-            "Content-Disposition": f"inline; filename=\"speech.mp3\"",
-            "Cache-Control": "no-cache",
-            "Content-Type": "audio/mp3"
-        }
-
-        return StreamingResponse(
-            response.iter_content(chunk_size=8192),
-            media_type="audio/mp3",
-            headers=headers
-        )
-
-    except requests.Timeout:
-        logger.error("External speech-to-speech API timed out")
-        raise HTTPException(status_code=504, detail="External API timeout")
-    except requests.RequestException as e:
-        logger.error(f"External speech-to-speech API error: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"External API error: {str(e)}")
-
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Run the FastAPI server.")