semvec/pypi-packages huggingface dataset:
torch2transformer 0.2.0
# torch2transformer
Requires Python: >=3.9

# torch2transformer

**torch2transformer** lets you wrap plain PyTorch models so they work
seamlessly with the Hugging Face Transformers ecosystem.  

**Important:** The original PyTorch model class must be available at **run time** and **load time**.

---

## Features

- Wrap any PyTorch model for Hugging Face `Trainer`
- Save / load via `save_pretrained` / `from_pretrained`
- Supports Hugging Face `.generate()` for autoregressive text generation
- Minimal interface required: `forward(input_ids, labels=None)` returning `{"logits": ..., "loss": ...}`
- No custom training loops needed

---

## Installation

```bash
pip install torch2transformer
or,
uv pip install torch2transformer
```

## Example

```python
from torch2transformer import TorchAdapter, wrap_model, load_model

# wrap Pytorch model as a Transformer model
model = wrap_model(
    torch_model_cls=TinyCharModel,
    torch_model_kwargs={"vocab_size": 100, "hidden_size": 32},
    task_type="causal_lm"
)
# then can be used with Trainer()

# save model
model.save_pretrained("./tiny_ckpt")

# load model
model = load_model("./tiny_ckpt", torch_model_cls=TinyCharModel)

# example input
seed_text = "I love "
input_ids = torch.tensor([[char2id[c] for c in seed_text]])

# generate next characters
output_ids = model.generate(input_ids, max_new_tokens=20)
pred_text = "".join([id2char[i] for i in output_ids[0].tolist()])
print(pred_text)
simpleval 1.1.1
Simple Evaluation Framework for LLM use cases
Requires Python: >=3.11

# Simple LLM Evaluation

[![version](https://img.shields.io/github/v/release/cyberark/simple-llm-eval)](https://pypi.org/project/simpleval/)
![Build Status](https://github.com/cyberark/simple-llm-eval/actions/workflows/ci.yml/badge.svg)
![Code Coverage](https://raw.githubusercontent.com/cyberark/simple-llm-eval/refs/heads/badges/ci/badges/coverage-updated.svg)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/simpleval)
[![license](https://img.shields.io/badge/license-Apache%202.0-blue?style=flat-square)](https://raw.githubusercontent.com/cyberark/simple-llm-eval/refs/heads/main/LICENSE)
[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/cyberark/simple-llm-eval/badge)](https://scorecard.dev/viewer/?uri=github.com/cyberark/simple-llm-eval)

![Simpleval Banner](https://raw.githubusercontent.com/cyberark/simple-llm-eval/main/docs/media/simpleval-banner.jpeg)

Welcome to the simple LLM evaluation framework—**simpleval**, for short.

**simpleval** is a Python package designed to make evaluating Large Language Models (LLMs) easier, using the "LLM as a Judge" technique.

It supports a [variety of LLM providers](https://cyberark.github.io/simple-llm-eval/latest/getting-started/judge-authentication/), including OpenAI, Google (Gemini API, Vertex), AWS Bedrock, Anthropic, Azure, and more (via LiteLLM).

**simpleval** also includes several reports to help you analyze, compare, and summarize your evaluation results. See the [available reports](https://cyberark.github.io/simple-llm-eval/latest/getting-started/reporting/) for more details.

## Getting Started

See the [📚 Quickstart Guide 📚](https://cyberark.github.io/simple-llm-eval/latest/getting-started/quickstart/)

## Documentation

See [📚 Project Documentation 📚](https://cyberark.github.io/simple-llm-eval/)

## Contributing

We appreciate your help in making this project better! ✨

If you would like to contribute to this project, please follow the guidelines outlined in the [CONTRIBUTING.md](https://github.com/cyberark/simple-llm-eval/blob/main/CONTRIBUTING.md) file.

## License

simpleval is released under the [Apache License](https://www.apache.org/licenses/LICENSE-2.0). See the [LICENSE](https://github.com/cyberark/simple-llm-eval/blob/main/LICENSE) file for more details.

## Contact

If you have any questions or suggestions, feel free to join our [GitHub discussions forum](https://github.com/cyberark/simple-llm-eval/discussions) 💬

If you want to report a bug or request a feature, please open an issue in the [GitHub issues tracker](https://github.com/cyberark/simple-llm-eval/issues) 🐛

<br>
canvas-nbgrader 0.1.0
Add your description here
Requires Python: >=3.14

# Canvas/nbgrader utility

This is a package for automating the process of creating and grading
assignments in Jupyter notebooks. It is designed to work with the
[nbgrader](https://nbgrader.readthedocs.io/en/stable/) package, which is a tool
for creating and grading assignments in Jupyter notebooks. The package provides
a set of utilities for creating and grading assignments, as well as a set of
tools for managing the assignment process.
terryann-cli 0.5.2
CLI for TerryAnn Medicare Journey Intelligence Platform
Requires Python: >=3.11

# TerryAnn CLI

Command line interface for the TerryAnn Medicare Journey Intelligence Platform.

## Installation

```bash
pip install -e .
```

## Configuration

Set the gateway URL via environment variable:

```bash
export TERRYANN_GATEWAY_URL=https://terryann-core-production.up.railway.app
```

Or create a config file at `~/.terryann/config.toml`:

```toml
[gateway]
url = "https://terryann-core-production.up.railway.app"
```

## Usage

### Check gateway status

```bash
terryann status
```

### Start interactive chat

```bash
terryann chat
```

## Development

```bash
pip install -e ".[dev]"
pytest
```
terryann-core 0.1.0
Gateway + MCP Server for TerryAnn V2 - Medicare Journey Intelligence Platform
Requires Python: >=3.11

# TerryAnn Core

Gateway + MCP Server for TerryAnn V2 - Medicare Journey Intelligence Platform.

## Overview

TerryAnn Core provides:
- **Gateway API**: Conversation endpoint that handles user messages and orchestrates responses
- **MCP Server**: Tool definitions for cohort generation, journey simulation, and campaign execution
- **Session Management**: Conversation state and context tracking

## Quick Start

```bash
# Install dependencies
pip install -e .

