semvec/pypi-packages huggingface dataset:
llm-pricing 0.1.3
A library for scraping and managing LLM pricing information
Requires Python: >=3.10
Keywords: llm pricing, llm api, llm api cost

# Retrieve LLM API Prices Fast!

This project provides LLM prices for developers as an API.

## Live API

Note: Please use only for testing!!

[click here](https://llm-costs.tomris.dev)

## Anthropic

```py
from llm_pricing import AnthropicScraper

async def main():
    async with ClientSession() as session:
        scraper = AnthropicScraper(session)

        llm_tools = await scraper.get_tools()
        latest_models = await scraper.get_latest_models()
        legacy_models = await scraper.get_legacy_models()

        # overall contains tools, legacy and latest models
        # with using llm_pricing.AnthropicLLMCosts
        overall = await scraper.pricing_overall()

if __name__ == '__main__':
    import asyncio
    asyncio.run(main())
```

## Serve API

```sh
make serve
```

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
4. Push to the branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request
SpokeoAPI 0.1.4
official API wrapper for Spokeo lookup service
Requires Python: >=3.6

spokeoAPI

**spokeoAPI** is an unofficial Python API wrapper and command-line tool for automating USA directory resigstory look ups.  
Designed for security researchers, pentesters, and OSINT professionals who need to automate people search and account enumeration tasks.



## Installation

```bash
pip install spokeoAPI
model-version-manager 1.0.1
Makes it easier to work with versions for your projects.
Requires Python: >=3.11

# Version Class (Python Implementation)

A Python implementation of version number management inspired by .NET's `Version` class, providing robust version number handling and comparison capabilities.

## Features

- Multiple constructors for flexible version creation
- String parsing and validation
- Component-based comparison operations
- Strict type and value checking
- Comprehensive error handling

## Installation

```bash
pip install model_version_manager
```

# Basic Usage

```python
from model_version_manager import Version

# Different ways to create versions
v1 = Version()           # 0.0
v2 = Version(1, 2)       # 1.2
v3 = Version(1, 2, 3)    # 1.2.3
v4 = Version("1.2.3.4")  # From string

# Access components
print(f"{v4.major}.{v4.minor}.{v4.build}.{v4.revision}")

# Comparison
print(v2 == Version(1, 2))  # True
print(v3 < Version(1, 3))   # True
print(v1 > v2)              # False
```

# API Reference

```python
Version()   # 0.0
Version(major: int, minor: int) 
Version(major: int, minor: int, build: int) 
Version(major: int, minor: int, build: int, revision: int)
Version(version_string: str)  # Parses "major.minor.build.revision"
```

# Properies

- `major`: int - Major version number

- `minor`: int - Minor version number

- `build`: int - Build number (-1 if not specified)

- `revision`: int - Revision number (-1 if not specified)

# Methods

- `__str__()`: Returns string representation (e.g. "1.2.3.4")

- `__eq__()`, `__lt__()`, etc.: Comparison operators

- `parse(version_string)`: Classmethod to parse version strings

# Comparison Rules

Versions are compared component by component in order:

1. Major

2. Minor

3. Build

4. Revision

Missing components (represented by -1) are considered older than any specified component.

# Examples

See complete examples in the examples/ directory:

- `basic_usage.py` - Basic functionality
upyboard 0.9.35
This is a CLI tool for MicroPython-based embedded systems.
Requires Python: >=3.10
Keywords: micropython, pyserial, genlib

This tool is supports microcontrollers to which MicroPython is ported.

### Help
```sh
upy
```
or
```sh
upy --help
```

### Finding the serial port on a board with MicroPython
- Explore a serially connected MicroPython device.
- The MicroPython version and device type are printed. 
- Currently supported devices are Digi XBee3 and Raspberry Pi Pico 2 W

```sh
upy scan
```

- The --raw (or -r) option returns low-level board information.
```sh
upy scan -r
```

### Option Rules
- Options and values can have spaces or omit spaces.
- Options and values can be inserted with the = character.

```sh
<option><value>  
<option> <value>
<option>=<value> 
```

### Environment
- Convert a VSCode workspace into a MicroPython workspace
- Assuming the result of the scan argument is COM3
```sh
upy -sport com3 env
```

```sh
upy sport
```
```out
Current serial port: COM8
```

```sh
upy sport com4
```
```
erial port set to: COM4
```

### Initialize Microcontroller file system
- If you created MicroPython workspace in the current path, omit the --sport(or -s) options in all subsequent commands.
```sh
upy init
```

or, You can also use the --sport(or -s) options explicitly.
```sh
upy --sport <your_port_name> init
```

Behavior is not guaranteed if you explicitly specify the device name.
```sh
upy init ticle
```

### Check list of Microcontroller file systems
- If path is omitted, the output will be the files or directories contained in the top-level directory.

```sh
upy ls [<path>/][remote_directory]
```

### Put PC file or directroy into Microcontroller
- If path or remote name is omitted, a remote name identical to the local name is created in the top-level directory.
```sh
upy put <local_name> [[path][/remote_name]]
```

### Get Microcontroller file to PC
- Getting the current directory is not supported.
```sh
upy get <remote_file_name> <local_file_name>
```

### Delete Microcontroller file or directory
```sh
upy rm [path/]<remote_name>
```

### Executes the PC's MicroPython script by sequentially passing it to the Microcontroller
- Wait for serial input/output until the script finishes  
- To force quit in running state, press Ctrl+c

```sh
upy <micropython_script_file>
```
or
```sh
upy run [-i | -n] <micropython_script_file>
```

**Additional Options**
- -i: Display the pressed key in the terminal window (Echo on)
- -n: Does not wait for serial output, so it appears as if the program has terminated on the PC side.
  - Script continues to run on Microcontroller
  - Used to check data output serially from Microcontroller with other tools (PuTTY, etc.)
conics 0.1.0a2
Conic sections library
Requires Python: >=3.9
Keywords: circle, ellipse, hyperbola, parabola

# Conics

![Linux](https://github.com/sergiud/conics/actions/workflows/linux.yml/badge.svg)
[![codecov](https://codecov.io/gh/sergiud/conics/graph/badge.svg?token=89OIQDFWHV)](https://codecov.io/gh/sergiud/conics)
[![Documentation Status](https://readthedocs.org/projects/conics/badge/?version=latest)](https://conics.readthedocs.io/en/latest/?badge=latest)
![PyPI - Version](https://img.shields.io/pypi/v/conics)


Conics is a library for managing conic sections (or simply *conics*).

## Features

* Conics construction and transformation
* Algebraic and geometric fitting and conditioning
* Computing intersections of conics
* 5 DoF pose estimation of the supporting plane of an ellipse

## License

The library is provided under the [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0).
ast-scope 0.5.2
Annotates a Python AST with the scope of symbols.
Requires Python: >=3.9


# ast_scope

This package is an implementation of Python's lexical scoping rules. It's interface is simple, you pass in an AST object to the `annotate` function, and it provides a mapping from each node in the tree that represents a symbol to the containing scope.

## Example Usage: Get Global Symbols

Let's say you have the code

```
code = """
def f():
    x = 3
    lambda z: theta
    return x + y
"""
```

and you want to determine which global variables are referenced by it. All you need to do is run

```
import ast
import ast_scope
tree = ast.parse(code)
scope_info = ast_scope.annotate(tree)
global_variables = sorted(scope_info.global_scope.symbols_in_frame)
```

Once you have executed this code, `global_variables` will be bound to `['f', 'theta', 'y']`.

## Example Usage: Get Dependency Graph

Let's say you have the code

```
code = """
def hailstone(n):
    if n == 1:
        return 1
    if n % 2 == 0:
        return hailstone(n // 2)
    if n % 2 == 1:
        return hailstone(3 * n + 1)

def mapper(f, lst):
    return list(map(f, lst))

def lrange(n):
    return list(range(n))

def main():
    return mapper(hailstone, lrange(20))
"""
```

and you want to find the dependency graph. You can run

```
import ast
import ast_scope
tree = ast.parse(code)
scope_info = ast_scope.annotate(tree)
graph = scope_info.static_dependency_graph
```

which results in the following directed graph of dependencies between top-level functions (rendering using networkx):

<img src="img/dependency_graph_example.png">

See the documentation for some caveats.

## Example usage: find a specific symbol's scope

Take the following code:

```
code = """
def f(x):
    def g(x): return x()
    return g(lambda: x)
"""
```

First, parse the code and identify the node (in practice, you'd probably have this always).

```
import ast, ast_scope
tree = ast.parse(code)
last_x = tree.body[0].body[-1].value.args[0].body
```

If you want to find the scope in which the last `x` could be found, just run the annotator and look up it's scope!

```
# run the annotator
scope_info = ast_scope.annotate(tree)
scope_x = scope_info[last_x]
```

You should get a `FunctionScope` object which contains a bunch of information about the other variables, etc., in the scope, but also `scope_x.function_node`, a pointer to the node containing the `def` statement for `f`.
all-roads-to-literature 0.1.0
PydanticAI and MCP approaches for getting textual representations of scientific literature from PMIDs, DOIs, etc.
Requires Python: <4.0,>=3.11

# All Roads to Literature

An MCP for retrieving scientific literature metadata and content using PMIDs, DOIs, and other identifiers.

## Features

- Retrieve metadata for scientific articles using DOIs
- Fetch abstracts from PubMed using PMIDs
- MCP-based architecture for easy extensibility

## Installation

### Prerequisites

- Python 3.11 or higher
- uv (optional but recommended)

### Setup

1. Clone the repository:
   ```bash
   git clone https://github.com/yourusername/all-roads-to-literature.git
   cd all-roads-to-literature
   ```

2. Install with uv (recommended):
   ```bash
   uv venv
   uv pip install -e .
   ```

   Or with standard pip:
   ```bash
   python -m venv .venv
   source .venv/bin/activate  # On Windows: .venv\Scripts\activate
   pip install -e .
   ```

## Usage

### Starting the MCP Server

To start the MCP server:

```bash
uv run artl --server
```

This will start the server in the current terminal. The server provides access to all registered tools through FastMCP's interface.

### Running the Tests

```bash
uv run pytest tests/
```

## Architecture

The project follows this structure:

- `main.py`: Entry point that creates and configures the MCP server
- `tools.py`: Contains the tool implementations that the MCP server exposes
atgtools 0.1.9rc0
Add your description here
Requires Python: <=3.13,>=3.12

# ATGtools

[![Supported Python Versions](https://img.shields.io/pypi/pyversions/atgtools)](https://pypi.org/project/atgtools/)
[![PyPI version](https://badge.fury.io/py/atgtools.svg)](https://badge.fury.io/py/atgtools)

This is a collection of tools for NGS data analysis. It provides many easy-to-use functionalities to clean, visualize, and analyze NGS results.

## Installation

Latest `atgtools` version: [![PyPI version](https://badge.fury.io/py/atgtools.svg)](https://badge.fury.io/py/atgtools)

### Recommended Installation Methods

#### Using pipx (Recommended)

[pipx](https://pypa.github.io/pipx/) installs Python applications in isolated environments:

```bash
pipx install atgtools
```

#### Using uv (Alternative)

```bash
uv pip install atgtools
```

### Development Setup

For development, clone the repository and set up the environment using uv:

```bash
# Clone the repository
git clone https://github.com/yourusername/atgtools.git
cd atgtools

# Create and activate virtual environment with Python 3.12
uv venv --python 3.12
source .venv/bin/activate  # On Unix/macOS

# Install dependencies
uv sync

# Use as a module
python -m atg --help
```

## Features

### Diversity Analysis

The package provides tools for both alpha and beta diversity analysis.

#### Alpha Diversity

Calculate various alpha diversity indices:

* Shannon (natural log and custom base)
* Gini-Simpson
* Simpson
* Dominance
* Richness
* Pielou's Evenness

```bash
atg div alpha --input abundance.tsv
```

#### Beta Diversity

Calculate dissimilarity between samples using various metrics:

* Bray-Curtis
* Jensen-Shannon
* Jaccard
* Euclidean
* UniFrac (weighted and unweighted)

```bash
atg div beta --input abundance.tsv --metric braycurtis
```

### Utility Tools

#### Git Repository Management

Check multiple git repositories in one pass:

```bash
atg tools git [options]
```

Options:

* `--verbose/-v`: Show files & commits
* `--remote/-r`: Force remote update
* `--untracked/-u`: Show untracked files
* `--dir/-d`: Search specific directory for repositories
* `--all-branch/-a`: Show status of all branches
* `--stash/-s`: Show stashed changes

#### Manifest Creation

Create manifest files for QIIME2:

```bash
atg tools manifest --fastq_dir /path/to/fastq --output manifest.tsv
```

Supported FASTQ naming schemes:

* `sample_R1.fastq.gz`
* `sample_R2.fastq.gz`
* `sample_S01_R1.fastq.gz`
* `sample_S01_R2.fastq.gz`

#### Other Tools

* `atg tools oneliner`: Convert multiline FASTA to single line
* `atg tools countfq`: Count reads in FASTQ files
* `atg tools abundance`: Generate relative abundance tables
* `atg tools download`: Download ENA data
* `atg tools retrieve`: Search and retrieve ENA data
* `atg tools search`: Search ENA database
subnetcalc 1.0.0
A lightweight and efficient Python tool to perform subnetting operations on IPv4 addresses. It can be used both as a standalone CLI utility and as a reusable module in your Python projects.

# 🧮 SubnetCalc – Fast IP Subnetting Calculator

A lightweight and efficient Python tool to perform subnetting operations on IPv4 addresses.  
It can be used both as a standalone CLI utility and as a reusable module in your Python projects.

---

## 📦 Features

- Accepts IP addresses with or without CIDR notation (e.g. `192.168.1.1` or `192.168.1.1/24`)
- Calculates:
  - IP address
  - CIDR prefix
  - Binary and decimal netmask
  - Network ID
  - Broadcast address
  - First and last usable IPs
  - All usable IPs in the subnet (as a generator)
- Built with static conversion methods (binary ↔ decimal), reusable without class instantiation
- Fully functional from the command line or as an importable Python class

---

## 🚀 Usage

### 1. CLI (Command-Line Interface)

```bash
python3 subnetcalc.py -i 192.168.1.1/24
[+] IP --> 192.168.1.1
[+] CIDR --> 24
[+] Netmask --> 255.255.255.0
[+] Network ID --> 192.168.1.0
[+] Broadcast --> 192.168.1.255
[+] Min / Max IP --> ('192.168.1.1', '192.168.1.254')
```
### 2. Import as a Module
```python
from subnetcalc import Ip

my_ip = Ip("10.0.0.1/26")
print(my_ip.network_ip)       # 10.0.0.0
print(my_ip.broadcast)        # 10.0.0.63
print(list(my_ip.available_ips))  # List of usable IPs
```
***
## 🔧 Class & Methods

### Class: `Ip`

#### Constructor
``` python
ip_instance = Ip("192.168.1.0/24")
```
Creates a new subnet object from an IP address string, with or without CIDR.
##### Attributes

- `ip` → base IP address (string)
    
- `cidr` → subnet prefix (e.g. `'24'`)
    
- `netmask` → human-readable subnet mask (e.g. `'255.255.255.0'`)
    
- `network_ip` → network ID
    
- `broadcast` → broadcast address
    
- `min_max_ip` → tuple of (first usable, last usable) IPs
    
- `available_ips` → generator that yields all usable IPs in the subnet

***
### Static Methods

These can be called without creating an object:

#### `ip_to_bin(ip: str) → str`

Converts a dotted-decimal IP to its 32-bit binary representation.

#### `bin_to_ip(bin: str) → str`

Converts a 32-bit binary string back to a dotted-decimal IP.

#### `ip_to_dec(ip: str) → int`

Converts a dotted-decimal IP to a 32-bit integer.

#### `dec_to_ip(entero: int) → str`

Converts a 32-bit integer to a dotted-decimal IP.
***
## 📁 Example:
``` python
from subnetcalc import Ip

ip = Ip("172.16.5.9/28")
print("Netmask:", ip.netmask)
print("First usable IP:", ip.min_max_ip[0])
print("Broadcast:", ip.broadcast)

# Iterate through usable IPs
for host in ip.available_ips:
    print(host)
```
aio-usb-hotplug 7.0.0
Asynchronous generators yielding detected hotplug events on the USB buses
Requires Python: >=3.9

# aio-usb-hotplug

`aio-usb-hotplug` is a Python library that provides asynchronous generators
yielding detected hotplug events on the USB buses.

Requires Python >= 3.8.

Works with [`asyncio`](https://docs.python.org/3/library/asyncio.html)
and [`trio`](https://trio.readthedocs.io/en/stable/).

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install
`aio-usb-hotplug`.

```bash
pip install aio-usb-hotplug
```

`aio-usb-hotplug` depends on [PyUSB](https://pypi.org/pypi/pyusb), which
in turn requires [libusb](https://libusb.info) or
[openusb](https://sourceforge.net/projects/openusb/). An easy way to satisfy
this requirement is to install
[libusb-package](https://pypi.org/pypi/libusb-package), which supplies
pre-compiled binaries for most platforms:

```bash
pip install libusb-package
```

`aio-usb-hotplug` will make use of
[libusb-package](https://pypi.org/pypi/libusb-package) if it is installed in
the current Python environment.

## Usage

### Dump all hotplug events related to a specific USB device

```python
from aio_usb_hotplug import HotplugDetector
from trio import run  # ...or asyncio

async def dump_events():
    detector = HotplugDetector.for_device(vid="1050", pid="0407")
    async for event in detector.events():
        print(repr(event))

trio.run(dump_events)
```

### Run an async task for each USB device matching a VID/PID pair

```python
from aio_usb_hotplug import HotplugDetector
from trio import sleep_forever


async def handle_device(device):
    print("Handling device:", repr(device))
    try:
        # Do something meaningful with the device. The task gets cancelled
        # when the device is unplugged.
        await sleep_forever()
    finally:
        # Device unplugged or an exception happened
        print("Stopped handling device:", repr(device))


async def handle_detected_devices():
    detector = HotplugDetector.for_device(vid="1050", pid="0407")
    await detector.run_for_each_device(handle_device)


trio.run(handle_detected_devices)
```

## Contributing

Pull requests are welcome. For major changes, please open an issue first to
discuss what you would like to change.

Please make sure to update tests as appropriate.

## License

[MIT](https://choosealicense.com/licenses/mit/)
alert2issue 0.2.0
Automatically create GitHub issues from open Dependabot alerts
Keywords: Dependabot, GitHub, alert, issue, no-patch

# alert2issue

🔐 Automatically create GitHub issues from open Dependabot alerts — complete with severity, CVE info, and tagging.

---

## 🚀 What It Does

`alert2issue` scans a list of GitHub repositories for open [Dependabot alerts](https://docs.github.com/en/code-security/dependabot) and creates labeled GitHub issues summarizing the problems.

It helps teams stay on top of security alerts by converting them into visible, actionable tasks.

---

## 📦 Features

- ✅ Lists open Dependabot alerts using the GitHub CLI
- ✅ Avoids duplicate issues
- ✅ Auto-labels issues with `security` and `dependabot`
- ✅ Marks alerts with no patch as special warnings
- ✅ Supports dry-run mode for safe testing
- ✅ Tested with unit tests and coverage

---

## 📦 Installation

Install via [PyPI](https://pypi.org/project/alert2issue/):

```bash
pip install alert2issue
````

Make sure you have the [GitHub CLI](https://cli.github.com/) (`gh`) installed and authenticated:

```bash
gh auth login
```

---

## ⚙️ Usage

Run the tool with a list of repositories (one per line):

```bash
alert2issue path/to/repo-list.txt
```

### Options

```text
--dry-run     Run without creating issues or labels (preview only)
--verbose     Print extra info
```

### Example repo list

```text
# Only include public or authorized repos
openai/gym
pallets/flask  # Inline comment OK
```

---

## ✅ Requirements

- Python 3.8+
- GitHub CLI (`gh`)
- GitHub token with `repo` scope if using private repositories

---

## 🧪 Testing

To run tests:

```bash
python -m unittest test_alert2issue.py
```

With code coverage:

```bash
coverage run -m unittest
coverage report
```

---

## 📈 CI

This project includes a GitHub Actions workflow that runs tests and linting.

---

## 🛠 Development Install (optional)

If you want to run it from source:

```bash
git clone https://github.com/annejan/alert2issue.git
cd alert2issue
pip install -e .
```

---

## 🙋 Contributing

Pull requests welcome! Open an issue first if you'd like to suggest a major change.

---

## 📄 License

MIT License — see [LICENSE](./LICENSE) file.

© 2025 Anne Jan Brouwer

Parts of this project were written with the assistance of [ChatGPT](https://openai.com/chatgpt), [Claude](https://www.anthropic.com/claude) and [VLAM.ai](https://vlam.ai/).