semvec/pypi-packages huggingface dataset:
ruid 0.1.2
Reasonably unique and readable identifier generator
Requires Python: <4.0,>=3.8

# Description

Generates reasonably unique (slim chance of duplicates) and readable (avoids characters that look similar) fixed width string identifiers. These identifiers are useful as API tokens, database record identifiers (primary keys, etc) among other things.

## Installation

```shell
pip install ruid
```

or

```shell
poetry add ruid
```

## Length considerations

- The function uses current date and time to determine part of the random string. This has the advantage of ensuring fewer collisions at different timestamps but also means that a length of 6 would result in same token generated within the same second.
- A reasonable default length of 10 ensures more than 6 million tokens per second.
- Length of 7 or less discards the datetime logic and just generates a random token.
stanford-stk 0.7.1
Sparse Toolkit

# :abacus: Sparse Toolkit

A light-weight PyTorch library for block-sparse matrices and block-sparse matrix multiplication.

STK is built around a core sparse matrix class ([stk.Matrix](stk/matrix.py)), which uses a hybrid [blocked-CSR-COO](https://arxiv.org/abs/2211.15841) sparse matrix encoding to enable efficient matrix products with sparse inputs and outputs in transposed or non-transposed order. The library supports the following operations:

```
op: transpose or non-transpose

[Sparse Matrix Multiplication]
stk.ops.dsd: dense = op(sparse) x op(dense)
stk.ops.dds: dense = op(dense) x op(sparse)
stk.ops.sdd: sparse = op(dense) x op(dense)

[Sparse Matrix Conversion]
stk.ops.to_sparse: torch.Tensor => stk.Matrix
stk.ops.to_dense: stk.Matrix => torch.Tensor

[Sparse Matrix Generation]
stk.random.dense_mask: Create a random, block-sparse dense matrix.
stk.random.mask: Create a random, block-sparse sparse matrix.
```

STK is designed for applications where the sparse matrices change rapidly. This is complementary to libraries like [triton-blocksparse](https://github.com/ptillet/torch-blocksparse), which assume that sparse matrix topologies do not change between invocations.

# :rocket: Performance

![STK Performance](media/block_sparse_matmul_benchmarks.png)

Block-sparse matrix multiplication with STK is able to match the performance of cuBLAS on a range of problems. On these benchmarks from [MegaBlocks](https://github.com/stanford-futuredata/megablocks) dMoE models, STK realizes **98.6%** of cuBLAS throughput with `128x128` blocks on average.

```
Hardware: A100-SXM4-80GB
Software: CUDA 11.5, CUTLASS 2.5
```

# :building_construction: Installation

NOTE: This assumes that you have `torch` and `numpy` installed.

`pip install stanford-stk`

# :writing_hand: Citation

```
@article{megablocks-arxiv,
  author    = {Trevor Gale and Deepak Narayanan and Cliff Young and Matei Zaharia},
  title     = {MegaBlocks: Efficient Sparse Training with Mixture-of-Experts},
  journal   = {CoRR},
  volume    = {abs/2211.15841},
  year      = {2022},
}
```
webpic 0.1.3
Automate screenshot taking
Requires Python: >=3.12

# Webpic

Webpic fixes the issue of having to open ports on develepment websites to show the website to your friends.

## Installation

Install via pip:
```bash
pip install webpic      
```

## Usage

Usage: webpic [OPTIONS] HOSTNAME SAVEPATH [URLS]...

Options:
  -f, --file PATH  File containing URLs separated by newlines.

### Examples

Let's say you have a django development server in your local machine with 2 urls: /home and /help and you want to save them in "screenshots"

```bash
webpic http://127.0.0.1:8000 ./screenshots home help
```

Or, if you have a long list of urls, put them in a file with the urls separated by new lines and run

```bash
webpic -f urls.txt http://127.0.0.1:8000 ./screenshots 
```
mcclient-lib 0.0.1
A lightweight Minecraft client for querying the status data of a Minecraft server.
Requires Python: >=3.7

# mcclient-lib

[![Downloads](https://static.pepy.tech/badge/mcclient-lib)](https://pepy.tech/project/mcclient-lib)
[![PyPI](https://img.shields.io/pypi/v/mcclient-lib?color=green&label=PyPI%20package)](https://pypi.org/project/mcclient-lib/)

A lightweight Minecraft client for querying the status data of a Minecraft server.

## Supported Minecraft versions

* Minecraft Java (v1.4.0 and later)
* Minecraft Bedrock

## Supported protocols

* [Server List Ping](https://wiki.vg/Server_List_Ping) for Minecraft Java servers
* [Legacy Server List Ping](https://wiki.vg/Server_List_Ping#1.4_to_1.5) for Minecraft Java servers before 1.4
* [Query Protocol](https://wiki.vg/Query) for Minecraft Java servers (needs to be enabled on the server)
* [Bedrock Server List Ping](https://wiki.vg/Raknet_Protocol#Unconnected_Ping) for Minecraft Bedrock servers

## Installation

```bash
pip install mcclient-lib
```

## Usage

### Server List Ping

```python
from mcclient import SLPClient

# for Minecraft Java servers from version 1.7 and later
slp_client = SLPClient("mc.example.com")
res = slp_client.get_status()
 ```

### Query

```python
from mcclient import QueryClient

# for Minecraft Java servers (needs to be enabled on the server)
query_client = QueryClient("mc.example.com")
res = query_client.get_status()
```

### Bedrock Server List Ping

```python
from mcclient import BedrockSLPClient

# for Minecraft Bedrock servers
bedrock_slp_client = BedrockSLPClient("mc.example.com")
res = bedrock_slp_client.get_status()
```

### Response

```python
print(f"motd: {res.motd}")

print(f"online players: {res.players.online}")
print(f"max players: {res.players.max}")
print(f"players list: {res.players.list}")

print(f"version: {res.version.name}")
print(f"protocol version: {res.version.protocol}")

print(f"host: {res.host}")
print(f"port: {res.port}")
print(f"timestamp: {res.timestamp}")
print(f"favicon: {res.favicon is not None}")

# only for query and Bedrock responses
print(f"gametype: {res.gametype}")
print(f"map: {res.map}")

# only for query responses
print(f"plugins: {res.plugins}")
print(f"host ip: {res.hostip}")
print(f"host port: {res.hostport}")

# only for bedrock responses
print(f"server id: {res.server_id}")
```

Note that not every field is queryable with every protocol.