semvec/pypi-packages huggingface dataset:
myerson 0.1.8
A python package to calculate Myerson values from game theory and use them as explanations for graph neural networks.
Requires Python: >=3.8

![Myerson logo banner](docs/source/images/logo_banner_embedded.svg "Myerson")

[![test](https://github.com/kochgroup/myerson/actions/workflows/test.yml/badge.svg)](https://github.com/kochgroup/myerson/actions/workflows/test.yml)
[![Documentation Status](https://readthedocs.org/projects/myerson/badge/?version=latest)](https://myerson.readthedocs.io/en/latest/?badge=latest)

# Calculate Myerson values and explain GNNs

This package implements the Myerson solution concept from cooperative game theory. The Myerson values attribute every player of a game their fair contribution to the games payoff. Myerson values are related to Shapley values but the player cooperation is restricted by a graph.

A graph neural network (GNN) can be treated as a coalition function for a game and the Myerson values can be used as feature attribution explanations to understand a model prediction. This package also implements Methods to explain PyG GNNs with Myerson values.

Calculating the Myerson value scales exponentially with bigger graphs / more players. Therfore, Monte Carlo sampling techniques were implemented to approximate the Myerson values.

## Installation
Install the package with the following command:

```bash
pip install myerson
```

## Examples and Documentation
Example uses can be found [here](https://myerson.readthedocs.io/en/latest/get_started.html#get-started). The full documentation can be found at https://myerson.readthedocs.io/.

## Citation

TBD.
logginglib 0.1.1
Evvve Platform Logging Lib
Requires Python: <4.0,>=3.10

# Publishing LoggingLib with Poetry

This guide will walk you through the steps to publish your Python package using Poetry. Poetry is a dependency management and packaging tool for Python projects. 

## Prerequisites

1. **Poetry Installed**: Make sure Poetry is installed on your system. You can install it by following the instructions on the [Poetry official website](https://python-poetry.org/docs/#installation).

2. **PyPI Account**: Ensure you have an account on [PyPI](https://pypi.org/). You'll need your username and password for publishing.

## Steps to Publish a Python Package

### 1. Build Your Package

Navigate to your project directory and run the following command to build your package:

```sh
poetry build
```

This command will generate distribution archives (e.g., `.whl` and `.tar.gz` files) in the `dist` directory.

### 2. Publish Your Package

To publish your package to PyPI, use the following command:

```sh
poetry publish --username <your-username> --password <your-password>
```

Alternatively, you can use the `--build` option to build and publish your package in one step:

```sh
poetry publish --build --username <your-username> --password <your-password>
```

### 3. Using PyPI Token

For better security, you can use an API token instead of your username and password. First, generate an API token from your [PyPI account settings](https://pypi.org/manage/account/#api-tokens).

Then, you can publish your package using the token:

```sh
poetry publish --build --username __token__ --password <your-token>
```

### 4. Publishing to TestPyPI (Optional)

Before publishing to the official PyPI repository, you might want to publish to TestPyPI to test your package. 

To publish to TestPyPI, use the following command:

```sh
poetry publish --build --repository testpypi --username <your-username> --password <your-password>
```

To use an API token with TestPyPI:

```sh
poetry publish --build --repository testpypi --username __token__ --password <your-token>
```
omicfate 0.0.1
OmicFate: Unraveling the Secrets of Cellular Fate Determination
Requires Python: >=3.8
Keywords: bioinformatics, deep-learning, scRNA-seq, RNA-seq

<h1 align="center">
<img src="https://raw.githubusercontent.com/Starlitnightly/cellfate/master/assets/logo.png" width="400">
</h1><br>

[![pypi-badge](https://img.shields.io/pypi/v/omicverse)](https://pypi.org/project/omicverse) [![Documentation Status](https://readthedocs.org/projects/omicverse/badge/?version=latest)](https://omicverse.readthedocs.io/en/latest/?badge=latest) [![pypiDownloads](https://static.pepy.tech/badge/omicfate)](https://pepy.tech/project/omicverse) [![condaDownloads](https://img.shields.io/conda/dn/conda-forge/omicverse?logo=Anaconda)](https://anaconda.org/conda-forge/omicverse) [![License:GPL](https://img.shields.io/badge/license-GNU-blue)](https://img.shields.io/apm/l/vim-mode)

**`OmicVerse`** is the fundamental package for multi omics included **bulk ,single cell and spatial RNA-seq** analysis with Python. For more information, please read our paper: [OmicVerse: a framework for bridging and deepening insights across bulk and single-cell sequencing](https://www.nature.com/articles/s41467-024-50194-3)
polars-pairing 0.1.0
Polars plugin with pairing functions for nonnegative integers
Requires Python: >=3.8

# polars-pairing

This plugin provides pairing functions to Polars. These functions encode two natural numbers into a single natural number.

## Installation

```bash
pip install polars-pairing
```

## Functionality and usage

This plugin implements three pairing functions (Hagen[^1], Szudzik[^2], and Cantor[^3]), along with their corresponding unpairing functions, as Polars expressions. The pairing functions take two integer columns as input and produce a single column containing the encoded pair. Conversely, the unpairing functions accept a single column as input and generate a struct column containing the values of the original pair.

```python
>>> import polars as pl
>>> import polars_pairing as plp

>>> df = pl.DataFrame({
...     "a": [1, 2, 38, 4],
...     "b": [5, 6, 77, 80]
... })
>>> df.select(plp.col("b").pairing.pair(plp.col("b")).alias("pair"))
shape: (4, 1)
┌──────┐
│ pair │
│ ---  │
│ u64  │
╞══════╡
│ 35   │
│ 48   │
│ 6083 │
│ 6560 │
└──────┘

# By default, the Hagen pairing function is used, but you can specify alternative functions:
>>> df.select(
...     plp.col("a").pairing.pair(plp.col("b"), method="hagen").alias("hagen_pair"),
...     plp.col("a").pairing.pair(plp.col("b"), method="szudzik").alias("szudzik_pair"),
...     plp.col("a").pairing.pair(plp.col("b"), method="cantor").alias("cantor_pair")
)
shape: (4, 3)
┌────────────┬──────────────┬─────────────┐
│ hagen_pair ┆ szudzik_pair ┆ cantor_pair │
│ ---        ┆ ---          ┆ ---         │
│ u64        ┆ u64          ┆ u64         │
╞════════════╪══════════════╪═════════════╡
│ 28         ┆ 26           ┆ 26          │
│ 40         ┆ 38           ┆ 42          │
│ 6006       ┆ 5967         ┆ 6747        │
│ 6408       ┆ 6404         ┆ 3650        │
└────────────┴──────────────┴─────────────┘

# The corresponding unpairing functions are also available:
>>> df = pl.DataFrame({"p": [28, 40, 6006, 6408]})
>>> df.select(plp.col("p").pairing.unpair().alias("unpair"))
shape: (4, 1)
┌───────────┐
│ unpair    │
│ ---       │
│ struct[2] │
╞═══════════╡
│ {1,5}     │
│ {2,6}     │
│ {38,77}   │
│ {4,80}    │
└───────────┘

>>> df = pl.DataFrame({"p": [26, 38, 5967, 6404]})
>>> df.select(
...     plp.col("p").pairing.unpair(method="szudzik").alias("unpair")
... ).unnest("unpair")
shape: (4, 2)
┌──────┬───────┐
│ Left ┆ Right │
│ ---  ┆ ---   │
│ u64  ┆ u64   │
╞══════╪═══════╡
│ 1    ┆ 5     │
│ 2    ┆ 6     │
│ 38   ┆ 77    │
│ 4    ┆ 80    │
└──────┴───────┘
```

[^1]: Hagen, D. R. Superior Pairing Function. <https://drhagen.com/blog/superior-pairing-function/> (2018).
[^2]: Szudzik, Matthew. "An elegant pairing function." *Wolfram Research (ed.) Special NKS 2006 Wolfram Science Conference*. 2006.
[^3]: Cantor, G. Ein Beitrag zur Mannigfaltigkeitslehre. *Journal für die reine und angewandte Mathematik* **1878**, 242–258 (1878).