semvec/pypi-packages huggingface dataset:
thermoML-macos 0.1.0
Physics-informed ML for thermal fluid property prediction
License: MIT
Requires Python: >=3.9
Keywords: python, chemistry-ml, thermodynamics-informed-ml, machine-learning, thermal-fluids


ThermoML is a Python package for predicting thermophysical properties of pure fluids using chemistry- and temperature-aware machine learning models. This tool integrates physics-informed modeling with machine learning techniques to accurately predict thermophyiscal properties across temperature ranges. The package includes pre-trained models, data preprocessing utilities, and simple interfaces for inference and evaluation.

Key Features:
1. Predict property of interest (such as dynamic viscosity) from SMILES and temperature
2. Flexible equation integration based on the property of interest (e.g., Arrhenius-based scaling for viscosity)
3. Easy-to-use for batch predictions
4. Includes curated datasets and example notebooks

Whether you're working on thermal fluid research, chemical engineering, or data-driven materials science, ThermoML provides a fast and extensible way to estimate temperature-dependent fluid properties.

This is the exact same repository as thermoML (see https://github.com/AI4ChemS/thermoML), but that package is only compatible with Windows and Linux - this package is the exact same, but specifically for macOS. For Windows and Linux users, please see pyPI thermoML.
pointerflow 0.1.0
High-performance Python library for zero-copy memory mapping.
License: MIT
Requires Python: >=3.9

# PointerFlow

**PointerFlow** is a high-performance library for Python designed to eliminate the data transfer bottleneck between CPU and GPU. By using **zero-copy memory mapping**, it allows processors to share a common physical memory space completely asynchronously. It is powered by C++ and custom-made CUDA kernels.

## The Edge of Low Latency

In applications where milliseconds also count, PointerFlow is faster than conventional frameworks like PyTorch in real-time data flow management applications.

- **Round-Trip Latency:** Reduced from **0.86 ms** (industry standard) to **0.14 ms**.
- **Dispatch Overhead:** Return of control to Python in **< 0.1 ms** using *non-blocking CUDA Streams*.
- **True Zero-Copy:** Complete elimination of `cudaMemcpy`. Data written to a NumPy view is instantly available to the GPU via the PCIe bus.

## Technical Architecture

PointerFlow combines the efficiency of **C++20** with the flexibility of **Python** through a low-level integration.

1. **Memory Management (RAII):** Automatic lifecycle management of *Pinned Memory* and *CUDA Streams* to prevent memory leaks in high-frequency executions.
2. **NumPy Integration:** Creating memory views using `py::capsule`, allowing Python to manipulate data in RAM that is read directly by the GPU.
3. **Asynchronous Execution:** Native support for CUDA kernels fired in independent streams, allowing real overlap of computation and business logic.
mantisdk 0.1.8
Mantisdk - AI Agent Training and Evaluation Platform
License: MIT
Requires Python: >=3.10
Keywords: agents, ai, evaluation, llm, mantis, observability, reinforcement-learning, training

# Mantisdk

[![PyPI version](https://badge.fury.io/py/mantisdk.svg)](https://badge.fury.io/py/mantisdk)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

**AI Agent Training and Evaluation Platform**

Mantisdk is a comprehensive toolkit for training and evaluating AI agents using reinforcement learning, automatic prompt optimization, and supervised fine-tuning.

## Core Features

- Turn your agent into an optimizable beast with **minimal code changes**
- Build with **any** agent framework (LangChain, OpenAI Agent SDK, AutoGen, CrewAI, and more)
- **Selectively** optimize one or more agents in a multi-agent system
- Embraces **algorithms** like Reinforcement Learning, Automatic Prompt Optimization, Supervised Fine-tuning and more

## Installation

```bash
pip install mantisdk
```

For optional dependencies:

```bash
# For LLMProxy feature (note: has strict dependency pins for boto3, grpcio, uvicorn)
pip install 'mantisdk[proxy]'

# For APO (Automatic Prompt Optimization)
pip install 'mantisdk[apo]'

# For VERL integration
pip install 'mantisdk[verl]'

# For Weave integration
pip install 'mantisdk[weave]'

# For MongoDB store
pip install 'mantisdk[mongo]'
```

## Quick Start

```python
import mantisdk as msk

# Initialize the client
client = msk.MantisdkClient()

# Your agent code here...
```

## CLI Usage

```bash
# Start the Mantisdk server
msk store serve

# Run with vLLM
msk vllm start
```

## Documentation

For full documentation, visit [https://withmetis.github.io/mantis/mantisdk/](https://withmetis.github.io/mantis/mantisdk/)

## License

MIT License - see [LICENSE](LICENSE) for details.
git-commit-tracker 0.1.0
A CLI tool to detect which tests are impacted by a git commit.
License: MIT
Requires Python: >=3.8

# Git Commit Tracker

Git Commit Tracker is a small CLI utility to determine which tests a given Git commit touches by mapping changed file ranges to test definitions discovered via Tree-sitter ASTs.

## Key principles

- AST-first: parse files to locate test definitions and compute exact line ranges.
- Language-driven: pick a parser by file extension and cache parsers for reuse.
- Conservative impact: report tests that overlap changed line ranges (added, removed, or modified).

## Quick start

Prerequisites

- Python 3.8+
- Git

Install for development

```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -e .
```

Install from PyPI

```bash
pip install git-commit-tracker
```

Run the CLI

```bash
impact-analyzer --commit <SHA> --repo <PATH_OR_URL>
```

## Common examples

- Analyze a remote repo (auto-clones): `impact-analyzer --commit 75cdcc5 --repo https://github.com/example/repo`
- Analyze a local repo: `impact-analyzer --commit 45433fd --repo ./my-local-project`
- Analyze a private repo: `impact-analyzer --commit 45433fd --repo https://<your-access-token>@github.com/owner/repo.git`

## What it detects

- JavaScript / TypeScript: `test`, `it`, `describe` call expressions (including `.only`, `.skip`).
- Python: functions named `test_*`.
- Other languages: extend by adding parsers and detection rules.

## Project structure

- `src/impact_analyzer/cli.py`: CLI entrypoint and repo handling (cloning, temp dirs).
- `src/impact_analyzer/engine.py`: Main orchestration—diff inspection, parsing, and result formatting.
- `src/impact_analyzer/parser.py`: Tree-sitter parsing and AST traversal to find tests and ranges.
- `src/impact_analyzer/languages.py`: Extension-to-parser mapping and parser caching.
- `src/impact_analyzer/git_utils.py`: Helpers to extract changed line ranges from commit diffs.

## Architecture notes

- The CLI resolves the repo (local path or remote URL) and checks out the requested commit.
- `git_utils` extracts hunks and changed line sets between the commit and its parent.
- Parsers in `languages.py` are looked up by extension; `parser.py` walks the AST and emits test identifiers and their line ranges.
- `engine.py` computes intersections between changed lines and test ranges to produce the final impact report.

## Extending the tool

1. Add a Tree-sitter grammar dependency (if needed) and expose it via `languages.py`.
2. Add detection logic for new test forms in `parser.py`.

## License

MIT