semvec/pypi-packages huggingface dataset:
glm-ocr-mcp 0.1.1
MCP server for GLM OCR to extract text from images and PDFs
Requires Python: >=3.12

# GLM OCR MCP Server

MCP server for extracting text from images and PDFs using ZhipuAI GLM-OCR.

## Usage

```json
{
  "mcpServers": {
    "glm-ocr": {
      "command": "uvx",
      "args": ["glm-ocr-mcp"],
      "env": {
        "ZHIPU_API_KEY": "your_api_key_here",
        "ZHIPU_OCR_API_URL": "https://open.bigmodel.cn/api/paas/v4/layout_parsing"
      }
    }
  }
}
```

### Using with Claude Code

```bash
claude mcp add --scope user glm-ocr \
  --env ZHIPU_API_KEY=your_api_key_here \
  --env ZHIPU_OCR_API_URL=https://open.bigmodel.cn/api/paas/v4/layout_parsing \
  -- uvx glm-ocr-mcp
```

### Using with Codex

Add MCP server with command:

```bash
codex mcp add glm-ocr \
  --env ZHIPU_API_KEY=your_api_key_here \
  --env ZHIPU_OCR_API_URL=https://open.bigmodel.cn/api/paas/v4/layout_parsing \
  -- uvx glm-ocr-mcp
```

### Tools

The server provides one tool:

- **extract_text**: Extract from local file or URL (`png`, `jpg/jpeg`, `pdf`)
  - default returns Markdown text
  - set `return_json=true` to return structured JSON without `md_results` (contains page parsing details like `bbox_2d`, `content`, `label`, etc.)

Parameters:

- **file_path**: Local file path or URL for `png`, `jpg/jpeg`, or `pdf`
- **base64_data**: Optional data URL/base64 payload (use when `file_path` is unavailable)
- **start_page_id**: Optional PDF start page (1-based, only effective for PDF)
- **end_page_id**: Optional PDF end page (1-based, only effective for PDF)
- **return_json**: Optional boolean, default `false`. `true` returns JSON; `false` returns Markdown.

### Examples

```python
# Extract text from local image
extract_text(file_path="./screenshot.png")

# Extract text from local PDF
extract_text(file_path="./document.pdf")

# Extract text from URL image
extract_text(file_path="https://example.com/test.jpg")

# Use base64/data URL
extract_text(base64_data="data:image/png;base64,iVBORw0KGgo...")

# Extract structured layout JSON
extract_text(file_path="https://example.com/test.png", return_json=True)
```

## Development

```bash
# Create virtual environment
uv venv
source .venv/bin/activate

# Sync dependencies and install current project
uv sync

# Run server for testing
python -m glm_ocr_mcp.server
```

Windows PowerShell activation:
```powershell
.venv\Scripts\Activate.ps1
```

## Project Structure

```
glm-ocr-mcp/
├── pyproject.toml         # Project configuration
├── README.md              # Documentation
├── .env.example           # Environment variable template
├── src/
│   └── glm_ocr_mcp/
│       ├── __init__.py
│       ├── __main__.py    # Entry point
│       ├── ocr.py         # OCR client
│       └── server.py      # MCP server
```
planformcreator2 4.0.2
Design a wing planform
Requires Python: >=3.12

