semvec/pypi-packages huggingface dataset:
libgcs 1.0.4
Basic library for GCS implementations
Requires Python: >=3.10

# LIBGCS

## Plans

- ✅ Logging
- ✅ Threading
- ✅ Message Queue
- ✅ Serial Port Management
- ✅ Preference Tree (JSON and TOML to Tree/Dict)
- ✅ File: Base file reader and writer
- ❌ File: CSV and KML writer
- ❌ Basic GIS Library
- ❌ Parser: CSV or similar
- ❌ Parser: Pattern
- ❌ Parser: Bitstream
visualize-tools 0.0.3
A set of tools for visualization
Requires Python: >=3.11

# visualize_tools: A set of tools for visualization
Tools are adapted from visualization code written and used in researches with some (insufficient) rewrite and cleanup. Structure and API are subject to change. A minimal set of documentation is included, but digging into the source code may be required to use the API.  
## Commandline tools
Currently a single commandline tool is provided.
### img-set-diff
A tool to visualize the difference between two corresponding image sets, with an optional reference image set (the ground truth). Typically useful when analyzing and/or comparing performance of image compressing/reconstructing method(s).
oraczenhq-zenbroker 1.0.0
Zenbroker client

# Zenbroker Client Example

This project demonstrates how to use the Zenbroker client library to publish messages to channels.

## Installation

```bash
pip install zenbroker
```

## Configuration

You need to configure your Zenbroker client with your application ID:

```python
from zenbroker import ZenbrokerClient

client = ZenbrokerClient(
    application_id="YOUR_APPLICATION_ID",
    base_url="https://broker.oraczen.xyz"
)
```

## Usage

### Publishing a single message

```python
resp = client.publish(
    channel="CHANNEL-ID",
    data={
        "key": "value",
        "message": "hello"
    }
)
```

## Notes

- Replace `YOUR_APPLICATION_ID` with your actual application ID
- Replace `CHANNEL-ID` with your target channel ID when publishing messages
oraczenhq-authorization 0.0.3
Authorization client

Thank you for the update.  
With your new changes, **the usage pattern of your library's singleton service has changed**.

Now, before calling `OpenFgaServiceSingleton.get_service()`, you need to **set the configuration** via `OpenFgaServiceSingleton.config = <YourConfigInstance>`.  
No configuration argument is accepted in `get_service()` anymore.

---

## ⏩ Updated Basic Setup & Usage

### Step 1. Set configuration and initialize

```python
from your_library import OpenFgaConfig, OpenFgaServiceSingleton

# 1. Create configuration as before
fga_config = OpenFgaConfig(
    store_name="my-store",
    model_version="1",
    model_obj={},  # your FGA model dict
    api_url="http://localhost:8080",  # or your FGA API endpoint
    redis_host="localhost",
    redis_password=None,
    redis_port="6379",
)

# 2. Set configuration on the singleton class BEFORE get_service()
OpenFgaServiceSingleton.config = fga_config

# 3. Now get the service
service = OpenFgaServiceSingleton.get_service()

# 4. Continue as before
await service.setup_store()
await service.setup_auth_model()
auth_model = await service.read_auth_model()
print(auth_model)
```

---

### Example Usage: List objects

```python
# Get the (already initialized) singleton service
fga = OpenFgaServiceSingleton.get_service()

# List object IDs of type 'doc' where 'user:alice' has 'reader' access
object_ids = await fga.list_objects("user:alice", "reader", "doc")
print(object_ids)
```

---

## 🔍 What changed?

- You **MUST** set `OpenFgaServiceSingleton.config = <YourConfig>` before you try to instantiate the service.
- If `get_service()` is called before `.config` is set, you get an Exception:
  > "OpenFgaConfig must be set before getting the service instance."
- Passing config in `get_service(config)` is **no longer supported**.

---

## 📦 Reusable Example

```python
from your_library import OpenFgaConfig, OpenFgaServiceSingleton

fga_config = OpenFgaConfig(
    store_name="my-store",
    model_version="1",
    model_obj={},
    api_url="http://localhost:8080"
)
OpenFgaServiceSingleton.config = fga_config

service = OpenFgaServiceSingleton.get_service()
await service.setup_store()
await service.setup_auth_model()
auth_model = await service.read_auth_model()

object_ids = await service.list_objects("user:alice", "reader", "doc")
print(object_ids)
```

---

**Be sure to always set `.config` before `.get_service()`!**

---

