semvec/pypi-packages huggingface dataset:
PyGreSQL 6.2.3
Python PostgreSQL interfaces
Requires Python: >=3.8
Keywords: pygresql, postgresql, database, api, dbapi

PyGreSQL - Python interface for PostgreSQL
==========================================

PyGreSQL is a Python module that interfaces to a PostgreSQL database.
It wraps the lower level C API library libpq to allow easy use of the
powerful PostgreSQL features from Python.

PyGreSQL should run on most platforms where PostgreSQL and Python is running.
It is based on the PyGres95 code written by Pascal Andre.
D'Arcy J. M. Cain renamed it to PyGreSQL starting with version 2.0
and serves as the "BDFL" of PyGreSQL.
Christoph Zwerschke volunteered as another maintainer and has been the main 
contributor since version 3.8 of PyGreSQL.

The following Python versions are supported:

* PyGreSQL 4.x and earlier: Python 2 only
* PyGreSQL 5.x: Python 2 and Python 3
* PyGreSQL 6.x and newer: Python 3 only

The current version of PyGreSQL supports Python versions 3.8 to 3.14
and PostgreSQL versions 12 to 18 on the server.

Installation
------------

The simplest way to install PyGreSQL is to type::

    $ pip install PyGreSQL

For other ways of installing PyGreSQL and requirements,
see the documentation.

Note that PyGreSQL also requires the libpq shared library to be
installed and accessible on the client machine.

Documentation
-------------

The documentation is available at
`pygresql.github.io/ <http://pygresql.github.io/>`_ and at
`pygresql.readthedocs.io <https://pygresql.readthedocs.io/>`_,
where you can also find the documentation for older versions.
modelcontextprotocol-client 0.1.3
ModelContextProtocol Client
Requires Python: >=3.13

# Model Context Protocol Client

A Python client implementation for the Model Context Protocol (MCP). This library allows you to connect to MCP servers, list tools, resources, and prompts, and execute tool calls.

## Installation

```bash
pip install modelcontextprotocol-client
```

Or from source:

```bash
pip install .
```

## Features

- Support for Stdio, SSE, HTTP, and WebSocket transports
- Full MCP protocol implementation (Client capabilities)
- Type-safe interactions with Pydantic models
- Async/Await support

## Hello World Example

Here is a simple example of how to use the client to connect to a local MCP server (using stdio transport) and list available tools.

This example assumes you have an MCP server running or available to run (e.g., a simple python script or a CLI tool).

### 1. Basic Usage

```python
import asyncio
from mcp.client import Client

async def main():
    # Define server configuration
    # This example connects to a local git MCP server (requires 'uv' and 'mcp-server-git')
    config = {
        "mcpServers": {
            "git-server": {
                "transport": "stdio",
                "command": "uvx",
                "args": ["mcp-server-git", "--repository", "."]
            }
        }
    }

    # Initialize the client
    client = Client.from_config(config)

    try:
        # Create a session with the 'git-server'
        print("Connecting to server...")
        session = await client.create_session("git-server")
        print("Connected!")

        # Initialize the connection (handshake)
        # Note: create_session already handles connect() and initialize()

        # List available tools
        print("\nFetching tools...")
        tools = await session.list_tools()
        
        print(f"Found {len(tools.tools)} tools:")
        for tool in tools.tools:
            print(f"- {tool.name}: {tool.description}")

        # Example: Call a tool (if applicable)
        # await session.call_tool(...)

    finally:
        # Close all sessions
        await client.close_all_sessions()

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

### 2. Using an SSE Server

```python
import asyncio
from mcp.client import Client

async def main():
    config = {
        "mcpServers": {
            "remote-server": {
                "transport": "sse",
                "url": "http://localhost:8000/sse"
            }
        }
    }
    
    client = Client(config)
    
    # ... rest of the logic is the same
