portugython 0.3.0__tar.gz → 0.4.0__tar.gz

{portugython-0.3.0 → portugython-0.4.0}/CHANGELOG.md

@@ -1,6 +1,59 @@
 # Changelog
 
-## 0.3.0 (2026-06-26)
+## 0.4.0 (2026-06-26)
+
+Add `transpilador` module: a tokenizer-based source transpiler that
+translates Python keywords to Portuguese, enabling fully Portuguese Python syntax.
+
+New module `portugython.transpilador`:
+
+- `traduzir(codigo)` - translates Portuguese Python source to valid Python
+- `traduzir_para_portugues(codigo)` - inverse translation
+- `executar_texto(codigo)` - translate and execute a Portuguese Python string
+- `executar_arquivo(caminho)` - translate and execute a `.ptpy` file
+- `mostrar_traducao(codigo)` - print the translated Python source
+- `MAPA_PALAVRAS_CHAVE` - full keyword translation table
+- `PALAVRAS_RESERVADAS` - frozenset of reserved Portuguese keywords
+
+Keyword translations (34 keywords):
+
+    se       -> if       senaose   -> elif     senao      -> else
+    para     -> for      enquanto  -> while    parar      -> break
+    continuar -> continue passar   -> pass
+    defina   -> def      classe    -> class    retorne    -> return
+    produzca -> yield    anonima   -> lambda
+    importe  -> import   de        -> from     como       -> as
+    tente    -> try      exceto    -> except   finalmente -> finally
+    levante  -> raise    com       -> with
+    nao      -> not      e         -> and      ou         -> or
+    em       -> in       eh        -> is
+    excluir  -> del      afirmar   -> assert
+    global   -> global   naolocal  -> nonlocal
+    assincronico -> async aguardar -> await
+    Verdadeiro -> True   Falso     -> False    Nenhum     -> None
+
+New CLI entry point: `ptpy` runs `.ptpy` files directly:
+
+    ptpy meu_programa.ptpy
+    ptpy -c 'para i em intervalo(3): escreva(i)'
+    ptpy --mostrar meu_programa.ptpy   # show the translated Python
+
+Extended import hook to load `.ptpy` files via the normal import system.
+
+Example `.ptpy` program:
+
+```python
+defina fatorial(n):
+    se n <= 1:
+        retorne 1
+    senao:
+        retorne n * fatorial(n - 1)
+
+para i em intervalo(1, 6):
+    escreva(f"{i}! = {fatorial(i)}")
+```
+
+
 
 Add import hook so all Portuguese module names work as top-level imports.
 

