Example #1
0
def evaluate_policy_docs():
    opt = make_options()
    dataset = data.Dataset()
    feeder = data.Feeder(dataset)
    model, _ = models.load_or_create_models(opt, False)
    translator = Translator(model, opt.beam_size, opt.min_length,
                            opt.max_length)
    docs = data.load_policy_documents()
    for doc in docs:
        data.parse_paragraphs(doc)
    lines = []
    for doc in docs:
        paras = [p for p in doc.paragraphs if 50 <= len(p) <= 400]
        if not paras:
            continue
        lines.append('=================================')
        lines.append(doc.title)
        if len(paras) > 16:
            paras = random.sample(paras, 16)
        paras = sorted(paras, key=lambda x: -len(x))
        pids = [feeder.sent_to_ids(p) for p in paras]
        pids = data.align2d(pids)
        src = nu.tensor(pids)
        lengths = (src != data.NULL_ID).sum(-1)
        tgt = translator.translate(src.transpose(0, 1), lengths,
                                   opt.best_k_questions)
        questions = [[feeder.ids_to_sent(t) for t in qs] for qs in tgt]
        for p, qs in zip(paras, questions):
            lines.append('--------------------------------')
            lines.append(p)
            for k, q in enumerate(qs):
                lines.append('predict {}: {}'.format(k, q))
    utils.write_all_lines(opt.output_file, lines)
def main():
	import os
	DEVNULL = open(os.devnull, 'wb')

	#Kill Previous dnsmasq process.
	Popen(["sudo", "pkill", "ovs"], stdout=DEVNULL, stderr=DEVNULL)
	Popen(["sudo", "killall", "dnsmasq"], stdout=DEVNULL, stderr=DEVNULL)
	#pass the username to the custom net function
	customNet(username = sys.argv[5], enableBlank = sys.argv[1], enableBasic = sys.argv[2], enableDhcp = sys.argv[3])
	
	arguments = sys.argv[1:]
	pcapFiles = []
	username = sys.argv[5]

	#sudo python NetInitialiser.py bw delay loss file.xml h1.pcap h2.pcap s1-eth1.pcap
	for i in range(6, len(sys.argv)):
		pcapFiles = sys.argv[i].split()

	print "pcap files = ", pcapFiles
	packetReader = PacketReader(pcapFiles, username)
	packetReader.openFiles()
	#packetReader.calculateTimes()
	#print " "
	#print packetReader.getFullSrcIPList()
	#print " "
	#print packetReader.getFullDstIPList()
	translator = Translator(packetReader.getFullSrcIPList(), packetReader.getFullDstIPList(), packetReader.getPktTimes(), packetReader.getIpNodeDict(), packetReader.getMetaInfo())
	print sys.argv[4]
	translator.getHostSwitchIDs(sys.argv[4])
	#username = getpass.getuser()
	translator.writeToXML("/home/comhghall/Final-Year-Project/resources/netanim_topo.xml")
Example #3
0
 def test_match_found(self):
     t = Translator()
     self.assertFalse(t.countef)  # empty object for counting mappings
     self.assertFalse(t.totalf)  # empty object
     t.train(english, foreign)
     self.assertEquals(t.translate('dog'), [('der', 0.1287760647333088),
                                            ('Hund', 0.8712239352666912)])
Example #4
0
 def test_no_match_found(self):
     t = Translator()
     self.assertFalse(t.countef)  # empty object for counting mappings
     self.assertFalse(t.totalf)  # empty object
     t.train(english, foreign)
     # self.assertEquals(t.translate('bro'), NoMatchError('no matches found'))
     self.assertRaises(NoMatchError, t.translate, 'bro')
Example #5
0
def translate_file(input_file, input_file_name, output_file, write_boot):
    """
    translates the given input vm file to the given output asm file
    :param input_file: the input vm file
    :param input_file_name: the name of the input file
    :param output_file: the output asm file
    :param write_boot: should the function write the booting lines in the beginning of the translation
    """
    file_name_dirs = input_file_name.split(
        os.path.sep)  # split the path to its directories and the file name
    file_name = file_name_dirs[
        FILE_NAME_POSITION][:-len(VM_SUFFIX) - 1]  # gets the file name only
    file_parser = Parser(file_name)
    file_translator = Translator(file_parser)

    # if needed: puts the booting line at the start of the file
    if write_boot:
        output_file.write(file_translator.translate_booting())

    # the input file translation
    for line in input_file:
        file_parser.set_command(line)  # setting the parser to the current line
        file_parser.parse()
        asm_command = file_translator.translate()
        output_file.write(
            asm_command)  # printing the asm code in the output file
Example #6
0
File: gui.py Project: halbbob/dff
class gui():
    def __init__(self, debug = False):
        """Launch GUI"""
        self.debug = debug
        self.app = QApplication(sys.argv)

        self.translator = Translator()
        
        self.app.installTranslator(self.translator.getGeneric())
        self.app.installTranslator(self.translator.getDFF())
        self.app.setApplicationName("Digital Forensics Framework")
	self.app.setApplicationVersion("1.2.0")
        pixmap = QPixmap(":splash.png")
        self.splash = SplashScreen(pixmap, Qt.WindowStaysOnTopHint, self.app.applicationVersion())
        self.splash.setMask(pixmap.mask()) 

    def launch(self, modPath = None):
        self.splash.show()
        if modPath:
          self.loader = loader()
          self.loader.do_load(modPath, self.splash.showMessage)
        mainWindow = MainWindow(self.app, self.debug)
        mainWindow.show()

        self.splash.finish(mainWindow)
        sys.exit(self.app.exec_())
Example #7
0
 def __init__(self, source):
     self.output_type = type(BaseMessage)
     self.input_type = type(BaseMessage)
     #assert issubclass(source,Source)
     #assert source.output_type == self.input_type
     #self.next = source
     Translator.__init__(self, source)
Example #8
0
 def test_no_match_found(self):
     t = Translator()
     self.assertFalse(t.countef)  # empty object for counting mappings
     self.assertFalse(t.totalf)  # empty object
     t.train(english, foreign)
     # self.assertEquals(t.translate('bro'), NoMatchError('no matches found'))
     self.assertRaises(NoMatchError, t.translate, 'bro')
Example #9
0
class MessageTests(unittest.TestCase):
    def setUp(self) -> None:
        self.translator = Translator(common)

    def test_message_without_head(self):
        msg = "1 2 3 6 0 й 6 0 6 0 6 3 й 6 0 3 й й 1"
        self.assertFalse(
            self.translator.is_encoded(msg)
        )

    def test_valid_message(self):
        msg = "й й 2 1 2 3 6 0 й 1 1 1 3 3 3 6 6 6 й й й й й 1"
        self.assertTrue(
            self.translator.is_encoded(msg)
        )

    def test_invalid_len_message(self):
        msg = "й й 2 1 2 3 6 0 й 6 0 6 0 6 3 й 6 й й 1"
        self.assertFalse(
            self.translator.is_encoded(msg)
        )

    def test_message_without_tail(self):
        msg = "й й 2 1 2 3 6 0 й 6 0 6 0 6 3 й 6 0"
        self.assertFalse(
            self.translator.is_encoded(msg)
        )
Example #10
0
    def test_simple_test(self):
        translator = Translator("tests/test_data/translate/file_to_translate",
                                "tests/test_data/translate/actual_file",
                                "tests/test_data/translate/entries.json")

        translator.translate("tests/test_data/translate/actual_file")
        os.remove("tests/test_data/translate/actual_file")
