semvec/pypi-packages huggingface dataset:
funx 1.2.0
Python utility functions for cleaner, more readable code
License: MIT
Requires Python: >=3.6
Keywords: python, utilities, helpers, functions, clean code, readable code, maintainable code, utility library, code quality, developer tools, productivity

# funx

[![PyPI version](https://badge.fury.io/py/funx.svg)](https://badge.fury.io/py/funx)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![PyPI Downloads](https://static.pepy.tech/personalized-badge/funx?period=total&units=INTERNATIONAL_SYSTEM&left_color=GRAY&right_color=BRIGHTGREEN&left_text=downloads)](https://pepy.tech/projects/funx)

The main reason why this library was created is to:

### use

```python
from funx import isinstances


def add(num1: int, num2: int) -> int:
    if isinstances(num1, num2, datatype=int):  # 41 char
        return num1 + num2
    raise TypeError("invalid arguments types")


print(add(3, 7))
```

### in place of

```python
def add(num1: int, num2: int) -> int:
    if isinstance(num1, int) and isinstance(num2, int):  # 51 char
        return num1 + num2
    raise TypeError("invalid arguments types")


print(add(3, 7))
```

### and

```python
from funx import isinstances


def fun(name: str, age: int) -> None:
    if isinstances(name, age, datatype=(str, int)):  # 47 char
        print(f"your name is {name} and your age is {age}")
        return
    raise TypeError("invalid arguments types")


fun("mohamed", 23)
```

### in place of

```python
def fun(name: str, age: int) -> None:
    if isinstance(name, str) and isinstance(age, int):  # 50 char
        print(f"your name is {name} and your age is {age}")
        return
    raise TypeError("invalid arguments types")


fun("mohamed", 23)
```

but not just this there is other funcs and with a very advanced usage you can see the source code and check all the tests in the main fun.

## Installation

You can install `funx` via pip:

```bash
pip install funx
```

## License

This project is licensed under the MIT LICENSE - see the [LICENSE](https://opensource.org/licenses/MIT) for more details.
explain-cli 1.1.0
Explain repo state with Claude Code or Gemini CLI
License: MIT
Requires Python: >=3.7
Keywords: git, ai, cli, llm, explain

# explain-cli

Explain Git commits, PRs, and branch differences using Claude Code or Gemini CLI.

## Install

```bash
# uv
uv tool install explain-cli
# uv (source)
uv tool install https://github.com/ccmdi/explain-cli.git

# pip
pip install explain-cli
# pip (source)
pip install https://github.com/ccmdi/explain-cli.git
```

## Commands

```bash
# Explain commits
explain -C                    # Current commit
explain -C -s                 # Pick from recent commits

# Explain PRs  
explain -P                    # Current PR
explain -P -s                 # Pick from all PRs

# Compare branches
explain -D                    # Compare your current work vs master/main
explain -D feature..main      # Compare two branches

# Interactive selection
explain -D -s                 # Pick branches to compare
explain -D -f "*.py"          # Only Python files
explain -C abc1234 -c         # Copy to clipboard

# Configuration
explain --config              # Set AI provider & verbosity
```

## Requirements

- `git`
- `gh` CLI (for PRs)
- `gemini` CLI or `claude` code
tkinter-mcp-server 0.9.3
MCP server for inspecting and automating Tkinter GUI applications
License: MIT
Requires Python: >=3.10
Keywords: ai-agents, claude, gui-automation, llm, mcp, model-context-protocol, tkinter

# tkinter-mcp

MCP server for inspecting and automating Tkinter GUI applications.

[![PyPI](https://img.shields.io/pypi/v/tkinter-mcp-server.svg)](https://pypi.org/project/tkinter-mcp-server/)
[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
[![MCP](https://img.shields.io/badge/MCP-compatible-purple.svg)](https://modelcontextprotocol.io)

## Overview

An MCP server that enables AI agents to launch, inspect, and interact with Tkinter applications. The server auto-injects an inspection agent via monkey-patching. No modifications to target apps required.

![Demo](assets/demo.gif)

## Tools

| Tool | Description |
|------|-------------|
| `launch_app` | Start a Tkinter app with inspection enabled |
| `is_connected` | Check if an app is currently connected |
| `get_ui_layout` | Get the widget tree as structured JSON |
| `view_application` | Capture a high-quality JPEG screenshot |
| `view_application_thumbnail` | Capture a small thumbnail screenshot |
| `get_window_info` | Get window position and dimensions |
| `click_widget` | Click a widget (left/right/middle, single/double) |
| `type_text` | Type text into Entry or Text widgets |
| `get_widget_by_text` | Find a widget by its text content |
| `focus_widget` | Set keyboard focus to a widget |
| `get_focused_widget` | Get the currently focused widget |
| `get_widget_value` | Get widget value (Entry, Text, Scale, Checkbox, etc.) |
| `set_widget_value` | Set widget value based on widget type |
| `get_widget_options` | Get options for Combobox or Listbox |
| `drag_widget` | Drag and drop between two widgets |
| `close_app` | Terminate the application |

## Installation

### uvx (Quick Start)

```bash
claude mcp add tkinter-mcp-server -- uvx tkinter-mcp-server
```

> **Note:** Apps using PIL/ImageTk may have compatibility issues with uvx. Use pip install instead.

### pip (Recommended for PIL apps)

```bash
pip install tkinter-mcp-server
claude mcp add tkinter-mcp-server -- tkinter-mcp-server
```

### Claude Desktop

Add to your Claude Desktop configuration (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):

```json
{
  "mcpServers": {
    "tkinter": {
      "command": "tkinter-mcp-server"
    }
  }
}
```

For uvx: use `"command": "uvx"` with `"args": ["tkinter-mcp-server"]`

## How It Works

The server launches Tkinter apps through a custom launcher that patches `tkinter.Tk.__init__`. This injects an agent that communicates over a local socket, enabling thread-safe inspection and control of the GUI.

```mermaid
flowchart LR
    A[MCP Client] <--> B[MCP Server]
    B <--> C[Socket]
    C <--> D[Agent]
    D <--> E[Tkinter App]
```

## Requirements

- Python 3.10+
- macOS, Windows, or Linux

## License

MIT
camel-py 0.2.0
A lightweight Python client for Ollama with context management and streaming support.
License: MIT
Requires Python: >=3.12


# 🐪 Camel-py

A lightweight Python client for [Ollama](https://ollama.ai/) with built-in agentic capabilities and tool calling support.

---

## 🚀 Installation

```bash
pip install camel-py
```


## ⚡ Quickstart

### Basic Chat
```python
from camel import CamelClient

with CamelClient(model="llama3") as client:
    resp = client.chat("Hello, who are you?")
    print(resp.text)
    
    # Streaming
    print("Assistant: ", end="")
    client.stream("Tell me a joke about camels")
```

### AI Agent with Tool Calling
```python
from camel import CamelClient, Agent, Tool

def get_weather(location: str) -> str:
    return f"Weather in {location}: 72°F, sunny"

weather_tool = Tool(
    name="get_weather",
    description="Gets current weather for any location",
    schema={
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "City name"}
        },
        "required": ["location"]
    },
    function=get_weather
)

client = CamelClient(model="llama3")
agent = Agent(client, tools=[weather_tool])

result = agent.run("What's the weather in Paris?")
print(result)
```

## 🔧 Features

- **AI Agents**: Built-in tool calling via FunctionGemma (auto-installed)
- **Dual-model architecture**: Specialized tool detection + your choice for responses
- **Streaming**: Real-time token streaming
- **Context management**: Save/load/clear conversation history
- **Model management**: List, pull, delete Ollama models
- **Embeddings**: Generate text embeddings

## 📂 Examples

- [examples/agent.py](examples/agent.py) → AI agent with tool calling
- [examples/adv_chat.py](examples/adv_chat.py) → Context persistence

## 🛠️ How It Works

The Agent uses a two-model approach:
1. **FunctionGemma** detects when tools are needed
2. **Your chosen model** generates natural responses

This provides reliable tool calling while maintaining conversation quality.

## 📦 Requirements

- Python ≥3.12
- Ollama running locally