Let me know if you would like an updated full documentation, code template, or anything else!
wframe 0.1.10
一个轻量级的 Python Web 框架
Requires Python: >=3.7

# WFrame

一个轻量级的 Python Web 框架，专注于简单性和可扩展性。

## 特性

- 轻量级路由系统
- 中间件支持
- 会话管理
- JWT 认证
- CSRF 保护
- 数据库集成（SQLAlchemy）
- OpenAPI 文档
- 请求速率限制
- 错误处理

## 安装

```bash
pip install wframe
```

## 快速开始

1. 创建新项目：

```bash
wframe new myapp
cd myapp
```

2. 运行应用：

```bash
wframe run
```

## 示例代码

```python
from wframe import WebFramework, Response
from wframe.security import token_required

app = WebFramework()

@app.route('/')
def index(request):
    return Response('Hello, WFrame!')

@app.route('/api/profile')
@token_required
def profile(request):
    return Response({
        'username': request.user.username
    })

if __name__ == '__main__':
    app.run()
```

## 主要功能

### 路由

```python
@app.route('/users/<id>', methods=['GET', 'POST'])
def user(request, id):
    return Response(f'User {id}')
```

### 中间件

```python
def logger_middleware(request):
    print(f'Request: {request.method} {request.path}')
    return request

app.use(logger_middleware)
```

### 数据库

```python
from wframe.models import User

@app.route('/users')
def users(request):
    db = next(get_db())
    users = db.query(User).all()
    return Response([user.username for user in users])
```

### 认证

```python
@app.route('/login', methods=['POST'])
def login(request):
    data = json.loads(request.get_data())
    token = create_access_token({'username': data['username']})
    return Response({'token': token})
```

## 文档

访问 `http://localhost:5000/docs` 查看 API 文档。

## 许可证

MIT License
poc-project-dl 0.1.0
dlt pipeline POC
Requires Python: >=3.12


## Project Overview