Example #11
0
def translate(config):

    model_path = config.model_path

    if config.gpu < 0:
        device = torch.device('cpu')
    else:
        device = torch.device('cuda:0')

    model_state = Checkpointer.restore(model_path, device)

    fields = model_state["fields"]
    src_field = fields[0][1]  # SRC field object
    tgt_field = fields[1][1]  # SRC field object
    datareader = DatasetReader(config, fields)
    test_iter = datareader.prepare_for_test()

    model_config = model_state["config"]
    model_config.beam_width = config.beam_width
    model = build_model(model_config, src_field, tgt_field)
    model.to(device)
    model.load_state_dict(model_state["model"])

    translator = Translator(config, fields, model, test_iter)
    translator.translate()
Example #12
0
    def build_floor(self):
        # place the floor down first
        self.place_floor()

        # build outer walls
        self.place_outer_walls()

        # create initial room positions
        self.initialize_rooms()

        # debug information
        # self.print_floor()

        # grow the rooms until none can grow anymore
        self.grow_rooms()

        # fix the walls to patch up weird growing
        self.fix_walls()

        # builds the door locations between rooms and on the outerwall
        self.build_doors()

        #debug information
        # self.print_floor()

        # translate self.floor from 2d numpy array into 3d Minecraft space
        translator = Translator(self.level, self.box, self.floor, self.options)
        translator.translate_floor()
Example #13
0
def translate(message):
    t = Translator(YANDEX_API_KEY)
    if t.get_language(message.text) == 'en':
        result = t.get_translation(message.text, 'ru')
    else:
        result = t.get_translation(message.text, 'en')
    bot.send_message(message.chat.id, result)
Example #14
0
 def get(self, page):
     self.response.headers['Content-Type'] = 'text/html'
     # FIXME: URL stringing is sooo crude.
     response = fetch('http://trac.webkit.org/export/HEAD/trunk/LayoutTests/' + page + '-expected.txt')
     translator = Translator()
     self.response.out.write('<html>\n<head>\n<link rel="stylesheet" type="text/css" href="/assets/styles.css">\n<script src="/assets/visualizer.js"></script>\n<script>')
     translator.translate_file(self.response.out, response.content.split('\n'))
     self.response.out.write('</script>\n</head>\n<body></body>\n</html>\n')
Example #15
0
 def __init__(self, f):
     self.asm_file = f
     self.table = SymbolTable()
     self.data = self.read_file()
     self.parser = Parser(self.data)
     self.commands = self.parser.commands
     self.translator = Translator()
     self.filename = self.asm_file.split(".")[0]
Example #16
0
 def __init__(self, show_tree):
     #terminales = ['+', '-', '*', '/', '(', ')', 'num', 'id', '$']
     #noterminales = ['E', 'Ep', 'T', 'Tp', 'F']
     self.nodoInicial = None
     self.tablaSintactica = None
     self.terminales.add('$')  # Fin de cadena
     self.analizador_lexico = AnalizadorLexico()
     self.translator = Translator()
     self.show_tree = show_tree
Example #17
0
def handle_translation(message):
    translator = Translator()
    translator.detect_language(message)
    result = None
    try:
        result = translator.translate_text_with_model(
            translator.target_language, message)
    except:
        result = 'Sorry cannnot translate your message'
    return result
Example #18
0
 def run(self):
     self.soc_serv = UDPSocketServer(self.app_logger)
     self.transl = Translator(self.app_logger)
     self.app_logger.info("server started")
     while True:
         message, address = self.soc_serv.recv()
         for client in self.clients:
             if address[0] == client.IP:
                 client_queue = client.QUEUE
                 client_queue.put(message)
Example #19
0
 def testTranslate(self):
     translator = Translator()
     content = "我爱"
     from_lang = 'ch'
     to_lang = 'en'
     result = translator.translate(content, from_lang, to_lang)
     self.assertEqual("I love", result)
     translate = translator.translate("When writing unit tests", to_lang,
                                      from_lang)
     print(translate)
Example #20
0
    def __init__(self, filename):

        self.filename = filename
        self.translator = Translator()
        self.translator.load_model(self.MODEL_PATH)
        self.image_out_path = os.path.join(os.getcwd(), "./data/images/")
        self.outfilename = os.path.join(os.path.dirname(self.filename),
                                        "output" + str(uuid.uuid1()) + ".txt")
        self.english = list()
        self.hindi = list()
Example #21
0
def translate():
    if request.method == 'POST':

        # Get the results from the web user
        form_data = request.form
        for key, value in form_data.items():
            if key == 'Input_Text':
                input = value
                continue
            if key == 'Language':
                lang_index = value

        set_language(lang_index)

        # Get the model preferences locally or from S3
        s3_file = False

        try:
            if (s3_file):
                model_pref_path = 'machine-learning/models/' + lang_prefix[
                    lang_index] + model_id + 'pickles/model_prefs.pkl'
                s3 = S3Bucket()
                model_prefs = pickle.load(s3.read_pickle(model_pref_path))
            else:
                model_pref_path = 'models/' + lang_prefix[
                    lang_index] + model_id + 'pickles/model_prefs.pkl'
                model_prefs = pickle.load(open(model_pref_path, 'rb'))

        except Exception as e:
            input = e
            translation_error = 'No Model found for {}'.format(model_pref_path)
            return render_template(
                'index.html',
                input_echo=input,
                input_text='Unable to load language model: ' + lang_index,
                translation=translation_error,
                selected_lang=get_selected(lang_options),
                options=lang_options,
                lang_details=lang_details[lang_index],
                bleu_score=bleus[lang_index])

        # A model exists, so use it and translate away!
        T = Translator(model_prefs)
        translation = T.translate(input)
        #
        # # Keras backend needs to clear the session
        clear_session()
        return render_template('index.html',
                               input_echo=input,
                               input_text=input,
                               translation=translation,
                               selected_lang=get_selected(lang_options),
                               options=lang_options,
                               lang_details=lang_details[lang_index],
                               bleu_score=bleus[lang_index])
class PageTranslator(object):
    """
		Provides methods for translating the text of each page belonging to a publicaiton, into English.
	"""

    translator = None

    def __init__(self, api_key):
        self.translator = Translator(api_key)

    def translate_page(self, input_filepath, output_file_path,
                       output_file_name):
        """
			Reads in text from the input file, and then uses the Translator to determine
			whether the language is english or not. If not then it uses the Translator
			to acquire an english language version and save it to the output file.

			Args:
        	input_filepath (str): The input page text file
        	output_file_path (str): The output directory path
        	output_file_name (str): The name of the file to save the translated text to
		"""
        if os.path.exists(output_file_path + output_file_name):
            return
        with open(input_filepath, 'r') as input_file:
            page_text = input_file.read()
            is_english = self.translator.is_english(page_text)
        if is_english != True:
            print "[" + is_english + "]" + input_filepath + " ---> " + output_file_path + output_file_name
            translation = self.translator.translate(page_text)
            if not os.path.exists(output_file_path):
                os.makedirs(output_file_path)
            with open(output_file_path + output_file_name, 'w') as output_file:
                output_file.write(str(translation['text']))

    def translate_publications(self, working_directory, translation_directory,
                               input_file):
        """
			Iterates through in input csv containing ukmhl identifiers and then 
			iterates through the page text files for each publication, using translate_page
			to attempt to translate the page text if required.

			Args:
        	input_file (str): The input csv file containing a list of ukmhl identifiers to process
		"""
        lab_csv_reader = LabCSVReader(input_file)
        for row in lab_csv_reader.reader():
            publication_directory = working_directory + row['id'] + "/pages/"
            for page_file in os.listdir(publication_directory):
                translation_path = translation_directory + row[
                    'id'] + "/translations/"
                self.translate_page(publication_directory + page_file,
                                    translation_path, page_file)
        lab_csv_reader.close()
