semvec/pypi-packages huggingface dataset:
muvfde 0.0.9
A Python library to generate Fixed Dimensional Embeddings for Multi-dimensional embedding vectors based on Google Muvera.
Requires Python: >=3.10

# MuvFDE
A Python library to generate fixed dimensional embeddings for multi-dimensional vectors based on [Google Muvera](https://research.google/blog/muvera-making-multi-vector-retrieval-as-fast-as-single-vector-search/).

![Version](https://img.shields.io/pypi/v/muvfde?style=flat-square)
![UnitTests](https://img.shields.io/github/actions/workflow/status/viig99/muvfde/pip.yml?branch=main&style=flat-square)
![Downloads](https://img.shields.io/pypi/dm/muvfde?style=flat-square)
![License](https://img.shields.io/github/license/viig99/muvfde?style=flat-square)


## Installation
```shell script
pip install --upgrade muvfde
```

## Integeration Benchmark
```shell script
uv venv --python 3.12
uv pip install -e .
uv pip install -r integeration_test/requirements.txt
python integeration_test/benchmark.py
```

## Usage
Check out `integeration_test/benchmark.py` for usage examples.

## Caveats
* The FDE algorithm is highly hyperparameter sensitive. The hyperparameters used in the benchmark are not optimal for all models.
* FDE quality is tightly linked to dimensionality; increase in dimensionality will generally result in quality gains.

## Results
[Benchmark Results](https://github.com/viig99/muvfde/blob/main/integeration_test/benchmark.md)

## References
* [Google Muvera Blog](https://research.google/blog/muvera-making-multi-vector-retrieval-as-fast-as-single-vector-search/)
* [MUVERA: Multi-Vector Retrieval via Fixed Dimensional Encodings](https://arxiv.org/abs/2405.19504)
* [Reference Fixed Dimensional embeddings code](https://github.com/google/graph-mining/tree/main/sketching/point_cloud)
akedly-client 0.1.1
Unofficial Akedly OTP API Client
Requires Python: >=3.7

# Akedly Python Client

**Akedly Client** is an unofficial Python wrapper for the [Akedly OTP API](https://akedly.io). It provides a simple interface for managing OTP transactions including creation, activation, and verification using Akedly's [Transaction-Based OTP Verification API](https://docs.akedly.io/docs/category/otp-verification).

## About Akedly

[Akedly](https://akedly.io) is a robust authentication-as-a-service platform that offers OTP delivery pipelines for secure user verification via phone or email. This client integrates directly with their public OTP API.

## Features

- Create OTP transactions
- Activate OTP sessions
- Verify OTP codes
- Lightweight with minimal dependencies (requests and python-dotenv)
- Designed for integration into Python-based backend systems

## Installation

```bash
pip install akedly-client
```

## Configuration

This client requires three environment variables. You can load them using a `.env` file and `python-dotenv`.

### Environment Variables

Create a `.env` file in your project root:

```env
AKEDLY_API_URL=https://api.akedly.io/api/v1/transactions
AKEDLY_API_KEY=your_akedly_api_key_here
AKEDLY_PIPELINE_ID=your_pipeline_id_here
```

**Important:** Never commit your `.env` file to version control.

## Usage

```python
from akedly_client import (
    create_otp_transaction,
    activate_otp_transaction,
    verify_otp
)

# 1. Create a new OTP transaction
transaction_id = create_otp_transaction(
    phone="+201234567890",
    email="user@example.com"
)

# 2. Activate the transaction to send OTP
request_id = activate_otp_transaction(transaction_id)

# 3. Verify the OTP entered by the user
is_valid, result = verify_otp(request_id, otp="123456")

if is_valid:
    print("OTP verified successfully.")
else:
    print("Verification failed:", result)
```

## API Reference

For detailed API documentation, please refer to:

- [OTP API Reference](https://docs.akedly.io/docs/category/otp-verification)
- [Akedly Website](https://akedly.io)
- [Dashboard Login](https://dashboard.akedly.io)

## Requirements

- Python 3.7 or higher
- `requests`
- `python-dotenv`

Install dependencies:

```bash
pip install -r requirements.txt
```

## Testing

```bash
pytest tests/
```

Add your test cases under `tests/test_client.py`.

## Contributing

1. Fork the repository
2. Create a feature branch (`git checkout -b feature/new-feature`)
3. Commit your changes (`git commit -am 'Add new feature'`)
4. Push to the branch (`git push origin feature/new-feature`)
5. Create a Pull Request

## Disclaimer

This is an **unofficial client** maintained by the community. It is not affiliated with Akedly Inc., and no guarantees are provided for uptime, API changes, or SLA adherence.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

## Support

For issues related to this client, please open an issue on GitHub. For Akedly API support, please contact Akedly directly through their official channels.
globalite 0.0.1
Easy global variables
Requires Python: >=3.9

# Globalite
A python library for easy global variables saved to a SQLite db and accessable from multiple programs at ones.


## Supported types
|Type|Read|Write|Delete|
|:-|:-|:-|:-|
|bool|✅|✅|✅|
|int|✅|✅|✅|
|float|✅|✅|✅|
|str|✅|✅|✅|
|dict|⚠️~1~|✅|⚠️~1~|
|custom classes|❌~2~|❌~2~|❌~2~|


⚠️~1~: When reading a dict you will receive a new instance of the dict and not a reference.  
meaning that the following is the case:
```python
import globalite
gl = globalite.get_default_globalite()
gl.a_dict = {"a": 1}
assertEqual(gl.a_dict, gl.a_dict) # is true
assertIs(gl.a_dict, gl.a_dict) # is false
```
seedtools 0.1.3
A lightweight toolkit for loading and managing versioned seed datasets in Python.


# <center> <u> SeedTools </u>  </center>

- while doing Machine learning projects , not able to load data fast enough ?

- tired of writing same code again and again for same datasets 

**seedtools** is a Python utility package for reading, versioning, and managing seed data files — especially useful for machine learning projects, database seeding, and automated data workflows.

<u> Here is our Solution </u> 👍

- just make a directory which contains all the datasets and use it anywhere across the pc 




### Features

- 🔄 Load and preprocess versioned seed data files
- 📁 Supports CSV and other tabular formats
- 🔍 Easily inspect, debug, and manage seed data across versions

### Installation

```bash
pip install seedtools

```

### SET `Data Path` once and use it anywhere 

``` python
from seedtools import configure_data_path, reset_path

reset_path() # default path 
configure_data_path("you path")
```

## How to load data from directory 

``` python 
from seedtools import load_seed
data = load_seed("data_science_jobs.csv")
print(data.data)
```


**If  already have version**

``` python 
data = load_seed("data_science_jobs.csv","v2")
print(data.data)
```


## How to register it first ?

``` python 
data = load_seed("data_science_jobs.csv")
data.register(desc="wonderful_dataset") # will create a seed file in same dir 
```


## How to register version ?

``` python 
data = load_seed("data_science_jobs.csv")
data.register_version("v_name",drop_cols=["col1","col2"],cols_maps={"Gender":"auto","City":{"London":1."Delhi":0}})  
# will register in the seed file 
# auto will convert gender = > Male :  1 , female : 0
# you can make custom mapping also 
```


## How to Check Available Versions ? 
``` python 
data = load_seed("data_science_jobs.csv")
print(data.versions_list())
``` 

## How to check seed File (rarely needed) ?

``` python 
data = load_seed("data_science_jobs.csv")
print(data.seed_file())
``` 


## Terminate Version 

``` python 
data = load_seed("data_science_jobs.csv")
data.terminate_version("v3")
```
jadio-llmnet 0.0.7
Jadio-compatible extension package
Requires Python: >=3.8

# LLMNet

LLMNet is a local LAN server for **configuring, assigning, and hot-swapping** local language models on your own network.

It’s designed to help you manage your local AI deployments with ease, providing a single interface to load, unload, and switch between "lazy" local models on demand.

---

## 🚀 About

LLMNet makes it easy to build your own **Local Model Hub**:

- Assign models to specific ports on your local machine or LAN.
- Lazy-load large models only when needed.
- Hot-swap models without restarting the whole server.
- Enable local devices or apps on your network to query any assigned model.
- Avoid relying on cloud APIs for privacy, cost, or latency reasons.

LLMNet is ideal for anyone running multiple local AI models and wanting an easy, organized way to manage them across their LAN.

---

## ⚙️ Key Features

✅ Local server that runs on your LAN  
✅ Configurable ports and model assignments  
✅ Lazy loading for efficient memory use  
✅ Hot-swap models with zero downtime  
✅ Simple CLI to manage everything  
✅ Designed for self-hosting and privacy  

---

## 📦 Example Use Cases

- Run multiple LLMs on one machine and assign them to different ports.
- Let local apps choose which model they want to call.
- Easily test and compare models by swapping assignments.
- Share models across devices on your local network securely.
- Build your own "local huggingface" with your own models.

---

## 🗂️ How It Works

1. **Start the server**  
   - Runs on your machine or server on a designated LAN port.
2. **Assign models to ports**  
   - Use the CLI to load models and map them to specific ports.
3. **Lazy load on demand**  
   - Models load into memory only when first called.
4. **Hot-swap at any time**  
   - Change model assignments without restarting the server.
5. **Connect over LAN**  
   - Local devices or apps can send requests to specific models via their assigned ports.

---

## 🛠️ Planned Features

- Web-based admin panel for managing assignments  
- Resource monitoring (CPU, GPU, RAM) per model  
- User authentication and access control  
- Preset configuration profiles  
- Model performance and latency metrics  
- Support for ONNX, GGUF, SafeTensors, and other formats

---

## 🗺️ Project Goals

LLMNet aims to make **local model management** as easy as:

- Plug and play
- Secure and private
- Cost-effective
- Cloud-independent

If you want to build your own *mini OpenAI-style service* for local models, LLMNet is your foundation.

---

## 💼 License

MIT License

---

## ✨ Build your own Local Model Hub. Stay in control. Use LLMNet. 🚀