portugython 0.1.0__tar.gz → 0.3.0__tar.gz

portugython-0.3.0/CHANGELOG.md

@@ -0,0 +1,91 @@
+# Changelog
+
+## 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>`:
+
+**New in 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
+- `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
+- `subprocesso` (subprocess): executar, executar_shell, saida, chamar
+- `copia` (copy): copiar, copiar_profundo
+- `hash_pt` (hashlib + hmac): md5, sha256, sha512, blake2b, codigo_autenticacao, comparar_seguro
+- `threads` (threading): Thread, Semaforo, Evento, Trava, contagem_threads, thread_atual
+- `abstrato` (abc): ClasseAbstrata, metodo_abstrato, propriedade_abstrata
+- `bisecao` (bisect + heapq): inserir_ordenado, buscar_ordenado, heapificar, empurrar, n_maiores
+- `identificador` (uuid): uuid1, uuid3, uuid4, uuid5
+- `calendario` (calendar): dias_no_mes, eh_ano_bissexto, dia_semana, calendario_mes
+- `configuracao` (configparser): AnalisadorConfig com ler_arquivo, obter, definir, escrever_arquivo
+- `serializacao` (pickle): serializar, deserializar, serializar_arquivo, deserializar_arquivo
+- `codificacao` (base64 + codecs): para_base64, de_base64, para_base32, para_base16
+- `compressao` (gzip + zlib): comprimir_gzip, descomprimir_gzip, comprimir_zlib
+- `formatacao` (textwrap + pprint + string): quebrar, preencher, dedenter, recuar, imprimir_bonito
+- `depuracao` (traceback + warnings + gc): imprimir_excecao, formatar_excecao, coletar_lixo
+- `soquete` (socket): Soquete, criar_conexao, criar_servidor, nome_host, endereco_ip
+- `assincronico` (asyncio): executar, criar_tarefa, dormir, reunir, Evento, Fila
+- `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
+
+
+## 0.1.0 (2026-06-26)
+
+- Add full stdlib submodule set with Portuguese translations:
+  - `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.
+  - `tempo` (time + datetime): Data, Hora, DataHora, Duracao, agora, hoje, dormir, etc.
+  - `colecoes` (collections): Contador, Deque, DicionarioOrdenado, Pilha, Fila, etc.
+  - `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
+
+## 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
+
+## 0.0.14 (2022-11-28)
+
+- Latest release on PyPI.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portugython
-Version: 0.1.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.1.0 → portugython-0.3.0}/portugython/__init__.py

@@ -4,7 +4,16 @@ from __future__ import annotations
 
 from functools import reduce as _reduce
 
-__version__ = "0.1.0"
+from portugython._importador import (
+    desinstalar,
+    instalar,
+    listar_modulos,
+)
+
+__version__ = "0.3.0"
+
+# Instala o gancho de importacao automaticamente
+instalar()
 
 # ---------------------------------------------------------------------------
 # IO
@@ -48,7 +57,7 @@ tipo = type
 chamavel = callable
 e_instancia = isinstance
 e_subclasse = issubclass
-identificador = id
+obter_id = id
 atributos = dir
 obter_atributo = getattr
 definir_atributo = setattr
