portugython 0.2.0__tar.gz → 0.4.0__tar.gz

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

@@ -1,6 +1,80 @@
 # Changelog
 
-## 0.2.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.
+
+After `import portugython`, the full stdlib-level syntax works:
+
+    import aleatorio
+    from matematica import raiz_quadrada, PI
+    from colecoes import Contador, Pilha, Fila
+    from tempo import agora, hoje
+    from expressao import buscar, encontrar_todos
+    from dados import serializar, deserializar     # json
+    from subprocesso import executar
+    from caminho import Caminho
+    # ... all 36 modules
+
+New exports:
+- `portugython.instalar()` - instala o gancho (chamado automaticamente)
+- `portugython.desinstalar()` - remove o gancho
+- `portugython.listar_modulos()` - retorna o mapa de nomes
+
+
 
 Full stdlib coverage. 36 submodules total, all importable via `from portugython import <modulo>`:
 

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: portugython
-Version: 0.2.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.2.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.2.0 → portugython-0.4.0}/portugython/__init__.py

@@ -4,7 +4,25 @@ from __future__ import annotations
 
 from functools import reduce as _reduce
 
-__version__ = "0.2.0"
+from portugython._importador import (
+    desinstalar,
+    instalar,
+    listar_modulos,
+)
+from portugython.transpilador import (
+    MAPA_PALAVRAS_CHAVE,
+    PALAVRAS_RESERVADAS,
+    executar_arquivo,
+    executar_texto,
+    mostrar_traducao,
+    traduzir,
+    traduzir_para_portugues,
+)
+
+__version__ = "0.4.0"
+
+# Instala o gancho de importacao automaticamente
+instalar()
 
 # ---------------------------------------------------------------------------
 # IO
@@ -490,6 +508,18 @@ def imprima(*args: object, sep: str = " ", fim: str = "\n", **kwargs: object) ->
 # ---------------------------------------------------------------------------
 __all__ = [
     "__version__",
+    # Importador
+    "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.4.0/portugython/_importador.py

@@ -0,0 +1,200 @@
+"""_importador - gancho de importacao que permite importar modulos em Portugues.
+
+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
+
+import importlib
+import importlib.abc
+import importlib.machinery
+import importlib.util
+import sys
+from importlib.machinery import ModuleSpec, SourceFileLoader
+from pathlib import Path
+from typing import Sequence
+
+# Mapeamento de nome em Portugues -> caminho completo do modulo portugython
+MAPA_MODULOS: dict[str, str] = {
+    # Matematica e ciencia
+    "aleatorio": "portugython.aleatorio",
+    "matematica": "portugython.matematica",
+    "estatistica": "portugython.estatistica",
+    # Tipos e estruturas
+    "colecoes": "portugython.colecoes",
+    "iteradores": "portugython.iteradores",
+    "funcional": "portugython.funcional",
+    "bisecao": "portugython.bisecao",
+    # Tempo e data
+    "tempo": "portugython.tempo",
+    "calendario": "portugython.calendario",
+    # Sistema e IO
+    "sistema": "portugython.sistema",
+    "caminho": "portugython.caminho",
+    "subprocesso": "portugython.subprocesso",
+    "soquete": "portugython.soquete",
+    "rede": "portugython.rede",
+    # Texto e expressoes
+    "expressao": "portugython.expressao",
+    "formatacao": "portugython.formatacao",
+    # Serialization e codificacao
+    "serializacao": "portugython.serializacao",
+    "codificacao": "portugython.codificacao",
+    "compressao": "portugython.compressao",
+    "dados": "portugython.json",
+    # Concorrencia
+    "threads": "portugython.threads",
+    "assincronico": "portugython.assincronico",
+    # OOP e tipos
+    "abstrato": "portugython.abstrato",
+    "enumeracao": "portugython.enumeracao",
+    "classe_dados": "portugython.classe_dados",
+    "tipagem": "portugython.tipagem",
+    # Utilitarios
+    "registro": "portugython.registro",
+    "argumentos": "portugython.argumentos",
+    "contexto": "portugython.contexto",
+    "copia": "portugython.copia",
+    "hash_pt": "portugython.hash_pt",
+    "identificador": "portugython.identificador",
+    "configuracao": "portugython.configuracao",
+    "estrutura": "portugython.estrutura",
+    "depuracao": "portugython.depuracao",
+    "csv_pt": "portugython.csv_pt",
+}
+
+
+class _CarregadorAlias(importlib.abc.Loader):
+    """Carrega um modulo portugython sob um nome em Portugues."""
+
+    def __init__(self, modulo_real: str) -> None:
+        self._modulo_real = modulo_real
+
+    def create_module(self, spec: ModuleSpec):  # noqa: ANN001
+        """Retorna o modulo real (ja carregado ou carregado agora)."""
+        return importlib.import_module(self._modulo_real)
+
+    def exec_module(self, module) -> None:  # noqa: ANN001
+        """Nao precisa fazer nada: create_module ja retornou o modulo pronto."""
+
+
+class ImportadorPortugues(importlib.abc.MetaPathFinder):
+    """Intercepta imports de nomes em Portugues e redireciona para portugython.*."""
+
+    def find_spec(
+        self,
+        fullname: str,
+        path: Sequence[str] | None,
+        target=None,  # noqa: ANN001
+    ) -> ModuleSpec | None:
+        """Retorna um ModuleSpec para o modulo em Portugues, se mapeado.
+
+        Args:
+            fullname: Nome completo do modulo sendo importado.
+            path: Caminho de busca (ignorado aqui).
+            target: Modulo alvo (ignorado aqui).
+        """
+        if fullname in MAPA_MODULOS:
+            modulo_real = MAPA_MODULOS[fullname]
+            carregador = _CarregadorAlias(modulo_real)
+            return ModuleSpec(fullname, carregador)
+        return None
+
+
+_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:
+    - 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
+        from tempo import agora, hoje
+    """
+    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, ImportadorPtpy))
+    ]