semvec/pypi-packages huggingface dataset:
ashredis 1.2.5
Async Redis ORM for Python
Requires Python: >=3.8
Keywords: redis, orm, async, asyncio, hash

# ashredis - Redis Object Storage Library
[![PyPI version](https://img.shields.io/pypi/v/ashredis.svg)](https://pypi.org/project/ashredis/)
[![Python versions](https://img.shields.io/pypi/pyversions/ashredis.svg)](https://pypi.org/project/ashredis/)
## Overview
Python library for Redis object storage with async interface.
## Installation
```bash
pip install ashredis
```
## Basic Usage Example
```python
import asyncio
from dataclasses import dataclass
from typing import Optional
from ashredis import RedisObject, RedisParams, RecordBase, MISSING

# Define data model
@dataclass
class User(RecordBase):
    username: Optional[str] = MISSING
    email: Optional[str] = MISSING
    age: Optional[int] = MISSING

async def main():
    # Configure Redis connection
    redis_params = RedisParams(
        host="localhost",
        port=6379,
        password="",
        db=0
    )
    
    # Create RedisObject instance
    async with RedisObject(redis_params=redis_params) as redis_obj:
        # Create and save object
        user = User(
            username="test_user",
            email="user@example.com",
            age=30
        )
        
        # Save object to Redis
        await redis_obj.save(record=user, key="user_1")
        
        # Load object from Redis
        loaded_user = await redis_obj.load(record_type=User, key="user_1")
        print(f"Loaded user: {loaded_user.username}, {loaded_user.email}")
        
        # Update object
        loaded_user.age = 31
        await redis_obj.save(record=loaded_user, key="user_1")
        
        # Delete object
        await redis_obj.delete(record_type=User, key="user_1")

if __name__ == "__main__":
    asyncio.run(main())
```
pybigue 1.0.0
Sampling algorithm of network hyperbolic embeddings.
Requires Python: >=3.10
Keywords: mcmc, hyperbolic, embedding, networks

# BIGUE hyperbolic embedder

<img src="https://raw.githubusercontent.com/DynamicaLab/bigue/refs/heads/main/logo.png" style="float: right;" alt="isolated" width="200"/>

Bayesian Inference of a Graph's Unkown Embedding (BIGUE) is a Markov Chain Monte Carlo algorithm that samples the best hyperbolic embeddings of a given network according to a Bayesian $\mathbb{S}^1$ model.

The code used to generate the Figures in the paper is in the [bigue-analysis] repository.
If you use this algorithm, please cite:

[Simon Lizotte](https://siliz4.github.io), [Jean-Gabriel Young](https://jgyoung.ca) and [Antoine Allard](https://antoineallard.github.io)
"Symmetry-driven embedding of networks in hyperbolic space". _Commun. Phys._ __8__, 199 (2025).
https://doi.org/10.1038/s42005-025-02122-0

## Installation

### Dependencies

The pybigue library requires:

- Python (>= 3.10)
- NumPy
- SciPy
- CmdStanPy
- Numba


pybigue can be installed directly from [PyPi](https://pypi.org/)
```
pip install pybigue
```

## Usage

To use the default BIGUE sampler,
```{python}
from pybigue.sampling import sample_bigue, read_sample

# ... code that obtains an numpy adjacency matrix

sample_directory = "./sample/"
sample_bigue(adjacency_matrix, sample_directory) # Writes samples to disk
samples = read_sample(sample_directory) # Reads samples
```

Two complete examples are presented in the `examples`. The file `embed_synthetic_graph.py` uses the default BIGUE algorithm (requires also `matplotlib`) and the file `manual_sampling.py` shows how one can tweak the sampler (hyperparameter values, prior distributions, subkernel selection probabilities, combining with Stan HMC, etc.).

Note that the __samples are not aligned automatically__. This Python library doesn't provide a tool to compute automorphisms. This can be found in the [bigue-analysis] repository.
Nevertheless, the samples can be aligned given a list of automorphisms

```{python}
from pybigue.models import S1Model

# Each automorphism is an array of the new label of each vertex.
automorphisms = [np.arange(adjacency_matrix.shape[0])] # Trivial automorphism
aligned_samples = {
    chain: S1Model.align_sample(sample, reference_thetas=some_thetas, automorphisms=automorphisms)
        for chain, sample in samples.items()
}
```


## Source code

The lastest version can be fetched with
```
git clone https://github.com/DynamicaLab/bigue.git
```

## Testing

After downloding the code, the test suite can be ran using (requires installing `pytest`)
```{python}
pytest pybigue
```

[bigue-analysis]: https://github.com/DynamicaLab/bigue-analysis
venvpool 22
Run your Python scripts using an automated pool of virtual environments to satisfy their requirements

# venvpool
Run your Python scripts using an automated pool of virtual environments to satisfy their requirements.

This README is auto-generated, see [project wiki](https://wikiwheel.net/s/foyono/w/venvpool) for details.

## Commands

### motivate
Create and maintain wrapper scripts in ~/.local/bin for all runnable modules in the given projects, or the current project if none given.

## API

<a id="venvpool"></a>

### venvpool

<a id="venvpool.dotpy"></a>

###### dotpy

Python source file extension including dot.

<a id="venvpool.initlogging"></a>

###### initlogging

```python
def initlogging()
```

Initialise the logging module to send debug (and higher levels) to stderr.

<a id="venvpool.util"></a>

### venvpool.util

<a id="venvpool.util.detach"></a>

###### detach

```python
def detach()
```

For all venvs (typically just one) that this process has locked for reading, set those locks to non-inheritable.
Return a copy of os.environ in which PATH does not include the bin directories of those venvs.
Then passing that environment to a subprocess will launch it free of any venvpool venv.
MSIght 1.0.24
MSIght is an open-source Python-based algorithm designed for proteome characterization from the automated integration of histology, LC-MS/MS, and MSI datasets.
Requires Python: >=3.8

[![Documentation Status](https://readthedocs.org/projects/msight-100/badge/?version=latest)](https://msight-100.readthedocs.io/en/latest/?badge=latest)
![Unit Tests](https://github.com/laurenfields/MSIght_1.0.0/actions/workflows/ci.yml/badge.svg)
[![PyPI version](https://badge.fury.io/py/msight.svg?cache-bust=1)](https://pypi.org/project/msight/)

<div align="center">
<img src="https://github.com/laurenfields/MSIght/blob/main/MSIght_logo.png">
</div>

# MSIght

MSIght is a program produced by the Lingjun Li Lab at the University of Wisconsin-Madison for automated integration of H&E, MSI, and LC-MS/MS datasets

#### Getting started
* [User manual](https://docs.google.com/document/d/e/2PACX-1vRg7HEovZCDG1IdLaVpfKdxXk9n3LBGevGVzZj9DhtYL69CmZ8VAwbSIM4Tm7bsCUkNBI8ixcHTqp6f/pub)
* [Documentation](https://msight-100.readthedocs.io/en/latest/)
* [Video tutorial](https://drive.google.com/file/d/1caKp6fv9s_aWqJw8W0Bl-qT7vrga0kWd/view?usp=sharing)

## Installation

You can install MSIght directly from [PyPI](https://pypi.org/project/msight/):

```
pip install msight
```

### How to Cite
Fields, L.; Miles, H. N.; Adrian, A. E.; Patrenets, E.; Ricke, W. A.; Li, L. (2025). MSIght: A Modular Platform for Improved Confidence in Global, Untargeted Mass Spectrometry Imaging Annotation. J. Proteome Res. https://doi.org/10.1021/acs.jproteome.4c01140

#### Major release notes
##### Version 0.0.1 (Released 9/17/2024)
* Initial release
dmodkit 1.0
Lightweight Discord moderation toolkit for discord.py bots
Requires Python: >=3.8

# dmodkit

[![PyPI version](https://img.shields.io/pypi/v/dmodkit)](https://pypi.org/project/dmodkit/)
[![Python version](https://img.shields.io/pypi/pyversions/dmodkit)](https://pypi.org/project/dmodkit/)
[![License](https://img.shields.io/github/license/mochathehuman/dmodkit)](https://github.com/mochathehuman/dmodkit/blob/main/LICENSE)

**dmodkit** is a fast, no-fluff Discord moderation toolkit for `discord.py` bots. Plug it in, load commands, and go.


## Install:
```bash
pip install dmodkit
```

## Features

- Slash commands for:
  - Kick / Ban
  - Warns & Strikes (auto-kick on 3rd)
  - Timeout Mute / Unmute
  - Message Purge
  - Channel Lock / Unlock
  - Slowmode control
  - Nickname changes
  - Snipe (last deleted message)
- Command logging
- Warning history saved to `warnings.log`

> [!IMPORTANT]
>
> This project requires the following packages:
>
> - [`discord.py`](https://pypi.org/project/discord.py/) (v2.0.0 or higher)
> - [`loggingutil`](https://github.com/mochathehuman/loggingutil) (v1.2.2 or higher)
>
> Install them using:
>
> `pip install discord.py loggingutil==1.2.2`

## Quickstart

```
import discord
from discord.ext import commands
from discord import app_commands
from dmodkit import Modkit

client = discord.Client(intents=discord.Intents.all())
tree = app_commands.CommandTree(client)

modkit = Modkit(client, tree)
modkit.load_all()

@client.event
async def on_ready():
    await tree.sync()
    print(f"Logged in as {client.user}")

client.run("YOUR_TOKEN")
```

## Logs

- Warnings: `warnings.log`
- Commands: `modkit.log`
- Supports buffering, compression, and rotation

## Planned

- Context menu moderation
- AutoMod keyword filters
- Persistent user notes

## Permissions

Ensure your bot has:

- Kick Members
- Ban Members
- Moderate Members
- Manage Messages
- Manage Nicknames
- Manage Channels