Spaces:
Sleeping
Sleeping
| 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}"} | |
| # Gemini setup | |
| 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) | |
| # 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): | |
| 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): | |
| """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() | |
| 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) | |
| 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..."): | |
| 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()) | |
| else: | |
| st.warning("⚠️ Please enter some code before translating.") | |
| # version1: Without Trained model. | |
| # 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("🔄 Programming Language Translator") | |
| # 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 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.") | |