semvec/pypi-packages huggingface dataset:
wiliot-certificate 4.5.2b2
A library for certifying Wiliot-compliant boards
Requires Python: >=3.9

# wiliot-certificate

<!-- Description -->
wiliot-certificate is a Python library that provides tools for testing and certifying boards for compatibility with Wiliot’s ecosystem.
This python package includes the following tools:
 - Certification Wizard (`wlt-cert`)
 - Certificate CLI (`wlt-cert-cli`)
 - Tester Upgrade (`wlt-cert-tester-upgrade`)
 - Registration Certificate Test (`wlt-cert-reg`)

# Versioning: 
wiliot-certificate versions 4.5.x are compatible with firmware version >=4.4.0.
- Bridge API version >= 12
- Gateway API version >= 203

## Installing wiliot-certificate
````commandline
pip install wiliot-certificate
````

## Using wiliot-certificate
### Certification
````commandline
wlt-cert
````
This tool is the default to test and certify your device.
It runs a setup wizard that walks you through the initialization steps before running the tests.
You'll need a [validation schema](https://community.wiliot.com/customers/s/article/Validation-Schema) and a [tester device](https://community.wiliot.com/customers/s/article/Wiliot-Certification).
Once set up it opens a terminal and tests your device.



### Certificate CLI
````commandline
wlt-cert-cli -h
````
CLI version of the certificate. Use -h for details on the different arguments.


### Tester Upgrade
````commandline
wlt-cert-tester-upgrade
````
Upgrades the firmware of the tester device to the version required for certification.