![PC2](https://github.com/jxjo/PlanformCreator2/blob/main/images/PC2_logo.png?raw=true)

### Version 4.0.2

---

**PlanformCreator2** - short PC2 - is an app to design the planform of a wing focusing on model sailplanes. 

#### Planform Design 

* Define a planform based on a chord distribution and a reference line along wing span
* Import image of an existing wing as a background image for design
* Add wing sections with fixed position or relative chord length
* Define flaps hinge line and flaps 
* Export planform as dxf file for use in CAD

#### Airfoils and Polars
* Define airfoil at wing sections and edit its properties using the [AirfoilEditor](https://github.com/jxjo/AirfoilEditor)
* Generate blended airfoils for intermediate wing sections ('strak')
* View polars of the airfoil based on xfoil polar generation

#### Wing Analysis
* Auto paneling of the planform as preparation for aerodynamic calculation 
* VLM based lift calculation 
* Determine critical sections where cl_max of airfoils will be reached
* Export wing definition to Xflr5 and FLZ_vortex for further analysis


The app, developed in Python with the Qt UI framework, runs on Windows, Linux, and MacOS. 
Linux and MacOS users are required to compile Worker (polar generation) from the [Xoptfoil2](https://github.com/jxjo/Xoptfoil2) project.

Find more info about the **PlanformCreator2** on [Github](https://github.com/jxjo/PlanformCreator2).

---

Find Release Information in [CHANGELOG](https://github.com/jxjo/PlanformCreator2/blob/main/CHANGELOG.md).
bpnotify 0.51
Notification routing for Django
Requires Python: >=3.10
Keywords: django

.. image:: https://github.com/beproud/bpnotify/actions/workflows/tests.yml/badge.svg
   :target: https://github.com/beproud/bpnotify/actions
   :alt: GitHub Actions

`bpnotify` is notification routing for Django. Application notify function with targets, notify_type, media, extra_data, then bpnotify send notify with backend (example: mail).

Requirements
============

* Python (3.9, 3.10, 3.11, 3.12)
* Celery (5.3)
* Django (4.2)
* six

Links
=================

* `release checklist <https://github.com/beproud/bpnotify/blob/master/release_checklist.rst>`_
composio-openai-agents 0.11.1
Use Composio to get array of strongly typed tools for OpenAI Agents
Requires Python: <4,>=3.9

# Composio Integration for OpenAI Agents

This package integrates the OpenAI Agents framework with Composio, allowing you to use Composio's rich set of tools with the OpenAI Agents framework.

## Installation

```bash
pip install composio_openai_agents
```

## Usage

```python
import asyncio
import dotenv
from agents import Agent, Runner

from composio_openai_agents import Action, ComposioToolSet

# Load environment variables from .env
dotenv.load_dotenv()

# Initialize Composio toolset
composio_toolset = ComposioToolSet()

# Get all the tools
tools = composio_toolset.get_tools(actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER])

# Create an agent with the tools
agent = Agent(
    name="GitHub Agent",
    instructions="You are a helpful assistant that helps users with GitHub tasks.",
    tools=tools,
)

# Run the agent
async def main():
    result = await Runner.run(agent, "Star the repository composiohq/composio on GitHub")
    print(result.final_output)

asyncio.run(main())
```

## Features

- Seamlessly integrate Composio's tools with OpenAI Agents
- Access hundreds of pre-built API integrations
- Maintain consistent schema formats between frameworks
- Error handling for validation issues
- Proper type annotations that work with mypy and pylance

## Requirements

- Python 3.9+
- OpenAI Agents framework
- Composio (with valid API key)

## License

Apache 2.0
composio-openai 0.11.1
Use Composio to get an array of tools with your OpenAI Function Call.
Requires Python: <4,>=3.9

## 🚀🔗 Leveraging OpenAI with Composio

Facilitate the integration of OpenAI with Composio to empower OpenAI models to directly interact with external applications, broadening their capabilities and application scope.

### Objective

- **Automate starring a GitHub repository** using conversational instructions via OpenAI Function Calls.

### Installation and Setup

Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.

```bash
# Install Composio LangChain package
pip install composio-openai

# Connect your GitHub account
composio-cli add github

# View available applications you can connect with
composio-cli show-apps
```

### Usage Steps

#### 1. Import Base Packages

Prepare your environment by initializing necessary imports from OpenAI and setting up your client.

```python
from openai import OpenAI

# Initialize OpenAI client
openai_client = OpenAI()
```

### Step 2: Integrating GitHub Tools with Composio

This step involves fetching and integrating GitHub tools provided by Composio, enabling enhanced functionality for LangChain operations.
```python
from composio_openai import App, ComposioToolSet

toolset = ComposioToolSet()
actions = toolset.get_tools(apps=[App.GITHUB])
```

### Step 3: Agent Execution

This step involves configuring and executing the agent to carry out actions, such as starring a GitHub repository.

```python
my_task = "Star a repo composiohq/composio on GitHub"

# Create a chat completion request to decide on the action
response = openai_client.chat.completions.create(model="gpt-5",
    tools=actions, # Passing actions we fetched earlier.
    messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": my_task}
        ]
    )

pprint(response)
```

### Step 4: Validate Execution Response

Execute the following code to validate the response, ensuring that the intended task has been successfully completed.

```python
result = toolset.handle_tool_calls(response)
pprint(result)
```