semvec/pypi-packages huggingface dataset:
py_log_mjk 0.1.5
Um pacote de logging completo e profissional para aplicações Python.
License: MIT
Requires Python: >=3.12
Keywords: python, logging, toolkit, log, logging-library

# py-log-mjk

### **Um pacote de logging completo e profissional para aplicações Python.**

[![PyPI version](https://badge.fury.io/py/py-log-mjk.svg)](https://badge.fury.io/py/py-log-mjk)
[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)
[![Python 3.12](https://img.shields.io/badge/Python-3.12-blue.svg)](https://www.python.org/downloads/release/python-3120/)

## **Visão Geral**

O `py-log-mjk` é uma solução de logging robusta e fácil de usar para projetos em Python. Ele foi projetado para ser configurado de forma declarativa, permitindo que você personalize o comportamento do logging sem precisar alterar o código da sua aplicação.

Com o `py-log-mjk`, você obtém:

- **Configuração Simples**: Gerenciamento de configurações através de um arquivo JSON.
- **Formatação Rica**: Saída de logs colorida e formatada com a biblioteca **`rich`**.
- **Logs Estruturados**: Logs em formato JSON para facilitar o monitoramento em ferramentas como o ELK Stack ou o Datadog.
- **Filtragem Avançada**: Controle de nível de log por módulo.
- **Processamento Assíncrono**: Desempenho otimizado com `QueueHandler` para processar logs em segundo plano.

## **Instalação**

Recomendamos usar o **Poetry** para gerenciar as dependências e o ambiente virtual.

```bash
# Adicione a biblioteca ao seu projeto
poetry add py-log-mjk

# Ou, se estiver desenvolvendo o pacote localmente, instale-o em modo editável
poetry install

Uso Básico
Basta importar a função get_logger e começar a usar.

# app.py
from py_log_mjk import get_logger

# Obtenha o logger. A configuração é automática.
logger = get_logger(__name__)

logger.info("A aplicação foi iniciada com sucesso!")
logger.debug("Esta é uma mensagem de depuração.")
logger.error("Ops, algo deu errado!", exc_info=True)

```

## **Créditos**
Este projeto é fruto de uma aula sobre logging do prof. Luiz Otávio Miranda!

```bash
Estude, copie, adapte, melhore e compartilhe! ☕

```
reddev 0.1.0
A legal red/blue/purple-team module for legal and ethical use only
License: MIT
Requires Python: >=3.8

# Reddevw

⚠️ Before I say anything else; **THIS IS A RED TEAM MODULE**!!!! I SWEAR, PLEASE PLEASE PLEASE DON'T USE THIS ILLEGALLY! I MADE THIS JUST TO HELP WITH OFFENSIVE CODING (in red teaming)!

If you DO infact use this illegaly:

1) You're stupid.
2) You ARE going to get arrested.
3) If you just go bare bones, you WILL be caught, this WILL be detected, and YOU WILL be in a LOT of trouble!

This is made for the intended purpose of ethical use, pentesting, red/blue/purple-teaming, and legality in mind.
pocketwatch 0.1.2
Drop-in stopwatch utility
License: MIT
Requires Python: >=3.9

# Pocketwatch

Pocketwatch provides a simple stopwatch for timing any block of Python code. It
can display desktop notifications, play a chime after long runs, and optionally
collect profiling statistics.

## Installation

```bash
pip install pocketwatch
```

## Basic Usage

```python
from pocketwatch import Pocketwatch

with Pocketwatch("load data"):
    load_data()
```

The context manager prints the elapsed time when the block finishes. Pass a
`logging.Logger` if you also want the output sent to a log. Notifications and
sound are disabled unless explicitly requested.

```python
with Pocketwatch(
    "big task",
    notify=True,          # show a pop-up
    notify_after=5.0,     # minimum duration before popup
    sound=True,           # play ding.wav
    sound_after=60.0,     # minimum duration for sound
):
    run_big_task()
```

You can capture intermediate checkpoints using `mark()` (or its alias
`log()`):

```python
with Pocketwatch("steps") as pw:
    load()
    pw.mark("loaded data")
    transform()
    pw.log("transformed")
```

To enable cProfile integration, pass `profile=True`.  By default the raw stats
are written to `profile_output.prof`; set `profile_output_path=None` to skip
writing the file.  Call `end(return_stats=True)` to retrieve a
`pstats.Stats` instance.

```python
with Pocketwatch(profile=True) as pw:
    crunch_numbers()
stats = pw.end(return_stats=True)
```

## Decorator Shortcut

A lightweight decorator mirrors the context manager. It uses the function name
as the message label and prints the elapsed time. Provide a logger argument to
forward output to your own logging setup.

```python
from pocketwatch.decorators import stopwatch

@stopwatch
def do_work():
    ...
```

Custom options may be supplied when decorating:

```python
@stopwatch(sound=True, notify=False)
def background_job():
    ...
```

## Features

- Drop-in context manager for timing code blocks
- Desktop notifications via [notifypy](https://pypi.org/project/notifypy/)
- Optional sound playback with bundled audio files
- Incremental mode to suppress output for short runs
- Optional logging to a custom logger
- Checkpointing with `mark()` or `log()`
- cProfile support with stats returned on request
- Works with Python 3.9+
- Licensed under the MIT license