semvec/pypi-packages huggingface dataset:
patent-mcp-server-baiten 0.1.0
MCP Server for Patent Search Functions - integrates with Baiten Patent API
License: MIT
Requires Python: >=3.10
Keywords: mcp, patent, search, baiten, mcp-server

# Patent MCP Server

A Model Context Protocol (MCP) server that provides patent search and analysis tools using the Baiten Patent API.

## Features

- 专利检索 (Patent Search)
- 权利要求查询 (Claims Retrieval)
- 说明书查询 (Specification Retrieval)
- 法律状态查询 (Legal Status Check)
- 专利附图获取 (Patent Images)
- 相似专利查询 (Similar Patents)

## Installation

```bash
pip install patent-mcp-server
```

Or use with uvx:

```bash
uvx patent-mcp-server
```

## Configuration

Create a `.env` file with your Baiten API credentials:

```env
PATENT_DB_APPKEY=your_app_key
PATENT_DB_SECRET=your_secret
PATENT_DB_BASEURL=http://open.baiten.cn
```

## Usage

### Run as MCP Server

```bash
patent-mcp-server
```

### Use with MCP Clients

Add to your MCP client configuration:

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

## Available Tools

1. **custom_search** - Search patents
2. **get_claims** - Get patent claims
3. **extract_claims** - Extract claim text
4. **get_patent_images** - Get patent images
5. **extract_image_urls** - Extract image URLs
6. **get_law_status** - Get legal status
7. **extract_law_status** - Extract legal status info
8. **get_similar_patents** - Find similar patents
9. **get_specification** - Get specification
10. **extract_specification** - Extract specification sections

## License

MIT
decouplet 0.2.2
Decouple config with support for secrets directory (e.g., Docker secrets)
License: MIT
Requires Python: >=3.9

# Decouplet

- A tiny wrapper around [python-decouple](https://pypi.org/project/python-decouple/) that adds support for reading secrets from a directory (like Docker secrets).

## Usage
```python
from decouplet import config

DATABASE_PASSWORD = config("DATABASE_PASSWORD")
```

By default, it looks in `/run/secrets/`. Set `SECRETS_PATH` environment variable to override.

## Secret have biggest priority than .env and environment variables.
pa-py-rs 0.1.2
A Python module that brings ergonomic, Rust-inspired utilities like Result, and panics to Python
License: MIT
Requires Python: >=3.7

[![PyPI version info](https://img.shields.io/pypi/v/pa-py-rs.svg?style=for-the-badge&logo=pypi&color=yellowgreen&logoColor=white)](https://pypi.python.org/pypi/pa-py-rs)
[![PyPI supported Python versions](https://img.shields.io/pypi/pyversions/pa-py-rs.svg?style=for-the-badge&logo=python&logoColor=white)](https://pypi.python.org/pypi/pa-py-rs)

# Key Features
- Result Type: Rust-style `Result[T, E]` for explicit error handling without exceptions
- Ok/Err Variants: Type-safe success and error cases with pattern matching methods
- Panic Mechanism: Rust-like `panic()` for unrecoverable errors with detailed stack traces
- Decorator Utilities: Convert existing functions to return Results with `@resultify` and `@resultify_catch_only`
- Chainable Operations: Functional methods like `map`, `map_err`, `unwrap_or`, and more
- Fully Typed: Complete type hints for excellent IDE support and type checking

# Installation
```bash
# using pip
pip install pa-py-rs

# using uv
uv add pa-py-rs
```
> *NOTE: Python 3.7 or higher is required*

# Examples
## Result
### Basic Result Usage
```python
from pa_py_rs import Result, Ok, Err

def divide(a: float, b: float) -> Result[float, str]:
    if b == 0:
        return Err("Division by zero")
    return Ok(a / b)

result = divide(10, 2)
print(result)   # Ok(5.0)
if result.is_ok():
    print(f"Success: {result.unwrap()}")    # Success: 5.0

result = divide(10, 0)
print(result)   # Err(Division by zero)
if result.is_err():
    print(f"Error: {result.unwrap_err()}")  # Error: Division by zero
```

### Using decorators
```python
from pa_py_rs import resultify, resultify_catch_only

# Convert any function to return Result
# Automatically catch errors and wrap in Err(...)
@resultify
def parse_int(value: str) -> int:
    return int(value)

result = parse_int("123")   # Ok(123)
result = parse_int("abc")   # Err(...)

# For functions already returning Result
# Automatically catch errors and wrap in Err(...)
@resultify_catch_only
def safe_divide(a: float, b: float) -> Result[float, str]:
    return Ok(a / b)

result = safe_divide(10, 2)  # Ok(5.0)
result = safe_divide(10, 0)  # Err("cannot divide by zero")
```

### Chaining Operations
```python
from pa_py_rs import Ok, Err

result = Err("error").unwrap_or(0)
print(result)   # 0

result = (Ok(10)
    .map(lambda x: x * 2)
    .map(lambda x: x + 5)
    .unwrap())
print(result)   # 25
```