app.py

from flask import Flask, request, jsonify
from flask_caching import Cache
import time

import asyncio
from hypercorn.asyncio import serve
from hypercorn.config import Config
import os
os.environ['CURL_CA_BUNDLE'] = ''
#from googletranslate import translate
import json
import random
import re

import numpy as np
import emoji, json
from torchmoji.global_variables import PRETRAINED_PATH, VOCAB_PATH
from torchmoji.sentence_tokenizer import SentenceTokenizer
from torchmoji.model_def import torchmoji_emojis
import torch

# Emoji map in emoji_overview.png
EMOJIS = ":joy: :unamused: :weary: :sob: :heart_eyes: \
:pensive: :ok_hand: :blush: :heart: :smirk: \
:grin: :notes: :flushed: :100: :sleeping: \
:relieved: :relaxed: :raised_hands: :two_hearts: :expressionless: \
:sweat_smile: :pray: :confused: :kissing_heart: :heartbeat: \
:neutral_face: :information_desk_person: :disappointed: :see_no_evil: :tired_face: \
:v: :sunglasses: :rage: :thumbsup: :cry: \
:sleepy: :yum: :triumph: :hand: :mask: \
:clap: :eyes: :gun: :persevere: :smiling_imp: \
:sweat: :broken_heart: :yellow_heart: :musical_note: :speak_no_evil: \
:wink: :skull: :confounded: :smile: :stuck_out_tongue_winking_eye: \
:angry: :no_good: :muscle: :facepunch: :purple_heart: \
:sparkling_heart: :blue_heart: :grimacing: :sparkles:".split(' ')

def top_elements(array, k):
    ind = np.argpartition(array, -k)[-k:]
    return ind[np.argsort(array[ind])][::-1]


with open("vocabulary.json", 'r') as f:
    vocabulary = json.load(f)

st = SentenceTokenizer(vocabulary, 100)

emojimodel = torchmoji_emojis("pytorch_model.bin")

def deepmojify(sentence, top_n=5, prob_only=False):
    list_emojis = []
    def top_elements(array, k):
        ind = np.argpartition(array, -k)[-k:]
        return ind[np.argsort(array[ind])][::-1]

    tokenized, _, _ = st.tokenize_sentences([sentence])
    tokenized = np.array(tokenized).astype(int)  # convert to float first
    if USE_GPU:
        tokenized = torch.tensor(tokenized).cuda()  # then convert to PyTorch tensor

    prob = emojimodel.forward(tokenized)[0]
    if not USE_GPU:
        prob = torch.tensor(prob)
    if prob_only:
        return prob
    emoji_ids = top_elements(prob.cpu().numpy(), top_n)
    emojis = map(lambda x: EMOJIS[x], emoji_ids)
    list_emojis.append(emoji.emojize(f"{' '.join(emojis)}", language='alias'))
    # returning the emojis as a list named as list_emojis
    return list_emojis, prob

app = Flask(__name__)
cache = Cache(app, config={'CACHE_TYPE': 'simple', 'CACHE_DEFAULT_TIMEOUT': 60})

@app.route('/', methods=['GET'])
def home():
  return "HI! Use /translate POST"

# Load the JSON data into memory
def load_json_data(file_path):
    with open(file_path, 'r') as file:
        data = json.load(file)
    return data

# Assuming your JSON structure is a list of dictionaries
json_data = load_json_data('englishspanishpairs.json')

@app.route('/spanish')
def random_spanish_pair1():
    # Select a random English-Spanish pair
    random_pair = random.choice(json_data)
    return jsonify(random_pair)

def is_word(s):
    """
    Check if the string 's' is a word (contains only alphabetic characters).
    """
    return s.isalpha()

# Lists to store English and Spanish words separately
english_words = set()
spanish_words = set()

# Populate the word lists
for pair in json_data:
    if "english" in pair:
        # Extract words from the English sentence and filter out numbers
        english_words.update(filter(is_word, re.findall(r'\b\w+\b', pair.get("english", ""))))
    if "spanish" in pair:
        # Extract words from the Spanish sentence and filter out numbers
        spanish_words.update(filter(is_word, re.findall(r'\b\w+\b', pair.get("spanish", ""))))

def get_distractors(target_word, all_words, num_distractors=3):
    """
    Get distractor words from the same language.
    """
    distractors = set()
    while len(distractors) < num_distractors:
        distractor = random.choice(list(all_words))
        if distractor.lower() != target_word.lower():
            distractors.add(distractor)
    return list(distractors)

@app.route('/fillgame')
def random_spanish_pair2():
    # Select a random English-Spanish pair
    random_pair = random.choice(json_data)

    # Choose either English or Spanish for the fill-in-the-blank game
    if random.choice([True, False]):
        sentence = random_pair.get('english', "")
        language = 'english'
        word_set = english_words
    else:
        sentence = random_pair.get('spanish', "")
        language = 'spanish'
        word_set = spanish_words

    # Split the sentence into words and filter out non-words
    words = filter(is_word, re.findall(r'\b\w+\b', sentence))

    # Choose a random word to replace with blank
    blank_word = random.choice(list(words))
    sentence_with_blank = sentence.replace(blank_word, "_____")

    # Get distractors from the same language
    distractors = get_distractors(blank_word, word_set)

    # Combine correct word with distractors and shuffle
    options = [blank_word] + distractors
    random.shuffle(options)

    # Return the sentence with a blank, options, and the correct word
    return jsonify({
        'sentence': sentence_with_blank,
        'options': options,
        'correctWord': blank_word,
        'language': language
    })

    

"""
@app.route('/translate', methods=['POST'])
def dotranslate():
    data = request.get_json()

    txt = data.get('txt')
    src = data.get('src', 'en')
    dest = data.get('dest', 'es')

    if txt:
        cache_key = f"{txt}_{src}_{dest}"
        translation = cache.get(cache_key)
        if translation is None:
            translation = translate(txt, dest=dest, src=src)
            cache.set(cache_key, translation)
        return jsonify({'translation': translation}), 200
    else:
        return jsonify({'error': 'No text provided'}), 400
"""


from transformers import M2M100ForConditionalGeneration
from tokenization_small100 import SMALL100Tokenizer

model_name = "alirezamsh/small100"
model = M2M100ForConditionalGeneration.from_pretrained(model_name)
tokenizer = SMALL100Tokenizer.from_pretrained(model_name)

@app.route('/translate', methods=['POST'])
def dotranslate():
    data = request.get_json()
    txt = data.get('txt')
    src = data.get('src', 'en')
    dest = data.get('dest', 'es')

    if txt:
        cache_key = f"{txt}_{src}_{dest}"
        translation = cache.get(cache_key)
        if translation is None:
            # Set the source and target languages
            tokenizer.src_lang = src
            tokenizer.tgt_lang = dest

            # Tokenize the input text
            encoded = tokenizer(txt, return_tensors="pt")
            with torch.no_grad():
                # Generate translation
                generated_tokens = model.generate(
                    **encoded,
                    forced_bos_token_id=tokenizer.get_lang_id(dest)
                )

            # Decode the generated tokens
            translation = tokenizer.decode(generated_tokens[0], skip_special_tokens=True)

            # Cache the translation
            cache.set(cache_key, translation)
        return jsonify({'translation': translation}), 200
    else:
        return jsonify({'error': 'No text provided'}), 400

if __name__ == "__main__":
   config = Config()
   config.bind = ["0.0.0.0:7860"]  # You can specify the host and port here
   asyncio.run(serve(app, config))