semvec/pypi-packages huggingface dataset:
dodil 0.0.8
DODIL Python SDK
Requires Python: <4.0,>=3.10

# DODIL Python SDK

The **DODIL Python SDK** lets you interact with DODIL services from Python.

Currently supported services:

- **VNG**: multi-modal vector ingestion
- **VBase**: vector database (Milvus-backed)
- **VSpace**: integrated embedding + storage structure

---

## Install

```bash
pip install dodil
```

---

## Quick start

Create a client using a **service account**:

```python
from dodil import Client

c = Client(
    profile="staging",  # or "prod"
    service_account_id="...",
    service_account_secret="...",
)
```

VBase (connect + list collections):

```python
from dodil import VBaseConfig

vbase = c.vbase.connect(
    VBaseConfig(
        host="vbase-db-<id>.infra.dodil.cloud",
        port=443,
        scheme="https",
        db_name="db_<id>",
    )
)

print(vbase.list_collections())

vbase.close()
c.close()
```

## VSpace

For varied use cases involving embedding + storage, the SDK provides a **VSpace** structure. This allows you to embed texts via VNG and store/search them in VBase with single commands.

### 1) Initialize VSpace

```python
space = c.vspace.connect()
col_name = space.setup(dim=1024)  # Setup space with desired embedding dimension
```

### 2) Index data

```python
from dodil.vng import EmbeddingTask

space.add(
    data=[
        "apple",
        "banana",
        # Example: embedding an image from URL
        "https://example.com/cherry.jpg"
    ],
    ids=[1, 2, 3],  # Optional manually assigned IDs
    vng_task=EmbeddingTask.INDEX
)
```

### 3) Search data

```python
# Search with text
results = space.search(
    query="fruit",
    limit=5,
    vng_task=EmbeddingTask.QUERY,
    output_fields=["text", "id"]
)

print(f"Found {len(results)} results:")
for i, hit in enumerate(results):
    print(f"\nResult {i+1}:")
    print(f"  Score: {hit.get('distance'):.4f}")

```

## 4) Visualize

```python
space.visualize()
```

---

## Documentation

