semvec/pypi-packages huggingface dataset:
torchqml 0.1.7
PyTorch Quantum Machine Learning with cuQuantum - Fast Adjoint Differentiation
License: MIT
Requires Python: >=3.8
Keywords: quantum, machine learning, pytorch, cuquantum, adjoint differentiation

# torchqml

PyTorch Quantum Machine Learning with cuQuantum - Fast Adjoint Differentiation

## Features

- **Adjoint Differentiation**: O(G) gradient calculation using cuQuantum's `custatevec` and optimized C++ kernels.
- **PyTorch Native**: Fully integrated with `torch.autograd` and `torch.nn`.
- **High Performance**: Custom C++/CUDA extension reusing cuStateVec/cuBLAS handles for minimize overhead.

## Performance
TorchQML outperforms PennyLane's `lightning.gpu` backend significantly on NVIDIA GPUs (measured on T4):

| Qubits | Layers | TorchQML (ms) | PennyLane (ms) | Speedup |
| :--- | :--- | :--- | :--- | :--- |
| 4 | 5 | 5.72 | 16.99 | **3.0x** |
| 8 | 10 | 13.18 | 48.69 | **3.7x** |
| 12 | 10 | 24.29 | 69.65 | **2.9x** |

## Installation

```bash
pip install .
```

## Usage

```python
import torch
import torchqml as tq

# Build circuit
qc = tq.QuantumCircuit(2)
qc.h(0)
qc.ry(0, param_index=0)
qc.cx(0, 1)

# Parameters
params = torch.tensor([[0.5]], requires_grad=True)

# Expectation
exp_val = qc.expectation(params, tq.Z(0))

# Backward
exp_val.backward()
print(params.grad)
```
python-maestro 0.2.0
A lightweight orchestrator for managing Python tasks
License: MIT
Requires Python: >=3.12
Keywords: orchestration, task-scheduler, python, CLI

**pymaestro** is a lightweight Python orchestration framework for defining and executing tasks.
It supports multiple ways of interacting with the system:

- A **programmatic (functional) API** for explicit and dynamic job registration
- A **declarative, decorator-based API** for concise and readable task definitions
- A **CLI interface** for managing and executing jobs without writing orchestration code

All approaches are built on the same underlying execution model, allowing users to choose
the style that best fits their workflow.

---

### Why pymaestro is Lightweight

`pymaestro` is designed to be lightweight by construction.
It runs entirely in-process and does not require a scheduler daemon, persistent metadata store,
message broker, or external services. Tasks are explicitly added, inspected, and executed
by the user, making the execution model transparent and easy to reason about.

Unlike full-scale orchestration platforms that target distributed and long-running
pipelines, `pymaestro` focuses on simplicity, portability, and low operational overhead.
By deliberately limiting its scope, it covers the majority of common orchestration
use cases while remaining easy to build, deploy, and extend.

---

### Supported Functionality

Maestro currently supports a concise set of core orchestration features:

- Add tasks from scripts, Python callables, or async callables
- Assign optional names, arguments, and parallel execution groups
- Remove scheduled tasks by name or insertion order
- Inspect the current execution plan and task ordering
- Execute tasks sequentially or in parallel, depending on grouping
- Serialize and deserialize the orchestration state to and from JSON
- Interact via a CLI or an interactive shell for iterative workflows


### Installation

To install the **core library** from PyPI:

```bash
  pip install python-maestro
```

To install the core library with CLI support:
```bash
  pip install python-maestro[cli]
```
bcodparser 1.0.1
Allows you to decode the Bluetooth Class of Device (CoD) field and interpret major, minor, and service classes.
License: MIT

# bcodparser
Allows you to decode the Bluetooth Class of Device (CoD) field and interpret major, minor, and service classes.

# ⚙️ Installation
```
pip install bcodparser
```

