semvec/pypi-packages huggingface dataset:
logrelay 0.2.0
Error log relay using various methods (LINE, Mail, etc.)
Requires Python: >=3.8

# LogRelay
LogRelayは、ログメッセージをLINE, Slack, Discord, メールに転送するためのライブラリです。
※ 現在はLINEのみで順次追加予定です。

## プロジェクト情報

- **名前**: logrelay
- **バージョン**: 0.1.0
- **説明**: エラーログをLINEやメールなどの方法でリレーするライブラリ
- **依存関係**:
  - requests>=2.32.3
- **Pythonバージョン**: >= 3.8

## インストール
```sh
pip install logrelay
```

## 使用方法 (LINE)
### 環境変数

1. [LINE Developers](https://developers.line.biz/ja/) でチャネルを作成
1. プロバイダー（または新規作成）を選択
1. Messaging API チャネルを作成
1. ｢チャネルアクセストークン（長期）｣ を取得
    - トップ > ユーザー名 > サービス名 > Messaging API設定 > チャネルアクセストークン > チャネルアクセストークン（長期）
1. QRコードをスマートフォンで読み込み友だち追加する
    - トップ > ユーザー名 > サービス名 > Messaging API設定 > ボット情報 > QRコード
1. ｢あなたのユーザーID｣を取得
    - トップ > ユーザー名 > サービス名 > チャネル基本設定 > 基本情報 > あなたのユーザーID
1. 環境変数に値を割り当てる
    - line_access_token: チャネルアクセストークン（長期）
    - user_id: あなたのユーザーID

### 使用例
```python
import requests
from logrelay import LogRelay

line_access_token = "YOUR_LINE_ACCESS_TOKEN"
user_id = "TARGET_USER_ID"

log_relay = LogRelay(line_access_token, user_id)

try:
    response = requests.get("https://example.com/api")
    response.raise_for_status()
except requests.exceptions.RequestException as e:
    error_message = f"<Example_Service>Error: {str(e)}"
    log_relay.send_line_message(error_message)
    print(error_message)
```
llmtk 0.1.0
Type-safe function registration and validation for LLM function calls
Requires Python: >=3.9
Keywords: llm, openai, function-calling, type-safety, validation, pydantic

# llmtk (LLM Toolkit)

> Stop writing JSON schemas for your AI functions. Let Python types do it for you. ⚡️

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)

## Features

- 🎯 **Zero Schema Maintenance**: Your Python types become your OpenAI schemas
- ✨ **Type Safety**: Catch invalid AI responses before they break your code
- 📝 **Rich Types**: Support for Pydantic models, lists, and custom types
- 🚀 **Quick Setup**: One decorator is all you need

## Without llmtk, you write this:


```python
# Define your function
def get_weather(city: str) -> str:
    return f"Weather in {city}: Sunny"

# Manually maintain OpenAI function schema
weather_schema = {
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get weather information for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Name of the city"
                }
            },
            "required": ["city"]
        }
    }
}

# Hope the schema stays in sync with your function
tools = [weather_schema]
```

## With llmtk, just write this:

```python
from llmtk import register_function, get_openai_tools

@register_function
def get_weather(city: str) -> str:
    """Get weather information for a city"""
    return f"Weather in {city}: Sunny"

# Schema automatically generated from your Python types
tools = get_openai_tools()
```

## Quick Start

```bash
pip install llmtk
```

```python
from llmtk import register_function, call_function, get_openai_tools

@register_function
def calculate_price(quantity: int, unit_price: float) -> float:
    """Calculate total price for items"""
    return quantity * unit_price

# Get schema for OpenAI
tools = get_openai_tools()

# Use with OpenAI
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Calculate price for 5 items at $10 each"}],
    tools=tools,
    tool_choice="auto"
)

# Safe function execution with validation
result = call_function(
    response.choices[0].message.tool_calls[0].function.name,
    response.choices[0].message.tool_calls[0].function.arguments
)

if isinstance(result, tuple):
    print(f"Validation error: {result[0]}")
else:
    print(f"Total: ${result:.2f}")  # Total: $50.00
```
## License

MIT License - feel free to use in your projects!
whiskerrag_toolkit 0.0.1a1
A utility package for RAG operations
Requires Python: <4.0,>=3.8.1

# WhiskerRAG-toolkit

