portugython 0.2.0__tar.gz → 0.3.0__tar.gz

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

@@ -1,6 +1,27 @@
 # Changelog
 
-## 0.2.0 (2026-06-26)
+## 0.3.0 (2026-06-26)
+
+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.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portugython
-Version: 0.2.0
+Version: 0.3.0
 Summary: A Portuguese translation of the Python functions/modules/packages
 Project-URL: Homepage, https://github.com/spacemany2k38/portugython
 Project-URL: Bug Tracker, https://github.com/spacemany2k38/portugython/issues

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

@@ -4,7 +4,16 @@ from __future__ import annotations
 
 from functools import reduce as _reduce
 
-__version__ = "0.2.0"
+from portugython._importador import (
+    desinstalar,
+    instalar,
+    listar_modulos,
+)
+
+__version__ = "0.3.0"
+
+# Instala o gancho de importacao automaticamente
+instalar()
 
 # ---------------------------------------------------------------------------
 # IO
@@ -490,6 +499,10 @@ def imprima(*args: object, sep: str = " ", fim: str = "\n", **kwargs: object) ->
 # ---------------------------------------------------------------------------
 __all__ = [
     "__version__",
+    # Importador
+    "instalar",
+    "desinstalar",
+    "listar_modulos",
     # IO
     "escreva",
     "leia",

portugython-0.3.0/portugython/_importador.py

@@ -0,0 +1,136 @@
+"""_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
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.abc
+import importlib.machinery
+import sys
+from importlib.machinery import ModuleSpec
+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 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:
+
+        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)
+
+
+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)
+    ]
+
+
+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.2.0 → portugython-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "portugython"
-version = "0.2.0"
+version = "0.3.0"
 description = "A Portuguese translation of the Python functions/modules/packages"
 readme = "README.md"
 license = {text = "MIT"}

portugython-0.3.0/tests/test_importador.py

@@ -0,0 +1,170 @@
+"""Testa o gancho de importacao de modulos em Portugues."""
+
+import importlib
+import sys
+
+import portugython
+from portugython._importador import MAPA_MODULOS, ImportadorPortugues
+
+
+def _limpar_cache(nome: str) -> None:
+    sys.modules.pop(nome, None)
+
+
+def test_hook_instalado():
+    """O gancho deve estar instalado apos import portugython."""
+    assert any(isinstance(f, ImportadorPortugues) for f in sys.meta_path)
+
+
+def test_listar_modulos():
+    """listar_modulos deve retornar o mapa completo."""
+    mapa = portugython.listar_modulos()
+    assert "aleatorio" in mapa
+    assert "matematica" in mapa
+    assert mapa["aleatorio"] == "portugython.aleatorio"
+
+
+def test_import_aleatorio():
+    """import aleatorio deve funcionar como from portugython import aleatorio."""
+    _limpar_cache("aleatorio")
+    import aleatorio  # noqa: PLC0415
+    assert hasattr(aleatorio, "inteiro_aleatorio")
+    assert hasattr(aleatorio, "escolha")
+    assert hasattr(aleatorio, "embaralhe")
+    n = aleatorio.inteiro_aleatorio(1, 100)
+    assert 1 <= n <= 100
+
+
+def test_from_aleatorio_import():
+    """from aleatorio import deve funcionar."""
+    _limpar_cache("aleatorio")
+    from aleatorio import escolha, inteiro_aleatorio  # noqa: PLC0415
+    assert callable(inteiro_aleatorio)
+    assert callable(escolha)
+    assert escolha([1, 2, 3]) in [1, 2, 3]
+
+
+def test_import_matematica():
+    """import matematica deve expor raiz_quadrada, PI, etc."""
+    _limpar_cache("matematica")
+    from matematica import PI, raiz_quadrada, seno  # noqa: PLC0415
+    assert abs(PI - 3.14159) < 0.001
+    assert raiz_quadrada(9) == 3.0
+    assert abs(seno(PI / 2) - 1.0) < 1e-10
+
+
+def test_import_tempo():
+    """import tempo deve expor agora, hoje, dormir."""
+    _limpar_cache("tempo")
+    from tempo import agora, hoje  # noqa: PLC0415
+    assert hoje().ano >= 2024
+    assert agora().horas >= 0
+
+
+def test_import_colecoes():
+    """import colecoes deve expor Contador, Pilha, Fila."""
+    _limpar_cache("colecoes")
+    from colecoes import Contador, Fila, Pilha  # noqa: PLC0415
+    c = Contador(["a", "a", "b"])
+    assert c["a"] == 2
+    p = Pilha([1, 2, 3])
+    assert p.retire() == 3
+    f = Fila()
+    f.enfileire("x")
+    assert f.desenfileire() == "x"
+
+
+def test_import_iteradores():
+    """import iteradores deve expor combine, encadeie, etc."""
+    _limpar_cache("iteradores")
+    from iteradores import acumule, encadeie  # noqa: PLC0415
+    assert list(encadeie([1, 2], [3, 4])) == [1, 2, 3, 4]
+    assert list(acumule([1, 2, 3])) == [1, 3, 6]
+
+
+def test_import_funcional():
+    """import funcional deve expor reduzido, parcial, cache."""
+    _limpar_cache("funcional")
+    from funcional import parcial, reduzido  # noqa: PLC0415
+    total = reduzido(lambda a, b: a + b, [1, 2, 3, 4, 5])
+    assert total == 15
+    dobrar = parcial(lambda a, b: a * b, 2)
+    assert dobrar(7) == 14
+
+
+def test_import_expressao():
+    """import expressao deve expor buscar, encontrar_todos."""
+    _limpar_cache("expressao")
+    from expressao import buscar, encontrar_todos  # noqa: PLC0415
+    m = buscar(r"\d+", "pagina 42")
+    assert m.group() == "42"
+    assert encontrar_todos(r"\d+", "1 e 2 e 3") == ["1", "2", "3"]
+
+
+def test_import_sistema():
+    """import sistema deve expor diretorio_atual, versao."""
+    _limpar_cache("sistema")
+    from sistema import diretorio_atual, versao  # noqa: PLC0415
+    assert isinstance(diretorio_atual(), str)
+    assert isinstance(versao, str)
+
+
+def test_import_caminho():
+    """import caminho deve expor Caminho."""
+    _limpar_cache("caminho")
+    from caminho import Caminho  # noqa: PLC0415
+    c = Caminho(".")
+    assert c.existe()
+    assert c.eh_diretorio()
+
+
+def test_import_dados_json():
+    """import dados deve expor serializar/deserializar (json)."""
+    _limpar_cache("dados")
+    from dados import deserializar, serializar  # noqa: PLC0415
+    texto = serializar({"chave": "valor", "numero": 42})
+    recuperado = deserializar(texto)
+    assert recuperado["chave"] == "valor"
+
+
+def test_import_subprocesso():
+    """import subprocesso deve expor executar."""
+    _limpar_cache("subprocesso")
+    from subprocesso import executar  # noqa: PLC0415
+    r = executar(["python3", "-c", "print('portugython')"], capturar=True)
+    assert "portugython" in r.stdout
+
+
+def test_import_copia():
+    """import copia deve expor copiar_profundo."""
+    _limpar_cache("copia")
+    from copia import copiar_profundo  # noqa: PLC0415
+    original = [[1, 2], [3, 4]]
+    clon = copiar_profundo(original)
+    original[0].append(99)
+    assert 99 not in clon[0]
+
+
+def test_import_estatistica():
+    """import estatistica deve expor media, mediana, desvio_padrao."""
+    _limpar_cache("estatistica")
+    from estatistica import desvio_padrao, media, mediana  # noqa: PLC0415
+    dados = [1, 2, 3, 4, 5]
+    assert media(dados) == 3.0
+    assert mediana(dados) == 3.0
+    assert desvio_padrao(dados) > 0
+
+
+def test_desinstalar_reinstalar():
+    """desinstalar e instalar devem funcionar corretamente."""
+    portugython.desinstalar()
+    assert not any(isinstance(f, ImportadorPortugues) for f in sys.meta_path)
+    portugython.instalar()
+    assert any(isinstance(f, ImportadorPortugues) for f in sys.meta_path)
+
+
+def test_todos_modulos_mapeados_importaveis():
+    """Todos os modulos no MAPA_MODULOS devem ser importaveis."""
+    for nome_pt, caminho in MAPA_MODULOS.items():
+        mod = importlib.import_module(caminho)
+        assert mod is not None, f"Nao foi possivel importar {caminho}"

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

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