semvec/pypi-packages huggingface dataset:
boson-release 1.0.0
Python SDK for BSO Registry
Requires Python: >=3.8

# BSO Python SDK

Python client library for the Docker Release Registry.

## Installation

```bash
pip install bso
```

## Quick Start

```python
from bso import Registry

# Initialize client
registry = Registry(
    base_url="http://localhost/api",
    api_key="your-api-key"
)

# Or use environment variables
# REGISTRY_URL=http://localhost/api
# REGISTRY_API_KEY=your-api-key
registry = Registry.from_env()

# Create a model
model = registry.create_model(
    name="myorg/pytorch-model",
    storage_path="s3://models/myorg/pytorch-model",
    description="My PyTorch model"
)

# Create a release
release = registry.create_release(
    model_name="myorg/pytorch-model",
    version="1.0.0",
    tag="v1.0.0",
    digest="sha256:abc123...",
    metadata={
        "pytorch_version": "2.1.0",
        "accuracy": 0.95,
        "git_commit": "abc123"
    }
)

# Record a deployment
deployment = registry.deploy(
    release_id=release.id,
    environment="production",
    metadata={"replicas": 3}
)

# Get latest release
latest = registry.get_latest_release(
    model_name="myorg/pytorch-model",
    environment="production"
)

print(f"Latest release: {latest.version}")
```

## API Reference

See the [documentation](https://docs.example.com) for complete API reference.

## License

MIT
cursor-wrapped 1.0.10
Your Cursor IDE year in review - see your AI coding stats for 2025
Requires Python: >=3.8
Keywords: ai, analytics, coding, cursor, stats, wrapped, year-in-review

# Cursor Wrapped 2025 🎁

Your Cursor year in review - see your AI coding stats for 2025!

## Quick Start

```bash
# Using uv (recommended)
uvx cursor-wrapped


```

## How It Works


1. Opens a browser window for you to sign in to your Cursor account
2. Fetches your usage data from Cursor
3. Displays an animated summary of your year
4. Option to share summary card of stats on X or iMessage!

## Requirements

- Python 3.8+
- Chrome browser (for authentication)

## Links

- [GitHub](https://github.com/riyapatel25/cursorWrapped)
- [python package](https://pypi.org/project/cursor-wrapped/)
stochtest 0.6.2
Stochtest is a Python library for performing statistical assertions on stochastic outputs.
Requires Python: >=3.10
Keywords: MCMC, assertions, monte carlo, simulation, statistics, stochastic, test, testing, unittest

# stochtest

[![PyPI - Version](https://img.shields.io/pypi/v/stochtest.svg)](https://pypi.org/project/stochtest)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/stochtest.svg)](https://pypi.org/project/stochtest)

-----

Stochtest is a Python library for performing statistical assertions on stochastic outputs (i.e. outputs described by probability distributions) using statistical methods. It enables automated testing for probabilistic code and Monte Carlo simulations.

## Installation

```console
pip install stochtest
```

## Usage

### 1. Asserting Rates & Means

Use `stochtest.assert_that(samples)` to validate acceptance rates (proportions) or expected values (means).

```python
import stochtest
import numpy as np

# --- Acceptance Rates (Proportions) ---
samples = np.random.normal(1000)

stochtest.assert_that(samples > 0).has_acceptance_rate_greater_than(0.4)
stochtest.assert_that(outcomes).has_acceptance_rate_between(0.45, 0.55)

# --- Expected Values (Means) ---
# Validated using one-sample Student's t-tests
returns = np.random.normal(1, 0.5, 1000)

stochtest.assert_that(returns).has_expected_value_greater_than(0.5)
stochtest.assert_that(returns).has_expected_value_between(0.9, 1.1)

```

### 2. Asserting Distributions

Use `stochtest.distributions.assert_that(samples)` to verify that an entire dataset matches a specific shape or theoretical distribution using a **Bootstrapped Kolmogorov-Smirnov (KS) Test**.

This asserts that the distributions are **sufficiently similar** by ensuring the KS distance is consistently within a specific `margin` with high confidence.

```python
import numpy as np
import scipy.stats
import stochtest.distributions

samples = np.random.normal(0, 1, 1000)

# Assert samples follow a normal distribution (mean=0, std=1)
stochtest.distributions.assert_that(samples).has_normal_distribution(
    loc=0, scale=1, margin=0.05
)

# Assert samples match a custom CDF (e.g., Uniform)
stochtest.distributions.assert_that(samples).has_distribution(
    lambda x: scipy.stats.uniform.cdf(x), 
    margin=0.05
)

```

## License

`stochtest` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
llnl-clippy 0.4.2
A Python interface to HPC resources
Requires Python: >=3.10

# CLIPPy - Command Line Interface Plus Python
 ````
 ╭────────────────────────────────────╮
 │ It looks like you want to use HPC. │ 
 │ Would you like help with that?     │
 ╰────────────────────────────────────╯
  ╲
   ╲
    ╭──╮  
    ⊙ ⊙│╭
    ││ ││
    │╰─╯│
    ╰───╯
````

## Overview

Clippy (CLI + PYthon) is a Python language interface to HPC resources. Precompiled binaries
that execute on HPC systems are exposed as methods to a dynamically-created `Clippy` Python
object, where they present a familiar interface to researchers, data scientists, and others.
Clippy allows these users to interact with HPC resources in an easy, straightforward
environment – at the REPL, for example, or within a notebook – without the need to learn
complex HPC behavior and arcane job submission commands.

## Installation of Python Code
```console
$ pip install .
```

## Building C++ Examples on LC

```console
$ . /usr/workspace/llamag/spack/share/spack/setup-env.sh
$ git clone https://github.com/LLNL/clippy-cpp.git
$ spack load gcc
$ spack load boost
$ cd clippy-cpp
$ mkdir build
$ cd build
$ cmake ../
$ make
$ cd ../.. #back to root project directory 
```

## Running Current C++ Examples
```python
$ CLIPPY_BACKEND_PATH=/path/to/binaries ipython3

In [1]: from clippy import *

 ╭────────────────────────────────────╮
 │ It looks like you want to use HPC. │ 
 │ Would you like help with that?     │
 ╰────────────────────────────────────╯
  ╲
   ╲
    ╭──╮  
    ⊙ ⊙│╭
    ││ ││
    │╰─╯│
    ╰───╯

In [2]: c = ClippyBag()  # creates a bag datastructure.

In [3]: c.insert("foo").insert("bar")  # mutating methods can be chained
       
Out[3]: foo bar

In [4]: c.size()  # nonmutating methods return the appropriate output.
Out[4]: 2

```
## Authors
- Seth Bromberger (seth at llnl dot gov)
- Roger Pearce (rpearce at llnl dot gov)


## License
CLIPPy is distributed under the MIT license.

See [LICENSE-MIT](LICENSE-MIT), [NOTICE](NOTICE), and [COPYRIGHT](COPYRIGHT) for
details.

SPDX-License-Identifier: MIT

## Release
LLNL-CODE-818157
malpz 9.0.13
The MALPZ (Malware Pickled Zip) format describes a method of neutering malware while providing a simple, extensible mechanism for capturing metadata
Requires Python: >=3.9
Keywords: malware, malpz, neuter

# malpz

## Overview

The MALPZ (Malware Pickled Zip) format describes a method of neutering malware
while providing a simple, extensible mechanism for capturing metadata.

This project is deprecated and we encourage use of CART format instead.

https://github.com/CybercentreCanada/cart