```

## Configuration

The client accepts a configuration dictionary or path to a JSON config file.

```python
# Load from file
client = Client.from_config_file("mcp_config.json")
```

The config file structure:
```json
{
  "mcpServers": {
    "my-server": {
      "command": "python",
      "args": ["server.py"],
      "env": { "MY_VAR": "value" }
    }
  }
}
```

## License

[Add License Here]
djangocms-katex 1.0.1
Provides plugin to render formulae in django CMS
Requires Python: >=3.9
Keywords: KaTeX, django CMS

# djangocms-katex

[![PyPI version](https://badge.fury.io/py/djangocms-katex.svg)](https://badge.fury.io/py/djangocms-katex)
[![Python version](https://img.shields.io/pypi/pyversions/djangocms-katex.svg?style=flat-square)](https://pypi.org/project/djangocms-katex/)
[![Django version](https://img.shields.io/pypi/frameworkversions/django/djangocms-katex.svg?style=flat-square)](https://www.djangoproject.com/)
[![django CMS version](https://img.shields.io/pypi/frameworkversions/django-cms/djangocms-katex.svg?style=flat-square)](https://www.django-cms.org/)

Provides a django CMS plugin to render formulae using KaTeX and
its mhchem extension.

The plugin can display formulae either inline or in display mode.
It is text-enabled, and you can add equations to rich text fields
of djangocms-text-ckeditor.

The plugin form has a preview functionality that either shows
the typed formula. Errors are shown in red.

![Example screenshot](https://github.com/fsbraun/djangocms-katex/blob/main/private/screenshot.jpg?raw=true)

## Installation

For a manual install:

* run `pip install djangocms-katex`
* add the following entries to your ``INSTALLED_APPS``:
  ```
      "djangocms_katex",
  ```

* run `python manage.py migrate`

The Code plugin uses the ace code editor which is loaded from a CDN by default.
If you want the ace code editor to be served from static files, please use
`djangocms-katex[static-ace]` instead of `djangocms-katex` in your
requirements or with pip. Make the static files for the ace code editor available
to your project by adding `djangocms_static_ace` to your project's
``INSTALLED_APPS``.

djangocms-text-ckeditor's inline functionality might interfere with KaTeX's layout.
To ensure a great editing experience deactivate it if you use djangocms-katex by
removing `TEXT_INLINE_EDITING = True` from your `settings.py` file.

## Usage

Once installed, a new puling ("KaTeX formula") is available and can be entered
into any placeholder or within a text plugin.


djangocms-katex only loads required LaTeX JavaScript libraries on demand only.
This might lead to formulae initially only shown in source code. To see the rendered
formula in such a case, please reload the page which ensures that all required
JavaScript is loaded.
hanzo-zap 0.6.0
Zero-copy Agent Protocol (ZAP) SDK - 1000x faster than MCP
Requires Python: >=3.10
Keywords: agent, ai, hanzo, mcp, protocol, zap, zero-copy

# hanzo-zap

Zero-copy Agent Protocol (ZAP) SDK for Python.

**1000x faster than MCP/JSON-RPC** through binary wire protocol with zero-copy serialization.

## Installation

```bash
pip install hanzo-zap
# or
uv add hanzo-zap
```

## Quick Start

### Client

```python
import asyncio
from hanzo_zap import ZapClient

async def main():
    # Connect to a ZAP server
    async with ZapClient.connect("zap://localhost:9999") as client:
        # List available tools
        tools = await client.list_tools()
        print("Tools:", [t.name for t in tools])

        # Call a tool
        result = await client.call_tool("read_file", {"path": "README.md"})
        print("Content:", result.content)

        # Batch multiple calls
        results = await client.batch([
            {"name": "read_file", "args": {"path": "package.json"}},
            {"name": "git_status", "args": {}},
        ])

asyncio.run(main())
```

### Server

```python
import asyncio
from hanzo_zap import ZapServer

server = ZapServer(name="my-tools", version="1.0.0")

@server.tool("greet", "Greet someone by name", {"type": "object", "properties": {"name": {"type": "string"}}})
async def greet(name: str, args: dict) -> str:
    return f"Hello, {args['name']}!"

asyncio.run(server.serve(9999))
```

## Wire Protocol

ZAP uses a simple length-prefixed binary format:

```
+----------+----------+------------------+
| Length   | MsgType  | Payload          |
| (4 bytes)| (1 byte) | (variable)       |
| LE u32   |          | JSON             |
+----------+----------+------------------+
```

## API

### ZapClient

- `ZapClient.connect(url)` - Connect to server
- `client.list_tools()` - List available tools
- `client.call_tool(name, args)` - Call a tool
- `client.batch(calls)` - Call multiple tools
- `client.ping()` - Check connection
- `client.close()` - Close connection

### ZapServer

- `ZapServer(name, version)` - Create server
- `server.register_tool(name, description, schema, handler)` - Register tool
- `@server.tool(name, description, schema)` - Decorator to register tool
- `server.serve(port)` - Start serving (blocking)
- `server.start(port)` - Start in background
- `server.stop()` - Stop server

## Policies

```python
from hanzo_zap import ApprovalPolicy, SandboxPolicy

# Approval policies (when to ask for human approval)
ApprovalPolicy.UNLESS_TRUSTED  # Only auto-approve known-safe reads
ApprovalPolicy.ON_FAILURE      # Auto-approve, escalate on failure
ApprovalPolicy.ON_REQUEST      # Model decides (default)
ApprovalPolicy.NEVER           # Never ask

# Sandbox policies
sandbox = SandboxPolicy.workspace_write(
    writable_roots=["/home/user/project"],
    network_access=True,
)
```

## License

MIT - Hanzo AI Inc.
ownership 0.0.1
Enrich CODEOWNERS files with metadata via owners.toml
Requires Python: >=3.10
Keywords: codeowners, github, gitlab, metadata, ownership, teams

# ownership

Enrich CODEOWNERS files with metadata via `owners.toml`.

Supports GitHub and GitLab.

## Status

🚧 **Coming soon** — This package is under active development.

## Installation

```bash
pip install ownership
```

## License

MIT