semvec/pypi-packages huggingface dataset:
synthpilot 1.1.1
AI-powered FPGA development with Vivado
Requires Python: >=3.10
Keywords: ai, eda, fpga, mcp, vivado

# SynthPilot

**Let AI build your FPGA designs.**

SynthPilot is an MCP (Model Context Protocol) server that gives AI assistants full control over AMD Vivado. **414 tools** covering the entire FPGA development flow — project management, synthesis, implementation, timing analysis, IP configuration, Block Design, simulation, debug, and device programming.

## Quick Start

```bash
# Install
pip install synthpilot

# Activate your free license
synthpilot activate YOUR-LICENSE-KEY

# Set up Vivado integration
synthpilot install

# Done! Open Vivado → start chatting with AI
```

## MCP Configuration

**Claude Desktop / Claude Code / Cursor:**

```json
{
  "mcpServers": {
    "synthpilot": {
      "command": "synthpilot"
    }
  }
}
```

Or with `uvx` (requires [uv](https://docs.astral.sh/uv/)):

```json
{
  "mcpServers": {
    "synthpilot": {
      "command": "uvx",
      "args": ["synthpilot"]
    }
  }
}
```

## Features

| | Free | Pro | Max |
|---|---|---|---|
| **Tools** | 39 | 380 | All 414 |
| **Project & Synthesis** | ✅ | ✅ | ✅ |
| **IP Config & Block Design** | — | ✅ | ✅ |
| **Simulation & Debug** | — | ✅ | ✅ |
| **Custom Tcl & Non-Project** | — | — | ✅ |
| **Devices** | 1 | 2 | 3 |

## Requirements

- Python 3.10+
- Windows x64
- AMD Vivado 2018.1+

## Links

- 📖 **Documentation:** [www.synthpilot.dev/docs.html](https://www.synthpilot.dev/docs.html)
- 🆓 **Get Free License:** [www.synthpilot.dev](https://www.synthpilot.dev)
- 📧 **Support:** support@synthpilot.dev
- 📋 **Issues:** [GitHub Issues](https://github.com/LNC0831/SynthPilot/issues)
aiodbcore 0.6.2
A modest orm that does not require you to adjust your code to it
Requires Python: >=3.12

# DBCore [![Python 3.12+](https://badgen.net/badge/Python/3.12+/blue)](https://www.python.org/downloads/) [![License:MIT](https://badgen.net/badge/License/MIT/blue)](https://github.com/AlexDev505/DBCore/blob/master/LICENSE.txt) [![PyPi version](https://img.shields.io/pypi/v/aiodbcore.svg)](https://pypi.python.org/pypi/aiodbcore/)

ORM that does not require the developer to create models specifically for it.
dbcore works with dataclasses and allows you to connect from one interface
to both local databases (sqlite+aiosqlite) and remote databases (postgres+asyncpg).


### Small example

```python
import os
import asyncio
from dataclasses import dataclass

from aiodbcore import AsyncDBCore


# a model in which only the id field gives out DB membership
@dataclass
class MyModel:
    id: int | None = None
    foo: int = 0
    bar: str = ""


class MyDB(AsyncDBCore[MyModel]):
    # there i can implement my queries
    async def my_simple_query(self) -> list[MyModel]:
        return await self.fetchall(MyModel, where=MyModel.foo > 10)


async def main():
    MyDB.init(os.environ["DB"])  # init db at start of program
    db = MyDB()
    data = await db.my_simple_query()
    first = data[0]
    first.foo += 100
    await db.save(first)
    await db.close_connections()


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

The declaration of the model from the example above is certainly simple and elegant, but this method does not allow the IDE to show type hints, and static typers will complain. Therefore, there is another way to declare models, it will require minimal changes in the code.

```python
from dataclasses import dataclas
from aiodbcore.models import Field

@dataclass
class MyModel:
    # Here you can wrap default values in `Field`
    # if you don't want complaints from static typers,
    # but it is not necessary
    id: Field[int | None] = Field(None)
    foo: Field[int] = 0
    bar: Filed[str] = ""
```

### Sync version

`SyncDBCore` has the same interface as the async version.
You just need to remove all the `async` and `await` statements.

```python
class MyDB(SyncDBCore[MyModel]):  # the same model `MyModel` is used
    def my_simple_query(self) -> list[MyModel]:
        return self.fetchall(MyModel, where=MyModel.foo > 10)
```

> Currently only `sqlite+sqlite3` is supported.


### Context manager declaration

Using the `Database` class allows you to select synchronous and asynchronous connections using the context manager.

```python
from aiodbcore import Database

class MyDB(Database[MyModel]): ...

MyDB.init("sqlite://db.sqlite")  # In this case, you cannot explicitly specify the library in the database path.

def sync_environment():
    with MyDB() as db:
        data = db.fetchall(MyModel)
        
async def async_environment():
    async with MyDB() as db:
        data = await db.fetchall(MyModel)
```


### Installation

You can install `aiodbcore` using pip:

```bash
pip install aiodbcore
```

for install all async providers (aiosqlite and asyncpg):

```bash
pip install aiodbcore[async]
```
ultimate-ai-labeller 0.1.5
AI Labelling tool for computer vision

# Ultimate AI Labeller

Desktop image annotation tool for object detection datasets (Tkinter + Ultralytics).

## Features

- Bounding-box annotation with drag, move, and resize handles
- Undo/redo history (`Ctrl+Z`, `Ctrl+Y`)
- Image navigation (`F` next/save, `D` previous)
- Auto red-region proposal (`A`)
- YOLO detection from UI (`Run Detection`)
- Startup source selection:
  - Open Images Folder
  - Open YOLO Dataset
  - Open RF-DETR Dataset
- Detection model management:
  - Official model mode (`yolo26m.pt` path by default)
  - Import custom models (`.pt`, `.onnx`) via `Browse Model`
  - Select model from dropdown library
- Auto-detect and propagate options
- Scrollable right settings panel
- Remove/restore bad frames from split
- Image dropdown jump
- Session resume (last project/split/image/model settings)
- English/Chinese UI switch and light/dark theme
- Export all annotations by format:
  - `YOLO (.txt)` full dataset export
  - `JSON` full dataset export (per-image annotation json)

## Dataset Structure

```text
your_project/
  images/
    train/
    val/
    test/
  labels/
    train/
    val/
    test/
```

- Image extensions: `.png`, `.jpg`, `.jpeg`
- Label format: YOLO txt (`class cx cy w h`, normalized)
- Full guide (ZH): `docs/dataset-structure-guide.md`

Removed frames are moved to:

```text
your_project/
  removed/
    train|val|test/
      images/
      labels/
```

## Install

From PyPI:

```bash
pip install ultimate_ai_labeller
```

From local wheel:

```bash
pip install dist/ultimate_ai_labeller-0.1.5-py3-none-any.whl
```

From source:

```bash
pip install .
```

For development:

```bash
pip install -e .
```

## Run

```bash
ai-labeller
```

Or:

```bash
python src/ai_labeller/main.py
```

## Shortcuts

- `F`: save and next image
- `D`: previous image
- `A`: auto red detection
- `Ctrl+Z`: undo
- `Ctrl+Y`: redo
- `Delete`: delete selected box

## Notes

- Default detection model mode is `Official YOLO26m.pt (Bundled)`.
- If the official model file is unavailable locally, import a custom `.pt/.onnx` model from the UI.
- To use your own Tk app icon, put `app_icon.png` in `src/ai_labeller/assets/`.
- Session file: `~/.ai_labeller_session.json`.