Merge pull request #24 from harmony-one/luma-video

fegloff · web-flow · commit f5ff2a3b6625 · 2024-11-07T21:57:30.000-05:00
Luma video
diff --git a/apis/anthropic/anthropic_resource.py b/apis/anthropic/anthropic_resource.py
@@ -6,6 +6,7 @@
 import anthropic
 import json
 import os
+from services import telegram_report_error
 from .anthropic_helper import anthropicHelper as helper
 from app_types import ToolsBetaMessage
 from res import EngMsg as msg, CustomError
@@ -121,6 +122,7 @@ def post(self):
             error_json = json.loads(e.response.text)
             error_message = error_json["error"]["message"]
             app.logger.error(f"Unexpected Error: ({error_code}) {error_message}")
+            telegram_report_error("anthropic", "NO_CHAT_ID", error_code, error_message)            
             raise CustomError(error_code, error_message)
         except Exception as e:
             app.logger.error(f"Unexpected Error: {str(e)}")
@@ -157,6 +159,7 @@ def post(self):
             error_json = json.loads(e.response.text)
             error_message = error_json["error"]["message"]
             app.logger.error(f"Unexpected Error: ({error_code}) {error_message}")
+            telegram_report_error("anthropic", "NO_CHAT_ID", error_code, error_message)
             raise CustomError(error_code, error_message)
         except Exception as e:
             app.logger.error(f"Ucnexpected Error: {str(e)}")
@@ -255,6 +258,7 @@ def __tool_request_handler(self, data, tool_execution_id, context):
             error_json = json.loads(e.response.text)
             error_message = error_json["error"]["message"]
             app.logger.error(f"Unexpected Error: ({error_code}) {error_message}")
+            telegram_report_error("anthropic", "NO_CHAT_ID", error_code, error_message)
             raise CustomError(error_code, error_message)
         except Exception as e:
             context.push()
@@ -342,6 +346,7 @@ def post(self):
             error_json = json.loads(e.response.text)
             error_message = error_json["error"]["message"]
             app.logger.error(f"Unexpected Error: ({error_code}) {error_message}")
+            telegram_report_error("anthropic", "NO_CHAT_ID", error_code, error_message)
             raise CustomError(error_code, error_message)
         except Exception as e:
             app.logger.error(f"Unexpected Error: {str(e)}")
@@ -434,11 +439,12 @@ def post(self):
             else: 
                 raise CustomError(400, "Bad request")
         except anthropic.AnthropicError as e:
-                    error_code = e.status_code
-                    error_json = json.loads(e.response.text)
-                    error_message = error_json["error"]["message"]
-                    app.logger.error(f"Unexpected Error: ({error_code}) {error_message}")
-                    raise CustomError(error_code, error_message)
+            error_code = e.status_code
+            error_json = json.loads(e.response.text)
+            error_message = error_json["error"]["message"]
+            app.logger.error(f"Unexpected Error: ({error_code}) {error_message}")
+            telegram_report_error("anthropic", "NO_CHAT_ID", error_code, error_message)
+            raise CustomError(error_code, error_message)
         except Exception as e:
             app.logger.error(f"Unexpected Error: {str(e)}")
             raise CustomError(500, "An unexpected error occurred.")
diff --git a/apis/llms_resource.py b/apis/llms_resource.py
@@ -1,4 +1,5 @@
 from flask import request, jsonify, Response, make_response, current_app as app
+
 from .vertex_resource import VertexGeminiCompletionRes
 from .anthropic import AnthropicCompletionRes
 from flask_restx import Namespace, Resource
diff --git a/apis/luma/luma_helper.py b/apis/luma/luma_helper.py
@@ -7,6 +7,7 @@
 from config import config
 from . import luna_client
 import json
+from services import send_telegram_error_message
 
 def send_telegram_message_with_download_button(chat_id, text, generation_id):
     try:
@@ -57,19 +58,6 @@ def count_generation_in_progress(generation_list):
 def get_queue_time(in_progress_count):
     return in_progress_count * 45 # 45 secs per video
 
-def send_telegram_error_message(chat_id, error_text):
-    bot_token = config.TELEGRAM_API_KEY
-    base_url = f"https://api.telegram.org/bot{bot_token}/"
-    
-    params = {
-        "chat_id": chat_id,
-        "text": error_text
-    }
-    
-    response = requests.post(base_url + "sendMessage", json=params)
-    return response.json()
-
-
 def process_generation(prompt, generation_id, chat_id):
     try:
         completed = False
