semvec/pypi-packages huggingface dataset:
vdfpy 0.1.2
Velocity distribution function classifier
Requires Python: >=3.11

# VDFPy

<p align="center">
  <a href="https://badge.fury.io/py/vdfpy">
    <img src="https://badge.fury.io/py/vdfpy.svg" alt="PyPI version" height="18">
  </a>
  <a href="https://github.com/henry2004y/vdfpy/actions">
    <img src="https://github.com/henry2004y/vdfpy/actions/workflows/CI.yml/badge.svg">
  </a>
  <a href="https://henry2004y.github.io/vdfpy/">
    <img src="https://img.shields.io/badge/docs-dev-blue">
  </a>
  <a href="LICENSE">
    <img src="https://img.shields.io/badge/license-MIT-blue">
  </a>
  <a href="https://app.codecov.io/gh/henry2004y/vdfpy/">
    <img src="https://img.shields.io/codecov/c/github/henry2004y/vdfpy">
  </a>
</p>

VDFPy is a velocity distribution function classifier in Python.

## Installation

```python
python -m pip install vdfpy
```

## Usage

We currently support extracting data from simulation (Vlasiator, FLEKS) and satellite observation (pyspedas).
Please refer to the [documentation](https://henry2004y.github.io/vdfpy/) for more details.

## License

`vdfpy` is licensed under the terms of the MIT license.
jz-rekor-verifier 0.1.1
Rekor transparency log verifier for inclusion and consistency proofs
Requires Python: >=3.10

# Description
This project provides a way to verify the Rekor transparency log, which records artifact signatures to provide tamper-proof evidence that something was signed at a specific time.

There are three main verfifcation operations that can be performed:
1. Checkpoint Retrieval (--checkpoint)
This fetches the latest state of the Rekor transparency log, including:
• Tree size (number of entries)
• Root hash (cryptographic commitment to all entries)
• Tree ID

2. Inclusion Proof Verification (--inclusion)
This proves that a specific artifact exists in the transparency log by:
• Fetching a log entry by index from Rekor
• Extracting the signature and certificate from the entry
• Verifying the artifact's digital signature using ECDSA with the public key
• Computing a Merkle tree inclusion proof to cryptographically prove the entry is in the log
• Checking if it's included in the latest checkpoint

3. Consistency Proof Verification (--consistency)
This proves that the transparency log hasn't been tampered with over time by:
• Comparing an older checkpoint with the current checkpoint
• Verifying the Merkle tree consistency proof ensures no entries were removed or modified

# Installation Steps
To sign artifacts and verify signatures using Sigstore, you need to install Cosign:
• Go to https://docs.sigstore.dev/cosign/system_config/installation/ for installation instructions appropriate to your system.

# Usage Instructions
1. Create an artifact:

For example, I can create an `artifact.md` file and type in "Hello World". Typical artifacts can be container images, software binaries, source code tarballs, package manifests, among other things. Though an artifact can be anything software-related that you want to verify the integrity of.

2. Using the cosign tool (check #Installation Steps for more info), sign the artifact via Terminal:
`cosign sign-blob <file-name> --bundle artifact.sigstore.bundle`

This will prompt you to verify your identity. And once your identity is verified, an ephemeral certificate is generated, artifact is signed and its signature is uploaded to transparency log.


# Necessary Dependencies

Just the cosign tool which is reference in #Installation Steps.
spiralplot 0.1.1
A spiral plot generator
Requires Python: >=3.8

# Spiral Plot

A Python package to create scatter plots where each point is represented by a spiral glyph. This is useful for visualizing a third dimension of data (magnitude, duration, etc.) as the complexity or size of a spiral at a specific 2D location. It also supports visualizing two values simultaneously using a dual-colored spiral.

## Installation

You can install this package locally using pip:

```bash
pip install .
```

Or directly from GitHub:

```bash
pip install git+https://github.com/bioinfoguru/spiralplot.git
```

## Usage

### Single Spiral Value

```python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from spiralplot import spiralplot

# Create sample data
n = 20
df = pd.DataFrame({
    'x_pos': np.random.rand(n) * 100,
    'y_pos': np.random.rand(n) * 100,
    'magnitude': np.random.rand(n) * 50 + 10 
})

plt.figure(figsize=(10, 10))
spiralplot(
    data=df,
    x='x_pos',
    y='y_pos',
    spiral='magnitude',
    cmap='magma',
    scale=0.5,
    dpt=15
)
plt.show()
```

### Dual Spiral Values

You can visualize two values at once. The total length of the spiral represents the sum of the values, and the spiral is split into two colors proportional to each value.

```python
df['magnitude2'] = np.random.rand(n) * 50 + 10

plt.figure(figsize=(10, 10))
spiralplot(
    data=df,
    x='x_pos',
    y='y_pos',
    spiral=['magnitude', 'magnitude2'], # Pass list of two columns
    spiral_colors=['blue', 'red'],      # Colors for each part
    scale=0.5
)
plt.show()
```

## API

### `spiralplot(data, x, y, spiral, ax=None, cmap='viridis', color=None, scale=1.0, spiral_scale=0.1, spiral_colors=None, dpt=10, **kwargs)`

- `data`: Input pandas DataFrame.
- `x`: Column name for x-axis position.
- `y`: Column name for y-axis position.
- `spiral`: Column name (str) or list of two column names (list of str).
    - If single string: Maps value to spiral length.
    - If list of two strings: Maps sum of values to length, splits spiral into two colors.
- `ax`: Optional matplotlib Axes.
- `cmap`: Colormap for the spirals. Ignored if `color` is provided or if `spiral` is a list.
- `color`: Single color to use for all spirals. Overrides `cmap`. Ignored if `spiral` is a list.
- `scale`: Global scaling factor for the size of the spirals relative to data coordinates.
- `spiral_scale`: Factor to control the size of individual dots within the spiral.
- `spiral_colors`: List of two colors (e.g. `['green', 'orange']`) to use when `spiral` is a list of two columns.
- `dpt`: Dots per turn. Specifies the number of dots in a turn of the helix. Defaults to 10.
- `**kwargs`: Additional arguments passed to `plt.scatter`.