Upload 17 files

working files addes

.github/workflows/python-app.yml

@@ -0,0 +1,23 @@
+name: Streamlit app
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+jobs:
+  streamlit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - uses: streamlit/streamlit-app-action@v0.0.3
+        with:
+          app-path: streamlit_app.py
+          ruff: true

app.py

@@ -0,0 +1,178 @@
+import streamlit as st
+from src.api.model_integration import stream_response
+from src.utils.prompt_templates import (
+    get_translation_prompt,
+    get_sentiment_analysis_prompt,
+    get_cultural_reference_explanation_prompt,
+    get_interactive_translation_prompt,
+)
+from config.config import Config
+
+
+def setup_page():
+    """
+    Sets up the page with custom styles and page configuration.
+    """
+    st.set_page_config(
+        page_title="Translator-AI (Llama3.1)",
+        layout="wide",
+        initial_sidebar_state="expanded",
+    )
+
+    st.markdown(
+        """
+        <style>
+        :root {
+            --llama-color: #4e8cff;
+            --llama-color-light: #e6f0ff;
+            --llama-color-dark: #1a3a6c;
+            --llama-gradient-start: #4e54c8;
+            --llama-gradient-end: #8f94fb;
+        }
+        .stApp {
+            margin: auto;
+            background-color: var(--background-color);
+            color: var(--text-color);
+        }
+        .logo-container {
+            display: flex;
+            justify-content: center;
+            margin-bottom: 1rem;
+        }
+        .logo-container img {
+            width: 150px;
+        }
+        </style>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def main():
+    setup_page()
+
+    # Header section with title and subtitle
+    st.markdown(
+        """
+        <div style="text-align: center;">
+            <h1 class="header-title">🦙 Meta-Llama 3.1 Translator-AI</h1>
+            <p class="header-subtitle">Powered by Meta's advanced language models</p>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    # Meta logo
+    st.markdown(
+        """
+        <div class="logo-container">
+            <img src="https://upload.wikimedia.org/wikipedia/commons/7/7b/Meta_Platforms_Inc._logo.svg" alt="Meta Logo">
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    # Remove the Llama image display
+
+    # Sidebar for settings
+    with st.sidebar:
+        st.title("🦙 Llama Translator Settings")
+        model_name = st.selectbox("Choose a model", Config.AVAILABLE_MODELS)
+
+        source_lang = st.selectbox(
+            "From", ["English", "Spanish", "French", "German", "Japanese"]
+        )
+        target_lang = st.selectbox(
+            "To", ["Spanish", "English", "French", "German", "Japanese"]
+        )
+        cultural_context = st.selectbox(
+            "Context", ["Formal", "Casual", "Business", "Youth Slang", "Poetic"]
+        )
+
+    # Main container with border
+    main_container = st.container(border=True)
+
+    with main_container:
+        st.header("Enter Text for Translation and Analysis")
+        text = st.text_area(
+            "Text to translate",
+            "It was the best of times, it was the worst of times...",
+            height=200,
+        )
+        st.caption(f"Character count: {len(text)}")
+
+        if st.button("Translate and Analyze", type="primary"):
+            if text:
+                # Tabs for different analysis types
+                tab1, tab2, tab3, tab4 = st.tabs(
+                    [
+                        "Translation",
+                        "Sentiment Analysis",
+                        "Cultural References",
+                        "Interactive Translation",
+                    ]
+                )
+
+                # Tab 1: Translation
+                with tab1:
+                    st.subheader("Translation Result")
+                    translation_container = st.empty()
+                    translation_prompt = get_translation_prompt(
+                        text, source_lang, target_lang, cultural_context
+                    )
+                    translation = stream_response(
+                        [{"role": "user", "content": translation_prompt}],
+                        translation_container,
+                        model_name,
+                    )
+
+                # Tab 2: Sentiment Analysis
+                with tab2:
+                    st.subheader("Sentiment Analysis")
+                    sentiment_container = st.empty()
+                    sentiment_prompt = get_sentiment_analysis_prompt(text, source_lang)
+                    sentiment_analysis = stream_response(
+                        [{"role": "user", "content": sentiment_prompt}],
+                        sentiment_container,
+                        model_name,
+                    )
+
+                # Tab 3: Cultural References
+                with tab3:
+                    st.subheader("Cultural References")
+                    cultural_container = st.empty()
+                    cultural_prompt = get_cultural_reference_explanation_prompt(
+                        text, source_lang, target_lang
+                    )
+                    cultural_references = stream_response(
+                        [{"role": "user", "content": cultural_prompt}],
+                        cultural_container,
+                        model_name,
+                    )
+
+                # Tab 4: Interactive Translation
+                with tab4:
+                    st.subheader("Interactive Translation")
+                    interactive_container = st.empty()
+                    interactive_prompt = get_interactive_translation_prompt(
+                        text, source_lang, target_lang
+                    )
+                    interactive_translation = stream_response(
+                        [{"role": "user", "content": interactive_prompt}],
+                        interactive_container,
+                        model_name,
+                    )
+
+    # Sidebar for additional information and feedback
+    with st.sidebar:
+        st.subheader("About")
+        st.info("This app demonstrates Meta's Llama 3.1 capabilities.")
+
+        st.subheader("Feedback")
+        feedback = st.text_area("Leave your feedback here", height=100)
+        if st.button("Submit Feedback"):
+            st.success("Thank you for your feedback!")
+
+
+if __name__ == "__main__":
+    main()

config/config.py

@@ -0,0 +1,19 @@
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+class Config:
+    """
+    A configuration class that retrieves env variables and stores config settings.
+    """
+
+    HOSTED_BASE_URL = os.getenv("HOSTED_BASE_URL")
+    HOSTED_API_KEY = os.getenv("HOSTED_API_KEY")
+    LOCAL_BASE_URL = os.getenv("LOCAL_BASE_URL")
+
+    AVAILABLE_MODELS = [
+        "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",
+        "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+        "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+        "llama3.1",
+    ]

requirements.txt

@@ -0,0 +1,7 @@
+streamlit
+openai
+requests
+Pillow
+python-dotenv
+langchain
+langchain_community

src/api/model_integration.py

@@ -0,0 +1,94 @@
+import requests
+import json
+from openai import OpenAI
+from config.config import Config
+
+
+def get_api_config(model_name):
+    """
+    Get API base URL and API key based on the model name.
+    """
+    if model_name.startswith("meta-llama/"):
+        return Config.HOSTED_BASE_URL, Config.HOSTED_API_KEY
+    elif model_name == "llama3.1":
+        return Config.LOCAL_BASE_URL, None
+    else:
+        raise ValueError(f"Invalid model name: {model_name}")
+
+
+def handle_hosted_request(client, model_name, messages, container):
+    """
+    Handles the hosted Llama 3.1 model requests via OpenAI's API.
+    """
+    try:
+        stream = client.chat.completions.create(
+            model=model_name,
+            messages=messages,
+            stream=True,
+        )
+        response_placeholder = container.empty()
+        full_response = ""
+        for chunk in stream:
+            if chunk.choices[0].delta.content is not None:
+                full_response += chunk.choices[0].delta.content
+                response_placeholder.markdown(full_response + "▌")
+        response_placeholder.markdown(full_response)
+        return full_response
+    except Exception as e:
+        error_message = f"API Error: {str(e)}"
+        container.error(error_message)
+        return None
+
+
+def handle_local_request(base_url, model_name, messages, container):
+    """
+    Handles requests to the locally hosted Llama 3.1 model.
+    """
+    try:
+        payload = {
+            "model": model_name,
+            "messages": messages,
+            "stream": True,
+        }
+        headers = {"Content-Type": "application/json"}
+
+        response_placeholder = container.empty()
+        full_response = ""
+
+        with requests.post(
+            base_url, json=payload, headers=headers, stream=True
+        ) as response:
+            response.raise_for_status()
+            for line in response.iter_lines():
+                if line:
+                    try:
+                        chunk = json.loads(line)
+                        if "done" in chunk and chunk["done"]:
+                            break
+                        if "message" in chunk and "content" in chunk["message"]:
+                            content = chunk["message"]["content"]
+                            full_response += content
+                            response_placeholder.markdown(full_response + "▌")
+                    except json.JSONDecodeError:
+                        pass
+        response_placeholder.markdown(full_response)
+        return full_response
+    except requests.RequestException as e:
+        error_message = f"API Error: {str(e)}"
+        container.error(error_message)
+        return None
+
+
+def stream_response(messages, container, model_name):
+    """
+    This function handles the API request based on the model (hosted or local) and streams the response.
+    """
+    base_url, api_key = get_api_config(model_name)
+
+    if model_name.startswith("meta-llama/"):
+        client = OpenAI(api_key=api_key, base_url=base_url)
+        return handle_hosted_request(client, model_name, messages, container)
+    elif model_name == "llama3.1":
+        return handle_local_request(base_url, model_name, messages, container)
+    else:
+        raise ValueError("Unsupported model selected.")

src/utils/prompt_templates.py

@@ -0,0 +1,111 @@
+def get_translation_prompt(text, source_lang, target_lang, cultural_context):
+    """
+    Returns a prompt for translating the given text while considering cultural context.
+    """
+    return f"""
+    As an advanced cultural translation assistant, translate the following text from {source_lang} to {target_lang}, adapting it to a {cultural_context} context:
+
+    "{text}"
+
+    Provide your response in markdown format as follows, using Streamlit's markdown capabilities for enhanced visual appeal:
+
+    ## :blue[Translation]
+    > [Your translated text here]
+
+    ## :green[Cultural Adaptations]
+    - **Adaptation 1**: [Explanation]
+    - **Adaptation 2**: [Explanation]
+    [Add more adaptations as needed]
+
+    ## :orange[Alternative Phrasings]
+    1. ":violet[Original phrase]" → ":rainbow[Alternative 1]", ":rainbow[Alternative 2]"
+       - _Context_: [Explain when to use each alternative]
+
+    ## :red[Linguistic Analysis]
+    - **Register**: [Formal/Informal/etc.]
+    - **Tone**: [Describe the tone of the translation]
+    - **Key Challenges**: [Discuss any particularly challenging aspects of the translation]
+    """    
+
+
+def get_sentiment_analysis_prompt(text, source_lang):
+    """
+    Returns a prompt for conducting sentiment analysis on a given text.
+    """
+    return f"""
+    Conduct a comprehensive sentiment analysis of the following {source_lang} text:
+
+    "{text}"
+
+    Provide your analysis in markdown format as follows:
+
+    ## :blue[Overall Sentiment]
+    [Positive/Negative/Neutral/Mixed]
+
+    ## :green[Sentiment Breakdown]
+    - **Positivity**: :smile: [Score from 0 to 1]
+    - **Negativity**: :frowning: [Score from 0 to 1]
+    - **Neutrality**: :neutral_face: [Score from 0 to 1]
+
+    ## :orange[Key Emotional Indicators]
+    1. **:heart: [Emotion 1]**: 
+       - _Evidence_: ":violet[Relevant quote from text]"
+       - _Explanation_: [Brief analysis]
+
+    ## :earth_americas: Cultural Context
+    [Explain how the sentiment might be perceived in the {source_lang}-speaking culture, considering any cultural-specific expressions or connotations]
+    """
+
+def get_cultural_reference_explanation_prompt(text, source_lang, target_lang):
+    """
+    Returns a prompt to explain cultural references in a source language for a target language audience.
+    """
+    return f"""
+    As a cross-cultural communication expert, explain the cultural references in this {source_lang} text for someone from a {target_lang} background:
+
+    "{text}"
+
+    ## :earth_americas: Cultural References
+
+    1. **:star: [Reference 1]**
+       - _Meaning_: :blue[Explanation]
+       - _Cultural Significance_: :green[Brief description]
+       - _{target_lang} Equivalent_: :orange[Equivalent or similar concept, if applicable]
+       - _Usage Example_: ":violet[Show how it's used in a sentence]"
+
+    2. **:star: [Reference 2]**
+       - _Meaning_: :blue[Explanation]
+       - _Cultural Significance_: :green[Brief description]
+       - _{target_lang} Equivalent_: :orange[Equivalent or similar concept, if applicable]
+       - _Usage Example_: ":violet[Show how it's used in a sentence]"
+
+    ## :globe_with_meridians: Overall Cultural Context
+    [Summarize the cultural differences relevant to this text.]
+    """
+
+def get_interactive_translation_prompt(text, source_lang, target_lang):
+    """
+    Returns a prompt for providing an interactive, detailed translation with context.
+    """
+    return f"""
+    Translate the following text from {source_lang} to {target_lang} and provide an overall analysis of its meaning, usage, and cultural relevance:
+
+    "{text}"
+
+    ## :books: General Translation
+    **Text** → ":blue[Overall translation]"
+
+    ## :arrows_counterclockwise: Contextual Usage and Adaptation
+    1. ":green[Context 1]" - _Explanation_: [How the translation adapts to cultural context]
+    2. ":orange[Context 2]" - _Explanation_: [Alternative contextual usage]
+
+    ## :dna: Etymology and Origin
+    - **Origin**: :violet[Brief description of word origins or key concepts]
+    - **Related concepts**: :rainbow[If applicable, related words or phrases]
+
+    ## :memo: Usage Notes
+    - **Register**: :blue[Formal/Informal/etc.]
+    - **Connotations**: :green[Positive/Negative connotations of the translation]
+    - **Cultural Significance**: :orange[Explain the cultural impact or relevance of the translation]
+    """
+