Example #23
0
class TextDocument(Document):

    def set_text(self, text):
	self.text = text;

    def translate(self, config):
	self.translator = Translator(config)
	if self.input_file is not None:
		self.braille_text = self.translator.translate_file (self.input_file)
	else:
		self.braille_text = self.translator.translate_string (self.text)
Example #24
0
    def __init__(self, inputt, musicName, initialBPM, initialInstrument):
        input_converter = Input_information_converter(inputt)
        translator = Translator()

        self._text = input_converter.get_text()
        self._instructions = translator.translate_text_to_instructions(
            self._text)
        self._music_name = musicName
        self._initial_bpm = initialBPM
        self._initialInstrument = initialInstrument
        self._track = Track(1, self._initial_bpm, self._initialInstrument)
Example #25
0
    def translate(self, term, language):
        if len(term.split()) > 1:
            print("Error: A Term must be only a single word")
        else:
            try:
                t = Translator()
                word = t.translate(term, dest=language)

                return word
            except:
                print("Invalid Word")
Example #26
0
    def get_bug_report(self):
        # set gzip header
        cherrypy.response.headers['Content-Type'] = 'application/gzip'
        # create return tuple
        return_tuple = {}
        return_tuple['status'] = "failed"
        return_tuple['warning'] = ""
        return_tuple['error'] = ""

        # parse json encoded input
        input = helper.convert_dict_values_to_utf8(cherrypy.request.json)

        # user language
        language = ""
        if input.has_key("language") == True:
            language = input['language']
        # if the user sends a language, which is not german, take the default language setting
        if language != "de":
            language = Config().get_param("default_language")
        # initialize the translator object with the user's choosen language
        translator = Translator(language)

        # bug report variables
        if input.has_key("file_name") == False:
            return_tuple['error'] = translator.translate(
                "message", "no_bug_report_file_name")
            return helper.zip_data(return_tuple)
        if input.has_key("bug_report") == False:
            return_tuple['error'] = translator.translate(
                "message", "no_bug_report_contents")
            return helper.zip_data(return_tuple)

        # save bug report
        try:
            bug_report_folder = os.path.join(Config().get_param("logs_folder"),
                                             "client")
            if os.path.exists(bug_report_folder) == False:
                os.makedirs(bug_report_folder)
            file = open(
                os.path.join(bug_report_folder,
                             input['file_name'].split("/")[-1]), 'w')
            file.write(input['bug_report'])
            file.close()
        except IOError as e:
            pass

        # send mail to the admin
        helper.send_email(
            "OSMRouter: New bug report", "%s\n\n%s" %
            (input['file_name'].split("/")[-1], input['bug_report']))

        # convert return_tuple to json and zip it, before returning
        return_tuple['status'] = "ok"
        return helper.zip_data(return_tuple)
Example #27
0
 def __init__(self,
              path,
              source_language,
              target_language,
              engine="Google"):
     self.source_language = source_language
     self.target_language = target_language
     self.ebook = Ebook(path)
     self.set_out_path()
     self.set_counter_path()
     self.set_start_point()
     self.translator = Translator(source_language, target_language, engine)
Example #28
0
def main():
    logging.basicConfig(
        format='%(asctime)s - %(levelname)s - %(name)s -   %(message)s',
        datefmt='%m/%d/%Y %H:%M:%S',
        level=logging.INFO)
    logger = logging.getLogger(__name__)

    args = parse_args()

    # load data
    if args.share_vocab:
        vocab = load_vocab(args.vocab_path)
        src_vocab = vocab
        tgt_vocab = vocab
        vocab_size = len(vocab)
        logger.info("Load vocabulary from %s, vocabulary size: %d" %
                    (args.vocab_path, vocab_size))
    else:
        src_vocab = load_vocab(args.src_vocab_path)
        tgt_vocab = load_vocab(args.tgt_vocab_path)
        src_vocab_size, tgt_vocab_size = len(src_vocab), len(tgt_vocab)
        logger.info("Load src vocabulary from %s, vocabulary size: %d" %
                    (args.src_vocab_path, src_vocab_size))
        logger.info("Load tgt vocabulary from %s, vocabulary size: %d" %
                    (args.tgt_vocab_path, tgt_vocab_size))

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    n_gpu = torch.cuda.device_count()
    use_gpu = n_gpu > 0

    model = torch.load(args.model_path)
    model.to(device)

    input_data = list(load_data(args.input_file, src_vocab))
    logger.info("Load dataset with %d samples from %s" %
                (len(input_data), args.input_file))

    translator = Translator(model=model,
                            src_vocab=src_vocab,
                            tgt_vocab=tgt_vocab,
                            batch_size=args.batch_size,
                            beam_size=args.beam_size,
                            device=device)

    with torch.no_grad():
        results = translator.translate(input_data)
    prediction = results['prediction']
    content = '\n'.join(prediction) + '\n'
    with open(args.output_file, 'w', encoding='utf8') as f:
        f.write(content)

    logger.info('%d samples have been translated.' % len(prediction))
Example #29
0
class EbookTranslator:
    def __init__(self,
                 path,
                 source_language,
                 target_language,
                 engine="Google"):
        self.source_language = source_language
        self.target_language = target_language
        self.ebook = Ebook(path)
        self.set_out_path()
        self.set_counter_path()
        self.set_start_point()
        self.translator = Translator(source_language, target_language, engine)

    def translate(self):
        for counter, original_sentence in enumerate(tqdm(
                self.ebook.sentences)):
            translated_sentence = self.translator.translate(original_sentence)
            both_sentences = f"{translated_sentence}\n\n{original_sentence}\n\n"
            self.write_to_file(both_sentences, self.out_path)
            self.write_to_file(str(counter), self.counter_path, mode="w")
        self.quit()

    def set_out_path(self):
        self.out_path = self.ebook.path.replace(
            ".txt", f"_translated_to_{self.target_language}.txt")

    def set_counter_path(self):
        self.counter_path = self.ebook.path.replace(".txt", f"_counter.txt")

    def write_counter_to_file(self, counter):
        self.write_to_file(counter, self.counter_path, mode="w")

    def write_to_file(self, text, path, mode="a"):
        with open(path, mode) as file:
            file.write(text)

    def read_counter(self):
        with open(self.counter_path) as file:
            return int(file.read())

    def set_start_point(self):
        if os.path.exists(self.counter_path):
            start_point = self.read_counter() + 1
            print(f"Continuing translation from sentence {start_point}")
            self.ebook.sentences = self.ebook.sentences[start_point:]
        else:
            print("Starting translation from the beginning.")

    def quit(self):
        self.translator.quit()
Example #30
0
def main():
    """Requests infix expressions, translates them to postfix,
    and evaluates them, until the user enters nothing."""
    while True:
        sourceStr = input("Enter an infix expression: ")
        if sourceStr == "": break
        try:
            scanner = Scanner(sourceStr)
            translator = Translator(scanner)
            postfix = translator.translate()
            evaluator = Evaluator(postfix)
            print("Value:", evaluator.evaluate())
        except Exception as e:
            print("Error:", e, translator.translationStatus())
Example #31
0
def main():
    """Requests infix expressions, translates them to postfix,
    and evaluates them, until the user enters nothing."""
    while True:
        sourceStr = input("Enter an infix expression: ")
        if sourceStr == "": break
        try:
            scanner = Scanner(sourceStr)
            translator = Translator(scanner)
            postfix = translator.translate()
            evaluator = Evaluator(postfix)
            print("Value:", evaluator.evaluate())
        except Exception as e:
            print("Error:", e, translator.translationStatus())
