Create app.py

app.py

@@ -0,0 +1,212 @@
+import os
+import json
+from pptx import Presentation
+import gradio as gr
+from openai import OpenAI
+import queue
+from datetime import datetime
+
+# Configuration for different API providers
+API_PROVIDERS = {
+    "DeepSeek": "https://api.deepseek.com",
+    "ChatGPT": "https://api.openai.com/v1",
+    "Mistral": "https://api.mistral.ai/v1"
+}
+
+# List of supported languages
+LANGUAGES = {
+    "Chinese (Simplified)": "zh",
+    "Chinese (Traditional)": "zh-TW",
+    "Korean": "ko",
+    "Japanese": "ja",
+    "Arabic": "ar",
+    "English": "en",
+    "Spanish": "es",
+    "French": "fr",
+    "German": "de",
+    "Italian": "it",
+    "Portuguese": "pt",
+    "Russian": "ru",
+    "Hindi": "hi",
+    "Turkish": "tr",
+    "Dutch": "nl",
+    "Polish": "pl",
+    "Vietnamese": "vi",
+    "Thai": "th",
+    "Indonesian": "id",
+    "Swedish": "sv",
+    "Greek": "el"
+}
+
+class TranslatorApp:
+    def __init__(self):
+        self.log_queue = queue.Queue()
+        self.processing = False
+        self.process_thread = None
+
+    def load_config(self):
+        try:
+            with open('config.json', 'r') as f:
+                return json.load(f)
+        except:
+            return {}
+
+    def save_config(self, api_provider, api_key, source_lang, target_lang):
+        config = {
+            'api_provider': api_provider,
+            'api_key': api_key,
+            'source_lang': source_lang,
+            'target_lang': target_lang
+        }
+        with open('config.json', 'w') as f:
+            json.dump(config, f)
+
+    def translate_text(self, text, source_lang, target_lang, api_provider, api_key):
+        if not api_key:
+            raise ValueError("API key is required")
+
+        translation_methods = {
+            "DeepSeek": self.translate_with_deepseek,
+            "ChatGPT": self.translate_with_chatgpt,
+            "Mistral": self.translate_with_mistral
+        }
+
+        translate_method = translation_methods.get(api_provider)
+        if not translate_method:
+            raise ValueError(f"Unsupported API provider: {api_provider}")
+
+        return translate_method(text, source_lang, target_lang, api_key)
+
+    def translate_with_deepseek(self, text, source_lang, target_lang, api_key):
+        client = OpenAI(api_key=api_key, base_url=API_PROVIDERS["DeepSeek"])
+        response = client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[
+                {"role": "system", "content": f"Translate from {source_lang} to {target_lang}:"},
+                {"role": "user", "content": text},
+            ]
+        )
+        return response.choices[0].message.content
+
+    def translate_with_chatgpt(self, text, source_lang, target_lang, api_key):
+        client = OpenAI(api_key=api_key)
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": f"Translate from {source_lang} to {target_lang}:"},
+                {"role": "user", "content": text},
+            ]
+        )
+        return response.choices[0].message.content
+
+    def translate_with_mistral(self, text, source_lang, target_lang, api_key):
+        client = OpenAI(api_key=api_key, base_url=API_PROVIDERS["Mistral"])
+        response = client.chat.completions.create(
+            model="mistral-tiny",
+            messages=[
+                {"role": "system", "content": f"Translate from {source_lang} to {target_lang}:"},
+                {"role": "user", "content": text},
+            ]
+        )
+        return response.choices[0].message.content
+
+    def generate_review(self, translated_text, source_lang, api_provider, api_key):
+        try:
+            self.log("Generating review...")
+            client = OpenAI(api_key=api_key, base_url=API_PROVIDERS[api_provider])
+            
+            system_prompt = f"""Generate a comprehensive review in {source_lang} covering:
+            1. Main themes and key points
+            2. Translation quality assessment
+            3. Coherence and flow
+            4. Technical terminology accuracy
+            5. Recommendations for improvement"""
+            
+            model = {
+                "DeepSeek": "deepseek-chat",
+                "ChatGPT": "gpt-3.5-turbo",
+                "Mistral": "mistral-tiny"
+            }.get(api_provider, "gpt-3.5-turbo")
+            
+            response = client.chat.completions.create(
+                model=model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": translated_text},
+                ]
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            self.log(f"Error generating review: {str(e)}")
+            return "Failed to generate review."
+
+    def log(self, message):
+        self.log_queue.put(message)
+
+    def process_pptx(self, file_path, source_lang, target_lang, api_provider, api_key):
+        try:
+            prs = Presentation(file_path)
+            total_slides = len(prs.slides)
+            all_translated_text = ""
+
+            for i, slide in enumerate(prs.slides):
+                if not self.processing:
+                    self.log("Process interrupted by user")
+                    return
+
+                self.log(f"Processing slide {i+1}/{total_slides}")
+                for shape in slide.shapes:
+                    if hasattr(shape, "text") and shape.text.strip():
+                        translated_text = self.translate_text(shape.text, source_lang, target_lang, api_provider, api_key)
+                        shape.text = translated_text
+                        all_translated_text += translated_text + "\n"
+
+            if self.processing:
+                output_path = os.path.join(os.path.dirname(file_path), f"translated_{os.path.basename(file_path)}")
+                prs.save(output_path)
+                self.log(f"Saved translated file: {output_path}")
+
+                # Generate and save review
+                review = self.generate_review(all_translated_text, source_lang, api_provider, api_key)
+                review_path = output_path.replace(".pptx", "_review.txt")
+                with open(review_path, "w", encoding="utf-8") as f:
+                    f.write(review)
+                self.log(f"Generated and saved review: {review_path}")
+
+                return output_path, review_path
+
+        except Exception as e:
+            self.log(f"Error during processing: {str(e)}")
+            raise e
+
+    def run(self, file, api_provider, api_key, source_lang, target_lang):
+        self.processing = True
+        self.save_config(api_provider, api_key, source_lang, target_lang)
+        try:
+            output_path, review_path = self.process_pptx(file.name, source_lang, target_lang, api_provider, api_key)
+            return f"File has been translated and saved as:\n{output_path}\nReview saved as:\n{review_path}"
+        except Exception as e:
+            return f"An error occurred during processing: {str(e)}"
+        finally:
+            self.processing = False
+
+def create_interface():
+    app = TranslatorApp()
+    interface = gr.Interface(
+        fn=app.run,
+        inputs=[
+            gr.File(label="Upload PowerPoint File"),
+            gr.Dropdown(label="API Provider", choices=list(API_PROVIDERS.keys())),
+            gr.Textbox(label="API Key", type="password"),
+            gr.Dropdown(label="Source Language", choices=list(LANGUAGES.keys())),
+            gr.Dropdown(label="Target Language", choices=list(LANGUAGES.keys()))
+        ],
+        outputs=gr.Textbox(label="Output"),
+        title="BabelSlide by Heuristica",
+        description="Translate PowerPoint presentations using various AI models."
+    )
+    return interface
+
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch()