Upload 5 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+java_to_python_seq2seq_model.pdf filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,286 @@
+import streamlit as st
+import requests
+import os
+import google.generativeai as genai
+import tensorflow as tf
+import numpy as np
+from tensorflow.keras.layers import TextVectorization
+
+# --- 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")
+
+# 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}"}
+
+genai.configure(api_key="AIzaSyBkc8CSEhyYwZAuUiJfzF1Xtns-RYmBOpg")
+
+# --- Load Local Model & Vectorizers ---
+model = tf.keras.models.load_model("java_to_python_seq2seq_model.h5")
+
+java_vectorizer = TextVectorization(max_tokens=vocab_size, output_sequence_length=sequence_length)
+python_vectorizer = TextVectorization(max_tokens=vocab_size, output_sequence_length=sequence_length)
+
+# Dummy adaptation to initialize
+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"]))
+
+python_vocab = python_vectorizer.get_vocabulary()
+index_to_word = dict(enumerate(python_vocab))
+
+# --- Translator Functions ---
+
+def fallback_translate_with_gemini(code_snippet, source_lang, target_lang):
+    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 explanation. 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)}"
+
+def translate_with_local_model(code_snippet):
+    try:
+        java_seq = java_vectorizer(tf.constant([code_snippet]))
+        python_in = tf.constant([[1] + [0] * (sequence_length - 1)])
+        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()
+
+    except Exception as e:
+        return f"Local Model Error: {str(e)}"
+
+def translate_code(code_snippet, source_lang, target_lang):
+    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 logic:")
+
+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)
+
+# State initialization
+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
+        attempt = st.session_state.translate_attempts
+
+        with st.spinner(f"Translating..."):
+            # First click
+            if attempt == 1:
+                if 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)
+            else:
+                # Second and later attempts -> Gemini
+                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.")
+
+
+
+
+
+
+
+# Best version. It doesn't having trained model only.
+
+# import streamlit as st
+# import requests
+# 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")
+
+# # Set up Hugging Face API
+# MODEL_ID = "Salesforce/codet5p-770m"  # CodeT5+ (Recommended)
+# 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')
+
+# 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"
+
+#     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}"
+
+# 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 with Gemini AI")
+# 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)
+
+# # 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..."):
+#             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 LLM
+
+# 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")  # Fetch token securely
+# # Change MODEL_ID to a better model
+# # MODEL_ID = "Salesforce/codet5p-770m"  # CodeT5+ (Recommended)
+# MODEL_ID = "bigcode/starcoder2-15b"  # StarCoder2
+# # MODEL_ID = "meta-llama/CodeLlama-34b-Instruct"  # Code Llama
+
+# # API_URL = f"https://api-inference.huggingface.co/models/{MODEL_ID}"
+
+# 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.")

java_to_python_seq2seq_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a68cc27b5fdf226846c3a069451dcf9a35905ec6bec9a5a8c6ed8cc94df9a30a
+size 160844388

java_to_python_seq2seq_model.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d4e74324bdec3d287aa7d57fdfcd2dec443e995cecab4813148c24ef60ce3c8
+size 789260

requirements.txt

@@ -0,0 +1,12 @@
+torch
+torchvision
+torchaudio
+transformers
+tree_sitter
+fastapi
+uvicorn
+sentencepiece
+accelerate
+streamlit
+google.generativeai
+tensorflow

translator.py

@@ -0,0 +1,35 @@
+import requests
+import os
+
+# Your Hugging Face API token (Replace 'your_token_here' with your actual token)
+
+API_TOKEN = os.getenv("HF_API_TOKEN") 
+
+# Define model and API endpoint
+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 (No local download needed).
+    """
+    prompt = f"Translate the following {source_lang} code to {target_lang}:\n\n{code_snippet}\n\nTranslated {target_lang} Code:"
+
+    response = requests.post(API_URL, headers=HEADERS, json={"inputs": prompt})
+
+    if response.status_code == 200:
+        return response.json()[0]["generated_text"]
+    else:
+        return f"Error: {response.status_code}, {response.text}"
+
+# Example usage
+source_code = """
+def add(a, b):
+    return a + b
+"""
+translated_code = translate_code(source_code, "Python", "Java")
+print("Translated Java Code:\n", translated_code)
+
+
+