py_assuntos_classific prova de conceito.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classificador de assuntos de um texto\n",
    "Classificador de assuntos que considera a distancia entre as palavras procuradas\n",
    "\n",
    "Por considerar a distância e não a sequência exata das palavras no texto, como é feito no classificador\n",
    "baseado em busca em profundidade, este classificador consegue lidar com palavras que não estão em ordem sequencial e até mesmo com a presença de outras palavras na frase que não interfiram no entendimento do assunto.\n",
    "\n",
    "Devido a esta maleabilidade, pode ser necessário, em alguns assuntos, definir uma lista de palavras que estando na frase ou na vizinhança, negativem o resultado.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importa do módulo texto a função que normaliza o conteúdo,\n",
    "# retirando acentuação e palavras que não interferem no sentido da frase\n",
    "from lib.texto import normaliza"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1ª Etapa\n",
    "Normalizar o texto que será classificado, retirando acentos e palavras descartáveis e converter o texto em uma lista de palavras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# texto que será classificado\n",
    "texto = '''Tendo em vista a LIQUIDAÇÃO TOTAL\n",
    "DO DÉBITO representado pela (s) CDA(s) acima\n",
    "indicada(s), requer a Fazenda Pública do Estado de São Paulo,\n",
    "por seu (sua) Procurador(a), abaixo assinado (a),\n",
    "requer a extinção do  feito, com fundamento no artigo\n",
    "924, inciso II, do Código de Processo Civil.\n",
    "Caso deferida a pretensão supra, dá-\n",
    "se, desde já, por ciente.\n",
    "Pede deferimento \u0013  924.'''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Texto padronizado e convertido em uma lista de palavras:\n",
      "['tendo', 'vista', 'liquidacao', 'total', 'debito', 'representado', 'cdas', 'acima', 'indicadas', 'requer', 'fesp', 'procuradora', 'abaixo', 'assinado', 'requer', 'extincao', 'feito', 'fundamento', 'art', '924', 'dois', 'codigo', 'processo', 'civil', 'caso', 'deferida', 'pretensao', 'supra', 'ciente', 'pede', 'deferimento', '924']\n"
     ]
    }
   ],
   "source": [
    "texto = normaliza(texto)\n",
    "palavras = texto.split(' ')\n",
    "print('Texto padronizado e convertido em uma lista de palavras:')\n",
    "print(palavras)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2ª Etapa\n",
    "Gerar as listas de assuntos a partir do dicionário de dados padronizado que contém os campos:\n",
    "* `id`: Número único de identificação do assunto\n",
    "* `titulo`: Descrição do assunto\n",
    "* `contem`: lista com os padrões contidos no assunto. Cada item da lista deve ser:\n",
    "    * uma string contendo palavras e/ou listas de palavras sinônimas `[(extincao|extinto)]`\n",
    "    * esta string deve ser convertida em uma lista de palavras e/ou uma lista de palavras sinônimas\n",
    "* `nao_contem`: lista com as palavras que não podem estar na frase encontrada nem na vizinhança\n",
    "\n",
    "As palavras ou frases carregadas no dicionário padrão já devem ter sido padronizadas conforme as regras da função `normaliza()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dicionario contendo os tipos de assuntos para busca -> base para montagem das listas de busca\n",
    "# Para simular registros em um Banco de dados, cada linha é um string\n",
    "# As palavras sinônimas ficam dentro de um formato padrão [(extincao|extinto)]\n",
    "assuntos_dic = {\n",
    "    1: {\n",
    "        'titulo': 'pedido extincao art. 924,ii',\n",
    "        'contem': [\n",
    "            'requer extincao [(execucao|processo|feito)] 924 dois',\n",
    "            'requer [(extincao|extinto)] [(execucao|processo|feito)] 924 dois',\n",
    "        ],\n",
    "        'nao_contem': ['nao', 'revogacao']\n",
    "    },\n",
    "    2: {\n",
    "        'titulo': 'revogacao sentenca',\n",
    "        'contem': [\n",
    "            'requer revogacao sentenca extincao [(execucao|processo|feito)]',\n",
    "        ]\n",
    "    },\n",
    "    3: {\n",
    "        'titulo': 'termo de ciencia',\n",
    "        'contem': [\n",
    "            'supra ciente',\n",
    "        ]\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ser usado no classificador, o dicionário acima (`assuntos_dic`) tem que ser convertido na lista que segue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# exemplo de como deve ficar a lista convertida a partir do dicionario de assuntos\n",
    "# itens de cada linha: 0->id; 1->contem e/ou; 2->não contém\n",
    "assuntos_lista = [\n",
    "    [1, ['requer', 'extincao', ['execucao', 'processo', 'feito'], '924', 'dois'], ['nao', 'revogacao']],\n",
    "    [1, ['requer', ['extincao', 'extinto'], ['execucao', 'processo', 'feito'], '924', 'dois'], ['nao', 'revogacao']],\n",
    "    [2, ['requer', 'revogacao', 'sentenca', 'extincao', ['execucao', 'processo', 'feito']], []],\n",
    "    [3, ['supra', 'ciente'],[]],\n",
    "]           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A função _prepara_lista_e_ou faz conversão da linha\n",
    "# recebe uma string e a converte numa lista de palavras E/OU\n",
    "# conforme o modelo acima\n",
    "def _prepara_lista_e_ou(texto):\n",
    "    marca1 = '[('\n",
    "    marca2 = ')]'\n",
    "    if not(marca1 in texto):\n",
    "        return texto.split(' ')\n",
    "    if texto.count(marca1) != texto.count(marca2):\n",
    "        msg = 'Erro no formato de\\n{}\\n quantidade de \"[(\" e \")]\" diferentes'.format(texto)\n",
    "        raise ValueError(msg)\n",
    "    lista = []\n",
    "    while True:\n",
    "        pos1 = texto.find(marca1)\n",
    "        if pos1 < 0:\n",
    "            if not texto:\n",
    "                break\n",
    "            for palavra in texto.split(' '):\n",
    "                lista.append(palavra)\n",
    "            break\n",
    "        pos2 = texto.find(marca2)\n",
    "        if pos1 != 0:\n",
    "            tmp = texto[:pos1].strip()\n",
    "            for palavra in tmp.split(' '):\n",
    "                lista.append(palavra)\n",
    "        pos2 += 2\n",
    "        texto_ou = texto[pos1 + 2:pos2 - 2]\n",
    "        lista.append(texto_ou.split('|'))\n",
    "        texto = texto[pos2:].strip()\n",
    "    return lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['supra', 'ciente']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_prepara_lista_e_ou('supra ciente')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['requer', 'extincao', ['execucao', 'processo', 'feito'], '924', 'dois']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_prepara_lista_e_ou('requer extincao [(execucao|processo|feito)] 924 dois')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['requer',\n",
       " 'revogacao',\n",
       " 'sentenca',\n",
       " 'extincao',\n",
       " ['execucao', 'processo', 'feito']]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_prepara_lista_e_ou('requer revogacao sentenca extincao [(execucao|processo|feito)]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['requer',\n",
       " ['extincao', 'extinto'],\n",
       " ['execucao', 'processo', 'feito'],\n",
       " '924',\n",
       " 'dois']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_prepara_lista_e_ou('requer [(extincao|extinto)] [(execucao|processo|feito)] 924 dois')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A função _prepara_lista_de_busca recebe a chave e valor de um item do dicionário padronizado\n",
    "# e converte este item em listas de assuntos.\n",
    "# cada linha da lista é uma lista com os campos: 0->id; 1->contem e/ou; 2->não contém\n",
    "def _prepara_lista_de_busca(chave, valor):\n",
    "    listas = []\n",
    "    if not('contem' in valor):\n",
    "        raise KeyError('Chave contem nao encontrada no dicionario')\n",
    "    for linha in valor['contem']:\n",
    "        lista=[]\n",
    "        lista.append(chave)\n",
    "        lista.append(_prepara_lista_e_ou(linha))\n",
    "        if 'nao_contem' in valor:\n",
    "            lista.append(valor['nao_contem'])\n",
    "        else:\n",
    "            lista.append([])\n",
    "        listas.append(lista)\n",
    "    return listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, ['requer', 'extincao', ['execucao', 'processo', 'feito'], '924', 'dois'], ['nao', 'revogacao']], [1, ['requer', ['extincao', 'extinto'], ['execucao', 'processo', 'feito'], '924', 'dois'], ['nao', 'revogacao']]]\n"
     ]
    }
   ],
   "source": [
    "# testes de _prepara_lista_de_busca()\n",
    "print(_prepara_lista_de_busca(1, assuntos_dic[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3, ['supra', 'ciente'], []]]\n"
     ]
    }
   ],
   "source": [
    "print(_prepara_lista_de_busca(3, assuntos_dic[3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A partir do dicionário padrão, as listas são preparadas e extraídas\n",
    "# para serem utilizadas no classificador de assuntos\n",
    "def converte_dicionario_em_listas_de_busca(dic):\n",
    "    listas = []\n",
    "    for i in dic.keys():\n",
    "        lista = _prepara_lista_de_busca(i, dic[i])\n",
    "        for item in lista:\n",
    "            listas.append(item)\n",
    "    return listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, ['requer', 'extincao', ['execucao', 'processo', 'feito'], '924', 'dois'], ['nao', 'revogacao']], [1, ['requer', ['extincao', 'extinto'], ['execucao', 'processo', 'feito'], '924', 'dois'], ['nao', 'revogacao']], [2, ['requer', 'revogacao', 'sentenca', 'extincao', ['execucao', 'processo', 'feito']], []], [3, ['supra', 'ciente'], []]]\n"
     ]
    }
   ],
   "source": [
    "print(converte_dicionario_em_listas_de_busca(assuntos_dic))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# faz a comparação entre a lista gerada manualmente, o esperado, com a lista gerada pela função\n",
    "# _converte_dicionario_em_listas_de_busca()\n",
    "assuntos_lista == converte_dicionario_em_listas_de_busca(assuntos_dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3ª Etapa\n",
    "O núcleo do classificador são as funções que trabalham com cada uma das linhas geradas pela função `_converte_dicionario_em_listas_de_busca(): [1, ['requer', 'extincao', ['execucao', 'processo', 'feito'], '924', 'dois'], ['nao', 'revogacao']]` procurando identificar a sequencia de palavras vizinhas que mais se aproximam com as listas padrão (segunda posição da lista) e que não possuem na vizinhança nenhuma das palavras que negativam o assunto (terceira posição da lista)\n",
    "\n",
    "A função `_procura_lista_de_palavras(lista, palavras)` usa internamente a função `_consulta_palavra(palavra, palavras)` e retorna uma listagem com as posicões encontradas de cada uma das palavras distintas, ou pelo menos uma das palavras sinônimas contidas no texto.\n",
    "\n",
    "A lista retornada pela função `_procura_lista_de_palavras()` é transformada numa matriz com as posicoes entre as palavras encontradas e esta é usada para calcular a distância média entre as palavras e encontrar a sequência de palavras, se houver, que identificam a presença do assunto pesquisado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# faz a consulta de uma palavra no texto (convertido em uma lista)\n",
    "# e retorna uma lista com as posições encontradas da palavra\n",
    "# ou -1 se a palavra não estiver no texto\n",
    "def _consulta_palavra(palavra, palavras):\n",
    "    if not palavra in palavras:\n",
    "        return -1\n",
    "    lista = []\n",
    "    inicio = 0\n",
    "    for i in range(palavras.count(palavra)):\n",
    "        pos = palavras.index(palavra, inicio)\n",
    "        lista.append(pos)\n",
    "        inicio = pos + 1\n",
    "    return lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# procura uma lista de palavras no texto e retorna todas\n",
    "# as posições encontradas, se uma das palavras da lista não for encontrada\n",
    "# retorna uma lista vazia\n",
    "def _procura_lista_de_palavras(lista, palavras):\n",
    "    result = []\n",
    "    for item in lista[1]:\n",
    "        if isinstance(item, str):\n",
    "            # o item é uma palavra, ela tem que estar presente no texto\n",
    "            posicoes = _consulta_palavra(item, palavras)\n",
    "        else:\n",
    "            # o item é uma lista de palavras sinonimas, pelo menos uma tem que ser encontrada\n",
    "            posicoes = []\n",
    "            for palavra in item:\n",
    "                posicao = _consulta_palavra(palavra, palavras)\n",
    "                if posicao == -1:\n",
    "                    continue\n",
    "                posicoes += posicao\n",
    "            if not posicoes:\n",
    "                posicoes = -1\n",
    "        if posicoes == -1:\n",
    "            return []\n",
    "        result.append(posicoes)\n",
    "    return [lista[0], result]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['execucao', 'processo', 'feito']\n",
      "execucao -1\n",
      "processo [22]\n",
      "feito [16]\n"
     ]
    }
   ],
   "source": [
    "# teste da consulta de cada uma das palavras de uma lista:\n",
    "lista = assuntos_lista[0][1][2]\n",
    "print(lista)\n",
    "for palavra in lista:\n",
    "    print(palavra, _consulta_palavra(palavra, palavras))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['tendo', 'vista', 'liquidacao', 'total', 'debito', 'representado', 'cdas', 'acima', 'indicadas', 'requer', 'fesp', 'procuradora', 'abaixo', 'assinado', 'requer', 'extincao', 'feito', 'fundamento', 'art', '924', 'dois', 'codigo', 'processo', 'civil', 'caso', 'deferida', 'pretensao', 'supra', 'ciente', 'pede', 'deferimento', '924']\n",
      "[1, ['requer', 'extincao', ['execucao', 'processo', 'feito'], '924', 'dois'], ['nao', 'revogacao']]\n",
      "[1, [[9, 14], [15], [22, 16], [19, 31], [20]]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lista onde todas as palavras estao no texto\n",
    "print(palavras)\n",
    "print(assuntos_lista[0])\n",
    "esperado = [1, [[9, 14], [15], [22, 16], [19, 31], [20]]]\n",
    "resultado = _procura_lista_de_palavras(assuntos_lista[0], palavras)\n",
    "print(resultado)\n",
    "esperado == resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, ['supra', 'ciente'], []]\n",
      "[3, [[27], [28]]]\n"
     ]
    }
   ],
   "source": [
    "print(assuntos_lista[3])\n",
    "resultado = _procura_lista_de_palavras(assuntos_lista[3], palavras)\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['tendo', 'vista', 'liquidacao', 'total', 'debito', 'representado', 'cdas', 'acima', 'indicadas', 'requer', 'fesp', 'procuradora', 'abaixo', 'assinado', 'requer', 'extincao', 'feito', 'fundamento', 'art', '924', 'dois', 'codigo', 'processo', 'civil', 'caso', 'deferida', 'pretensao', 'supra', 'ciente', 'pede', 'deferimento', '924']\n",
      "[1, [[9, 14], [15], [22, 16], [19, 31], [20]]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(palavras)\n",
    "lista1 = [1, ['requer', 'extincao', ['execucao', 'processo', 'feito'], '924', 'dois'], ['nao', 'revogacao']]\n",
    "esperado = [1, [[9, 14], [15], [22, 16], [19, 31], [20]]]\n",
    "resultado = _procura_lista_de_palavras(lista1, palavras)\n",
    "print(resultado)\n",
    "esperado == resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, ['requer', 'revogacao', 'sentenca', 'extincao', ['execucao', 'processo', 'feito']], []]\n",
      "[]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lista contendo pelo menos uma palavra que não está no texto\n",
    "print(assuntos_lista[2])\n",
    "esperado = []\n",
    "resultado = _procura_lista_de_palavras(assuntos_lista[2], palavras)\n",
    "print(resultado)\n",
    "esperado == resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transforma a lista das posicoes das palavras encontradas\n",
    "# em uma matriz com as sequencias possiveis das palavras\n",
    "# A partir desta matriz a distância média entre as palavras é calculada\n",
    "def _prepara_matriz_dos_resultados(posicoes):\n",
    "    dic = {}\n",
    "    for i in range(len(posicoes[0])):\n",
    "        primeiro = posicoes[0][i]\n",
    "        dic[i] = [[primeiro]]\n",
    "        for listas in posicoes[1:]:\n",
    "            for j in range(len(listas)):\n",
    "                item = listas[j]\n",
    "                if j == 0:\n",
    "                    for l in dic[i]:\n",
    "                        l.append(item)\n",
    "                else:\n",
    "                    for l in range(len(dic[i])):\n",
    "                        tmp = dic[i][l]\n",
    "                        tmp = tmp[:-1]\n",
    "                        tmp.append(item)\n",
    "                        dic[i].append(tmp)\n",
    "    resultado = []\n",
    "    for lista in dic.values():\n",
    "        resultado += lista\n",
    "    return resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calcula a distância média entre as palavras\n",
    "# retornando a linha com menor distância e o valor da distância média\n",
    "def _retorna_palavras_mais_proximas(matriz):\n",
    "    mais_proximo = [[], 100000]\n",
    "    for lista in matriz:\n",
    "        lista.sort()\n",
    "        dist = 0\n",
    "        anterior = lista[0]\n",
    "        for i in range(1, len(lista)):\n",
    "            atual = lista[i]\n",
    "            dist += atual - anterior\n",
    "            anterior = atual\n",
    "        dist_media = 1\n",
    "        if len(lista) > 1:\n",
    "            dist_media = float(dist) / (len(lista) -1)\n",
    "            dist_media = float((\"%.2f\" % dist_media))\n",
    "        # print(lista, dist, dist_media)\n",
    "        if dist_media < mais_proximo[1]:\n",
    "            mais_proximo[0] = lista\n",
    "            mais_proximo[1] = dist_media\n",
    "    return mais_proximo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9, 15, 16, 19, 20], [9, 15, 16, 31, 20], [14, 15, 16, 19, 20], [14, 15, 16, 31, 20]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[14, 15, 16, 19, 20], 1.5]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = [[9, 14], [15], [16], [19, 31], [20]]\n",
    "'''\n",
    "lista: [[9, 14], [15], [16], [19, 31], [20]]\n",
    "matriz:\n",
    "[[9, 15, 16, 19, 20], [9, 15, 16, 31, 20], [14, 15, 16, 19, 20], [14, 15, 16, 31, 20]]\n",
    "mais proximas, distancia média:\n",
    "[14, 15, 16, 19, 20], 1.5\n",
    "'''\n",
    "matriz = _prepara_matriz_dos_resultados(result)\n",
    "print(matriz)\n",
    "_retorna_palavras_mais_proximas(matriz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10, 11, 13, 24], [10, 21, 13, 24], [10, 11, 22, 24], [10, 21, 22, 24], [20, 11, 13, 24], [20, 21, 13, 24], [20, 11, 22, 24], [20, 21, 22, 24]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[20, 21, 22, 24], 1.33]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = [[10, 20], [11, 21], [13, 22], [24]]\n",
    "'''\n",
    "matriz:\n",
    "[[10, 11, 13, 24], [10, 21, 13, 24], [10, 11, 22, 24], [10, 21, 22, 24], [20, 11, 13, 24], [20, 21, 13, 24], [20, 11, 22, \n",
    "24], [20, 21, 22, 24]]\n",
    "mais proximas, distancia média:\n",
    "[20, 21, 22, 24], 1.33\n",
    "'''\n",
    "matriz = _prepara_matriz_dos_resultados(result)\n",
    "print(matriz)\n",
    "_retorna_palavras_mais_proximas(matriz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9, 15, 16, 20, 32], [9, 15, 16, 31, 32], [14, 15, 16, 20, 32], [14, 15, 16, 31, 32]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[14, 15, 16, 20, 32], 4.5]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = [[9, 14], [15], [16], [20, 31], [32]]\n",
    "'''\n",
    "matriz:\n",
    "[[9, 15, 16, 20, 32], [9, 15, 16, 31, 32], [14, 15, 16, 20, 32], [14, 15, 16, 31, 32]]\n",
    "mais proximas, distancia média:\n",
    "[14, 15, 16, 20, 32], 4.5\n",
    "'''\n",
    "matriz = _prepara_matriz_dos_resultados(result)\n",
    "print(matriz)\n",
    "_retorna_palavras_mais_proximas(matriz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[39, 41, 43, 10, 50], [39, 41, 43, 44, 50], [58, 41, 43, 10, 50], [58, 41, 43, 44, 50]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[39, 41, 43, 44, 50], 2.75]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = [[39, 58], [41], [43], [10, 44], [50]]\n",
    "'''\n",
    "matriz:\n",
    "[[39, 41, 43, 10, 50], [39, 41, 43, 44, 50], [58, 41, 43, 10, 50], [58, 41, 43, 44, 50]]\n",
    "mais proximas, distancia média:\n",
    "[39, 41, 43, 44, 50], 2.75\n",
    "'''\n",
    "matriz = _prepara_matriz_dos_resultados(result)\n",
    "print(matriz)\n",
    "_retorna_palavras_mais_proximas(matriz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[40, 41, 43, 10, 45], [40, 59, 43, 10, 45], [40, 41, 43, 44, 45], [40, 59, 43, 44, 45], [40, 41, 43, 10, 60], [40, 59, 43, 10, 60], [40, 41, 43, 44, 60], [40, 59, 43, 44, 60], [58, 41, 43, 10, 45], [58, 59, 43, 10, 45], [58, 41, 43, 44, 45], [58, 59, 43, 44, 45], [58, 41, 43, 10, 60], [58, 59, 43, 10, 60], [58, 41, 43, 44, 60], [58, 59, 43, 44, 60]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[40, 41, 43, 44, 45], 1.25]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = [[40, 58], [41, 59], [43], [10, 44], [45, 60]]\n",
    "'''\n",
    "matriz:\n",
    "[[40, 41, 43, 10, 45], [40, 59, 43, 10, 45], [40, 41, 43, 44, 45], [40, 59, 43, 44, 45], [40, 41, 43, 10, 60],[40, 59, \n",
    "43, 10, 60], [40, 41, 43, 44, 60], [40, 59, 43, 44, 60], [58, 41, 43, 10, 45], [58, 59, 43, 10, 45], [58, 41, 43, 44, 45],\n",
    "[58, 59, 43, 44, 45], [58, 41, 43, 10, 60], [58, 59, 43, 10, 60], [58, 41, 43, 44, 60],[58, 59, 43, 44, 60]]\n",
    "mais proximas, distancia média:\n",
    "[40, 41, 43, 44, 45], 1.25\n",
    "'''\n",
    "matriz = _prepara_matriz_dos_resultados(result)\n",
    "print(matriz)\n",
    "_retorna_palavras_mais_proximas(matriz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4ª Etapa\n",
    "\n",
    "O classificador recebe o texto e o **dicionário padronizado** ou a **lista de assuntos** já formatada onde o primeiro índice de cada item é o código, segundo é a lista de palavras contidas no assunto e o terceiro a lista de palavras que não deve estar presente no texto encontrado ou vizinhança.\n",
    "\n",
    "A distância média mínima necessária entre as palavras encontradas tem como valor padrão 2.\n",
    "\n",
    "Basicamente o que fica \"exposto\" no classificador são as funções `converte_dicionario_em_listas_de_busca(assuntos)` e `classifica(texto, assuntos, distancia)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classifica(texto, assuntos, distancia=2):\n",
    "    if isinstance(assuntos, dict):\n",
    "        assuntos = converte_dicionario_em_listas_de_busca(assuntos)\n",
    "    texto = normaliza(texto)\n",
    "    palavras = texto.split(' ')\n",
    "    retorno = {}\n",
    "    for lista in assuntos:\n",
    "        result = _procura_lista_de_palavras(lista, palavras)\n",
    "        if not result:\n",
    "            continue\n",
    "        matriz = _prepara_matriz_dos_resultados(result[1])\n",
    "        mais_proximos = _retorna_palavras_mais_proximas(matriz)\n",
    "        if mais_proximos[1] <= distancia:\n",
    "            if result[0] in retorno.keys():\n",
    "                if mais_proximos[1] <= retorno[result[0]][1]:\n",
    "                    del(retorno[result[0]])\n",
    "                # print('ja existe')\n",
    "            inicio = mais_proximos[0][0]\n",
    "            fim = mais_proximos[0][-1] + 1\n",
    "            texto = ' '.join(palavras[inicio:fim])\n",
    "            tem_restricao = False\n",
    "            n_vizinhos = distancia + 1\n",
    "            if lista[2]:\n",
    "                if inicio <=  n_vizinhos:\n",
    "                    inicio = 0\n",
    "                else:\n",
    "                    inicio -=  n_vizinhos\n",
    "                fim +=  n_vizinhos\n",
    "                texto_vizinho = ' '.join(palavras[inicio:fim])\n",
    "                exclusoes = lista[2]\n",
    "                for excluir in exclusoes:\n",
    "                    if excluir in texto_vizinho:\n",
    "                        tem_restricao = True\n",
    "                        break\n",
    "            if not tem_restricao:\n",
    "                retorno[result[0]] = [texto, mais_proximos[1]]\n",
    "    return retorno\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tendo informacao fesp cancelamento divida requer revogacao sentenca extincao processo fundamento art 924 dois cpc requer extincao termos art 26 lef'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Neste texto, não há pedido de extinção nos termos do artigo 924, II\n",
    "# e sim um pedido de revogação da sentença\n",
    "texto5 = 'tendo a informacao da fesp sobre o cancelamento da dívida, requer a revogação da sentença \\\n",
    "de extinção do processo com fundamento  no art. 924, II do CPC e requer a extinção nos termos do art. 26 da LEF'\n",
    "normaliza(texto5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, [[5, 15], [8, 16], [9], [12], [13]]]\n"
     ]
    }
   ],
   "source": [
    "# isoladamente, os dois pedidos são validados\n",
    "palavras5 = normaliza(texto5).split(' ')\n",
    "lista1 = [1, ['requer', 'extincao', ['execucao', 'processo', 'feito'], '924', 'dois'], ['nao', 'revogacao']]\n",
    "# ('resultado', [1, [[5, 15], [8, 16], [[9]], [12], [13]]])\n",
    "result = _procura_lista_de_palavras(lista1, palavras5)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, [[5, 15], [6], [7], [8, 16], [9]]]\n"
     ]
    }
   ],
   "source": [
    "lista2 = [2, ['requer', 'revogacao', 'sentenca', 'extincao', ['execucao', 'processo', 'feito']]]\n",
    "# ('resultado', [2, [[5, 15], [6], [7], [8, 16], [9]]])\n",
    "result2 = _procura_lista_de_palavras(lista2, palavras5)\n",
    "print(result2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2: ['requer revogacao sentenca extincao processo', 1.0]}"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# o classificar deve saber desconsiderar o primeiro resultado e retornar apenas o segundo\n",
    "classifica(texto5, assuntos_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'divida requer extincao processo fundamento art 924 tres cpc requer'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Neste texto, não há pedido de extinção nos termos do artigo 924, II\n",
    "texto6 = 'dívida, requer a extinção do processo com fundamento  no art. 924, III do CPC, requer'\n",
    "normaliza(texto6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifica(texto6, assuntos_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tendo vista liquidacao total debito representado cdas acima indicadas requer fesp procuradora abaixo assinado requer extincao feito fundamento art 924 dois codigo processo civil caso deferida pretensao supra ciente pede deferimento 924\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1: ['requer extincao feito fundamento art 924 dois', 1.5],\n",
       " 3: ['supra ciente', 1.0]}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# no texto original, deve ser encontrado o pedido de extinção por pagamento e o termo de ciência\n",
    "print(texto)\n",
    "classifica(texto, assuntos_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# um texto parecido com o original mas com as palavras em ordem diferente\n",
    "texto1 = '... a procuradora abaixo assinado requer, com fundamento no art. 924, II do CPC, a extinção do processo \\\n",
    "caso deferida pretensao supra ciente. pede deferimento .'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: ['requer fundamento art 924 dois cpc extincao processo', 1.75],\n",
       " 3: ['supra ciente', 1.0]}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifica(texto1, assuntos_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: ['924 dois cpc requer processo extinto', 1.25], 3: ['supra ciente', 1.0]}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# basicamente o mesmo texto, mas recebendo o dicionário e não a lista já preparada\n",
    "texto2 = 'tendo vista liquidacao total debito representado cdas acima indicadas fazenda publica estado sao \\\n",
    "paulo procuradora abaixo assinado com fundamento no art. 924, II do CPC, requer processo extinto \\\n",
    "caso deferida pretensao supra ciente. pede deferimento .'\n",
    "classifica(texto2, assuntos_dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto3 = '''Tendo em vista a LIQUIDAÇÃO TOTAL\n",
    "DO DÉBITO representado pela (s) CDA(s) acima\n",
    "indicada(s), a Fazenda Pública do Estado de São Paulo,\n",
    "por seu (sua) Procurador(a), abaixo assinado (a),\n",
    "requer a extinção do  feito, com fundamento e na forma do artigo\n",
    "924, inciso II, do Código de Processo Civil. \u0013  .'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: ['requer extincao feito fundamento forma art 924 dois', 1.75]}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifica(texto3, assuntos_lista)"
   ]
  },
  {
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}