Updated app for version 2

app.py

@@ -1,48 +1,57 @@
 import streamlit as st
 import requests
-import os  # To access environment variables
-import google.generativeai as genai  # Import Gemini API
+import os
+import google.generativeai as genai
+import tensorflow as tf
+import numpy as np
+from tensorflow.keras.layers import TextVectorization
 
-# Load API keys from environment variables
+# --- Config ---
+vocab_size = 10000
+sequence_length = 150
+
+# Load API keys
 HF_API_TOKEN = os.getenv("HF_API_TOKEN")
 GEMINI_API_KEY = os.getenv("GOOGLE_API_KEY")
 
-# Set up Hugging Face API
-MODEL_ID = "Salesforce/codet5p-770m"  # CodeT5+ (Recommended)
+# Hugging Face setup
+MODEL_ID = "Salesforce/codet5p-770m"
 API_URL = f"https://api-inference.huggingface.co/models/{MODEL_ID}"
 HEADERS = {"Authorization": f"Bearer {HF_API_TOKEN}"}
 
-# Initialize Gemini API
-genai.configure(api_key='AIzaSyBkc8CSEhyYwZAuUiJfzF1Xtns-RYmBOpg')
+# Gemini setup
+genai.configure(api_key="AIzaSyBkc8CSEhyYwZAuUiJfzF1Xtns-RYmBOpg")
 
-def translate_code(code_snippet, source_lang, target_lang):
-    """Translate code using Hugging Face API."""
-    prompt = f"Translate the following {source_lang} code to {target_lang}:\n\n{code_snippet}\n\nTranslated {target_lang} Code:\n"
+# --- Load Local Model & Vectorizers ---
+model = tf.keras.models.load_model("java_to_python_seq2seq_model.h5")
 
-    response = requests.post(API_URL, headers=HEADERS, json={
-        "inputs": prompt,
-        "parameters": {
-            "max_new_tokens": 150,
-            "temperature": 0.2,
-            "top_k": 50
-        }
-    })
+java_vectorizer = TextVectorization(max_tokens=vocab_size, output_sequence_length=sequence_length)
+python_vectorizer = TextVectorization(max_tokens=vocab_size, output_sequence_length=sequence_length)
 
-    if response.status_code == 200:
-        generated_text = response.json()[0]["generated_text"]
-        translated_code = generated_text.split(f"Translated {target_lang} Code:\n")[-1].strip()
-        return translated_code
-    else:
-        return f"Error: {response.status_code}, {response.text}"
+# Fake adaptation to initialize vectorizers
+java_vectorizer.adapt(tf.data.Dataset.from_tensor_slices(["public class Main { public static void main(String[] args) {} }"]))
+python_vectorizer.adapt(tf.data.Dataset.from_tensor_slices(["def main():\n    pass"]))
+
+# Reverse lookup for Python vocab
+python_vocab = python_vectorizer.get_vocabulary()
+index_to_word = dict(enumerate(python_vocab))
+
+def decode_sequence(pred):
+    """Greedy decoding of the prediction."""
+    pred_ids = tf.argmax(pred, axis=-1).numpy()[0]
+    tokens = [index_to_word.get(i, "") for i in pred_ids]
+    code = " ".join(tokens).replace("[UNK]", "").strip()
+    return code
+
+# --- Translation Functions ---
 
 def fallback_translate_with_gemini(code_snippet, source_lang, target_lang):
-    """Fallback function using Gemini API for translation."""
     prompt = f"""You are a code translation expert. Convert the following {source_lang} code to {target_lang}:
     
     {code_snippet}
 
     Ensure the translation is accurate and follows {target_lang} best practices.
-    Do not give any explaination. only give the translated code.
+    Do not give any explanation. Only give the translated code.
     """
     try:
         model = genai.GenerativeModel("gemini-1.5-pro")
@@ -51,17 +60,55 @@ def fallback_translate_with_gemini(code_snippet, source_lang, target_lang):
     except Exception as e:
         return f"Gemini API Error: {str(e)}"
 
-# Streamlit UI
-st.title("🔄 Programming Language Translator")
-st.write("Translate code between different programming languages using AI.")
+def translate_with_local_model(code_snippet):
+    """Local seq2seq Java→Python translation."""
+    try:
+        java_seq = java_vectorizer(tf.constant([code_snippet]))
+        python_in = tf.constant([[1] + [0] * (sequence_length - 1)])  # <start> token
+        translated_tokens = []
+
+        for i in range(sequence_length):
+            preds = model.predict([java_seq, python_in], verbose=0)
+            next_token = tf.argmax(preds[0, i]).numpy()
+            translated_tokens.append(next_token)
+            if next_token == 0:
+                break
+            if i + 1 < sequence_length:
+                python_in = tf.tensor_scatter_nd_update(
+                    python_in, [[0, i + 1]], [next_token]
+                )
+
+        tokens = [index_to_word.get(t, "") for t in translated_tokens]
+        return " ".join(tokens).replace("[UNK]", "").strip()
 
