semvec/pypi-packages huggingface dataset:
casm-tools 2.0a2
CASM command line tools
Requires Python: <3.14,>=3.9

<img alt="Shows the CASM logo" src="https://raw.githubusercontent.com/prisms-center/CASMcode_global/main/python/doc/_static/logo.svg" width="600" />

#### casm-tools

The casm-tools package provides pure Python CLI tools and helper functions. This includes:

- casm-calc: Setup, run, and report results of structure calculations
- casm-map: Structure mapping and import


#### Install

    pip install casm-tools


#### Usage

See the [casm docs](https://prisms-center.github.io/CASMcode_pydocs/casm/overview/latest/).


#### Instal Zsh Completions

To install Zsh completions, cp the completions function to your custom completions directory:

    cp completions/zsh/_casm_map ~/.oh-my-zsh/custom/completions/_casm-map

Then reload your shell or run:

    compinit


#### About CASM

The casm-tools package is part of the [CASM](https://prisms-center.github.io/CASMcode_docs/) open source software package, which is designed to perform first-principles statistical mechanical studies of multi-component crystalline solids.

CASM is developed by the Van der Ven group, originally at the University of Michigan and currently at the University of California Santa Barbara.

For more information, see the [CASM homepage](https://prisms-center.github.io/CASMcode_docs/).


#### License

GNU Lesser General Public License (LGPL). Please see the file LICENSE for details.
pr-checker-ai 0.1.0
Add your description here
Requires Python: >=3.11

# PR Checker AI 💚

An intelligent pull request review tool that leverages both OpenAI and Anthropic AI models to provide comprehensive code reviews directly on your GitHub pull requests.

## Features

- **Dual AI Analysis**: Get reviews from both OpenAI GPT and Anthropic Claude models for comprehensive feedback
- **Automated PR Comments**: Automatically posts review results as comments on your GitHub pull requests
- **Rich Console Output**: Beautiful terminal output with tables and markdown rendering
- **Flexible Model Selection**: Choose specific models from OpenAI and Anthropic
- **GitHub CLI Integration**: Uses GitHub CLI for seamless PR interaction

## Prerequisites

Before using PR Checker AI, ensure you have:

1. **GitHub CLI (`gh`)** installed and authenticated
2. **OpenAI API Key** - Set as `OPENAI_API_KEY` environment variable
3. **Anthropic API Key** - Set as `ANTHROPIC_API_KEY` environment variable

## Installation

1. Install `pr-checker-ai`:

```bash
pip install pr-checker-ai
```

2. Set up your API keys:

```bash
export OPENAI_API_KEY="your-openai-api-key"
export ANTHROPIC_API_KEY="your-anthropic-api-key"
```

3. Ensure GitHub CLI is authenticated:

```bash
gh auth login
```

## Usage

### Basic Usage

Review a pull request (flag `-p`, `--pr`) using default models (`gpt-4.1` for OpenAI and `claude-sonnet-4-0` for Anthropic):

```bash
pr-checker-cli -p 123
```

### Advanced Usage

Specify custom models for both providers using the flags:

- `-o, --openai`: OpenAI model to use (default: "gpt-4.1")
- `-a, --anthropic`: Anthropic model to use (default: "claude-sonnet-4-0")

```bash
pr-checker-cli -p 456 -o "gpt-5" -a "claude-3-7-sonnet-latest"
```

## How It Works

1. **Fetches PR Details**: Uses GitHub CLI to collect general PR information and diff changes
2. **AI Analysis**: Sends PR details to both OpenAI and Anthropic models for review
3. **Processes Responses**: Filters and formats responses from both AI providers
4. **Posts Comment**: Creates a formatted comment on the PR with both reviews
5. **Console Output**: Displays results in a beautiful table format in your terminal

## Output Format

The tool generates a structured comment on your PR containing:

- **OpenAI Review**: Analysis from the specified OpenAI model
- **Anthropic Review**: Analysis from the specified Anthropic model
- **Approval Status**: Each AI provides an approve/not approve recommendation
- **Automated Footer**: Indicates the comment was generated by PR Checker AI

## Contributing

We welcome contributions! Please read our [Contributing Guide](CONTRIBUTING.md) to get started.

## License

This project is licensed under the [MIT License](./LICENSE)
microbrewery 0.1.0rc1
Tool for knowledge distillation into conversational LLMs
Requires Python: >=3.9

# Microbrewery

Distill conversational models into any causal LM architecture on HuggingFace!

## Installation

### From PyPI

```bash
python3 -m pip install microbrewery
```

### Manual

1. Clone this repository
2. Create a new virtualenv and activate it
3. (optional) Download [PyTorch](https://pytorch.org/get-started/locally/) wheel suited to your needs
4. `pip install -r requirements.txt`

### You're all set

Done! You can now run `microbrewery --help` to see a list of available options.

## Usage

### CLI

![Bielik teaching GPT-2 Polish grammar](assets/Bielik_teaching_GPT2.png)

Distill knowledge of the Polish language from _Bielik v3.0_ into _GPT-2_ (commands tested on RTX 3070).

```bash
microbrewery distill \
    --teacher-model-path speakleash/Bielik-1.5B-v3.0-Instruct \
    --student-model-path openai-community/gpt2 \
    --dataset-path "Igorrr0/polish-qa-general" \
    --custom-system-prompt "Jesteś ekspertem od udzielania odpowiedzi, dobrze znającym język polski. Odpowiadaj krótko, konwersacyjnie, zgodnie z prawdą." \
    --completion-column-name output \
    --prompt-column-name instruction \
    --output-dir "./microbrewery-distilled-model" \
    --max-new-tokens 128 \
    --training-max-tokens 256 \
    --teacher-batch-size 32 \
    --cached-targets-path "./microbrewery-cached" \
    --learning-rate 1e-4 \
    --num-train-epochs 10 \
    --gradient-accumulation-steps 1 \
    --per-device-train-batch-size 4
```

Make sure the models are not too big and the batch size fits your VRAM.

To get a new response from the distilled model, simply run:

```bash
microbrewery infer \
    --system-prompt "Jesteś ekspertem od udzielania odpowiedzi, dobrze znającym język polski. Odpowiadaj krótko, konwersacyjnie, zgodnie z prawdą." \
    --user-prompt "Czy już znasz język polski?" \
    --model-path "./microbrewery-distilled-model/checkpoint-740"
```

![Sample response after 10 training epochs (740 steps)](assets/training_10_epochs.png)

### Library

You can also run the same functions as a Python library (e.g. in Jupyter notebooks).
Simply put `from microbrewery import distill, finetune, infer` in your code.

## Features

1. Hard target distillation
2. Easy inference with the distilled weights
3. PyTorch support
4. Caching of generated targets
5. Automatic cloning of teacher architecture's chat template
6. Q&A dataset conversion into chat format

## License

This project is licensed under the [MIT License](LICENSE.md).
vtds-platform-ubuntu 0.0.14
Ubuntu Platform Layer Plugin for the Virtual Test Development System (vTDS) suite
Requires Python: >=3.9

# vtds-platform-ubuntu

An Ubuntu Linux Virtual Blade based vTDS Platform Layer Implementation.

## Description

This Platform Layer Implementation provides the code and
[base configuration](https://github.com/Cray-HPE/vtds-platform-ubuntu/blob/main/vtds_platform_ubuntu/private/config/config.yaml)
to configure a set of Ubuntu Linux based Virtual Blades for use under
vTDS. For more information about configuring this Layer Implementation
see the annotated base configuration linked above.

A brief introduction to vTDS can be found in the [vTDS Core Project
Repository](https://github.com/Cray-HPE/vtds-core/blob/main/README.md).
ignoregen-cli 1.0.0
A CLI tool and Python package for generating .gitignore files
Requires Python: >=3.7

# IgnoreGen - Smart .gitignore Generator

A powerful CLI tool and Python package that helps you generate comprehensive `.gitignore` files from templates with intelligent auto-detection capabilities.

## Features

- 🚀 **Multiple Templates**: Python, Node.js, React, Django, Java, C++, and more
- 🧠 **Smart Auto-Detection**: Automatically detects project types based on files and structure
- 🔄 **Template Merging**: Combine multiple templates for polyglot projects
- 💾 **Merge with Existing**: Preserves your existing .gitignore content
- 🛡️ **Backup Protection**: Automatically backs up existing files
- 📦 **Python API**: Use programmatically in your Python projects
- ⚡ **Fast & Lightweight**: Zero external dependencies

## Installation

```bash
# Install from PyPI (when published)
pip install ignoregen

# Or install from source
git clone https://github.com/yourusername/ignoregen.git
cd ignoregen
pip install -e .
lafs 0.0.5
Least-Authority File Store utils
Requires Python: >=3.9
Keywords: allmydata, tahoe-lafs, tahoe, lafs

# LAFS

_LAFS_ is an **experimental** Rust crate that provides a limited implementation of some parts of [Tahoe-LAFS](https://tahoe-lafs.org) -- the Least-Authority File Store. More specifically, it offers Rust implementations of the following functions (from the original Python `allmydata` package):

```
allmydata.util.base32.b2a
allmydata.util.hashutil.tagged_hash
allmydata.util.hashutil.ssk_pubkey_fingerprint_hash
allmydata.util.hashutil.ssk_writekey_hash
allmydata.util.netstring.netstring
```

Taken together, these provide just enough functionality to derive valid mutable capability strings/URIs that are fully compatible with the original (Python) implementation (as confirmed by testing against Tahoe-LAFS' own test vectors). As such, this library can be used to generate or recover cryptographic capabilities completely "offline" (i.e., without the need to interact with a running Tahoe-LAFS node) and/or in environments -- such as mobile -- where running a full `tahoe` node may be infeasible or undesirable.


## Usage

Although Tahoe-LAFS does not provide a Python API, for the sake of consistency with the original implementation, paths exposed by this crate strive to match the namespaces defined in the original `allmydata` Python package. For example, the Python `allmydata.util.base32.b2a` function can be called via the `lafs::util::base32::b2a` path in Rust.

Function signatures and types, likewise, aim to follow the original implementation as closely as possible (thus a Python function that returns a `bytes` of undefined length might return a `Vec<u8>` in Rust), however, given Python's dynamic type system and other fundamental language differences (like Python's exception system, "default" args., etc.), some concessions should be expected. When in doubt, consult the source code.


## Python bindings

In addition to the Rust crate, Python bindings are provided for each of the modules/functions defined by this library (using [pyo3](https://pyo3.rs/), however, due to the aforementioned essential language differences (as well as some [outstanding](https://github.com/PyO3/pyo3/issues/759) [issues](https://github.com/PyO3/pyo3/issues/1517) with pyo3 submodule imports), these should not be considered as suitable "drop-in" replacements for those defined by the `allmydata` Python package; these bindings are used mainly to support testing against the original implementation. (See the `test/` directory for examples.)