semvec/pypi-packages huggingface dataset:
bosing 2.7.0
Waveform generator for pulse sequences in quantum computing
License: MIT
Requires Python: >=3.10
Keywords: pulse, waveform, awg

# Bosing

[![Documentation Status](https://readthedocs.org/projects/bosing/badge/?version=latest)](https://bosing.readthedocs.io/zh-cn/latest/?badge=latest)
[![PyPI - Version](https://img.shields.io/pypi/v/bosing)](https://pypi.org/project/bosing/)

Waveform generator for superconducting circuits.

## Installation

```bash
pip install bosing
```

## Documentation

Docs are hosted on [Read the Docs](http://bosing.readthedocs.io/)

## Usage

Examples can be found in `python/examples`.

```python
import matplotlib.pyplot as plt

from bosing import Barrier, Channel, Hann, Play, Stack, generate_waveforms

channels = {"xy": Channel(30e6, 2e9, 1000)}
shapes = {"hann": Hann()}
schedule = Stack(duration=500e-9).with_children(
    Play(
        channel_id="xy",
        shape_id="hann",
        amplitude=0.3,
        width=100e-9,
        plateau=200e-9,
    ),
    Barrier(duration=10e-9),
)
result = generate_waveforms(channels, shapes, schedule)
w = result["xy"]
plt.plot(w[0], label="I")
plt.plot(w[1], label="Q")
plt.legend()
plt.show()
```

If you want to post-process waveforms outside of bosing, you can generate a deduplicated
list of envelopes and compact pulse instructions:

```python
import numpy as np

from bosing import Barrier, Channel, Hann, Play, Stack, generate_envelopes_and_instructions

length = 1000
channels = {"xy": Channel(30e6, 2e9, length)}
shapes = {"hann": Hann()}
schedule = Stack(duration=500e-9).with_children(
    Play(channel_id="xy", shape_id="hann", amplitude=0.3, width=100e-9, plateau=200e-9),
    Barrier(duration=10e-9),
)

envelopes, instructions = generate_envelopes_and_instructions(channels, shapes, schedule)
inst0 = instructions["xy"][0]
env0 = envelopes[inst0.env_id]
assert env0.dtype == np.float64
```

## Performance

`python/examples/schedule_stress.py` (0.15 s) vs `python/benches/naive.py` (1.4 s)

CPU: AMD Ryzen 5 5600

## Development

### Prerequisites

- Rustup for rust toolchain management.
- [maturin](https://github.com/PyO3/maturin) 1.7+.
- [uv](https://github.com/astral-sh/uv) for python project management.

```bash
git clone https://github.com/kahojyun/Bosing.git
cd Bosing
uv sync
uv run task makedocs # build docs
uv run task format # format rust and python code
uv run task lint # lint rust and python code
uv run task test # run cargo test and pytest
```
vovk-hello-world 0.0.87
A "Hello World!" app built with Next.js, Vovk.ts and Zod. For details, visit https://vovk.dev/hello-world
License: MIT
Requires Python: >=3.8
Keywords: api, openapi, vovk, zod

<!-- Generated by vovk-cli v0.0.1-beta.86 at 2026-01-15T06:50:51.483Z -->
# vovk_hello_world v0.0.87 [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/) [![Vovk.ts](https://badgen.net/badge/Built%20with/Vovk.ts/333333?icon=https://vovk.dev/icon-white.svg)](https://vovk.dev)


> A "Hello World!" app built with Next.js, Vovk.ts and Zod. For details, visit https://vovk.dev/hello-world

License: **MIT**

```bash
# Install the package
pip install vovk_hello_world
```



## UserRPC
        
### UserRPC.update_user
> Update user

Update user by ID


`POST https://hello-world.vovk.dev/api/users/{id}`

```py
from vovk_hello_world import UserRPC

response = UserRPC.update_user(
    body={
        # -----
        # User data object
        # -----
        # User email
        "email": "john@example.com",
        # User profile object
        "profile": {
            # User full name
            "name": "John Doe",
            # User age
            "age": 25
        }
    },
    query={
        # -----
        # Query parameters
        # -----
        # Notification type
        "notify": "email"
    },
    params={
        # -----
        # Path parameters
        # -----
        # User ID
        "id": "123e4567-e89b-12d3-a456-426614174000"
    },
)

print(response)
{
    # -----
    # Response object
    # -----
    # Success status
    "success": true,
    # User ID
    "id": "00000000-0000-0000-0000-000000000000",
    # Notification type
    "notify": "email"
}
```
        
    

## StreamRPC
        
### StreamRPC.stream_tokens
> Stream tokens

Stream tokens to the client


`GET https://hello-world.vovk.dev/api/streams/tokens`

```py
from vovk_hello_world import StreamRPC

response = StreamRPC.stream_tokens()

for i, item in enumerate(response):
    print(f"iteration #{i}:\n {item}")
    # iteration #0:
    {
        # -----
        # Streamed token object
        # -----
        # Message from the token
        "message": "string"
    }
```
        
    


## OpenApiRPC
        
### OpenApiRPC.get_spec
> OpenAPI spec

Get the OpenAPI spec for the "Hello World" app API


`GET https://hello-world.vovk.dev/api/static/openapi.json`

```py
from vovk_hello_world import OpenApiRPC

response = OpenApiRPC.get_spec()
```
chunkrank 0.2.4
Model-aware text chunking and answer re-ranking for LLM pipelines. Automatically adapts chunk size to tokenizer and context window, then consolidates and ranks answers across chunks.
License: MIT
Requires Python: <4.0,>=3.14

# ChunkRank: Model-Aware Chunking + Answer Ranking
```
Used internally for long-document QA and evaluation pipelines handling 1,000+ PDFs.
```
```
ChunkRank is a lightweight Python library that automatically chunks 
text based on an LLM’s tokenizer and context window, then consolidates
and ranks answers across chunks. In short ChunkRank is a model-aware text 
chunking and answer re-ranking library for LLM pipelines.
```

🔗 PyPI : https://pypi.org/project/chunkrank/

---

## Why ChunkRank?

When working with LLMs, long documents must be split into chunks, but:
- Every model has **different tokenizers and context limits**
- Chunk sizes are usually **hard-coded and error-prone**
- Answer quality drops when responses come from **multiple chunks**
- Existing RAG frameworks are **heavy** when you only need chunking + ranking

**ChunkRank solves this gap.**

---

## What It Does

✅**Model-aware chunking**  
- Pass a model name (`gpt-4o-mini`, `claude-3.5-sonnet`, `Llama-3.1-8B` etc.)   
- ChunkRank automatically:
  - Selects the correct tokenizer
  - Applies the correct context window
  - Reserves token space for prompts and responses

No manual token math. No trial-and-error.
  
✅**Answer consolidation & ranking**  
- Query runs across multiple chunks
- Multiple candidate answers are produced
- ChunkRank **re-ranks** them to return the best answer
Works standalone — no full RAG stack required.

---

## Installation

```bash
pip install chunkrank
```
or for development:
```bash
poetry install

```
## Quick Example

``` python
from chunkrank import ChunkRankPipeline

text = open("document.txt").read()

pipe = ChunkRankPipeline(model="gpt-4o-mini")

answer = pipe.process(
    question="What is the main topic of this document?",
    text=text
)

print(answer)
```
---


## Core API

``` python
chunks = chunkrank.split(text, model="gpt-4o-mini")

answers = chunkrank.answer(question, chunks)

best_answer = chunkrank.rank(answers)
```
---


## Supported Capabilities

- Automatic model → tokenizer → context resolution
- Token, sentence, and paragraph chunking strategies
- Cross-encoder based answer re-ranking
- Works with OpenAI, Anthropic, HF, Llama-based models
- Drop-in utility for QA, summarization, extraction

---

## How It Fits

| Tool | What it does |
|------|-------------|
| LangChain / LlamaIndex | Full RAG pipelines |
| Haystack | End-to-end retrieval frameworks |
| **ChunkRank** | Focused, model-aware chunking + answer ranking |

**ChunkRank complements RAG frameworks — it doesn’t replace them.**

---
## Roadmap
1. Build the **model registry** (model → context window + tokenizer).  
2. Implement **chunking strategies** (tokens, sentences, paragraphs).  
3. Integrate a **re-ranking engine** (start with Hugging Face cross-encoder).  
4. Package and release to PyPI with a simple API.  
---

## Community

- [Contributors](CONTRIBUTORS.md)
- [Maintainers](MAINTAINERS.md)

---