-languages = ["Python", "Java", "C++", "C"]
+    except Exception as e:
+        return f"Local Model Error: {str(e)}"
+
+def translate_code(code_snippet, source_lang, target_lang):
+    """Hugging Face translation."""
+    prompt = f"Translate the following {source_lang} code to {target_lang}:\n\n{code_snippet}\n\nTranslated {target_lang} Code:\n"
+    response = requests.post(API_URL, headers=HEADERS, json={
+        "inputs": prompt,
+        "parameters": {"max_new_tokens": 150, "temperature": 0.2, "top_k": 50}
+    })
 
+    if response.status_code == 200:
+        generated_text = response.json()[0]["generated_text"]
+        translated_code = generated_text.split(f"Translated {target_lang} Code:\n")[-1].strip()
+        return translated_code
+    else:
+        return f"Error: {response.status_code}, {response.text}"
+
+# --- Streamlit UI ---
+
+st.title("🔄  Programming Language Translator")
+st.write("Translate code between programming languages using 3-tier AI fallback.")
+
+languages = ["Python", "Java", "C++", "C"]
 source_lang = st.selectbox("Select source language", languages)
 target_lang = st.selectbox("Select target language", languages)
 code_input = st.text_area("Enter your code here:", height=200)
 
-# Initialize session state
 if "translate_attempts" not in st.session_state:
     st.session_state.translate_attempts = 0
     st.session_state.translated_code = ""
@@ -69,13 +116,15 @@ if "translate_attempts" not in st.session_state:
 if st.button("Translate"):
     if code_input.strip():
         st.session_state.translate_attempts += 1
-        with st.spinner("Translating..."):
-            if st.session_state.translate_attempts == 1:
-                # First attempt using the pretrained model
-                st.session_state.translated_code = translate_code(code_input, source_lang, target_lang)
-            else:
-                # Second attempt uses Gemini API
+        attempt = st.session_state.translate_attempts
+
+        with st.spinner(f"Translating..."):
+            if attempt == 1:
                 st.session_state.translated_code = fallback_translate_with_gemini(code_input, source_lang, target_lang)
+            elif attempt == 2 and source_lang == "Java" and target_lang == "Python":
+                st.session_state.translated_code = translate_with_local_model(code_input)
+            else:
+                st.session_state.translated_code = translate_code(code_input, source_lang, target_lang)
 
         st.subheader("Translated Code:")
         st.code(st.session_state.translated_code, language=target_lang.lower())
@@ -95,28 +144,27 @@ if st.button("Translate"):
 
 
 
-
-
-
-# V1 without gemini api
+# version1: Without Trained model.
 
 # import streamlit as st
 # import requests
-# import os  # Import os to access environment variables
-
-# # Get API token from environment variable
-# API_TOKEN = os.getenv("HF_API_TOKEN")
+# import os  # To access environment variables
+# import google.generativeai as genai  # Import Gemini API
 
+# # Load API keys from environment variables
+# HF_API_TOKEN = os.getenv("HF_API_TOKEN")
+# GEMINI_API_KEY = os.getenv("GOOGLE_API_KEY")
 
-# # Change MODEL_ID to a better model
+# # Set up Hugging Face API
 # MODEL_ID = "Salesforce/codet5p-770m"  # CodeT5+ (Recommended)
-# # MODEL_ID = "bigcode/starcoder2-15b"  # StarCoder2
-# # MODEL_ID = "bigcode/starcoder"
 # API_URL = f"https://api-inference.huggingface.co/models/{MODEL_ID}"
-# HEADERS = {"Authorization": f"Bearer {API_TOKEN}"}
+# HEADERS = {"Authorization": f"Bearer {HF_API_TOKEN}"}
+
+# # Initialize Gemini API
+# genai.configure(api_key='AIzaSyBkc8CSEhyYwZAuUiJfzF1Xtns-RYmBOpg')
 
 # def translate_code(code_snippet, source_lang, target_lang):
-#     """Translate code using Hugging Face API securely."""
+#     """Translate code using Hugging Face API."""
 #     prompt = f"Translate the following {source_lang} code to {target_lang}:\n\n{code_snippet}\n\nTranslated {target_lang} Code:\n"
 
 #     response = requests.post(API_URL, headers=HEADERS, json={
@@ -125,7 +173,6 @@ if st.button("Translate"):
 #             "max_new_tokens": 150,
 #             "temperature": 0.2,
 #             "top_k": 50
-#             # "stop": ["\n\n", "#", "//", "'''"]
 #         }
 #     })
 
