semvec/pypi-packages huggingface dataset:
resinkit-sdk-python 0.1.1
A Python SDK for ResinKit
Requires Python: >=3.10

# ResinKit Python SDK

A Python SDK for ResinKit.

## Requirements

- Python 3.9+
- uv for dependency management

## Installation

You can install the package using uv:

```bash
uv add resinkit-sdk-python
```

Or directly with pip:

```bash
pip install resinkit-sdk-python
```

## Development Setup

1. Clone the repository:
```bash
git clone https://github.com/yourusername/resinkit-sdk-python.git
cd resinkit-sdk-python
```

2. Install uv (if not already installed):
```bash
curl -sSL https://install.python-uv.org | python3 -
```

3. Install dependencies:
```bash
uv install
```

4. Run tests:
```bash
uv run pytest
```

## Usage

```python
from resinkit import Client

# Initialize the client
client = Client()

# Use the client
```

## Contributing

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## License

This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.
python-mailable 0.1.0
An expressive email builder for Python
Requires Python: >=3.13

# Python Mailable

**Python Mailable** is an email builder for Python, inspired by Laravel's Mailable class. It provides a clean and reusable structure for defining, composing, and sending emails with rich context and templates.

> [!IMPORTANT]  
> We currently only support _rendering_ emails, not sending them.
>
> This package helps you build and render email content using templates, but you need to handle email sending yourself with your own SMTP client or email delivery service.
>
> Use the `.render()` method to get your email body, and then integrate with any mail-sending solution you prefer.

## Features

- Define email classes with subjects, recipients, and templates
- Pass context to templates for dynamic rendering
- Attach files easily
- Designed for clarity, testability, and reusability

## Usage

### Creating a Mailable

To define a custom email, subclass `Mailable` and implement the `build()` method. Use the fluent API to configure the mail.

```python
from dataclasses import dataclass
from mailable import Mailable

@dataclass
class OrderShipped(Mailable):
    user: User  # Your domain model or DTO

    def build(self):
        return (
            self.to(self.user.email)
                .subject("Your order has shipped!")
                .template("emails/order_shipped.html")
                .with_context({"user": self.user})
        )

```

### Sending the email

```python
user = User(email="jane.doe@example.com", name="Jane Doe")

email = OrderShipped(user).build()
email.send()  # Sends using the built-in SMTP backend
```

> 💡 **Want to use your own mail client instead?**  
> You can call `email.render()` to get the subject, body, and recipient info — and pass that into your own delivery system.
nebu 0.1.132
A globally distributed container runtime
Requires Python: >=3.10.14

# nebulous-py