Example #32
0
def evaluation(model, src_vocab, tgt_vocab, valid_data, reference, batch_size=64, beam_size=1, args=None, device=None):
    translator = Translator(
        model=model,
        src_vocab=src_vocab,
        tgt_vocab=tgt_vocab,
        batch_size=batch_size,
        beam_size=beam_size,
        device=device)

    result = translator.translate(valid_data)
    prediction = result['prediction']
    prediction = [pred.replace('@@ ', '') for pred in prediction]
    prediction = [pred.split() for pred in prediction]
    bleu = corpus_bleu(reference, prediction) * 100.
    return bleu
    def get_bug_report(self):
        # set gzip header
        cherrypy.response.headers['Content-Type'] = 'application/gzip'
        # create return tuple
        return_tuple = {}
        return_tuple['status'] = "failed"
        return_tuple['warning'] = ""
        return_tuple['error'] = ""

        # parse json encoded input
        input = helper.convert_dict_values_to_utf8( cherrypy.request.json )

        # user language
        language = ""
        if input.has_key("language") == True:
            language = input['language']
        # if the user sends a language, which is not german, take the default language setting
        if language != "de":
            language = Config().get_param("default_language")
        # initialize the translator object with the user's choosen language
        translator = Translator(language)

        # bug report variables
        if input.has_key("file_name") == False:
            return_tuple['error'] = translator.translate("message", "no_bug_report_file_name")
            return helper.zip_data(return_tuple)
        if input.has_key("bug_report") == False:
            return_tuple['error'] = translator.translate("message", "no_bug_report_contents")
            return helper.zip_data(return_tuple)

        # save bug report
        try:
            bug_report_folder = os.path.join( Config().get_param("logs_folder"), "client")
            if os.path.exists(bug_report_folder) == False:
                os.makedirs(bug_report_folder)
            file = open(os.path.join(bug_report_folder, input['file_name'].split("/")[-1]), 'w')
            file.write(input['bug_report'])
            file.close()
        except IOError as e:
            pass

        # send mail to the admin
        helper.send_email("OSMRouter: New bug report", "%s\n\n%s"
                % (input['file_name'].split("/")[-1], input['bug_report']) )

        # convert return_tuple to json and zip it, before returning
        return_tuple['status'] = "ok"
        return helper.zip_data(return_tuple)
Example #34
0
    def on_content_loading_state_change(self, event):
        """Handles loading/unloading of a content.

        :param event: Event that contains information about current
                      availability of a content
        :type event: :class:`events.ContentLoadingState`

        """
        video = getattr(event, 'video', None)
        subtitles = getattr(event, 'subtitles', None)
        if video is not None and video != self._video_state:
            self._video_state = video
            if self.video.Length():
                self.video_slider.SetRange(0, self.video.Length())
                self.video_slider.SetPageSize(int(self.video.Length() / 10))
                self.Layout()
            for widget in ('play_button', 'stop_button', 'video_slider'):
                getattr(self, widget).Enable(video)
            self.enable_menu_actions(play=video, stop=video)
            self.video.SetVolume(self.volume_slider.GetValue() / 100.0)
            if video:
                wx.CallLater(300, wx.PostEvent, self,
                             wx.PyCommandEvent(wx.EVT_BUTTON.typeId, ids.PLAY))
        if subtitles is not None:
            self._subtitles_state = subtitles
        both = self._video_state and self._subtitles_state
        for widget in ('mode_choice', 'delay_spin', 'answer_edit'):
            getattr(self, widget).Enable(both)
        if both:
            self.translator = Translator()
        else:
            try:
                del self.translator
            except AttributeError:
                pass
Example #35
0
class PdfDocument(Document):
    def _get_text (self, file):
	uri = "file://" + file
	document = poppler.document_new_from_file (uri, None)
	npages = document.get_n_pages()
	text = ""
	for p in range(0,npages):
		page = document.get_page(p)
		w,h = page.get_size()
		r = poppler.Rectangle ()
		r.x1 = 0
		r.x2 = w
		r.y1 = 0
		r.y2 = h
		# Currently we are getting the layout from the pdf here
		# we should collapse it
		text += page.get_text(poppler.SELECTION_GLYPH,r)

	return text


    def translate(self, config):
	# FIXME: Check if poppler gives us always UTF-8 strings
	config['outputFormat']['inputTextEncoding'] = "UTF8"
	self.translator = Translator(config)
	text = self._get_text(self.input_file)
	self.braille_text = self.translator.translate_string (text)
	return
Example #36
0
def translate(source_lang,
              target_lang,
              data_list: List[str] = Query(None),
              special_tokens: List[str] = Query(None)):
    '''
    :param source_lang: source language [arb, eng, heb]
    :param target_lang: target language [arb, eng, heb]
    :param data_list: list[str]
    :return: list[str]
    '''
    model_index = f"{source_lang}_{target_lang}"
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    if model_index not in running_models.keys():
        # need to init model
        running_models[model_index] = Translator(source_lang=source_lang,
                                                 target_lang=target_lang,
                                                 special_tokens=special_tokens)
    else:  #model exists
        if torch.cuda.is_available():
            running_models[model_index].load_model_to_gpu()
            running_models[model_index].to(device)
    translation_df = running_models[model_index].translate(data_list)
    api_logger.info(
        f"returned value to client: {translation_df['tgt_text'].tolist()}")
    _free_model(model_index)
    return translation_df["tgt_text"].tolist()
Example #37
0
    def translate(self, config):
	# FIXME: Check if poppler gives us always UTF-8 strings
	config['outputFormat']['inputTextEncoding'] = "UTF8"
	self.translator = Translator(config)
	text = self._get_text(self.input_file)
	self.braille_text = self.translator.translate_string (text)
	return
Example #38
0
def main_loop():
    translator = Translator(settings.TRANSLATION_MAP, DoneAction())

    def collect_actions():
        result = translator.translate_pressed(universe.mode)
        for event in pygame.event.get():
            universe.mouseCoord = pygame.mouse.get_pos()
            print(universe.mouseCoord)
            result += translator.translate_event(universe.mode, event)
        return result

    while True:
        actions = collect_actions()

        if any(action.is_done() for action in actions):
            break

        for action in actions:
            action.change_universe(universe, render)

        screen.fill((255, 255, 255))
        render.draw(universe.surface_altitudes)
        render.draw_hero(universe.hero)  # NEW METHOD
        pygame.display.flip()

        universe.update()
        # render_universe()
        clock.tick(settings.FPS)
 def get_translation_response(self, from_lang_number, to_lang_number, word):
     """
     Gets the translation response for the word from the original language to the target language
     """
     from_language = self.languages[from_lang_number]
     to_language = self.languages[to_lang_number]
     return Translator(from_language, to_language).translate(word)
 def cancel_request(self):
     # set gzip header
     cherrypy.response.headers['Content-Type'] = 'application/gzip'
     # create the return tuple
     return_tuple = {}
     return_tuple['warning'] = ""
     return_tuple['error'] = ""
     translator = Translator(Config().get_param("default_language"))
     # parse json encoded input
     options = helper.convert_dict_values_to_utf8( cherrypy.request.json )
     # create session id
     if options.has_key("session_id") == False:
         return_tuple['error'] = translator.translate("message", "no_session_id_option")
         return helper.zip_data(return_tuple)
     Config().query_removement_of_session_id(options['session_id'])
     print "cancel session id %s" % options['session_id']
     return helper.zip_data(return_tuple)
