portugython 0.4.0__tar.gz → 0.5.0__tar.gz

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

@@ -1,21 +1,58 @@
 # Changelog
 
-## 0.4.0 (2026-06-26)
+## 0.5.0 (2026-06-26)
 
-Add `transpilador` module: a tokenizer-based source transpiler that
-translates Python keywords to Portuguese, enabling fully Portuguese Python syntax.
+Adiciona **codec de fonte `portugues`**: a forma mais natural de escrever Python em português.
 
-New module `portugython.transpilador`:
+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.
 
-- `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
+Exemplo completo:
 
-Keyword translations (34 keywords):
+```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.
+
+
+
+Adiciona módulo `transpilador`: transpilador de código-fonte baseado no tokenizador do
+Python que traduz palavras-chave para português, permitindo sintaxe Python completamente
+em português.
+
+Novo módulo `portugython.transpilador`:
+
+- `traduzir(codigo)` - traduz código Python em português para Python padrão
+- `traduzir_para_portugues(codigo)` - tradução inversa
+- `executar_texto(codigo)` - traduz e executa uma string de código em português
+- `executar_arquivo(caminho)` - traduz e executa um arquivo `.ptpy`
+- `mostrar_traducao(codigo)` - imprime o código Python equivalente
+- `MAPA_PALAVRAS_CHAVE` - tabela completa de tradução de palavras-chave
+- `PALAVRAS_RESERVADAS` - frozenset de palavras-chave reservadas em português
+
+Traduções de palavras-chave (34 palavras):
 
     se       -> if       senaose   -> elif     senao      -> else
     para     -> for      enquanto  -> while    parar      -> break
@@ -32,15 +69,15 @@ Keyword translations (34 keywords):
     assincronico -> async aguardar -> await
     Verdadeiro -> True   Falso     -> False    Nenhum     -> None
 
-New CLI entry point: `ptpy` runs `.ptpy` files directly:
+Novo ponto de entrada CLI: `ptpy` executa arquivos `.ptpy` diretamente:
 
     ptpy meu_programa.ptpy
     ptpy -c 'para i em intervalo(3): escreva(i)'
-    ptpy --mostrar meu_programa.ptpy   # show the translated Python
+    ptpy --mostrar meu_programa.ptpy   # exibe o Python equivalente
 
-Extended import hook to load `.ptpy` files via the normal import system.
+Hook de importação estendido para carregar arquivos `.ptpy` pelo sistema de importação normal.
 
-Example `.ptpy` program:
+Exemplo de programa `.ptpy`:
 
 ```python
 defina fatorial(n):
@@ -53,11 +90,12 @@ para i em intervalo(1, 6):
     escreva(f"{i}! = {fatorial(i)}")
 ```
 
+## 0.3.0 (2026-06-26)
 
+Adiciona hook de importação para que todos os módulos em português funcionem como
+importações de nível superior.
 
-Add import hook so all Portuguese module names work as top-level imports.
-
-After `import portugython`, the full stdlib-level syntax works:
+Após `import portugython`, a sintaxe completa em nível de stdlib funciona:
 
     import aleatorio
     from matematica import raiz_quadrada, PI
@@ -67,25 +105,26 @@ After `import portugython`, the full stdlib-level syntax works:
     from dados import serializar, deserializar     # json
     from subprocesso import executar
     from caminho import Caminho
-    # ... all 36 modules
+    # ... todos os 36 módulos
 
-New exports:
+Novos exports:
 - `portugython.instalar()` - instala o gancho (chamado automaticamente)
 - `portugython.desinstalar()` - remove o gancho
 - `portugython.listar_modulos()` - retorna o mapa de nomes
 
+## 0.2.0 (2026-06-26)
 
+Cobertura completa da stdlib. 36 submódulos no total, todos importáveis via
+`from portugython import <modulo>`:
 
-Full stdlib coverage. 36 submodules total, all importable via `from portugython import <modulo>`:
-
-**New in 0.2.0:**
+**Novos em 0.2.0:**
 - `caminho` (pathlib): Caminho com existe, eh_arquivo, listar, ler_texto, escrever_texto, etc.
 - `json`: serializar, deserializar, serializar_arquivo, deserializar_arquivo
 - `estatistica` (statistics): media, mediana, moda, desvio_padrao, covariancia, correlacao, quantis
 - `enumeracao` (enum): Enumeracao, EnumeracaoInteira, EnumeracaoBandeira, automatico, unico
 - `classe_dados` (dataclasses): classe_dados, campo, para_dicionario, para_tupla, substituir
 - `contexto` (contextlib): gerenciador, suprimir, fechar_ao_sair, pilha_saida
