semvec/pypi-packages huggingface dataset:
grabpy 0.1.3
Simple package for requesting web pages that respects robots.txt
Requires Python: >=3.9

# Grabpy

Simple respectful web scraper

## INSTALLING

How to install Grabpy.

```bash
pip install grabpy
```

## USING

How to use Grabpy to fetch pages or download content.

```python
from grabpy import Grabber

with Grabber('useragent/0.1', retries=3) as grabber:
    content = grabber.get('https://www.example.org')
    
    if grabber.download('https://www.example.org/music.mp3', 'music.mp3'):
        print('Download successful.')
    else:
        print('Download failed.')
```

## LOGGING

How to enable logging for this package.

```python
import logging

logging.basicConfig(level=logging.DEBUG)
logging.getLogger('grabpy').setLevel(logging.DEBUG)
logging.getLogger().setLevel(logging.WARNING)
```
59chat 0.3.7
59-second zero-trace terminal chat (Ultra-Light Edition)
Requires Python: >=3.8

# Ephemeral Terminal Chat

Zero-trace terminal chat application with 59-second disappearing messages.

## Features

- Messages disappear after 59 seconds
- Zero trace - no history kept
- Fast terminal UI with Textual framework
- Mono font recommended (set in your terminal, e.g., JetBrains Mono)
- Supabase backend for real-time sync
- Share rooms with 6-character room codes
- Random nickname generation

## Setup

### 1. Supabase Setup