Example #41
0
  def on_Whatson_response(self, response, tv_channel, irc_channel, user, url, next):
    #log.msg('{response}'.format(response=response))
    program = scrape_tv_schedule(response, tv_channel)
    if not program:
      self._parent.say(channel, u'\x033No schedule found at tv.so-net.ne.jp...'.encode('utf-8'))
      return
    if next:
      #TODO: figure out the time the current program ends
      #this will be of the form '6:00 ~ 7:00' in the response.
      #in that case i'd just want '7:00' which i can turn into a datetime
      #THen we initiate another lookup with that time.
      next_program_time = program.end_time
      self.initiate_program_lookup(next_program_time, tv_channel, irc_channel, user, False)
      return

    #blurb = u'{program}\x033{url}'.format(program=unicode(program), url=url)
    Translator.translate(program.name, self.on_translation, 
      self.on_translation_error,
      tv_channel=tv_channel, irc_channel=irc_channel, program=program, user=user, url=url)
Example #42
0
class DocDocument(Document):

    def _get_text(seff, file):
	text = subprocess.check_output([antiword, "-x", "db", file])
	return text

    def translate(self, config):
	config['outputFormat']['inputTextEncoding'] = "UTF8"
	self.translator = Translator(config)
	result = self._get_text (self.input_file)
	self.braille_text = self.translator.translate_string (result)
Example #43
0
File: gui.py Project: halbbob/dff
    def __init__(self, debug = False):
        """Launch GUI"""
        self.debug = debug
        self.app = QApplication(sys.argv)

        self.translator = Translator()
        
        self.app.installTranslator(self.translator.getGeneric())
        self.app.installTranslator(self.translator.getDFF())
        self.app.setApplicationName("Digital Forensics Framework")
	self.app.setApplicationVersion("1.2.0")
        pixmap = QPixmap(":splash.png")
        self.splash = SplashScreen(pixmap, Qt.WindowStaysOnTopHint, self.app.applicationVersion())
        self.splash.setMask(pixmap.mask()) 
Example #44
0
class OdtDocument(Document):

    def _get_text(sefl, file):
	odhandler = ODF2XHTML (False, False)
	odhandler.elements[(TEXTNS, u"changed-region")] = (odhandler.s_ignorexml,None)
	try:
		result = odhandler.odf2xhtml(file).encode('UTF-8','xmlcharrefreplace')
	except:
		result = ""
		pass
	return result

    def translate(self, config):
	config['outputFormat']['inputTextEncoding'] = "UTF8"
	self.translator = Translator(config)
	result = self._get_text (self.input_file)
	self.braille_text = self.translator.translate_string (result)
Example #45
0
class PdfDocument(Document):
    def _get_text (self, file):
	uri = "file://" + file
	document = Poppler.Document.new_from_file (uri, "")
	npages = document.get_n_pages()
	text = ""
	for p in range(0,npages):
		page = document.get_page(p)
		text += page.get_text()

	return text


    def translate(self, config):
	# FIXME: Check if poppler gives us always UTF-8 strings
	config['outputFormat']['inputTextEncoding'] = "UTF8"
	self.translator = Translator(config)
	text = self._get_text(self.input_file)
	self.braille_text = self.translator.translate_string (text)
	return