-- `tipagem` (typing): re-exporta todos os tipos com nomes em Portugues
+- `tipagem` (typing): re-exporta todos os tipos com nomes em português
 - `csv_pt` (csv): ler_csv, escrever_csv, LeitorCSV, EscritorCSV, LeitorDicionario
 - `registro` (logging): obter_registrador, configurar_registro, depurar, informar, avisar, erro
 - `argumentos` (argparse): AnalisadorArgumentos com adicionar_argumento, analisar
@@ -108,14 +147,13 @@ Full stdlib coverage. 36 submodules total, all importable via `from portugython
 - `estrutura` (struct): empacotar, desempacotar, calcular_tamanho
 - `rede` (urllib + http): baixar_url, abrir_url, analisar_url, codificar_url, codificar_parametros
 
-Also in 0.2.0:
-- Fix: renamed builtin `identificador` alias to `obter_id` to avoid shadowing the uuid submodule
-- 49 tests covering all modules
-
+Também em 0.2.0:
+- Correção: alias de builtin `identificador` renomeado para `obter_id` para evitar shadowing do submódulo uuid
+- 49 testes cobrindo todos os módulos
 
 ## 0.1.0 (2026-06-26)
 
-- Add full stdlib submodule set with Portuguese translations:
+- Adiciona conjunto completo de submódulos da stdlib com traduções em português:
   - `aleatorio` (random): escolha, embaralhe, amostra, gauss, normal, etc.
   - `matematica` (math): raiz_quadrada, seno, cosseno, fatorial, mdc, mmc, etc.
   - `sistema` (os + sys): diretorio_atual, listar_diretorio, existe, sair, etc.
@@ -124,21 +162,21 @@ Also in 0.2.0:
   - `iteradores` (itertools): encadeie, combine, permute, acumule, agrupe, etc.
   - `funcional` (functools): reduzido, parcial, cache, compor, negado, etc.
   - `expressao` (re): compilar, buscar, substituir, encontrar_todos, Padrao, etc.
-- Rewrite `__init__.py` with clean Portuguese names (remove `_pt` suffixes)
-- Add `Conjunto` class with Portuguese methods
-- Expand `Texto`, `Lista`, `Dicionario` with more methods
-- Add more exception types: ErroArquivo, ErroPermissao, ErroRecursao, ErroPausa
-- Bump minimum Python to >=3.10
-- 30 tests across all modules
+- Reescrita do `__init__.py` com nomes em português limpos (remove sufixos `_pt`)
+- Adiciona classe `Conjunto` com métodos em português
+- Expande `Texto`, `Lista`, `Dicionario` com mais métodos
+- Adiciona mais tipos de exceção: ErroArquivo, ErroPermissao, ErroRecursao, ErroPausa
+- Versão mínima do Python elevada para >=3.10
+- 30 testes cobrindo todos os módulos
 
 ## 0.0.15 (2026-06-26)
 
-- Add Portuguese translations of Python builtins and core functions
-- Introduce Lista, Dicionario, Texto classes with Portuguese methods
-- Add helper functions: se(), para_cada(), filtro()
-- Add Portuguese exception classes
-- Expand test suite
+- Adiciona traduções em português dos builtins e funções principais do Python
+- Introduz classes Lista, Dicionario, Texto com métodos em português
+- Adiciona funções auxiliares: se(), para_cada(), filtro()
+- Adiciona classes de exceção em português
+- Expande a suíte de testes
 
 ## 0.0.14 (2022-11-28)
 
-- Latest release on PyPI.
+- Última versão anterior no PyPI.

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: portugython
-Version: 0.4.0
-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,22 +31,74 @@ 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 Portugues. Portugython traduz funcoes, tipos e modulos da biblioteca padrao do Python para nomes em portugues.
+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`.
 
-## Instalacao
+## Instalação
 
 ```bash
 pip install portugython
 ```
 
-## Uso basico
+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 *
 
-escreva("Ola, Mundo!")
-nome = leia("Qual e seu nome? ")
-escreva("Ola,", nome)
+escreva("Olá, Mundo!")
+nome = leia("Qual é seu nome? ")
+escreva("Olá,", nome)
 
 numeros = Lista([1, 2, 3, 4, 5])
 numeros.adicione(6)
@@ -60,9 +112,9 @@ resultado = se(tamanho(pares) > 0, "tem pares", "sem pares")
 escreva(resultado)
 ```
 
-## Modulos da biblioteca padrao
+## Módulos da biblioteca padrão
 
-Cada modulo da stdlib tem uma versao em portugues que pode ser importada separadamente.
+Cada módulo da stdlib tem uma versão em português que pode ser importada separadamente.
 
 ### aleatorio (random)
 
@@ -159,7 +211,7 @@ print(p.x, p.y)
 ```python
 from portugython import iteradores
 
