harbour-deepfish/qml/pages/languagedownloader.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import pyotherside
import deepl
import sqlite3
import os
#import logging

<<<<<<< HEAD
ROUTE_FILE = ".local/share/org.jojo_/Deepfish/language.db"
=======
ROUTE_FILE = ".local/share/harbour-deepfish/Deepfish/language.db"
>>>>>>> a06af59400796a91060e6faac688b7ab372b6688

def setAPItoken(apiToken):
    con = sqlite3.connect(ROUTE_FILE)
    con.execute("CREATE TABLE IF NOT EXISTS apiTokenTable(apiToken TEXT)")
    con.execute('INSERT INTO apiTokenTable(apiToken) VALUES (?)', (apiToken,))
    con.commit()
    cur = con.execute("SELECT * FROM apiTokenTable ORDER BY rowid DESC LIMIT 1")
    setAPItokenValue = cur.fetchone()
    con.close()
    return setAPItokenValue

def currentAPItoken():
    con = sqlite3.connect(ROUTE_FILE)
    con.execute("CREATE TABLE IF NOT EXISTS apiTokenTable(apiToken TEXT)")
    cur = con.execute("SELECT * FROM apiTokenTable ORDER BY rowid DESC LIMIT 1")
    tokenName = cur.fetchone()
    con.close()
    return tokenName[0]

def getAPItoken():
    con = sqlite3.connect(ROUTE_FILE)
    con.execute("CREATE TABLE IF NOT EXISTS apiTokenTable(apiToken TEXT)")
    cur = con.execute('SELECT * FROM apiTokenTable ORDER BY rowid DESC');#count(*) as apiToken
    apiTokenCount = cur.fetchall()
    con.close()
    return apiTokenCount

def get_source_langs():
    source_lst = []
    TOKEN = currentAPItoken()
    translator = deepl.Translator(TOKEN)
    for language_source in translator.get_source_languages():
        x = language_source.code, language_source.name
        source_lst.append(x)
    return source_lst

def get_target_langs():
    target_lst = []
    TOKEN = currentAPItoken()
    translator = deepl.Translator(TOKEN)
    for language_target in translator.get_target_languages():
        y = language_target.code, language_target.name
        target_lst.append(y)
    return target_lst

def populateSourceLangDB():
    con = sqlite3.connect(ROUTE_FILE)
    cur = con.execute("CREATE TABLE IF NOT EXISTS LanguageSource(language_code TEXT, language_name TEXT, last_lang INTEGER, UNIQUE (language_code))")
    populateWithSourceLangs = get_source_langs()
    cur.executemany("INSERT or IGNORE INTO LanguageSource(language_code, language_name) VALUES (?, ?)", populateWithSourceLangs)
    con.commit()
    con.close()
    return "DB source populated"

def populateTargetLangDB():
    con = sqlite3.connect(ROUTE_FILE)
    cur = con.execute("CREATE TABLE IF NOT EXISTS LanguageTarget(language_code TEXT, language_name TEXT, last_lang INTEGER, UNIQUE (language_code))")
    populateWithTargetLangs = get_target_langs()
    cur.executemany("INSERT or IGNORE INTO LanguageTarget(language_code, language_name) VALUES (?, ?)", populateWithTargetLangs)
    con.commit()
    con.close()
    return "DB target populated"

def sourceLangFromDB():
    con = sqlite3.connect(ROUTE_FILE)
    cur = con.execute("SELECT * FROM LanguageSource ORDER BY last_lang DESC")
    returnSourceLangFromDB = cur.fetchall()
    con.close()
    return returnSourceLangFromDB

def targetLangFromDB():
    con = sqlite3.connect(ROUTE_FILE)
    cur = con.execute("SELECT * FROM LanguageTarget ORDER BY last_lang DESC")
    returnTargetLangFromDB = cur.fetchall()
    con.close()
    return returnTargetLangFromDB