Example #46
0
 def test_EM_transitions(self):
     t = Translator()
     self.assertFalse(t.countef)  # empty object for counting mappings
     self.assertFalse(t.totalf)  # empty object
     t.train(english, foreign)
     self.assertTrue(t.transmissions)
    def get_departures(self):
        # set gzip header
        cherrypy.response.headers['Content-Type'] = 'application/gzip'
        # create the return tuple
        return_tuple = {}
        return_tuple['departures'] = []
        return_tuple['warning'] = ""
        return_tuple['error'] = ""
        translator = Translator(Config().get_param("default_language"))
        # parse json encoded input
        options = helper.convert_dict_values_to_utf8( cherrypy.request.json )

        # user language
        language = ""
        if options.has_key("language") == True:
            language = options['language']
        # if the user sends a language, which is not german, take the default language setting
        if language != "de":
            language = Config().get_param("default_language")
        # initialize the translator object with the user's choosen language
        translator = Translator(language)

        # check latitude, longitude and vehicles parameters
        try:
            lat = float(options['lat'])
        except KeyError as e:
            return_tuple['error'] = translator.translate("message", "no_latitude_value")
            return helper.zip_data(return_tuple)
        except ValueError as e:
            return_tuple['error'] = translator.translate("message", "no_latitude_value")
            return helper.zip_data(return_tuple)
        try:
            lon = float(options['lon'])
        except KeyError as e:
            return_tuple['error'] = translator.translate("message", "no_longitude_value")
            return helper.zip_data(return_tuple)
        except ValueError as e:
            return_tuple['error'] = translator.translate("message", "no_longitude_value")
            return helper.zip_data(return_tuple)
        try:
            vehicles = options['vehicles'].split("+")
        except KeyError as e:
            vehicles = []

        # get the nearest stations for this coordinates and take the first one
        gateway = JavaGateway(GatewayClient(port=Config().get_param("gateway_port")), auto_field=True)
        main_point = gateway.entry_point
        closest_stations_result = main_point.getNearestStations(
                geometry.convert_coordinate_to_int(lat),
                geometry.convert_coordinate_to_int(lon))
        if closest_stations_result.status.toString() == "INVALID_STATION":
            return_tuple['error'] = translator.translate("message", "no_station_for_this_coordinates")
            return helper.zip_data(return_tuple)
        if closest_stations_result.status.toString() == "SERVICE_DOWN":
            return_tuple['error'] = translator.translate("message", "bahn_server_down")
            return helper.zip_data(return_tuple)
        if closest_stations_result.locations == None or len(closest_stations_result.locations) == 0:
            return_tuple['error'] = translator.translate("message", "no_station_for_this_coordinates")
            return helper.zip_data(return_tuple)

        # get departures for station
        sfinder = StationFinder(translator)
        station = sfinder.choose_station_by_vehicle_type(closest_stations_result.locations, lat, lon, vehicles)
        departures_result = main_point.getDepartures( station.id)
        date_format = gateway.jvm.java.text.SimpleDateFormat("HH:mm", gateway.jvm.java.util.Locale.GERMAN)
        for station_departure in departures_result.stationDepartures:
            for departure in station_departure.departures:
                try:
                    dep_entry = {}
                    dep_entry['nr'] = "%s%s" % (departure.line.product.code, departure.line.label)
                    dep_entry['to'] = departure.destination.name
                    dep_entry['time'] = date_format.format(departure.plannedTime)
                    # remaining time
                    duration = departure.plannedTime.getTime()/1000 - int(time.time())
                    minutes, seconds = divmod(duration, 60)
                    dep_entry['remaining'] = minutes
                    return_tuple['departures'].append(dep_entry)
                except Exception as e:
                    pass

        # convert return_tuple to json and zip it, before returning
        return helper.zip_data(return_tuple)
    def get_poi(self):
        # set gzip header
        cherrypy.response.headers['Content-Type'] = 'application/gzip'
        # create the return tuple
        return_tuple = {}
        return_tuple['poi'] = []
        return_tuple['warning'] = ""
        return_tuple['error'] = ""
        translator = Translator(Config().get_param("default_language"))
        # parse json encoded input
        options = helper.convert_dict_values_to_utf8( cherrypy.request.json )

        # user language
        language = ""
        if options.has_key("language") == True:
            language = options['language']
        # if the user sends a language, which is not german, take the default language setting
        if language != "de":
            language = Config().get_param("default_language")
        # initialize the translator object with the user's choosen language
        translator = Translator(language)

        # check latitude, longitude and radius input
        try:
            lat = float(options['lat'])
        except KeyError as e:
            return_tuple['error'] = translator.translate("message", "no_latitude_value")
            return helper.zip_data(return_tuple)
        except ValueError as e:
            return_tuple['error'] = translator.translate("message", "no_latitude_value")
            return helper.zip_data(return_tuple)
        try:
            lon = float(options['lon'])
        except KeyError as e:
            return_tuple['error'] = translator.translate("message", "no_longitude_value")
            return helper.zip_data(return_tuple)
        except ValueError as e:
            return_tuple['error'] = translator.translate("message", "no_longitude_value")
            return helper.zip_data(return_tuple)
        try:
            radius = int(options['radius'])
        except KeyError as e:
            return_tuple['error'] = translator.translate("message", "no_range_value")
            return helper.zip_data(return_tuple)
        except ValueError as e:
            return_tuple['error'] = translator.translate("message", "no_range_value")
            return helper.zip_data(return_tuple)

        # tags and search
        # tag list
        if options.has_key("tags") == False:
            return_tuple['error'] = translator.translate("message", "no_tags_value")
            return helper.zip_data(return_tuple)
        if options['tags'] == "":
            return_tuple['error'] = translator.translate("message", "no_tags_value")
            return helper.zip_data(return_tuple)
        tag_list = options['tags'].split("+")
        # search
        try:
            search = options['search']
        except KeyError as e:
            search = ""

        # create session id
        if options.has_key("session_id") == False:
            return_tuple['error'] = translator.translate("message", "no_session_id_option")
            return helper.zip_data(return_tuple)
        session_id = options['session_id']
        # try to cancel prior request
        if Config().clean_old_session(session_id) == False:
            return_tuple['error'] = translator.translate("message", "old_request_still_running")
            return helper.zip_data(return_tuple)
        if Config().number_of_session_ids() == Config().get_param("thread_pool") - 1:
            return_tuple['error'] = translator.translate("message", "server_busy")
            return helper.zip_data(return_tuple)
        Config().add_session_id(session_id)

        # get poi
        poi = POI(session_id, translator)
        poi_list = poi.get_poi(lat, lon, radius, tag_list, search)
        if poi_list == None:
            Config().confirm_removement_of_session_id(session_id)
            return_tuple['poi'] = []
            return_tuple['error'] = translator.translate("message", "process_canceled")
            return helper.zip_data(return_tuple)

        # convert return_tuple to json and zip it, before returning
        return_tuple['poi'] = poi_list
        Config().confirm_removement_of_session_id(session_id)
        return helper.zip_data(return_tuple)
    def get_transport_routes(self):
        # set gzip header
        cherrypy.response.headers['Content-Type'] = 'application/gzip'
        # create the return tuple
        return_tuple = {}
        return_tuple['transport_routes'] = {}
        return_tuple['warning'] = ""
        return_tuple['error'] = ""
        translator = Translator(Config().get_param("default_language"))

        # parse json encoded input
        input = helper.convert_dict_values_to_utf8( cherrypy.request.json )

        # options object
        if input.has_key("options") == False:
            return_tuple['error'] = translator.translate("message", "no_route_options")
            return helper.zip_data(return_tuple)
        elif type(input['options']) != type({}):
            return_tuple['error'] = translator.translate("message", "no_route_options")
            return helper.zip_data(return_tuple)
        options = input['options']

        # user language
        language = ""
        if options.has_key("language") == True:
            language = options['language']
        # if the user sends a language, which is not german, take the default language setting
        if language != "de":
            language = Config().get_param("default_language")
        # initialize the translator object with the user's choosen language
        translator = Translator(language)

        # source route
        if input.has_key("source_route") == False:
            return_tuple['error'] = translator.translate("message", "no_source_route")
            return helper.zip_data(return_tuple)
        elif type(input['source_route']) != type([]):
            return_tuple['error'] = translator.translate("message", "no_source_route")
            return helper.zip_data(return_tuple)
        elif input['source_route'].__len__() < 3:
            return_tuple['error'] = translator.translate("message", "source_route_incomplete")
            return helper.zip_data(return_tuple)
        source_route = input['source_route']

        # check if route is valid
        index = 0
        number_of_transport_parts = 0
        for part in source_route:
            if part['type'] in ["way_point", "intersection", "poi", "station"]:
                index += 1
            elif part['type'] in ["footway", "transport"]:
                index -= 1
                if part['sub_type'] == "transport_place_holder":
                    number_of_transport_parts += 1
            else:
                index = -1
                break
        if index != 1:
            return_tuple['error'] = translator.translate("message", "source_route_incomplete")
            return helper.zip_data(return_tuple)
        if number_of_transport_parts == 0:
            return_tuple['error'] = translator.translate("message", "source_route_no_transport_parts")
            return helper.zip_data(return_tuple)
        if number_of_transport_parts > 1:
            return_tuple['error'] = translator.translate("message", "source_route_multiple_transport_parts")
            return helper.zip_data(return_tuple)

        # further options
        if options.has_key("number_of_possible_routes") == False:
            options['number_of_possible_routes'] = 3

        # create session id
        if options.has_key("session_id") == False:
            return_tuple['error'] = translator.translate("message", "no_session_id_option")
            return helper.zip_data(return_tuple)
        session_id = options['session_id']
        # try to cancel prior request
        if Config().clean_old_session(session_id) == False:
            return_tuple['error'] = translator.translate("message", "old_request_still_running")
            return helper.zip_data(return_tuple)
        if Config().number_of_session_ids() == Config().get_param("thread_pool") - 1:
            return_tuple['error'] = translator.translate("message", "server_busy")
            return helper.zip_data(return_tuple)
        Config().add_session_id(session_id)

        # create route logger object
        route_logger = RouteLogger("routes", "public_transport---%s---%s" % (source_route[0]['name'], source_route[-1]['name']))

        # parse route parts
        rtc = RouteTransportCreator(session_id, route_logger, translator)
        for i in range(1, source_route.__len__(), 2):
            if source_route[i]['type'] == "footway" and source_route[i]['sub_type'] == "transport_place_holder":
                result = rtc.find_best_transport_routes(source_route[i-1], source_route[i+1],
                        options['number_of_possible_routes'])
                return_tuple['transport_routes'] = result.routes
                pre_source_route = source_route[0:i-1]
                post_source_route = source_route[i+2:source_route.__len__()]
                break
        if return_tuple['transport_routes'] == None:
            Config().confirm_removement_of_session_id(session_id)
            route_logger.append_to_log("\n----- result -----\ncanceled")
            return_tuple['transport_routes'] = []
            return_tuple['error'] = translator.translate("message", "process_canceled")
            return helper.zip_data(return_tuple)

        for key in return_tuple['transport_routes'].keys():
            serializable_list = []
            for route in return_tuple['transport_routes'][key]:
                route.route = pre_source_route + route.route + post_source_route
                serializable_list.append(route.__dict__)
            return_tuple['transport_routes'][key] = serializable_list
        f = open("/tmp/tr_routes.json", "w")
        f.write(json.dumps(return_tuple['transport_routes'], indent=4, encoding="utf-8"))
        f.close()

        # convert return_tuple to json and zip it, before returning
        Config().confirm_removement_of_session_id(session_id)
        return helper.zip_data(return_tuple)
    def get_route(self):
        # set gzip header
        cherrypy.response.headers['Content-Type'] = 'application/gzip'
        # create the return tuple
        return_tuple = {}
        return_tuple['route'] = []
        return_tuple['warning'] = ""
        return_tuple['error'] = ""
        translator = Translator(Config().get_param("default_language"))

        # parse json encoded input
        input = helper.convert_dict_values_to_utf8( cherrypy.request.json )

        # options object
        if input.has_key("options") == False:
            return_tuple['error'] = translator.translate("message", "no_route_options")
            return helper.zip_data(return_tuple)
        elif type(input['options']) != type({}):
            return_tuple['error'] = translator.translate("message", "no_route_options")
            return helper.zip_data(return_tuple)
        options = input['options']

        # user language
        language = ""
        if options.has_key("language") == True:
            language = options['language']
        # if the user sends a language, which is not german, take the default language setting
        if language != "de":
            language = Config().get_param("default_language")
        # initialize the translator object with the user's choosen language
        translator = Translator(language)

        # source route
        if input.has_key("source_route") == False:
            return_tuple['error'] = translator.translate("message", "no_source_route")
            return helper.zip_data(return_tuple)
        elif type(input['source_route']) != type([]):
            return_tuple['error'] = translator.translate("message", "no_source_route")
            return helper.zip_data(return_tuple)
        elif input['source_route'].__len__() < 3:
            return_tuple['error'] = translator.translate("message", "source_route_incomplete")
            return helper.zip_data(return_tuple)
        source_route = input['source_route']

        # check if route is valid
        index = 0
        for part in source_route:
            if part['type'] in ["way_point", "intersection", "poi", "station"]:
                index += 1
                if part.has_key("turn"):
                    part.__delitem__("turn")
                    print "turn deleted"
            elif part['type'] in ["footway", "transport"]:
                index -= 1
            else:
                index = -1
                break
        if index != 1:
            return_tuple['error'] = translator.translate("message", "source_route_incomplete")
            return helper.zip_data(return_tuple)

        # route factor
        if options.has_key("route_factor") == False:
            return_tuple['error'] = translator.translate("message", "no_route_factor_option")
            return helper.zip_data(return_tuple)

        # allowed way classes
        if options.has_key("allowed_way_classes") == False:
            allowed_way_classes = ["big_streets", "small_streets", "paved_ways",
                    "unpaved_ways", "unclassified_ways", "steps"]
        else:
            allowed_way_classes = options['allowed_way_classes']

        # blocked way ids
        blocked_ways = []
        if options.has_key("blocked_ways") == True:
            for id in options['blocked_ways'].split(","):
                try:
                    blocked_ways.append(int(id))
                except ValueError as e:
                    pass

        # create session id
        if options.has_key("session_id") == False:
            return_tuple['error'] = translator.translate("message", "no_session_id_option")
            return helper.zip_data(return_tuple)
        session_id = options['session_id']
        # try to cancel prior request, if necessary
        if Config().clean_old_session(session_id) == False:
            return_tuple['error'] = translator.translate("message", "old_request_still_running")
            return helper.zip_data(return_tuple)
        # this code is onley reached, if the prior session was canceled successfully
        if Config().number_of_session_ids() == Config().get_param("thread_pool") - 1:
            return_tuple['error'] = translator.translate("message", "server_busy")
            return helper.zip_data(return_tuple)
        Config().add_session_id(session_id)

        # create route logger object
        route_logger = RouteLogger("routes", "%s---%s" % (source_route[0]['name'], source_route[-1]['name']))
        # and append the source route
        route_logger.append_to_log("\n----- start of source route -----")
        route_logger.append_to_log( json.dumps( source_route, indent=4, encoding="utf-8") \
                + "\n----- end of source route -----\n")

        # get a route
        rfc = RouteFootwayCreator(session_id, route_logger, translator,
                options['route_factor'], allowed_way_classes, blocked_ways)
        for i in range(1, source_route.__len__(), 2):
            if source_route[i]['type'] == "footway" and source_route[i]['sub_type'] == "footway_place_holder":
                try:
                    route_part = rfc.find_footway_route(source_route[i-1], source_route[i+1])
                except RouteFootwayCreator.FootwayRouteCreationError as e:
                    Config().confirm_removement_of_session_id(session_id)
                    route_logger.append_to_log("\n----- result -----\ncanceled")
                    return_tuple['route'] = []
                    return_tuple['error'] = "%s" % e
                    return helper.zip_data(return_tuple)
                if return_tuple['route'].__len__() > 0:
                    route_part.__delitem__(0)
                return_tuple['route'] += route_part
            else:
                if return_tuple['route'].__len__() == 0:
                    return_tuple['route'].append(source_route[i-1])
                return_tuple['route'].append(source_route[i])
                return_tuple['route'].append(source_route[i+1])
        # delete start point and first route segment, if it's a nameless one, just added as place holder
        if return_tuple['route'].__len__() >= 3 \
                and return_tuple['route'][1].has_key("sub_type") \
                and return_tuple['route'][1]['sub_type'] == "":
            print "deleted placeholder start segment %s" % return_tuple['route'][1]
            return_tuple['route'].__delitem__(0)
            return_tuple['route'].__delitem__(0)
        # check for missing turn values at intersections and poi
        # for example this can happen, if an intersection is a intermediate destination of a source route
        for i in range(2, return_tuple['route'].__len__()-2, 2):
            if return_tuple['route'][i].has_key("turn") == False \
                    and return_tuple['route'][i-1].has_key("bearing") == True \
                    and return_tuple['route'][i+1].has_key("bearing") == True:
                return_tuple['route'][i]['turn'] = geometry.turn_between_two_segments(
                        return_tuple['route'][i+1]['bearing'], return_tuple['route'][i-1]['bearing'])
                print "new turn in webserver = %d" % return_tuple['route'][i]['turn']
        return_tuple['description'] = rfc.get_route_description( return_tuple['route'] )
        route_logger.append_to_log("\n----- start of result route -----")
        route_logger.append_to_log( json.dumps( return_tuple['route'], indent=4, encoding="utf-8") \
                + "\n----- end of result route -----\n")

        # delete session id
        Config().confirm_removement_of_session_id(session_id)
        # convert return_tuple to json and zip it, before returning
        return helper.zip_data(return_tuple)
