Testing language tool.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/bin/sh: 1: ../tool_langue/tool_language: not found\r\n"
     ]
    }
   ],
   "source": [
    "!../tool_langue/tool_language -h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['exemplo.txt',\n",
       " 'es.dat',\n",
       " 'data',\n",
       " 'error.txt',\n",
       " 'ptbr.dat',\n",
       " 'phn.tmp',\n",
       " 'tmp',\n",
       " 'leia-me.txt',\n",
       " 'txt.tmp',\n",
       " 'ptbr.log',\n",
       " 'exemplo_phn.txt',\n",
       " 'tool_language',\n",
       " 'libptbr.so.4.6.0',\n",
       " 'libes.so.4.6.0']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir(\"../tool_language\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Este é um exemplo de fala acolhedora com a voz da Rosana\n"
     ]
    }
   ],
   "source": [
    "# Arquivos de entrada/saida do modulo linguistico \n",
    "tmp_txt = \"exemplo_sintese.txt\"\n",
    "tmp_phn = \"exemplo_sintese_phn.txt\"\n",
    "\n",
    "lang = 'pt_BR'\n",
    "#lang = 'es_AL'\n",
    "\n",
    "input_from_console = True\n",
    "txt_in_file = \"merda.txt\" #Soh eh usado se input_from_console == False\n",
    "\n",
    "if input_from_console: #Recebe entrada a partir do console \n",
    "    line = input()\n",
    "    lines = [line]\n",
    "else: #Recebe entrada a partir de arquivo\n",
    "    encodingDetect = EncodingDetect(txt_in_file)\n",
    "    with open(txt_in_file, \"r\", encoding=encodingDetect.get_encoding()) as f:\n",
    "        lines = f.readlines()\n",
    "\n",
    "with open(tmp_txt, \"w\", encoding=\"utf-8\") as f:\n",
    "    f.writelines(lines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['exemplo_sintese_pnh.txt',\n",
       " 'pw_qualifi',\n",
       " 'Testing language tool.ipynb',\n",
       " '.cache',\n",
       " 'leiame_global_22kz.txt',\n",
       " 'data',\n",
       " 'exemplo_sintese_phn.txt',\n",
       " 'github',\n",
       " 'exemplo_sintese.pnh',\n",
       " 'error.txt',\n",
       " '.gnupg',\n",
       " 'CH',\n",
       " 'leima_global.txt',\n",
       " 'Avalicao Blizzard.ipynb',\n",
       " '.ipynb_checkpoints',\n",
       " 'example_restart.sh',\n",
       " '.bash_history',\n",
       " 'nohup.out',\n",
       " 'exemplo_sintese.txt',\n",
       " '.gitconfig',\n",
       " 'lucas_venv',\n",
       " 'docker-run.sh',\n",
       " 'docker-run-notebook-espnet.sh',\n",
       " 'pw_results',\n",
       " '.python_history',\n",
       " '.local',\n",
       " 'leima.txt',\n",
       " 'Gera_texto_leonardo',\n",
       " 'venv']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.path.append(\"../tool_language/\")\n",
    "os.listdir('./')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid argument 'h'\r\n",
      "Usage: tool_language -l <library> -p <path> -t <text> FLAGS\r\n",
      "       tool_language -l <library> -p <path> -i <file> FLAGS\r\n",
      "\r\n",
      "   -l <library>     Path and file name to the TTS engine library.\r\n",
      "   -p <path>        Path to the TTS installation directory.\r\n",
      "   -t <text>        Text to be synthesized.\r\n",
      "   -i <file>        Path to the file containing text to be processed.\r\n",
      "                    Each line of the file will be processed individually,\r\n",
      "                    unless the SSML support is enable.\r\n",
      "   -o <file>        Path to the output file. If omited, the stdout is used.\r\n",
      "   -s               Use simplified output. In this mode, only the processed text\r\n",
      "                    will be written (no structural information).\r\n",
      "   --ssml-b         Assume the input file is a SSML script per block.\r\n",
      "   --ssml-l         Assume the input file is a SSML script per line.\r\n",
      "   --pipe           Insert separators between words and phonemes.\r\n",
      "\r\n",
      "   The entry FLAGS should be zero or more of the following:\r\n",
      "   --tokens         Write the tokens to the output file.\r\n",
      "   --words          Write the normalized words to the output file.\r\n",
      "   --phonemes       Write the normalized words to the output file.\r\n"
     ]
    }
   ],
   "source": [
    "!../tool_language/tool_language -h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "!../tool_language/tool_language -l ../tool_language/libptbr.so.4.6.0 -p ../tool_language/ -i exemplo_sintese.txt -o exemplo_sintese_phn.txt --phonemes -s\n",
    "# !../tool_language/tool_language -l ../tool_language/libptbr.so.4.6.0 -p ../tool_language/ -i exemplo_sintese.txt -o exemplo_sintese_phn.txt --phonemes -s --pipe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escreve no arq de saida\n",
    "with open (tmp_phn, \"r\") as f:\n",
    "    lines = f.readlines()\n",
    "    res = [i + ' ' + j for i, j in zip([lang]*len(lines), lines)]\n",
    "with open(tmp_phn, \"w\", encoding=\"utf-8\") as f:\n",
    "    f.writelines(res)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'exemplo_sintese_phn.txt'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tmp_phn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\"pt_BR #p 'ee ss ts ic 'eh un ee zz 'en pp ll uc dz ic ff 'aa ll ac aa kk oo lh ee dd 'oo rr ac kk on ac vv 'oh zz dd ac rx oo zz 'an nn ac #p\\n\"]\n"
     ]
    }
   ],
   "source": [
    "with open (tmp_phn, \"r\") as f:\n",
    "    lines = f.readlines()\n",
    "    print(lines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, so need to used --phoneme -s --pipe, to generate the structure that we want. that is with word boundaries and phonetic transcription"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}