1. Go to [supabase.com](https://supabase.com) and create a free account
2. Create a new project
3. Go to SQL Editor and run the `supabase_setup.sql` file
4. Get your project URL and anon key from Settings > API

### 2. Environment Variables

Copy `.env.example` to `.env` and add your Supabase credentials:

```bash
cp .env.example .env
```

Edit `.env`:
```
SUPABASE_URL=your_supabase_project_url
SUPABASE_KEY=your_supabase_anon_key
```

### 3. Install Dependencies

```bash
pip install -r requirements.txt
```

### 4. Run

```bash
python main.py
```

## Usage

- **Type a message** and press Enter to send
- **Ctrl+R** - Create new room
- **Ctrl+C** - Quit
- Share the **room code** with others to chat
- Messages auto-delete after 59 seconds

## How It Works

- Each room has a unique 6-character code
- Messages are stored in Supabase with timestamp
- Auto-cleanup deletes messages older than 59 seconds
- Terminal polls for new messages every second
- Zero-trace: no message history retained

## Terminal Share

Share your terminal with:
- tmate: `tmate`
- warp: Share session feature
- ssh: Allow remote connections
- Or just share the room code via any channel
tunnelify 0.3.2
A simple package for easily creating Cloudflare or Localtunnel tunnels.
Requires Python: >=3.6

# Tunnelify

Tunnelify is a Python library to easily create and manage Cloudflare or Localtunnel tunnels.

# Example

```python
from tunnelify import tunnel

# For Cloudflare
url, proc = tunnel(8000, "cloudflare")
print(f"Cloudflare URL: {url}")

# For Localtunnel (without custom subdomain)
url, _ = tunnel(8000, "localtunnel")
print(f"Localtunnel URL: {url}")

# For Localtunnel with custom subdomain
url, _ = tunnel(8000, "localtunnel", "customsub")
print(f"Custom Localtunnel URL: {url}")
```

# Installation

Just:
`pip install tunnelify`

Tunnelify requires Cloudflared package to work.
csv-citation-counter 0.1.0
Summarize CSV publication and citation data by column.
Requires Python: >=3.8

# 📊 CSV Citation Counter

This Python script processes one or more CSV files to summarize publication and citation data by a chosen column — such as journal names, author names, or institutions.

It supports:

- ✅ Counting how many times each entry appears (e.g., number of articles per journal)
- ✅ Summing citations per entry using a `"Cited by"` column
- ✅ Calculating average and max citations per entry
- ✅ Sorting results by:
  - Number of articles [articles]
  - Total citations [total]
  - Average citations per article [avg]
- ✅ Handling multi-entry fields (e.g., multiple authors separated by `; `)
- ✅ Writing clean summaries to a human-readable `summary.txt`

---

## 📦 Requirements

No external libraries required — works with standard Python 3.

---

## 🚀 How to Run the Script

You can run the script in **two ways**:

---

### ✅ Option 1: Command Line Arguments

```bash
python script.py \
  --files data/file1.csv data/file2.csv \
  --column "Authors" \
  --split "; " \
  --sortby avg
```

### ✅ Option 2: Interactive Mode

You'll be prompted to: 
##### Enter file paths or folders:
Input one path per line (CSV file or folder)

Hit Enter on an empty line when you're done

All .csv files in a folder will be included

##### Column name to analyze (e.g., Journal, Authors)
Delimiter (optional) if each csv entry has multiple elements (such as authors):

Leave blank for single-entry fields

Make sure to add a space (like "; ") if necessary.

##### Sort method (optional):
articles → by number of articles (default)

total → by total citations

avg → by average citations per article

### Output
The summary is recorded to a summary.txt in the same directory where this script was run. Blank lines separated groups with differnet values for the sort attribute.
otter-service-stdalone 1.1.36
Grading Service for Instructors using Otter Grader
Requires Python: >=3.8

# otter-service-standalone

## Use: [Instructions](https://docs.google.com/document/d/1Hih6No17ffvLcNImf8uOueRSo0UT-fvEIDMFUhfLSPk/edit)

## Deployment
The cloud deployment is configured using a helm chart. The branch you are on(e.g. dev, staging, prod) determines what environment/k8 namespace you deploy into.

See the ./deploy.sh for details. The script will determine the branch and 
deploy properly. If you are on the dev branch and pass "build" as an argument,
(e.g. `./deploy.sh build`) then the docker image used on the container is built and pushed to the gcloud image repository (gcr.io). You need to be sure to bump
the version number in src/otter_service_stdalone/__init__.py before a new build.

## Version
A git tag with the version is pushed to git whenever the version is bumped and
deployed in production. `git tag` will show you the format of the tag(e.g. 0.0.30)

## Local Dev:
Execute: sh deployment/local/build.sh
- FireStore: http://127.0.0.1:4007/firestore/
- App: http://127.0.0.1/
usageflow-fastapi 0.3.4
FastAPI middleware for UsageFlow - Usage-based pricing made simple
Requires Python: >=3.6

# UsageFlow FastAPI

FastAPI middleware for UsageFlow - Usage-based pricing made simple.

## Installation

```bash
pip install usageflow-fastapi
```

## Usage

```python
from fastapi import FastAPI
from usageflow.fastapi import UsageFlowMiddleware

app = FastAPI()

# Initialize UsageFlow middleware
app.add_middleware(
    UsageFlowMiddleware,
    api_key="your-api-key",
    pool_size=10  # Optional: Number of WebSocket connections (default: 10)
)

@app.get("/api/v1/users")
async def get_users():
    return {"users": ["user1", "user2"]}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

## Configuration

The middleware accepts the following parameters:

- `app`: Your FastAPI application instance (passed via `add_middleware`)
- `api_key`: Your UsageFlow API key (required)
- `pool_size` (optional): Number of WebSocket connections in the pool (default: 10)

Note: Whitelist and tracklist routes are now managed server-side via the UsageFlow dashboard, not through local parameters.

## Features

- Automatic usage tracking
- Request/response logging
- Rate limiting and quota management
- User identification via JWT tokens
- Custom metadata support
- Async support
- Endpoint blocking support
- Server-side whitelist and tracklist route filtering

## Documentation

For full documentation, visit [https://docs.usageflow.io](https://docs.usageflow.io)

## License

This project is licensed under the MIT License - see the LICENSE file for details.
usageflow-core 0.3.4
Core functionality for UsageFlow - Usage-based pricing made simple
Requires Python: >=3.6

# UsageFlow Core

> ⚠️ **Beta Notice**: This package is currently in beta. While we strive to maintain stability, there may be breaking changes as we continue to improve the API.

The core package of UsageFlow provides the fundamental functionality for API usage tracking and management. It contains the base client implementation and shared utilities used by framework-specific packages.

## Installation

```bash
pip install usageflow-core
```

## Features

- Base client implementation

## Usage

While you typically won't use this package directly (instead using framework-specific packages like `usageflow-flask` or `usageflow-fastapi`), here's how you can use the core client:

```python
from usageflow.core import UsageFlowClient

client = UsageFlowClient(api_key="your_api_key_here")

# Track a request
client.track_request(
    method="GET",
    path="/api/v1/users",
    identity="user123",
    metadata={"user_agent": "Mozilla/5.0"}
)
```

## Development

To contribute to the project:

1. Clone the repository
2. Install development dependencies:
   ```bash
   pip install -e ".[dev]"
   ```
3. Run tests:
   ```bash
   pytest
   ```

## License

This project is licensed under the MIT License - see the LICENSE file for details.
obsidian-vault-mcp 1.1.0
Obsidian Vault MCP - 语义搜索和记忆服务
Requires Python: >=3.12
Keywords: knowledge-base, mcp, obsidian, search, semantic

# Obsidian Vault MCP

[![PyPI](https://img.shields.io/pypi/v/obsidian-vault-mcp)](https://pypi.org/project/obsidian-vault-mcp/)
[![Python](https://img.shields.io/pypi/pyversions/obsidian-vault-mcp)](https://pypi.org/project/obsidian-vault-mcp/)
[![License](https://img.shields.io/github/license/chyax98/obsidian-mcp)](https://github.com/chyax98/obsidian-mcp/blob/main/LICENSE)

Obsidian 知识库的 MCP 服务，提供语义搜索和知识图谱分析能力。

## 特性

- **混合搜索**：BM25 关键词 + 向量语义 + RRF 融合 + PageRank 加权
- **轻量高效**：mmap 索引加载，内存占用 ~300MB
- **后台索引**：启动不阻塞，增量更新
- **零配置**：开箱即用

## 安装

```bash
uv tool install obsidian-vault-mcp --python 3.12
```

## 工具列表

| 工具 | 说明 |
|------|------|
| `vault_search` | 搜索笔记，支持 bm25/semantic/hybrid 三种模式 |
| `vault_read` | 读取笔记完整内容 |
| `vault_list` | 列出笔记，支持目录过滤和最近修改筛选 |
| `vault_links` | 获取笔记的反向链接和出链关系 |
| `vault_tags` | 获取标签统计或按标签查找笔记 |
| `vault_related` | 查找语义相似的相关笔记 |

### 工具详情

**vault_search** - 搜索笔记
- `query`: 搜索关键词或问题
- `mode`: 搜索模式（bm25=关键词匹配，semantic=语义理解，hybrid=混合，默认 hybrid）
- `limit`: 返回数量（1-50，默认 10）

**vault_read** - 读取笔记
- `path`: 笔记路径，如 `folder/note.md`

**vault_list** - 列出笔记
- `folder`: 目录过滤，如 `projects/`
- `recent_days`: 只返回最近 N 天修改的笔记
- `limit`: 返回数量（1-200，默认 50）

**vault_links** - 链接关系
- `path`: 笔记路径
- 返回：backlinks（反向链接）和 outgoing（出链）

**vault_tags** - 标签查询
- `tag`: 标签名（可选），不传则返回所有标签统计

**vault_related** - 相关笔记
- `path`: 笔记路径
- `limit`: 返回数量（1-30，默认 10）

## 使用

### Vault 路径配置

优先级：`--vault` 参数 > `OBSIDIAN_VAULT_PATH` 环境变量 > 当前目录

```bash
# 命令行参数
obsidian-vault-mcp --vault /path/to/vault

# 环境变量
export OBSIDIAN_VAULT_PATH=/path/to/vault
obsidian-vault-mcp
```

### Claude Code 配置

**命令行添加：**

```bash
claude mcp add obsidian-vault \
  -e OBSIDIAN_VAULT_PATH=/path/to/vault \
  -- obsidian-vault-mcp
```

**项目 `.mcp.json`（放在 vault 目录下）：**

```json
{
  "mcpServers": {
    "obsidian-vault": {
      "type": "stdio",
      "command": "obsidian-vault-mcp",
      "env": {
        "OBSIDIAN_VAULT_PATH": "${PWD}"
      }
    }
  }
}
```

## 索引机制

- 启动时后台初始化（不阻塞主线程）
- BM25 索引使用 mmap 加载，内存高效
- 向量索引使用 LanceDB 持久化
- PageRank 图谱缓存到磁盘
- 每 10 分钟检查文件变动，增量更新

## 配置

在 vault 目录下创建 `.obsidian/vault-mcp.json`：

```json
{
  "embedding_model": "BAAI/bge-small-zh-v1.5",
  "index_interval": 600
}
```

- `embedding_model`: 向量模型（默认 bge-small-zh-v1.5）
- `index_interval`: 索引更新间隔秒数（默认 600）

## 开发

```bash
git clone https://github.com/chyax98/obsidian-mcp.git
cd obsidian-mcp
uv sync
uv run obsidian-vault-mcp --vault /path/to/vault
```

## License

MIT
geoph 0.0.1
A Delaunay-Rips persistent homology library
Requires Python: >=3.9

# GeoPH: Delaunay–Rips persistence diagrams

This repository contains the code for the manuscript [*Delaunay–Rips filtration: a study and an algorithm*](https://arxiv.org/abs/2512.17382).

It also contains the code for the planar Rips and Delaunay--Rips persistence algorithm described in [*Topological Autoencoders++: Fast and Accurate Cycle-Aware Dimensionality Reduction*](https://arxiv.org/abs/2502.20215).

## Dependencies

The following dependencies are required:
* Boost >= 1.72
* CGAL
* Eigen3

For multi-threading, the following dependencies are additionally required:
* Boost >= 1.83
* OpenMP
* TBB

This implementation also uses and contains the following codes:
* [ankerl::unordered_dense](https://github.com/martinus/unordered_dense), a densely stored hashmap and hashset by Martin Leitner-Ankerl
* [dset](https://github.com/wjakob/dset), a lock-free parallel disjoint set data structure by Wenzel Jakob

## C++

This code can be used as a header-only C++ library. Copy and include the `geoPHUtils.h` and `geoPH{2,3,d}.h` files (in the `src` directory) in your project. Then use the classes `DRPersistence{2,3,D}`.

## Python

Execute
`pip wheel .` in the project root
and
`pip install` the produced `.whl` wheel file.