This repository is a simple showcase Python package demonstrating how to use [dlt](https://dlthub.com/) for data extraction and loading. The package is structured to extract data from sources and load it into parquet, DuckDB and etc, serving as a reference for integrating dlt in your own projects.

## Getting Started

### Clone and run 
import package from pypi or clone and run
```bash
git clone https://github.com/e-espootin/poc_dlthub
cd poc_dlthub
make run
```



The main dlt pipeline file is located at:

```
src/app/ingest/
```
- ignore : src\app\utils

Refer to this path when running or modifying the pipeline.

## Managing Secrets

Sensitive information such as API keys or credentials should be managed securely:

- **GitHub Actions:** Store secrets using [GitHub Secrets](https://docs.github.com/en/actions/security-guides/encrypted-secrets).
- **Databricks:** Use [Databricks Secret Scopes](https://docs.databricks.com/en/security/secrets/index.html) for secure storage.



### connect to duckdb
```bash
duckdb .../rest_api_github.duckdb
show all tables;
```
---

### create dlt from scratch
```bash
uv init
uv venv --python 3.12
uv pip install -U dlt
dlt --version
dlt init rest_api duckdb
```
llm-tools-searxng 0.1.1
A tool to search the web using SearXNG.
Requires Python: >=3.9

# llm-tools-searxng

[![PyPI](https://img.shields.io/pypi/v/llm-tools-searxng.svg)](https://pypi.org/project/llm-tools-searxng/)
[![Changelog](https://img.shields.io/github/v/release/justyns/llm-tools-searxng?include_prereleases&label=changelog)](https://github.com/justyns/llm-tools-searxng/releases)
[![Tests](https://github.com/justyns/llm-tools-searxng/actions/workflows/test.yml/badge.svg)](https://github.com/justyns/llm-tools-searxng/actions/workflows/test.yml)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/justyns/llm-tools-searxng/blob/main/LICENSE)

A tool to search the web using SearXNG search engines.

## Installation

Install this plugin in the same environment as [LLM](https://llm.datasette.io/).
```bash
llm install llm-tools-searxng
```

## Configuration

By default, the tool does not have a default SearXNG URL set. You can configure it in one of two ways:

### Using environment variables

```bash
export SEARXNG_URL=https://your-searxng-instance.com
export SEARXNG_METHOD=GET  # or POST (default)
```

### Using LLM's built-in key management

```bash
llm key set searxng_url https://your-searxng-instance.com
```

**Note:** Public SearXNG instances typically don't allow API access or JSON output.

## Usage

### Simple search function

Use the `searxng_search` function for basic web searches:

```bash
llm --tool searxng_search "latest developments in AI" --tools-debug
```

### With LLM chat

This plugin works well with `llm chat`:

```bash
llm chat --tool searxng_search --tools-debug
```

### Python API usage

```python
import llm
from llm_tools_searxng import SearXNG, searxng_search

# Using the simple function
model = llm.get_model("gpt-4.1-mini")
result = model.chain(
    "What are the latest developments in renewable energy?",
    tools=[searxng_search]
).text()
```

## Development

To set up this plugin locally, first checkout the code. Then create a new virtual environment:

```bash
cd llm-tools-searxng
uv sync --all-extras
```

Now install the dependencies and test dependencies:

```bash
llm install -e '.[test]'
```

To run the tests:

```bash
uv run python -m pytest
```
alireza-esp-weatherlib 0.0.1
A simple package for getting weather information from an API.
Keywords: weather, API

# 🌦️ Weather Info CLI (Python)

This is a simple command-line tool written in Python that allows you to retrieve **current**, **past**, and **forecast** weather data using the [WeatherAPI](https://www.weatherapi.com/).

## 📦 Features

- 🔍 Search for cities by name
- 📍 Get **current weather** conditions for a city
- 📊 Get **weekly weather** including:
  - Weather data for the past 3 days
  - Today’s weather
  - Forecast for the next 2 days
- ✅ Automatic error handling for connection and API issues

---

## 🧰 Requirements

Make sure you have the following Python packages installed:

```bash
pip install requests
streamlit-tetrascience-ui 0.1.1
Tetrascience UI components for Streamlit
Requires Python: >=3.9
Keywords: streamlit, tetrascience, ui, components

# streamlit-tetrascience-ui

Tetrascience UI components for [Streamlit](https://streamlit.io/).

## Installation

```bash
pip install streamlit-tetrascience-ui
```

## Usage

```python
import streamlit as st
import streamlit_tetrascience_ui as ui

# Example: Simple interactive component
name = st.text_input("Enter your name:", value="Streamlit")
count = ui.my_component(name, key="example")
st.write(f"Button clicked {count} times!")

# Example: Histogram component
hist_data = [
    {"label": "A", "values": [1, 2, 3]},
    {"label": "B", "values": [4, 5, 6]},
]
ui.histogram_component(
    name="My Histogram",
    dataSeries=hist_data,
    width=400,
    height=300,
    title="Histogram Example",
    xTitle="Bins",
    yTitle="Frequency",
    bargap=0.2,
    showDistributionLine=True,
    key="hist1"
)
```

## Features

- Custom Streamlit components for Tetrascience UI
- Easy integration and usage
- Example components: `my_component`, `histogram_component`

## License

MIT
chinese-lunar-calendar-converter 0.1.0
A Python package for converting between Gregorian and Lunar calendars.
Requires Python: >=3.6

# chinese_lunar_calendar_converter

`chinese_lunar_calendar_converter` 是一个用于公历和农历之间相互转换的 Python 包，并提供万年历打印功能。

## 安装

您可以通过 pip 安装 `chinese_lunar_calendar_converter`：

```bash
pip install chinese_lunar_calendar_converter
```

## 使用示例

### 公历转农历

```python
from chinese_lunar_calendar_converter import solar_to_lunar

gregorian_date = "2025-01-29"
lunar_info = solar_to_lunar(gregorian_date)
print(f"{gregorian_date} 为农历：{lunar_info[0]}年 {lunar_info[1]}月 {lunar_info[2]}日 {lunar_info[3]}{lunar_info[4]}")
# 输出示例: 2025-01-29 为农历：甲辰年 丁丑月 戊戌日 正月初一
```

### 农历转公历

```python
from chinese_lunar_calendar_converter import lunar_to_solar

lunar_year = 2025 # 农历年份
lunar_date_str = "正月初一"
gregorian_info = lunar_to_solar(lunar_year, lunar_date_str)
print(f"农历{lunar_year}年{lunar_date_str} 为公历：{gregorian_info[0]}-{gregorian_info[1]:02d}-{gregorian_info[2]:02d}")
# 输出示例: 农历2025年正月初一 为公历：2025-01-29
```

### 打印万年历

```python
from chinese_lunar_calendar_converter import print_perpetual_calendar

# 打印2024年全年日历
print_perpetual_calendar(2024)

# 打印2024年3月日历
print_perpetual_calendar(2024, 3)
```

## API 接口

### `solar_to_lunar(gregorian_date_str: str) -> Tuple[str, str, str, str, str]`

将公历日期字符串转换为农历日期元组。

*   **参数**:
    *   `gregorian_date_str` (str): 公历日期字符串，格式为 "YYYY-MM-DD"。
*   **返回**:
    *   `Tuple[str, str, str, str, str]`: 包含农历年干支、月干支、日干支、农历月名和农历日名的元组。
        例如: `("甲辰", "丁丑", "戊戌", "正月", "初一")`
*   **可能抛出的异常**:
    *   `ValueError`: 如果输入日期格式不正确或日期无效。

### `lunar_to_solar(lunar_year: int, lunar_date_str: str) -> Tuple[int, int, int]`

将农历日期转换为公历日期元组。

*   **参数**:
    *   `lunar_year` (int): 农历年份（例如：1999）。
    *   `lunar_date_str` (str): 农历日期字符串，格式为 "[闰]月名日名" (例如 "五月十七" 或 "闰五月十七")。也可以是干支日名 (例如 "癸丑日")。
*   **返回**:
    *   `Tuple[int, int, int]`: 包含公历年、月、日的元组。
        例如: `(2025, 1, 29)`
*   **可能抛出的异常**:
    *   `ValueError`: 如果农历日期格式不正确或日期无效。

### `print_perpetual_calendar(year: int, month: int = 0) -> None`

打印指定年份（或月份）的万年历（农历及公历对照）。

*   **参数**:
    *   `year` (int): 公历年份。
    *   `month` (int, optional): 公历月份 (1-12)。如果为 0，则输出全年日历。默认为 0。
*   **可能抛出的异常**:
    *   `ValueError`: 如果年份为 0。

## 贡献

欢迎贡献！如果您有任何建议或发现 bug，请随时提交 issue 或 pull request。

## 许可证

本项目采用 MIT 许可证。详见 [LICENSE](LICENSE) 文件。
mcp-server-youtube-info 0.1.8
A YouTube information retrieval server implementation for Model Context Protocol (MCP)
Requires Python: >=3.10
Keywords: automation, llm, mcp, model-context-protocol, youtube

# MCP YouTube Info Server

This project is a server implementation that retrieves YouTube video information using the Model Context Protocol (MCP). It utilizes the FastMCP framework to provide functionality for fetching YouTube video data.

## Available Tools

### youtube_metainfo

Retrieves metadata for a YouTube video.

- `video_id` (string, required): YouTube video ID

  - Returns: JSON containing metadata such as title, description, view count, publication date, etc.

### youtube_thumbnail_url

Retrieves the URL of a YouTube video's thumbnail image.

- `video_id` (string, required): YouTube video ID

  - Returns: URL of the thumbnail image

### youtube_thumbnail_image

Retrieves the image data from a YouTube video.

- `video_id` (string, required): YouTube video ID

  - Returns: Thumbnail image

## Installation

### Using `uv` (recommended)

No special installation is needed when using `uv`. You can run `mcp-server-youtube-info` directly with `uvx`.

### Using PIP

Alternatively, you can install `mcp-server-youtube-info` using pip:

```
pip install mcp-server-youtube-info
```

After installation, you can run it as a script like this:

```
mcp-server-youtube-info
```

## Configuration

### Configure for Claude.app

Add to your Claude settings:

<details>
<summary>Using uvx</summary>

```json
{
  "mcpServers": {
    "youtube-info": {
      "command": "uvx",
      "args": ["mcp-server-youtube-info"]
    }
  }
}
```

</details>

### Configure for VS Code

For quick installation, use one of the one-click install buttons below...

[![Install with UV in VS Code](https://img.shields.io/badge/VS_Code-UV-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=youtube-info&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22mcp-server-youtube-info%22%5D%7D)

### Command-Line Options

You can specify the following options when running the server:

- `--sse`: Enable SSE transport

  - Choices: `on`, `off`
  - Default: `off`
  - Description: Enables SSE transport when set to "on"

- `--host`: Host to bind the server to

  - Default: `localhost`
  - Description: Specifies the host address the server will bind to

- `--port`: Port to bind the server to

  - Type: Integer
  - Default: `8000`
  - Description: Specifies the port number the server will bind to

- `--log-level`: Set the log level

  - Choices: `debug`, `info`, `warning`, `error`
  - Default: `info`
  - Description:

    - debug: Detailed debug information
    - info: General runtime information (default)
    - warning: Potential issues that do not affect execution
    - error: Errors encountered during execution