semvec/pypi-packages huggingface dataset:
pyxla 0.0.4
A flexible and generic framework for explainable landscape analysis.
Requires Python: >=3.8
Keywords: Explainable landscape analysis, Landscape analysis

# pyXla

A flexible and generic framework for explainable landscape analysis.

### Install required packages (i.e pytest, sphinx)
Navigate to the `src/` directory and then run:

```
$ pip install -r requirements.txt
```
### How to run tests
Navigate to the `src/` directory and then run:

```
$ pytest
```

Some tests will fail, but only the first time. Re-run it again to get all tests to pass.

### How build docs
Navigate to the `docs/` directory and then run:

```
$ make clean html
```

It might take a while. The built docs will be saved in `docs/build/` directory
toml-rs 0.3.3
A High-Performance TOML Parser for Python written in Rust
Requires Python: >=3.10

<div align="center">

# toml-rs

*A High-Performance TOML v1.0.0 and v1.1.0 parser for Python written in Rust*

[![PyPI License](https://img.shields.io/pypi/l/toml_rs.svg?style=flat-square)](https://pypi.org/project/toml_rs/)

[![Monthly downloads](https://img.shields.io/pypi/dm/toml_rs.svg?style=flat-square)](https://pypi.org/project/toml_rs/)
[![Github Repository size](https://img.shields.io/github/repo-size/lava-sh/toml-rs?style=flat-square)](https://github.com/lava-sh/toml-rs)

[![Python version](https://img.shields.io/pypi/pyversions/toml_rs.svg?style=flat-square)](https://pypi.org/project/toml_rs/)
[![Implementation](https://img.shields.io/pypi/implementation/toml_rs.svg?style=flat-square)](https://pypi.org/project/toml_rs/)

</div>

## Features

* The fastest TOML parser in Python (see [benchmarks](https://github.com/lava-sh/toml-rs/tree/main/benchmark))

* Drop-in compatibility with most [`tomllib`](https://docs.python.org/3/library/tomllib.html) use cases (see [below](#differences-with-tomllib))

## Installation

```bash
# Using pip
pip install toml-rs

# Using uv
uv pip install toml-rs
```

## Examples

```python
import tomllib
from pprint import pprint

import toml_rs

toml = """\
title = "TOML Example"

[owner]
name = "Tom Preston-Werner"
dob = 1979-05-27T07:32:00-08:00

[database]
enabled = true
ports = [ 8000, 8001, 8002 ]
data = [ ["delta", "phi"], [3.14] ]
temp_targets = { cpu = 79.5, case = 72.0 }

[servers]
[servers.alpha]
ip = "10.0.0.1"
role = "frontend"
[servers.beta]
ip = "10.0.0.2"
role = "backend"
"""

tomllib_loads = tomllib.loads(toml)
toml_rs_loads = toml_rs.loads(toml)
toml_rs_dumps = toml_rs.dumps(toml_rs_loads)

assert tomllib_loads == toml_rs_loads

print("toml_rs.loads:")
pprint(toml_rs_loads)
print("toml_rs.dumps:")
print(toml_rs_dumps)
```

## Differences with [`tomllib`](https://docs.python.org/3/library/tomllib.html)

1. More understandable errors

```python
import tomllib

t = """\
x = 1
y = 2
v = 
"""
print(tomllib.loads(t))
# tomllib.TOMLDecodeError: Invalid value (at line 3, column 5)
```

```python
import toml_rs

t = """\
x = 1
y = 2
v = 
"""
print(toml_rs.loads(t))
# toml_rs.TOMLDecodeError: TOML parse error at line 3, column 5
#   |
# 3 | v = 
#   |     ^
# string values must be quoted, expected literal string
```

2. Supports serialization (`toml_rs.dumps` and `toml_rs.dump`)

```python
from pathlib import Path

import toml_rs

data = {
    "title": "TOML Example",
    "owner": {"name": "Alice", "age": 30},
}

print(toml_rs.dumps(data))

toml_rs.dump(data, Path("example.toml"))  
# or `toml_rs.dump(data, "example.toml")`
```
linkage2df 1.0.0
Convert SciPy linkage matrices to plot-ready DataFrames — used for ggplot/Plotnine dendrograms.
Requires Python: >=3.11

# linkage2df

### Easily plot SciPy dendrograms using the Grammar of Graphics in Python

`linkage2df` is a  tool that converts SciPy linkage matrices (typically used for hierarchical clustering) into tidy DataFrames. By transforming the dendrogram tree into a set of segments with (x, y) coordinates, you can leverage the full power of **Plotnine** (or any `ggplot2` clone) to create highly customizable dendrograms.

![Penguin Dendrogram](dendrogram_penguins.png)


## Features

* **Tidy Data Output**: Converts hierarchical trees into a simple DataFrame of segments with `x_start`, `y_start`, `x_end`, and `y_end` columns.
* **Cluster Propagation**: Automatically assigns clusters to higher-level branches based on their children, allowing for intuitive coloring of the tree.
* **Plotnine Ready**: Designed specifically to work with `geom_segment()` in the Grammar of Graphics.

---

## Installation

You can install the package directly from your local directory:

```bash
pip install .
```

## Quick start
```
import numpy as np
import pandas as pd
from scipy.cluster.hierarchy import linkage, fcluster
from plotnine import ggplot, aes, geom_segment, theme_minimal
from linkage2df import linkage_to_segments

# 1. Generate some dummy data
np.random.seed(42)
X = np.random.rand(15, 4)

# 2. Compute linkage matrix & clusters
linkage_matrix = linkage(X, method="ward")
clusters = fcluster(linkage_matrix, t=0.7, criterion='distance')

# 3. Convert linkage matrix to a tidy segments DataFrame
df = linkage_to_segments(linkage_matrix, clusters=clusters)

# 4. Plot using Plotnine
p = (
    ggplot(df) +
    geom_segment(aes(x='x_start', y='y_start', xend='x_end', yend='y_end'), size=0.75) +
    theme_minimal()
)

print(p)
```
Biosig 3.9.3
BioSig - tools for biomedical signal processing
Keywords: EEG, ECG, EKG, EMG, EOG, Polysomnography, ECoG, biomedical signals, SCP, EDF, GDF, HEKA, CFS, ABF

# Biosig Package

Biosig is a toolbox for processing biomedical signals
like ECG, EEG etc. It can read about 50 different
data formats including EDF, GDF, BDF, CFS, Heka, ABF,
HL7aECG, SCP (EN1064), BrainVision, and many more.
The heavy lifting is done in "libbbiosig"
the biosig library implemented in C/C++. The
Python module of Biosig provides an interface between
libbiosig and Python. Currently, two functions are
provided, one for reading the data samples, and one
for extracting the meta information, like event
table, scaling factors, sampling rates, etc.


More information is available at
- [Biosig project homepage](https://biosig.sourceforge.io)
- [Biosig wiki page](https://sourceforge.net/p/biosig/wiki/Home/)

# Installation:
## GNU/Linux (Debian, Ubuntu, and family)
```
  sudo apt install python3-biosig
```
or if you want to install in your own venv
```
  sudo apt install libbiosig-dev  # make sure that libbiosig and its prerequisites are in place
  pip install biosig
```

## MacOSX/Homebrew
```
  brew install biosig             # make sure libbiosig is in place.
  pip install biosig
```

## MS-Windows (Python >=3.9,<=3.14)
```
  pip install biosig
```

## Other *NIX (Linux, Unix) OS

- install libbiosig from source (`configure && make && make install`)
- `pip install biosig`

# Usage
```
  import biosig
  import json
```
## read header/metainformation
```
  HDR=json.loads(biosig.header(FILENAME))
```
## read data
```
  DATA=biosig.data(FILENAME)
```

## A more elaborate example is this [demo](https://sourceforge.net/p/biosig/code/ci/master/tree/biosig4c++/python/demo2.py "demo2.py")

showing
- how to load data
- displaying the traces with matplotlib
- splitting the traces into sweeps



# History
In the past there were several attempts
of providing Python support. A first attempt
using pure python should to be very slow and a
lot of implementation effort, only some early
version of GDF has been supported.
Later, Swig was used for providing a python binding.
This was reasonable flexible, and the libbiosig
implementation could be mostly used. Disadvantages
were the effort to maintain swig.i interface file,
which is currently most likely broken. Known issues
are string support, lack of Python3 support. Also this
attempt is considered deprecated.

The third attempt is using "module extensions".
Currently, two functions, one for reading the header
information (in JSON format) and one for reading the
data samples is provided.
swh.vault 2.1.0
Software Heritage vault
Requires Python: >=3.10

Software Heritage - Vault
=========================

User-facing service that allows to retrieve parts of the archive as
self-contained bundles (e.g., individual releases, entire repository snapshots,
etc.)
The creation of a bundle is called "cooking" a bundle.

Architecture
------------

The vault is made of two main parts:

1. a stateful RPC server called the **backend**
2. Celery tasks, called **cookers**
openfeature-hooks-opentelemetry 0.3.1
OpenTelemetry hooks for the OpenFeature Python SDK
Requires Python: >=3.9


# OpenTelemetry Hook

The OpenTelemetry tracing hook for OpenFeature provides a [spec compliant][otel-spec] way to automatically add a feature flag evaluation to a span as a span event. Since feature flags are dynamic and affect runtime behavior, it’s important to collect relevant feature flag telemetry signals. This can be used to determine the impact a feature has on a request, enabling enhanced observability use cases, such as A/B testing or progressive feature releases.

## Installation

```
pip install openfeature-hooks-opentelemetry
```


## Usage

OpenFeature provides various ways to register hooks. The location that a hook is registered affects when the hook is run. It's recommended to register the `TracingHook` globally in most situations but it's possible to only enable the hook on specific clients. You should **never** register the `TracingHook` globally and on a client.

More information on hooks can be found in the [OpenFeature documentation][hook-concept].

### Register Globally

The `TracingHook` can be set globally. This will ensure that every flag evaluation will always create a span event, if an active span is available.

```python
from openfeature import api
from openfeature.contrib.hook.opentelemetry import TracingHook

api.add_hooks([TracingHook()])
```

### Register Per Client

The `TracingHook` can also be set on an individual client. This should only be done if it wasn't set globally and other clients shouldn't use this hook. Setting the hook on the client will ensure that every flag evaluation performed by this client will always create a span event, if an active span is available.

```python
from openfeature import api
from openfeature.contrib.hook.opentelemetry import TracingHook

client = api.get_client("my-app")
client.add_hooks([TracingHook()])
```

## License

Apache 2.0 - See [LICENSE](./LICENSE) for more information.


[otel-spec]: https://opentelemetry.io/docs/reference/specification/trace/semantic_conventions/feature-flags/
[hook-concept]: https://openfeature.dev/docs/reference/concepts/hooks