portugython 0.4.1__tar.gz → 0.5.0__tar.gz

{portugython-0.4.1 → portugython-0.5.0}/CHANGELOG.md

@@ -1,6 +1,37 @@
 # Changelog
 
-## 0.4.1 (2026-06-26)
+## 0.5.0 (2026-06-26)
+
+Adiciona **codec de fonte `portugues`**: a forma mais natural de escrever Python em português.
+
+Adicione `# -*- coding: portugues -*-` ao topo de qualquer arquivo `.py` e escreva
+Python com palavras-chave em português diretamente. Não é necessária nenhuma ferramenta
+extra além do Python padrão.
+
+Exemplo completo:
+
+```python
+# -*- coding: portugues -*-
+de chaves importe *
+
+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)}")
+```
+
+Novos módulos:
+
+- `portugython._codec`: codec `portugues` que traduz palavras-chave antes do parse;
+  registrado automaticamente via `portugython-codec.pth` ao instalar.
+- `portugython.chaves`: re-exporta todos os identificadores em português do
+  portugython para uso com `from chaves import *`.
+
+
 
 Corrige acentuação em toda a documentação (README, CHANGELOG, docstrings).
 Sem alterações na API ou no código.

{portugython-0.4.1 → portugython-0.5.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: portugython
-Version: 0.4.1
-Summary: A Portuguese translation of Python: functions, modules and syntax
+Version: 0.5.0
+Summary: Escreva Python em Português: codec de sintaxe, módulos e funções traduzidos
 Project-URL: Homepage, https://github.com/spacemany2k38/portugython
 Project-URL: Bug Tracker, https://github.com/spacemany2k38/portugython/issues
 Author: Victor Kolis
@@ -31,7 +31,7 @@ Description-Content-Type: text/markdown
 [![Python versions](https://img.shields.io/pypi/pyversions/portugython.svg)](https://pypi.org/project/portugython/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Escreva Python em Português. Portugython traduz funções, tipos e módulos da biblioteca padrão do Python para nomes em português.
+Escreva Python em Português. Portugython traduz funções, tipos e módulos da biblioteca padrão do Python para nomes em português, e inclui um **codec de sintaxe** que permite escrever palavras-chave (`se`, `para`, `defina`, etc.) nativamente em qualquer arquivo `.py`.
 
 ## Instalação
 
@@ -39,7 +39,59 @@ Escreva Python em Português. Portugython traduz funções, tipos e módulos da
 pip install portugython
 ```
 
-## Uso básico
+O codec é registrado automaticamente ao instalar. Basta adicionar `# -*- coding: portugues -*-` ao topo do arquivo.
+
+## Uso: Python em Português nativo
+
+```python
+# -*- coding: portugues -*-
+de chaves importe *
+
+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, 6):
+    escreva(f"{n}! = {fatorial(n)}")
+
+tente:
+    resultado = 10 / 0
+exceto ZeroDivisionError como err:
+    escreva("Erro capturado:", err)
+finalmente:
+    escreva("Pronto!")
+```
+
+Salve como `programa.py` e execute com `python programa.py`. Nenhuma ferramenta extra necessária.
+
+> **Nota sobre palavras ambíguas**: `e`, `ou`, `de`, `com`, `em` são palavras-chave
+> reservadas em arquivos com `# -*- coding: portugues -*-`. Evite usá-las como
+> nomes de variáveis (use `err` em vez de `e` para exceções, por exemplo).
+
+## Como funciona
+
+O codec `portugues` é registrado automaticamente via `portugython-codec.pth` ao instalar
+o pacote. Quando Python encontra `# -*- coding: portugues -*-`, chama o codec para
+decodificar o arquivo antes de parsear, traduzindo palavras-chave em português para
+Python padrão de forma transparente.
+
+O módulo `chaves` exporta todos os aliases de funções em português (`escreva`, `leia`,
+`intervalo`, `tamanho`, `Lista`, `Dicionario`, etc.) para uso direto via `from chaves import *`.
+
+## Uso básico sem codec
 
 ```python
 from portugython import *
@@ -281,84 +333,28 @@ if email.encontrar("contato@example.com"):
 | `filtro(f, it)` | `list(filter(f, it))` |
 | `reduzido(f, it)` | `functools.reduce(f, it)` |
 
-## Transpilador de palavras-chave
+## Transpilador (API programática)
 
-Portugython inclui um transpilador completo que traduz a sintaxe do Python
-(palavras-chave) para português. Isso permite escrever programas Python
-inteiramente em português.
-
-### 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
+Além do codec, `portugython.transpilador` expõe funções para tradução programática:
 
 ```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)
+# Ver o Python equivalente
+print(traduzir("se x > 0:\n    retorne x"))
+# if x > 0:
+#     return x
 
 # Executar diretamente
 executar_texto("para i em intervalo(3):\n    escreva(i)")
 
 # Executar um arquivo .ptpy
-executar_arquivo("meu_programa.ptpy")
+executar_arquivo("programa.ptpy")
 ```
 
-### Programa completo em português (.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
 
-### Tabela de palavras-chave
 
-| Português | Python | | Português | Python |
 |-----------|--------|-|-----------|--------|
 | `se` | `if` | | `senao` | `else` |
 | `senaose` | `elif` | | `para` | `for` |

{portugython-0.4.1 → portugython-0.5.0}/README.md

@@ -4,7 +4,7 @@
 [![Python versions](https://img.shields.io/pypi/pyversions/portugython.svg)](https://pypi.org/project/portugython/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Escreva Python em Português. Portugython traduz funções, tipos e módulos da biblioteca padrão do Python para nomes em português.
+Escreva Python em Português. Portugython traduz funções, tipos e módulos da biblioteca padrão do Python para nomes em português, e inclui um **codec de sintaxe** que permite escrever palavras-chave (`se`, `para`, `defina`, etc.) nativamente em qualquer arquivo `.py`.
 
 ## Instalação
 
@@ -12,7 +12,59 @@ Escreva Python em Português. Portugython traduz funções, tipos e módulos da
 pip install portugython
 ```
 
-## Uso básico
+O codec é registrado automaticamente ao instalar. Basta adicionar `# -*- coding: portugues -*-` ao topo do arquivo.
+
+## Uso: Python em Português nativo
+
+```python
+# -*- coding: portugues -*-
+de chaves importe *
+
+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, 6):
+    escreva(f"{n}! = {fatorial(n)}")
+
+tente:
+    resultado = 10 / 0
+exceto ZeroDivisionError como err:
+    escreva("Erro capturado:", err)
+finalmente:
+    escreva("Pronto!")
+```
+
+Salve como `programa.py` e execute com `python programa.py`. Nenhuma ferramenta extra necessária.
+
+> **Nota sobre palavras ambíguas**: `e`, `ou`, `de`, `com`, `em` são palavras-chave
+> reservadas em arquivos com `# -*- coding: portugues -*-`. Evite usá-las como
+> nomes de variáveis (use `err` em vez de `e` para exceções, por exemplo).
+
+## Como funciona
+
+O codec `portugues` é registrado automaticamente via `portugython-codec.pth` ao instalar
+o pacote. Quando Python encontra `# -*- coding: portugues -*-`, chama o codec para
+decodificar o arquivo antes de parsear, traduzindo palavras-chave em português para
+Python padrão de forma transparente.
+
+O módulo `chaves` exporta todos os aliases de funções em português (`escreva`, `leia`,
+`intervalo`, `tamanho`, `Lista`, `Dicionario`, etc.) para uso direto via `from chaves import *`.
+
+## Uso básico sem codec
 
 ```python
 from portugython import *
@@ -254,84 +306,28 @@ if email.encontrar("contato@example.com"):
 | `filtro(f, it)` | `list(filter(f, it))` |
 | `reduzido(f, it)` | `functools.reduce(f, it)` |
 
-## Transpilador de palavras-chave
+## Transpilador (API programática)
 
-Portugython inclui um transpilador completo que traduz a sintaxe do Python
-(palavras-chave) para português. Isso permite escrever programas Python
-inteiramente em português.
-
-### 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
+Além do codec, `portugython.transpilador` expõe funções para tradução programática:
 
 ```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)
+# Ver o Python equivalente
+print(traduzir("se x > 0:\n    retorne x"))
+# if x > 0:
+#     return x
 
 # Executar diretamente
 executar_texto("para i em intervalo(3):\n    escreva(i)")
 
 # Executar um arquivo .ptpy
-executar_arquivo("meu_programa.ptpy")
+executar_arquivo("programa.ptpy")
 ```
 
-### Programa completo em português (.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
 
-### Tabela de palavras-chave
 
-| Português | Python | | Português | Python |
 |-----------|--------|-|-----------|--------|
 | `se` | `if` | | `senao` | `else` |
 | `senaose` | `elif` | | `para` | `for` |

{portugython-0.4.1 → portugython-0.5.0}/portugython/__init__.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from functools import reduce as _reduce
 
+import portugython._codec  # registra o codec 'portugues' automaticamente  # noqa: F401
 from portugython._importador import (
     desinstalar,
     instalar,
@@ -19,7 +20,7 @@ from portugython.transpilador import (
     traduzir_para_portugues,
 )
 
-__version__ = "0.4.1"
+__version__ = "0.5.0"
 
 # Instala o gancho de importação automaticamente
 instalar()

portugython-0.5.0/portugython/_codec.py

@@ -0,0 +1,99 @@
+"""_codec - codec 'portugues' que habilita sintaxe Python em português.
+
+Quando registrado, qualquer arquivo com:
+
+    # -*- coding: portugues -*-
+
+pode usar palavras-chave em português diretamente. Python chama este codec
+para decodificar o código-fonte antes de parsear, então a tradução é
+transparente para o interpretador.
+
+O codec é registrado automaticamente ao importar portugython, e também
+via o arquivo portugython-codec.pth instalado em site-packages (que
+registra o codec ao iniciar o Python, antes de qualquer código do usuário).
+"""
+
+from __future__ import annotations
+
+import codecs
+import encodings.utf_8
+
+
+def _decode(input_bytes: bytes, errors: str = "strict") -> tuple[str, int]:
+    """Decodifica bytes de fonte Python em português para Python padrão.
+
+    Chamado pelo Python quando encontra '# -*- coding: portugues -*-'.
+
+    Args:
+        input_bytes: Bytes do arquivo-fonte.
+        errors: Política de tratamento de erros de encoding.
+
+    Returns:
+        Tupla (código_python_str, bytes_consumidos).
+    """
+    from portugython.transpilador import traduzir  # noqa: PLC0415
+
+    fonte = input_bytes.decode("utf-8", errors)
+    return traduzir(fonte), len(input_bytes)
+
+
+class _DecodificadorIncremental(codecs.BufferedIncrementalDecoder):
+    """Decodificador incremental necessário pela interface de codecs."""
+
+    def _buffer_decode(
+        self, entrada: bytes, erros: str, final: bool
+    ) -> tuple[str, int]:
+        return _decode(entrada, erros)
+
+
+class _LeitorFluxo(codecs.StreamReader):
+    """Leitor de fluxo necessário pela interface de codecs."""
+
+    def decode(self, entrada: bytes, erros: str = "strict") -> tuple[str, int]:
+        return _decode(entrada, erros)
+
+
+_CODEC_INFO = codecs.CodecInfo(
+    name="portugues",
+    encode=encodings.utf_8.encode,
+    decode=_decode,
+    incrementaldecoder=_DecodificadorIncremental,
+    streamreader=_LeitorFluxo,
+)
+
+_NOMES_CODEC: frozenset[str] = frozenset(
+    ("portugues", "portugues_br", "pt_br", "português", "português_br")
+)
+
+
+def _buscar_codec(nome: str) -> codecs.CodecInfo | None:
+    """Função de busca registrada no sistema de codecs do Python.
+
+    Args:
+        nome: Nome do codec solicitado pelo Python.
+
+    Returns:
+        CodecInfo se o nome for 'portugues', None caso contrário.
+    """
+    if nome.replace("-", "_").lower() in _NOMES_CODEC:
+        return _CODEC_INFO
+    return None
+
+
+def registrar() -> None:
+    """Registra o codec 'portugues' no sistema de codecs do Python.
+
+    Após registrar, arquivos com '# -*- coding: portugues -*-'
+    podem usar palavras-chave em português nativamente.
+
+    Chamado automaticamente ao importar portugython e pelo arquivo
+    portugython-codec.pth no arranque do Python.
+
+    Example:
+        from portugython._codec import registrar
+        registrar()
+    """
+    codecs.register(_buscar_codec)
+
+
+registrar()

{portugython-0.4.1 → portugython-0.5.0}/portugython/_importador.py

@@ -69,6 +69,8 @@ MAPA_MODULOS: dict[str, str] = {
     "estrutura": "portugython.estrutura",
     "depuracao": "portugython.depuracao",
     "csv_pt": "portugython.csv_pt",
+    # Namespace principal em português
+    "chaves": "portugython.chaves",
 }
 
 

portugython-0.5.0/portugython/chaves.py

@@ -0,0 +1,31 @@
+"""chaves - exporta todos os identificadores em português do portugython.
+
+Uso típico junto com o codec 'portugues':
+
+    # -*- coding: portugues -*-
+    de chaves importe *
+
+    se 4 > 5:
+        passe
+    senao:
+        escreva("correto!")
+
+    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)}")
+
+Também pode ser importado com a sintaxe Python padrão:
+
+    # -*- coding: portugues -*-
+    from chaves import *
+"""
+
+from portugython import *  # noqa: F401, F403
+from portugython import __all__  # noqa: F401
+
+__all__ = list(__all__)

portugython-0.5.0/portugython-codec.pth

@@ -0,0 +1 @@
+import portugython._codec

{portugython-0.4.1 → portugython-0.5.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "portugython"
-version = "0.4.1"
-description = "A Portuguese translation of Python: functions, modules and syntax"
+version = "0.5.0"
+description = "Escreva Python em Português: codec de sintaxe, módulos e funções traduzidos"
 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"
 
+[tool.hatch.build.targets.wheel]
+force-include = {"portugython-codec.pth" = "portugython-codec.pth"}
+
 [project.scripts]
 ptpy = "portugython.transpilador:_main"
 

portugython-0.5.0/tests/exemplo_codec.ptpy

@@ -0,0 +1,22 @@
+# -*- coding: portugues -*-
+de chaves importe *
+
+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
+
+resultados = []
+para n em intervalo(1, 6):
+    resultados.adicione(fatorial(n))
+
+primos = [x para x em intervalo(2, 20) se verificar_primo(x)]

portugython-0.5.0/tests/test_codec.py

@@ -0,0 +1,245 @@
+"""Testes para o codec 'portugues' e o módulo chaves."""
+
+from __future__ import annotations
+
+import codecs
+import sys
+import textwrap
+
+# ---------------------------------------------------------------------------
+# Testes do codec
+# ---------------------------------------------------------------------------
+
+
+def test_codec_registrado():
+    """O codec 'portugues' deve estar disponível após importar portugython."""
+    import portugython  # noqa: F401
+
+    info = codecs.lookup("portugues")
+    assert info.name == "portugues"
+
+
+def test_codec_decodifica_se():
+    info = codecs.lookup("portugues")
+    codigo = b"se x > 0: passar"
+    resultado, _ = info.decode(codigo)
+    assert "if" in resultado
+    assert "pass" in resultado
+
+
+def test_codec_decodifica_para():
+    info = codecs.lookup("portugues")
+    codigo = b"para i em intervalo(3): passar"
+    resultado, _ = info.decode(codigo)
+    assert "for" in resultado
+    assert "in" in resultado
+    assert "pass" in resultado
+
+
+def test_codec_decodifica_defina_retorne():
+    info = codecs.lookup("portugues")
+    codigo = b"defina f(x):\n    retorne x * 2"
+    resultado, _ = info.decode(codigo)
+    assert "def f(x):" in resultado
+    assert "return x * 2" in resultado
+
+
+def test_codec_preserva_strings():
+    info = codecs.lookup("portugues")
+    codigo = b'x = "se para enquanto defina"'
+    resultado, _ = info.decode(codigo)
+    assert '"se para enquanto defina"' in resultado
+
+
+def test_codec_preserva_comentarios():
+    info = codecs.lookup("portugues")
+    codigo = b"# se para enquanto\nx = 1"
+    resultado, _ = info.decode(codigo)
+    assert "# se para enquanto" in resultado
+
+
+def test_codec_encode_utf8():
+    """Encode deve ser UTF-8 normal (sem transformação)."""
+    info = codecs.lookup("portugues")
+    texto = "olá mundo"
+    codificado, _ = info.encode(texto)
+    assert codificado == texto.encode("utf-8")
+
+
+# ---------------------------------------------------------------------------
+# Testes do módulo chaves
+# ---------------------------------------------------------------------------
+
+
+def test_chaves_importavel():
+    from chaves import Falso, Nenhum, Verdadeiro, escreva, intervalo  # noqa: F401
+
+    assert escreva is print
+    assert intervalo is range
+    assert Verdadeiro is True
+    assert Falso is False
+    assert Nenhum is None
+
+
+def test_chaves_tem_all():
+    import chaves
+
+    assert hasattr(chaves, "__all__")
+    assert len(chaves.__all__) > 20
+
+
+def test_chaves_escreva(capsys):
+    from chaves import escreva
+
+    escreva("olá do chaves")
+    assert "olá do chaves" in capsys.readouterr().out
+
+
+def test_chaves_lista_classe():
+    from chaves import Lista, tamanho
+
+    lista = Lista([1, 2, 3])
+    lista.adicione(4)
+    assert tamanho(lista) == 4
+
+
+def test_chaves_tamanho():
+    from chaves import tamanho
+
+    assert tamanho([1, 2, 3]) == 3
+    assert tamanho("abc") == 3
+
+
+# ---------------------------------------------------------------------------
+# Testes de execução com codec via arquivo .ptpy
+# ---------------------------------------------------------------------------
+
+
+def test_arquivo_ptpy_com_declaracao_codec(tmp_path, capsys):
+    """Arquivo com # -*- coding: portugues -*- é executado com palavras-chave em PT."""
+    arquivo = tmp_path / "teste.ptpy"
+    arquivo.write_text(
+        textwrap.dedent("""
+            # -*- coding: portugues -*-
+            de chaves importe *
+
+            defina quadrado(n):
+                retorne n * n
+
+            para i em intervalo(1, 4):
+                escreva(quadrado(i))
+        """).strip(),
+        encoding="utf-8",
+    )
+
+    from portugython.transpilador import executar_arquivo
+
+    executar_arquivo(arquivo)
+    saida = capsys.readouterr().out
+    assert "1" in saida
+    assert "4" in saida
+    assert "9" in saida
+
+
+def test_ptpy_se_senao(tmp_path, capsys):
+    arquivo = tmp_path / "cond.ptpy"
+    arquivo.write_text(
+        textwrap.dedent("""
+            # -*- coding: portugues -*-
+            de chaves importe *
+
+            x = 10
+            se x > 5:
+                escreva("grande")
+            senaose x == 5:
+                escreva("exato")
+            senao:
+                escreva("pequeno")
+        """).strip(),
+        encoding="utf-8",
+    )
+    from portugython.transpilador import executar_arquivo
+
+    executar_arquivo(arquivo)
+    assert "grande" in capsys.readouterr().out
+
+
+def test_ptpy_tente_exceto(tmp_path, capsys):
+    arquivo = tmp_path / "erro.ptpy"
+    arquivo.write_text(
+        textwrap.dedent("""
+            # -*- coding: portugues -*-
+            de chaves importe *
+
+            tente:
+                levante ValueError("teste")
+            exceto ValueError como err:
+                escreva("capturado:", err)
+            finalmente:
+                escreva("pronto")
+        """).strip(),
+        encoding="utf-8",
+    )
+    from portugython.transpilador import executar_arquivo
+
+    executar_arquivo(arquivo)
+    saida = capsys.readouterr().out
+    assert "capturado" in saida
+    assert "pronto" in saida
+
+
+def test_ptpy_enquanto(tmp_path, capsys):
+    arquivo = tmp_path / "loop.ptpy"
+    arquivo.write_text(
+        textwrap.dedent("""
+            # -*- coding: portugues -*-
+            de chaves importe *
+
+            i = 0
+            enquanto i < 3:
+                escreva(i)
+                i = i + 1
+        """).strip(),
+        encoding="utf-8",
+    )
+    from portugython.transpilador import executar_arquivo
+
+    executar_arquivo(arquivo)
+    saida = capsys.readouterr().out
+    assert "0" in saida
+    assert "2" in saida
+
+
+# ---------------------------------------------------------------------------
+# Testes de importação via hook (.ptpy como módulo)
+# ---------------------------------------------------------------------------
+
+
+def test_importar_modulo_ptpy(tmp_path):
+    """Módulos .ptpy podem ser importados via import normal com o hook ativo."""
+    import portugython  # garante hook ativo  # noqa: F401
+
+    modulo_py = tmp_path / "meu_modulo.ptpy"
+    modulo_py.write_text(
+        textwrap.dedent("""
+            de chaves importe *
+
+            defina dobrar(x):
+                retorne x * 2
+
+            VALOR = dobrar(21)
+        """).strip(),
+        encoding="utf-8",
+    )
+
+    sys.path.insert(0, str(tmp_path))
+    try:
+        if "meu_modulo" in sys.modules:
+            del sys.modules["meu_modulo"]
+        import meu_modulo  # noqa: PLC0415
+
+        assert meu_modulo.VALOR == 42
+        assert meu_modulo.dobrar(5) == 10
+    finally:
+        sys.path.remove(str(tmp_path))
+        sys.modules.pop("meu_modulo", None)

{portugython-0.4.1 → portugython-0.5.0}/tests/test_portugython.py

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