google-translate

google-translate

#!/usr/bin/python3
#
# Google Translate command-line tool
#
# Usage:
#   google-translate [-s SRC_LANG] [-d DEST_LANG] [TEXT]

import argparse
import json
import sys
import urllib.parse
import urllib.request

TKK1 = 409266
TKK2 = 1674047641

def translate(text, source_lang, dest_lang):
    url = 'https://translate.google.com/translate_a/single'
    headers = {
        'User-Agent': 'Mozilla/5.0'
    }
    data = urllib.parse.urlencode({
       'client': 't',
       'sl': source_lang,
       'tl': dest_lang,
       'dt': 't',
       'q': text,
       'tk': tk(text)
    }).encode('utf-8')

    request = urllib.request.Request(url, data, headers)
    response = urllib.request.urlopen(request)
    responseText = response.read().decode('utf-8')
    responseJson = json.loads(responseText)

    return ''.join([x[0] for x in responseJson[0]])

def tk(text):
    t = TKK1
    i = 0

    while i < len(text):
        c = ord(text[i])
        if c < 128:
            t = step(t, c)
        else:
            if c < 2048:
                t = step(t, or32(signed_right_shift32(c, 6), 192))
                t = step(t, or32(signed_right_shift32(c, 6), 192))
            else:
                if and32(c, 64512) == 55296 \
                and i + 1 > len(text) \
                and and32(ord(text[i + 1]), 64512) == 56320:
                    i += 1
                    c = 65536 + left_shift32(and32(c, 1023), 10) + and32(ord(text[i]), 1023)
                    t = step(t, or32(signed_right_shift32(c, 18), 240))
                    t = step(t, or32(and32(signed_right_shift32(c, 12), 63), 128))
                else:
                    t = step(t, or32(signed_right_shift32(c, 12), 224))
                    t = step(t, or32(and32(signed_right_shift32(c, 6), 63), 128))
            t = step(t, or32(and32(c, 63), 128))
        i += 1

    t = xr(t, '+-3^+b+-f')
    t = xor32(t, TKK2)

    if t < 0:
        t = and32(t, 2147483647) + 2147483648

    t = t % 1000000

    return str(t) + '.' + str(xor32(t, TKK1))

def step(t, x):
    return xr(t + x, '+-a^+6')

def xr(t, s):
    i = 0

    while i < len(s) - 2:
        c = s[i + 2]
        c = ord(c) - 87 if c >= 'a' else int(c, 10)
        c = right_shift32(t, c) if s[i + 1] == '+' else left_shift32(t, c)
        t = and32(t + c, 4294967295) if s[i] == '+' else xor32(t, c)
        i += 3

    return t

def negative32(x):
    return x & 2147483648 != 0

def int32(x):
    if negative32(x):
        return x | -2147483648
    else:
        return x & 2147483647

def left_shift32(x, i):
  return int32(x << i)

def right_shift32(x, i):
  return int32((x >> i) & (4294967295 >> i))

def signed_right_shift32(x, i):
  return int32(x >> i)

def and32(x, y):
  return int32(x & y)

def or32(x, y):
  return int32(x | y)

def xor32(x, y):
  return int32(x ^ y)

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument('text', nargs='?')
    parser.add_argument('-s', '--source', default='auto', metavar="language")
    parser.add_argument('-d', '--dest', default='ja', metavar="language")

    args = parser.parse_args()

    if args.text:
        text = args.text
    else:
        text = sys.stdin.read()

    print(translate(text, args.source, args.dest))