semvec/pypi-packages huggingface dataset:
pyg-rnnconv 0.1.0
RNNConv module for PyTorch Geometric
Requires Python: >=3.8

# pyg-rnn

A PyTorch Geometric RNN-based Convolution layer for temporal graph processing.

## Installation

```bash
pip install pyg-rnn
```
## Example usage
```python
from pyg_rnn import RNNConv
import torch
from torch_geometric.data import Data

conv = RNNConv(torch.nn.GRU, edge_index=edge_index, event_time=event_time, in_channels=16, hidden_channels=32)

x = torch.randn((num_events, 16))
output = conv(x)
print(output.shape)
```

## Why pyg-rnn
This Module allows creation of RNN layers within a PyG model without going through a padded tensor.
Creating a padded tensor can be very prohibitive for a dataset with big lead and long tail For example, it you have 1 million groups of events, where most groups have 3-5 events (long take), but some have about 1000, you will need to create a padded tensor $1000000*1,000*n$, where $n$ is the number of properties within each event. That can be 100 times more space than needed
megarnucleusx 0.0.5.0
Una IA modular de alto nivel con bots pre-configurados, impulsada por sminitorch y micronumpy.
Requires Python: >=3.6

# Megalitex

Versión 0.0.2.2 - Sistema de IA modular básico y extensible

## Características
- Anti-glitch en entrenamiento.
- Simulación de NLTK sin instalar dependencias.
- Tokenización y procesamiento básico de texto.
- Chatbot sencillo con respuestas prediseñadas.
- Entrenamiento de mini neuronas artificiales.
- Soporte para crear tus propias mini IAs (SubAI).

## Instalación
```bash
pip install megalitex
micronumpy 0.1.2
Una implementación ligera y pura en Python de la API de NumPy para proyectos sin dependencias pesadas.
Requires Python: >=3.6

# micronumpy

`micronumpy` es una reimplementación ultraligera y pura en Python de las funcionalidades más esenciales de la API de NumPy. Está diseñada para entornos donde las dependencias pesadas como el NumPy completo no son una opción, como dispositivos con recursos limitados o para proyectos que buscan la máxima portabilidad.

## Características Principales

- Objeto `ndarray` para cálculo numérico.
- Operaciones vectorizadas (`+`, `-`, `*`).
- Multiplicación de matrices con el operador `@`.
- Creación de arrays (`zeros`, `array`).
- Cero dependencias externas.

## Instalación

```bash
pip install .
sminitorch 0.1.0
Un framework de deep learning minimalista, con tensores y autograd, que utiliza micronumpy como backend.
Requires Python: >=3.6

# sminitorch

`sminitorch` (Small/Mini Torch) es un framework de deep learning educativo y minimalista inspirado en PyTorch. Proporciona Tensores con diferenciación automática (autograd) y componentes básicos para construir redes neuronales.

Utiliza `micronumpy` como su backend para las operaciones numéricas, manteniendo todo el ecosistema en Python puro.

## Características

- `sminitorch.Tensor`: un contenedor para `micronumpy.ndarray` con autograd.
- `sminitorch.nn`: Módulos para construir redes (`Linear`, `ReLU`, `Tanh`).
- `sminitorch.optim`: Optimizadores como `SGD`.
typing-unknown 0.1.2
Defines Unknown type for Python
Requires Python: >=3.12

# typing-unknown

