semvec/pypi-packages huggingface dataset:
sphinxnotes-mock 1.1
Sphinx extension for masking unsupported directives and roles
Requires Python: >=3.12
Keywords: sphinx, extension, documentation, sphinxnotes

.. This file is generated from sphinx-notes/cookiecutter.
   You need to consider modifying the TEMPLATE or modifying THIS FILE.

================
sphinxnotes-mock
================

.. |docs| image:: https://img.shields.io/github/deployments/sphinx-notes/mock/github-pages
   :target: https://sphinx.silverrainz.me/mock
   :alt: Documentation Status
.. |license| image:: https://img.shields.io/github/license/sphinx-notes/mock
   :target: https://github.com/sphinx-notes/mock/blob/master/LICENSE
   :alt: Open Source License
.. |pypi| image:: https://img.shields.io/pypi/v/sphinxnotes-mock.svg
   :target: https://pypi.python.org/pypi/sphinxnotes-mock
   :alt: PyPI Package
.. |download| image:: https://img.shields.io/pypi/dm/sphinxnotes-mock
   :target: https://pypi.python.org/pypi/sphinxnotes-mock
   :alt: PyPI Package Downloads

|docs| |license| |pypi| |download|

Sphinx extension for masking unsupported directives and roles.

.. INTRODUCTION START 
   (MUST written in standard reStructuredText, without Sphinx stuff)

.. INTRODUCTION END

Please refer to Documentation_ for more details.

.. _Documentation: https://sphinx.silverrainz.me/mock
pyPodControl 0.0a1
Python implementation of iPod Accessory Protocol

# pyPodControl

Implementation of Apple iPod Accessory Protocol (iAP) over UART in Python

## How-To

Connect the iPod (or iPhone, or iPad) with a 30 pin docking connector via a breakout cable to a USB->UART adapter, or to a UART port on your SBC (not tested yet).

