#! /usr/bin/env python
# v. 2.7
# Interactive subtitles for `mpv` for language learners.
import os, subprocess, sys
import random, re, time
import requests
import threading, queue
import calendar, math, base64
import numpy
import ast
from bs4 import BeautifulSoup
from urllib.parse import quote
from json import loads
import warnings
from six.moves import urllib
from PyQt5.QtCore import Qt, QThread, QObject, pyqtSignal, pyqtSlot, QSize
from PyQt5.QtWidgets import QApplication, QFrame, QVBoxLayout, QHBoxLayout, QLabel, QSizePolicy, QWidget
from PyQt5.QtGui import QPalette, QPaintEvent, QPainter, QPainterPath, QFont, QFontMetrics, QColor, QPen, QBrush
pth = os.path.expanduser('~/.config/mpv/scripts/')
os.chdir(pth)
import interSubs_config as config
pons_combos = ['enes', 'enfr', 'deen', 'enpl', 'ensl', 'defr', 'dees', 'deru', 'depl', 'desl', 'deit', 'dept', 'detr', 'deel', 'dela', 'espl', 'frpl', 'itpl', 'plru', 'essl', 'frsl', 'itsl', 'enit', 'enpt', 'enru', 'espt', 'esfr', 'delb', 'dezh', 'enzh', 'eszh', 'frzh', 'denl', 'arde', 'aren', 'dade', 'csde', 'dehu', 'deno', 'desv', 'dede', 'dedx']
# returns ([[word, translation]..], [morphology = '', gender = ''])
# pons.com
def pons(word):
if config.lang_from + config.lang_to in pons_combos:
url = 'http://en.pons.com/translate?q=%s&l=%s%s&in=%s' % (quote(word), config.lang_from, config.lang_to, config.lang_from)
else:
url = 'http://en.pons.com/translate?q=%s&l=%s%s&in=%s' % (quote(word), config.lang_to, config.lang_from, config.lang_from)
pairs = []
fname = 'urls/' + url.replace('/', "-")
try:
p = open(fname).read().split('=====/////-----')
try:
word_descr = p[1].strip()
except:
word_descr = ''
if len(p[0].strip()):
for pi in p[0].strip().split('\n\n'):
pi = pi.split('\n')
pairs.append([pi[0], pi[1]])
except:
p = requests.get(url, headers={'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.167 Safari/537.36'}).text
soup = BeautifulSoup(p, "lxml")
trs = soup.find_all('dl')
for tr in trs:
try:
tr1 = tr.find('dt').find('div', class_="source").get_text()
tr1 = re.sub('\n|\r|\t', ' ', tr1)
tr1 = re.sub(' +', ' ', tr1).strip()
if not len(tr1):
tr1 = '-'
tr2 = tr.find('dd').find('div', class_="target").get_text()
tr2 = re.sub('\n|\r|\t', ' ', tr2)
tr2 = re.sub(' +', ' ', tr2).strip()
if not len(tr2):
tr2 = '-'
except:
continue
pairs.append([tr1, tr2])
if config.number_of_translations_to_save and len(pairs) > config.number_of_translations_to_save:
break
try:
word_descr = soup.find_all('h2', class_='')
if '<i class="icon-bolt">' not in str(word_descr[0]):
word_descr = re.sub('\n|\r|\t', ' ', word_descr[0].get_text())
word_descr = re.sub(' +', ' ', word_descr).replace('<', '<').replace('>', '>').replace(' · ', '·').replace(' , ', ', ').strip()
else:
word_descr = ''
except:
word_descr = ''
# extra check against double-writing from rouge threads
if not os.path.isfile(fname):
print('\n\n'.join(e[0] + '\n' + e[1] for e in pairs), file=open(fname, 'a'))
print('\n'+'=====/////-----'+'\n', file=open(fname, 'a'))
print(word_descr, file=open(fname, 'a'))
if len(word_descr):
if word_descr.split(' ')[-1] == 'm':
word_descr_gen = [word_descr[:-2], 'm']
elif word_descr.split(' ')[-1] == 'f':
word_descr_gen = [word_descr[:-2], 'f']
elif word_descr.split(' ')[-1] == 'nt':
word_descr_gen = [word_descr[:-3], 'nt']
else:
word_descr_gen = [word_descr, '']
else:
word_descr_gen = ['', '']
return pairs, word_descr_gen
# https://github.com/ssut/py-googletrans
class TokenAcquirer(object):
"""Google Translate API token generator
translate.google.com uses a token to authorize the requests. If you are
not Google, you do have this token and will have to pay for use.
This class is the result of reverse engineering on the obfuscated and
minified code used by Google to generate such token.
The token is based on a seed which is updated once per hour and on the
text that will be translated.
Both are combined - by some strange math - in order to generate a final
token (e.g. 744915.856682) which is used by the API to validate the
request.
This operation will cause an additional request to get an initial
token from translate.google.com.
Example usage:
>>> from googletrans.gtoken import TokenAcquirer
>>> acquirer = TokenAcquirer()
>>> text = 'test'
>>> tk = acquirer.do(text)
>>> tk
950629.577246
"""
RE_TKK = re.compile(r'tkk:\'(.+?)\'', re.DOTALL)
RE_RAWTKK = re.compile(r'tkk:\'(.+?)\'', re.DOTALL)
def __init__(self, tkk='0', session=None, host='translate.google.com'):
self.session = session or requests.Session()
self.tkk = tkk
self.host = host if 'http' in host else 'https://' + host
def rshift(self, val, n):
"""python port for '>>>'(right shift with padding)
"""
return (val % 0x100000000) >> n
def _update(self):
"""update tkk
"""
# we don't need to update the base TKK value when it is still valid
now = math.floor(int(time.time() * 1000) / 3600000.0)
if self.tkk and int(self.tkk.split('.')[0]) == now:
return
r = self.session.get(self.host)
raw_tkk = self.RE_TKK.search(r.text)
if raw_tkk:
self.tkk = raw_tkk.group(1)
return
# this will be the same as python code after stripping out a reserved word 'var'
code = unicode(self.RE_TKK.search(r.text).group(1)).replace('var ', '')
# unescape special ascii characters such like a \x3d(=)
if PY3: # pragma: no cover
code = code.encode().decode('unicode-escape')
else: # pragma: no cover
code = code.decode('string_escape')
if code:
tree = ast.parse(code)
visit_return = False
operator = '+'
n, keys = 0, dict(a=0, b=0)
for node in ast.walk(tree):
if isinstance(node, ast.Assign):
name = node.targets[0].id
if name in keys:
if isinstance(node.value, ast.Num):
keys[name] = node.value.n
# the value can sometimes be negative
elif isinstance(node.value, ast.UnaryOp) and \
isinstance(node.value.op, ast.USub): # pragma: nocover
keys[name] = -node.value.operand.n
elif isinstance(node, ast.Return):
# parameters should be set after this point
visit_return = True
elif visit_return and isinstance(node, ast.Num):
n = node.n
elif visit_return and n > 0:
# the default operator is '+' but implement some more for
# all possible scenarios
if isinstance(node, ast.Add): # pragma: nocover
pass
elif isinstance(node, ast.Sub): # pragma: nocover
operator = '-'
elif isinstance(node, ast.Mult): # pragma: nocover
operator = '*'
elif isinstance(node, ast.Pow): # pragma: nocover
operator = '**'
elif isinstance(node, ast.BitXor): # pragma: nocover
operator = '^'
# a safety way to avoid Exceptions
clause = compile('{1}{0}{2}'.format(
operator, keys['a'], keys['b']), '', 'eval')
value = eval(clause, dict(__builtin__={}))
result = '{}.{}'.format(n, value)
self.tkk = result
def _lazy(self, value):
"""like lazy evalution, this method returns a lambda function that
returns value given.
We won't be needing this because this seems to have been built for
code obfuscation.
the original code of this method is as follows:
... code-block: javascript
var ek = function(a) {
return function() {
return a;
};
}
"""
return lambda: value
def _xr(self, a, b):
size_b = len(b)
c = 0
while c < size_b - 2:
d = b[c + 2]
d = ord(d[0]) - 87 if 'a' <= d else int(d)
d = self.rshift(a, d) if '+' == b[c + 1] else a << d
a = a + d & 4294967295 if '+' == b[c] else a ^ d
c += 3
return a
def acquire(self, text):
a = []
# Convert text to ints
for i in text:
val = ord(i)
if val < 0x10000:
a += [val]
else:
# Python doesn't natively use Unicode surrogates, so account for those
a += [
math.floor((val - 0x10000)/0x400 + 0xD800),
math.floor((val - 0x10000)%0x400 + 0xDC00)
]
b = self.tkk if self.tkk != '0' else ''
d = b.split('.')
b = int(d[0]) if len(d) > 1 else 0
# assume e means char code array
e = []
g = 0
size = len(text)
while g < size:
l = a[g]
# just append if l is less than 128(ascii: DEL)
if l < 128:
e.append(l)
# append calculated value if l is less than 2048
else:
if l < 2048:
e.append(l >> 6 | 192)
else:
# append calculated value if l matches special condition
if (l & 64512) == 55296 and g + 1 < size and \
a[g + 1] & 64512 == 56320:
g += 1
l = 65536 + ((l & 1023) << 10) + (a[g] & 1023) # This bracket is important
e.append(l >> 18 | 240)
e.append(l >> 12 & 63 | 128)
else:
e.append(l >> 12 | 224)
e.append(l >> 6 & 63 | 128)
e.append(l & 63 | 128)
g += 1
a = b
for i, value in enumerate(e):
a += value
a = self._xr(a, '+-a^+6')
a = self._xr(a, '+-3^+b+-f')
a ^= int(d[1]) if len(d) > 1 else 0
if a < 0: # pragma: nocover
a = (a & 2147483647) + 2147483648
a %= 1000000 # int(1E6)
return '{}.{}'.format(a, a ^ b)
def do(self, text):
self._update()
tk = self.acquire(text)
return tk
# translate.google.com
def google(word):
url = 'https://translate.google.com/translate_a/single?client=t&sl={lang_from}&tl={lang_to}&hl={lang_to}&dt=at&dt=bd&dt=ex&dt=ld&dt=md&dt=qca&dt=rw&dt=rm&dt=ss&dt=t&ie=UTF-8&oe=UTF-8&otf=1&pc=1&ssel=3&tsel=3&kc=2&q={word}'.format(lang_from = config.lang_from, lang_to = config.lang_to, word = quote(word))
pairs = []
fname = 'urls/' + url.replace('/', "-")
try:
p = open(fname).read().split('=====/////-----')
try:
word_descr = p[1].strip()
except:
word_descr = ''
for pi in p[0].strip().split('\n\n'):
pi = pi.split('\n')
pairs.append([pi[0], pi[1]])
except:
acquirer = TokenAcquirer()
tk = acquirer.do(word)
url = '{url}&tk={tk}'.format(url = url, tk = tk)
p = requests.get(url, headers={'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.167 Safari/537.36'}).text
p = loads(p)
try:
pairs.append([p[0][0][0], p[0][0][1]])
except:
pass
if p[1] != None:
for translations in p[1]:
for translation in translations[2]:
try:
t1 = translation[5] + ' ' + translation[0]
except:
t1 = translation[0]
t2 = ', '.join(translation[1])
if not len(t1):
t1 = '-'
if not len(t2):
t2 = '-'
pairs.append([t1, t2])
word_descr = ''
# extra check against double-writing from rouge threads
if not os.path.isfile(fname):
print('\n\n'.join(e[0] + '\n' + e[1] for e in pairs), file=open(fname, 'a'))
print('\n'+'=====/////-----'+'\n', file=open(fname, 'a'))
print(word_descr, file=open(fname, 'a'))
return pairs, ['', '']
# reverso.net
def reverso(word):
reverso_combos = {'ar':'Arabic', 'de':'German', 'en':'English', 'es':'Spanish', 'fr':'French', 'he':'Hebrew', 'it':'Italian', 'nl':'Dutch', 'pl':'Polish', 'pt':'Portuguese', 'ro':'Romanian', 'ru':'Russian'}
if not config.lang_from in reverso_combos and not config.lang_to in reverso_combos:
return [['Language code is not correct.', '']], ['', '']
url = 'http://context.reverso.net/translation/%s-%s/%s' % (reverso_combos[config.lang_from].lower(), reverso_combos[config.lang_to].lower(), quote(word))
pairs = []
fname = 'urls/' + url.replace('/', "-")
try:
p = open(fname).read().split('=====/////-----')
if len(p[0].strip()):
for pi in p[0].strip().split('\n\n'):
pi = pi.split('\n')
pairs.append([pi[0], pi[1]])
except:
p = requests.get(url, headers={'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.167 Safari/537.36'}).text
soup = BeautifulSoup(p, "lxml")
trs = soup.find_all(class_ = re.compile('translation.*ltr.*'))
exmpls = soup.find_all(class_ = 'example')
tr_combined = []
for tr in trs:
tr_combined.append(tr.get_text().strip().replace('\n', ' '))
if len(tr_combined) == 4:
pairs.append(['-', ' :: '.join(tr_combined)])
tr_combined = []
for exmpl in exmpls:
pairs.append([x.strip() for x in exmpl.get_text().split('\n') if len(x.strip())])
# extra check against double-writing from rouge threads
if not os.path.isfile(fname):
print('\n\n'.join(e[0] + '\n' + e[1] for e in pairs), file=open(fname, 'a'))
print('\n'+'=====/////-----'+'\n', file=open(fname, 'a'))
return pairs, ['', '']
# linguee.com (unfinished; site blocks frequent requests)
def linguee(word):
url = 'https://www.linguee.com/german-english/search?source=german&query=%s' % quote(word)
pairs = []
fname = 'urls/' + url.replace('/', "-")
try:
p = open(fname).read().split('=====/////-----')
try:
word_descr = p[1].strip()
except:
word_descr = ''
for pi in p[0].strip().split('\n\n'):
pi = pi.split('\n')
pairs.append([pi[0], pi[1]])
except:
#p = open('/home/lom/d/1.html', encoding="ISO-8859-15").read()
p = requests.get(url, headers={'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.167 Safari/537.36'}).text
soup = BeautifulSoup(p, "lxml")
trs = soup.find_all('div', class_="lemma featured")
for tr in trs:
pairs.append([tr.find_all('a')[0].get_text(), '-'])
for tr2 in tr.find_all('a')[1:]:
if len(tr2.get_text()):
#print(tr2.get_text())
pairs.append(['-', tr2.get_text()])
word_descr = ''
# extra check against double-writing from rouge threads
if not os.path.isfile(fname):
print('\n\n'.join(e[0] + '\n' + e[1] for e in pairs), file=open(fname, 'a'))
print('\n'+'=====/////-----'+'\n', file=open(fname, 'a'))
print(word_descr, file=open(fname, 'a'))
return pairs, ['', '']
# dict.cc
def dict_cc(word):
url = 'https://%s-%s.dict.cc/?s=%s' % (config.lang_from, config.lang_to, quote(word))
pairs = []
fname = 'urls/' + url.replace('/', "-")
try:
p = open(fname).read().split('=====/////-----')
try:
word_descr = p[1].strip()
except:
word_descr = ''
if len(p[0].strip()):
for pi in p[0].strip().split('\n\n'):
pi = pi.split('\n')
pairs.append([pi[0], pi[1]])
except:
p = requests.get(url, headers={'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.167 Safari/537.36'}).text
p = re.sub('<div style="float:right;color:#999">\d*</div>', '', p)
p = re.sub('<span style="color:#666;font-size:10px;padding:0 2px;position:relative;top:-3px">\d*</span>', '', p)
soup = BeautifulSoup(p, "lxml")
trs = soup.find_all('tr', id = re.compile('tr\d*'))
for tr in trs:
tr2 = tr.find_all('td', class_ = 'td7nl')
pairs.append([tr2[1].get_text(), tr2[0].get_text()])
if config.number_of_translations_to_save and len(pairs) > config.number_of_translations_to_save:
break
word_descr = ''
# extra check against double-writing from rouge threads
if not os.path.isfile(fname):
print('\n\n'.join(e[0] + '\n' + e[1] for e in pairs), file=open(fname, 'a'))
print('\n'+'=====/////-----'+'\n', file=open(fname, 'a'))
print(word_descr, file=open(fname, 'a'))
return pairs, ['', '']
# redensarten-index.de
def redensarten(word):
if len(word) < 3:
return [], ['', '']
url = 'https://www.redensarten-index.de/suche.php?suchbegriff=' + quote(word) + '&bool=relevanz&gawoe=an&suchspalte%5B%5D=rart_ou&suchspalte%5B%5D=rart_varianten_ou&suchspalte%5B%5D=erl_ou&suchspalte%5B%5D=erg_ou'
pairs = []
fname = 'urls/' + url.replace('/', "-")
try:
p = open(fname).read().split('=====/////-----')
try:
word_descr = p[1].strip()
except:
word_descr = ''
if len(p[0].strip()):
for pi in p[0].strip().split('\n\n'):
pi = pi.split('\n')
pairs.append([pi[0], pi[1]])
except:
p = requests.get(url, headers={'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.167 Safari/537.36'})
p.encoding = 'utf-8'
p = p.text
soup = BeautifulSoup(p, "lxml")
for a in soup.find_all('a', class_ = 'autosyn-icon'):
a.decompose()
try:
table = soup.find_all('table', id = 'tabelle')[0]
trs = table.find_all('tr')
for tr in trs[1:]:
tds = tr.find_all('td')
if len(tds) > 1:
pairs.append([ re.sub(' +', ' ', tds[0].get_text()).strip(), re.sub(' +', ' ', tds[1].get_text()).strip() ])
except:
pass
word_descr = ''
# extra check against double-writing from rouge threads
if not os.path.isfile(fname):
print('\n\n'.join(e[0] + '\n' + e[1] for e in pairs), file=open(fname, 'a'))
print('\n'+'=====/////-----'+'\n', file=open(fname, 'a'))
print(word_descr, file=open(fname, 'a'))
return pairs, ['', '']
# leo.org
def leo(word):
language = config.lang_from if config.lang_from != 'de' else config.lang_to
url = "https://dict.leo.org/dictQuery/m-vocab/%sde/query.xml?tolerMode=nof&rmWords=off&rmSearch=on&searchLoc=0&resultOrder=basic&multiwordShowSingle=on&lang=de&search=%s" % (language, word)
pairs = []
fname = 'urls/' + url.replace('/', "-")
try:
p = open(fname).read().split('=====/////-----')
try:
word_descr = p[1].strip()
except:
word_descr = ''
if len(p[0].strip()):
for pi in p[0].strip().split('\n\n'):
pi = pi.split('\n')
pairs.append([pi[0], pi[1]])
except:
req = requests.get(url.format(lang=language))
content = BeautifulSoup(req.text, "xml")
pairs = []
for section in content.sectionlist.findAll('section'):
if int(section['sctCount']):
for entry in section.findAll('entry'):
res0 = entry.find('side', attrs = {'hc' : '0'})
res1 = entry.find('side', attrs = {'hc' : '1'})
if res0 and res1:
line0 = re.sub('\s+', ' ', res0.repr.getText())
line1 = re.sub('\s+', ' ', res1.repr.getText())
line0 = line0.rstrip('|').strip()
line1 = line1.rstrip('|').strip()
if res0.attrs['lang'] == config.lang_from:
pairs.append([line0, line1])
else:
pairs.append([line1, line0])
word_descr = ''
# extra check against double-writing from rouge threads
if not os.path.isfile(fname):
print('\n\n'.join(e[0] + '\n' + e[1] for e in pairs), file=open(fname, 'a'))
print('\n'+'=====/////-----'+'\n', file=open(fname, 'a'))
print(word_descr, file=open(fname, 'a'))
return pairs, ['', '']
# offline dictionary with word \t translation
def tab_divided_dict(word):
if word in offdict:
tr = re.sub('<.*?>', '', offdict[word]) if config.tab_divided_dict_remove_tags_B else offdict[word]
tr = tr.replace('\\n', '\n').replace('\\~', '~')
return [[tr, '-']], ['', '']
else:
return [], ['', '']
# morfix.co.il
def morfix(word):
url = "http://www.morfix.co.il/en/%s" % quote(word)
pairs = []
fname = 'urls/' + url.replace('/', "-")
try:
p = open(fname).read().split('=====/////-----')
try:
word_descr = p[1].strip()
except:
word_descr = ''
if len(p[0].strip()):
for pi in p[0].strip().split('\n\n'):
pi = pi.split('\n')
pairs.append([pi[0], pi[1]])
except:
req = requests.get(url)
soup = BeautifulSoup(req.text, "lxml")
divs = soup.find_all('div', class_ = 'title_ph')
pairs = []
for div in divs:
he = div.find('div', class_ = re.compile('translation_he'))
he = re.sub('\s+', ' ', he.get_text()).strip()
en = div.find('div', class_ = re.compile('translation_en'))
en = re.sub('\s+', ' ', en.get_text()).strip()
if config.lang_from == 'he':
pairs.append([he, en])
else:
pairs.append([en, he])
word_descr = ''
# extra check against double-writing from rouge threads
if not os.path.isfile(fname):
print('\n\n'.join(e[0] + '\n' + e[1] for e in pairs), file=open(fname, 'a'))
print('\n'+'=====/////-----'+'\n', file=open(fname, 'a'))
print(word_descr, file=open(fname, 'a'))
return pairs, ['', '']
# deepl.com
# https://github.com/EmilioK97/pydeepl
def deepl(text):
l1 = config.lang_from.upper()
l2 = config.lang_to.upper()
if len(text) > 5000:
return 'Text too long (limited to 5000 characters).'
parameters = {
'jsonrpc': '2.0',
'method': 'LMT_handle_jobs',
'params': {
'jobs': [
{
'kind':'default',
'raw_en_sentence': text
}
],
'lang': {
'source_lang_user_selected': l1,
'target_lang': l2
}
}
}
response = requests.post('https://www2.deepl.com/jsonrpc', json=parameters).json()
print(response)
if 'result' not in response:
return 'DeepL call resulted in a unknown result.'
translations = response['result']['translations']
if len(translations) == 0 \
or translations[0]['beams'] is None \
or translations[0]['beams'][0]['postprocessed_sentence'] is None:
return 'No translations found.'
return translations[0]['beams'][0]['postprocessed_sentence']
def listen(word, type = 'gtts'):
if type == 'pons':
if config.lang_from + config.lang_to in pons_combos:
url = 'http://en.pons.com/translate?q=%s&l=%s%s&in=%s' % (quote(word), config.lang_from, config.lang_to, config.lang_from)
else:
url = 'http://en.pons.com/translate?q=%s&l=%s%s&in=%s' % (quote(word), config.lang_to, config.lang_from, config.lang_from)
p = requests.get(url, headers={'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.167 Safari/537.36'}).text
x = re.findall('<dl id="([a-zA-Z0-9]*?)" class="dl-horizontal kne(.*?)</dl>', p, re.DOTALL)
x2 = re.findall('class="audio tts trackable trk-audio" data-pons-lang="(.*?)"', x[0][1])
for l in x2:
if config.lang_from in l:
mp3 = 'http://sounds.pons.com/audio_tts/%s/%s' % (l, x[0][0])
break
os.system('(cd /tmp; wget ' + mp3 + '; mpv --load-scripts=no --loop=1 --volume=40 --force-window=no ' + mp3.split('/')[-1] + '; rm ' + mp3.split('/')[-1] + ') &')
elif type == 'gtts':
gTTS(text = word, lang = config.lang_from, slow = False).save('/tmp/gtts_word.mp3')
os.system('(mpv --load-scripts=no --loop=1 --volume=75 --force-window=no ' + '/tmp/gtts_word.mp3' + '; rm ' + '/tmp/gtts_word.mp3' + ') &')
elif type == 'forvo':
url = 'https://forvo.com/word/%s/%s/' % (config.lang_from, quote(word))
try:
data = requests.get(url, headers={'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.167 Safari/537.36'}).text
soup = BeautifulSoup(data, "lxml")
trs = soup.find_all('article', class_ = 'pronunciations')[0].find_all('span', class_ = 'play')
mp3s = ''
for tr in trs[:2]:
tr = tr['onclick']
tr = re.findall('Play\((.*?)\)', tr)[0]
tr = tr.split(',')[4].replace("'", '')
tr = base64.b64decode(tr)
tr = tr.decode("utf-8")
mp3s += 'mpv --load-scripts=no --loop=1 --volume=111 --force-window=no https://audio00.forvo.com/audios/mp3/%s ; ' % tr
os.system('(%s) &' % mp3s)
except:
return
# https://github.com/Boudewijn26/gTTS-token
class Token:
""" Token (Google Translate Token)
Generate the current token key and allows generation of tokens (tk) with it
Python version of `token-script.js` itself from translate.google.com
"""
SALT_1 = "+-a^+6"
SALT_2 = "+-3^+b+-f"
def __init__(self):
self.token_key = None
def calculate_token(self, text, seed=None):
""" Calculate the request token (`tk`) of a string
:param text: str The text to calculate a token for
:param seed: str The seed to use. By default this is the number of hours since epoch
"""
if seed is None:
seed = self._get_token_key()
[first_seed, second_seed] = seed.split(".")
try:
d = bytearray(text.encode('UTF-8'))
except UnicodeDecodeError:
# This will probably only occur when d is actually a str containing UTF-8 chars, which means we don't need
# to encode.
d = bytearray(text)
a = int(first_seed)
for value in d:
a += value
a = self._work_token(a, self.SALT_1)
a = self._work_token(a, self.SALT_2)
a ^= int(second_seed)
if 0 > a:
a = (a & 2147483647) + 2147483648
a %= 1E6
a = int(a)
return str(a) + "." + str(a ^ int(first_seed))
def _get_token_key(self):
if self.token_key is not None:
return self.token_key
response = requests.get("https://translate.google.com/")
tkk_expr = re.search("(tkk:.*?),", response.text)
if not tkk_expr:
raise ValueError(
"Unable to find token seed! Did https://translate.google.com change?"
)
tkk_expr = tkk_expr.group(1)
try:
# Grab the token directly if already generated by function call
result = re.search("\d{6}\.[0-9]+", tkk_expr).group(0)
except AttributeError:
# Generate the token using algorithm
timestamp = calendar.timegm(time.gmtime())
hours = int(math.floor(timestamp / 3600))
a = re.search("a\\\\x3d(-?\d+);", tkk_expr).group(1)
b = re.search("b\\\\x3d(-?\d+);", tkk_expr).group(1)
result = str(hours) + "." + str(int(a) + int(b))
self.token_key = result
return result
""" Functions used by the token calculation algorithm """
def _rshift(self, val, n):
return val >> n if val >= 0 else (val + 0x100000000) >> n
def _work_token(self, a, seed):
for i in range(0, len(seed) - 2, 3):
char = seed[i + 2]
d = ord(char[0]) - 87 if char >= "a" else int(char)
d = self._rshift(a, d) if seed[i + 1] == "+" else a << d
a = a + d & 4294967295 if seed[i] == "+" else a ^ d
return a
# https://github.com/pndurette/gTTS
class gTTS:
""" gTTS (Google Text to Speech): an interface to Google's Text to Speech API """
# Google TTS API supports two read speeds
# (speed <= 0.3: slow; speed > 0.3: normal; default: 1)
class Speed:
SLOW = 0.3
NORMAL = 1
GOOGLE_TTS_URL = 'https://translate.google.com/translate_tts'
MAX_CHARS = 100 # Max characters the Google TTS API takes at a time
LANGUAGES = {
'af' : 'Afrikaans',
'sq' : 'Albanian',
'ar' : 'Arabic',
'hy' : 'Armenian',
'bn' : 'Bengali',
'ca' : 'Catalan',
'zh' : 'Chinese',
'zh-cn' : 'Chinese (Mandarin/China)',
'zh-tw' : 'Chinese (Mandarin/Taiwan)',
'zh-yue' : 'Chinese (Cantonese)',
'hr' : 'Croatian',
'cs' : 'Czech',
'da' : 'Danish',
'nl' : 'Dutch',
'en' : 'English',
'en-au' : 'English (Australia)',
'en-uk' : 'English (United Kingdom)',
'en-us' : 'English (United States)',
'eo' : 'Esperanto',
'fi' : 'Finnish',
'fr' : 'French',
'de' : 'German',
'el' : 'Greek',
'hi' : 'Hindi',
'hu' : 'Hungarian',
'is' : 'Icelandic',
'id' : 'Indonesian',
'it' : 'Italian',
'iw' : 'Hebrew',
'ja' : 'Japanese',
'km' : 'Khmer (Cambodian)',
'ko' : 'Korean',
'la' : 'Latin',
'lv' : 'Latvian',
'mk' : 'Macedonian',
'no' : 'Norwegian',
'pl' : 'Polish',
'pt' : 'Portuguese',
'ro' : 'Romanian',
'ru' : 'Russian',
'sr' : 'Serbian',
'si' : 'Sinhala',
'sk' : 'Slovak',
'es' : 'Spanish',
'es-es' : 'Spanish (Spain)',
'es-us' : 'Spanish (United States)',
'sw' : 'Swahili',
'sv' : 'Swedish',
'ta' : 'Tamil',
'th' : 'Thai',
'tr' : 'Turkish',
'uk' : 'Ukrainian',
'vi' : 'Vietnamese',
'cy' : 'Welsh'
}
def __init__(self, text, lang = 'en', slow = False, debug = False):
self.debug = debug
if lang.lower() not in self.LANGUAGES:
raise Exception('Language not supported: %s' % lang)
else:
self.lang = lang.lower()
if not text:
raise Exception('No text to speak')
else:
self.text = text
# Read speed
if slow:
self.speed = self.Speed().SLOW
else:
self.speed = self.Speed().NORMAL
# Split text in parts
if self._len(text) <= self.MAX_CHARS:
text_parts = [text]
else:
text_parts = self._tokenize(text, self.MAX_CHARS)
# Clean
def strip(x): return x.replace('\n', '').strip()
text_parts = [strip(x) for x in text_parts]
text_parts = [x for x in text_parts if len(x) > 0]
self.text_parts = text_parts
# Google Translate token
self.token = Token()
def save(self, savefile):
""" Do the Web request and save to `savefile` """
with open(savefile, 'wb') as f:
self.write_to_fp(f)
def write_to_fp(self, fp):
""" Do the Web request and save to a file-like object """
for idx, part in enumerate(self.text_parts):
payload = { 'ie' : 'UTF-8',
'q' : part,
'tl' : self.lang,
'ttsspeed' : self.speed,
'total' : len(self.text_parts),
'idx' : idx,
'client' : 'tw-ob',
'textlen' : self._len(part),
'tk' : self.token.calculate_token(part)}
headers = {
"Referer" : "http://translate.google.com/",
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.167 Safari/537.36"
}
if self.debug: print(payload)
try:
# Disable requests' ssl verify to accomodate certain proxies and firewalls
# Filter out urllib3's insecure warnings. We can live without ssl verify here
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=requests.packages.urllib3.exceptions.InsecureRequestWarning)
r = requests.get(self.GOOGLE_TTS_URL,
params=payload,
headers=headers,
proxies=urllib.request.getproxies(),
verify=False)
if self.debug:
print("Headers: {}".format(r.request.headers))
print("Request url: {}".format(r.request.url))
print("Response: {}, Redirects: {}".format(r.status_code, r.history))
r.raise_for_status()
for chunk in r.iter_content(chunk_size=1024):
fp.write(chunk)
except Exception as e:
raise
def _len(self, text):
""" Get char len of `text`, after decoding if Python 2 """
try:
# Python 2
return len(text.decode('utf8'))
except AttributeError:
# Python 3
return len(text)
def _tokenize(self, text, max_size):
""" Tokenizer on basic roman punctuation """
punc = "¡!()[]¿?.,;:—«»\n"
punc_list = [re.escape(c) for c in punc]
pattern = '|'.join(punc_list)
parts = re.split(pattern, text)
min_parts = []
for p in parts:
min_parts += self._minimize(p, " ", max_size)
return min_parts
def _minimize(self, thestring, delim, max_size):
""" Recursive function that splits `thestring` in chunks
of maximum `max_size` chars delimited by `delim`. Returns list. """
if self._len(thestring) > max_size:
idx = thestring.rfind(delim, 0, max_size)
return [thestring[:idx]] + self._minimize(thestring[idx:], delim, max_size)
else:
return [thestring]
def mpv_pause():
os.system('echo \'{ "command": ["set_property", "pause", true] }\' | socat - "' + mpv_socket + '" > /dev/null')
def mpv_resume():
os.system('echo \'{ "command": ["set_property", "pause", false] }\' | socat - "' + mpv_socket + '" > /dev/null')
def mpv_pause_status():
stdoutdata = subprocess.getoutput('echo \'{ "command": ["get_property", "pause"] }\' | socat - "' + mpv_socket + '"')
try:
return loads(stdoutdata)['data']
except:
return mpv_pause_status()
def mpv_fullscreen_status():
stdoutdata = subprocess.getoutput('echo \'{ "command": ["get_property", "fullscreen"] }\' | socat - "' + mpv_socket + '"')
try:
return loads(stdoutdata)['data']
except:
return mpv_fullscreen_status()
def mpv_message(message, timeout = 3000):
os.system('echo \'{ "command": ["show-text", "' + message + '", "' + str(timeout) + '"] }\' | socat - "' + mpv_socket + '" > /dev/null')
def stripsd2(phrase):
return ''.join(e for e in phrase.strip().lower() if e == ' ' or (e.isalnum() and not e.isdigit())).strip()
def r2l(l):
l2 = ''
try:
l2 = re.findall('(?!%)\W+$', l)[0][::-1]
except:
pass
l2 += re.sub('^\W+|(?!%)\W+$', '', l)
try:
l2 += re.findall('^\W+', l)[0][::-1]
except:
pass
return l2
def split_long_lines(line, chunks = 2, max_symbols_per_line = False):
if max_symbols_per_line:
chunks = 0
while 1:
chunks += 1
new_lines = []
for i in range(chunks):
new_line = ' '.join(numpy.array_split(line.split(' '), chunks)[i])
new_lines.append(new_line)
if len(max(new_lines, key = len)) <= max_symbols_per_line:
return '\n'.join(new_lines)
else:
new_lines = []
for i in range(chunks):
new_line = ' '.join(numpy.array_split(line.split(' '), chunks)[i])
new_lines.append(new_line)
return '\n'.join(new_lines)
def dir2(name):
print('\n'.join(dir( name )))
exit()
class thread_subtitles(QObject):
update_subtitles = pyqtSignal(bool, bool)
@pyqtSlot()
def main(self):
global subs
was_hidden = 0
inc = 0
auto_pause_2_ind = 0
last_updated = time.time()
while 1:
time.sleep(config.update_time)
# hide subs when mpv isn't in focus or in fullscreen
if inc * config.update_time > config.focus_checking_time - 0.0001:
while 'mpv' not in subprocess.getoutput('xdotool getwindowfocus getwindowname') or (config.hide_when_not_fullscreen_B and not mpv_fullscreen_status()) or (os.path.exists(mpv_socket + '_hide')):
if not was_hidden:
self.update_subtitles.emit(True, False)
was_hidden = 1
else:
time.sleep(config.focus_checking_time)
inc = 0
inc += 1
if was_hidden:
was_hidden = 0
self.update_subtitles.emit(False, False)
continue
try:
tmp_file_subs = open(sub_file).read()
except:
continue
if config.extend_subs_duration2max_B and not len(tmp_file_subs):
if not config.extend_subs_duration_limit_sec:
continue
if config.extend_subs_duration_limit_sec > time.time() - last_updated:
continue
last_updated = time.time()
# automatically switch into Hebrew if it's detected
if config.lang_from != 'he' and config.lang_from != 'iw' and any((c in set('קראטוןםפשדגכעיחלךףזסבהנמצתץ')) for c in tmp_file_subs):
config.lang_from = 'he'
frf = random.choice(config.he_fonts)
config.style_subs = re.sub('font-family: ".*?";', lambda ff: 'font-family: "%s";' % frf, config.style_subs, flags = re.I)
config.R2L_from_B = True
config.translation_function_names = config.translation_function_names_2
config.listen_via = 'forvo'
os.system('notify-send -i none -t 1111 "He"')
os.system('notify-send -i none -t 1111 "%s"' % str(frf))
self.update_subtitles.emit(False, True)
while tmp_file_subs != subs:
if config.auto_pause == 2:
if not auto_pause_2_ind and len(re.sub(' +', ' ', stripsd2(subs.replace('\n', ' '))).split(' ')) > config.auto_pause_min_words - 1 and not mpv_pause_status():
mpv_pause()
auto_pause_2_ind = 1
if auto_pause_2_ind and mpv_pause_status():
break
auto_pause_2_ind = 0
subs = tmp_file_subs
if config.auto_pause == 1:
if len(re.sub(' +', ' ', stripsd2(subs.replace('\n', ' '))).split(' ')) > config.auto_pause_min_words - 1:
mpv_pause()
self.update_subtitles.emit(False, False)
break
class thread_translations(QObject):
get_translations = pyqtSignal(str, int, bool)
@pyqtSlot()
def main(self):
while 1:
to_new_word = False
try:
word, globalX = config.queue_to_translate.get(False)
except:
time.sleep(config.update_time)
continue
# changing cursor to hourglass during translation
QApplication.setOverrideCursor(Qt.WaitCursor)
threads = []
for translation_function_name in config.translation_function_names:
threads.append(threading.Thread(target = globals()[translation_function_name], args = (word,)))
for x in threads:
x.start()
while any(thread.is_alive() for thread in threads):
if config.queue_to_translate.qsize():
to_new_word = True
break
time.sleep(config.update_time)
QApplication.restoreOverrideCursor()
if to_new_word:
continue
if config.block_popup:
continue
self.get_translations.emit(word, globalX, False)
# drawing layer
# because can't calculate outline with precision
class drawing_layer(QLabel):
def __init__(self, line, subs, parent=None):
super().__init__(None)
self.line = line
self.setStyleSheet(config.style_subs)
self.psuedo_line = 0
def draw_text_n_outline(self, painter: QPainter, x, y, outline_width, outline_blur, text):
outline_color = QColor(config.outline_color)
font = self.font()
text_path = QPainterPath()
if config.R2L_from_B:
text_path.addText(x, y, font, ' ' + r2l(text.strip()) + ' ')
else:
text_path.addText(x, y, font, text)
# draw blur
range_width = range(outline_width, outline_width + outline_blur)
# ~range_width = range(outline_width + outline_blur, outline_width, -1)
for width in range_width:
if width == min(range_width):
alpha = 200
else:
alpha = (max(range_width) - width) / max(range_width) * 200
blur_color = QColor(outline_color.red(), outline_color.green(), outline_color.blue(), alpha)
blur_brush = QBrush(blur_color, Qt.SolidPattern)
blur_pen = QPen(blur_brush, width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
painter.setPen(blur_pen)
painter.drawPath(text_path)
# draw outline
outline_color = QColor(outline_color.red(), outline_color.green(), outline_color.blue(), 255)
outline_brush = QBrush(outline_color, Qt.SolidPattern)
outline_pen = QPen(outline_brush, outline_width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
painter.setPen(outline_pen)
painter.drawPath(text_path)
# draw text
color = self.palette().color(QPalette.Text)
painter.setPen(color)
painter.drawText(x, y, text)
if config.outline_B:
def paintEvent(self, evt: QPaintEvent):
if not self.psuedo_line:
self.psuedo_line = 1
return
x = y = 0
y += self.fontMetrics().ascent()
painter = QPainter(self)
self.draw_text_n_outline(
painter,
x,
y + config.outline_top_padding - config.outline_bottom_padding,
config.outline_thickness,
config.outline_blur,
text = self.line
)
def resizeEvent(self, *args):
self.setFixedSize(
self.fontMetrics().width(self.line),
self.fontMetrics().height() +
config.outline_bottom_padding +
config.outline_top_padding
)
def sizeHint(self):
return QSize(
self.fontMetrics().width(self.line),
self.fontMetrics().height()
)
class events_class(QLabel):
mouseHover = pyqtSignal(str, int, bool)
redraw = pyqtSignal(bool, bool)
def __init__(self, word, subs, skip = False, parent=None):
super().__init__(word)
self.setMouseTracking(True)
self.word = word
self.subs = subs
self.skip = skip
self.highlight = False
self.setStyleSheet('background: transparent; color: transparent;')
def highligting(self, color, underline_width):
color = QColor(color)
color = QColor(color.red(), color.green(), color.blue(), 200)
painter = QPainter(self)
if config.hover_underline:
font_metrics = QFontMetrics(self.font())
text_width = font_metrics.width(self.word)
text_height = font_metrics.height()
brush = QBrush(color)
pen = QPen(brush, underline_width, Qt.SolidLine, Qt.RoundCap)
painter.setPen(pen)
if not self.skip:
painter.drawLine(0, text_height - underline_width, text_width, text_height - underline_width)
if config.hover_hightlight:
x = y = 0
y += self.fontMetrics().ascent()
painter.setPen(color)
painter.drawText(x, y + config.outline_top_padding - config.outline_bottom_padding, self.word)
if config.outline_B:
def paintEvent(self, evt: QPaintEvent):
if self.highlight:
self.highligting(config.hover_color, config.hover_underline_thickness)
#####################################################
def resizeEvent(self, event):
text_height = self.fontMetrics().height()
text_width = self.fontMetrics().width(self.word)
self.setFixedSize(text_width, text_height + config.outline_bottom_padding + config.outline_top_padding)
def enterEvent(self, event):
if not self.skip:
self.highlight = True
self.repaint()
config.queue_to_translate.put((self.word, event.globalX()))
@pyqtSlot()
def leaveEvent(self, event):
if not self.skip:
self.highlight = False
self.repaint()
config.scroll = {}
self.mouseHover.emit('', 0, False)
QApplication.restoreOverrideCursor()
def wheel_scrolling(self, event):
if event.y() > 0:
return 'ScrollUp'
if event.y():
return 'ScrollDown'
if event.x() > 0:
return 'ScrollLeft'
if event.x():
return 'ScrollRight'
def wheelEvent(self, event):
for mouse_action in config.mouse_buttons:
if self.wheel_scrolling(event.angleDelta()) == mouse_action[0]:
if event.modifiers() == eval('Qt.%s' % mouse_action[1]):
exec('self.%s(event)' % mouse_action[2])
def mousePressEvent(self, event):
for mouse_action in config.mouse_buttons:
if 'Scroll' not in mouse_action[0]:
if event.button() == eval('Qt.%s' % mouse_action[0]):
if event.modifiers() == eval('Qt.%s' % mouse_action[1]):
exec('self.%s(event)' % mouse_action[2])
#####################################################
def f_show_in_browser(self, event):
config.avoid_resuming = True
os.system(config.show_in_browser.replace('${word}', self.word))
def f_auto_pause_options(self, event):
if config.auto_pause == 2:
config.auto_pause = 0
else:
config.auto_pause += 1
mpv_message('auto_pause: %d' % config.auto_pause)
def f_listen(self, event):
listen(self.word, config.listen_via)
@pyqtSlot()
def f_subs_screen_edge_padding_decrease(self, event):
config.subs_screen_edge_padding -= 5
mpv_message('subs_screen_edge_padding: %d' % config.subs_screen_edge_padding)
self.redraw.emit(False, True)
@pyqtSlot()
def f_subs_screen_edge_padding_increase(self, event):
config.subs_screen_edge_padding += 5
mpv_message('subs_screen_edge_padding: %d' % config.subs_screen_edge_padding)
self.redraw.emit(False, True)
@pyqtSlot()
def f_font_size_decrease(self, event):
config.style_subs = re.sub('font-size: (\d+)px;', lambda size: [ 'font-size: %dpx;' % ( int(size.group(1)) - 1 ), mpv_message('font: %s' % size.group(1)) ][0], config.style_subs, flags = re.I)
self.redraw.emit(False, True)
@pyqtSlot()
def f_font_size_increase(self, event):
config.style_subs = re.sub('font-size: (\d+)px;', lambda size: [ 'font-size: %dpx;' % ( int(size.group(1)) + 1 ), mpv_message('font: %s' % size.group(1)) ][0], config.style_subs, flags = re.I)
self.redraw.emit(False, True)
def f_auto_pause_min_words_decrease(self, event):
config.auto_pause_min_words -= 1
mpv_message('auto_pause_min_words: %d' % config.auto_pause_min_words)
def f_auto_pause_min_words_increase(self, event):
config.auto_pause_min_words += 1
mpv_message('auto_pause_min_words: %d' % config.auto_pause_min_words)
@pyqtSlot()
def f_deepl_translation(self, event):
self.mouseHover.emit(self.subs , event.globalX(), True)
def f_save_word_to_file(self, event):
if ( os.path.isfile(os.path.expanduser(config.save_word_to_file_fname)) and self.word not in [ x.strip() for x in open(os.path.expanduser(config.save_word_to_file_fname)).readlines() ] ) or not os.path.isfile(os.path.expanduser(config.save_word_to_file_fname)):
print(self.word, file = open(os.path.expanduser(config.save_word_to_file_fname), 'a'))
@pyqtSlot()
def f_scroll_translations_up(self, event):
if self.word in config.scroll and config.scroll[self.word] > 0:
config.scroll[self.word] = config.scroll[self.word] - 1
else:
config.scroll[self.word] = 0
self.mouseHover.emit(self.word, event.globalX(), False)
@pyqtSlot()
def f_scroll_translations_down(self, event):
if self.word in config.scroll:
config.scroll[self.word] = config.scroll[self.word] + 1
else:
config.scroll[self.word] = 1
self.mouseHover.emit(self.word, event.globalX(), False)
class main_class(QWidget):
def __init__(self):
super().__init__()
self.thread_subs = QThread()
self.obj = thread_subtitles()
self.obj.update_subtitles.connect(self.render_subtitles)
self.obj.moveToThread(self.thread_subs)
self.thread_subs.started.connect(self.obj.main)
self.thread_subs.start()
self.thread_translations = QThread()
self.obj2 = thread_translations()
self.obj2.get_translations.connect(self.render_popup)
self.obj2.moveToThread(self.thread_translations)
self.thread_translations.started.connect(self.obj2.main)
self.thread_translations.start()
# start the forms
self.subtitles_base()
self.subtitles_base2()
self.popup_base()
def clearLayout(self, layout):
if layout == 'subs':
layout = self.subtitles_vbox
self.subtitles.hide()
elif layout == 'subs2':
layout = self.subtitles_vbox2
self.subtitles2.hide()
elif layout == 'popup':
layout = self.popup_vbox
self.popup.hide()
if layout is not None:
while layout.count():
item = layout.takeAt(0)
widget = item.widget()
if widget is not None:
widget.deleteLater()
else:
self.clearLayout(item.layout())
def subtitles_base(self):
self.subtitles = QFrame()
self.subtitles.setAttribute(Qt.WA_TranslucentBackground)
self.subtitles.setWindowFlags(Qt.X11BypassWindowManagerHint)
self.subtitles.setStyleSheet(config.style_subs)
self.subtitles_vbox = QVBoxLayout(self.subtitles)
self.subtitles_vbox.setSpacing(config.subs_padding_between_lines)
self.subtitles_vbox.setContentsMargins(0, 0, 0, 0)
def subtitles_base2(self):
self.subtitles2 = QFrame()
self.subtitles2.setAttribute(Qt.WA_TranslucentBackground)
self.subtitles2.setWindowFlags(Qt.X11BypassWindowManagerHint)
self.subtitles2.setStyleSheet(config.style_subs)
self.subtitles_vbox2 = QVBoxLayout(self.subtitles2)
self.subtitles_vbox2.setSpacing(config.subs_padding_between_lines)
self.subtitles_vbox2.setContentsMargins(0, 0, 0, 0)
if config.pause_during_translation_B:
self.subtitles2.enterEvent = lambda event : [mpv_pause(), setattr(config, 'block_popup', False)][0]
self.subtitles2.leaveEvent = lambda event : [mpv_resume(), setattr(config, 'block_popup', True)][0] if not config.avoid_resuming else [setattr(config, 'avoid_resuming', False), setattr(config, 'block_popup', True)][0]
def popup_base(self):
self.popup = QFrame()
self.popup.setAttribute(Qt.WA_TranslucentBackground)
self.popup.setWindowFlags(Qt.X11BypassWindowManagerHint)
self.popup.setStyleSheet(config.style_popup)
self.popup_inner = QFrame()
outer_box = QVBoxLayout(self.popup)
outer_box.addWidget(self.popup_inner)
self.popup_vbox = QVBoxLayout(self.popup_inner)
self.popup_vbox.setSpacing(0)
def render_subtitles(self, hide = False, redraw = False):
if hide or not len(subs):
try:
self.subtitles.hide()
self.subtitles2.hide()
finally:
return
if redraw:
self.subtitles.setStyleSheet(config.style_subs)
self.subtitles2.setStyleSheet(config.style_subs)
else:
self.clearLayout('subs')
self.clearLayout('subs2')
if hasattr(self, 'popup'):
self.popup.hide()
# if subtitle consists of one overly long line - split into two
if config.split_long_lines_B and len(subs.split('\n')) == 1 and len(subs.split(' ')) > config.split_long_lines_words_min - 1:
subs2 = split_long_lines(subs)
else:
subs2 = subs
subs2 = re.sub(' +', ' ', subs2).strip()
##############################
for line in subs2.split('\n'):
line2 = ' %s ' % line.strip()
ll = drawing_layer(line2, subs2)
hbox = QHBoxLayout()
hbox.setContentsMargins(0, 0, 0, 0)
hbox.setSpacing(0)
hbox.addStretch()
hbox.addWidget(ll)
hbox.addStretch()
self.subtitles_vbox.addLayout(hbox)
####################################
hbox = QHBoxLayout()
hbox.setContentsMargins(0, 0, 0, 0)
hbox.setSpacing(0)
hbox.addStretch()
if config.R2L_from_B:
line2 = line2[::-1]
line2 += '\00'
word = ''
for smbl in line2:
if smbl.isalpha():
word += smbl
else:
if len(word):
if config.R2L_from_B:
word = word[::-1]
ll = events_class(word, subs2)
ll.mouseHover.connect(self.render_popup)
ll.redraw.connect(self.render_subtitles)
hbox.addWidget(ll)
word = ''
if smbl != '\00':
ll = events_class(smbl, subs2, skip = True)
hbox.addWidget(ll)
hbox.addStretch()
self.subtitles_vbox2.addLayout(hbox)
self.subtitles.adjustSize()
self.subtitles2.adjustSize()
w = self.subtitles.geometry().width()
h = self.subtitles.height = self.subtitles.geometry().height()
x = (config.screen_width/2) - (w/2)
if config.subs_top_placement_B:
y = config.subs_screen_edge_padding
else:
y = config.screen_height - config.subs_screen_edge_padding - h
self.subtitles.setGeometry(x, y, 0, 0)
self.subtitles.show()
self.subtitles2.setGeometry(x, y, 0, 0)
self.subtitles2.show()
def render_popup(self, text, x_cursor_pos, is_line):
if text == '':
if hasattr(self, 'popup'):
self.popup.hide()
return
self.clearLayout('popup')
if is_line:
QApplication.setOverrideCursor(Qt.WaitCursor)
line = deepl(text)
if config.split_long_lines_B and len(line.split('\n')) == 1 and len(line.split(' ')) > config.split_long_lines_words_min - 1:
line = split_long_lines(line)
ll = QLabel(line)
ll.setObjectName("first_line")
self.popup_vbox.addWidget(ll)
else:
word = text
for translation_function_name_i, translation_function_name in enumerate(config.translation_function_names):
pairs, word_descr = globals()[translation_function_name](word)
if not len(pairs):
pairs = [['', '[Not found]']]
#return
# ~pairs = [ [ str(i) + ' ' + pair[0], pair[1] ] for i, pair in enumerate(pairs) ]
if word in config.scroll:
if len(pairs[config.scroll[word]:]) > config.number_of_translations:
pairs = pairs[config.scroll[word]:]
else:
pairs = pairs[-config.number_of_translations:]
if len(config.translation_function_names) == 1:
config.scroll[word] -= 1
for i1, pair in enumerate(pairs):
if i1 == config.number_of_translations:
break
if config.split_long_lines_in_popup_B:
pair[0] = split_long_lines(pair[0], max_symbols_per_line = config.split_long_lines_in_popup_symbols_min)
pair[1] = split_long_lines(pair[1], max_symbols_per_line = config.split_long_lines_in_popup_symbols_min)
if pair[0] == '-':
pair[0] = ''
if pair[1] == '-':
pair[1] = ''
# ~if config.R2L_from_B:
# ~pair[0] = pair[0][::-1]
# ~if config.R2L_to_B:
# ~pair[1] = pair[1][::-1]
if pair[0] != '':
# to emphasize the exact form of the word
# to ignore case on input and match it on output
chnks = re.split(word, pair[0], flags = re.I)
exct_words = re.findall(word, pair[0], flags = re.I)
hbox = QHBoxLayout()
hbox.setContentsMargins(0, 0, 0, 0)
for i2, chnk in enumerate(chnks):
if len(chnk):
ll = QLabel(chnk)
ll.setObjectName("first_line")
hbox.addWidget(ll)
if i2 + 1 < len(chnks):
ll = QLabel(exct_words[i2])
ll.setObjectName("first_line_emphasize_word")
hbox.addWidget(ll)
# filling the rest of the line with empty bg
ll = QLabel()
ll.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
hbox.addWidget(ll)
self.popup_vbox.addLayout(hbox)
if pair[1] != '':
ll = QLabel(pair[1])
ll.setObjectName("second_line")
self.popup_vbox.addWidget(ll)
# padding
ll = QLabel()
ll.setStyleSheet("font-size: 6px;")
self.popup_vbox.addWidget(ll)
if len(word_descr[0]):
ll = QLabel(word_descr[0])
ll.setProperty("morphology", word_descr[1])
ll.setAlignment(Qt.AlignRight)
self.popup_vbox.addWidget(ll)
# delimiter between dictionaries
if translation_function_name_i + 1 < len(config.translation_function_names):
ll = QLabel()
ll.setObjectName("delimiter")
self.popup_vbox.addWidget(ll)
self.popup_inner.adjustSize()
self.popup.adjustSize()
w = self.popup.geometry().width()
h = self.popup.geometry().height()
if w > config.screen_width:
w = config.screen_width - 20
if not is_line:
if w < config.screen_width / 3:
w = config.screen_width / 3
if x_cursor_pos == -1:
x = (config.screen_width/2) - (w/2)
else:
x = x_cursor_pos - w/5
if x+w > config.screen_width:
x = config.screen_width - w
if config.subs_top_placement_B:
y = self.subtitles.height + config.subs_screen_edge_padding
else:
y = config.screen_height - config.subs_screen_edge_padding - self.subtitles.height - h
self.popup.setGeometry(x, y, w, 0)
self.popup.show()
QApplication.restoreOverrideCursor()
if __name__ == "__main__":
print('[py part] Starting interSubs ...')
try:
os.mkdir('urls')
except:
pass
if 'tab_divided_dict' in config.translation_function_names:
offdict = { x.split('\t')[0].strip().lower() : x.split('\t')[1].strip() for x in open(os.path.expanduser(config.tab_divided_dict_fname)).readlines() if '\t' in x }
mpv_socket = sys.argv[1]
sub_file = sys.argv[2]
# sub_file = '/tmp/mpv_sub_'
# mpv_socket = '/tmp/mpv_socket_'
subs = ''
app = QApplication(sys.argv)
config.avoid_resuming = False
config.block_popup = False
config.scroll = {}
config.queue_to_translate = queue.Queue()
config.screen_width = app.primaryScreen().size().width()
config.screen_height = app.primaryScreen().size().height()
form = main_class()
app.exec_()
