semvec/pypi-packages huggingface dataset:
promptly-llm 0.2.0
A lightweight library for LLM prompt management, observability/tracing, and optimization
Requires Python: >=3.9
Keywords: llm, prompt, ai, machine-learning, evaluation

# promptly

A lightweight, developer-friendly library for LLM prompt management, observability/tracing, and optimization.
Currently with support for Python.

## Features

- **Prompt Templates**: Jinja2-based templating system for dynamic prompts
- **Multi-Provider Support**: OpenAI, Anthropic, Google AI (Gemini), and extensible client architecture
- **Built-in Tracing**: Comprehensive observability for prompt execution
- **Genetic Optimization**: LLM-powered genetic algorithms for automated prompt improvement
- **Async Support**: Full async/await support for high-performance applications
- **CLI Interface**: Command-line tools for prompt management
- **Type Safety**: Full type hints and Pydantic models

## Installation


```bash
# Install UV if you haven't already
curl -LsSf https://astral.sh/uv/install.sh | sh

# Install promptly
uv pip install promptly

# With development dependencies
uv pip install promptly[dev]

# With CLI tools
uv pip install promptly[cli]

# With UI components
uv pip install promptly[ui]
```

## Quick Start

```python
import asyncio
from promptly import PromptRunner, OpenAIClient, PromptTemplate

async def main():
    # Initialize client
    client = OpenAIClient(api_key="your-api-key")

    # Create a prompt template
    template = PromptTemplate(
        name="greeting",
        template="Hello {{ name }}, how are you today?",
        variables=["name"]
    )

    # Create runner with tracing
    runner = PromptRunner(client)

    # Execute prompt
    response = await runner.run(
        template=template,
        variables={"name": "Alice"},
        model="gpt-3.5-turbo"
    )

    print(response.content)

asyncio.run(main())
```

## Prompt Optimization

Promptly includes an advanced genetic algorithm optimizer that uses LLMs to automatically improve your prompts through iterative evaluation and mutation. The optimizer can work with test cases for accuracy-based optimization or without test cases for general quality improvement.

**Quick Example:**
```bash
# Optimize with test cases
promptly optimize \
  --base-prompt "Answer this question: {{question}}" \
  --test-cases my_tests.json \
  --population-size 10 \
  --generations 5

# Quality-based optimization (no test cases needed)
promptly optimize \
  --base-prompt "Write a {{genre}} story about {{character}}" \
  --population-size 8 \
  --generations 4
```

For complete documentation on optimization features, configuration options, and examples, see **[OPTIMIZER_README.md](OPTIMIZER_README.md)**.

## CLI Usage

```bash
# Run a simple prompt
promptly run "What is the capital of France?" --model="gpt-3.5-turbo"

# Run with tracing
promptly run "Explain quantum computing" --trace

# View traces
promptly trace
```

## Development

For developers who want to contribute to or extend promptly:

- **[Developer Quick Start.md](DEVELOPER_QUICKSTART.md)** - Complete development guide

## License

MIT License - see LICENSE file for details.
bayesmbar 0.1.1
Bayesian Multistate Bennett Acceptance Ratio (BayesMBAR) methods for free energy calculations.
Requires Python: >=3.11

# Bayesian Multistate Bennett Acceptance Ratio Method