{portugython-0.3.0 → portugython-0.4.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: portugython
-Version: 0.3.0
-Summary: A Portuguese translation of the Python functions/modules/packages
+Version: 0.4.0
+Summary: A Portuguese translation of Python: functions, modules and syntax
 Project-URL: Homepage, https://github.com/spacemany2k38/portugython
 Project-URL: Bug Tracker, https://github.com/spacemany2k38/portugython/issues
 Author: Victor Kolis
@@ -281,6 +281,109 @@ if email.encontrar("contato@example.com"):
 | `filtro(f, it)` | `list(filter(f, it))` |
 | `reduzido(f, it)` | `functools.reduce(f, it)` |
 
+## Transpilador de palavras-chave
+
+Portugython inclui um transpilador completo que traduz a sintaxe do Python
+(palavras-chave) para portugues. Isso permite escrever programas Python
+inteiramente em portugues.
+
+### CLI: ptpy
+
+```bash
+ptpy meu_programa.ptpy               # executa um arquivo .ptpy
+ptpy -c 'para i em intervalo(3): escreva(i)'   # executa inline
+ptpy --mostrar meu_programa.ptpy     # imprime o Python equivalente
+```
+
+### API Python
+
+```python
+from portugython import traduzir, executar_texto, executar_arquivo
+
+# Traduzir uma string
+codigo_pt = """
+defina fatorial(n):
+    se n <= 1:
+        retorne 1
+    senao:
+        retorne n * fatorial(n - 1)
+"""
+print(traduzir(codigo_pt))
+# def fatorial(n):
+#     if n <= 1:
+#         return 1
+#     else:
+#         return n * fatorial(n - 1)
+
+# Executar diretamente
+executar_texto("para i em intervalo(3):\n    escreva(i)")
+
+# Executar um arquivo .ptpy
+executar_arquivo("meu_programa.ptpy")
+```
+
+### Programa completo em portugues (.ptpy)
+
+```python
+# fatorial.ptpy
+importe portugython
+
+defina fatorial(n):
+    se n <= 1:
+        retorne 1
+    senao:
+        retorne n * fatorial(n - 1)
+
+defina verificar_primo(n):
+    se n < 2:
+        retorne Falso
+    para i em intervalo(2, n):
+        se n % i == 0:
+            retorne Falso
+    retorne Verdadeiro
+
+primos = [x para x em intervalo(2, 20) se verificar_primo(x)]
+escreva("Primos:", primos)
+
+para n em intervalo(1, 8):
+    escreva(f"{n}! = {fatorial(n)}")
+
+tente:
+    resultado = 10 / 0
+exceto ZeroDivisionError como err:
+    escreva("Erro capturado:", err)
+finalmente:
+    escreva("Pronto!")
+```
+
+### Tabela de palavras-chave
+
+| Portugues | Python | | Portugues | Python |
+|-----------|--------|-|-----------|--------|
+| `se` | `if` | | `senao` | `else` |
+| `senaose` | `elif` | | `para` | `for` |
+| `enquanto` | `while` | | `parar` | `break` |
+| `continuar` | `continue` | | `passar` | `pass` |
+| `defina` | `def` | | `classe` | `class` |
+| `retorne` | `return` | | `produzca` | `yield` |
+| `anonima` | `lambda` | | `importe` | `import` |
+| `de` | `from` | | `como` | `as` |
+| `tente` | `try` | | `exceto` | `except` |
+| `finalmente` | `finally` | | `levante` | `raise` |
+| `com` | `with` | | `nao` | `not` |
+| `e` | `and` | | `ou` | `or` |
+| `em` | `in` | | `eh` | `is` |
+| `excluir` | `del` | | `afirmar` | `assert` |
+| `global` | `global` | | `naolocal` | `nonlocal` |
+| `assincronico` | `async` | | `aguardar` | `await` |
+| `Verdadeiro` | `True` | | `Falso` | `False` |
+| `Nenhum` | `None` | | | |
+
+> **Nota**: Palavras como `e`, `ou`, `de`, `com` e `em` sao palavras-chave
+> reservadas no contexto de arquivos `.ptpy`. Evite usa-las como nomes de
+> variaveis nesses arquivos, assim como nao se usa `if` ou `for` como
+> variaveis em Python normal.
+
 ## Contribuir
 
 1. Crie um fork deste repositorio

{portugython-0.3.0 → portugython-0.4.0}/README.md

@@ -254,6 +254,109 @@ if email.encontrar("contato@example.com"):
 | `filtro(f, it)` | `list(filter(f, it))` |
 | `reduzido(f, it)` | `functools.reduce(f, it)` |
 
+## Transpilador de palavras-chave
+
+Portugython inclui um transpilador completo que traduz a sintaxe do Python
+(palavras-chave) para portugues. Isso permite escrever programas Python
+inteiramente em portugues.
+
+### CLI: ptpy
+
+```bash
+ptpy meu_programa.ptpy               # executa um arquivo .ptpy
+ptpy -c 'para i em intervalo(3): escreva(i)'   # executa inline
+ptpy --mostrar meu_programa.ptpy     # imprime o Python equivalente
+```
+
+### API Python
+
+```python
+from portugython import traduzir, executar_texto, executar_arquivo
+
+# Traduzir uma string
+codigo_pt = """
+defina fatorial(n):
+    se n <= 1:
+        retorne 1
+    senao:
+        retorne n * fatorial(n - 1)
+"""
+print(traduzir(codigo_pt))
+# def fatorial(n):
+#     if n <= 1:
+#         return 1
+#     else:
+#         return n * fatorial(n - 1)
+
+# Executar diretamente
+executar_texto("para i em intervalo(3):\n    escreva(i)")
+
+# Executar um arquivo .ptpy
+executar_arquivo("meu_programa.ptpy")
+```
+
+### Programa completo em portugues (.ptpy)
+
+```python
+# fatorial.ptpy
+importe portugython
+
+defina fatorial(n):
+    se n <= 1:
+        retorne 1
+    senao:
+        retorne n * fatorial(n - 1)
+
+defina verificar_primo(n):
+    se n < 2:
+        retorne Falso
+    para i em intervalo(2, n):
+        se n % i == 0:
+            retorne Falso
+    retorne Verdadeiro
+
+primos = [x para x em intervalo(2, 20) se verificar_primo(x)]
+escreva("Primos:", primos)
+
+para n em intervalo(1, 8):
+    escreva(f"{n}! = {fatorial(n)}")
+
+tente:
+    resultado = 10 / 0
+exceto ZeroDivisionError como err:
+    escreva("Erro capturado:", err)
+finalmente:
+    escreva("Pronto!")
+```
+
+### Tabela de palavras-chave
+
+| Portugues | Python | | Portugues | Python |
+|-----------|--------|-|-----------|--------|
+| `se` | `if` | | `senao` | `else` |
+| `senaose` | `elif` | | `para` | `for` |
+| `enquanto` | `while` | | `parar` | `break` |
+| `continuar` | `continue` | | `passar` | `pass` |
+| `defina` | `def` | | `classe` | `class` |
+| `retorne` | `return` | | `produzca` | `yield` |
+| `anonima` | `lambda` | | `importe` | `import` |
+| `de` | `from` | | `como` | `as` |
+| `tente` | `try` | | `exceto` | `except` |
+| `finalmente` | `finally` | | `levante` | `raise` |
+| `com` | `with` | | `nao` | `not` |
+| `e` | `and` | | `ou` | `or` |
+| `em` | `in` | | `eh` | `is` |
+| `excluir` | `del` | | `afirmar` | `assert` |
+| `global` | `global` | | `naolocal` | `nonlocal` |
+| `assincronico` | `async` | | `aguardar` | `await` |
+| `Verdadeiro` | `True` | | `Falso` | `False` |
+| `Nenhum` | `None` | | | |
+
+> **Nota**: Palavras como `e`, `ou`, `de`, `com` e `em` sao palavras-chave
+> reservadas no contexto de arquivos `.ptpy`. Evite usa-las como nomes de
+> variaveis nesses arquivos, assim como nao se usa `if` ou `for` como
+> variaveis em Python normal.
+
 ## Contribuir
 
 1. Crie um fork deste repositorio

{portugython-0.3.0 → portugython-0.4.0}/portugython/__init__.py

@@ -9,8 +9,17 @@ from portugython._importador import (
     instalar,
     listar_modulos,
 )
+from portugython.transpilador import (
+    MAPA_PALAVRAS_CHAVE,
+    PALAVRAS_RESERVADAS,
+    executar_arquivo,
+    executar_texto,
+    mostrar_traducao,
+    traduzir,
+    traduzir_para_portugues,
+)
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"
 
 # Instala o gancho de importacao automaticamente
 instalar()
@@ -503,6 +512,14 @@ __all__ = [
     "instalar",
     "desinstalar",
     "listar_modulos",
+    # Transpilador
+    "traduzir",
+    "traduzir_para_portugues",
+    "executar_texto",
+    "executar_arquivo",
+    "mostrar_traducao",
+    "MAPA_PALAVRAS_CHAVE",
+    "PALAVRAS_RESERVADAS",
     # IO
     "escreva",
     "leia",

{portugython-0.3.0 → portugython-0.4.0}/portugython/_importador.py

@@ -5,6 +5,10 @@ Quando ativado, permite usar nomes de modulos em Portugues diretamente:
     import aleatorio
     from matematica import raiz_quadrada
     from colecoes import Contador
+
+Tambem permite importar arquivos .ptpy (Python em Portugues):
+
+    import meu_modulo   # carrega meu_modulo.ptpy se existir
 """
 
 from __future__ import annotations
@@ -12,8 +16,10 @@ from __future__ import annotations
 import importlib
 import importlib.abc
 import importlib.machinery
+import importlib.util
 import sys
-from importlib.machinery import ModuleSpec
+from importlib.machinery import ModuleSpec, SourceFileLoader
+from pathlib import Path
 from typing import Sequence
 
 # Mapeamento de nome em Portugues -> caminho completo do modulo portugython
@@ -106,11 +112,75 @@ class ImportadorPortugues(importlib.abc.MetaPathFinder):
 _gancho = ImportadorPortugues()
 
 
+
+
+def listar_modulos() -> dict[str, str]:
+    """Retorna o mapeamento de nomes em Portugues para modulos portugython.
+
+    Returns:
+        Dicionario com nome_portugues -> caminho_modulo.
+    """
+    return dict(MAPA_MODULOS)
+
+
+# ---------------------------------------------------------------------------
+# Carregador de arquivos .ptpy
+# ---------------------------------------------------------------------------
+
+
+class _CarregadorPtpy(SourceFileLoader):
+    """Carrega arquivos .ptpy transpilando-os para Python antes da execucao."""
+
+    def get_data(self, path: str) -> bytes:
+        """Le o arquivo .ptpy e retorna o codigo Python traduzido como bytes."""
+        from portugython.transpilador import traduzir  # noqa: PLC0415
+
+        codigo_pt = Path(path).read_text(encoding="utf-8")
+        codigo_py = traduzir(codigo_pt)
+        return codigo_py.encode("utf-8")
+
+
+class ImportadorPtpy(importlib.abc.MetaPathFinder):
+    """Importa arquivos .ptpy (Python em Portugues) de qualquer diretorio
+    no sys.path."""
+
+    def find_spec(
+        self,
+        fullname: str,
+        path: Sequence[str] | None,
+        target=None,  # noqa: ANN001
+    ) -> ModuleSpec | None:
+        """Procura um arquivo .ptpy para o modulo solicitado.
+
+        Args:
+            fullname: Nome completo do modulo.
+            path: Caminhos de busca.
+            target: Modulo alvo (ignorado).
+        """
+        diretorios = path if path else sys.path
+        for diretorio in diretorios:
+            candidato = Path(diretorio) / f"{fullname}.ptpy"
+            if candidato.exists():
+                carregador = _CarregadorPtpy(fullname, str(candidato))
+                return ModuleSpec(
+                    fullname,
+                    carregador,
+                    origin=str(candidato),
+                )
+        return None
+
+
+_gancho_ptpy = ImportadorPtpy()
+
+
 def instalar() -> None:
     """Instala o importador de modulos em Portugues no sys.meta_path.
 
-    Apos chamar esta funcao, e possivel importar modulos pelo nome em Portugues:
+    Apos chamar esta funcao:
+    - Modulos portugython sao importaveis pelo nome em Portugues
+    - Arquivos .ptpy sao importaveis via import normal
 
+    Example:
         import aleatorio
         from matematica import raiz_quadrada, PI
         from colecoes import Contador, Pilha
@@ -118,19 +188,13 @@ def instalar() -> None:
     """
     if not any(isinstance(f, ImportadorPortugues) for f in sys.meta_path):
         sys.meta_path.insert(0, _gancho)
+    if not any(isinstance(f, ImportadorPtpy) for f in sys.meta_path):
+        sys.meta_path.append(_gancho_ptpy)
 
 
 def desinstalar() -> None:
     """Remove o importador de modulos em Portugues do sys.meta_path."""
     sys.meta_path[:] = [
-        f for f in sys.meta_path if not isinstance(f, ImportadorPortugues)
+        f for f in sys.meta_path
+        if not isinstance(f, (ImportadorPortugues, ImportadorPtpy))
     ]
-
-
-def listar_modulos() -> dict[str, str]:
-    """Retorna o mapeamento de nomes em Portugues para modulos portugython.
-
-    Returns:
-        Dicionario com nome_portugues -> caminho_modulo.
-    """
-    return dict(MAPA_MODULOS)

portugython-0.4.0/portugython/transpilador.py

@@ -0,0 +1,254 @@
+"""transpilador - converte codigo Python escrito em Portugues para Python padrao.
+
+Uso como modulo:
+
+    from portugython.transpilador import traduzir, executar_texto, executar_arquivo
+    codigo_py = traduzir("se x > 0:\\n    escreva(x)")
+    executar_texto("para i em intervalo(3):\\n    escreva(i)")
+
+Uso como CLI:
+
+    ptpy meu_programa.ptpy
+    ptpy meu_programa.py        # qualquer .py com sintaxe portuguesa
+"""
+
+from __future__ import annotations
+
+import io
+import sys
+import tokenize
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Mapa de palavras-chave: Portugues -> Python
+# ---------------------------------------------------------------------------
+
+MAPA_PALAVRAS_CHAVE: dict[str, str] = {
+    # Controle de fluxo
+    "se": "if",
+    "senao": "else",
+    "senaose": "elif",
+    "para": "for",
+    "enquanto": "while",
+    "parar": "break",
+    "continuar": "continue",
+    "passar": "pass",
+    # Funcoes e classes
+    "defina": "def",
+    "classe": "class",
+    "retorne": "return",
+    "produzca": "yield",
+    "anonima": "lambda",
+    # Importacoes
+    "importe": "import",
+    "de": "from",
+    "como": "as",
+    # Tratamento de erros
+    "tente": "try",
+    "exceto": "except",
+    "finalmente": "finally",
+    "levante": "raise",
+    # Gerenciadores de contexto
+    "com": "with",
+    # Operadores logicos (como funcoes: e/ou/nao ja existem em __init__.py,
+    # mas aqui traduzimos os tokens da sintaxe)
+    "nao": "not",
+    "e": "and",
+    "ou": "or",
+    # Pertencimento e identidade
+    "em": "in",
+    "eh": "is",
+    # Escopo de variaveis
+    "global": "global",
+    "naolocal": "nonlocal",
+    # Outros
+    "excluir": "del",
+    "afirmar": "assert",
+    # Concorrencia
+    "assincronico": "async",
+    "aguardar": "await",
+    # Constantes booleanas e nula
+    "Verdadeiro": "True",
+    "Falso": "False",
+    "Nenhum": "None",
+}
+
+# Mapa inverso (Python -> Portugues) para referencia
+MAPA_INVERSO: dict[str, str] = {v: k for k, v in MAPA_PALAVRAS_CHAVE.items()}
+
+# Palavras reservadas em portugues (nao podem ser nomes de variaveis)
+PALAVRAS_RESERVADAS: frozenset[str] = frozenset(MAPA_PALAVRAS_CHAVE.keys())
+
+# ---------------------------------------------------------------------------
+# Nucleo do transpilador
+# ---------------------------------------------------------------------------
+
+
+def traduzir(codigo: str) -> str:
+    """Traduz codigo Python em Portugues para Python padrao.
+
+    Usa o tokenizador do Python para substituir apenas tokens NAME que
+    correspondem a palavras-chave em Portugues. Strings, comentarios e
+    identificadores compostos (ex: minha_se_variavel) sao intocados.
+
+    Args:
+        codigo: Codigo fonte em Portugues.
+
+    Returns:
+        Codigo fonte Python valido.
+
+    Example:
+        >>> traduzir("se x > 0:\\n    retorne x")
+        'if x > 0:\\n    return x'
+    """
+    tokens_novos: list[tuple] = []
+    try:
+        leitor = io.StringIO(codigo).readline
+        for tok in tokenize.generate_tokens(leitor):
+            tipo, valor, inicio, fim, linha = tok
+            if tipo == tokenize.NAME and valor in MAPA_PALAVRAS_CHAVE:
+                tokens_novos.append(
+                    (tipo, MAPA_PALAVRAS_CHAVE[valor], inicio, fim, linha)
+                )
+            else:
+                tokens_novos.append(tok)
+    except tokenize.TokenError:
+        return codigo
+
+    return tokenize.untokenize(tokens_novos)
+
+
+def traduzir_para_portugues(codigo: str) -> str:
+    """Traduz codigo Python padrao para Python em Portugues.
+
+    Operacao inversa de traduzir().
+
+    Args:
+        codigo: Codigo fonte Python padrao.
+
+    Returns:
+        Codigo fonte em Portugues.
+    """
+    tokens_novos: list[tuple] = []
+    try:
+        leitor = io.StringIO(codigo).readline
+        for tok in tokenize.generate_tokens(leitor):
+            tipo, valor, inicio, fim, linha = tok
+            if tipo == tokenize.NAME and valor in MAPA_INVERSO:
+                tokens_novos.append((tipo, MAPA_INVERSO[valor], inicio, fim, linha))
+            else:
+                tokens_novos.append(tok)
+    except tokenize.TokenError:
+        return codigo
+
+    return tokenize.untokenize(tokens_novos)
+
+
+# ---------------------------------------------------------------------------
+# Execucao
+# ---------------------------------------------------------------------------
+
+
+def executar_texto(
+    codigo: str,
+    globais: dict | None = None,
+    locais: dict | None = None,
+) -> None:
+    """Traduz e executa uma string de codigo em Portugues.
+
+    O ambiente de execucao inclui automaticamente todos os nomes definidos
+    em portugython (escreva, intervalo, Verdadeiro, etc.).
+
+    Args:
+        codigo: Codigo em Portugues a executar.
+        globais: Namespace global adicional. Mesclado com portugython.
+        locais: Namespace local. None usa o global.
+
+    Example:
+        executar_texto("para i em intervalo(3):\\n    escreva(i)")
+    """
+    import portugython  # garante que o hook esta ativo  # noqa: PLC0415
+
+    env: dict = {
+        k: getattr(portugython, k)
+        for k in dir(portugython)
+        if not k.startswith("_")
+    }
+    env["__builtins__"] = __builtins__
+    if globais:
+        env.update(globais)
+    codigo_py = traduzir(codigo)
+    exec(compile(codigo_py, "<portugython>", "exec"), env, locais or env)  # noqa: S102
+
+
+def executar_arquivo(caminho: str | Path) -> None:
+    """Traduz e executa um arquivo .ptpy ou .py em Portugues.
+
+    O ambiente de execucao inclui automaticamente todos os nomes definidos
+    em portugython.
+
+    Args:
+        caminho: Caminho para o arquivo a executar.
+
+    Example:
+        executar_arquivo("meu_programa.ptpy")
+    """
+    import portugython  # garante que o hook esta ativo  # noqa: PLC0415
+
+    caminho = Path(caminho)
+    codigo = caminho.read_text(encoding="utf-8")
+    codigo_py = traduzir(codigo)
+    env: dict = {
+        k: getattr(portugython, k)
+        for k in dir(portugython)
+        if not k.startswith("_")
+    }
+    env["__builtins__"] = __builtins__
+    env["__file__"] = str(caminho)
+    env["__name__"] = "__main__"
+    exec(compile(codigo_py, str(caminho), "exec"), env)  # noqa: S102
+
+
+def mostrar_traducao(codigo: str) -> None:
+    """Imprime o codigo traduzido para Python padrao.
+
+    Util para depuracao e aprendizado.
+
+    Args:
+        codigo: Codigo em Portugues.
+    """
+    print(traduzir(codigo))
+
+
+# ---------------------------------------------------------------------------
+# Entrada de linha de comando: ptpy
+# ---------------------------------------------------------------------------
+
+
+def _main() -> None:
+    """Ponto de entrada do CLI: ptpy <arquivo>."""
+    if len(sys.argv) < 2:
+        print("Uso: ptpy <arquivo.ptpy>")
+        print("     ptpy -c 'codigo em portugues'")
+        sys.exit(1)
+
+    if sys.argv[1] == "-c":
+        if len(sys.argv) < 3:
+            print("ptpy -c requer um argumento de codigo")
+            sys.exit(1)
+        codigo = sys.argv[2]
+        sys.argv = sys.argv[2:]
+        executar_texto(codigo)
+    elif sys.argv[1] == "--mostrar":
+        if len(sys.argv) < 3:
+            print("ptpy --mostrar requer um arquivo")
+            sys.exit(1)
+        codigo = Path(sys.argv[2]).read_text(encoding="utf-8")
+        mostrar_traducao(codigo)
+    else:
+        caminho = Path(sys.argv[1])
+        if not caminho.exists():
+            print(f"Arquivo nao encontrado: {caminho}")
+            sys.exit(1)
+        sys.argv = sys.argv[1:]
+        executar_arquivo(caminho)

{portugython-0.3.0 → portugython-0.4.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "portugython"
-version = "0.3.0"
-description = "A Portuguese translation of the Python functions/modules/packages"
+version = "0.4.0"
+description = "A Portuguese translation of Python: functions, modules and syntax"
 readme = "README.md"
 license = {text = "MIT"}
 requires-python = ">=3.10"
@@ -29,6 +29,9 @@ classifiers = [
 Homepage = "https://github.com/spacemany2k38/portugython"
 "Bug Tracker" = "https://github.com/spacemany2k38/portugython/issues"
 
+[project.scripts]
+ptpy = "portugython.transpilador:_main"
+
 [project.optional-dependencies]
 dev = ["pytest", "ruff"]
 

portugython-0.4.0/tests/ola_mundo.ptpy

@@ -0,0 +1,38 @@
+# Programa de exemplo em portugues usando sintaxe traduzida
+importe portugython
+
+de aleatorio importe escolha, inteiro_aleatorio
+
+defina saudacao(nome):
+    retorne "Ola, " + nome + "!"
+
+defina calcular_fatorial(n):
+    se n <= 1:
+        retorne 1
+    senao:
+        retorne n * calcular_fatorial(n - 1)
+
+nomes = ["Alice", "Bob", "Carlos", "Diana"]
+nome_escolhido = escolha(nomes)
+mensagem = saudacao(nome_escolhido)
+
+para i em intervalo(1, 6):
+    fato = calcular_fatorial(i)
+    escreva(f"{i}! = {fato}")
+
+numero = inteiro_aleatorio(1, 10)
+se numero > 5:
+    escreva("Grande:", numero)
+senaose numero == 5:
+    escreva("Exato cinco!")
+senao:
+    escreva("Pequeno:", numero)
+
+frutas = ["manga", "abacaxi", "goiaba", "caju"]
+maiusculas = [fruta.upper() para fruta em frutas]
+escreva(maiusculas)
+
+contador = 0
+enquanto contador < 3:
+    escreva("Contando:", contador)
+    contador = contador + 1

{portugython-0.3.0 → portugython-0.4.0}/tests/test_portugython.py

@@ -33,7 +33,7 @@ from portugython import (
 
 def test_version():
     """Testa a versao do pacote."""
-    assert __version__ == "0.3.0"
+    assert __version__ == "0.4.0"
 
 
 def test_type_functions():

portugython-0.4.0/tests/test_transpilador.py

@@ -0,0 +1,310 @@
+"""Testes para o transpilador de palavras-chave em Portugues."""
+
+from __future__ import annotations
+
+import textwrap
+
+from portugython.transpilador import (
+    MAPA_PALAVRAS_CHAVE,
+    PALAVRAS_RESERVADAS,
+    executar_texto,
+    mostrar_traducao,
+    traduzir,
+    traduzir_para_portugues,
+)
+
+# ---------------------------------------------------------------------------
+# Testes de traducao de palavras-chave individuais
+# ---------------------------------------------------------------------------
+
+
+def test_se_para_if():
+    resultado = traduzir("se x > 0: passar")
+    assert "if" in resultado
+    assert "pass" in resultado
+    assert "se" not in resultado.split()
+
+
+def test_senao_para_else():
+    codigo = "se x:\n    passar\nsenao:\n    passar"
+    resultado = traduzir(codigo)
+    assert "else" in resultado
+    assert "pass" in resultado
+
+
+def test_senaose_para_elif():
+    codigo = "se x > 0:\n    passar\nsenaose x == 0:\n    passar"
+    resultado = traduzir(codigo)
+    assert "elif" in resultado
+
+
+def test_para_para_for():
+    resultado = traduzir("para i em intervalo(10): passar")
+    assert "for" in resultado
+    assert "in" in resultado
+    assert "pass" in resultado
+    # intervalo e um alias de funcao (nao palavra-chave), permanece intacto
+    assert "intervalo" in resultado
+
+
+def test_enquanto_para_while():
+    resultado = traduzir("enquanto Verdadeiro: parar")
+    assert "while" in resultado
+    assert "True" in resultado
+    assert "break" in resultado
+
+
+def test_defina_para_def():
+    resultado = traduzir("defina minha_funcao(): passar")
+    assert "def" in resultado
+    assert "pass" in resultado
+
+
+def test_classe_para_class():
+    resultado = traduzir("classe MinhaClasse: passar")
+    assert "class" in resultado
+
+
+def test_retorne_para_return():
+    resultado = traduzir("defina f(): retorne 42")
+    assert "return" in resultado
+
+
+def test_importe_para_import():
+    resultado = traduzir("importe os")
+    assert "import os" in resultado
+
+
+def test_de_importe_para_from_import():
+    resultado = traduzir("de os importe path")
+    assert "from os import path" in resultado
+
+
+def test_como_para_as():
+    resultado = traduzir("importe os como sistema_op")
+    assert "as sistema_op" in resultado
+
+
+def test_tente_exceto_finalmente():
+    codigo = textwrap.dedent("""
+        tente:
+            passar
+        exceto ValueError:
+            passar
+        finalmente:
+            passar
+    """)
+    resultado = traduzir(codigo)
+    assert "try" in resultado
+    assert "except" in resultado
+    assert "finally" in resultado
+
+
+def test_levante_para_raise():
+    resultado = traduzir("levante ValueError('erro')")
+    assert "raise" in resultado
+
+
+def test_com_como_para_with_as():
+    resultado = traduzir("com abrir('f') como arq: passar")
+    assert "with" in resultado
+    assert "as" in resultado
+
+
+def test_produzca_para_yield():
+    resultado = traduzir("defina gen():\n    produzca 1")
+    assert "yield" in resultado
+
+
+def test_nao_ou_e():
+    resultado = traduzir("se nao x ou y e z: passar")
+    assert "not" in resultado
+    assert "or" in resultado
+    assert "and" in resultado
+
+
+def test_eh_para_is():
+    resultado = traduzir("se x eh Nenhum: passar")
+    assert "is" in resultado
+    assert "None" in resultado
+
+
+def test_excluir_para_del():
+    resultado = traduzir("excluir minha_var")
+    assert "del" in resultado
+
+
+def test_afirmar_para_assert():
+    resultado = traduzir("afirmar x > 0")
+    assert "assert" in resultado
+
+
+def test_global_e_naolocal():
+    codigo = "defina f():\n    global x\n    naolocal y"
+    resultado = traduzir(codigo)
+    assert "global" in resultado
+    assert "nonlocal" in resultado
+
+
+def test_assincronico_aguardar():
+    codigo = "assincronico defina buscar():\n    aguardar algo()"
+    resultado = traduzir(codigo)
+    assert "async def" in resultado
+    assert "await" in resultado
+
+
+def test_verdadeiro_falso_nenhum():
+    resultado = traduzir("x = Verdadeiro\ny = Falso\nz = Nenhum")
+    assert "True" in resultado
+    assert "False" in resultado
+    assert "None" in resultado
+
+
+def test_parar_continuar_passar():
+    codigo = textwrap.dedent("""
+        para i em intervalo(10):
+            se i == 5: parar
+            se i == 3: continuar
+            passar
+    """)
+    resultado = traduzir(codigo)
+    assert "break" in resultado
+    assert "continue" in resultado
+    assert "pass" in resultado
+
+
+# ---------------------------------------------------------------------------
+# Testes de preservacao de strings e comentarios
+# ---------------------------------------------------------------------------
+
+
+def test_strings_nao_sao_traduzidas():
+    codigo = 'x = "para se enquanto defina"'
+    resultado = traduzir(codigo)
+    assert '"para se enquanto defina"' in resultado
+
+
+def test_comentarios_nao_sao_traduzidos():
+    codigo = "# para se enquanto\nx = 1"
+    resultado = traduzir(codigo)
+    assert "# para se enquanto" in resultado
+
+
+def test_identificadores_compostos_preservados():
+    codigo = "minha_para_funcao = 1\nresultado_se_positivo = 2"
+    resultado = traduzir(codigo)
+    assert "minha_para_funcao" in resultado
+    assert "resultado_se_positivo" in resultado
+
+
+# ---------------------------------------------------------------------------
+# Testes de execucao
+# ---------------------------------------------------------------------------
+
+
+def test_executar_texto_basico(capsys):
+    executar_texto("escreva('ola mundo')")
+    saida = capsys.readouterr().out
+    assert "ola mundo" in saida
+
+
+def test_executar_texto_com_se(capsys):
+    executar_texto("x = 10\nse x > 5:\n    escreva('grande')")
+    saida = capsys.readouterr().out
+    assert "grande" in saida
+
+
+def test_executar_texto_para_loop(capsys):
+    executar_texto("para i em intervalo(3):\n    escreva(i)")
+    saida = capsys.readouterr().out
+    assert "0" in saida
+    assert "1" in saida
+    assert "2" in saida
+
+
+def test_executar_texto_defina_funcao(capsys):
+    codigo = textwrap.dedent("""
+        defina quadrado(n):
+            retorne n * n
+        escreva(quadrado(4))
+    """)
+    executar_texto(codigo)
+    saida = capsys.readouterr().out
+    assert "16" in saida
+
+
+def test_executar_texto_tente_exceto(capsys):
+    codigo = textwrap.dedent("""
+        tente:
+            levante ValueError("teste")
+        exceto ValueError como err:
+            escreva("capturado:", err)
+    """)
+    executar_texto(codigo)
+    saida = capsys.readouterr().out
+    assert "capturado" in saida
+
+
+def test_executar_texto_enquanto_loop(capsys):
+    codigo = "i = 0\nenquanto i < 3:\n    escreva(i)\n    i = i + 1"
+    executar_texto(codigo)
+    saida = capsys.readouterr().out
+    assert "0" in saida
+    assert "2" in saida
+
+
+def test_executar_texto_lista_compreensao(capsys):
+    codigo = "resultado = [x * 2 para x em intervalo(4)]\nescreva(resultado)"
+    executar_texto(codigo)
+    saida = capsys.readouterr().out
+    assert "[0, 2, 4, 6]" in saida
+
+
+# ---------------------------------------------------------------------------
+# Testes do mapa e palavras reservadas
+# ---------------------------------------------------------------------------
+
+
+def test_mapa_palavras_chave_nao_vazio():
+    assert len(MAPA_PALAVRAS_CHAVE) > 20
+
+
+def test_palavras_reservadas_sao_frozenset():
+    assert isinstance(PALAVRAS_RESERVADAS, frozenset)
+
+
+def test_palavras_reservadas_contem_palavras_chave():
+    for pt in MAPA_PALAVRAS_CHAVE:
+        assert pt in PALAVRAS_RESERVADAS
+
+
+def test_traducao_inversa(capsys):
+    codigo_python = "if x > 0:\n    return x"
+    codigo_pt = traduzir_para_portugues(codigo_python)
+    assert "se" in codigo_pt
+    assert "retorne" in codigo_pt
+
+
+def test_mostrar_traducao(capsys):
+    mostrar_traducao("se x: passar")
+    saida = capsys.readouterr().out
+    assert "if" in saida
+    assert "pass" in saida
+
+
+# ---------------------------------------------------------------------------
+# Testes do arquivo .ptpy
+# ---------------------------------------------------------------------------
+
+
+def test_executar_arquivo_ptpy(tmp_path, capsys):
+    arquivo = tmp_path / "teste.ptpy"
+    arquivo.write_text(
+        "defina ola(nome):\n    retorne 'Ola, ' + nome\nescreva(ola('mundo'))",
+        encoding="utf-8",
+    )
+    from portugython.transpilador import executar_arquivo
+
+    executar_arquivo(arquivo)
+    saida = capsys.readouterr().out
+    assert "Ola, mundo" in saida