semvec/pypi-packages huggingface dataset:
byteprints 1.3.0rc3
字节跳动风格延迟逐元素打印库，支持字符串/容器，毫秒/秒模式切换 | ByteDance-style delayed element-wise printing library
License: MIT
Requires Python: >=3.6
Keywords: print, delay, byte dance, 延迟打印, 容器打印, 打印

字节跳动风格延迟逐元素打印库
支持字符串、列表、元组、字典等类型
可切换毫秒/秒延迟模式，简化别名函数（bd/sbd/cbd）
完善参数校验和双语警告，无额外依赖。
BytePrint库，缩写bp。
采用双语制作：中文，英文
支持版本：Python >= 3.6
构建方式：正式版确定为a.b.c.d
byteprints不建议与byteprint库在一起，会混淆
（byteprints注册为byteprints，byteprint注册为byteprint）

ByteDance-style delayed printing library
supports strings/lists/tuples/dicts, switchable delay modes
simplified aliases, validation and bilingual warnings
no extra dependencies.
BytePrint library, abbreviated as bp.
Produced in bilingual: Chinese, English
Supported versions: Python >= 3.6
Construction method: The official version is determined to be a.b.c.d.
byteprints is not recommended with the byteprint library and can confuse
content-addressed-store 1.0.0
Content-addressed block store with chunking and deduplication
License: MIT
Requires Python: >=3.9
Keywords: content-addressed, storage, chunking, deduplication, cas

# Content-Addressed Block Store

A Python content-addressed storage system with content-defined chunking and automatic deduplication. Efficiently stores large files by splitting them into content-defined chunks and deduplicating at the chunk level.

## Features

- **Content-Defined Chunking**: Rabin fingerprinting approximation for intelligent file splitting
- **Automatic Deduplication**: Chunk-level deduplication with reference counting
- **Optional Compression**: zlib compression for space efficiency
- **SHA256 Content Addressing**: Immutable, verifiable content identifiers
- **Garbage Collection**: Reference-counted cleanup of unreferenced chunks
- **SQLite Metadata**: Robust metadata storage with proper indexing
- **Thread-Safe**: Reentrant lock protection for concurrent access
- **Integrity Verification**: Hash-based blob verification

## Installation

```bash
pip install content-addressed-store
```

## Usage

```python
from content_addressed_store import ContentAddressedStore

store = ContentAddressedStore("./my_store", enable_compression=True)

# Store data (returns content hash)
blob_hash = store.put(b"Hello, World!" * 1000, metadata={"type": "text"})

# Retrieve data
data = store.get(blob_hash)

# Verify integrity
assert store.verify(blob_hash)

# Get statistics
print(store.stats())
```

## License

MIT
merkle-dag-store 1.0.0
Local Merkle DAG store with content-addressable block storage
License: MIT
Requires Python: >=3.9
Keywords: merkle, dag, content-addressable, storage, blockchain

# Merkle DAG Store

A local Merkle DAG store with content-addressable block storage in Python. Provides immutable, deterministic, block-addressed object storage with DAG linking, snapshotting, and garbage collection.

## Features

- **Content Addressing**: Multiple hash algorithms (SHA256, SHA512, BLAKE2b)
- **DAG Linking**: Create parent-child relationships between blocks
- **Snapshotting**: Tag and version DAG states for time-travel
- **Garbage Collection**: Remove unreachable blocks from storage
- **Integrity Verification**: Recursive DAG verification
- **DAG Traversal**: BFS traversal to discover reachable blocks
- **SQLite Index**: Efficient metadata indexing and access statistics
- **Sharded Storage**: Filesystem sharding for performance at scale

## Installation

```bash
pip install merkle-dag-store
```

## Usage

```python
from merkle_dag_store import MerkleDAGStore

store = MerkleDAGStore("./my_dag")

# Store blocks
cid1 = store.put(b"Hello, World!")
cid2 = store.put(b"Linked data")

# Create linked block
cid3 = store.put(b"Parent", links=[str(cid1), str(cid2)])

# Create snapshot
store.snapshot(str(cid3), tag="v1.0")

# Verify integrity
assert store.verify(str(cid3), recursive=True)
```

## License

MIT
sync-coordination 1.0.0
Sync coordination layer using Merkle DAG, event sourcing, and CRDTs
License: MIT
Requires Python: >=3.9
Keywords: sync, coordination, crdt, distributed, vector-clock, event-sourcing

# Sync Coordination Layer

A Python sync coordination engine that orchestrates synchronization between distributed nodes using vector clocks, operation logging, and conflict resolution with last-write-wins semantics.

## Features

- **Vector Clocks**: Full causality tracking across distributed nodes
- **Operation Logging**: Persistent SQLite-backed operation log
- **Conflict Resolution**: Automatic last-write-wins with vector clock tie-breaking
- **Entity CRUD**: Create, update, delete, and merge operations
- **Remote Sync**: Synchronize operations between multiple nodes
- **State Export**: Full state export for backup and transfer
- **Thread-Safe**: Reentrant lock protection for concurrent access

## Installation

```bash
pip install sync-coordination
```

## Usage

```python
from sync_coordination import SyncCoordinator, OperationType

# Initialize nodes
node1 = SyncCoordinator("node-1", "./sync_store_1")
node2 = SyncCoordinator("node-2", "./sync_store_2")

# Create entity on node 1
op = node1.create_operation(
    OperationType.CREATE, "user:1",
    {"name": "Alice", "email": "alice@example.com"}
)
node1.apply_operation(op)

# Sync to node 2
result = node2.sync_with_remote([op])
print(result)
```

## License

MIT