semvec/pypi-packages huggingface dataset:
project-toolbox 0.4.9
A modular toolbox to support your Python development workflow
Requires Python: >=3.12

# project-toolbox

A modular toolbox to support your Python development workflow.
- `project-toolbox` provides the **box** of the toolbox as a unique command: `t`.
- Tools are selected/added to the box at the project level.


## Features

- one command (`t`) gathering all tools
  - prevent cluttering command namespace
  - completion even for tools installed in dedicated environment
- toolboxs are plugins
  - each project can select its own set of plugins
  - a plugin can be public (pypi) or shipped with the project
- tool calls are automatically embeded (eg `uv run ...`)
- tools are [click](https://click.palletsprojects.com/) commands


## Getting started

Install the main command globally:
```shell
uv tool install project-toolbox
```

Enable completion (bash) by adding the following to the end of your `~/.bashrc`:
```shell
eval "$(_T_COMPLETE=bash_source t)"
```
Instructions for completion with other shells [can be found here](https://click.palletsprojects.com/en/stable/shell-completion/#enabling-completion).

Manage the toolbox:
```shell
# show all 'self' subcommands
t self
# add a toolbox to current project
t self install <toolbox>
```

Read carefully crafted manuals guiding you through the workflow:
```shell
# show all 'manual' subcommands
t manual
```

Use the toolbox:
```shell
# show all commands
t
# use a tool
t <command> <arg1> <arg2> ...
```


## Filling the toolbox with tools

### Adding plugins to a project

Your toolbox need to be filled with tools.
The toolbox content is selected at project level and may differ between projects.
Use `t self install` to add a published toolbox to the project.

If your toolbox is not published, it can be shipped whithin the project repo and added locally:
```shell
uv add --dev path/to/plugin-package/
```

### Writing plugins

A `project-toolbox` plugin is a python package that defines some `click` commands and registers them to the dedicated entry points.
This is very similar to the usual way of creating console scripts, only the pyproject.toml entry changes from `[project.scripts]` to `[project.entry-points.'project_toolbox']`.

```toml
# pyproject.toml
[project.entry-points.'project_toolbox']
tool_name_1 = "package.module_1:object_1"
tool_name_2 = "package.module_2:object_2"
```
project-toolbox-default 0.4.9
A toolbox for my basic workflow on git+uv projects.
Requires Python: >=3.11

# project-toolbox-default

A [project-toolbox](https://pypi.org/project/project-toolbox/) plugin for my default development workflow.

## Getting started

If not done yet, [install uv](https://docs.astral.sh/uv/getting-started/installation/) and [project-toolbox](https://pypi.org/project/project-toolbox/).

Add the toolbox to the project:
```shell
cd path/to/project
t self install default
```
This will edit the 'pyproject.toml' file of the project.

Now you can use the toolbox:
```shell
# show all commands
t
# use a command
t <command> <arg1> <arg2> ...
```

## Philosophy

I want a toolbox to support my Python development workflow.
This toolbox does not cover all workflows.

For now, I'm working with git and uv.

Some general principles:
  - tools should make each step of the workflow simple and easy
  - tools should make the workflow easy to follow and remember
  - tools should automate repetitive tasks
  - tools should reduce the number of command to remember
  - tools should avoid mistakes by checking project sanity
  - tools should tell what they are doing
booboo-sdk 0.7.0
Lightweight error tracking for Python
Requires Python: >=3.9
Keywords: error-tracking, monitoring, debugging, exceptions, booboo

# booboo-sdk

[![PyPI version](https://img.shields.io/pypi/v/booboo-sdk.svg)](https://pypi.org/project/booboo-sdk/)
[![Python versions](https://img.shields.io/pypi/pyversions/booboo-sdk.svg)](https://pypi.org/project/booboo-sdk/)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

Official Python SDK for [booboo.dev](https://booboo.dev) error tracking.

## Installation

```bash
pip install booboo-sdk
```

## Quick Start

```python
import booboo

booboo.init("your-dsn-here")
```

That's it. Unhandled exceptions are automatically captured and sent to booboo.dev.

## Manual Capture

```python
try:
    risky_operation()
except Exception:
    booboo.capture_exception()  # captures the current exception
```

Or pass an exception explicitly:

```python
try:
    risky_operation()
except Exception as e:
    booboo.capture_exception(e)
```

## User Context

```python
booboo.set_user({
    "id": "123",
    "email": "user@example.com",
    "username": "alice",
})
```

## Framework Integration

### Django

Auto-detected — no extra setup needed. The SDK injects middleware and patches Django's internal exception handler to capture errors that never reach middleware (like `DisallowedHost`).

### Flask

```python
from flask import Flask
import booboo

app = Flask(__name__)
booboo.init("your-dsn-here", app=app)
```

Or without passing `app` — the SDK monkey-patches `Flask.__init__` to auto-register on any Flask app created after `init()`.

### FastAPI

```python
from fastapi import FastAPI
import booboo

app = FastAPI()
booboo.init("your-dsn-here", app=app)
```

Same auto-detection as Flask if `app` is not passed explicitly.

## Configuration

```python
booboo.init(
    dsn="your-dsn-here",
    endpoint="https://api.booboo.dev/ingest/",  # default
)
```

| Parameter | Default | Description |
|-----------|---------|-------------|
| `dsn` | (required) | Your project's DSN from booboo.dev |
| `endpoint` | `https://api.booboo.dev/ingest/` | Ingestion endpoint URL |
| `app` | `None` | Flask/FastAPI app instance for explicit registration |

## Features

- Automatic capture of unhandled exceptions
- Rich stack traces with source context and local variables
- Exception chain support (`raise ... from ...`)
- PII scrubbing for sensitive headers and variables
- Django, Flask, and FastAPI integrations
- Non-blocking event delivery
- Graceful shutdown flush
- Minimal dependency footprint (`requests` only)

## License

MIT