portugython 0.1.0__tar.gz → 0.2.0__tar.gz

portugython-0.2.0/CHANGELOG.md

@@ -0,0 +1,70 @@
+# Changelog
+
+## 0.2.0 (2026-06-26)
+
+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.2.0}/PKG-INFO

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

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from functools import reduce as _reduce
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 # ---------------------------------------------------------------------------
 # IO
@@ -48,7 +48,7 @@ tipo = type
 chamavel = callable
 e_instancia = isinstance
 e_subclasse = issubclass
-identificador = id
+obter_id = id
 atributos = dir
 obter_atributo = getattr
 definir_atributo = setattr
@@ -522,7 +522,7 @@ __all__ = [
     "chamavel",
     "e_instancia",
     "e_subclasse",
-    "identificador",
+    "obter_id",
     "atributos",
     "obter_atributo",
     "definir_atributo",

portugython-0.2.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.2.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.2.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.2.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.2.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)

portugython-0.2.0/portugython/caminho.py

@@ -0,0 +1,132 @@
+"""caminho - traducao em Portugues do modulo pathlib."""
+from __future__ import annotations
+
+import pathlib as _pathlib
+from typing import Iterator
+
+__all__ = ["Caminho", "CaminhoPuro", "caminho_atual"]
+
+class Caminho(_pathlib.Path):
+    """Path com metodos em Portugues."""
+    _flavour = (
+        _pathlib.Path('.')._flavour
+        if hasattr(_pathlib.Path('.'), '_flavour')
+        else None
+    )
+
+    def __new__(cls, *args, **kwargs):
+        return super().__new__(cls, *args, **kwargs)
+
+    @classmethod
+    def atual(cls) -> "Caminho":
+        """Retorna o diretorio de trabalho atual."""
+        return cls(_pathlib.Path.cwd())
+
+    @classmethod
+    def usuario(cls) -> "Caminho":
+        """Retorna o diretorio home do usuario."""
+        return cls(_pathlib.Path.home())
+
+    def existe(self) -> bool:
+        """Retorna True se o caminho existe."""
+        return self.exists()
+
+    def eh_arquivo(self) -> bool:
+        """Retorna True se for um arquivo regular."""
+        return self.is_file()
+
+    def eh_diretorio(self) -> bool:
+        """Retorna True se for um diretorio."""
+        return self.is_dir()
+
+    def eh_link(self) -> bool:
+        """Retorna True se for um link simbolico."""
+        return self.is_symlink()
+
+    def criar(self, existe_ok: bool = False) -> None:
+        """Cria o arquivo (touch)."""
+        self.touch(exist_ok=existe_ok)
+
+    def criar_dir(self, pais: bool = False, existe_ok: bool = False) -> None:
+        """Cria o diretorio."""
+        self.mkdir(parents=pais, exist_ok=existe_ok)
+
+    def remover(self) -> None:
+        """Remove o arquivo."""
+        self.unlink()
+
+    def remover_dir(self) -> None:
+        """Remove o diretorio vazio."""
+        self.rmdir()
+
+    def renomear(self, destino: str | "Caminho") -> "Caminho":
+        """Renomeia e retorna o novo caminho."""
+        return Caminho(self.rename(destino))
+
+    def listar(self) -> Iterator["Caminho"]:
+        """Itera sobre o conteudo do diretorio."""
+        return (Caminho(p) for p in self.iterdir())
+
+    def buscar(self, padrao: str) -> Iterator["Caminho"]:
+        """Busca arquivos que correspondem ao padrao."""
+        return (Caminho(p) for p in self.glob(padrao))
+
+    def buscar_recursivo(self, padrao: str) -> Iterator["Caminho"]:
+        """Busca recursivamente arquivos que correspondem ao padrao."""
+        return (Caminho(p) for p in self.rglob(padrao))
+
+    def ler_texto(self, codificacao: str = "utf-8") -> str:
+        """Le o conteudo como texto."""
+        return self.read_text(encoding=codificacao)
+
+    def escrever_texto(self, conteudo: str, codificacao: str = "utf-8") -> int:
+        """Escreve texto no arquivo."""
+        return self.write_text(conteudo, encoding=codificacao)
+
+    def ler_bytes(self) -> bytes:
+        """Le o conteudo como bytes."""
+        return self.read_bytes()
+
+    def escrever_bytes(self, dados: bytes) -> int:
+        """Escreve bytes no arquivo."""
+        return self.write_bytes(dados)
+
+    def absoluto(self) -> "Caminho":
+        """Retorna o caminho absoluto."""
+        return Caminho(self.resolve())
+
+    @property
+    def nome(self) -> str:
+        """Nome do arquivo com extensao."""
+        return self.name
+
+    @property
+    def sufixo(self) -> str:
+        """Extensao do arquivo."""
+        return self.suffix
+
+    @property
+    def sufixos(self) -> list[str]:
+        """Todas as extensoes."""
+        return self.suffixes
+
+    @property
+    def raiz_nome(self) -> str:
+        """Nome sem extensao."""
+        return self.stem
+
+    @property
+    def pai(self) -> "Caminho":
+        """Diretorio pai."""
+        return Caminho(self.parent)
+
+    @property
+    def partes(self) -> tuple[str, ...]:
+        """Componentes do caminho."""
+        return self.parts
+
+CaminhoPuro = _pathlib.PurePath
+
+def caminho_atual() -> Caminho:
+    """Retorna o diretorio de trabalho atual."""
+    return Caminho.atual()

portugython-0.2.0/portugython/classe_dados.py

@@ -0,0 +1,40 @@
+"""classe_dados - traducao em Portugues do modulo dataclasses."""
+from __future__ import annotations
+
+import dataclasses as _dc
+from typing import Any
+
+__all__ = [
+    "classe_dados", "campo", "Campo", "fabrica_campo",
+    "para_dicionario", "para_tupla", "eh_classe_dados",
+    "eh_instancia_classe_dados", "campos", "substituir",
+]
+
+classe_dados = _dc.dataclass
+campo = _dc.field
+Campo = _dc.Field
+fabrica_campo = _dc.fields
+
+def para_dicionario(instancia: Any) -> dict:
+    """Converte uma instancia de classe_dados em dicionario."""
+    return _dc.asdict(instancia)
+
+def para_tupla(instancia: Any) -> tuple:
+    """Converte uma instancia de classe_dados em tupla."""
+    return _dc.astuple(instancia)
+
+def eh_classe_dados(cls: Any) -> bool:
+    """Retorna True se cls e uma classe decorada com @classe_dados."""
+    return _dc.is_dataclass(cls) and isinstance(cls, type)
+
+def eh_instancia_classe_dados(obj: Any) -> bool:
+    """Retorna True se obj e uma instancia de classe_dados."""
+    return _dc.is_dataclass(obj) and not isinstance(obj, type)
+
+def campos(cls: Any) -> tuple:
+    """Retorna os campos de uma classe_dados."""
+    return _dc.fields(cls)
+
+def substituir(instancia: Any, **alteracoes: Any) -> Any:
+    """Cria uma nova instancia substituindo campos especificados."""
+    return _dc.replace(instancia, **alteracoes)