diff --git a/apis/luma/luma_resource.py b/apis/luma/luma_resource.py
@@ -5,6 +5,7 @@
 from .luma_helper import count_generation_in_progress, count_generation_states, get_queue_time, process_generation, LumaErrorHandler
 from res import EngMsg as msg, CustomError
 from config import config
+from services import telegram_report_error
 import concurrent.futures
 import lumaai
 
@@ -16,6 +17,7 @@ class Generation:
     def __init__(self, id):
         self.id = id
 
+
 @api.route('/generations')
 class LumaAiGenerationRes(Resource):
     
@@ -44,6 +46,7 @@ def post(self):
         except lumaai.APIError as e:
             status_code, error_detail = LumaErrorHandler.get_error_info(e)
             LumaErrorHandler.log_error(app.logger, e)
+            telegram_report_error("luma", chat_id, status_code, error_detail)
             raise CustomError(status_code, error_detail)
     
         except Exception as e:
@@ -63,7 +66,7 @@ def get(self):
         return make_response(jsonify(generations), 200)
 
 
-@api.route('/generation/<generation_id>')
+@api.route('/generations/<generation_id>')
 class GenerationRes(Resource):
     
     @api.doc(params={"generation_id": msg.API_DOC_PARAMS_COLLECTION_NAME})