def cleanLastLangDB():
    con = sqlite3.connect(ROUTE_FILE)
    cur = con.execute("UPDATE LanguageSource SET last_lang = 0")
    con.commit()
    con.close()

def setLastLangDB(modelDataValue):
    con = sqlite3.connect(ROUTE_FILE)
    cur = con.execute("UPDATE LanguageSource SET last_lang = 0")
    con.commit()
    cur = con.execute("UPDATE LanguageSource SET last_lang = 1 WHERE language_code = (?)", (modelDataValue,))
    # found solution so it doesnt say "there are two items instead of one required"
    con.commit()
    ###for debug
    cur1 = con.execute("SELECT * FROM LanguageSource ORDER BY last_lang DESC")
    returnSourceLangFromDB = cur1.fetchall()
    ###for debug
    con.close()
    return returnSourceLangFromDB

def getLastSourceLangDB():
    con = sqlite3.connect(ROUTE_FILE)
    cur = con.execute("SELECT * FROM LanguageSource ORDER BY last_lang DESC")
    getReturnSourceLangFromDB = cur.fetchall()
    con.close()
    return getReturnSourceLangFromDB

def setLastTargetLangDB(modelDataValueTarget):
    con = sqlite3.connect(ROUTE_FILE)
    cur = con.execute("UPDATE LanguageTarget SET last_lang = 0")
    con.commit()
    cur = con.execute("UPDATE LanguageTarget SET last_lang = 1 WHERE language_code = (?)", (modelDataValueTarget,))
    # found solution so it doesnt say "there are two items instead of one required"
    con.commit()
    ###for debug
    cur1 = con.execute("SELECT * FROM LanguageTarget ORDER BY last_lang DESC")
    returnTargetLangFromDB = cur1.fetchall()
    ###for debug
    con.close()
    return returnTargetLangFromDB

def getLastTargetLangDB():
    con = sqlite3.connect(ROUTE_FILE)
    cur = con.execute("SELECT * FROM LanguageTarget ORDER BY last_lang DESC")
    getReturnTargetLangFromDB = cur.fetchall()
    con.close()
    return getReturnTargetLangFromDB

def swapLanguages():
    lang_source_raw = getLastTargetLangDB()
    lang_target_raw = getLastSourceLangDB()
    lang_source = lang_source_raw[0][0]
    lang_target = lang_target_raw[0][0]
    if lang_source == "EN-US" or lang_source == "EN-GB":
        lang_source = "EN"
    elif lang_target == "EN":
        lang_target = "EN-GB"
    elif lang_source == "PT-BR" or lang_source == "PT-PT":
        lang_source = "PT"
    elif lang_target == "PT":
        lang_target = "PT-PT"
    setLastTargetLangDB(lang_target)
    setLastLangDB(lang_source)

def translate_text(translation):
    token = currentAPItoken()
    while True:
        translator = deepl.Translator(
            token
            )
        break
    lang_source_raw = getLastSourceLangDB()
    lang_source = lang_source_raw[0][0]
    lang_dest_raw = getLastTargetLangDB()
    lang_dest = lang_dest_raw[0][0]
    try:
        if lang_source == "Auto" or lang_source == "None" or lang_source == "NONE":
            result = translator.translate_text(
                 translation,
                 target_lang=lang_dest,
            )
            pyotherside.send(
                'finished',
                result.text,
                result.detected_source_lang
                )
            pyotherside.send('status', 1)
        else:
            result = translator.translate_text(
                 translation,
                 source_lang=lang_source,
                 target_lang=lang_dest,
            )
            pyotherside.send(
                'finished',
                result.text
                )
            pyotherside.send('status', 2)
    except deepl.exceptions.ConnectionException:
        result = ""
        pyotherside.send(
            'finished',
            result
            )
        pyotherside.send('status', 3)
    except Exception:
        pyotherside.send('finished')
        pyotherside.send('status', 4)

#logging.basicConfig()
#logging.getLogger('deepl').setLevel(logging.DEBUG)