semvec/pypi-packages huggingface dataset:
python-docs-hook 0.1.13
A pre-commit hook to generate Python documentation
Requires Python: >=3.6

# Python Documentation Hook

A pre-commit hook that automatically generates documentation for Python files by extracting docstrings and function definitions.

## Features

- Automatically extracts Python docstrings
- Generates markdown documentation
- Updates README.md automatically in the same directory as Python files
- Handles nested function documentation
- Supports multiple Python files
- Preserves existing README content

## Installation

```bash
# Using pip
pip install python_docs_hook

# From source
git clone https://github.com/geek-kb/python_docs_hook.git
cd python_docs_hook
pip install -e .
```

## Usage

Add this to your `.pre-commit-config.yaml`:

```yaml
repos:
-   repo: https://github.com/geek-kb/python_docs_hook
    rev: v0.1.1
    hooks:
    -   id: python-docs
```

Install the pre-commit hook:

```bash
pre-commit install
```

## Configuration

The hook will:

- Look for Python files in your commits
- Generate documentation from docstrings
- Create/update README.md in the same directory as the Python files
- Use markers to update documentation sections:

  ```markdown
  <!-- BEGIN_PY_DOCS -->
## setup.py

<!-- END_PY_DOCS -->
  ```

## Example Output

<!-- BEGIN_PY_DOCS -->
## setup.py

<!-- END_PY_DOCS -->

## Development

Clone the repository and install in development mode:

```bash
git clone https://github.com/geek-kb/python_docs_hook.git
cd python_docs_hook
python -m venv venv
source venv/bin/activate
pip install -e .
```

## Contributing

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some
argumentation 0.1.0
Python argument parser for complex applications
Requires Python: >=3.9

# Argumentation
Argumentation is a Python library that bridges Pydantic models with argparse to create robust, type-safe command-line interfaces with minimal boilerplate. Define your application's configuration using Pydantic models, and Argumentation handles the command-line parsing, validation, and configuration file loading automatically.

## Features
- Type-safe Configuration: Utilize Pydantic's validation system for command-line arguments
- Configuration Files: Support for TOML, YAML, and JSON configuration files
- Automatic CLI Generation: Convert your Pydantic models into command-line interfaces automatically
- Rich Type Support: Handles complex types including:
    - Basic types (bool, int, float, str)
    - Lists and tuples
    - Literal types with choices
    - Union types
    - Custom Pydantic models

## Installation
1. uv (recommended)
```bash
uv add argumentation
```
2. poetry
```bash
poetry add argumentation
```
3. pip
```bash
pip install argumentation
```

## Usage

1. Create your configuration model using the ArgumentationModel
1. Create your main function which takes the configuration as an argument
1. Call the argumentation.run function with your main function

See `examples/simple.py` for more details

```bash
python examples/simple.py --name "My Application" --debug --port 5000 --hosts localhost 127.0.0.1
```

### Configuration Files

Argumentation supports loading configuration from TOML, YAML, and JSON files.
```bash
python examples/config.py --config examples/config.yaml
```

You can also override configuration file values from the command line.
```bash
python examples/simple.py --config examples/config.yaml --port 8888
```

## License

Argumentation is licensed under the MIT License. See the LICENSE file for details.
apollo-tracker 0.1.4
A lightweight Flask middleware that captures and reports errors to Apollo, a centralized error tracking system.
Requires Python: >=3.6

# Apollo Tracker

Apollo Tracker is a lightweight Flask middleware for tracking and reporting errors to **Apollo**, an internal error tracking system similar to Sentry.

## Features

- 🛠 **Automatic Error Tracking**: Captures and reports all unhandled exceptions.
- 🚀 **Flask Integration**: Works seamlessly with Flask applications.
- 📡 **Send Errors to Apollo**: Forwards error logs to an Apollo backend.
- 🔍 **Includes Request Metadata**: Logs IP address, user agent, endpoint, and method.
- 📦 **Simple Installation**: Just `pip install apollo-tracker`.

## Installation

You can install `apollo-tracker` using `pip`:

```bash
pip install apollo-tracker
```

## Usage

### 1. Setup `ApolloTracker` in Your Flask App

To start tracking errors in your Flask app, follow these steps:

1. **Import the ApolloTracker class**:

   ```python
   from apollo_tracker.tracker import ApolloTracker
   ```
2. **Initialize the tracker with your service name**:

   ```python
   tracker = ApolloTracker(service_name="projet_uid")
   ```
3. **Register the error handler**:

   ```python
   tracker.register_error_handler(app)
   ```

### 2. Example Flask App Setup

```python
from flask import Flask
from apollo_tracker.tracker import ApolloTracker  # import the tracker class

app = Flask(__name__)

# Initialize ApolloTracker with your service name
tracker = ApolloTracker(service_name="my_project_id")

# Register the error handler to track errors globally
tracker.register_error_handler(app)

@app.route('/')
def home():
    # Simulate an error
    1 / 0  # This will raise a ZeroDivisionError

if __name__ == "__main__":
    app.run(debug=True)
```

### 3. Error Handling

- The `ApolloTracker` class automatically captures unhandled exceptions in your Flask app.
- When an error occurs, it sends detailed information (like the error type, message, stack trace, request path, and user agent) to the Apollo server.
ansible-tools 0.5.0
Keyring integration and local execution wrappers for Ansible
Requires Python: >=3.8
Keywords: ansible, keyring, local, tools, wrapper

# ansible-tools

[![PyPI Version](https://img.shields.io/pypi/v/ansible-tools.svg)](https://pypi.python.org/pypi/ansible-tools)
[![PyPI Downloads](https://img.shields.io/pypi/dm/ansible-tools.svg)](https://pypi.python.org/pypi/ansible-tools)
[![MIT License](https://img.shields.io/badge/license-mit-blue.svg)](https://choosealicense.com/licenses/mit/)

This is a set of wrappers around the `ansible`, `ansible-playbook` and `ansible-vault` commands
which integrate with the system keyring to retrieve the vault password.

It should work on both Linux and macOS.

# Installation

* On macOS, with Homebrew: `brew install lvillani/tap/ansible-tools`;
* With Pip: `pip install --user ansible-tools`;

It is best, however, to install `ansible-tools` in a Virtualenv, along with the version of Ansible
you are using.

# Overview

- `ansible-vault-helper`: Used by users to setup keyring integration, called by Ansible to obtain a
  Vault unlock password.
- `vaultify`: Wraps Ansible commands such as `ansible`, `ansible-playbook` and `ansible-playbook` so
  that the Vault is automatically unlocked with the password stored in the system's keyring.
- `ansible-local`: Wrapper to run Ansible locally.
- `ansible-mkpasswd`: Generates an encrypted password that can be used with the user module (see also
  [here](https://docs.ansible.com/ansible/latest/reference_appendices/faq.html#how-do-i-generate-encrypted-passwords-for-the-user-module))

# Usage

Go to the same directory that contains your playbooks and then run:

    ansible-vault-helper --update

You will be prompted for a vault name (which can be anything) and the unlock password. The former is
stored in `ansible.cfg` alongside your playbooks, the latter is securely stored in your keyring.

At this point you can run Ansible as usual but precede the command with `vaultify`. That is, to
start a playbook run:

    vaultify ansible-playbook site.yml

We also ship a tool to easily apply a playbook on the current system called `ansible-local` which is
composable with `vaultify`.

# Aliases

Here's a list of handy shell aliases to make your life easier. They were tested on fish but should
work also on Bash and Zsh:

    alias v="vaultify"
    alias ansible="vaultify ansible"
    alias ansible-playbook="vaultify ansible-playbook"