semvec/pypi-packages huggingface dataset:
bibtex-formatter 1.4.0
Format

# BibTeX Formatter

![GitHub repo size](https://img.shields.io/github/repo-size/Nickydusk/bibtex-formatter) ![PyPI](https://img.shields.io/pypi/v/bibtex-formatter) ![PyPI - Downloads](https://img.shields.io/pypi/dm/bibtex-formatter) ![GitHub](https://img.shields.io/github/license/Nickydusk/BibTex-Formatter)

Help generate citations that meet the requirements for conference and journal submissions.

## Call for Contributions

Completing standardized names can make matching more precise. We would greatly appreciate it if you can fill more standard conference / journal names or correct wrong names in `bfm/data/others.txt`. Please use pull requests to submit your changes.

## Quick Installation

Install from [PyPi](https://pypi.org/project/bibtex-formatter/):

```bash
pip install -U bibtex-formatter
```

Alternatively, you can also install the latest version (not stable) from github:

```bash
pip install -U git+https://github.com/Nickydusk/BibTeX-Formatter.git@main
```

## Usage

```bash
bfm IN_FILE
```

Positional args:

- `IN_FILE`: Choose the input .bib file

Options (Please see `bfm --help` for more details):

- `-o OUTPUT`,`--output OUTPUT`: Choose the output .bib file, default to `out.bib`
- `-l LOG`,`--log LOG`: Choose the output log file, default to `logs.txt`
<!-- - `-d`, `--use_database`: Do online check with NJU database, default to False (The feature may override correct entries, use with caution!) -->

## Features

- [x] Remove duplicate citations (keep the first occurrence), log what is removed
- [x] Simplify keys according to citation type (e.g., `@inproceedings -> [author, title, booktitle, pages, year]`)
- [x] Standardize conference / journal names (e.g., `Advances in Neural Information Processing Systems`)
- [x] Standardize "pages" to `pages = {start-end}`, alert if more or less timestamps.
- [x] Standardize arXiv citations to **google scholar style**
  - [x] arXiv export bibtex -> google scholar style
  - [x] dblp bibtex -> google scholar style
- [ ] Online check contents, make sure they are up to date
mcp-server-copilot 0.1.3
A Meta Model Context Protocol (MCP) server that seamlessly scales LLMs to 1000+ MCP servers through automatic routing.
Requires Python: >=3.10
Keywords: mcp, copilot, router

# MCP Server Copilot

[![python](https://img.shields.io/badge/-Python_3.10_%7C_3.11_%7C_3.12-blue?logo=python&logoColor=white&style=flat-square)](https://github.com/tshu-w/lightning-template)
![PyPI - Version](https://img.shields.io/pypi/v/mcp-server-copilot?style=flat-square)
[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json&style=flat-square)](https://github.com/astral-sh/uv)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=flat-square)](https://github.com/astral-sh/ruff)

A meta Model Context Protocol (MCP) server that seamlessly scales LLMs to 1000+ MCP servers through automatic routing without expose all servers and tools to LLMs directly.

<p align="center">
  <img src="https://github.com/user-attachments/assets/7bb3ac79-6706-4fc5-8dab-2f0a3e5b981c" alt="mcp_copilot" style="max-width:100%; height:auto; width:500px;">
</p>

## Components

### Tools

- `router-servers`: Route user query to appropriate MCP servers.
  - `query` (string, required): User's query to find relevant servers.
  - `top_k` (integer, optional): Maximum number of servers to return (default: 5).

- `route-tools`: Route user query to appropriate MCP tools across all servers.
  - `query` (string, required): User's query to find relevant tools.
  - `top_k` (integer, optional): Maximum number of tools to return (default: 5).

- `execute-tool`: Execute a specific tool on a specific server based on previous routing results.
  - `server_name` (string, required): Name of the server hosting the tool.
  - `tool_name` (string, required): Name of the tool to execute.
  - `params` (object, optional): Parameters to pass to the tool, as a key-value dictionary (default: null or empty object).

## Installation

### Using uv (recommended)

When using [`uv`](https://docs.astral.sh/uv/) no specific installation is needed. We will
use [`uvx`](https://docs.astral.sh/uv/guides/tools/) to directly run *mcp-server-copilot*.

### Using PIP

Alternatively you can install `mcp-server-copilot` via pip:

```
pip install mcp-server-copilot
```

After installation, you can run it as a script using:

```
python -m mcp_server_copilot
```

## Configuration

Copy `config/config.sample.json` to `~/.config/mcp-server-copilot`

Add to your MCP Client settings:

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

```json
"mcpServers": {
  "copilot": {
    "command": "uvx",
    "args": ["mcp-server-copilot", "--config", "~/.config/mcp-server-copilot/config.json"]
  }
}
```
</details>

<details>
<summary>Using pip installation</summary>

```json
"mcpServers": {
  "copilot": {
    "command": "python",
    "args": ["-m", "mcp_server_copilot", "--config", "~/.config/mcp-server-copilot/config.json"]
  }
}
```
</details>

## TODOs

- [ ] Manage Servers more easily
- [ ] Add Semantic Routing
- [ ] Add Planning Capabilities
edwh-web2py-effdted-prio-grid 0.6.1
Web2py plugin for a effective dated grid with priority support.
Requires Python: >=3.10
Keywords: effdt, effective-dated, grid, web2py

# edwh_web2py_effdted_prio_grid

[![PyPI - Version](https://img.shields.io/pypi/v/edwh-web2py-effdted-prio-grid.svg)](https://pypi.org/project/edwh-web2py-effdted-prio-grid)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/edwh-web2py-effdted-prio-grid.svg)](https://pypi.org/project/edwh-web2py-effdted-prio-grid)

-----

**Table of Contents**

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install edwh-web2py-effdted-prio-grid
```

## Usage
```python
from edwh_web2py_effdted_prio_grid import effective_dated_grid

effective_dated_grid(db.organisations)

```

## License

`edwh-web2py-effdted-prio-grid` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
pybriiv 0.1.1
Python library for communicating with Briiv Air Purifier devices
Requires Python: >=3.9

# PyBriiv

A Python library for communicating with Briiv Air Purifier devices.

## Installation

```bash
pip install pybriiv
```

## Usage

```python
import asyncio
from pybriiv import BriivAPI

def select_device(devices):
    """Let the user select which device to connect to."""
    if not devices:
        print("No devices found.")
        return None
    
    if len(devices) == 1:
        print("Only one device found. Using it automatically.")
        return devices[0]
    
    print("Please select a device:")
    for i, device in enumerate(devices):
        pro_status = "Pro" if device.get('is_pro') else "Standard"
        print(f"{i+1}. {device['serial_number']} ({pro_status}) - IP: {device['host']}")
    
    while True:
        try:
            selection = int(input("Enter the number of the device to control: "))
            if 1 <= selection <= len(devices):
                return devices[selection-1]
            else:
                print(f"Please enter a number between 1 and {len(devices)}")
        except ValueError:
            print("Please enter a valid number")

async def main():
    # Discover devices
    devices = await BriivAPI.discover(timeout=15)
    print(f"Found {len(devices)} devices: {devices}")
    
    # Let user select which device to connect to
    selected_device = select_device(devices)
    if not selected_device:
        print("No device selected. Exiting.")
        return
    
    # Connect to the selected device
    api = BriivAPI(
        host=selected_device['host'], 
        port=3334,  # Using standard port
        serial_number=selected_device['serial_number']
    )
    
    # Start listening for updates
    await api.start_listening(asyncio.get_event_loop())
    
    # Control the device

    await api.set_fan_speed(50)

    await asyncio.sleep(5)

    await api.set_fan_speed(0)
    
    # Clean up
    await api.stop_listening()

if __name__ == "__main__":
    asyncio.run(main())
```

## Features

* Device discovery via UDP
* Power control (on/off)
* Fan speed adjustment
* Boost mode control
* Real-time device state updates

## License

MIT
mcp-dify-knowledge 0.1.2
This is a simple MCP service for the Dify knowledge base.
Requires Python: >=3.13

# Usege

## Environment Variables

```
DIFY_API_URL="your dify knowledge api url"
DIFY_API_KEY="your dify knowledge api key"
```

## UVX

```
{
  "mcpServers": {
    "dify-knowledge": {
      "command": "uvx",
      "args": [
        "mcp-dify-knowledge"
      ],
      "env": {
        "DIFY_API_KEY": "your_dify_knowledge_api_key",
        "DIFY_API_URL": "your_dify_knowledge_api_url"
      }
    }
  }
}

```
nezha-agent 0.4.0
基于大语言模型的命令行代码助手
Requires Python: >=3.8

# nezha

nezha 是一个命令行 AI 助手工具，支持模型选择、对话、计划生成、配置初始化等多种智能操作，适合开发者和 AI 爱好者快速集成和使用。

## 主要特性
- 支持多种大语言模型（LLM），包括预置和用户自定义模型
- 模型可配置、可切换
- 命令行交互式体验，支持对话 (`chat`)、计划 (`plan`) 等多种命令
- 支持通过 `init` 命令初始化或重置配置
- 配置灵活，支持用户自定义模型参数和安全设置
- 内置安全层，提供不同级别的操作确认和路径限制
- 适合二次开发和集成

## 安装方法

### 通过 pip 安装（推荐）
```bash
pip install nezha-agent
```

### 源码安装
```bash
git clone https://github.com/echovic/nezha.git
cd nezha
pip install .
```

## 快速开始

### 初始化配置 (可选)
```bash
nezha init
```

### 查看和管理模型
```bash
# 查看所有可用模型
nezha models list

# 交互式选择并设置默认模型
nezha models select

# 添加新模型配置
nezha models add
```

### 启动对话
```bash
nezha chat
```

### 生成计划
```bash
nezha plan "帮我写一个发送邮件的 Python 脚本"
```

## 配置说明
- 默认配置文件位于 `~/.config/nezha/config.yaml` (路径可能因操作系统而异，请参考 `platformdirs` 文档)
- 可通过 `nezha init` 命令生成或重置配置文件
- 支持自定义模型列表及参数
- 安全相关配置位于 `config/security_config.yaml`，详情请参考 [安全层设计与使用指南](docs/security_layer.md)

## 自动化发布流程

项目使用 GitHub Actions 实现了自动化的版本管理和发布流程，简化了发布过程。

### 自动版本管理

当代码推送到 main 分支时，系统会根据提交信息自动确定版本增量类型：

- 提交包含 "BREAKING CHANGE" 或 "major" 时，增加主版本号
- 提交包含 "feat"、"feature" 或 "minor" 时，增加次版本号
- 其他情况增加修订版本号

### 自动发布过程

工作流程会自动执行以下操作：

1. 自动更新 pyproject.toml 中的版本号
2. 提交版本更新到仓库
3. 创建并推送新版本的 git tag
4. 构建 Python 包
5. 发布到 PyPI

### 使用方法

只需正常开发和提交代码，在提交信息中使用关键词控制版本增量。当代码合并到 main 分支后，工作流程会自动执行所有步骤。

如果不希望某次提交触发发布，可以在提交信息中添加 "[skip ci]"。

## 贡献指南
欢迎提交 issue 和 PR！如需贡献代码，请遵循本项目的代码规范。

## 项目结构

### 目录结构

```
src/nezha_agent/
├── core/                 # 核心功能和基础组件
│   ├── common/          # 通用工具和功能
│   ├── context/         # 上下文引擎
│   ├── models/          # 模型接口和实现
│   ├── security/        # 安全相关功能
│   └── tools/           # 核心工具接口
├── features/            # 具体功能实现
│   ├── agent/           # 代理相关功能
│   ├── commands/        # 命令实现（chat、plan等）
│   ├── editing/         # 文件编辑功能
│   ├── git/             # Git相关功能
│   ├── shell/           # Shell相关功能
│   └── tools/           # 具体工具实现
├── integrations/        # 与外部系统的集成
│   ├── api/             # API集成
│   ├── editors/         # 编辑器集成
│   ├── external/        # 外部工具集成
│   └── shells/          # Shell集成
├── plugins/             # 插件系统
│   ├── registry/        # 插件注册管理
│   └── sdk/             # 插件开发工具包
└── ui/                  # 用户界面
    ├── cli/             # 命令行界面
    ├── display/         # 显示相关功能
    └── terminal/        # 终端相关功能
```

### 架构图

<div align="center">
  <img src="docs/nezha_architecture.svg" alt="Nezha 架构图" width="800" style="max-width: 800px;" />
</div>

架构说明：
- **Core**：核心模块，包含模型接口、安全层、上下文引擎等基础组件
- **Features**：实现具体功能，如代理、命令和各种工具
- **Integrations**：负责与外部系统和工具的交互和集成
- **Plugins**：提供插件系统，使得功能可扩展
- **UI**：用户界面模块，主要包含命令行界面和显示功能

## 联系方式
- 邮箱：137844255@qq.com
- Issues：https://github.com/echovic/nezha/issues
amos-api 1.0.9
AMOS common api
Requires Python: >=3

# amos api

主要用于定义离线分析中的 API 规范以及通用的 Response 等

## 快速开始

```py
import logging
from fastapi import (FastAPI, Body)
from fastapi.responses import JSONResponse
from pydantic import ValidationError

from amos_api import (
    ResponseBase,
    ResponseOK,
    ResponseValidationError,
    ResponseAlgorithmError,
    CheckAssertionError,
    CheckValueError
)

from starlette.responses import RedirectResponse

logger = logging.getLogger()

async def document():
    # return RedirectResponse(url="/docs")
    return RedirectResponse(url="/redoc")

def mount_app_routes(app: FastAPI):
    app.get("/",
            response_model=ResponseBase,
            summary="swagger 文档")(document)
    # tag items
    app.post("/user",
             tags=["User"],
             summary="用户信息",
             )(userInfo)

async def userInfo(name: str=Body(..., description="用户名称", examples=["ray"])) -> ResponseBase:
    return ResponseBase(data={"seq":"1", "name": name,})

async def userList(name: str=Body(..., description="用户名称", examples=["ray"])) -> ResponseBase:
    try:
        dblist()
        return ResponseOK(data=[])
    except Exception as e:
        if isinstance(e, (ValidationError, CheckAssertionError, CheckValueError)):
            ret = ResponseValidationError(data='校验错误的详细信息')
        else:
            ret = ResponseAlgorithmError(data='算法错误的详细信息')
        logger.error() #错误日志
        return JSONResponse(status_code=ret.code, content=ret.model_dump())
```

- `HttpCode._200` 请求成功,正常 code 值，ResponseBase 如果不设置code时，默认值。
- `HttpCode._400` 错误的请求，比如参数错误
- `HttpCode._403` 禁止访问的资源
- `HttpCode._404` 未找到
- `HttpCode._422` 常用于参数错误
- `HttpCode._500` 服务器错误，内部错误
- `HttpCode._522` 服务器错误，内部错误
- `HttpCode._523` 服务器错误，内部错误,已知
kitchenware 0.3.0
Utility tools to load and process biomolecular data.
Requires Python: >=3.12

# Kitchenware

Utility tools to load and process biomolecular data. This package provides a foundation for deep learning applications in structural biology, offering efficient tools for handling molecular structures and their analysis.

## Features

**Data Processing**
- Load and save molecular structures (PDB/CIF formats)
- Structure encoding and processing
- Biomolecular data type handling

**Geometric Analysis**
- Distance matrix computation
- Connectivity extraction
- Neighborhood analysis
- Structure superposition
- Contact detection

**Structure Analysis**
- Secondary structure analysis
- RMSD calculations
- lDDT scoring
- Angle and dihedral measurements

**Utilities**
- Standard amino acid encodings
- Template handling
- Chain and residue operations
- Density map operations

## Installation

```bash
pip install kitchenware
```

## Quick Start

```python
import kitchenware as kw

# Load a structure (PDB or CIF format)
structure = kw.load_structure("input_structure.pdb")

# Encode structure and convert to a collection of tensors (PyTorch)
data = kw.encode_structure(structure)

# Convert back to a structure
structure = kw.data_to_structure(data)

# Write PDB files
kw.save_pdb(data, "output_structure.pdb")
```

## Dependencies

- gemmi
- mrcfile
- numpy
- pandas
- torch
- rdkit
- scipy
- scikit-learn

For a list of dependencies see [pyproject.toml](./pyproject.toml)

## Applications

This toolkit serves as the foundation for several deep learning methods in structural biology:
- [PeSTo](https://github.com/LBM-EPFL/PeSTo): parameter-free geometric deep learning for accurate prediction of protein binding interfaces
- [CARBonAra](https://github.com/LBM-EPFL/CARBonAra): Context-aware geometric deep learning for protein sequence design

## Contributing

We welcome contributions! Please feel free to submit a Pull Request.

## License

This work is licensed under a
[Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License][cc-by-nc-sa].

[![CC BY-NC-SA 4.0][cc-by-nc-sa-image]][cc-by-nc-sa]

[cc-by-nc-sa]: http://creativecommons.org/licenses/by-nc-sa/4.0/
[cc-by-nc-sa-image]: https://licensebuttons.net/l/by-nc-sa/4.0/88x31.png
[cc-by-nc-sa-shield]: https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey.svg

## Reference

This toolkit was developed as the foundation for both PeSTo and CARBonAra. If you use this toolkit in your research, please cite one of the following publications.

### PeSTo

Krapp, L.F., Abriata, L.A., Cortés Rodriguez, F. et al. PeSTo: parameter-free geometric deep learning for accurate prediction of protein binding interfaces. Nat Commun 14, 2175 (2023). https://doi.org/10.1038/s41467-023-37701-8

### CARBonAra

Krapp, L.F., Meireles, F.A., Abriata, L.A. et al. Context-aware geometric deep learning for protein sequence design. Nat Commun 15, 6273 (2024). https://doi.org/10.1038/s41467-024-50571-y
toolkitx 0.0.3
A personal Python toolkit for common tasks
Requires Python: >=3.12

# toolkitx

A personal Python toolkit for common tasks. This package provides various utility functions to simplify common development workflows.

## Features

*   **Text Utilities** (`toolkitx.text_utils`):
    *   `truncate_text_smart`: Smartly truncates text by characters or words, with options for suffix and tolerance, attempting to preserve sentence or word boundaries.
    *   `split_text_by_word_count`: Splits long text into overlapping chunks based on word count.
*   **Command-Line Script**:
    *   `hello`: A simple script accessible via `hello` command after installation, prints a greeting message.
*   **Experimental Translator** (`toolkitx.lab.translator`):
    *   `Translator`: A class providing translation capabilities using Baidu or Tencent translation APIs, with disk-based caching for performance. (Requires API credentials)

## Installation

1.  Clone the repository:
    ```bash
    git clone https://github.com/ider-zh/toolkitx.git
    cd toolkitx
    ```
2.  Install the package. For development, you can install it in editable mode with development dependencies:
    ```bash
    pip install -e ".[dev]"
    ```
    For regular installation:
    ```bash
    pip install .
    ```

## Usage

### Text Utilities

```python
from toolkitx import truncate_text_smart, split_text_by_word_count

# Smart Truncation
text = "This is a very long sentence that needs to be truncated."
truncated_char = truncate_text_smart(text, limit=20, mode="char", suffix="...")
print(f"Char truncated: {truncated_char}")

truncated_word = truncate_text_smart(text, limit=5, mode="word", suffix="...")
print(f"Word truncated: {truncated_word}")

# Split Text
long_text = "This is a long piece of text that we want to split into several smaller chunks with some overlap between them for context."
chunks = split_text_by_word_count(long_text, max_words=10, overlap=2)
for i, chunk in enumerate(chunks):
    print(f"Chunk {i+1}: {chunk}")
```