### Registration Certificate
````commandline
wlt-cert-reg
````
Certify the gateway registration process to Wiliot platform.
The gateway must use Wiliot production MQTT broker, and mustn't be registered to any account on Wiliot platform.
Use -h for details on the arguments (see [Registration](https://community.wiliot.com/customers/s/article/Wiliot-Certification) for more info).


## The following capabilities are not tested in this version
##### Cloud Connectivity & Misc
 - Board type registered within the Board Type Management system
##### Module Energy 2400
  - Functionality of energy pattern, output power and duty cycle
##### Module Energy SUB1G
  - Functionality of energy pattern and duty cycle 
##### Module Datapath 
  - RSSI edge cases: -127 and 0 
  - Functionality of transmission pattern, output power
##### Calibration 
  - Functionality of output power and interval calibration 
  - Functionality of calibration transmission patterns for the configuration STANDARD & EU & DISABLE
dsd-scalingo 0.1.1
A plugin for django-simple-deploy, supporting deployments to Scalingo.
Requires Python: >=3.9
Keywords: django, deployment

# dsd-scalingo

A plugin for deploying Django projects to Scalingo, using django-simple-deploy.

For full documentation, see the documentation for [django-simple-deploy](https://django-simple-deploy.readthedocs.io/en/latest/).

Current status
---

This plugin is in a pre-1.0 development phase. Scalingo has one of the best free trial plans in the industry, so this plugin will be prioritized and should move forward quickly.

Fully automated deployment
---

- Install the Scalingo CLI.
- Upload your SSH public key to Scalingo.
- Run the following commands:
```sh
$ scalingo login
$ pip install dsd-scalingo
# Add django_simple_deploy to INSTALLED_APPS.
$ python manage.yp deploy --automate-all
```

Your deployed project should appear in a new browser tab.

Destroying a project
---

If you're doing a test deployment and want to destroy your project:

```sh
$ scalingo --app <app-name> destroy
```

Scalingo documentation
---

These have been the most helpful parts of the Scalingo docs so far:

- [Python on Scalingo](https://doc.scalingo.com/languages/python/start)
- [Get started with Django on Scalingo](https://doc.scalingo.com/languages/python/django/start#create-your-application-and-databases-on-scalingo)
- [CLI reference](https://doc.scalingo.com/tools/cli/features#run-custom-job)
- [Environment variables](https://doc.scalingo.com/platform/app/environment)
- [First steps/ SSH key setup](https://doc.scalingo.com/platform/getting-started/first-steps#ssh-key-setup)
- [Postgres on Scalingo](https://doc.scalingo.com/databases/postgresql/about/overview)
sequential-importance-sampling 0.1.1
Sequential importance sampling for contingency tables with fixed margins
Requires Python: >=3.9

# Sequential Importance Sampling for Contingency Tables

Numba-accelerated sequential importance sampling (SIS) for uniformly sampling **two-way** contingency tables with fixed row and column margins, following **Chen, Diaconis, Holmes, and Liu (2005, JASA)**.

## Installation

```bash
pip install sequential-importance-sampling
```

For development (editable install from source):

```bash
pip install -e .
```

## Usage

```python
import numpy as np
from sequential_importance_sampling import sample_tables

# Row and column margins from Chen et al. (2005)
row_sums = np.array([10, 62, 13, 11, 39])
col_sums = np.array([65, 25, 45])

# Draw 150,000 importance-weighted tables
tables, logq = sample_tables(row_sums, col_sums, num_samples=150_000, rng_seed=44042)

# Estimate the number of tables with these margins
# True value: 239,382,173 (Diaconis and Gangolli, 1995)
print("Estimate:", np.exp(-logq).mean())
```

**Batch dimensions** are supported for sampling many independent two-way tables in parallel. If `row_sums` has shape `(R, d1, d2, ...)` and `col_sums` has shape `(C, d1, d2, ...)`, each combination of batch indices defines an independent R×C table problem. The output `tables` will have shape `(num_samples, d1, d2, ..., R, C)` with batch dims before table dims for C-contiguous access. Note that this does **not** extend to multi-way (3+) contingency tables with additional margin constraints — each batch element is a separate two-way table.

## API

| Function | Description |
|---|---|
| `sample_tables` | Main entry point — sample batches of tables with arbitrary batch dimensions |
| `sample_table_sis` | Sample a single contingency table via column-wise SIS |

`sample_tables` returns `(tables, logq)` where `logq` contains the log importance weights. Pass `parallel=False` to disable numba parallelism.

## Tests

Run the Diaconis-Gangolli counting verification:

```bash
python tests/test_diaconis_gangolli.py
```

```
True count:               239,382,173
SIS estimate (n=150k):    239,413,201
Coefficient of variation: 0.9512
Effective sample size:    78,750
```

Run the Holmes-Jones example from the Chen et al. paper:

```bash
python tests/test_holmes_jones.py
```

```
Reference (Chen et al.):  3.383e16
SIS estimate (n=1M):     3.382e+16
log10 estimate:           16.5291
log10 reference:          16.5293
Coefficient of variation: 1.0537
Effective sample size:    473,875
```


## References

- Chen, Y., Diaconis, P., Holmes, S. P., & Liu, J. S. (2005). Sequential Monte Carlo methods for statistical analysis of tables. *Journal of the American Statistical Association*, 100(469), 109-120.
- Diaconis, P., & Gangolli, A. (1995). Rectangular arrays with fixed margins. In *Discrete Probability and Algorithms* (pp. 15-41). Springer.
benanalysis 4.1.3
Bentham Spectral Analysis and Calibration Utilities Library

benanalysis
===========

Bentham Instruments spectral analysis library.

Compatibility
-------------

Wheels are built for python versions 3.12 - 3.13, for these systems:

- Windows: win32, amd64
- Linux: x86, x86_64
- MacOS >10.9, universal2 (combined x86_64, arm64, requires pip version > 20.6 on intel, >21.0.1 on Apple Silicon)

Note: Apple silicon build has not been tested.

Installation
------------

`pip install benanalysis`

Building from source
--------------------

For local development (building the C++ core + the Python extension + docs), see:

- `BenAnalysis/src/benanalysis-python/README.md` in the repository.

Usage
-----

```python
import benanalysis as ba

# Create scans from (wavelength, value) data
scan1 = ba.Scan([400, 410, 420], [1.0, 2.0, 3.0])
scan2 = ba.Scan([405, 415], [10.0, 20.0])

# Arithmetic operators are supported (scan-scan and scan-scalar)
scaled = 2.0 * scan1 + 1.0

# The wavelength grid of Scan/Scan operations depends on interpolation:
# - If interpolation is disabled on both scans, results use only shared wavelengths.
# - If either scan is interpolated, results are evaluated on wavelengths in the overlap
#   region where both scans can be evaluated without extrapolation.
scan1.interpolation = ba.Interpolation.LINEAR
scan2.interpolation = ba.Interpolation.LINEAR
combined = scan1 + scan2

print(combined.wavelengths())
```