dataloom-engine 0.3.0__tar.gz

dataloom_engine-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 [Dioni Padilha]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dataloom_engine-0.3.0/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: dataloom-engine
+Version: 0.3.0
+Summary: DataLoom: Um orquestrador de threads leve e eficiente para dados.
+Author-email: Dioni Padilha <dionipdl@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/dionipadilha/dataloom
+Project-URL: Changelog, https://github.com/dionipadilha/dataloom/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/dionipadilha/dataloom/issues
+Keywords: pipeline,data,threading,loom,concurrency
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Dynamic: license-file
+
+# 🧵 DataLoom
+
+> Um motor de orquestração multi-thread leve, eficiente e seguro para Python.
+
+[![CI](https://github.com/dionipadilha/dataloom/actions/workflows/ci.yml/badge.svg)](https://github.com/dionipadilha/dataloom/actions/workflows/ci.yml) ![Python](https://img.shields.io/badge/python-3.9%2B-blue) ![License](https://img.shields.io/badge/license-MIT-green)
+
+<img width="2752" height="1536" alt="DataLoom: Um motor de orquestração multi-thread leve, eficiente e seguro para Python." src="https://github.com/user-attachments/assets/c1f3fc98-5eaf-4add-a38c-2717ae699cd5" />
+
+O **DataLoom** é uma biblioteca projetada para processar fluxos de dados utilizando o padrão **Produtor-Consumidor** com múltiplas threads (Weavers). Ele abstrai a complexidade de filas (`Queues`), sincronização (`Locks`) e gerenciamento de ciclo de vida, permitindo que você foque apenas na lógica de transformação dos dados.
+
+## Por que usar o DataLoom?
+⚡ Performance: Processamento paralelo real para tarefas I/O bound.
+🧩 Simplicidade: API intuitiva inspirada na metáfora de tecelagem.
+🛡️ Segurança: Thread-safety garantido por design em todo o pipeline.
+📦 Leve: Dependências mínimas, pronto para rodar em qualquer ambiente Python.
+
+### Por que não usar só `ThreadPoolExecutor`?
+
+Pergunta justa — a stdlib resolve o *paralelismo*, mas não o *pipeline*. O
+`concurrent.futures` te dá um pool de threads; tudo ao redor fica por sua conta:
+
+| Você precisa de...                                  | Com a stdlib             | Com o DataLoom                    |
+| --------------------------------------------------- | ------------------------ | --------------------------------- |
+| Fluxo contínuo produtor-consumidor                   | `Queue` + loops manuais  | `Loom` + `Source`                 |
+| Backpressure (produtor mais rápido que consumidores) | `Queue(maxsize=...)` manual | Padrão, configurável            |
+| Shutdown limpo (drenar fila, fechar recursos)        | Sentinelas e joins manuais | `stop()` / `with Loom(...)`     |
+| Worker que sobrevive a erros e os reporta            | try/except em cada worker | `hooks.on_error` centralizado    |
+| Métricas por item processado                         | Instrumentação manual    | `hooks.on_batch_processed`        |
+| Escrita concorrente segura em arquivo                | Lock manual              | Sinks prontos (JSON, CSV, callback) |
+
+Se o seu caso é "aplicar uma função a uma lista e coletar os resultados",
+use `ThreadPoolExecutor.map` — é a ferramenta certa. O DataLoom é para
+**fluxos contínuos ou longos** onde ciclo de vida, resiliência e
+observabilidade importam. E, como toda solução baseada em threads no
+CPython, o ganho de paralelismo vale para cargas **I/O bound**; para
+CPU bound, prefira multiprocessing.
+
+## ✨ Características
+
+- **API Coesa:** Conceitos alinhados (`Loom`, `Weaver`, `Sink`).
+- **Concorrente:** Gerencia automaticamente múltiplos _Weavers_ (threads) em paralelo.
+- **Seguro:** Sinks padrão são thread-safe e exceções são tipadas (`LoomError`).
+- **Resiliente:** Erros de processamento não derrubam os Weavers e são reportados via hooks.
+- **Gerenciável:** `Loom` é um context manager — `with Loom(...) as loom:` garante `stop()` automático.
+- **Backpressure:** Fila de tarefas limitada por padrão (`queue_maxsize`), evitando crescimento de memória sem controle.
+- **Observável:** Hooks de ciclo de vida e métricas por lote (`on_batch_processed` com resultado e duração), além de Logs integrados.
+
+## 📦 Instalação
+
+```bash
+pip install dataloom-engine
+```
+
+> ⚠️ **Atenção ao nome:** o pacote instala o módulo `dataloom_engine`
+> (`import dataloom_engine`). Não confunda com o pacote `dataloom` do PyPI,
+> que é um ORM de outro autor e não tem relação com este projeto.
+
+Para desenvolver ou usar a versão mais recente do repositório:
+
+```bash
+git clone https://github.com/dionipadilha/dataloom.git
+cd dataloom
+pip install -e .
+```
+
+## 🚀 Uso Rápido
+
+Aqui está um exemplo completo de como tecer um pipeline de dados:
+
+```python
+from pathlib import Path
+import numpy as np
+from dataloom_engine import (
+    Loom,
+    LoomConfig,
+    LoomLogs,
+    Processor,
+    JsonFileSink,
+    ThreadedBufferedSink
+)
+from dataloom_engine.sources import RandomNumPySource
+
+# 1. Defina sua lógica de processamento (Stateless)
+class MyFilterProcessor(Processor):
+    def process(self, batch: np.ndarray) -> dict:
+        # 'batch' é um array numpy com o tamanho definido na config
+        avg = float(batch.mean())
+        return {
+            "processed_items": len(batch),
+            "average_value": avg,
+            "status": "high" if avg > 0.5 else "low"
+        }
+
+# 2. Configuração Inicial
+if __name__ == "__main__":
+    # Configura logs no console
+    LoomLogs.setup()
+
+    # Define parâmetros do motor
+    config = LoomConfig(
+        output_dir=Path("./data_out"),
+        batch_size=100,      # Processa 100 itens por vez
+        interval_seconds=1   # Gera um novo lote a cada 1 segundo
+    )
+
+    # 3. Fonte de Dados
+    # Agora desvinculada do motor, permitindo fontes customizadas (DB, CSV, S3)
+    source = RandomNumPySource(config)
+
+    # 4. Sink Arquivado e Otimizado
+    # ThreadedBufferedSink evita que o I/O bloqueie o processamento
+    file_sink = JsonFileSink(config.output_dir)
+    sink = ThreadedBufferedSink(file_sink)
+
+    # 5. Inicializa o Loom (O Orquestrador)
+    loom = Loom(
+        config=config,
+        processor=MyFilterProcessor(),
+        sink=sink,
+        source=source,
+        num_weavers=4  # 4 Threads trabalhando em paralelo
+    )
+
+    print("🧵 DataLoom iniciado! Pressione Ctrl+C para parar.")
+    try:
+        # O context manager garante stop() e limpeza dos recursos,
+        # mesmo em caso de exceção ou Ctrl+C
+        with loom:
+            loom.start()
+    except KeyboardInterrupt:
+        print("\n🛑 Tear parado.")
+```
+
+## 🏗️ Arquitetura
+
+O DataLoom utiliza uma metáfora de tecelagem:
+
+- **Loom (Tear):** A máquina principal. Gerencia a fila de tarefas e o ciclo de vida.
+- **Weaver (Tecelão):** As threads trabalhadoras. Elas pegam a matéria-prima (batch), processam e entregam.
+- **Processor:** A lógica de negócio. Transforma dados brutos em informação.
+- **Sink:** O destino final. Onde o produto acabado é depositado (ex: `JsonFileSink`, `CsvFileSink`, ou qualquer destino via `CallbackSink`).
+
+## 🛠️ Desenvolvimento e Testes
+
+Para contribuir com o projeto ou rodar os testes unitários:
+
+1.  Instale as dependências de desenvolvimento:
+
+    ```bash
+    pip install -e ".[dev]"
+    ```
+
+2.  Rode a suíte de testes (via pytest):
+    ```bash
+    pytest
+    ```
+
+## 📄 Licença
+
+Este projeto está licenciado sob a licença MIT - veja o arquivo [LICENSE](LICENSE) para detalhes.
+
+## 🗒️ Histórico de versões
+
+As mudanças de cada versão estão documentadas no [CHANGELOG](CHANGELOG.md).

dataloom_engine-0.3.0/README.md

@@ -0,0 +1,164 @@
+# 🧵 DataLoom
+
+> Um motor de orquestração multi-thread leve, eficiente e seguro para Python.
+
+[![CI](https://github.com/dionipadilha/dataloom/actions/workflows/ci.yml/badge.svg)](https://github.com/dionipadilha/dataloom/actions/workflows/ci.yml) ![Python](https://img.shields.io/badge/python-3.9%2B-blue) ![License](https://img.shields.io/badge/license-MIT-green)
+
+<img width="2752" height="1536" alt="DataLoom: Um motor de orquestração multi-thread leve, eficiente e seguro para Python." src="https://github.com/user-attachments/assets/c1f3fc98-5eaf-4add-a38c-2717ae699cd5" />
+
+O **DataLoom** é uma biblioteca projetada para processar fluxos de dados utilizando o padrão **Produtor-Consumidor** com múltiplas threads (Weavers). Ele abstrai a complexidade de filas (`Queues`), sincronização (`Locks`) e gerenciamento de ciclo de vida, permitindo que você foque apenas na lógica de transformação dos dados.
+
+## Por que usar o DataLoom?
+⚡ Performance: Processamento paralelo real para tarefas I/O bound.
+🧩 Simplicidade: API intuitiva inspirada na metáfora de tecelagem.
+🛡️ Segurança: Thread-safety garantido por design em todo o pipeline.
+📦 Leve: Dependências mínimas, pronto para rodar em qualquer ambiente Python.
+
+### Por que não usar só `ThreadPoolExecutor`?
+
+Pergunta justa — a stdlib resolve o *paralelismo*, mas não o *pipeline*. O
+`concurrent.futures` te dá um pool de threads; tudo ao redor fica por sua conta:
+
+| Você precisa de...                                  | Com a stdlib             | Com o DataLoom                    |
+| --------------------------------------------------- | ------------------------ | --------------------------------- |
+| Fluxo contínuo produtor-consumidor                   | `Queue` + loops manuais  | `Loom` + `Source`                 |
+| Backpressure (produtor mais rápido que consumidores) | `Queue(maxsize=...)` manual | Padrão, configurável            |
+| Shutdown limpo (drenar fila, fechar recursos)        | Sentinelas e joins manuais | `stop()` / `with Loom(...)`     |
+| Worker que sobrevive a erros e os reporta            | try/except em cada worker | `hooks.on_error` centralizado    |
+| Métricas por item processado                         | Instrumentação manual    | `hooks.on_batch_processed`        |
+| Escrita concorrente segura em arquivo                | Lock manual              | Sinks prontos (JSON, CSV, callback) |
+
+Se o seu caso é "aplicar uma função a uma lista e coletar os resultados",
+use `ThreadPoolExecutor.map` — é a ferramenta certa. O DataLoom é para
+**fluxos contínuos ou longos** onde ciclo de vida, resiliência e
+observabilidade importam. E, como toda solução baseada em threads no
+CPython, o ganho de paralelismo vale para cargas **I/O bound**; para
+CPU bound, prefira multiprocessing.
+
+## ✨ Características
+
+- **API Coesa:** Conceitos alinhados (`Loom`, `Weaver`, `Sink`).
+- **Concorrente:** Gerencia automaticamente múltiplos _Weavers_ (threads) em paralelo.
+- **Seguro:** Sinks padrão são thread-safe e exceções são tipadas (`LoomError`).
+- **Resiliente:** Erros de processamento não derrubam os Weavers e são reportados via hooks.
+- **Gerenciável:** `Loom` é um context manager — `with Loom(...) as loom:` garante `stop()` automático.
+- **Backpressure:** Fila de tarefas limitada por padrão (`queue_maxsize`), evitando crescimento de memória sem controle.
+- **Observável:** Hooks de ciclo de vida e métricas por lote (`on_batch_processed` com resultado e duração), além de Logs integrados.
+
+## 📦 Instalação
+
+```bash
+pip install dataloom-engine
+```
+
+> ⚠️ **Atenção ao nome:** o pacote instala o módulo `dataloom_engine`
+> (`import dataloom_engine`). Não confunda com o pacote `dataloom` do PyPI,
+> que é um ORM de outro autor e não tem relação com este projeto.
+
+Para desenvolver ou usar a versão mais recente do repositório:
+
+```bash
+git clone https://github.com/dionipadilha/dataloom.git
+cd dataloom
+pip install -e .
+```
+
+## 🚀 Uso Rápido
+
+Aqui está um exemplo completo de como tecer um pipeline de dados:
+
+```python
+from pathlib import Path
+import numpy as np
+from dataloom_engine import (
+    Loom,
+    LoomConfig,
+    LoomLogs,
+    Processor,
+    JsonFileSink,
+    ThreadedBufferedSink
+)
+from dataloom_engine.sources import RandomNumPySource
+
+# 1. Defina sua lógica de processamento (Stateless)
+class MyFilterProcessor(Processor):
+    def process(self, batch: np.ndarray) -> dict:
+        # 'batch' é um array numpy com o tamanho definido na config
+        avg = float(batch.mean())
+        return {
+            "processed_items": len(batch),
+            "average_value": avg,
+            "status": "high" if avg > 0.5 else "low"
+        }
+
+# 2. Configuração Inicial
+if __name__ == "__main__":
+    # Configura logs no console
+    LoomLogs.setup()
+
+    # Define parâmetros do motor
+    config = LoomConfig(
+        output_dir=Path("./data_out"),
+        batch_size=100,      # Processa 100 itens por vez
+        interval_seconds=1   # Gera um novo lote a cada 1 segundo
+    )
+
+    # 3. Fonte de Dados
+    # Agora desvinculada do motor, permitindo fontes customizadas (DB, CSV, S3)
+    source = RandomNumPySource(config)
+
+    # 4. Sink Arquivado e Otimizado
+    # ThreadedBufferedSink evita que o I/O bloqueie o processamento
+    file_sink = JsonFileSink(config.output_dir)
+    sink = ThreadedBufferedSink(file_sink)
+
+    # 5. Inicializa o Loom (O Orquestrador)
+    loom = Loom(
+        config=config,
+        processor=MyFilterProcessor(),
+        sink=sink,
+        source=source,
+        num_weavers=4  # 4 Threads trabalhando em paralelo
+    )
+
+    print("🧵 DataLoom iniciado! Pressione Ctrl+C para parar.")
+    try:
+        # O context manager garante stop() e limpeza dos recursos,
+        # mesmo em caso de exceção ou Ctrl+C
+        with loom:
+            loom.start()
+    except KeyboardInterrupt:
+        print("\n🛑 Tear parado.")
+```
+
+## 🏗️ Arquitetura
+
+O DataLoom utiliza uma metáfora de tecelagem:
+
+- **Loom (Tear):** A máquina principal. Gerencia a fila de tarefas e o ciclo de vida.
+- **Weaver (Tecelão):** As threads trabalhadoras. Elas pegam a matéria-prima (batch), processam e entregam.
+- **Processor:** A lógica de negócio. Transforma dados brutos em informação.
+- **Sink:** O destino final. Onde o produto acabado é depositado (ex: `JsonFileSink`, `CsvFileSink`, ou qualquer destino via `CallbackSink`).
+
+## 🛠️ Desenvolvimento e Testes
+
+Para contribuir com o projeto ou rodar os testes unitários:
+
+1.  Instale as dependências de desenvolvimento:
+
+    ```bash
+    pip install -e ".[dev]"
+    ```
+
+2.  Rode a suíte de testes (via pytest):
+    ```bash
+    pytest
+    ```
+
+## 📄 Licença
+
+Este projeto está licenciado sob a licença MIT - veja o arquivo [LICENSE](LICENSE) para detalhes.
+
+## 🗒️ Histórico de versões
+
+As mudanças de cada versão estão documentadas no [CHANGELOG](CHANGELOG.md).

dataloom_engine-0.3.0/dataloom_engine/__init__.py

@@ -0,0 +1,43 @@
+# dataloom_engine/__init__.py
+
+"""
+DataLoom: Um motor de orquestração multi-thread leve e eficiente.
+
+Este módulo expõe a API pública do pacote. Observe que classes internas
+como 'Weaver' não são expostas propositalmente, mantendo a superfície
+de uso limpa e segura para o consumidor.
+"""
+
+from dataloom_engine.config import LoomConfig
+from dataloom_engine.exceptions import ConfigurationError, LoomError, WeaverError
+from dataloom_engine.hooks import LoomHooks
+from dataloom_engine.logs import LoomLogs
+from dataloom_engine.loom import Loom
+from dataloom_engine.processors import Processor
+from dataloom_engine.sinks import (
+    CallbackSink,
+    CsvFileSink,
+    JsonFileSink,
+    Sink,
+    ThreadedBufferedSink,
+)
+from dataloom_engine.sources import Source
+from dataloom_engine.types import LoomState
+
+__all__ = [
+    "Loom",
+    "LoomConfig",
+    "LoomState",
+    "Processor",
+    "Sink",
+    "JsonFileSink",
+    "CsvFileSink",
+    "CallbackSink",
+    "ThreadedBufferedSink",
+    "Source",
+    "LoomHooks",
+    "LoomLogs",
+    "LoomError",
+    "WeaverError",
+    "ConfigurationError",
+]

dataloom_engine-0.3.0/dataloom_engine/config.py

@@ -0,0 +1,52 @@
+# dataloom_engine/config.py
+
+"""
+Gerenciamento de configuração do orquestrador.
+Centraliza parâmetros operacionais como diretórios e tamanhos de lote.
+"""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Union
+
+from dataloom_engine.exceptions import ConfigurationError
+
+
+@dataclass
+class LoomConfig:
+    """
+    Objeto de configuração principal do DataLoom.
+
+    Args:
+        output_dir (Path): Diretório base onde os Sinks padrão salvarão dados.
+            Strings são convertidas para Path automaticamente.
+        batch_size (int): Quantidade de itens gerados por ciclo de processamento.
+        interval_seconds (float): Intervalo de tempo entre gerações de tarefas.
+        queue_maxsize (Optional[int]): Capacidade máxima da fila de tarefas
+            (backpressure). None usa o padrão do Loom (num_weavers * 4);
+            0 significa fila ilimitada.
+
+    Raises:
+        ConfigurationError: se algum parâmetro for inválido.
+    """
+
+    output_dir: Union[str, Path]
+    batch_size: int = 10
+    interval_seconds: float = 1.0
+    queue_maxsize: Optional[int] = None
+
+    def __post_init__(self) -> None:
+        self.output_dir = Path(self.output_dir)
+
+        if self.batch_size <= 0:
+            raise ConfigurationError(
+                f"batch_size deve ser maior que zero (recebido: {self.batch_size})."
+            )
+        if self.interval_seconds < 0:
+            raise ConfigurationError(
+                f"interval_seconds não pode ser negativo (recebido: {self.interval_seconds})."
+            )
+        if self.queue_maxsize is not None and self.queue_maxsize < 0:
+            raise ConfigurationError(
+                f"queue_maxsize não pode ser negativo (recebido: {self.queue_maxsize})."
+            )

dataloom_engine-0.3.0/dataloom_engine/exceptions.py

@@ -0,0 +1,25 @@
+# dataloom_engine/exceptions.py
+
+"""
+Exceções personalizadas para o DataLoom.
+Permite que consumidores capturem erros específicos da biblioteca
+sem depender de exceções genéricas do Python.
+"""
+
+
+class LoomError(Exception):
+    """Exceção base para todos os erros do DataLoom."""
+
+    pass
+
+
+class ConfigurationError(LoomError):
+    """Lançado quando há problemas na validação do LoomConfig."""
+
+    pass
+
+
+class WeaverError(LoomError):
+    """Lançado quando um Weaver falha de forma irrecuperável."""
+
+    pass

dataloom_engine-0.3.0/dataloom_engine/hooks.py

@@ -0,0 +1,50 @@
+# dataloom_engine/hooks.py
+
+"""
+Pontos de extensão para observabilidade (Hooks).
+Permite injetar lógica de monitoramento sem acoplar ao core do engine.
+"""
+
+from typing import Any, Dict
+
+
+class LoomHooks:
+    """
+    Classe base para hooks do ciclo de vida.
+    Todos os métodos são opcionais e no-op por padrão: sobrescreva apenas
+    os pontos de interesse. (Deliberadamente não é um ABC — não há método
+    obrigatório a implementar.)
+    """
+
+    def on_start(self) -> None:
+        """Chamado imediatamente antes dos Weavers serem iniciados."""
+        pass
+
+    def on_stop(self) -> None:
+        """Chamado após o encerramento gracioso do orquestrador."""
+        pass
+
+    def on_error(self, error: Exception) -> None:
+        """
+        Chamado quando ocorre uma exceção no loop principal do Loom ou
+        durante o processamento de um lote em um Weaver (WeaverError).
+
+        Atenção: pode ser invocado a partir de múltiplas threads Weaver
+        simultaneamente — implementações devem ser thread-safe.
+        """
+        pass
+
+    def on_batch_processed(self, result: Dict[str, Any], duration_seconds: float) -> None:
+        """
+        Chamado após cada lote processado e entregue ao Sink com sucesso.
+
+        Args:
+            result: O dicionário produzido pelo Processor para o lote.
+            duration_seconds: Tempo gasto em process() + send(), medido
+                com relógio monotônico.
+
+        Atenção: assim como on_error, é invocado a partir das threads
+        Weaver — implementações devem ser thread-safe e rápidas, pois
+        rodam no caminho quente do pipeline.
+        """
+        pass

dataloom_engine-0.3.0/dataloom_engine/logs.py

@@ -0,0 +1,28 @@
+# dataloom_engine/logs.py
+
+"""
+Utilitários de configuração de logging para o DataLoom.
+Fornece um namespace estático para configuração rápida.
+"""
+
+import logging
+
+
+class LoomLogs:
+    """
+    Namespace utilitário para gerenciamento de logs do DataLoom.
+    Não deve ser instanciado, apenas usado estaticamente.
+    """
+
+    @staticmethod
+    def setup(level: int = logging.INFO) -> None:
+        """
+        Configura o logging básico para stdout.
+
+        Uso:
+            LoomLogs.setup(level=logging.DEBUG)
+        """
+        logging.basicConfig(
+            level=level,
+            format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+        )