semvec/pypi-packages huggingface dataset:
bulletchess 0.4.0
A high performance C Extension for chess
Requires Python: >=3.13

<!-- bulletchess documentation master file, created by
sphinx-quickstart on Thu May 22 18:37:37 2025.
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive. -->

# bulletchess

[![Builds and Tests](https://github.com/zedeckj/bulletchess/actions/workflows/wheels.yml/badge.svg)](https://github.com/zedeckj/bulletchess/actions/workflows/wheels.yml)
[![PyPI version](https://badge.fury.io/py/bulletchess.svg)](https://badge.fury.io/py/bulletchess)

`bulletchess` is a Python module for playing, analyzing, and building engines for chess. Unlike other chess libraries in Python,
the core of `bulletchess` is written in C, allowing it to be [*much*](https://zedeckj.github.io/bulletchess/auto_examples/performance.html) faster than alternatives.

## Overview

At a high level, `bulletchess` includes:

* A complete game model with intuitive representations for pieces, moves, and positions.
* Extensively tested legal move generation, application, and undoing.
* Parsing and writing of positions specified in [Forsyth-Edwards Notation](https://www.chessprogramming.org/Forsyth-Edwards_Notation) (FEN), and moves specified in both [Long Algebraic Notation](https://www.chessprogramming.org/Algebraic_Chess_Notation#Long_Algebraic_Notation_.28LAN.29) and [Standard Algebraic Notation](https://www.chessprogramming.org/Algebraic_Chess_Notation#Standard_Algebraic_Notation_.28SAN.29).
* Methods to determine if a position is check, checkmate, stalemate, and each specific type of draw.
* Efficient hashing of positions using [Zobrist Keys](https://en.wikipedia.org/wiki/Zobrist_hashing).
* A [Portable Game Notation](https://thechessworld.com/articles/general-information/portable-chess-game-notation-pgn-complete-guide/) (PGN) file reader
* Utility functions for writing engines.

```
pip install bulletchess
```

[Read the docs](https://zedeckj.github.io/bulletchess/index.html)
radonpy 0.2.5
Tools to communicate with the RadonEye RD200 radon detector
Keywords: radon, radoneye

# RadonPy
### Tools to communicate with the RadonEye RD200 radon detector

RadonPy provides a Python library for communicating with the [RadonEye RD200](http://radonftlab.com/radon-sensor-product/radon-detector/rd200/) radon detector over Bluetooth Low Energy, as well as a command line program to read sensor values and configure settings.

Note that devices newer than November 2021 are not currently supported. They switched from an Nordic nRF5x to an ESP32 and changed the protocol, and I don't have new hardware to test.
data-utils11 0.1.0
Simple data utilities package
Requires Python: >=3.11

# Data Utils

A simple data utilities package for common data operations.

## Installation

```bash
# From workspace root
uv sync

# Run the CLI
uv run data-utils --help
```

## Usage

```bash
# Generate sample data
uv run data-utils generate --rows 1000 --output sample.parquet

# Inspect data
uv run data-utils inspect sample.parquet

# Convert formats
uv run data-utils convert sample.parquet --output sample.csv --format csv
```
semantic-pdf-search 0.8.4
Search PDFs semantically
Requires Python: >=3.6

<h1 align="center"><b>
	semantic-pdf-search
</b></h1>

<h4 align="center"><b>
A semantic PDF searching application, written in Python.
</b></h4>

<p align="center">
By Jordan Zedeck and Jonathan Louis
</p>


## Overview

This application utilizes a machine learning embedding model to encode both a PDF document and a user's queries. This process enables the application to find near-matches to the query within the document, much like an internet search engine would for web-pages. The page number results are displayed as buttons which can be clicked to open the PDF directly to the page in your default web browser.

## Features

  * **Semantic Search:** Finds near-matches and related concepts, not just exact keywords.
  * **Offline Operability:** Once semantic-pdf-search is installed and used once, it can be used completely offline.
  * **Cross-Platform:** Supports Linux, Windows and macOS.

## Example

**Query:** 

![alt text](https://raw.githubusercontent.com/notjonathanlouis/semantic-pdf-search/refs/heads/main/assets/great-gatsby-search.png)

**Result:**

![alt text](https://raw.githubusercontent.com/notjonathanlouis/semantic-pdf-search/refs/heads/main/assets/great-gatsby-result.png)

## Installation

### Prerequisites

This package requires **Tkinter**. If you run the command `python -m tkinter` and a new window does not appear, you will need to install it manually.

  * **Windows:** Re-run the [Python installer](https://www.python.org/downloads/windows/) and ensure the **tcl/tk** checkbox is ticked.
  * **macOS:** Install Tkinter using Homebrew with the following command:
    ```
    brew install python-tk
    ```
  * **Linux:** Varies depending on package manager:
  	* **Debian:**
	    ```
	    sudo apt install python3-tk
	    ```
	* **Fedora:**
	    ```
	    sudo dnf install python3-tkinter
	    ```
	* **Arch:** (note that pip installing packages on Arch requires using a venv):
	    ```
	    sudo pacman -S tk
	    ```

### From PyPI

The easiest way to install the package is using `pip`.

```
pip install semantic-pdf-search
```

### From Source

To install from the GitHub repository, follow these steps:

```
cd semantic-pdf-search
python -m build
pip install dist/semantic_pdf_search-0.8.0-py3-none-any.whl
```

## Launching semantic-pdf-search

Once installed, run the application from your command line:

```
semantic-pdf-search
```

### Basic Usage Guide

1.  **Browse for a PDF:** Click on "Browse for PDF" to browse for a PDF file.
2.  **Select and Open:** Navigate to your PDF, select it, and click "Open".
3.  **Wait for Embeddings:** The application will process the document and create embeddings. This may take a moment, especially for large files.
4.  **Enter a Query:** Once the document is loaded, type your query into the search bar and press **Enter**.
5.  **View Results:** The application will display a list of page numbers that contain near-matches to your query.
6.  **Open the Page:** Click on any of the result buttons to open the PDF directly to that page in your default web browser.
oxidize 0.7.0
High-performance data processing tools for Python, built with Rust
Requires Python: >=3.9
Keywords: data-processing, rust, performance, tools

# Oxidize

High-performance data processing tools for Python, built with Rust.

## Philosophy

- **Best of both worlds**: Python interfaces with Rust backends for both simplicity and performance
- **True parallelism**: GIL release for concurrent processing
- **Easy installation**: Pre-built wheels, no compilation required
- **Practical**: Specialized solutions for common data engineering tasks

## Tools

### [oxidize-postal](https://github.com/ericaleman/oxidize-postal)
oxidize-postal is an alternative to pypostal for Python bindings of the libpostal library, which provides address parsing and normalization with international support. 

oxidize-postal provides the same address parsing capabilities as pypostal but addresses key limitations: it installs without C compilation, releases the Python GIL for true parallel processing, and offers a cleaner API. Built using Rust and libpostal-rust bindings to the libpostal C library.

```python
import oxidize_postal

parsed = oxidize_postal.parse_address("781 Franklin Ave Brooklyn NY 11216")
# {'house_number': '781', 'road': 'franklin ave', 'city': 'brooklyn', 'state': 'ny', 'postcode': '11216'}

expansions = oxidize_postal.expand_address("123 Main St NYC NY")
# ['123 main street nyc new york', '123 main street nyc ny', ...]
```

### [oxidize-xml](https://github.com/ericaleman/oxidize-xml)
oxidize-xml is an alternative to lxml and provides streaming XML to JSON conversion for large files.

oxidize-xml is more specialized and opiniated, focusing on common data engineering workflows for extracting repeated elements from large XML files like API responses, log files, and data exports, is particularly built for engineers and analysts working in DuckDB or Polars.

```python
import oxidize_xml

# Extract repeated elements to JSON Lines
count = oxidize_xml.parse_xml_file_to_json_file("data.xml", "book", "output.jsonl")

# Stream processing for large files
json_lines = oxidize_xml.parse_xml_file_to_json_string("export.xml", "record")
```

## Future Tools

New versions to oxidize-xml / oxidize-postal plus new packages coming soon.

## License

MIT License for all tools.