A declarative python library for the [Nebulous runtime](https://github.com/agentsea/nebulous)

## Installation

```bash
pip install nebu
```

## Usage

Create a pytorch container on runpod with 1 A100 GPU

```python
from nebu import Container, V1EnvVar

container = Container(
    name="pytorch-example",
    namespace="test",
    image="pytorch/pytorch:latest",
    platform="runpod",
    env=[V1EnvVar(name="MY_ENV_VAR", value="my-value")],
    command="nvidia-smi",
    accelerators=["1:A100_SXM"],
    proxy_port=8080,
)

while container.status.status.lower() != "running":
    print(f"Container '{container.metadata.name}' is not running, it is '{container.status.status}', waiting...")
    time.sleep(1)

print(f"Container '{container.metadata.name}' is running")

print(f"You can access the container at {container.status.tailnet_url}")
```

### Decorator

Run a python function in a container [in progress]

```python
from nebu import container

@container(image="python:3.10-slim", accelerators=["1:A100_SXM"])
def my_function(x: int, y: int) -> int:
    return x + y

result = my_function(1, 2)
print(result)
```

## Contributing

Please open an issue or a PR to contribute to the project.

## Development

```bash
make test
```
pyvault-client 0.1.1
Flexible data and file storage, retrieval and caching system for Python applications 
Requires Python: >=3.9

# Vault

**Vault** is a flexible and lightweight data/file storage, retrieval, and caching system for Python applications.  

It enables developers to manage any Python object (given a proper `Datatype` implementation), store them locally or remotely, organize them by type, and access them efficiently using an in-memory cache, all this with just a few lines of code.  

Vault has only two dependencies (`psutil` and `requests`), encourages memory usage monitoring, and will support non-blocking I/O operations.

## I. Project Structure

Vault is split into two libraries:

- **`vault`** – Core data storage library, which also includes the ability to connect to remote Vaults.
- **`vault-fastapi`** – Library for building custom servers that expose Vault storage over the network.

There are also two usage examples: one for local use-cases where Vault is used within the same Python process, and one for remote use-cases where Vault is run on a separate machine.  

Additionally, the `datatypes/` directory contains example wrappers for using Python types from common libraries with Vault.


## II. Architecture

(todo)

![Diagram for showing the core in-memory cache for accessing data](https://github.com/djtech-dev/vault/blob/fe1bf1beffe63cf73cb1e049c6383c0a762f2aa8/.readme_assets/system_architecture_1.png)

## III. Milestones

A main issue with Vault is the absence of ways to scale Vaults across multiple servers: those issue will be solved with Vault 2.0, which will introduce *Scalable Storage*, *Disk Caching* and *Data Streaming*.

These changes are intended to support large-scale applications and will likely require breaking changes; we are planning to recieve feedback and fix bugs during the 1.0 development cycle in order to have a stable base to build upon, before starting the 2.0 development cycle.

Before that, a key improvement planned for 1.x is support for *non-blocking data operations*, either through async-compatible methods for the already implement classes or async-specific variants of existing classes.

A smaller improvement that could be done for programs that use large amounts of files is adding an optional feature for keeping track of files in a separate register (most likely sqlite) in order to remove the need to list all files in the directories when the Vault is loaded. This additional database could also be used to add data integrity checks (checksum).

## IV. Vault API

The Remote API specification for Vault 1.0 is available in [`VAULT_API.md`](./VAULT_API.md).
aqua-blue 0.2.19
Lightweight and basic reservoir computing library
Requires Python: >=3.9
Keywords: computing, forecasting, learning, machine, prediction, reservoir, series, time

# aqua-blue
Lightweight and basic reservoir computing library

[![Custom shields.io](https://img.shields.io/badge/docs-brightgreen?logo=github&logoColor=green&label=gh-pages)](https://jwjeffr.github.io/aqua-blue/)


[![PyPI version shields.io](https://img.shields.io/pypi/v/aqua-blue.svg)](https://pypi.python.org/pypi/aqua-blue/)
[![PyPI pyversions shields.io](https://img.shields.io/pypi/pyversions/aqua-blue.svg)](https://pypi.python.org/pypi/aqua-blue/)

## 🌊 What is aqua-blue?

`aqua-blue` is a lightweight `python` library for reservoir computing (specifically [echo state networks](https://en.wikipedia.org/wiki/Echo_state_network)) depending only on `numpy`. `aqua-blue`'s namesake comes from:

- A blue ocean of data, aka a reservoir 💧
- A very fancy cat named Blue 🐾

## 🐜 Found a bug?

Please open an issue [here](https://github.com/jwjeffr/aqua-blue/issues) if you found a bug!
The easier it is to reproduce the bug, the faster we will find a solution to the problem. Please consider including the
following info in your issue:

- Steps to reproduce
- Expected and actual behavior
- Version info, OS, etc.

## 🔧 Contributing

Please see [CONTRIBUTING.md](https://github.com/jwjeffr/aqua-blue/blob/main/CONTRIBUTING.md)
for instructions on how to contribute to `aqua-blue` ☺

## 📥 Installation

`aqua-blue` is on PyPI, and can therefore be installed with `pip`:

```bash
pip install aqua-blue
```

## 📝 Quickstart

```py
import numpy as np
import aqua_blue

# generate arbitrary two-dimensional time series
# y_1(t) = cos(t), y_2(t) = sin(t)
# resulting dependent variable has shape (number of timesteps, 2)
t = np.linspace(0, 4.0 * np.pi, 10_000)
y = np.vstack((2.0 * np.cos(t) + 1, 5.0 * np.sin(t) - 1)).T

# create time series object to feed into echo state network
time_series = aqua_blue.time_series.TimeSeries(dependent_variable=y, times=t)

# normalize
normalizer = aqua_blue.utilities.Normalizer()
time_series = normalizer.normalize(time_series)

# make model and train
model = aqua_blue.models.Model(
    reservoir=aqua_blue.reservoirs.DynamicalReservoir(
        reservoir_dimensionality=100,
        input_dimensionality=2
    ),
    readout=aqua_blue.readouts.LinearReadout()
)
model.train(time_series)

# predict and denormalize
prediction = model.predict(horizon=1_000)
prediction = normalizer.denormalize(prediction)
```

## 📃 License

`aqua-blue` is released under the MIT License.

---

![Blue](https://raw.githubusercontent.com/jwjeffr/aqua-blue/refs/heads/main/assets/blue.jpg)

*Blue, the cat behind `aqua-blue`.*