semvec/pypi-packages huggingface dataset:
sayaka 0.7.0
A Rust-backed Python module for decrypting and decompressing data for an anime game.
License: MIT
Requires Python: <3.15,>=3.10

# Sayaka

Sayaka is a Rust-backed Python module for decrypting and decompressing data for an anime game. It leverages [PyO3](https://pyo3.rs/) to provide a high-performance decompression function directly from Python.

## Installation

### Prerequisites

- Rust (edition 2024)
- Python (version 3.12 or higher)
- [maturin](https://github.com/PyO3/maturin) for building the extension module

### Build and Install

1. Clone the repository:

   ```powershell
   git clone https://github.com/baiqwerdvd/sayaka.git
   cd sayaka
   ```

2. Build the module using maturin:

   ```powershell
   uv sync
   uv run maturin develop --release
   ```

## Usage

Import the module in your Python code to decrypt or decompress data. The module provides three main functions:
- `decompress_buffer`: Decompresses data using LZ4 compression.
- `miki_decrypt`: Decrypts data encrypted with the Miki algorithm.
- `miki_decrypt_old`: Decrypts data encrypted with the old Miki algorithm.
- `miki_decrypt_and_decompress`: Combines decryption and decompression in one step.
- `miki_decrypt_and_decompress_old`: Combines decryption and decompression for the old Miki algorithm.

The function accepts any object implementing Buffer protocol (for example `bytes`, `bytearray`, `memoryview`) as input for the data.

```python
import sayaka

with open("compressed_data.bin", "rb") as f:
    compressed_data = f.read()

decompressed_size = 9796
decompressed_data = sayaka.decompress_buffer(compressed_data, decompressed_size)
```

```python
import sayaka

with open("miki_encrypted.bin", "rb") as f:
    encrypted_data = f.read()

decrypted_data = sayaka.miki_decrypt(encrypted_data)
```

```python
import sayaka

with open("miki_old_encrypted.bin", "rb") as f:
    encrypted_data = f.read()

decrypted_data = sayaka.miki_decrypt_old(encrypted_data)
```

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

## Acknowledgments

- [PyO3](https://github.com/PyO3/pyo3) for making Python/Rust interop simple.
- The LZ4 compression library for inspiration.
- [Lz4Inv](https://github.com/MooncellWiki/lz4inv) for providing a reference implementation.
- [YarikStudio](https://github.com/FrothierNine346/YarikStudio) for decryption logic.
bloomkv 1.3.1
A persistent key-value storage engine based on LSM-tree architecture.
License: MIT
Requires Python: >=3.8

# **BloomKV**
Light weight key value storage engine optimized for write heavy workloads.

## Overview
This project is an **LSM-tree based key-value storage engine** implemented in Python, optimized for **write-heavy workloads**.

It is a persistent key-value store featuring:
* A Write Ahead Log (WAL) for atomicity and durability.
* An in-memory Memtable using `SortedDict`.
* Persistent Sorted String Tables (SSTables).
* Asynchronous, leveled compaction handled by a background worker thread (introduced in v1.0.0).
* Metadata generation for created collections
* Bloom filter functionality to prevent unnecessary disk operations for keys that we know dont exist in the collection
* Storage engine is behind a FastAPI server and can be communicated with using REST APIs.
* Supports range queries from start_key to end_key
* Can be used as an importable library for programmatic integration
* Import csv files and store them as kv pairs in a collection

## Getting Started
* Detailed documentation, usage and explanation of each component is available in the docs folder.

## Contributing
Contributions, issues and feature requests are welcome!
**Contributing ideas**
* Implement a proper testing suite for different components. Unit tests, Integration Tests
* Thread safety for multi threaded programs
* UI features along with CLI and library utilisation. 
and many more, ideas are always welcome!

## LICENSE
This project is licensed under the MIT License. See the LICENSE file for details.
gbase8sdb 0.2.4
Python interface to GBase 8s Database
License: MIT
Keywords: GBase 8s, database

# python-gbase8sdb

python-gbase8sdb 是一个 [Python 编程语言][python] 扩展模块，允许 Python 程序连接到 GBase 8s 数据库。

该模块符合 [Python 数据库 API 2.0 规范][pep249]，并且包含大量扩展和少数排除项。


## 安装

运行 `python -m pip install gbase8sdb` 安装。


## 依赖和互操作性

- 支持的 GBase 8s 数据库版本：GBase 8s V8.8_3.6.2版本及以上。

- 支持的操作系统：Linux x86_64、 Windows 64位操作系统 。

- 依赖 GSDK 1.1 版本。


#### 使用说明

1.  gbase8sdb驱动连接数据库依赖GSDK，所以您需要联系GBase 8s技术支持或通过官方渠道获取相应版本的GSDK，并安装到您的机器上， 并设置如下环境变量：

- Linux系统：
```bash
GSDK_PATH=/path/to/gsdk
export LD_LIBRARY_PATH=${GSDK_PATH}/lib:$LD_LIBRARY_PATH
export GBASEDBTDIR=${GSDK_PATH}/lib
```
    
- Windows系统：

```cmd
GSDK_PATH=\path\to\gsdk
set PATH=%GSDK_PATH%\lib;%PATH%
set GBASEDBTDIR=%GSDK_PATH%\lib
```

#### 入门
在您的Python应用程序中，可以通过以下方式连接到数据库：
```python
import gbase8sdb

# 生成dsn
dsn = gbase8sdb.makedsn(
    server_name="ol_gbasedbt1210_2",    # 数据库实例名称
    db_name="testdbutf8",               # 数据库名称
    host="192.168.xxx.xxx",             # 数据库实例所在服务器的IP地址或域名
    port=9088,                          # 数据库实例的端口号
    db_locale='zh_CN.utf8'              # 数据库字符集
)
user = "gbasedbt"                       # 数据库用户名
password = "xxxxxx"                     # 数据库用户密码

# 连接数据库
conn = gbase8sdb.connect(dsn, user, password) 
# 创建游标  
cursor = conn.cursor()  
# 执行SQL语句                       
cursor.execute("drop table if exists t")
cursor.execute("create table t (id int, name varchar(20))")
cursor.execute("insert into t values (?, ?)", (1, "zhangsan"))
cursor.execute("select * from t")
# 获取查询结果
print(cursor.fetchall())
# 关闭游标和连接
cursor.close()
conn.close()
```
pathlike-typing 1.0.0
Lightweight Python library providing PathLike type alias for path annotations
License: MIT
Requires Python: >=3.6
Keywords: typing, path, pathlib, type-hints, annotations

# PathLike Typing Library / Библиотека PathLike Typing

____

# English Documentation

## Overview
`pathlike-typing` is a lightweight Python library that provides a standardized type alias PathLike for representing file system paths in type annotations. It simplifies working with path objects by unifying `Path` (from `pathlib`) and `str` types under a single type hint.

## Installing
```shell
pip install pathlike-typing
```

## Version
Current version: `1.0.0`

## Usage
```python
from pathlib import Path
from pathlike_typing import PathLike

# Use PathLike in type annotations
def read_file(path: PathLike) -> str:
    # Both Path objects and strings are accepted
    with open(path, 'r') as f:
        return f.read()

# Both will work:
read_file(Path("/home/user/file.txt"))
read_file("/home/user/file.txt")
```

## Type Alias
### The library provides one main export:

- `PathLike`: Type alias for `Union[Path, str]`

## Exports
```python
__all__ = ["PathLike", "__version__"]
```

## Why Use This Library?
1. Consistency: Standardizes path type annotations across your codebase
2. Clarity: Makes function signatures clearer about what types of path arguments are accepted
3. Compatibility: Works seamlessly with both pathlib.Path objects and traditional string paths
4. Lightweight: Minimal dependencies and overhead

## License
MIT License - See LICENSE file for details.

----

# Документация на русском языке

## Обзор
`pathlike-typing` — это облегчённая библиотека Python, предоставляющая стандартизированный псевдоним типа PathLike для представления путей к файловой системе в аннотациях типов. Она упрощает работу с объектами путей, объединяя типы `Path` (из `pathlib`) и `str` под единым указанием типа.

## Установка
```shell
pip install pathlike-typing
```

## Версия
Текущая версия: `1.0.0`

## Использование
```python
from pathlib import Path
from pathlike_typing import PathLike

# Используйте PathLike в аннотациях типов
def read_file(path: PathLike) -> str:
    # Поддерживаются как объекты Path, так и строки
    with open(path, 'r') as f:
        return f.read()

# Поддерживаются оба варианта:
read_file(Path("/home/user/file.txt"))
read_file("/home/user/file.txt")
```

## Псевдоним типа
### Библиотека предоставляет один основной экспорт:

- `PathLike`: Псевдоним типа для `Union[Path, str]`

## Экспорт
```python
__all__ = ["PathLike", "__version__"]
```

## Зачем использовать эту библиотеку?

1. Единообразие: Стандартизирует аннотации типов путей в вашей кодовой базе.
2. Ясность: Делает сигнатуры функций более понятными для определения типов принимаемых аргументов путей.
3. Совместимость: Без проблем работает как с объектами pathlib.Path, так и с традиционными строковыми путями.
4. Легковесность: Минимальные зависимости и накладные расходы.

## Лицензия
Лицензия MIT — подробности см. в файле LICENSE.