semvec/pypi-packages huggingface dataset:
pybinhistory 0.7.0
A python library for programmatically reading, writing, and managing Avid bin history log (`.log`) files.
Requires Python: >=3.7
Keywords: avid, media composer, nle, editorial, post, production, film, television, nexis, avb, bins, access, logs, log

# pybinhistory

*Because `pybinlog` was taken™*

`binhistory` is a python library for programmatically reading and writing Avid bin history log (`.log`) files in 
multi-user Avid Media Composer projects.

>[!WARNING]
> `binlog` is an unofficial library created for educational purposes.  While the ``.log`` file format
>is a very simple one, it is officially undocumented. Use this library at your own risk -- the developer assumes
>no responsibility for any damage to your project, loss of data, or weird snippy drama about who threw the audio
>out of sync in the latest version of the reel.

## Interesting Uses

- Be a good citizen!  Add a bin log entry when modifying a bin programmatically via automation/pipeline-y operations.
- Snoop around!  Easily gather metrics about modifications made by particular machines or users.
- Makes you look cool!  Everyone will be very impressed with you.  "Wow!" they'll say.

## Installation

Install the `pybinhistory` package [from PyPI](https://pypi.org/project/pybinhistory/) using `pip`:

```bash
pip install pybinhistory
```

Or clone from this repo:

```bash
git clone https://github.com/mjiggidy/pybinhistory.git
cd pybinhistory
pip install .
```

Now you can import `binhistory`!

```python
from binhistory import BinLog, BinLogEntry

# Write a log entry
BinLog.touch_bin("Reel 1.avb")

# See that last entry
log = BinLog.from_bin("Reel 1.avb").latest_entry()
print(f"Latest log entry was from {log.computer} at {log.timestamp}")
```

## Usage

See [readthedocs.io](https://pybinhistory.readthedocs.io) for general usage and API documentation!

## See Also
- [`pybinlock`](https://github.com/mjiggidy/pybinlock) - Programmatically read and write Avid bin lock (`.lck`) files
quantimatter 0.1.0
Quantum chemistry package for antimatter simulations
Requires Python: >=3.8

# Antimatter Quantum Chemistry (antimatter)

[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue)](https://www.python.org/downloads/)
[![License](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)

A high-performance quantum chemistry framework designed specifically for simulating antimatter systems, including positronium, anti-hydrogen, and other exotic matter-antimatter configurations.

## Features

- **Specialized Antimatter Physics**: Dedicated algorithms for positrons and positron-electron interactions
- **Relativistic Corrections**: Implementation of relativistic effects critical for accurate antimatter modeling
- **Annihilation Processes**: Modeling of electron-positron annihilation dynamics
- **Quantum Computing Integration**: Built-in Qiskit integration for quantum simulations of antimatter systems
- **Validation Tools**: Framework for verifying results against known theoretical benchmarks

## Installation

### Basic Installation

```bash
pip install antimatter
```

### Installation with Quantum Computing Support

```bash
pip install antimatter[qiskit]
```

## Quick Start

```python
import numpy as np
from antimatter.core.molecular_data import MolecularData
from antimatter.utils import create_antimatter_calculation

# Create a positronium system (electron-positron bound state)
positronium = MolecularData.positronium()

# Configure and run the calculation
result = create_antimatter_calculation(
    positronium,
    basis_options={'quality': 'positronium'},
    calculation_options={
        'include_annihilation': True,
        'include_relativistic': True
    }
)

# Print key results
print(f"Ground state energy: {result['energy']:.6f} Hartree")
print(f"Annihilation rate: {result['annihilation_rate']:.6e} s^-1")
print(f"Lifetime: {result['lifetime_ns']:.4f} ns")
```

## Examples

The package includes several example scripts for common antimatter research scenarios:

- `examples/positronium_simulation.py`: Basic positronium energy calculation
- `examples/quantum_antimatter.py`: Quantum computing simulation of positronium
- `examples/anti_hydrogen.py`: Anti-hydrogen atom calculations

## Citing This Work

If you use this package in your research, please cite:

```
@software{antimatter,
  author = {mk0dz},
  title = {Antimatter Quantum Chemistry},
  url = {https://github.com/mk0dz/antimatter},
  version = {0.1.0},
  year = {2023},
}
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
mcp-repl 0.1.3
Add your description here
Requires Python: >=3.12

# MCP-REPL

A lightweight REPL (Read-Eval-Print Loop) for interacting with various services through MCP (Model Context Protocol).

[![PyPI version](https://badge.fury.io/py/mcp-repl.svg)](https://pypi.org/project/mcp-repl/)
[![Databases Tests](https://github.com/kyryl-opens-ml/mcp-repl/actions/workflows/databases-example-test.yaml/badge.svg)](https://github.com/kyryl-opens-ml/mcp-repl/actions/workflows/databases-example-test.yaml)
[![Infrastructure Tests](https://github.com/kyryl-opens-ml/mcp-repl/actions/workflows/infra-example-test.yaml/badge.svg)](https://github.com/kyryl-opens-ml/mcp-repl/actions/workflows/infra-example-test.yaml)

## Overview

`mcp-repl` is designed for efficient development, debugging, and testing of MCP servers. It provides an intuitive command-line interface that's simpler than using the Cloud Desktop app, allowing developers to quickly:

- Send queries to MCP servers
- View detailed tool execution
- Automatically save chat history
- Test multiple MCP services simultaneously

## Installation

Install via pip or uv:

```bash
uv add mcp-repl
```

## Usage

Start the REPL:

```bash
uv run mcp-repl --config path/to/config.json
```

## Examples

**🔥 Check out our real-world examples to see mcp-repl in action! 🔥**

- **[Databases](./examples/databases/)** - Database administrators: See how to query, monitor, and manage your databases with natural language
- **[Infrastructure](./examples/infra/)** - DevOps engineers: Explore examples for managing cloud resources, monitoring systems, and automating infrastructure tasks

Each example includes sample configurations and common usage patterns to help you get started quickly.


### Optional Flags

- `--auto-approve-tools`: Automatically approve all tool executions
- `--always-show-full-output`: Always display complete tool outputs
- `--chat-history-dir PATH`: Directory to save chat history (default: `./chat_history`)

### Development Installation

Clone and install in editable mode:

```bash
git clone https://github.com/yourusername/mcp-repl.git
cd mcp-repl
uv venv
```

## Testing

Comprehensive integration tests are included to verify functionality:

Run all tests:

```bash
uv run pytest
```
prpa 1.0
Post-Render Perspective Align

# PRPA: Post-Render Perspective Align

## Install

Install from pypi:
```sh
pip install prpa
```
or from source:
```sh
pip install git+https://github.com/yindaheng98/PostRenderPerspectiveAlign
```

## Dependencies
- PyTorch  
- NumPy  
- open3d (optional, for visualization)
- opencv (optional, for reading sample data)
mcp-dnsdumpster 0.1.3
DNSDumpster MCP Server for querying DNS information
Requires Python: >=3.10
Keywords: claude, dns, dnsdumpster, mcp

# DNSDumpster - MCP Server

A Model Context Protocol (MCP) server for interacting with the DNSDumpster API, enabling AI assistants to perform detailed DNS reconnaissance through natural language requests.

## Features

- Query domain DNS records through AI assistants
- Retrieve detailed information about:
  - A records (with associated IP and ASN information)
  - CNAME records
  - MX records
  - TXT records
  - NS records
  - Banner information where available
- Support for pagination (Plus accounts)
- Rate limiting and caching

[![PyPI version](https://badge.fury.io/py/mcp-dnsdumpster.svg)](https://pypi.org/project/mcp-dnsdumpster/)

## Installation

```bash
# Install from PyPI
uv pip install mcp-dnsdumpster

# Or from source
git clone https://github.com/yourusername/mcp-dnsdumpster.git
cd mcp-dnsdumpster
uv pip install -e .
```

## Claude Desktop Configuration

Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%AppData%\Claude\claude_desktop_config.json` on Windows):

```json
{
  "mcpServers": {
    "dnsdumpster": {
      "command": "uvx",
      "args": ["mcp-dnsdumpster"],
      "env": {
        "DNSDUMPSTER_API_KEY": "your_api_key_here"
      }
    }
  }
}
```

## Usage

1. Set your API key:
```bash
export DNSDUMPSTER_API_KEY=your_api_key_here
```

2. Run the server:
```bash
# Using uvx (recommended)
uvx mcp-dnsdumpster

# Or if installed from source
uv run server.py
```

### Example Prompts

- "Show me all subdomains for example.com"
- "What are the mail servers for microsoft.com?"
- "Tell me about the DNS infrastructure for twitter.com"

## Development

- Python 3.10+
- Uses `uv` for dependency management
- Built with MCP SDK 1.4+

## License

MIT
biprop 1.0.4
Python library for biproportional and other apportionment methods.
Requires Python: >=3.7
Keywords: apportionment, biproportional, elections, politics, pukelsheim

# Biprop - A Python Library for Calculating Biproportional Apportionments

> [!CAUTION]
> DO NOT use this repository to calculate the official results of actual elections! The code in this repository was not formally verified and might not always deliver correct results or terminate.

Welcome to the `biprop` library. This library is meant for election enthusiats and statistics nerds like me who want to ask questions like
> How would the parliament of country X look like if they used biproportional apportionment in their last election?

or
> How would the apportionment change if party Y and Z ran together as one and if we introduced a quorum that parties have to fulfill?

The `biprop` library contains all the tools you need to answer these questions and more.

## Installation

You can install `biprop` with `pip` using
```
pip install biprop
```

## Basic Usage

To demonstrate the basic usage of the `biprop` library, we will replicate the calculations from the [example from this Wikipedia article](https://en.wikipedia.org/wiki/Biproportional_apportionment#Specific_example). We start with importing the `biprop` library and defining the votes, region and party names from the example:
```
>>> import biprop as bp
>>> party_names = ['A', 'B', 'C']
>>> region_names = ['I', 'II', 'III']
>>> votes = [[123,  45, 815],
...          [912, 714, 414],
...          [312, 255, 215]]
```
Now we can use the votes to define an election and calculate the upper and lower apportionments:
```
>>> e = bp.Election(votes, party_names=party_names, region_names=region_names, total_seats=20)
>>> e.upper_apportionment(which='parties')
array([ 5, 11,  4])
>>> e.upper_apportionment(which='regions')
array([7, 5, 8])
>>> e.lower_apportionment()
Lower apportionment converged after 2 iterations.
array([[1, 0, 4],
       [4, 4, 3],
       [2, 1, 1]])
```
We indeed arrive at the same seat distribution as the example in the Wikipedia article. You can find more usage examples and more detailed explanations in the [Examples directory of the project's GitHub page](https://github.com/herold-t/biprop/tree/main/Examples).

## Examples and Tutorial

You can find practical examples and detailed explanations in the tutorial iPython notebooks in the [Examples directory of the project's GitHub page](https://github.com/herold-t/biprop/tree/main/Examples). The tutorials are still being worked on and are not yet complete.

## Version 0

> [!WARNING]
> Version `0.1.0` is outdated and is not maintained anymore. Users still using this version are encouraged to migrate to version `1.x.x`.

If you still need access to the version `0.1.0`, you can find the code for it in the [v0 directory](https://github.com/herold-t/biprop/tree/main/v0). This directory includes the `biprop.py` module which implements the version `0.1.0`. It also contains an `example.py` module that uses the 2019 and 2023 Swiss National Council Elections to demonstrate how to use `biprop.py`.
luzitoolip 1.1
A simple IP info fetcher
Requires Python: >=3.6

luziip modÃ¼lÃ¼, Luzi Inc. tarafÄ±ndan geliÅŸtirilmiÅŸ bir IP sorgulama aracÄ±dÄ±r. Bu modÃ¼l, kullanÄ±cÄ±larÄ±n IP adreslerini sorgulamak, konum bilgilerini elde etmek ve Ã§eÅŸitli aÄŸ bilgilerini analiz etmek iÃ§in kullanÄ±lÄ±r. Luzi Inc., bu modÃ¼l ile internet Ã¼zerindeki IP adreslerinin izlenebilirliÄŸini artÄ±rarak, aÄŸ yÃ¶netimi ve gÃ¼venlik alanlarÄ±nda kolaylÄ±k saÄŸlamayÄ± amaÃ§lamaktadÄ±r. Bu araÃ§, kullanÄ±cÄ±larÄ±n IP tabanlÄ± analizler yapmasÄ±na ve aÄŸ yapÄ±landÄ±rmalarÄ±nÄ± optimize etmelerine olanak tanÄ±r.