semvec/pypi-packages huggingface dataset:
rdbpython 0.2.1
Python bindings for RocksDB with Cython
Requires Python: >=3.9
Keywords: rocksdb, database, key-value, storage, embedded, cython

# rdbpy

[![Build Wheels](https://github.com/everyabc/rdbpy/actions/workflows/build.yml/badge.svg)](https://github.com/everyabc/rdbpy/actions/workflows/build.yml)
[![Tests](https://github.com/everyabc/rdbpy/actions/workflows/test.yml/badge.svg)](https://github.com/everyabc/rdbpy/actions/workflows/test.yml)
[![PyPI version](https://badge.fury.io/py/rdbpython.svg)](https://pypi.org/project/rdbpython/)
[![Python Versions](https://img.shields.io/pypi/pyversions/rdbpython.svg)](https://pypi.org/project/rdbpython/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Python bindings for RocksDB with Cython - **batteries included!**

**No RocksDB installation required** - everything is bundled in the wheel for Linux and macOS (Intel + Apple Silicon).

## Installation

```bash
pip install rdbpython
```

That's it! No need to install RocksDB or any compression libraries manually.

## Usage

```python
import rdbpy

# Open database
options = rdbpy.Options(create_if_missing=True)
db = rdbpy.DB('/path/to/db', options)

# Put/Get
db.put(b'key', b'value')
value = db.get(b'key')

# Iterate
it = db.iterkeys()
it.seek_to_first()
while it.valid():
    print(it.key())
    it.next()
```

## Development

```bash
# Setup
make install

# Build
make build

# Test
make test
```

## License

MIT
candy-bar 2.0.3
A simple progress bar with the ILoveCandy style
Requires Python: >=3.9
Keywords: cython, cpp, wrapper

# CandyBar

A Progress Bar inspired by Arch pacman with `ILoveCandy` option enabled.

![CandyBar](https://raw.githubusercontent.com/MacDumi/CandyBar/refs/heads/main/images/candybar.gif)

## Usage

Import the package and create the progress bar object:

```python
from candy_bar import CandyBar

cb = CandyBar(100, "Progress")
```

### Parameters

| Parameter      | Default        | Description                                             |
| ---            | ---            | ---                                                     |
| iterable       | `None`         | Iterable object                                         |
| total          | `None`         | Defines the value for 100% if not used with an iterable |
| message        | `None`         | Write some text at the beginning of the line            |
| messageWidth   | `message width`| Size (in chars) of the message (padded with spaces).    |
| width          | `console size` | Size (in chars) of the full progress bar.               |
| linePos        |   0            | Line position in case of nested progress bars.          |
| leftJustified  |   true         | Defines the justification of the message.               |
| disable        |   false        | When set, the progress bar will be disabled.            |

To update the position of the progress bar use the `update` method:

```python
total = 100

for i in range(total):
    # Your code goes here
    cb.update(i + 1)

# Use it as an iterable
for i in CandyBar(range(total), message="Progress"):
    # your code here
    # no need to call the update
```

The progress bar can be disabled:

```python
def function(verbose):
    ...
    cb.disable(not verbose)
    ...
```

The __total__ value, the __message__, and the __justification__ of the progress bar can be changed:

```python
cb.total = 150

cb.setMessage("Another message")
# optionally, provide the width of the message (will be padded with white spaces)
cb.setMessage("Another message", 32)

cb.setLeftJustified(False)
```

__Multiple progress bars__:

In case of nested progress bars, it is necessary to set the appropriate **linePos**.
The value should be 0 for the _lowest_ progress bar and incremented for higher ones.

```python
for i in CandyBar(range(100), message="Outer", linePos=1):
    for j in CandyBar(range(50), message="Inner", linePos=0):
        # your code here

# The linePos can be also updated
# cb = CandyBar(100, "Progress")
cb.linePos = 1
```


#### Like what I do?

Buy me coffee
<img src="https://web.getmonero.org/press-kit/symbols/monero-symbol-480.png" alt="Donate with monero" width="15"/> `85jJPcfLPZRUKm3Re6qHZsKBZskVS2tYMWFoY5sYXUSQJzqzqpuPFepXMtqTKCRfuhYXaiJ3zQVeRPDYJUfepVjnJDpApH5`
skills-ref 0.1.1
Reference library for Agent Skills
Requires Python: >=3.11
Keywords: agents, ai, automation, llm, skills

# Agent Skills

[Agent Skills](https://agentskills.io) are a simple, open format for giving agents new capabilities and expertise.

Skills are folders of instructions, scripts, and resources that agents can discover and use to perform better at specific tasks. Write once, use everywhere.

## Installation

```bash
pip install skills-ref
```

Or using [uv](https://docs.astral.sh/uv/):

```bash
uv add skills-ref
```

## Quick Start

### CLI Usage

```bash
# Validate a skill
agentskills validate path/to/skill

# Read skill properties (outputs JSON)
agentskills read-properties path/to/skill

# Generate <available_skills> XML for agent prompts
agentskills to-prompt path/to/skill-a path/to/skill-b
```

### Python API

```python
from pathlib import Path
from skills_ref import validate, read_properties, to_prompt

# Validate a skill directory
errors = validate(Path("my-skill"))
if errors:
    print("Validation errors:", errors)
else:
    print("Valid skill!")

# Read skill properties
props = read_properties(Path("my-skill"))
print(f"Skill: {props.name}")
print(f"Description: {props.description}")

# Generate prompt XML for agent integration
prompt = to_prompt([Path("skill-a"), Path("skill-b")])
print(prompt)
```

## Features

- **Validation**: Check skills for proper format and required fields
- **Parsing**: Extract skill metadata from SKILL.md frontmatter
- **Prompt Generation**: Create XML blocks for agent system prompts
- **i18n Support**: Full Unicode support for international skill names
- **CLI Tools**: Command-line utilities for skill management

## Documentation

- [Full Documentation](https://agentskills.io) - Guides and tutorials
- [Specification](https://agentskills.io/specification) - Format details
- [Example Skills](https://github.com/anthropics/skills) - See what's possible

## About

Agent Skills is an open format maintained by [Anthropic](https://anthropic.com) and open to contributions from the community.

## License

Apache 2.0
stockstash 0.1
Intelligent time-series caching with Parquet and gap-aware incremental downloads
Requires Python: >=3.9
Keywords: timeseries, cache, parquet, finance, yfinance, pandas

# stockstash

**Intelligent local caching for time-series APIs using Parquet**

`stockstash` provides incremental, gap-aware caching for time-series data.
It avoids re-downloading overlapping date ranges and stores data using Parquet.

This library is especially useful for financial data APIs such as **yfinance**,
so that you dont need to download same data again.

---

## ✨ Features

- 📦 Local persistent cache using Parquet
- 🧠 Intelligent gap detection (downloads only missing dates)
- 🔌 Provider abstraction (yfinance included)
- 🗂 One file per symbol (simple & scalable)
- ♻ Reusable across sessions
---

## 📦 Installation

```bash
pip install stockstash
```

## 🚀 Quick Start

Take a look at the example: 
```
python examples/yfinance_example.py
```

```
from stockstash import TimeSeriesCache, ParquetStore, YFinanceProvider

cache = TimeSeriesCache(
    store=ParquetStore("./data"),
    provider=YFinanceProvider(),
)

df = cache.load(
    key="BTC-USD",
    start="2023-01-01",
    end="2023-12-31",
)

print(df.tail())
```

On subsequent runs, only missing dates are downloaded.

## 🧠 How It Works

Cached data is loaded from a local Parquet file

Missing date ranges are automatically detected

Only missing ranges are fetched from the API

New data is merged and deduplicated

Cache is updated on disk

## 📁 Cache Layout
```
data/
└── AAPL.parquet
└── ETH-USD.parquet
```

Each file contains a Pandas DataFrame indexed by DatetimeIndex.

## 🔌 Supported Providers
yfinance (built-in) 
from stockstash import YFinanceProvider


You can add your own provider by implementing:
```
class Provider:
    def fetch(self, key: str, start, end):
        ...
```
OverReacher 1.0.2
A scanner for CORS misconfiguration vulnerabilities
Requires Python: >=3.8
Keywords: cors, security, pentest, bugbounty, tool, automation


# OverReacher - A Convenient CORS Scanner

![Screenshot](https://raw.githubusercontent.com/Zipnx/OverReacher/master/screenshot.png)

OverReacher is a security research tool, meant to scan and find CORS misconfiguration vulnerabilities.

Made this tool based on functionality from [Corsy](https://github.com/s0md3v/Corsy)

## Getting Started

### Pipx install

OverReacher can be easily installed using:
```
pipx install overreacher
```

Afterwards you can check the usage with:
```
overreacher.py -h
```

### Pip install

A normal pip install also works:
```
pip install overreacher
```

But, unless it's a global install, which is not recommended, you need to do additional setup on your own

### Manual install

Instead of installing the package using pip or pipx, OverReacher can be setup manually.
Just git clone the repo and then do the following:

Setup a virtual environment using the tool you prefer (venv in this case), and activate it
```
python3 -m venv ./venv
source venv/bin/activate
```

Then install the base requirements
```
pip install -r requirements.txt
```

Afterwards you can run overreacher in the following ways:
```
python3 -m overreacher
```

Or through the run script, which you can alias or symlink to your liking:
```
chmod +x ./run
./run -h
```

NOTE: To run you still need to use the virtual environments python interpreter

## Configuration

OverReacher is made to be easily customizable. This is incredibly helpful in BugBounty, where you might say, want to customize headers/cookies depending on the target.
(eg. Setting a hackerone header, which some programs require)

In addition to configuration in the config.ini file, you can also customize attacks and add your own in the attacks.json file.

To make a new configuration, simply run
```
overreacher --make-config
```

This will make a local .overreacher directory which the tool will automatically be setup to use.
If the directory already exists, it will be set as the configuration of the tool with no additional changes.

In this fashion you can change configurations depending on your needs and projects, and reset to normal with:
```
overreacher --reset-config
```


## Usage

An attack can be tested against a certain url or a comma separated list of urls as such:

`
overreacher -u https://example.com/,https://google.com/
`

Alternatively the url's can be loaded from a file

`
overreacher.py -i [FILE]
`

Or piped through stdin

`
cat exampleurlfile.txt | overreacher 
`

## TODO:
In [TODO.md](./TODO.md)
overload-ai 1.1.0
AI-powered Python bug identification client
Requires Python: >=3.8
Keywords: python, ai, bug-detection, static-analysis, linting

# Overload AI Client

AI-powered Python bug identification client library.

## Installation

```bash
pip install overload-ai
```

## Usage

```python
from overload_ai import analyze_code

# Analyze code string
code = """
def divide(a, b):
    return a / b

result = divide(10, 0)
"""

bugs = analyze_code(code)
for bug in bugs:
    print(f"{bug['severity']}: {bug['description']}")
```

### File Analysis

You can also analyze Python files directly:

```python
from overload import analyze_code

# Analyze a Python file
bugs = analyze_code("my_script.py")
for bug in bugs:
    print(f"{bug['severity']}: {bug['description']}")
```

## Features

- Detect syntax bugs, runtime exceptions, logic flaws, security vulnerabilities
- Simple API with automatic file/code detection
- Custom timeout and error handling

## Configuration

Set environment variables:

- `OVERLOAD_BASE_URL`: Custom API base URL (default: https://overload-api.onrender.com)
- `OVERLOAD_API_KEY`: API key if required (future feature)

## License

MIT License