@@ -73,7 +76,7 @@ def delete(self, generation_id):
         """
         try:
             if (generation_id):
-                luna_client.generations.delete(generation_id)
+                luna_client.generations.delete(id=generation_id)
                 return 'OK', 204
             else:
                 return "Bad request, parameters missing", 400
diff --git a/apis/openai_resource.py b/apis/openai_resource.py
@@ -2,9 +2,11 @@
 from flask_restx import Namespace, Resource
 from werkzeug.utils import secure_filename
 from openai.error import OpenAIError
+from res import EngMsg as msg, CustomError
 import openai
 import os
-from res import EngMsg as msg, CustomError
+
+from services import telegram_report_error
 
 api = Namespace('openai', description=msg.API_NAMESPACE_OPENAI_DESCRIPTION)
 
@@ -58,6 +60,7 @@ def post(self):
         # Handle OpenAI API errors
         error_message = str(e)
         app.logger.error(f"OpenAI API Error: {error_message}")
+        telegram_report_error("openai", "NO_CHAT_ID", e.code, error_message)
         raise CustomError(500, error_message)
     except Exception as e:
         # Handle other unexpected errors
diff --git a/apis/vertex_resource.py b/apis/vertex_resource.py
@@ -3,15 +3,20 @@
 from vertexai.language_models import ChatModel, ChatMessage
 from vertexai.preview.generative_models import GenerativeModel, Content, Part
 import google.generativeai as genai
+from google.cloud import aiplatform
 from google.generativeai.types import content_types
 from google.oauth2 import service_account
 import google.cloud.aiplatform as aiplatform
+from google.api_core.exceptions import GoogleAPICallError, ClientError
+from vertexai.generative_models import ResponseValidationError
+from services import telegram_report_error
 
 # from litellm import litellm
 import openai
 import vertexai
 import json
 
+
 from res import EngMsg as msg, CustomError
 
 with open(
@@ -102,11 +107,15 @@ def post(self):
 
             # return f"{response}", 200 # non streaming responses
             return make_response(jsonify(response), 200)
-        except openai.error.OpenAIError as e:
-            # Handle OpenAI API errors
-            error_message = str(e)
-            app.logger.error(f"OpenAI API Error: {error_message}")
-            raise CustomError(500, error_message)
+        except ResponseValidationError as e:
+            telegram_report_error("vertex", "NO_CHAT_ID", "NO_CODE", str(e))
+            raise CustomError(e.code, e.message)
+        except GoogleAPICallError as e:
+            telegram_report_error("vertex", "NO_CHAT_ID", e.code, e.message)
+            raise CustomError(e.code, e.message)
+        except ClientError as e:
+            telegram_report_error("vertex", "NO_CHAT_ID", e.code, e.message)
+            raise CustomError(e.code, e.message)
         except Exception as e:
             # Handle other unexpected errors
             error_message = str(e)
@@ -127,14 +136,16 @@ def post(self):
             if data.get('stream') == "True":
                 data['stream'] = True  # convert to boolean
             model = data.get('model')
+            system_instruction = data.get('system')
+            max_output_tokens = data.get('max_tokens')
+            generation_config = genai.GenerationConfig(
+                max_output_tokens=int(max_output_tokens),
+                temperature=0.1,
+                top_p= 1.0,
+                top_k= 40,
+            )
             app.logger.info(f'handling gemini request using {model}')
-            chat_model = genai.GenerativeModel(model)
-            parameters = {
-                "max_output_tokens": 800,
-                "temperature": 0.1,
-                "top_p": 1.0,
-                "top_k": 40,
-            }
+            chat_model = genai.GenerativeModel(model, system_instruction=system_instruction)
             if all(
                 isinstance(m, dict) and
                 set(m.keys()) == {"parts", "role"} and
@@ -163,15 +174,19 @@ def post(self):
                     print("Skipping item - Invalid format:", item)
             inputTokens = chat_model.count_tokens(history)
             if data['stream'] == True: # use generate_responses to stream responses
-                response = chat_model.generate_content(history, stream=True)
+                response = chat_model.generate_content(history, generation_config=generation_config, stream=True)
                 return Response(data_generator(response, inputTokens.total_tokens, chat_model), mimetype='text/event-stream')
             
             return make_response(jsonify(response), 200)
-        except openai.error.OpenAIError as e:
-            # Handle OpenAI API errors
-            error_message = str(e)
-            app.logger.error(f"OpenAI API Error: {error_message}")
-            raise CustomError(500, error_message)
+        except ResponseValidationError as e:
+            telegram_report_error("vertex", "NO_CHAT_ID", "NO_CODE", str(e))
+            raise CustomError(e.code, e.message)
+        except GoogleAPICallError as e:
+            telegram_report_error("vertex", "NO_CHAT_ID", e.code, e.message)
+            raise CustomError(e.code, e.message)
+        except ClientError as e:
+            telegram_report_error("vertex", "NO_CHAT_ID", e.code, e.message)
+            raise CustomError(e.code, e.message)    
         except Exception as e:
             # Handle other unexpected errors
             error_message = str(e)
diff --git a/config.py b/config.py
@@ -21,4 +21,5 @@ class Config(object):
     API_KEYS = os.environ.get("API_KEYS").split(',') if os.environ.get("API_KEYS") else []
     LUMAAI_API_KEY = os.environ.get("LUMAAI_API_KEY")
     TELEGRAM_API_KEY = os.environ.get('TELEGRAM_API_KEY')
+    TELEGRAM_REPORT_ID = os.environ.get('TELEGRAM_REPORT_ID') # telegram user id
 config = Config()
diff --git a/services/__init__.py b/services/__init__.py
@@ -1,4 +1,4 @@
-from .telegram import BotHandler
+from .telegram import BotHandler, send_telegram_error_message, telegram_report_error
 from .web_crawling import WebCrawling
 from .pdf import PdfHandler
 from .timer_decorator import timer
diff --git a/services/telegram.py b/services/telegram.py
@@ -1,5 +1,26 @@
+import requests
 import telebot
 
+from config import config
+
+def send_telegram_error_message(chat_id, error_text):
+    bot_token = config.TELEGRAM_API_KEY
+    base_url = f"https://api.telegram.org/bot{bot_token}/"
+    
+    params = {
+        "chat_id": chat_id,
+        "text": error_text
+    }
+    
+    response = requests.post(base_url + "sendMessage", json=params)
+    return response.json()
+
+def telegram_report_error(resource_name, chat_id, status_code, error_detail):
+    user_id = config.TELEGRAM_REPORT_ID
+    if (user_id and resource_name and chat_id and status_code and error_detail): 
+        error_text = f"{resource_name} : Error reported in chat {chat_id} => ({status_code}) {error_detail}"
+        send_telegram_error_message(user_id, error_text)
+    
 class BotHandler:
     
     def __init__(self, token):

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`from flask import request, jsonify, Response, make_response, current_app as app`
	`2`	`+`
`2`	`3`	`from .vertex_resource import VertexGeminiCompletionRes`
`3`	`4`	`from .anthropic import AnthropicCompletionRes`
`4`	`5`	`from flask_restx import Namespace, Resource`