This repository contains the code for the Bayesian Multistate Bennett Acceptance Ratio Method as described in the [paper](https://doi.org/10.1021/acs.jctc.3c01212). BayesMBAR is a Bayesion generalization of the Multistate Bennett Acceptance Ratio (MBAR) method for computing free energy differences between multiple states. 

Besides its theoretical interest, BayesMBAR has two practical advantages over MBAR. First, it provides a more accurate uncertainty estimate, especially when the number of samples is small or the phase space overlap between states is poor. Second, it allows for the incorporation of prior information to improve the accuracy of the free energy estimates. For example, when the free energy surface over a collective variable is known to be smooth, BayesMBAR can use this information to improve the accuracy of the free energy estimates.  The [paper](https://doi.org/10.1021/acs.jctc.3c01212) has more details on the method and its applications.

We are committed to making the code as user-friendly as possible. We are actively working on improving the [documentation](http://xdinglab.com/BayesMBAR/) and adding more examples. If you have any questions or suggestions, please feel free to open an issue or [contact us](mailto:Xinqiang.Ding@tufts.edu) directly.
wavemonitor 0.4.2
A simple GUI for monitoring waveforms.
Requires Python: >=3.9

# Wave Monitor

![snapshot](https://qiujv.github.io/WaveMonitor/assets/snapshot.png)

A simple GUI for monitoring waveforms. It plots waveforms with PyQtGraph in a separate process.

The `WaveMonitor` class is the primary Python API.

In the GUI, right click to show the menu. Keyboard shortcuts are also supported.

Also see the [docs](https://qiujv.github.io/WaveMonitor/)

## Installation

```bash
pip install WaveMonitor
```

## Usage

```python
from wave_monitor import WaveMonitor
import numpy as np

monitor = WaveMonitor()
monitor.autoscale()
monitor.clear()

t = np.linspace(0, 1, 1_000_001)  # 1m pts ~= 1ms for 1GSa/s.
n = 20
i_waves = [np.cos(2 * np.pi * f * t) for f in range(1, n + 1)]
q_waves = [np.sin(2 * np.pi * f * t) for f in range(1, n + 1)]

for i, (i_wave, q_wave) in enumerate(zip(i_waves, q_waves)):
    monitor.add_wfm(f"wave_{i}", t, [i_wave, q_wave])
monitor.autoscale()

monitor.add_wfm("wave_1", t, [i_waves[-1], q_waves[-1]])  # Replaces previous wfm.
monitor.add_note("wave_1", "re-writen")

monitor.remove_wfm("wave_10")
```

## Acknowledge

This project is derived from [WaveViewer](https://github.com/kahojyun/wave-viewer).
train-12306-mcp 0.1.3
train_12306_mcp
Requires Python: >=3.10

# <div align="center">train_12306_mcp</div>

12306 MCP server, implementing the ticket inquiry feature.

基于 Model Context Protocol (MCP) 的12306购票搜索服务器。

<div align="center"> 

| 功能描述                         | 状态     |
|------------------------------|--------|
| 查询12306购票信息              | ✅ 已完成  |
| 过滤列车信息                   | ✅ 已完成  |
| 过站查询                      | ✅ 已完成 |
| 中转查询                      | ✅ 已完成 |

</div>

## <div align="center">⚙️Installation</div>

## <div align="center">▶️Quick Start</div>

### CLI-stdio
~~~bash
uv run -m train_12306_mcp
~~~

### MCP sever configuration

~~~json
{
  "mcpServers": {
    "train_12306_mcp": {
      "args": [
        "train_12306_mcp@latest"
      ],
      "command": "uvx"
    }
  }
}
~~~
precellar 0.5.1
precellar: Single-cell epigenomics preprocessing toolkit
Requires Python: <3.14,>=3.9

# Single-cell genomics preprocessing package

This tool is an automated pipeline for preprocessing single-cell genomics data.
It is designed to take raw data (fastq files) from a variety of single-cell genomics
platforms and a seqspec file as input, and output a count matrix (RNA) or a fragment file (ATAC)
for downstream analysis. The seqspec files for common platforms can be found here: https://github.com/IGVF/seqspec.

## Installation

### Stable version

```
pip install precellar
```

### Development version

```
pip install 'git+https://github.com/regulatory-genomics/precellar.git#egg=precellar&subdirectory=python'
```

For more information, please refer to the documentation: https://lab.kaizhang.org/precellar/.
gasp-ssfp 0.0.3
Generation of Arbitary Spectral Profiles using bSSFp MRI
Requires Python: >=3.8
Keywords: gasp, mri, ssfp


# GASP: Generation of Arbitrary Spectral Profiles

## Overview

GASP (Generation of Arbitrary Spectral Profiles) is a Python library for simulating and analyzing MRI sequences, particularly focused on balanced Steady-State Free Precession (bSSFP) and spectral shaping techniques. This project provides tools for simulating MRI signals, generating phantoms, and applying the GASP method to achieve desired spectral profiles.

## Features

- Simulation of bSSFP sequences
- Generation of various phantom types (e.g., Shepp-Logan, circles, blocks)
- Implementation of the GASP method for spectral shaping
- Tools for analyzing and visualizing MRI data
- Support for different tissue types and their relaxation properties

## Development

This project requires python 3.8+ and has the following dependancies: 
`numpy matplotlib scikit-image seaborn pymapvbvd jupyterlab gdown scipy`

To setup a local python enviroment with conda:

Create a new conda environment from scatch 
> ```
> conda create -n gasp python=3.8 
> conda activate gasp
> ```
> Then install packages with pip:
> ```
> pip install numpy matplotlib scikit-image seaborn pymapvbvd jupyterlab gdown scipy
> ```

## Usage

Here's a basic example of how to use the GASP simulation:

```python
from gasp import simulation, responses

# Set up simulation parameters
width, height = 256, 256
npcs = 16
TRs = [5e-3, 10e-3, 20e-3]
alpha = np.deg2rad(60)
gradient = 2 * np.pi

# Create a desired spectral profile
D = responses.gaussian(width, bw=0.2, shift=0)

# Simulate GASP
Ic, M, An = simulation.simulate_gasp(D, width, height, npcs, TRs, alpha, gradient)

# Visualize results
simulation.view_gasp_results(Ic, M, D)
```

## Modules

- `analysis.py`: Contains functions for analyzing GASP results and Dixon methods
- `dataloader.py`: Handles loading of raw MRI data
- `dataset.py`: Provides functions to load specific datasets
- `gasp.py`: Core implementation of the GASP method
- `phantom.py`: Functions for generating various phantom types
- `responses.py`: Implements different spectral response functions
- `simulation.py`: Main simulation routines for bSSFP and GASP
- `ssfp.py`: Implementation of Steady-State Free Precession signal equations
- `tissue.py`: Defines tissue properties and generates tissue phantoms
- `view.py`: Visualization tools for 3D data