EG_22_23_(interno).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8CIDIqz_Ar4S"
      },
      "source": [
        "#Engenharia Gramatical\n",
        "\n",
        "Ano Letivo 22/23\n",
        "\n",
        "Autor Tiago Baptista"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DqkKXFuZ9ACz"
      },
      "source": [
        "# Aula 2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o_zLT4OM9Ei_"
      },
      "source": [
        "## Sumário\n",
        "\n",
        "\n",
        "\n",
        "1.   O que é o lark ?\n",
        "2.   Principais características\n",
        "  - construções automáticas\n",
        "  - ferramentas de visualização\n",
        "  - suporte de ebnf\n",
        "4.   lexer em lark\n",
        "5.   Introdução aos transformers\n",
        "\n",
        "## Notas\n",
        "[lark cheatsheet](https://lark-parser.readthedocs.io/en/latest/_static/lark_cheatsheet.pdf)\n",
        "\n",
        "[Documentação](https://lark-parser.readthedocs.io)\n",
        "\n",
        "[lark common](https://github.com/lark-parser/lark/blob/master/lark/grammars/common.lark)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fiWId7-1AzGS"
      },
      "source": [
        "### Demo introdução a lark e Tranformers"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "giMyXurz6MHJ"
      },
      "source": [
        "####Exercício 1\n",
        "Escreva uma gramática independente de contexto para definir uma lista possivelmente vazia de números inteiros separados por vírgulas.\n",
        "\n",
        "Deve importar o módulo **Lark** para gerar um parser que ao reconhecer uma frase gere a respetiva árvore de parsing.\n",
        "\n",
        "Use a função de *pretty print* do módulo *Lark* para imprimir a árvore construida.\n",
        "\n",
        "Nesta primeira versão não se pretende que faça nenhuma travessia à árvore, \n",
        "mas em contrapartida pretende-se que escreva várias versões da GIC para usar extended-BNF (uso de operadores para descrever repetições) e para usar apenas BNF (uso de recursividade par descrever repetições). \n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "O2r-Md3eA3lP"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Defaulting to user installation because normal site-packages is not writeable\n",
            "Requirement already satisfied: lark in /home/miyagi/.local/lib/python3.10/site-packages (1.1.5)\n",
            "start\n",
            "  [\n",
            "  elemento\n",
            "    1\n",
            "    ,\n",
            "    23\n",
            "    ,\n",
            "    345\n",
            "  ]\n",
            "\n",
            "pe\n",
            "[\n",
            "numero\n",
            "1\n",
            "vir\n",
            ",\n",
            "numero\n",
            "23\n",
            "vir\n",
            ",\n",
            "numero\n",
            "345\n",
            "elemento soma\n",
            "369\n",
            "pd\n",
            "]\n",
            "start\n"
          ]
        }
      ],
      "source": [
        "from lark import Lark,Token\n",
        "from lark.tree import pydot__tree_to_png\n",
        "from lark import Transformer\n",
        "from lark import Discard\n",
        "\n",
        "grammar1 = '''\n",
        "//Regras Sintaticas\n",
        "start: PE ( | elementos) PD\n",
        "elementos : NUMERO (VIR NUMERO)*\n",
        "// elemento : NUMERO \n",
        "//Regras Lexicográficas\n",
        "NUMERO:\"0\"..\"9\"+ // [0-9]+\n",
        "PE:\"[\"\n",
        "PD:\"]\"\n",
        "VIR:\",\"\n",
        "//Tratamento dos espaços em branco\n",
        "%import common.WS\n",
        "%ignore WS\n",
        "'''\n",
        "grammar5 = '''\n",
        "//Regras Sintaticas\n",
        "start: PE ( |elemento (VIR elemento)*) PD\n",
        "elemento : NUMERO \n",
        "//Regras Lexicograficas\n",
        "NUMERO:\"0\"..\"9\"+\n",
        "PE:\"[\"\n",
        "PD:\"]\"\n",
        "VIR:\",\"\n",
        "//Tratamento dos espaços em branco\n",
        "%import common.WS\n",
        "%ignore WS\n",
        "'''\n",
        "\n",
        "grammar2 = '''\n",
        "//Regras Sintaticas\n",
        "start: PE elementos PD\n",
        "elementos: elemento VIR elementos\n",
        "        |\n",
        "elemento : NUMERO \n",
        "//Regras Lexicograficas\n",
        "NUMERO:\"0\"..\"9\"+\n",
        "PE:\"[\"\n",
        "PD:\"]\"\n",
        "VIR:\",\"\n",
        "//Tratamento dos espaços em branco\n",
        "%import common.WS\n",
        "%ignore WS\n",
        "'''\n",
        "\n",
        "grammar3 = '''\n",
        "//Regras Sintaticas\n",
        "start: PE elementos PD\n",
        "elementos: elementos VIR elemento\n",
        "        |\n",
        "elemento : NUMERO \n",
        "//Regras Lexicograficas\n",
        "NUMERO:\"0\"..\"9\"+\n",
        "PE:\"[\"\n",
        "PD:\"]\"\n",
        "VIR:\",\"\n",
        "//Tratamento dos espaços em branco\n",
        "%import common.WS\n",
        "%ignore WS\n",
        "'''\n",
        "\n",
        "grammar4 = '''\n",
        "//Regras Sintaticas\n",
        "start: PE ( |elementos) PD\n",
        "elementos: elemento VIR elementos\n",
        "         | elemento\n",
        "elemento : NUMERO \n",
        "//Regras Lexicograficas\n",
        "NUMERO:\"0\"..\"9\"+\n",
        "PE:\"[\"\n",
        "PD:\"]\"\n",
        "VIR:\",\"\n",
        "//Tratamento dos espaços em branco\n",
        "%import common.WS\n",
        "%ignore WS\n",
        "'''\n",
        "\n",
        "grammar = '''\n",
        "//Regras Sintaticas\n",
        "start: PE elemento* PD\n",
        "elemento : NUMERO (VIR NUMERO)*\n",
        "//Regras Lexicográficas\n",
        "NUMERO:\"0\"..\"9\"+ \n",
        "PE:\"[\"\n",
        "PD:\"]\"\n",
        "VIR:\",\"\n",
        "//Tratamento dos espaços em branco\n",
        "%import common.WS\n",
        "%ignore WS\n",
        "'''\n",
        "# Soma da lista, encontrar o maior da lista\n",
        "class ExemploTransformer(Transformer):\n",
        "  def start(self,elementos):\n",
        "    print(\"start\")\n",
        "    \n",
        "  def elemento(self,elemento):\n",
        "    print(\"elemento soma\")\n",
        "    print(sum(elemento))\n",
        "    \n",
        "  def NUMERO (self,numero):\n",
        "    print(\"numero\")\n",
        "    print(numero)\n",
        "    return int(numero)\n",
        "    \n",
        "  def PE(self,pe):\n",
        "    print(\"pe\")\n",
        "    print(pe)\n",
        "    return str(pe)\n",
        "\n",
        "  def PD(self,pd):\n",
        "    print(\"pd\")\n",
        "    print(pd)\n",
        "    return str(pd)\n",
        "\n",
        "  def VIR(self,vir):\n",
        "    print(\"vir\")\n",
        "    print(vir)\n",
        "    return Discard\n",
        "\n",
        "  pass\n",
        "\n",
        "frase = \"[1,23,345]\"\n",
        "\n",
        "p = Lark(grammar)   #não muito bem\n",
        "#p = Lark(grammar1)  #recomendada\n",
        "#p = Lark(grammar5)  #boa\n",
        "#p = Lark(grammar2)  #incorreta\n",
        "#p = Lark(grammar3)  #incorreta\n",
        "#p = Lark(grammar4)   #aceitável\n",
        "\n",
        "tree = p.parse(frase)\n",
        "print(tree.pretty())\n",
        "#for element in tree.children:\n",
        "  #print(element)\n",
        "\n",
        "\n",
        "data = ExemploTransformer().transform(tree) # chamar o transformer para obter\n",
        "#print(data)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Alc40If0_eHK"
      },
      "source": [
        "####Exercício 2\n",
        "Retome uma das GIC escrita em extended-BNF para definir uma linguagem que permita escrever uma lista possívelmente vazia de números inteiros separados por vírgulas,\n",
        "mas agora use o respetivo Transformer e escreva funções para visitar os nodos da árvore de parsing e escrever o conteúdo de cada uma.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "f8yz_AY8T4v2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "start\n",
            "  [\n",
            "  elemento\n",
            "    primeiro\t1\n",
            "    resto\n",
            "      ,\n",
            "      2\n",
            "      ,\n",
            "      3\n",
            "  ]\n",
            "\n",
            "[\n",
            "1\n",
            ",\n",
            "2\n",
            ",\n",
            "3\n",
            "[Tree(Token('RULE', 'primeiro'), [None]), Tree(Token('RULE', 'resto'), [None, None, None, None])]\n",
            "]\n",
            "raiz\n",
            "{}\n"
          ]
        }
      ],
      "source": [
        "from lark import Lark\n",
        "from lark.tree import pydot__tree_to_png\n",
        "from lark import Transformer\n",
        "from lark import Discard\n",
        "\n",
        "class MyTransformer(Transformer):\n",
        "    def start(self, items):\n",
        "        output={}\n",
        "        #output[\"elementos\"] = items[1]\n",
        "        #soma = sum(items[1])\n",
        "        #output[\"soma\"] = soma\n",
        "        print(\"raiz\")\n",
        "        return (output)\n",
        "\n",
        "    def elemento(self, elemento):\n",
        "        print(elemento)\n",
        "        #r = list(filter(lambda x: x!=',', elemento))\n",
        "        #return r\n",
        "\n",
        "    def VIR(self,op):\n",
        "        print(str(op))\n",
        "        #return Discard\n",
        "\n",
        "    def NUMERO(self,numero):\n",
        "        print(str(numero))\n",
        "\n",
        "    def PE(self,pe):\n",
        "        print(str(pe))\n",
        "\n",
        "    def PD(self,pd):\n",
        "        print(str(pd))\n",
        "\n",
        "## Primeiro precisamos da GIC\n",
        "grammar = '''\n",
        "start: PE elemento* PD\n",
        "elemento : primeiro resto \n",
        "primeiro : NUMERO\n",
        "resto : (VIR NUMERO)*\n",
        "NUMERO:\"0\"..\"9\"+\n",
        "PE:\"[\"\n",
        "PD:\"]\"\n",
        "VIR:\",\"\n",
        "\n",
        "%import common.WS\n",
        "%ignore WS\n",
        "'''\n",
        "\n",
        "frase = \"[1,2,3]\"\n",
        "p = Lark(grammar)\n",
        "\n",
        "parse_tree = p.parse(frase)\n",
        "print(parse_tree.pretty())\n",
        "\n",
        "data = MyTransformer().transform(parse_tree)\n",
        "print(data)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Is0lNlERDGJL"
      },
      "source": [
        "#### Exercício 3\n",
        "\n",
        "\n",
        "Desenvolva uma GIC para definir uma linguagem que permita escrever listas\n",
        "mistas de números e palavras, de tal forma que as 3 frases abaixo sejam frases\n",
        "válidas dessa linguagem:\n",
        "\n",
        "LISTA 1 .\n",
        "\n",
        "Lista aaa .\n",
        "\n",
        "Lista 1, 2, agora, 3, 4, fim, 7, 8.\n",
        "\n",
        "Resolva as seguintes alíneas recorrendo ao uso de Transformer :\n",
        "\n",
        "(a) Calcule, retorne e imprima quantos elementos existem numa lista.\n",
        "\n",
        "(b) Identifique, retorne e imprima o elemento que mais se repete numa lista.\n",
        "\n",
        "(c) Calcule, retorne e imprima a soma de todos os números que se encontrem entre as palavras\n",
        "agora e fim de uma lista.\n",
        "\n",
        "(d) Verifique se uma lista é válida de acordo com os seguintes parâmetros :\n",
        "\n",
        "- Caso a palavra \"agora\" ocorra então a palavra \"fim\" também tem de aparecer posteriormente na lista e o contrário também.\n",
        "- Entre \"agora\" e \"fim\" tem de aparecer pelo menos um número.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hQutjx-sQy9b"
      },
      "source": [
        "# Aula 3 e 4"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QOoO4XExQ3b-"
      },
      "source": [
        "## Exercícios"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QP2mrOUdQ61z"
      },
      "source": [
        "Exercício 1\n",
        "\n",
        "###### Nota : Abertura de ficheiros (caminho collab) : /content/sample_data\n",
        "\n",
        "\n",
        "Desenvolva uma GIC para definir uma linguagem que permita descrever os\n",
        "alunos (identificados pelo seu nome) de uma turma específica, de tal forma\n",
        "que a frase abaixo seja uma frase válida dessa linguagem (ignore os \\n):\n",
        "```\n",
        "TURMA A\n",
        "ana (12, 13, 15, 12, 13, 15, 14);\n",
        "joao (9,7,3,6,9);\n",
        "xico (12,16).\n",
        "TURMA B\n",
        "ana (12, 13, 15, 12, 13, 15, 14); \n",
        "joao (9,7,3,6,9,12);\n",
        "xico (12,16).\n",
        "```\n",
        "Recorrendo ao uso de lark Transformer :\n",
        "\n",
        "1.1 Conte e imprima o número de alunos presentes, retornando o valor regra de start.\n",
        "\n",
        "1.2 Calcule e imprima a média de cada aluno,  retornando o valor regra de start.\n",
        "\n",
        "1.3 Organize os dados de maneira a que a cada nota corresponda os alunos que\n",
        "tiraram essa nota, retornando o valor regra de start. Exemplo : ```{'12': {'joao', 'xico', 'ana'}, '13': {'ana'}, '15': {'ana'}, '14': {'ana'}, '9': {'joao'}, '7': {'joao'}, '3': {'joao'}, '6': {'joao'}, '16': {'xico'}}\n",
        "```\n",
        "\n",
        "1.4 Crie uma query INSERT em SQL que insira as notas de cada alunos numa\n",
        "tabela Resultado, com as seguintes colunas : nomeAluno, nota,\n",
        "dataInsercao, turma. (Nota: Garanta que não existem nomes repetidos dentro da mesma turma). Considere que o campo nota pode ser um array com as notas de cada aluno\n",
        "\n",
        "1.5 Crie um ficheiro markdown para visualizacao das alineas acima.\n",
        "Exemplo para a turma A:\n",
        "\n",
        "~~~\n",
        "# Visualizador de turmas\n",
        "## Turma A\n",
        "### Lista de alunos \n",
        "- Ana\n",
        "- Joao\n",
        "- Xico\n",
        "### Notas\n",
        "\n",
        "| Aluno | Media |\n",
        "|  --------  |  -------  |\n",
        "| Ana | 13 \n",
        "| Joao | 6 |\n",
        "| Xico | 4 |\n",
        "\n",
        "~~~\n",
        "\n",
        "1.6 Crie um ficheiro html para visualizacao das alineas acima. Exemplo :\n",
        "http://tpcg.io/_7FLIBV \n",
        "\n",
        "\n",
        "<h1>Turma A<code><br /></code></h1>\n",
        "<table style=\"border-collapse: collapse; width: 100%; height: 81px;\" border=\"1\">\n",
        "<tbody>\n",
        "<tr style=\"height: 18px;\">\n",
        "<td style=\"width: 10%; height: 18px; text-align: center;\">Nome</td>\n",
        "<td style=\"width: 10%; height: 18px; text-align: center;\">Nota1</td>\n",
        "<td style=\"width: 10%; height: 18px; text-align: center;\">Nota2</td>\n",
        "<td style=\"width: 10%; height: 18px; text-align: center;\">Nota3</td>\n",
        "<td style=\"width: 10%; height: 18px; text-align: center;\">Nota4</td>\n",
        "<td style=\"width: 10%; height: 18px; text-align: center;\">Nota5</td>\n",
        "<td style=\"width: 10%; height: 18px; text-align: center;\">Nota6</td>\n",
        "<td style=\"width: 10%; height: 18px; text-align: center;\">Nota7</td>\n",
        "<td style=\"width: 10%; height: 18px; text-align: center;\">M&eacute;dia</td>\n",
        "<td style=\"width: 10%; height: 18px; text-align: center;\">&nbsp;</td>\n",
        "</tr>\n",
        "<tr style=\"height: 21px;\">\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">ana</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">12</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">13</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">15</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">12</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">13</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">15</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">14</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\"><span id=\"cwos\" class=\"qv3Wpe\">13</span></td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\"><img src=\"https://html-online.com/editor/tiny4_9_11/plugins/emoticons/img/smiley-embarassed.gif\" alt=\"embarassed\" /></td>\n",
        "</tr>\n",
        "<tr style=\"height: 21px;\">\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">joao</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">9</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">7</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">3</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">6</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">9</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">-</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">-</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">6</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\"><img src=\"https://html-online.com/editor/tiny4_9_11/plugins/emoticons/img/smiley-cry.gif\" alt=\"cry\" /></td>\n",
        "</tr>\n",
        "<tr style=\"height: 21px;\">\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">xico</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">12</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">16</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">-</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">-</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">-</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">-</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">-</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\">4</td>\n",
        "<td style=\"width: 10%; text-align: center; height: 21px;\"><img src=\"https://html-online.com/editor/tiny4_9_11/plugins/emoticons/img/smiley-cry.gif\" alt=\"cry\" /></td>\n",
        "</tr>\n",
        "</tbody>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bqHkmhY8kmdS"
      },
      "source": [
        "# Aula 5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZdYZS3Bfl77Y"
      },
      "source": [
        "Funçoes sobre Tree :\n",
        "- .children\n",
        "- .data \n",
        "- visit\n",
        "- visit_children\n",
        "\n",
        "Funções sobre Token :\n",
        "- .type\n",
        "- .value"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NBtzmqOXkpVe"
      },
      "source": [
        "## Interpreter para análise"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eRs1_BKwktPl",
        "outputId": "d188972d-280e-41b3-e561-cc7eeeb8eda1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: lark in /usr/local/lib/python3.9/dist-packages (1.1.5)\n",
            "Entrei na Raiz, vou visitar os Elementos\n",
            "elementos\n",
            "  elemento\t10\n",
            "  vir\t,\n",
            "  elemento\tpala\n",
            "  vir\t,\n",
            "  elemento\t1\n",
            "  vir\t,\n",
            "  elemento\t2\n",
            "  vir\t,\n",
            "  elemento\t3\n",
            "  vir\t,\n",
            "  elemento\ta\n",
            "  vir\t,\n",
            "  elemento\t4\n",
            "  vir\t,\n",
            "  elemento\toutra\n",
            "  vir\t,\n",
            "  elemento\t\"A\"\n",
            "\n",
            "elemento [Token('NUMERO', '10')]\n",
            "elemento [Token('PALAVRA', 'pala')]\n",
            "elemento [Token('NUMERO', '1')]\n",
            "elemento [Token('NUMERO', '2')]\n",
            "elemento [Token('NUMERO', '3')]\n",
            "elemento [Token('PALAVRA', 'a')]\n",
            "elemento [Token('NUMERO', '4')]\n",
            "elemento [Token('PALAVRA', 'outra')]\n",
            "elemento [Token('ASPAS', '\"A\"')]\n",
            "Tree(Token('RULE', 'elemento'), [Token('NUMERO', '10')])\n",
            "Este filho adiciono porque é 1 Elemento\n",
            "elemento [Token('NUMERO', '10')]\n",
            "Tree(Token('RULE', 'vir'), [Token('VIR', ',')])\n",
            "Tree(Token('RULE', 'elemento'), [Token('PALAVRA', 'pala')])\n",
            "Este filho adiciono porque é 1 Elemento\n",
            "elemento [Token('PALAVRA', 'pala')]\n",
            "Tree(Token('RULE', 'vir'), [Token('VIR', ',')])\n",
            "Tree(Token('RULE', 'elemento'), [Token('NUMERO', '1')])\n",
            "Este filho adiciono porque é 1 Elemento\n",
            "elemento [Token('NUMERO', '1')]\n",
            "Tree(Token('RULE', 'vir'), [Token('VIR', ',')])\n",
            "Tree(Token('RULE', 'elemento'), [Token('NUMERO', '2')])\n",
            "Este filho adiciono porque é 1 Elemento\n",
            "elemento [Token('NUMERO', '2')]\n",
            "Tree(Token('RULE', 'vir'), [Token('VIR', ',')])\n",
            "Tree(Token('RULE', 'elemento'), [Token('NUMERO', '3')])\n",
            "Este filho adiciono porque é 1 Elemento\n",
            "elemento [Token('NUMERO', '3')]\n",
            "Tree(Token('RULE', 'vir'), [Token('VIR', ',')])\n",
            "Tree(Token('RULE', 'elemento'), [Token('PALAVRA', 'a')])\n",
            "Este filho adiciono porque é 1 Elemento\n",
            "elemento [Token('PALAVRA', 'a')]\n",
            "Tree(Token('RULE', 'vir'), [Token('VIR', ',')])\n",
            "Tree(Token('RULE', 'elemento'), [Token('NUMERO', '4')])\n",
            "Este filho adiciono porque é 1 Elemento\n",
            "elemento [Token('NUMERO', '4')]\n",
            "Tree(Token('RULE', 'vir'), [Token('VIR', ',')])\n",
            "Tree(Token('RULE', 'elemento'), [Token('PALAVRA', 'outra')])\n",
            "Este filho adiciono porque é 1 Elemento\n",
            "elemento [Token('PALAVRA', 'outra')]\n",
            "Tree(Token('RULE', 'vir'), [Token('VIR', ',')])\n",
            "Tree(Token('RULE', 'elemento'), [Token('ASPAS', '\"A\"')])\n",
            "Este filho adiciono porque é 1 Elemento\n",
            "elemento [Token('ASPAS', '\"A\"')]\n",
            "Elementos visitados, vou regressar à main()\n",
            "Número de número  10  Somatório:  20\n"
          ]
        }
      ],
      "source": [
        "from lark import Discard\n",
        "from lark import Lark,Token,Tree\n",
        "from lark.tree import pydot__tree_to_png\n",
        "from lark.visitors import Interpreter\n",
        "\n",
        "class MyInterpreter(Interpreter):\n",
        "    def __init__(self):\n",
        "        self.comprimento = 0\n",
        "        self.soma = 0\n",
        "\n",
        "\n",
        "    def start(self, tree):\n",
        "        print(\"Entrei na Raiz, vou visitar os Elementos\")\n",
        "        r = self.visit(tree.children[1])\n",
        "        print(\"Elementos visitados, vou regressar à main()\")\n",
        "        return (self.comprimento, r)\n",
        "\n",
        "    def elementos(self, tree):\n",
        "        print(tree.pretty())\n",
        "        #print(tree)\n",
        "        r = self.visit_children(tree)\n",
        "        #print(\"Agora vou visitar cada Elemento\")\n",
        "        r=0\n",
        "        for elemento in tree.children:\n",
        "          print(elemento)\n",
        "          if (elemento.data == 'elemento' and type(elemento)==Tree):\n",
        "            print(\"Este filho adiciono porque é 1 Elemento\")\n",
        "            r += self.visit(elemento)\n",
        "        return r\n",
        "        \n",
        "\n",
        "    def elemento(self, tree):\n",
        "        r = self.visit_children(tree)\n",
        "        print(\"elemento\",r)\n",
        "        if(r[0].type=='NUMERO'):\n",
        "          self.comprimento += 1\n",
        "          return int(r[0])\n",
        "        else:\n",
        "          return 0\n",
        "  \n",
        "\n",
        "    def vir(self, tree):\n",
        "      pass\n",
        "\n",
        "    \n",
        "## Primeiro precisamos da GIC\n",
        "grammar = '''\n",
        "start: PE elementos PD\n",
        "elementos : elemento (vir elemento)*\n",
        "vir : VIR\n",
        "elemento : NUMERO | PALAVRA |ASPAS\n",
        "NUMERO:\"0\"..\"9\"+ \n",
        "ASPAS: ESCAPED_STRING\n",
        "PALAVRA:(\"A\"..\"Z\"|\"a\"..\"z\")+\n",
        "PE:\"[\"\n",
        "PD:\"]\"\n",
        "VIR:\",\"\n",
        "\n",
        "%import common.WS\n",
        "%import common.ESCAPED_STRING\n",
        "%ignore WS\n",
        "'''\n",
        "\n",
        "#frase = \"[a,1,2,3,a,4]\"\n",
        "frase = \"[10,pala,1,2,3,a,4,outra,\\\"A\\\"]\"\n",
        "p = Lark(grammar)\n",
        "parse_tree = p.parse(frase)\n",
        "\n",
        "data = MyInterpreter().visit(parse_tree)\n",
        "print(\"Número de número \",data[0],\" Somatório: \",data[1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K4cMngaRma0C"
      },
      "source": [
        "# Exercícios"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M37LGHzumkX6"
      },
      "source": [
        "Refazer o exercício das turmas utilizando lark Interpreter"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mYXooQMlMF9b",
        "outputId": "96757a88-6fe9-48f7-b14f-11d83c3de350"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting lark\n",
            "  Using cached lark-1.1.5-py3-none-any.whl (107 kB)\n",
            "Installing collected packages: lark\n",
            "Successfully installed lark-1.1.5\n",
            "TURMA A\n",
            "Visitar os alunos\n",
            "Visitar o aluno ana\n",
            "Visitar o aluno ze\n",
            "Visitar o aluno rui\n",
            "TURMA PL\n",
            "Visitar os alunos\n",
            "Visitar o aluno zeca\n",
            "Visitar o aluno rita\n",
            "TURMA EG\n",
            "Visitar os alunos\n",
            "Visitar o aluno rosa\n",
            "raiz {'A': ['ana', 'ze', 'rui'], 'PL': ['zeca', 'rita'], 'EG': ['rosa']}\n",
            "Res {'A': ['ana', 'ze', 'rui'], 'PL': ['zeca', 'rita'], 'EG': ['rosa']}\n"
          ]
        }
      ],
      "source": [
        "!pip install lark\n",
        "from lark import Discard\n",
        "from lark import Lark,Token,Tree\n",
        "from lark.tree import pydot__tree_to_png\n",
        "from lark.visitors import Interpreter\n",
        "\n",
        "class MyInterpreter(Interpreter):\n",
        "  def turmas(self,listaTurmas):\n",
        "    #start: turma+\n",
        "    self.turmasDic = {}\n",
        "    for turma in listaTurmas.children:\n",
        "      self.visit(turma)\n",
        "    print(\"raiz\",self.turmasDic)\n",
        "    return(self.turmasDic)\n",
        "\n",
        "  def turma(self,turma): \n",
        "    #turma : (\"TURMA\" MAIUSCULA+ alunos PONTO)\n",
        "    for elemento in turma.children:\n",
        "      if (type(elemento) == Tree):\n",
        "        print(\"TURMA\",turma.children[0])\n",
        "        alunos = self.visit(elemento)\n",
        "        self.turmasDic[turma.children[0].value]=alunos\n",
        "  \n",
        "  def alunos(self,alunos):\n",
        "    #alunos: aluno (PONTOVIRGULA aluno)*\n",
        "    print(\"Visitar os alunos\")\n",
        "    alunosList = []\n",
        "    # Visitar todos os alunos\n",
        "    for element in alunos.children:\n",
        "      # So visitamos os tipo tree que sao os alunos\n",
        "      if (type(element) == Tree and element.data == \"aluno\"):\n",
        "        aluno = self.visit(element)\n",
        "        alunosList.append(aluno)\n",
        "    return alunosList\n",
        "\n",
        "  def aluno(self,aluno):\n",
        "    #aluno: NOME \"(\" notas \")\"\n",
        "    print(\"Visitar o aluno\",aluno.children[0])\n",
        "    return aluno.children[0].value\n",
        "\n",
        "grammar = '''\n",
        "turmas: turma+\n",
        "turma : (\"TURMA\" MAIUSCULAS alunos PONTO)\n",
        "alunos: aluno (PONTOVIRGULA aluno)*\n",
        "aluno: NOME \"(\" notas \")\"\n",
        "notas: NUMERO ( \",\" NUMERO)*\n",
        "MAIUSCULAS:(\"A\"..\"Z\")+\n",
        "NOME: (\"A\"..\"Z\"|\"a\"..\"z\")+\n",
        "NUMERO:\"0\"..\"9\"+\n",
        "PONTO:\".\"\n",
        "PONTOVIRGULA:\";\"\n",
        "%import common.WS\n",
        "%ignore WS\n",
        "'''\n",
        "\n",
        "# Definir o texto-fonte (input) a analisar\n",
        "#frase = \"TURMA A ana (12, 13, 15, 12, 13, 15, 14); joao (9,7,3,6,9,12); xico (12,16).TURMA B lucas (12, 13, 15, 12, 13, 15, 14); joana (9,7,3,6,9,12); xica (12,16).\"\n",
        "frase = \"TURMA A ana (1,2,3); ze (2,4);rui(12). TURMA PL zeca(2); rita(2,4,6). TURMA EG rosa (10,11,12,13).\"\n",
        "\n",
        "# Inicializar o objeto lark\n",
        "p = Lark(grammar,start=\"turmas\")\n",
        "# Criar a parsing tree\n",
        "parse_tree = p.parse(frase)\n",
        "# Utilizar o Interpreter para visitar a parsing tree\n",
        "ptnova=MyInterpreter().visit(parse_tree)\n",
        "\n",
        "print(\"Res\",ptnova)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ySjCaHkdnpLL"
      },
      "source": [
        "# Aula 6"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rdyi9oLAPhik"
      },
      "source": [
        "## Exercício\n",
        "\n",
        "1 - Transforme a seguinte GIC em notação lark :\n",
        "```\n",
        " T  = { '[', ']', STRING, DATA, FICH }\n",
        "         P = {\n",
        "         p1: album  : capa \"[\" pags \"]\" ccapa\n",
        "         p2: capa   : titulo autor DATA\n",
        "         p3: titulo : STRING\n",
        "         p4: autor  : STRING\n",
        "         p5: ccapa  : fecho DATA\n",
        "         p6: fecho  : STRING\n",
        "         p7: pags   : pag+\n",
        "         p8: pag    : sep | folha\n",
        "         p9: sep    : titulo\n",
        "         p10: folha : foto+\n",
        "         p11: foto  : FICH legenda\n",
        "         p12: legenda : STRING\n",
        "```\n",
        "Considere a seguinte frase de exemplo válida :\n",
        "```\n",
        "        \"Um passeio pelo Geres\" \n",
        "        Joaozinho \n",
        "        03-04-2000 \n",
        "        [ \n",
        "          \"Cascata do tahiti\"\n",
        "          img1\n",
        "          \"Vista da cascata.\"\n",
        "           \n",
        "          \"A aldeia de Soajo\"\n",
        "          img2 \n",
        "          \"casa da aldeia.\"\n",
        "        ] \n",
        "        \"Dedicado à família\" \n",
        "        03-05-2000\n",
        "```\n",
        "2 - Imprimir o album para latex, considerando :\n",
        "\n",
        "  -  que o titulo deverá ser um \\title ;\n",
        "  -  que o autor deverá ser um \\author ;\n",
        "  -  cada página deverá ser um \\title e terminar com o \\newpage ;\n",
        "  - uma foto devera usar o nome do ficheiro para renderizar e a legenda como \\caption.Exemplo :\n",
        "  ```\n",
        "\\begin{figure}[h!]\n",
        "\\centering\n",
        "\\includegraphics[width=0.3\\textwidth]{frog.jpg}\n",
        "\\caption{\\label{fig:frog}Vista da cascata.}\n",
        "\\end{figure}\n",
        "```\n",
        "\n",
        "3 - Extender a linguagem para permitir que uma folha possa também ter texto descritivo do momento retratado na foto.\n",
        "\n",
        "4 - Atualizar a impressão do livro para latex."
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.10.10"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}