Example #51
0
from translator import Translator
from bing_translator import BingTranslator

import redis
import os

REDIS_HOST = os.environ.get("REDIS_HOST", "localhost")
REDIS_PORT = os.environ.get("REDIS_PORT", "6379")

TRANSLATE_ENABLED = bool(os.environ.get("TRANSLATION_ENABLED", False))
TARGET_TRANSLATION_LANG = 'de'

gig_redis = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0)

gig_translator = Translator()
gig_translator.set_translator(BingTranslator())
gig_translator.set_target_translation_language(TARGET_TRANSLATION_LANG)


def build_localizable_key(untranslated, target_translation_lang):
    return 'giglocalizable%%%' + untranslated + '%%%' + target_translation_lang


def translate(untranslated):
    key = build_localizable_key(untranslated, TARGET_TRANSLATION_LANG)

    if not TRANSLATE_ENABLED:
        return untranslated

    # If redis contains the localized string in the target language, return it.
    try:
Example #52
0
import parser, re, json
from translator import Translator, is_function

def rename_type(name):
    return re.sub(r"^snd_", r"", name)

env = parser.default_env()
parser.parse(env, ['/usr/include/alsa/asoundlib.h'])
translate = Translator(env, rename_type)
translate.blacklist.update([
    'pollfd', # recursive rule
    '_IO_marker', # recursive rule
    '_IO_FILE', # recursive rule
])
translate.bluelist.update({
    'snd_seq_real_time': 'seq_real_time',
    'snd_dlsym_link': 'dlsym_link',
})

constants = {}
variables = {}

for name, value in env.constants.iteritems():
    if re.match(r'^SND_\w', name):
        if isinstance(value, (int, str)):
            name = re.sub(r"^SND_", r"", name)
            constants[name] = value

for cname in env.names:
    if re.match(r'^snd_\w', cname):
        typespec = translate.declarator(env.names[cname])
Example #53
0
 def test_match_found(self):
     t = Translator()
     self.assertFalse(t.countef)  # empty object for counting mappings
     self.assertFalse(t.totalf)  # empty object
     t.train(english, foreign)
     self.assertEquals(t.translate('dog'), [('der', 0.1287760647333088), ('Hund', 0.8712239352666912)])
Example #54
0
 def translate(self, name, content):
     t = Translator(ts=self)
     return t.translate(name, content) # Turn PSP source to Python source