# 🖊️ Example
> *Here is an example of use with [pybluez](https://github.com/pybluez/pybluez)*

**Code**
```python
from bcodparser import decode
import bluetooth # pybluez

# Scan Bluetooth
print("Scanning bluetooth...")

nearby_devices = bluetooth.discover_devices(
    lookup_names=True,
    lookup_class=True
)

print(f"Found {len(nearby_devices)} devices\n")

# List the Bluetooth devices with informations
for address, name, classe in nearby_devices:
    decoded = decode(classe)
    
    print(f"Name: {name}")
    print(f"Adress: {address}")
    
    print("Major Device Class: ", decoded["majorClass"])
    print("Minor Device Class: ", ", ".join(decoded["minorClass"]))
    print("Service Device Classes: ", ", ".join(decoded["serviceClass"]))
    
    print("\n")
```

**Output**
```
Scanning bluetooth...
Found 3 devices

Name: My Headphone
Adress: 11:22:33:44:55:66
Major Device Class:  Audio/Video
Minor Device Class:  Wearable Headset Device
Service Device Classes:  Rendering, Audio


Name: My Phone
Adress: 77:88:99:AA:BB:CC
Major Device Class:  Phone
Minor Device Class:  Smartphone
Service Device Classes:  Networking, Capturing, Object Transfert, Telephony


Name: My Computer
Adress: DD:EE:FF:11:22:33
Major Device Class:  Computer
Minor Device Class:  Laptop
Service Device Classes:  Networking, Capturing, Audio
```

View PyPi : https://pypi.org/project/bcodparser/
View GitHub : https://github.com/Lou-du-Poitou/bcodparser/
llm-mem-ai 0.1.2
A LLM Memory Cache package
License: MIT
Requires Python: >=3.7
Keywords: memory, llm, agent

# llm-mem

## 项目简介

- 想制作一个简单可行的对话存储的记忆模块，可以分层，可以混合检索，当用户提问时可以命中局部记忆内容
- 这里使用的模型为阿里云百炼，dashscope.aliyuncs.com，其他平台会慢慢兼容

## 安装方法

## 使用示例

```python
# How to run
def test_llm_memory():
    memory = MemoryAI()
    
    question = "我想了解一下Springboot能做什么呢？"
    user_id = "jerry.s.d"
    session_id = ""

    # 获取长期记忆 question_context 为上下文的消息列表(可根据情况自行加工)
    question_context, session_id, summary_result, message_ids = memory.get_memory(
        question, user_id, session_id
    )

    # TODO 这里是正常调用语言模型的逻辑，或者智能体， 使用question_context 构建自己的上下文即可
    # 开始提问
    answer_res = "Do some function call LLM "

    # 追加新的信息进入长期记忆
    memory.set_memory(
        question, answer_res, user_id, session_id, message_ids, summary_result
    )
```

```conf
# .env相关配置
# =========== 模型相关配置 ===========
# dashscope 目前只兼容了dashscope
PLATFORM = "dashscope"
API_KEY ="sk-"
BASE_URL="https://dashscope.aliyuncs.com/compatible-mode/v1"
LLM_MODEL="qwen-plus"
EMBEDDING_MODEL="text-embedding-v4"
EMBEDDING_MODEL_DIM=1024

# =========== 向量数据库相关配置 ===========
# qdrant 目前只兼容了qdrant
VECTOR = "qdrant"
QDRANT_URL = "http://localhost:6333"
QDRANT_API_KEY = "xxxxx"
QDRANT_COLLECTION = "mem_collection"
# =========== Mongo文档库相关配置 ===========
# 开启后自动存储聊天内容, TODO 对于False的情况，还没有进行测试
OPEN_CONTEXT_SAVE = "True"
# mongodb://chat:chat@localhost:27017/chat_database?authSource=admin
MONGO_URL = "mongodb://mongo:mongo@localhost:27017"
MONGO_DB = "mem_database"
MONGO_AUTH = "admin"
MONGO_COLLECTION = "mem_collection"

# 其他配置
DEBUG="False"
```

## Collaborate with your team