semvec/pypi-packages huggingface dataset:
dcentrapi 0.6.1
Dcentralab Pypi packages
License: MIT
Requires Python: >=3.9
Keywords: python

# DAPI

## Getting started

To make it easy for you to get started with GitLab, here's a list of recommended next steps.

Use this [link](https://app.clickup.com/3857237/v/dc/3npun-28475/3npun-46355) in order to set up the repository.

## Development Setup

### Install Dependencies

```bash
# Install UV if you haven't already
curl -LsSf https://astral.sh/uv/install.sh | sh

# Install project dependencies
uv sync

# Install with testing dependencies
uv sync --extra test
```

## Testing

The project includes comprehensive tests located in the `tests/` directory. For detailed testing instructions, see [tests/README_TESTING.md](tests/README_TESTING.md).

### Quick Test Commands

```bash
# Run all tests
uv run pytest tests/

# Run with coverage
uv run pytest tests/ --cov=dcentrapi --cov-report=html --cov-report=term

# Run specific test categories
uv run pytest tests/ -m unit          # Unit tests only
uv run pytest tests/ -m integration   # Integration tests only
uv run pytest tests/ -m ethereum      # Ethereum tests only
```

## Test and Deploy

- Make your changes on staging branch.
- Change the package version in Base.py and setup.py. If you added a new file make sure to add it to __init__.py file.
- Install the test package using your virtual environment. run ```pip install --index-url https://test.pypi.org/simple/ dcentrapi==<the version you deployed> ```
- Create a local test.py file (do not add to git), import your changes and test them.

- Once you finished testing, add the changes to main side branch and create a merge request.
bscal 0.0.6
Calendar for Bikram Sambat
License: MIT
Requires Python: >=3.9

## Bikram Sambat Calendar

### Installation

1. Using pip
```console
pip install bscal
```

2. Using pipx

```console
pipx install bscal
```

### Usage


#### Display calendar in BS format

```console
$ bscal
     Poush 2080
Su Mo Tu We Th Fr Sa
 1  2  3  4  5  6  7
 8  9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29
```

> [!TIP]
> You can provide `year` to display a calendar for that year, and also optionally specify the `month` for a specific month's calendar.

#### Display the current BS date:

```console
$ bsdate
Tue Poush 17 09:14:14 +0545 2080
```

#### Display a specific date (from given ISO format)

```console
$ bsdate 2016-09-08
Thu Bhadra 23 09:17:21 +0545 2073
```

#### Display a specific date (represented as a Unix timestamp):

```console
$ bsdate 1473305798
Thu Bhadra 23 09:21:38 +0545 2073
```

#### Convert BS date to AD format

```console
$ bsdate -c 2073-05-23
Thu Sep  8 09:19:00 +0545 2016
```
uubed-rs 0.1.0
High-performance Rust core for position-safe embedding encoding (QuadB64 family)
License: MIT
Requires Python: >=3.8
Keywords: encoding, embeddings, base64, rust, performance

# uubed-rs

High-performance Rust core for position-safe embedding encoding (QuadB64 family).

## Overview

This repository contains the Rust implementation of the uubed encoding library, providing:

- **Q64 Encoding**: Core position-safe encoding algorithm
- **SIMD Optimizations**: AVX2/AVX-512/NEON acceleration for maximum performance  
- **Zero-Copy Operations**: Direct buffer access for minimal overhead
- **Multiple Encoding Methods**: SimHash, Top-k, Z-order variants
- **PyO3 Bindings**: High-performance Python integration

## Features

- **Position-Safe Encoding**: Eliminates substring pollution in embeddings
- **Multiple Variants**: Eq64, Shq64, T8q64, Zoq64 for different use cases
- **High Performance**: 40-105x speedup over pure Python implementations
- **Memory Efficient**: Buffer pooling and zero-copy operations
- **Cross-Platform**: Linux, macOS, Windows support
- **Multi-Architecture**: x86_64, ARM64 with optimized SIMD

## Installation

Install via pip:

```bash
pip install uubed-rs
```

Or build from source:

```bash
maturin build --release --features simd
```

## Usage

```python
import uubed_rs

# Basic encoding
data = b"hello world"
encoded = uubed_rs.q64_encode_native(data)

# Zero-copy with buffers
import numpy as np
input_buffer = np.frombuffer(data, dtype=np.uint8)
output_buffer = np.zeros(len(data) * 2, dtype=np.uint8)
written = uubed_rs.q64_encode_inplace_native(input_buffer, output_buffer)
```

## Performance

- **Q64 Encoding**: Up to 105x faster than Python
- **SimHash**: 1.7-9.7x speedup with Rust implementation
- **Z-order**: 60-1600x performance improvement
- **Memory Usage**: 50-90% reduction through buffer pooling

## License

MIT License - see LICENSE file for details.

## Related Projects

- [uubed](https://github.com/twardoch/uubed) - Main project coordination
- [uubed-py](https://github.com/twardoch/uubed-py) - Python implementation
- [uubed-docs](https://github.com/twardoch/uubed-docs) - Comprehensive documentation