# Copy environment file
cp .env.example .env
# Edit .env with your settings

# Run locally
uvicorn app.main:app --reload --port 8080
```

## API Endpoints

### Gateway

- `POST /gateway/message` - Send a message and get a response
- `GET /gateway/session/{session_id}` - Get session details
- `GET /gateway/tools` - List available MCP tools

### Health

- `GET /` - Service info
- `GET /health` - Health check

## MCP Tools

| Tool | Description |
|------|-------------|
| `generate_cohort` | Generate a cohort based on targeting criteria |
| `get_cohort` | Retrieve an existing cohort |
| `simulate_journey` | Run Monte Carlo simulation on a journey |
| `compare_scenarios` | Compare multiple journey variations |
| `create_journey` | Create a new journey blueprint |
| `modify_journey` | Modify an existing journey |
| `optimize_journey` | Auto-optimize a journey for a goal |
| `push_to_crm` | Push data to CRM (Salesforce/HubSpot) |
| `schedule_campaign` | Schedule campaign execution |

## Project Structure

```
terryann-core/
├── app/
│   ├── main.py              # FastAPI entry point
│   ├── config.py            # Settings
│   ├── gateway/             # Conversation handling
│   │   ├── router.py        # Endpoints
│   │   ├── session.py       # Session management
│   │   └── auth.py          # Auth middleware
│   ├── mcp/                 # MCP Server
│   │   ├── server.py        # Tool registration
│   │   └── tools/           # Tool implementations
│   └── models/              # Pydantic schemas
├── tests/
├── Dockerfile
├── railway.toml
└── pyproject.toml
```

## Development

```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Lint
ruff check .
```

## Deployment

Configured for Railway deployment via `railway.toml`.

```bash
railway up
```
daxs 2026.1
Data Analysis for X-ray Spectroscopy
Requires Python: >=3.10

# Data Analysis for X-ray Spectroscopy

## Usage at the ESRF

### In scripts

If you want to use the library in scripts you execute on the ESRF computing cluster, follow the steps below.

1. Use a terminal to log in on one of the computing cluster front ends: `ssh -Y account@cluster-access`. The `account` can be your personal SMIS account or the user experiment number. Enter the associated password when prompted.
2. Ask for resources: `srun --x11 --pty bash -l`. This will give you an interactive shell. In addition, you can add `--time=hh:mm:ss` to specify the maximum time the resources will be available; by default, it will be 1 hour.
3. Load the spectroscopy environment module: `module load spectroscopy`. The command loads an environment that contains the latest stable version of `daxs`.
4. Print the version of the library to test that everything went smoothly: `python -c "import daxs; print(daxs.__version__)"`.

If all goes well with the previous command and you don't get an error, you should be able to use the library in your scripts.

### In Jupyter notebooks

You can also use the library in Jupyter notebooks.

1. Connect to <https://jupyter-slurm.esrf.fr>.
2. Select the `Spectroscopy (latest)` in the `Jupyter environment` drop-down menu.
3. Change the `Job duration` in case you need to run your notebook for a longer time, than the default 1 hour.
4. Press `Start` at the bottom of the page.

![image](https://gitlab.esrf.fr/spectroscopy/daxs/-/raw/main/doc/_static/images/jupyter-slurm.png){width=35%}

You can find more information about Jupyter at ESRF [here](https://confluence.esrf.fr/display/DAUWK/Jupyter+@+ESRF).

While this simplifies the usage, you will not be able to add Python packages to the virtual environment. If you want to use additional packages not present in the environment, either open an issue [here](https://gitlab.esrf.fr/apptainer/spectroscopy/-/issues) or install the library in your home directory, in a virtual environment (see below).

## Local installation

The latest stable version of the library can be installed using:

`pip install daxs`

The development version can be installed using:

`pip install [--ignore-installed] pip install git+https://gitlab.esrf.fr/spectroscopy/daxs.git`

The `--ignore-installed` argument **is required** to upgrade an existing installation.

Installing the library in a virtual environment is best to avoid messing up other Python packages. See [the official documentation](https://docs.python.org/3/tutorial/venv.html) on how to create and use virtual environments.

## Documentation

The documentation can be found at <https://daxs.readthedocs.io>.