- [Tutorial](https://github.com/dodilio/sdk-dodil-python/blob/0.1/docs/tutorial.md)
- [Multi-model Vector Embedding (VNG)](https://github.com/dodilio/sdk-dodil-python/blob/0.1/docs/vng/overview.md)
- [Vector Database (VBase)](https://github.com/dodilio/sdk-dodil-python/blob/0.1/docs/vbase/overview.md)

## Examples

Check out the [examples/](https://github.com/dodilio/sdk-dodil-python/tree/0.1/examples) directory for more usage scenarios:

- [Index Dropbox](https://github.com/dodilio/sdk-dodil-python/blob/0.1/examples/index_dropbox.ipynb)
- [Index Google Drive](https://github.com/dodilio/sdk-dodil-python/blob/0.1/examples/index_google_drive.ipynb)

---

## Development

```bash
uv sync
pytest
```

---

## Contributing

We welcome issues and pull requests.

	–	Keep public APIs stable (prefer additive changes).
	–	Maintain backward compatibility where possible.
	-	Add tests for bug fixes and new features.
	-	Format and lint before opening a PR.

Project conventions

	-	Root client: Client
	-	Services are accessed through handles (e.g. client.vng, client.vbase).
	-	Bound service clients are created via .connect(...)
isa-agent-sdk 0.1.0
isA Agent SDK - Build AI agents with human-in-the-loop capabilities, MCP integration, and advanced features
Requires Python: >=3.10
Keywords: ai, agent, sdk, llm, claude, anthropic, human-in-the-loop, mcp, model-context-protocol, langchain, langgraph

# isA Agent SDK

A complete AI Agent SDK for building intelligent agents with advanced features. Compatible with Claude Agent SDK patterns, with additional capabilities.

## Features

- **Claude Agent SDK Compatible** - Familiar API patterns
- **Streaming Messages** - Real-time response streaming
- **Built-in Tools** - Read, Write, Edit, Bash, WebSearch, etc.
- **MCP Integration** - Model Context Protocol support
- **Human-in-the-Loop** - Durable execution with checkpoints
- **Skills System** - Prompt injection and customization
- **Event Triggers** - Proactive agent activation
- **Multiple Execution Modes** - Reactive, Collaborative, Proactive

## Installation

```bash
pip install isa-agent-sdk

# With FastAPI server support
pip install isa-agent-sdk[server]
```

## Quick Start

### Basic Query

```python
from isa_agent_sdk import query, ISAAgentOptions

# Simple usage
async for msg in query("Hello, world!"):
    print(msg.content)

# With options
async for msg in query(
    "Fix the bug in auth.py",
    options=ISAAgentOptions(
        allowed_tools=["Read", "Edit", "Bash"],
        execution_mode="collaborative"
    )
):
    if msg.is_text:
        print(msg.content, end="")
    elif msg.is_tool_use:
        print(f"[Tool: {msg.tool_name}]")
```

### Human-in-the-Loop

```python
from isa_agent_sdk import request_tool_permission, checkpoint

# Request permission before dangerous operations
authorized = await request_tool_permission(
    "delete_file",
    {"path": "important_data.txt"}
)
if authorized:
    # proceed with deletion
    pass

# Create checkpoints for durable execution
await checkpoint("about_to_deploy", {
    "version": "1.0.0",
    "environment": "production"
})
```

### HTTP Client (for deployed apps)

```python
from isa_agent_sdk import ISAAgent

client = ISAAgent(base_url="http://localhost:8000")

# Non-streaming
response = client.chat.create(
    message="Explain quantum computing",
    user_id="user123"
)
print(response.content)

# Streaming
for event in client.chat.stream(
    message="Write a Python function",
    user_id="user123"
):
    if event.is_content:
        print(event.content, end="")
```

### Building a FastAPI Agent Service

```python
from fastapi import FastAPI
from isa_agent_sdk import query, ISAAgentOptions

app = FastAPI()

@app.post("/query")
async def agent_query(prompt: str):
    responses = []
    async for msg in query(prompt):
        if msg.is_text:
            responses.append(msg.content)
    return {"response": "".join(responses)}
```

## Execution Modes

- **Reactive** - Responds to explicit requests
- **Collaborative** - Checkpoints for human approval
- **Proactive** - Anticipates needs, suggests actions

## License

MIT
datamuse 0.3.0
datamuse is a simple wrapper around the datamuse api https://www.datamuse.com/api/
Requires Python: >=3.11

# datamuse

__datamuse__ is a simple wrapper around the [datamuse api](https://www.datamuse.com/api/)

## Installing
- _datamuse_ is available on [pypi](https://pypi.org/project/datamuse/)
- You can install _datamuse_ via _pip_:

```shell
pip install datamuse
```

## Acknowledgements

- [Harvey Beeferman, 1942–2024](https://beeferman.org/harvey/)
- [datamuse](https://www.datamuse.com/)
maxplotlibx 0.1.3
A reproducible plotting module with various backends and export options.
Requires Python: >=3.8
Keywords: matplotlib

# maxplotlib

This is a wrapper for matplotlib so I can produce figures with consistent formatting. It also has some pretty nice additions such as using layers and exporting to tikz.

## Install

Create and activate python environment

```
python -m venv env
source env/bin/activate
pip install --upgrade pip
```

Install the code and requirements with pip

```
pip install -e .
```

Additional dependencies for developers can be installed with

```
pip install -e ".[dev]"
```

Some examples can be found in `tutorials/`
coldblue 0.1.6
Modern dark theme for Django Admin
Requires Python: >=3.8
Keywords: django, django-admin, admin-theme, dashboard

# ColdBlue

ColdBlue is a modern, minimal dark theme for Django Admin.  
It enhances the default admin UI with a clean design, dashboard stats, optional grouped navigation, and improved mobile usability — while staying fully compatible with Django’s core admin system.

---
## Screenshots

### Login
![Login](https://raw.githubusercontent.com/jiyo-pv/coldblue/main/assets/login_ui.png)

### Dashboard
![Dashboard](https://raw.githubusercontent.com/jiyo-pv/coldblue/main/assets/dashboard_ui.png)

### Mobile UI
![Mobile](https://raw.githubusercontent.com/jiyo-pv/coldblue/main/assets/mobile_ui.jpg)

## Features

- Modern dark UI (no JavaScript frameworks)
- Dashboard statistics (model counts)
- Optional grouped sidebar navigation
- Mobile-friendly layout
- Respects Django admin permissions
- Drop-in app (no admin rewrites)

---

## Installation

pip install coldblue

Add ColdBlue to your INSTALLED_APPS before django.contrib.admin:
```
INSTALLED_APPS = [
    "coldblue",
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
]
```
---

## Configuration

### Core Theme Settings
```
COLDBLUE_SETTINGS = {
    "ENABLE_STATS": True,
    "STATS_LIMIT": 6,
    "STAT_SORT": "count_desc",  # or "alpha" or "count_asc"
    "SITE_HEADER": "Admin Panel",
    "SITE_TITLE": "Admin Login",
    "INDEX_TITLE": "Dashboard",
}
```
---

### Sidebar Configuration (Optional)
```
COLDBLUE_SIDEBAR = {
    "ENABLE": True,
    "SECTIONS": [
        {
            "label": "Authentication",
            "icon": "fa-user-shield",
            "models": [
                "auth.User",
                "auth.Group",
            ],
        },
        {
            "label": "Shop",
            "icon": "fa-box",
            "models": [
                "shop.Product",  # app.Model
                "shop.Category",
            ],
        },
    ],
}
```

If ENABLE=True and no SECTIONS are provided, ColdBlue will automatically group models by app label.

---

### Icon Overrides (Optional)
```
COLDBLUE_ICON_OVERRIDES = {
    "user": "fa-user-shield",
    "product": "fa-box-open",
}
```
Fallback icon: fa-database

---

## Dashboard

ColdBlue replaces the default admin index with:

- Model cards
- Optional statistics panel
- Recent actions panel
- Clean layout optimized for large and small screens

---

## Mobile Support

- Responsive layout
- Sidebar adapts to small screens
- No breaking admin functionality

---

## Compatibility

- Django 4.x, 5.x
- Works with default admin templates
- Does not override admin views or permissions

---

## What ColdBlue Does NOT Do

- No admin logic changes
- No database migrations
- No JavaScript-heavy UI frameworks

---

## License

MIT License