[![PyPI](https://img.shields.io/pypi/v/typing-unknown)](https://pypi.org/project/typing-unknown/)
[![Tests](https://github.com/ryayoung/typing-unknown/actions/workflows/tests.yml/badge.svg)](https://github.com/ryayoung/typing-unknown/actions/workflows/tests.yml)
[![codecov](https://codecov.io/gh/ryayoung/typing-unknown/branch/main/graph/badge.svg)](https://codecov.io/gh/ryayoung/typing-unknown)
[![License](https://img.shields.io/github/license/ryayoung/typing-unknown)](https://github.com/ryayoung/typing-unknown/blob/main/LICENSE)
[![Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Pyright](https://img.shields.io/badge/type%20checker-pyright-blue)](https://github.com/microsoft/pyright)

**`Unknown`: The missing member of Python's `typing` module**

```
pip install typing-unknown
```

Use `Unknown` as a drop-in *(but more strict)* replacement for `object` in
type hints.

```python
from typing_unknown import Unknown

def handle_thing(obj: Unknown):
    # Caller may pass any value, but we're limited in how we can use it.
```

### Why `Unknown`?

Historically, `object` has served the implicit role of "Unknown" in type hints,
preferred over `typing.Any` when you wish to *limit* how a value may be used
before checking its type.

But, `object` isn't as strict as you'd think. For example, static type checkers
consider the following code **valid** (no type issues):

```python
def handle_unknown_thing(obj: object | MyType, *args: float):
    if obj:
        obj_class = type(obj)
        instance = obj_class(*args)
```

But, **this code could be invalid**. In multiple ways. _Even if_ `obj` were of a valid,
compatible subtype of `object`, with no hidden or unusual behavior.

> [!TIP]
> If something is `object`, type checkers assume:
> 
> 1. Its constructor accepts any `*args`, or any `**kwargs`, both, or no
>    arguments at all.
> 2. Its provided-by-default-but-overridable "magic" signatures - like `__bool__` - are
>    unchanged.

To static type checkers, `Unknown` more accurately reflects what can
and cannot be done with an arbitrary, valid `object`.

Same code, after swapping `object` for `Unknown`:

```python
def handle_unknown_thing(obj: Unknown | MyType, *args: float):
    if obj: # PYRIGHT ERROR: Invalid conditional operand
        obj_class = type(obj)
        instance = obj_class(*args) # PYRIGHT ERROR: reportArgumentType
```

Perfect. This forces us to *safely* narrow the type of `obj`
(or explicitly suppress the issues):

```python
# Pyright errors are gone. Code is "safe" now.

def handle_unknown_thing(obj: Unknown | MyType, *args: float):
    if obj is not None and isinstance(obj, MyType):
        obj_class = type(obj)
        instance = obj_class(*args)
```
pybridge-mrt 1.3.0
A library for sharing data between python scripts


THIS LIBRARY IS FOR SHARING DATA BETWEEN TWO OR MORE THAN
TWO SCRIPTS WITH 'SQL' DATABASE,
BUT YOU CAN USE 'pybridge' AS A SIMPLE DATABASE LIBRARY

:::::::::::::::::::::::::::::::::::::::::::::::;

The main class of library is 'bridge' with some methods:

send_to_bridge() => for saving and sharing data with SQL database

receive_from_bridge(self, all=True, find_key=None, on_delete=False) =>
for getting datas from selected bridge by built object,
The type of received keys and values id 'string' 

***args:
all : RETURNS ALL RECORDS

find_key : YOU CAN FILTER RECORDS BASED ON THEIR KEYS

on_delete : DELETES ALL FOUNDED RECORDS WHEN IT IS 'TRUE'

delete_bridge_data(find_key=None) => delete records from databse with filtering by 'KEYS'

get_bridge_record_count() => RETURNS RECORDS COUNT IN BRIDGE

raw_sql(query: str, entry: tuple = ()) => RUNNING SQL IN BRIDGE

***args:

query: SQL query for command

entry: inputs for query, every item in this tuple must be tuple!


raw_query_select(query: str, entry: tuple = ()) => SELECTING WITH RAW SQL QUERY

***args:

query: SQL query for command

entry: inputs for query, every item in this tuple must be tuple!

This function returns tuple data

send_dict_data(data: dict) => SEND DATA WITH DICTIONARY

add_bridge_listener() => MAKE A LISTENER FOR BRIDGE EVENTS

It waits for events and after each event you have to call it again
and because of that you can usually use it in 'while True' Loops

the built object of 'bridge' has new_event and event_list

new_event ==> It shows the last event that happended to bridge and database

event_list ==> list of saved events by listener



:::::::::::::::::::::::::::::::::::::::::::::::;

THIS PACAKGE IS DEVELOPED BY 'MRT' => (MOHAMMAD REZA TAGHDIRI) A PERSIAN PROGRAMER.

I HOPE THAT 'pybridge' MAKE SOME WORKS EASIER FOR YOU....
variational-autoencoder-pytorch 0.1.0
A package to simplify the implementing a variational-autoencoder model with fully connected latent heads.
Requires Python: >=3.10
Keywords: variational autoencoder, pytorch, ml, deep learning

# variational-autoencoder-pytorch
A minimal PyTorch library for building variational autoencoders (VAEs) with fully connected latent heads. Designed for fast prototyping, it provides modular encoder-decoder components and handles μ/logσ² prediction out of the box. Ideal for researchers and developers who want clean, customizable VAE models without boilerplate.
kra 0.1.0
Convenient DataFrame column operations for Polars.
Requires Python: >=3.7

# kra

A set of useful tools to work with [polars](https://pola-rs.github.io/polars/), providing convenient extensions for DataFrame manipulation, column operations, label encoding, and more.

## Installation

Build and install the Rust extension and Python API using [maturin](https://github.com/PyO3/maturin):

```sh
pip install maturin
maturin develop
```

Or, for development and testing:

```sh
pip install nox
nox
```

## Features

- **DataFrame and Series extensions**: Add new methods to polars DataFrames and Series.
- **Column utilities**: Easily rename, check, and transform DataFrame columns.
- **Label encoding**: Encode string labels as categorical/integer values.
- **Dict-of-dicts conversion**: Convert between DataFrames and nested dictionaries.

---

## Example Use Cases

### 1. Dict-of-Dicts Conversion

Convert a DataFrame to a dict of dicts using a column as the key:

```python
import polars as pl
import kra

df = pl.DataFrame({
    "id": [1, 2, 3],
    "name": ["Alice", "Bob", "Charlie"]
})

dod = df.to_dod("id")
# {1: {'id': 1, 'name': 'Alice'}, 2: {'id': 2, 'name': 'Bob'}, ...}

# Convert back:
df2 = kra.from_dod(dod, "id")
```

---

### 2. Column Name Transformations

Transform column names to different cases:

```python
import polars as pl
import kra

df = pl.DataFrame({
    "First Name": [1, 2],
    "Last Name": [3, 4]
})

df_lower = df.cols.to_lowercase()
df_camel = df.cols.to_camelcalse()
df_snake = df.cols.to_snakecase()
```

---

### 3. Label Encoding

Encode string labels as integers:

```python
import polars as pl
import kra

df = pl.DataFrame({
    "label": ["cat", "dog", "cat", "bird"]
})

# Series API
encoded = df["label"].label.encode()

# Expression API (for use in with_columns, etc.)
df2 = df.with_columns(
    pl.col("label").label.encode().alias("encoded_label")
)
```

---

### 4. DataFrame Utilities

Drop columns of type Null:

```python
import polars as pl
import kra

df = pl.DataFrame({
    "a": [1, 2, 3],
    "b": [None, None, None]
})

df_clean = df.drop_null_cols()
```

---

### 5. From Array-like

Create a DataFrame from a numpy array:

```python
import kra
import numpy as np

data = np.array([[1, 2], [3, 4]])
df = kra.from_arraylike(data, schema=["x", "y"], orient="col")
```

---

## API Reference

- `kra.from_dod`: Create DataFrame from dict of dicts.
- `kra.to_dod`: Convert DataFrame to dict of dicts.
- `kra.Cols`: DataFrame column utilities (access via `df.cols`).
- `kra.LabelSeries`: Series label encoding (access via `series.label`).
- `kra.LabelExpr`: Expression label encoding (access via `pl.col(...).label`).
- `kra.drop_null_cols`: Remove columns of type Null.
- `kra.from_arraylike`: Create DataFrame from array-like objects.

For more, see the intro.ipynb notebook.

---

## Rust Extension

kra includes a Rust extension for fast label encoding, accessible via the Python API.

---

## License

MIT License. See LICENSE for details.
spotify-jam 0.2
spotify-jam is a package that allows you to manage Spotify Jams

# Spotify-Jam

A package to manage Spotify Jams!

## Installation

```
pip install spotify-jam
```

## Quick Start

Make sure to get your auth token. It seems to expire every so often but i got my mine by going to the Spotify web player and opening inspect element, going to the networking, making a request like playing a song, and then grabbing the "Authorization" value from a header.  

```python
import spotify_jam
import time
auth = "BEARER PERSONAL_TOKEN_HERE"

inviteURI, sessionId = spotify_jam.startJam(auth)
spotify_jam.allowJamUsersControlQueue(False)
toKickId = ""
for member in spotify_jam.getJamData(auth, sessionId)["session_members"]:
    toKickId = member["id"]
spotify_jam.kickJamUser(auth, sessionId, toKickId)
time.sleep(2)
spotify_jam.endJam(auth, sessionId)
```

## Version

-  **v.0.2** (August 2, 2025): Initial release