@@ -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",
@@ -522,7 +535,7 @@ __all__ = [
     "chamavel",
     "e_instancia",
     "e_subclasse",
-    "identificador",
+    "obter_id",
     "atributos",
     "obter_atributo",
     "definir_atributo",

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.3.0/portugython/abstrato.py

@@ -0,0 +1,14 @@
+"""abstrato - traducao em Portugues do modulo abc."""
+from __future__ import annotations
+
+import abc as _abc
+
+__all__ = ["ClasseAbstrata", "metodo_abstrato", "propriedade_abstrata", "ABCMeta"]
+
+ClasseAbstrata = _abc.ABC
+metodo_abstrato = _abc.abstractmethod
+ABCMeta = _abc.ABCMeta
+
+def propriedade_abstrata(func):
+    """Decorator para propriedades abstratas."""
+    return property(_abc.abstractmethod(func))

portugython-0.3.0/portugython/argumentos.py

@@ -0,0 +1,44 @@
+"""argumentos - traducao em Portugues do modulo argparse."""
+from __future__ import annotations
+
+import argparse as _ap
+
+__all__ = [
+    "AnalisadorArgumentos", "EspacoNomes", "AcaoAdicionar",
+    "AcaoVerdadeiro", "AcaoFalso", "AcaoContar",
+    "ErroArgumento",
+]
+
+ErroArgumento = _ap.ArgumentError
+EspacoNomes = _ap.Namespace
+AcaoAdicionar = "append"
+AcaoVerdadeiro = "store_true"
+AcaoFalso = "store_false"
+AcaoContar = "count"
+
+class AnalisadorArgumentos(_ap.ArgumentParser):
+    """ArgumentParser com metodos em Portugues."""
+
+    def adicionar_argumento(self, *nomes, **kwargs) -> None:
+        """Adiciona um argumento ao analisador."""
+        self.add_argument(*nomes, **kwargs)
+
+    def analisar(self, args=None) -> _ap.Namespace:
+        """Analisa os argumentos da linha de comando."""
+        return self.parse_args(args)
+
+    def analisar_parcial(self, args=None) -> tuple:
+        """Analisa os argumentos conhecidos, ignorando os desconhecidos."""
+        return self.parse_known_args(args)
+
+    def adicionar_subcomandos(self, **kwargs) -> _ap.Action:
+        """Adiciona suporte a subcomandos."""
+        return self.add_subparsers(**kwargs)
+
+    def adicionar_grupo(self, titulo: str = "", descricao: str = ""):
+        """Adiciona um grupo de argumentos."""
+        return self.add_argument_group(titulo, descricao)
+
+    def adicionar_grupo_exclusivo(self, obrigatorio: bool = False):
+        """Adiciona um grupo mutualmente exclusivo."""
+        return self.add_mutually_exclusive_group(required=obrigatorio)

portugython-0.3.0/portugython/assincronico.py

@@ -0,0 +1,87 @@
+"""assincronico - traducao em Portugues do modulo asyncio."""
+from __future__ import annotations
+
+import asyncio as _aio
+from typing import Any, Coroutine
+
+__all__ = [
+    "executar", "esperar", "criar_tarefa", "dormir",
+    "reunir", "timeout", "cancelar_ao_timeout",
+    "Evento", "Fila", "Semaforo", "Trava",
+    "obter_laco", "novo_laco", "LacoEventos",
+    "corrotina", "eh_corrotina", "eh_aguardavel",
+]
+
+LacoEventos = _aio.AbstractEventLoop
+Evento = _aio.Event
+Fila = _aio.Queue
+Semaforo = _aio.Semaphore
+Trava = _aio.Lock
+corrotina = _aio.coroutine if hasattr(_aio, "coroutine") else None
+
+def executar(corrotina_principal: Coroutine, *, depurar: bool = False) -> Any:
+    """Executa uma corrotina como programa principal.
+
+    Args:
+        corrotina_principal: Corrotina a executar.
+        depurar: Habilita modo de depuracao.
+    """
+    return _aio.run(corrotina_principal, debug=depurar)
+
+async def esperar(aguardavel: Any) -> Any:
+    """Aguarda um aguardavel e retorna o resultado.
+
+    Args:
+        aguardavel: Corrotina, Task ou Future a aguardar.
+    """
+    return await _aio.ensure_future(aguardavel)
+
+def criar_tarefa(corrotina: Coroutine, *, nome: str | None = None) -> _aio.Task:
+    """Cria uma Task a partir de uma corrotina.
+
+    Args:
+        corrotina: Corrotina a executar como tarefa.
+        nome: Nome opcional da tarefa.
+    """
+    return _aio.create_task(corrotina, name=nome)
+
+async def dormir(segundos: float) -> None:
+    """Suspende a corrotina pelo tempo especificado.
+
+    Args:
+        segundos: Tempo de espera em segundos.
+    """
+    await _aio.sleep(segundos)
+
+async def reunir(*aguardaveis: Any, retornar_excecoes: bool = False) -> list:
+    """Executa multiplos aguardaveis concorrentemente.
+
+    Args:
+        *aguardaveis: Corrotinas ou Tasks a executar.
+        retornar_excecoes: Se True, excecoes sao retornadas em vez de propagadas.
+    """
+    return await _aio.gather(*aguardaveis, return_exceptions=retornar_excecoes)
+
+def timeout(delay: float):
+    """Context manager que cancela a operacao apos delay segundos."""
+    return _aio.timeout(delay)
+
+def cancelar_ao_timeout(delay: float):
+    """Context manager que cancela apos delay (compat anterior)."""
+    return _aio.timeout(delay)
+
+def obter_laco() -> _aio.AbstractEventLoop:
+    """Retorna o laco de eventos em execucao."""
+    return _aio.get_event_loop()
+
+def novo_laco() -> _aio.AbstractEventLoop:
+    """Cria e retorna um novo laco de eventos."""
+    return _aio.new_event_loop()
+
+def eh_corrotina(obj: Any) -> bool:
+    """Retorna True se obj for uma corrotina."""
+    return _aio.iscoroutine(obj)
+
+def eh_aguardavel(obj: Any) -> bool:
+    """Retorna True se obj for aguardavel."""
+    return _aio.isfuture(obj) or _aio.iscoroutine(obj) or _aio.iscoroutinefunction(obj)

portugython-0.3.0/portugython/bisecao.py

@@ -0,0 +1,106 @@
+"""bisecao - traducao em Portugues dos modulos bisect e heapq."""
+from __future__ import annotations
+
+import bisect as _bis
+import heapq as _hq
+from typing import Any
+
+__all__ = [
+    # bisect
+    "inserir_esquerda", "inserir_direita", "buscar_esquerda", "buscar_direita",
+    # heapq
+    "heapificar", "empurrar", "retirar", "empurrar_retirar", "retirar_empurrar",
+    "n_maiores", "n_menores", "fundir",
+    # alias
+    "inserir_ordenado", "buscar_ordenado",
+]
+
+def inserir_esquerda(
+    lista: list, item: Any, inicio: int = 0, fim: int | None = None
+) -> None:
+    """Insere item na lista ordenada, a esquerda de iguais.
+
+    Args:
+        lista: Lista ordenada.
+        item: Item a inserir.
+        inicio: Indice de inicio da busca.
+        fim: Indice de fim da busca.
+    """
+    if fim is None:
+        _bis.insort_left(lista, item, inicio)
+    else:
+        _bis.insort_left(lista, item, inicio, fim)
+
+def inserir_direita(
+    lista: list, item: Any, inicio: int = 0, fim: int | None = None
+) -> None:
+    """Insere item na lista ordenada, a direita de iguais."""
+    if fim is None:
+        _bis.insort_right(lista, item, inicio)
+    else:
+        _bis.insort_right(lista, item, inicio, fim)
+
+inserir_ordenado = inserir_direita
+
+def buscar_esquerda(
+    lista: list, item: Any, inicio: int = 0, fim: int | None = None
+) -> int:
+    """Retorna o indice de insercao a esquerda de iguais."""
+    if fim is None:
+        return _bis.bisect_left(lista, item, inicio)
+    return _bis.bisect_left(lista, item, inicio, fim)
+
+def buscar_direita(
+    lista: list, item: Any, inicio: int = 0, fim: int | None = None
+) -> int:
+    """Retorna o indice de insercao a direita de iguais."""
+    if fim is None:
+        return _bis.bisect_right(lista, item, inicio)
+    return _bis.bisect_right(lista, item, inicio, fim)
+
+buscar_ordenado = buscar_direita
+
+def heapificar(lista: list) -> None:
+    """Converte uma lista em heap no lugar (min-heap).
+
+    Args:
+        lista: Lista a converter.
+    """
+    _hq.heapify(lista)
+
+def empurrar(heap: list, item: Any) -> None:
+    """Adiciona item ao heap mantendo a propriedade de heap.
+
+    Args:
+        heap: Heap existente.
+        item: Item a adicionar.
+    """
+    _hq.heappush(heap, item)
+
+def retirar(heap: list) -> Any:
+    """Remove e retorna o menor item do heap.
+
+    Args:
+        heap: Heap existente.
+    """
+    return _hq.heappop(heap)
+
+def empurrar_retirar(heap: list, item: Any) -> Any:
+    """Empurra item e retira o menor de forma eficiente."""
+    return _hq.heappushpop(heap, item)
+
+def retirar_empurrar(heap: list, item: Any) -> Any:
+    """Retira o menor e empurra item de forma eficiente."""
+    return _hq.heapreplace(heap, item)
+
+def n_maiores(n: int, iteravel: Any, chave=None) -> list:
+    """Retorna os n maiores elementos do iteravel."""
+    return _hq.nlargest(n, iteravel, key=chave)
+
+def n_menores(n: int, iteravel: Any, chave=None) -> list:
+    """Retorna os n menores elementos do iteravel."""
+    return _hq.nsmallest(n, iteravel, key=chave)
+
+def fundir(*iteraveis: Any, chave=None) -> Any:
+    """Funde iteraveis ordenados em um unico iteravel ordenado."""
+    return _hq.merge(*iteraveis, key=chave)

portugython-0.3.0/portugython/calendario.py

@@ -0,0 +1,70 @@
+"""calendario - traducao em Portugues do modulo calendar."""
+from __future__ import annotations
+
+import calendar as _cal
+
+__all__ = [
+    "calendario_mes", "calendario_ano", "dias_no_mes", "eh_ano_bissexto",
+    "dia_semana", "dias_semana", "meses",
+    "SEGUNDA", "TERCA", "QUARTA", "QUINTA", "SEXTA", "SABADO", "DOMINGO",
+    "Calendario", "CalendarioTexto",
+]
+
+SEGUNDA = _cal.MONDAY
+TERCA = _cal.TUESDAY
+QUARTA = _cal.WEDNESDAY
+QUINTA = _cal.THURSDAY
+SEXTA = _cal.FRIDAY
+SABADO = _cal.SATURDAY
+DOMINGO = _cal.SUNDAY
+
+dias_semana = list(_cal.day_name)
+meses = list(_cal.month_name)[1:]
+
+Calendario = _cal.Calendar
+CalendarioTexto = _cal.TextCalendar
+
+def calendario_mes(ano: int, mes: int, largura: int = 0) -> str:
+    """Retorna o calendario de um mes como texto.
+
+    Args:
+        ano: Ano.
+        mes: Mes (1-12).
+        largura: Largura da coluna de dia.
+    """
+    return _cal.month(ano, mes, largura)
+
+def calendario_ano(ano: int) -> str:
+    """Retorna o calendario do ano inteiro como texto.
+
+    Args:
+        ano: Ano.
+    """
+    return _cal.calendar(ano)
+
+def dias_no_mes(ano: int, mes: int) -> int:
+    """Retorna o numero de dias no mes.
+
+    Args:
+        ano: Ano.
+        mes: Mes (1-12).
+    """
+    return _cal.monthrange(ano, mes)[1]
+
+def eh_ano_bissexto(ano: int) -> bool:
+    """Retorna True se o ano for bissexto.
+
+    Args:
+        ano: Ano.
+    """
+    return _cal.isleap(ano)
+
+def dia_semana(ano: int, mes: int, dia: int) -> int:
+    """Retorna o dia da semana (0=segunda, 6=domingo).
+
+    Args:
+        ano: Ano.
+        mes: Mes (1-12).
+        dia: Dia (1-31).
+    """
+    return _cal.weekday(ano, mes, dia)