A 500k resistor on pin 21 may be needed. (In my testing it's been working without one)

**Important**: iPod uses TTL 3.3V serial

## Resources

-   [Official iPod Accessory Protocol Specification (archive.org)](https://archive.org/details/ipod-accessory-protocol-interface-specification/)
nats-key-value 0.0.0
NATS Key-Value Store functionality - package name reserved
Requires Python: >=3.8

# nats-key-value

This package name is reserved for future development of NATS Key-Value Store functionality.

## Status

This is currently a placeholder package. Full implementation coming soon.

## About NATS Key-Value Store

NATS Key-Value Store is a distributed key-value storage system built on top of NATS JetStream, providing Redis-like key-value operations with distributed consistency.

## Contact

For questions or inquiries, please contact the package maintainer.
nats-object 0.0.0
NATS Object Store functionality - package name reserved
Requires Python: >=3.8

# nats-object

This package name is reserved for future development of NATS Object Store functionality.

## Status

This is currently a placeholder package. Full implementation coming soon.

## About NATS Object Store

NATS Object Store is a high-performance object storage system built on top of NATS JetStream, providing S3-like object storage capabilities.

## Contact

For questions or inquiries, please contact the package maintainer.
nats-server 0.0.0
NATS server utilities - package name reserved
Requires Python: >=3.8

# nats-server

This package name is reserved for future development of NATS server utilities.

## Status

This is currently a placeholder package. Full implementation coming soon.

## About NATS Server

NATS server utilities for managing and interacting with NATS server instances.

## Contact

For questions or inquiries, please contact the package maintainer.
nats-jetstream 0.0.0
NATS JetStream functionality - package name reserved
Requires Python: >=3.8

# nats-jetstream

This package name is reserved for future development of NATS JetStream functionality.

## Status

This is currently a placeholder package. Full implementation coming soon.

## About NATS JetStream

NATS JetStream is a distributed persistence system built on top of NATS, providing streaming, message replay, and at-least-once delivery guarantees.

## Contact

For questions or inquiries, please contact the package maintainer.
overleaf 0.1.0
Add your description here
Requires Python: >=3.10

# Overleaf MCP Server

MCP server that lets compatible clients (e.g., Claude Desktop, Cursor, VS Code) interact with Overleaf projects via tools and resources.

## Features

- List projects and files.
- Read files.
- Safe, read-only mode.

Adjust to match your implementation.

## Requirements

- Python 3.10+
- An Overleaf account (or session cookie)

## Configure a client

### Claude Desktop

Edit claude_desktop_config.json:

```json
{
  "mcpServers": {
    "overleaf": {
      "command": "uv",
      "args": [
        "run",
        "mcp",
        "run",
        "/Volumes/Life/Python/Overleaf/overleaf_mcp/__main__.py"
      ],
      "env": {
        "PROJECT_ID": "<YOUR_PROJECT_ID>",
        "OVERLEAF_TOKEN": "<YOUR_OVERLEAF_TOKEN>"
      },
      "timeout": 120000
    }
  }
}
```

If you have a console script, set "command": "overleaf-mcp" and remove "args".

### Cursor (settings.json)

```json
{
  "mcpServers": {
    "overleaf": {
      "command": "uv",
      "args": [
        "run",
        "mcp",
        "run",
        "/Volumes/Life/Python/Overleaf/overleaf_mcp/__main__.py"
      ],
      "env": {
        "PROJECT_ID": "<YOUR_PROJECT_ID>",
        "OVERLEAF_TOKEN": "<YOUR_OVERLEAF_TOKEN>"
      }
    }
  }
}
```

### VS Code MCP (.vscode/mcp.json)

```jsonc
{
  "servers": {
    "my-mcp-server-overleaf": {
      "type": "stdio",
      "command": "uv",
      "args": [
        "run",
        "mcp",
        "run",
        "/Volumes/Life/Python/Overleaf/overleaf_mcp/__main__.py"
      ],
      "env": {
        "PROJECT_ID": "<YOUR_PROJECT_ID>",
        "OVERLEAF_TOKEN": "<YOUR_OVERLEAF_TOKEN>"
      }
    }
  },
  "inputs": []
}
```

## Tools

<TBD>
stockalert 2.0.1
Official Python SDK for StockAlert.pro API
Requires Python: >=3.8
Keywords: alerts, api, finance, sdk, stockalert, stocks, trading

# StockAlert.pro Python SDK

Official Python SDK for the StockAlert.pro API.

## Installation

```bash
pip install stockalert
```

## Quick Start

```python
from stockalert import StockAlert

# Initialize the client
client = StockAlert(api_key="sk_your_api_key")

# List all alerts
alerts = client.alerts.list()

# Create a new alert
alert = client.alerts.create(
    symbol="AAPL",
    condition="price_above",
    threshold=200,
    notification="email"
)

# Update alert status
client.alerts.update(alert.id, status="paused")

# Delete alert
client.alerts.delete(alert.id)
```

## Features

- 🐍 Python 3.7+ support
- 🔄 Automatic retries with exponential backoff
- 🛡️ Type hints for better IDE support
- 📦 Minimal dependencies
- 🧪 Comprehensive test suite
- 📚 Detailed documentation

## Async Support

The SDK also supports async operations:

```python
import asyncio
from stockalert import AsyncStockAlert

async def main():
    async with AsyncStockAlert(api_key="sk_your_api_key") as client:
        alerts = await client.alerts.list()
        print(f"Found {len(alerts.data)} alerts")

asyncio.run(main())
```

## Documentation

Full documentation is available at [https://stockalert.pro/api/docs](https://stockalert.pro/api/docs)

## License

MIT
## 🎯 More Examples

### Pagination
```python
# Iterate through all alerts efficiently
for alert in client.alerts.iterate():
    print(f"{alert.symbol}: {alert.condition}")
```

### Error Handling
```python
from stockalert import StockAlert, APIError, RateLimitError

try:
    alert = client.alerts.create(
        symbol="AAPL",
        condition="price_above",
        threshold=200
    )
except RateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after} seconds")
except APIError as e:
    print(f"API error: {e.message} (status: {e.status_code})")
```

### Environment Variables
```python
import os
from stockalert import StockAlert

# API key from environment variable
client = StockAlert(api_key=os.environ["STOCKALERT_API_KEY"])
```

### Async Usage
```python
import asyncio
from stockalert import AsyncStockAlert

async def main():
    async with AsyncStockAlert(api_key="sk_your_api_key") as client:
        alerts = await client.alerts.list()
        print(f"Found {len(alerts['data'])} alerts")

asyncio.run(main())
```
efficax 0.1.1
Extracts text from PDFs between keywords and adds rectangle overlays using PyMuPDF.
Requires Python: >=3.9
Keywords: pdf, pymupdf, text extraction, overlay, automation

## efficax

Simple tool for text extraction from pdf files and conversion 
to table format. This package features extraction from a defined
rectangle, start and end keywords for the extraction process as
well as automatic chapter identification by numbers. The result
is copied to the clipboard and a .csv file is saved to an output 
folder. Additionally a pdf with an overlay corresponding to the
extraction rectangle will be saved.


### Installation

```
pip install efficax
```


### Usage

```
from efficax import extract_text_with_overlay

extract_text_with_overlay(
    pdf_path="path/to/your/file.pdf,
    output_folder="folder/for/output",
    start_keyword="TITLE",
    end_keyword="The End",
    upper_border=0.2,
    lower_border=0.1,
    left_border=0.05,
    right_border=0.15
)
```
pydantic-cwe 0.1.2
A Pythonic representation of CWE records using Pydantic models.
Requires Python: >=3.9
Keywords: package, cwe, pydantic

# pydantic-cwe

`pydantic-cwe` provides a structured, object-oriented way to work with the Common Weakness Enumeration (CWE) database. 
By modeling CWE entries as Pydantic objects, this library enables developers and security researchers to 
programmatically access, validate, and manipulate CWE data with ease. Ideal for static analysis tools, vulnerability 
scanners, or custom security pipelines.

## Installation

```bash
pip install pydantic-cwe
```

## Usage

### Loading a CWE catalog

```python
from pydantic_cwe import Loader

# Create a loader instance
loader = Loader()

# Load the catalog
catalog = loader.load()

# Print some basic information about the catalog
print(f"Catalog Name: {catalog.name}")
print(f"Catalog Version: {catalog.version}")
print(f"Catalog Date: {catalog.date}")
print(f"Number of weaknesses: {len(catalog.weaknesses.weaknesses)}")
```

### Working with weaknesses

```python
from pydantic_cwe import Loader

loader = Loader()
catalog = loader.load()

# Get weaknesses ordered by ID
for weakness in catalog.get_ordered_weaknesses():
    if weakness.status == 'Deprecated':
        continue

    print(f"ID: {weakness.id}")
    print(f"Name: {weakness.name}")
    print(f"Abstraction: {weakness.abstraction}")
    print(f"Structure: {weakness.structure}")
    print(f"Status: {weakness.status}")
    print(f"Description: {weakness.description}")
```

## Project Structure

The project follows a standard Python library structure:

- `examples/`: Example scripts
- `pydantic_cwe/`: Main package directory
  - `models`: Pydantic models for CWE data
  - `__init__.py`: Package initialization and exports
  - `loader.py`: XML loading and parsing functionality
- `tests/`: Unit tests

## Development

### Setting up the development environment

```bash
# Clone the repository
git clone https://github.com/epicosy/pydantic-cwe.git
cd pydantic-cwe

# Create a virtual environment
python -m venv env
source env/bin/activate  # On Windows: env\Scripts\activate

# Install development dependencies
pip install -e ".[test]"
```

### Running tests

```bash
pytest
```