Example #55
0
class Bottlenose:
  def __init__(self, bootstrapVocabulary=False):
    Concept(bootstrapVocabulary=bootstrapVocabulary)
    self._contexts = [Context()]
    self._context = self._contexts[0]
    self._translator = Translator()
    self._interpreter = Interpreter(self._context)
    
  def tell(self, input):
    JSON = self._translator.visit(grammar.parse(input))
    return self.tellJSON(JSON)
  
  def tellJSON(self, JSON):
    results = self._interpreter.interpret(JSON)
    self._context.ponderRecentMentions()
    if isinstance(results, set) or isinstance(results, list):
      objects = list()
      for result in results:
        objects.append(BottlenoseObject(result, self._context))
      return objects
    elif not results:
      return None
    else:
      return [BottlenoseObject(results, self._context)]
  
  def ask(self, subject, clause=None):
    query = "?" + subject
    if clause:
      query += "(" + clause + ")"
    return self.tell(query)
  
  def context(self):
    return self._context
    
  def listContexts(self):
    return self._contexts
    
  def setContext(self, index):
    if index >= 0 and index < len(self._contexts):
      self._context = self._contexts[index]
      self._interpreter.setContext(self._contexts[index])
      
  def loadFile(self, filePath, onlyBeliefs=False, onlyStatements=False):
    file = open(filePath, 'r')
    for line in file:
      line = line.rstrip("\n")
      JSON = self._translator.visit(grammar.parse(line))
      if 'statement' in JSON:
        if not onlyBeliefs:
          self.tellJSON(JSON)
      else:
        if not onlyStatements:
          self.tellJSON(JSON)
        
  def loadDirectory(self, dirPath):
    filePaths = []
    for root, dirnames, filenames in os.walk(dirPath):
      for filename in fnmatch.filter(filenames, '*.bottle'):
        filePaths.append(os.path.join(root, filename))
    for filePath in filePaths:
      self.loadFile(filePath, onlyBeliefs=True)
    for filePath in filePaths:
      self.loadFile(filePath, onlyStatements=True)    
Example #56
0
 def __init__(self, bootstrapVocabulary=False):
   Concept(bootstrapVocabulary=bootstrapVocabulary)
   self._contexts = [Context()]
   self._context = self._contexts[0]
   self._translator = Translator()
   self._interpreter = Interpreter(self._context)
Example #57
0
    def translate(self, config):
	self.translator = Translator(config)
	if self.input_file is not None:
		self.braille_text = self.translator.translate_file (self.input_file)
	else:
		self.braille_text = self.translator.translate_string (self.text)
    def follow_this_way(self):
        # set gzip header
        cherrypy.response.headers['Content-Type'] = 'application/gzip'
        # create the return tuple
        return_tuple = {}
        return_tuple['route'] = []
        return_tuple['warning'] = ""
        return_tuple['error'] = ""
        translator = Translator(Config().get_param("default_language"))

        # parse json encoded input
        input = helper.convert_dict_values_to_utf8( cherrypy.request.json )

        # options
        if input.has_key("options") == False:
            return_tuple['error'] = translator.translate("message", "no_route_options")
            return helper.zip_data(return_tuple)
        elif type(input['options']) != type({}):
            return_tuple['error'] = translator.translate("message", "no_route_options")
            return helper.zip_data(return_tuple)
        options = input['options']
        # user language
        language = ""
        if options.has_key("language") == True:
            language = options['language']
        # if the user sends a language, which is not german, take the default language setting
        if language != "de":
            language = Config().get_param("default_language")
        # initialize the translator object with the user's choosen language
        translator = Translator(language)

        # start point
        if input.has_key("start_point") == False:
            return_tuple['error'] = translator.translate("message", "no_start_point")
            return helper.zip_data(return_tuple)
        start_point = input['start_point']
        if start_point.has_key("name") == False:
            return_tuple['error'] = translator.translate("message", "start_point_no_name")
            return helper.zip_data(return_tuple)
        elif start_point.has_key("lat") == False:
            return_tuple['error'] = translator.translate("message", "start_point_no_latitude")
            return helper.zip_data(return_tuple)
        elif start_point.has_key("lon") == False:
            return_tuple['error'] = translator.translate("message", "start_point_no_longitude")
            return helper.zip_data(return_tuple)
        elif start_point.has_key("type") == False:
            return_tuple['error'] = translator.translate("message", "start_point_no_type")
            return helper.zip_data(return_tuple)

        # further options
        if options.has_key("way_id") == False:
            return_tuple['error'] = translator.translate("message", "no_way_id")
            return helper.zip_data(return_tuple)
        if options.has_key("bearing") == False:
            return_tuple['error'] = translator.translate("message", "no_bearing_value")
            return helper.zip_data(return_tuple)
        add_all_intersections = False
        if options.has_key("add_all_intersections") == True:
            if options['add_all_intersections'] == "yes":
                add_all_intersections = True
        way = DBControl().fetch_data("SELECT nodes from ways where id = %d" % options['way_id'])
        if way.__len__() == 0:
            return_tuple['error'] = translator.translate("message", "way_id_invalid")
            return helper.zip_data(return_tuple)

        # create session id
        if options.has_key("session_id") == False:
            return_tuple['error'] = translator.translate("message", "no_session_id_option")
            return helper.zip_data(return_tuple)
        session_id = options['session_id']
        # try to cancel prior request
        if Config().clean_old_session(session_id) == False:
            return_tuple['error'] = translator.translate("message", "old_request_still_running")
            return helper.zip_data(return_tuple)
        if Config().number_of_session_ids() == Config().get_param("thread_pool") - 1:
            return_tuple['error'] = translator.translate("message", "server_busy")
            return helper.zip_data(return_tuple)
        Config().add_session_id(session_id)

        # get a route
        route_logger = RouteLogger("routes", "%s---way_id.%s" % (start_point['name'], options['way_id']))
        rfc = RouteFootwayCreator(session_id, route_logger, translator, 1.0,
                ["big_streets", "small_streets", "paved_ways", "unpaved_ways", "unclassified_ways", "steps"], [])
        try:
            route = rfc.follow_this_way(start_point,
                    options['way_id'], options['bearing'], add_all_intersections)
        except RouteFootwayCreator.FootwayRouteCreationError as e:
            route_logger.append_to_log("\n----- result -----\ncanceled")
            Config().confirm_removement_of_session_id(session_id)
            return_tuple['route'] = []
            return_tuple['error'] = "%s" % e
            return helper.zip_data(return_tuple)
        # return calculated route
        return_tuple['route'] = route
        return_tuple['description'] = rfc.get_route_description( return_tuple['route'] )
        route_logger.append_to_log("\n----- result -----\n")
        route_logger.append_to_log( json.dumps( return_tuple['route'], indent=4, encoding="utf-8") + "\n----- end of route -----\n")
        # convert return_tuple to json and zip it, before returning
        Config().confirm_removement_of_session_id(session_id)
        return helper.zip_data(return_tuple)
Example #59
0
    def translate(self, config):
	config['outputFormat']['inputTextEncoding'] = "UTF8"
	self.translator = Translator(config)
	result = self._get_text (self.input_file)
	self.braille_text = self.translator.translate_string (result)
Example #60
0
#!/usr/bin/python3

import argparse
from translator import Translator

if __name__ == '__main__':
    parser = argparse.ArgumentParser()

    parser.add_argument('word',
        action='store',
        help="word that will be translated"
    )
    parser.add_argument('-d', '--details',
        action='store_true',
        help='show detailed information about the translation',
        default=False
    )

    params = parser.parse_args()

    word = params.word
    details = params.details

    t = Translator(word)
    t.show(details)