-# Combinatoria
+# Combinatória
 for combo in iteradores.combine([1, 2, 3, 4], 2):
     print(combo)
 
@@ -167,7 +219,7 @@ for combo in iteradores.combine([1, 2, 3, 4], 2):
 for par in iteradores.produto("AB", "12"):
     print(par)
 
-# Acumulacao
+# Acumulação
 totais = list(iteradores.acumule([1, 2, 3, 4, 5]))
 
 # Encadeamento
@@ -179,21 +231,21 @@ unido = list(iteradores.encadeie([1, 2], [3, 4], [5]))
 ```python
 from portugython import funcional
 
-# Reducao
+# Redução
 total = funcional.reduzido(lambda a, b: a + b, range(1, 11))
 
-# Funcao parcial
+# Função parcial
 multiplicar_por_3 = funcional.parcial(lambda a, b: a * b, 3)
 print(multiplicar_por_3(7))
 
-# Memoizacao
+# Memoização
 @funcional.cache
 def fibonacci(n):
     if n < 2:
         return n
     return fibonacci(n - 1) + fibonacci(n - 2)
 
-# Composicao
+# Composição
 dobrar = lambda x: x * 2
 somar_um = lambda x: x + 1
 dobrar_e_somar = funcional.compor(somar_um, dobrar)
@@ -213,26 +265,26 @@ if m:
 # Todos os resultados
 numeros = expressao.encontrar_todos(r"\d+", "1 mais 2 igual 3")
 
-# Substituicao
+# Substituição
 limpo = expressao.substituir(r"\s+", " ", "texto  com   espacos")
 
-# Padrao reutilizavel
+# Padrão reutilizável
 email = expressao.Padrao(r"[\w.+-]+@[\w-]+\.[a-z]{2,}")
 if email.encontrar("contato@example.com"):
-    print("Email valido")
+    print("E-mail válido")
 ```
 
-## Referencia de builtins
+## Referência de builtins
 
-### Entrada / Saida
-| Portugues | Python |
+### Entrada / Saída
+| Português | Python |
 |-----------|--------|
 | `escreva` | `print` |
 | `leia` | `input` |
 | `abra` | `open` |
 
 ### Tipos
-| Portugues | Python |
+| Português | Python |
 |-----------|--------|
 | `inteiro` | `int` |
 | `texto` | `str` |
@@ -245,14 +297,14 @@ if email.encontrar("contato@example.com"):
 | `intervalo` | `range` |
 
 ### Constantes
-| Portugues | Python |
+| Português | Python |
 |-----------|--------|
 | `Verdadeiro` | `True` |
 | `Falso` | `False` |
 | `Nenhum` | `None` |
 
-### Funcoes de sequencia
-| Portugues | Python |
+### Funções de sequência
+| Português | Python |
 |-----------|--------|
 | `tamanho` | `len` |
 | `soma` | `sum` |
@@ -266,99 +318,43 @@ if email.encontrar("contato@example.com"):
 | `mapeado` | `map` |
 | `filtrado` | `filter` |
 
-### Operadores logicos
-| Portugues | Python |
+### Operadores lógicos
+| Português | Python |
 |-----------|--------|
 | `nao(x)` | `not x` |
 | `e(a, b)` | `a and b` |
 | `ou(a, b)` | `a or b` |
 
-### Funcoes utilitarias
-| Portugues | Python |
+### Funções utilitárias
+| Português | Python |
 |-----------|--------|
 | `se(c, a, b)` | `a if c else b` |
 | `para_cada(f, it)` | `list(map(f, it))` |
 | `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 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
+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 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
 
-### Tabela de palavras-chave
 
-| Portugues | Python | | Portugues | Python |
 |-----------|--------|-|-----------|--------|
 | `se` | `if` | | `senao` | `else` |
 | `senaose` | `elif` | | `para` | `for` |
@@ -379,17 +375,17 @@ finalmente:
 | `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.
+> **Nota**: Palavras como `e`, `ou`, `de`, `com` e `em` são palavras-chave
+> reservadas no contexto de arquivos `.ptpy`. Evite usá-las como nomes de
+> variáveis nesses arquivos, assim como não se usa `if` ou `for` como
+> variáveis em Python normal.
 
 ## Contribuir
 
-1. Crie um fork deste repositorio
+1. Crie um fork deste repositório
 2. Crie uma branch nova a partir de main
 3. Envie um pull request
 
-## Licenca
+## Licença
 
 MIT