@@ -136,8 +183,24 @@ if st.button("Translate"):
 #     else:
 #         return f"Error: {response.status_code}, {response.text}"
 
+# def fallback_translate_with_gemini(code_snippet, source_lang, target_lang):
+#     """Fallback function using Gemini API for translation."""
+#     prompt = f"""You are a code translation expert. Convert the following {source_lang} code to {target_lang}:
+    
+#     {code_snippet}
+
+#     Ensure the translation is accurate and follows {target_lang} best practices.
+#     Do not give any explaination. only give the translated code.
+#     """
+#     try:
+#         model = genai.GenerativeModel("gemini-1.5-pro")
+#         response = model.generate_content(prompt)
+#         return response.text.strip() if response else "Translation failed."
+#     except Exception as e:
+#         return f"Gemini API Error: {str(e)}"
+
 # # Streamlit UI
-# st.title("🔄 Code Translator using StarCoder")
+# st.title("🔄 Programming Language Translator")
 # st.write("Translate code between different programming languages using AI.")
 
 # languages = ["Python", "Java", "C++", "C"]
@@ -146,11 +209,96 @@ if st.button("Translate"):
 # target_lang = st.selectbox("Select target language", languages)
 # code_input = st.text_area("Enter your code here:", height=200)
 
+# # Initialize session state
+# if "translate_attempts" not in st.session_state:
+#     st.session_state.translate_attempts = 0
+#     st.session_state.translated_code = ""
+
 # if st.button("Translate"):
 #     if code_input.strip():
+#         st.session_state.translate_attempts += 1
 #         with st.spinner("Translating..."):
-#             translated_code = translate_code(code_input, source_lang, target_lang)
-#             st.subheader("Translated Code:")
-#             st.code(translated_code, language=target_lang.lower())
+#             if st.session_state.translate_attempts == 1:
+#                 # First attempt using the pretrained model
+#                 st.session_state.translated_code = translate_code(code_input, source_lang, target_lang)
+#             else:
+#                 # Second attempt uses Gemini API
+#                 st.session_state.translated_code = fallback_translate_with_gemini(code_input, source_lang, target_lang)
+
+#         st.subheader("Translated Code:")
+#         st.code(st.session_state.translated_code, language=target_lang.lower())
 #     else:
 #         st.warning("⚠️ Please enter some code before translating.")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# # V1 without gemini api
+
+# # import streamlit as st
+# # import requests
+# # import os  # Import os to access environment variables
+
+# # # Get API token from environment variable
+# # API_TOKEN = os.getenv("HF_API_TOKEN")
+
+
+# # # Change MODEL_ID to a better model
+# # MODEL_ID = "Salesforce/codet5p-770m"  # CodeT5+ (Recommended)
+# # # MODEL_ID = "bigcode/starcoder2-15b"  # StarCoder2
+# # # MODEL_ID = "bigcode/starcoder"
+# # API_URL = f"https://api-inference.huggingface.co/models/{MODEL_ID}"
+# # HEADERS = {"Authorization": f"Bearer {API_TOKEN}"}
+
+# # def translate_code(code_snippet, source_lang, target_lang):
+# #     """Translate code using Hugging Face API securely."""
+# #     prompt = f"Translate the following {source_lang} code to {target_lang}:\n\n{code_snippet}\n\nTranslated {target_lang} Code:\n"
+
+# #     response = requests.post(API_URL, headers=HEADERS, json={
+# #         "inputs": prompt,
+# #         "parameters": {
+# #             "max_new_tokens": 150,
+# #             "temperature": 0.2,
+# #             "top_k": 50
+# #             # "stop": ["\n\n", "#", "//", "'''"]
+# #         }
+# #     })
+
+# #     if response.status_code == 200:
+# #         generated_text = response.json()[0]["generated_text"]
+# #         translated_code = generated_text.split(f"Translated {target_lang} Code:\n")[-1].strip()
+# #         return translated_code
+# #     else:
+# #         return f"Error: {response.status_code}, {response.text}"
+
+# # # Streamlit UI
+# # st.title("🔄 Code Translator using StarCoder")
+# # st.write("Translate code between different programming languages using AI.")
+
+# # languages = ["Python", "Java", "C++", "C"]
+
+# # source_lang = st.selectbox("Select source language", languages)
+# # target_lang = st.selectbox("Select target language", languages)
+# # code_input = st.text_area("Enter your code here:", height=200)
+
+# # if st.button("Translate"):
+# #     if code_input.strip():
+# #         with st.spinner("Translating..."):
+# #             translated_code = translate_code(code_input, source_lang, target_lang)
+# #             st.subheader("Translated Code:")
+# #             st.code(translated_code, language=target_lang.lower())
+# #     else:
+# #         st.warning("⚠️ Please enter some code before translating.")