semvec/pypi-packages huggingface dataset:
openresponses-types 2.3.0.post1
Python SDK for OpenResponses specification
Requires Python: >=3.11
Keywords: ai, llm, openapi, openresponses, pydantic

# OpenResponses Types

[![PyPI version](https://img.shields.io/pypi/v/openresponses-types)](https://pypi.org/project/openresponses-types/)
[![Python versions](https://img.shields.io/pypi/pyversions/openresponses-types)](https://pypi.org/project/openresponses-types/)
[![License](https://img.shields.io/pypi/l/openresponses-types)](https://github.com/mozilla-ai/openresponses-python/blob/main/LICENSE)

Python SDK providing Pydantic models for the [OpenResponses](https://github.com/openresponses/openresponses) API specification.

## Installation

```bash
pip install openresponses-types
```

## Development

### Setup

```bash
# Clone the repository
git clone https://github.com/mozilla-ai/openresponses-python.git
cd openresponses-python

# Create virtual environment and install dependencies
uv venv && source .venv/bin/activate
uv sync --group dev
```

### Generate Types

The types are generated from the OpenResponses OpenAPI specification:

```bash
# Generate types (fetches spec if changed)
uv run python scripts/generate_types.py

# Force regeneration
uv run python scripts/generate_types.py --force

# Check if spec has changed
uv run python scripts/generate_types.py --check

# Show current spec hash
uv run python scripts/generate_types.py --version
```

## Versioning

This package follows [Semantic Versioning](https://semver.org/):

- **Major**: Breaking changes to helper types/API
- **Minor**: New types from spec updates, new helpers
- **Patch**: Bug fixes, documentation updates

The package includes a `__spec_hash__` attribute to track which OpenAPI spec version was used to generate the types.

## License

Apache 2.0 - see [LICENSE](LICENSE) for details.

## Links

- [OpenResponses Specification](https://github.com/openresponses/openresponses)
- [PyPI Package](https://pypi.org/project/openresponses-types/)
- [Issue Tracker](https://github.com/mozilla-ai/openresponses-python/issues)
londonaicentre-llama-serve 1.2.0
Serve llama models locally
Requires Python: >=3.12

# Llama serve

> [!WARNING]
> This package is now deprecated. Use `londonaicentre-mesa-local` rather than `londonaicentre-llama-serve` for pip commands.

Serve llama models locally.

- ⬇️ Downloads weights from S3

- 📦 Unpacks

- 🚀 Serves via a local OpenAI-compatible server

## Prerequisites

### Software

- Python 3.12

### Hardware

- A GPU with >=24GB VRAM (tested on NVIDIA A30)

### Configuration

- Create a file called `.env` in the directory where you intend to run this package.
Populate it with the details you have been provided with in the following format:

```text
MODEL_NAME=
WEIGHTS_ID=
WEIGHTS_KEY=
```

## Installation

1. (Recommended) Create a virtual environment and activate it:

    ```python
    python -m venv .venv
    source .venv/bin/activate
    ```

2. Install this package: `pip install londonaicentre-llama-serve`.

## Usage

### CLI

1. Note command line arguments:

    | Argument  | Description  |
    |---|---|
    | -v, --verbose | Enable debug output (optional) |

2. Start the server as follows: `llamaserve [args]`.

## Clients

### OpenAI (example)

1. Interact with the server using the [OpenAI client](https://pypi.org/project/openai) in python:

    ```python
    from openai import OpenAI

    client = OpenAI(
        base_url="http://localhost:5000/v1",
        api_key="blank" 
    )

    response = client.chat.completions.create(
        model="<MODEL_NAME>",
        messages=[
            {"role": "system", "content": "You are an LLM named gpt-4o"},
            {"role": "user", "content": "Hello"}
        ]
    )

    print(response.choices[0].message.content)
    ```

## License

This project uses a proprietary license (see [LICENSE](LICENSE.md)).
jaxeffort 0.2.5
JAX-based emulator for galaxy power spectra with bias modeling
Requires Python: <4.0,>=3.10

# jaxeffort
[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](
https://drive.google.com/file/d/1FxnXViYqIAg8Vu13Tippf0m7RIuSseEu/view?usp=sharing)
[![codecov](https://codecov.io/gh/CosmologicalEmulators/jaxeffort/branch/develop/graph/badge.svg?token=GPLEGMIU08)](https://codecov.io/gh/CosmologicalEmulators/jaxeffort)
[![arXiv](https://img.shields.io/badge/arXiv-2501.04639-b31b1b.svg)](https://arxiv.org/abs/2501.04639)
[![Documentation](https://img.shields.io/badge/docs-stable-blue.svg)](https://cosmologicalemulators.github.io/jaxeffort/stable/)
[![Documentation Dev](https://img.shields.io/badge/docs-dev-blue.svg)](https://cosmologicalemulators.github.io/jaxeffort/dev/)

JAX-based emulator for galaxy power spectra with bias modeling and EFT corrections.

## Documentation

- **[Stable Documentation](https://cosmologicalemulators.github.io/jaxeffort/stable/)** - Latest release documentation
- **[Development Documentation](https://cosmologicalemulators.github.io/jaxeffort/dev/)** - Latest development version documentation

## Installation and usage

In order to install `jaxeffort`, you can just run

```bash
pip install jaxeffort
```

If you prefer to use the latest version from the repository, you can clone it, enter it, and run

```bash
pip install .
```

In order to use the emulators, you have to import `jaxeffort` and load a trained emulator

```python3
import jaxeffort
import jax.numpy as np
trained_emu = jaxeffort.load_multipole_emulator("/path/to/emu/")
```
Then you are good to go! You have to create input arrays for cosmological and bias parameters and retrieve your calculation result

```python3
cosmo_params = np.array([...])  # cosmological parameters
bias_params = np.array([...])   # bias parameters
result = trained_emu.get_Pl(cosmo_params, bias_params, D)
```

For a more detailed explanation, check the tutorial in the `notebooks` folder, which also shows a comparison with standard power spectrum calculations.

## Citing

Free usage of the software in this repository is provided, given that you cite our release paper.

M. Bonici, G. D'Amico, J. Bel, C. Carbone, [_Effort.jl: a fast and differentiable emulator for the Effective Field Theory of the Large Scale Structure of the Universe_](https://dx.doi.org/10.1088/1475-7516/2025/09/044), JCAP 09 (2025) 044

```bibtex
@article{Bonici_2025,
  doi = {10.1088/1475-7516/2025/09/044},
  url = {https://dx.doi.org/10.1088/1475-7516/2025/09/044},
  year = {2025},
  month = {sep},
  publisher = {IOP Publishing},
  volume = {2025},
  number = {09},
  pages = {044},
  author = {Bonici, Marco and D'Amico, Guido and Bel, Julien and Carbone, Carmelita},
  title = {Effort.jl: a fast and differentiable emulator for the Effective Field Theory of the Large Scale Structure of the Universe},
  journal = {Journal of Cosmology and Astroparticle Physics}
}
```
langgraph-checkpoint-mongodb 0.3.1
Library with a MongoDB implementation of LangGraph checkpoint saver.
Requires Python: >=3.10

# LangGraph Checkpoint MongoDB

Implementation of LangGraph CheckpointSaver that uses MongoDB.

## Usage

```python
from langgraph.checkpoint.mongodb import MongoDBSaver

write_config = {"configurable": {"thread_id": "1", "checkpoint_ns": ""}}
read_config = {"configurable": {"thread_id": "1"}}

MONGODB_URI = "mongodb://localhost:27017"
DB_NAME = "checkpoint_example"

with MongoDBSaver.from_conn_string(MONGODB_URI, DB_NAME) as checkpointer:
    checkpoint = {
        "v": 1,
        "ts": "2024-07-31T20:14:19.804150+00:00",
        "id": "1ef4f797-8335-6428-8001-8a1503f9b875",
        "channel_values": {
            "my_key": "meow",
            "node": "node"
        },
        "channel_versions": {
            "__start__": 2,
            "my_key": 3,
            "start:node": 3,
            "node": 3
        },
        "versions_seen": {
            "__input__": {},
            "__start__": {
            "__start__": 1
            },
            "node": {
            "start:node": 2
            }
        },
        "pending_sends": [],
    }

    # store checkpoint
    checkpointer.put(write_config, checkpoint, {}, {})

    # load checkpoint
    checkpointer.get(read_config)

    # list checkpoints
    list(checkpointer.list(read_config))
```

### Async

```python
from langgraph.checkpoint.mongodb import MongoDBSaver

write_config = {"configurable": {"thread_id": "1", "checkpoint_ns": ""}}
read_config = {"configurable": {"thread_id": "1"}}

MONGODB_URI = "mongodb://localhost:27017"
DB_NAME = "checkpoint_example"

with MongoDBSaver.from_conn_string(MONGODB_URI, DB_NAME) as checkpointer:
    checkpoint = {
        "v": 1,
        "ts": "2024-07-31T20:14:19.804150+00:00",
        "id": "1ef4f797-8335-6428-8001-8a1503f9b875",
        "channel_values": {
            "my_key": "meow",
            "node": "node"
        },
        "channel_versions": {
            "__start__": 2,
            "my_key": 3,
            "start:node": 3,
            "node": 3
        },
        "versions_seen": {
            "__input__": {},
            "__start__": {
            "__start__": 1
            },
            "node": {
            "start:node": 2
            }
        },
        "pending_sends": [],
    }

    # store checkpoint
    await checkpointer.aput(write_config, checkpoint, {}, {})

    # load checkpoint
    await checkpointer.aget(read_config)

    # list checkpoints
    [c async for c in checkpointer.alist(read_config)]
```
femtorun 3.1.2
Femtorun defines the runtime interface for Femtosense software
Requires Python: >=3.6

# Femtorun

Femtorun defines the parent class for different femtosense run-ables (runtimes).
The idea is to unify the API for invoking these different runtimes,
to make side-by-side comparison/verification easier.

Also includes IOSpec, which formalizes multi-IO/multi-model
inputs/outputs and sequencing for models