[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)
[![Python Version](https://img.shields.io/pypi/pyversions/whiskerRAG)](https://pypi.org/project/whiskerRAG/)
[![PyPI version](https://badge.fury.io/py/whiskerRAG.svg)](https://badge.fury.io/py/whiskerRAG)

WhiskerRAG-toolkit 是为 PeterCat 和 Whisker 项目开发的 RAG（Retrieval-Augmented Generation）工具包，提供完整的 RAG 相关类型定义和方法实现。

## 特性
- 领域建模类型
- 插件接口描述
- Github、S3 数据源加载器
- OpenAI Emedding

## 安装

使用 pip 安装：

```bash
pip install whiskerRAG
```

## 快速开始

该工具包提供两个核心模块：whiskerrag_utils 和 whiskerrag_types

```
from whiskerrag_utils.github.fileLoader import GithubFileLoader
from whiskerrag_types.interface import DBPluginInterface
from whiskerrag_types.model import Knowledge, Task, Tenant, PageParams, PageResponse
```

## 开发指南

环境配置
本项目使用 Poetry 进行依赖管理。首先安装 Poetry：

```
pip install poetry
```

安装依赖

```
poetry install
```

运行测试

```
# 运行单元测试
poetry run pytest


# 生成测试覆盖率报告
poetry run pytest --cov

# 生成 HTML 格式的覆盖率报告
poetry run pytest --cov --cov-report=html
open htmlcov/index.html
```

## 构建与发布

```
# 构建项目
poetry build

# 发布到 PyPI
poetry publish
```
ioutrack-rs 0.4.0
IOU-based tracking algorithms (SORT & Bytetrack) implemented in Rust
Requires Python: >=3.7

# IOU Track

[![PyPI](https://img.shields.io/pypi/v/ioutrack_rs.svg?style=flat-square)](https://pypi.org/project/ioutrack_rs/)

Python package for IOU-based tracking ([SORT](https://arxiv.org/abs/1602.00763) & [ByteTrack](https://arxiv.org/abs/2110.06864)) written in Rust by [PaulKlinger](https://github.com/PaulKlinger). This is a modified version that can also return the indices of the boxes kept, so that it can be used with Ultralytics.

## Usage in Ultralytics

1. Install `pip install ioutracker_rs`
2. Patch Ultralytics tracker to use:

```python
from ultralytics import YOLO, ASSETS
import numpy as np
from ioutrack import ByteTrack
import ultralytics.trackers.byte_tracker as byte_tracker

# Monkey-patch with Rust based tracker
tracker = ByteTrack(max_age=5, min_hits=2, init_tracker_min_score=0.25)
def update(self, dets, img):
    boxes, cls = dets.data[:,:5], dets.data[:, -1:]
    tracks = tracker.update(boxes, return_indices=True)
    idxs = tracks[:, -1:].astype(int)
    confs = boxes[idxs.flatten(), 4:5]
    tracks = np.hstack((tracks[:, :-1], confs, cls[idxs.flatten()], idxs))
    return tracks
byte_tracker.BYTETracker.update = update

# Use normally after this. No need to run previous steps again
model = YOLO("yolo11n.pt")
results = model.track(ASSETS / "bus.jpg", tracker="bytetrack.yaml", persist=True, verbose=False)
```

## Latency comparison

```python
import cv2
import time
from ultralytics import YOLO, ASSETS
from ioutrack import ByteTrack
import ultralytics.trackers.byte_tracker as byte_tracker
import numpy as np

def update(self, dets, img):
    global tracker
    boxes, cls = dets.data[:,:5], dets.data[:, -1:]
    tracks = tracker.update(boxes, return_indices=True)
    idxs = tracks[:, -1:].astype(int)
    confs = boxes[idxs.flatten(), 4:5]
    tracks = np.hstack((tracks[:, :-1], confs, cls[idxs.flatten()], idxs))
    return tracks

img = cv2.imread(ASSETS / "bus.jpg")
original_update = byte_tracker.BYTETracker.update 

def test_latency(patch=False):
    model = YOLO("yolo11n.pt")
    if patch:
        global tracker
        tracker = ByteTrack(max_age=5, min_hits=2, init_tracker_min_score=0.25)
        byte_tracker.BYTETracker.update = update
    else:
        byte_tracker.BYTETracker.update  = original_update
    model.track(img, tracker="bytetrack.yaml", persist=True, verbose=False) # warmup
    s = time.perf_counter()
    results = model.track(img, tracker="bytetrack.yaml", persist=True, verbose=False)
    e = time.perf_counter()
    infer = sum(results[0].speed.values())
    print(results[0].speed)
    print("Infer:", infer)
    print("Tracker:", ((e - s) * 1000) - infer)
    print("End2End:", (e - s) * 1000)

print("Ultralytics ByteTrack")
test_latency(False)
print("Rust ByteTrack")
test_latency(True)
```

| Tracker Type       | Tracker (ms) |
|--------------------|--------------|
| Default ByteTrack  | 2.2130       |
| Rust ByteTrack     | 0.7089       |