semvec/pypi-packages huggingface dataset:
envoy-schema 0.31.1
Envoy Schema - a collection of pydantic models compatible with the Envoy utility server
Requires Python: >=3.9
Keywords: envoy, csip-aus, 2030.5, csip, pydantic

# envoy-schema
Public schema for the models/schema associated all envoy API endpoints.

This repository was built as a shared dependency for the envoy utility server and any external clients wishing to integrate. 

Envoy: https://github.com/bsgip/envoy


## Envoy Server Models

The models served under `envoy_schema.server` are derived from the following standards:

* [IEEE: Smart Energy Profile (2030.5-2018)](https://standards.ieee.org/ieee/2030.5/5897/)
* [Sunspec: Common Smart Inverter Profile](https://sunspec.org/2030-5-csip/)
* [Common Smart Inverter Profile (Australia)](https://csipaus.org/)


## Envoy Admin Models

The models served under `envoy_schema.admin` are typically only used for services directly integrating with the envoy utility server (via the admin server). This is for machine-machine services that are not typically exposed externally.

# Installation

Install directly from pypi

`pip install envoy_schema`


# Development

To install `envoy-schema` for development purposes, after cloning this repository:

```
pip install -e .[dev, test]
pytest
```

We use the following linting/formatting tools:
* [bandit](https://pypi.org/project/black/)
* [flake8](https://pypi.org/project/flake8/)
* [mypy](https://pypi.org/project/mypy/)

Contributions via a pull request are welcome but will be validated using the above tools.

Tests can be run with: `pytest` from the root directory.
leancert 0.3.0
Formal verification for numerical Python code - powered by Lean4
Requires Python: >=3.10
Keywords: formal-verification, theorem-prover, interval-arithmetic, neural-network-verification, lean4, mathematical-proofs

# LeanCert

Formal verification for numerical Python code, powered by Lean4.

Write Python, get mathematical proofs. LeanCert proves properties about your code for *all* inputs, not just test samples.

## Installation

```bash
pip install leancert
```

That's it! The package includes pre-built binaries - no Lean installation required.

## Quick Start

```python
import leancert as lc

# Define a symbolic expression
x = lc.var('x')
expr = x**2 + lc.sin(x)

# Verify a bound holds for ALL x in [-2, 2]
verified = lc.verify_bound(expr, {'x': (-2, 2)}, lower=-0.25)
print(verified)  # True - mathematically proven!

# Find rigorous bounds
result = lc.find_bounds(expr, {'x': (-2, 2)})
print(f"min in [{result.min_lo}, {result.min_hi}]")
print(f"max in [{result.max_lo}, {result.max_hi}]")
```

## Neural Network Verification

Verify properties of neural networks across entire input domains:

```python
import leancert as lc
from leancert.nn import TwoLayerReLUNetwork, Layer
import numpy as np

# Create/load a neural network
layer1 = Layer.from_numpy(
    weights=np.array([[2.0, -2.0], [-2.0, 2.0]]),
    bias=np.array([0.0, 0.0]),
    activation='relu'
)
layer2 = Layer.from_numpy(
    weights=np.array([[1.0, 1.0]]),
    bias=np.array([0.0]),
    activation='none'
)
network = TwoLayerReLUNetwork(layer1=layer1, layer2=layer2)

# Prove output bounds for ALL inputs in domain
verified = lc.verify_nn_bounds(
    network,
    {'x0': (-1, 1), 'x1': (-1, 1)},
    output_lower=-5,
    output_upper=5,
)
print(verified)  # True - proven for every possible input!
```

## Key Features

- **Interval Arithmetic**: Rigorous bounds using machine-verified Lean4 kernel
- **Neural Networks**: Verify ReLU networks, transformers
- **Root Finding**: Locate and isolate roots with guaranteed correctness
- **Integration**: Compute integral bounds
- **PyTorch Import**: Load weights directly from PyTorch models

## Supported Functions

`sin`, `cos`, `tan`, `exp`, `log`, `sqrt`, `abs`, `sinh`, `cosh`, `tanh`, `atan`, `erf`, `sinc`, and more.

## Why LeanCert?

Traditional testing samples inputs: `f(0.5)`, `f(1.0)`, etc. You can never test `f(0.7)` and the infinitely many values in between.

LeanCert uses interval arithmetic to prove properties for *all* inputs simultaneously. The heavy lifting happens in Lean4's kernel, which has a small, trusted core verified to be mathematically sound.

## Links

- [Documentation](https://leancert.readthedocs.io)
- [GitHub](https://github.com/leanbound/leancert)
- [Examples](https://github.com/leanbound/leancert/tree/main/python/examples)

## License

Apache 2.0
mlflow-migration 1.2.1
Copy MLflow objects (experiments, runs or registered models) to another tracking server
Requires Python: >=3.12
Keywords: mlflow, ml, ai

# MLflow Migration

The MLflow Migration package provides tools to copy MLflow objects (runs, experiments or registered models) from one MLflow tracking server (Databricks workspace) to another.
Using the MLflow REST API, the tools export MLflow objects to an intermediate directory and then import them into the target tracking server.

# Reference notes

This is a technical fork of the original [MLflow Export Import](https://github.com/mlflow/mlflow-export-import) released under a new name and intended for publication on PyPI.

# Documentation

Documentation published at [https://mlflow-oidc.github.io/mlflow-migration/](https://mlflow-oidc.github.io/mlflow-migration/)

Documentation source is available in the [docs](docs) directory.

# Installation

Install the package using pip:

```bash
pip install mlflow-migration
```


# License

This project is licensed under the Apache License 2.0. See the [LICENSE](LICENSE) file for details.