semvec/pypi-packages huggingface dataset:
llm-tools-datasette 0.1
Expose Datasette instances to LLM as a tool
Requires Python: >=3.9

# llm-tools-datasette

[![PyPI](https://img.shields.io/pypi/v/llm-tools-datasette.svg)](https://pypi.org/project/llm-tools-datasette/)
[![Changelog](https://img.shields.io/github/v/release/simonw/llm-tools-datasette?include_prereleases&label=changelog)](https://github.com/simonw/llm-tools-datasette/releases)
[![Tests](https://github.com/simonw/llm-tools-datasette/actions/workflows/test.yml/badge.svg)](https://github.com/simonw/llm-tools-datasette/actions/workflows/test.yml)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/simonw/llm-tools-datasette/blob/main/LICENSE)

Expose Datasette instances to LLM as a tool

## Installation

Install this plugin in the same environment as [LLM](https://llm.datasette.io/). You'll need at least the [0.26a1 alpha](https://llm.datasette.io/en/latest/changelog.html#a1-2025-05-25).
```bash
llm install llm-tools-datasette
```
## Usage

First find the URL to a _database_ within your Datasette instance. For example, `https://datasette.io/content`.

To use this with the [LLM command-line tool](https://llm.datasette.io/en/stable/usage.html):


```bash
llm --tool 'Datasette("https://datasette.io/content")' "Show tables" --td
```

This plugin works well with `llm chat`:

```bash
llm chat --tool 'Datasette("https://datasette.io/content")' --td
```
(Omit the `--td` option if you don't want to see debugging details.)

With the [LLM Python API](https://llm.datasette.io/en/stable/python-api.html):

```python
import llm
from llm_tools_datasette import Datasette

model = llm.get_model("gpt-4.1-mini")

result = model.chain(
    "Show most interesting tables",
    tools=[Datasette("https://datasette.io/content")],
).text()
```

## Development

To set up this plugin locally, first checkout the code. Then create a new virtual environment:
```bash
cd llm-tools-datasette
python -m venv venv
source venv/bin/activate
```
Now install the dependencies and test dependencies:
```bash
llm install -e '.[test]'
```
To run the tests:
```bash
python -m pytest
```
llm-tools-sqlite 0.1
LLM tools for running queries against SQLite
Requires Python: >=3.9

# llm-tools-sqlite

[![PyPI](https://img.shields.io/pypi/v/llm-tools-sqlite.svg)](https://pypi.org/project/llm-tools-sqlite/)
[![Changelog](https://img.shields.io/github/v/release/simonw/llm-tools-sqlite?include_prereleases&label=changelog)](https://github.com/simonw/llm-tools-sqlite/releases)
[![Tests](https://github.com/simonw/llm-tools-sqlite/actions/workflows/test.yml/badge.svg)](https://github.com/simonw/llm-tools-sqlite/actions/workflows/test.yml)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/simonw/llm-tools-sqlite/blob/main/LICENSE)

LLM tools for running queries against SQLite

## Installation

Install this plugin in the same environment as [LLM](https://llm.datasette.io/).
```bash
llm install llm-tools-sqlite
```
## Usage

To use this with the [LLM command-line tool](https://llm.datasette.io/en/stable/usage.html):

```bash
llm -T 'SQLite("content.db")' \
  "Count rows in the most interesting looking table" --td
```
Or use `llm chat` to chat with your database over multiple rounds:
```bash
llm chat -T 'SQLite("content.db")' 
```
This tool currently only supports read-only queries. Attempts to write to the database will fail with an error.

With the [LLM Python API](https://llm.datasette.io/en/stable/python-api.html):

```python
import llm
from llm_tools_sqlite import SQLite

model = llm.get_model("gpt-4.1-mini")

result = model.chain(
    "Show me the three most interesting looking tables",
    tools=[SQLite("content.db")]
)
for s in result:
    print(s, end="", flush=True)
```

## Development

To set up this plugin locally, first checkout the code. Then create a new virtual environment:
```bash
cd llm-tools-sqlite
python -m venv venv
source venv/bin/activate
```
Now install the dependencies and test dependencies:
```bash
llm install -e '.[test]'
```
To run the tests:
```bash
python -m pytest
```
aiopixooapi 0.2.2
Asynchronous Python library for Divoom Pixoo64 LED display
Requires Python: >=3.8


# AioPixooAPI

A Python library for interacting with Divoom Pixoo devices and the Divoom online API.

## Installation

Install the library using pip:

```bash
pip install aiopixooapi
```

## Usage

### Pixoo64 (Device API)

The `Pixoo64` class is used to interact with a Pixoo64 device on your local network.

```python
import asyncio
from aiopixooapi.pixoo64 import Pixoo64

async def main():
    async with Pixoo64("192.168.1.100") as pixoo:
        # Reboot the device
        response = await pixoo.sys_reboot()
        print(response)

        # Get all settings
        settings = await pixoo.get_all_settings()
        print(settings)

asyncio.run(main())
```

### Divoom (Online API)

The `Divoom` class is used to interact with the Divoom online API.

```python
import asyncio
from aiopixooapi.divoom import Divoom

async def main():
    async with Divoom() as divoom:
        # Get dial types
        dial_types = await divoom.get_dial_type()
        print(dial_types)

        # Get dial list for a specific type and page
        dial_list = await divoom.get_dial_list("Social", 1)
        print(dial_list)

asyncio.run(main())
```

## Development
### Setup
To set up the development environment, clone the repository, create a virtual environment and install the required packages

```bash
pip install -e .
pip install -e .[test]
```

## Running Tests

To run the tests using pytest, execute:

```bash
pytest
```

Or to run tests in a specific file:

```bash
pytest tests/test_pixoo64.py
```

## Documentation

http://docin.divoom-gz.com/web/#/5/23

### Sources used

#### Divoom

* https://divoom.com/apps/help-center#hc-pixoo64developeropen-sourcesdkapiopen-source

That gives us:

* http://doc.divoom-gz.com/web/#/12?page_id=89

Where the contact page:

* http://doc.divoom-gz.com/web/#/12?page_id=143

Send us to

* http://docin.divoom-gz.com/web/#/5/23

OLDER REFERENCES

* http://doc.divoom-gz.com/web/#/12
* http://doc.divoom-gz.com/web/#/7
* http://doc.divoom-gz.com/web/#/5

## License

This project is licensed under the GNU Affero General Public License v3.0 - see the LICENSE file for details.
translafast 1.0.4
Translate Python (.py) files into 178 languages using Google Translate.
Requires Python: >=3.7

# 🌍 TranslaFast

**TranslaFast** is a free, developer-friendly tool that automatically translates `.py` (Python) files into **178 different languages**, preserving the structure of the original code and replacing only visible UI text.

Built with 💡 Google Translate API and ready for both small projects and full-scale internationalization.

---

## 🚀 Features

✅ Detects and translates all user-facing strings (e.g. `print("Hello")`, `font.render("Game Over")`)  
✅ Translates to a specific language or **all 178 supported languages**  
✅ Free to use with `googletrans` (no API key required)  
✅ Outputs clean `.py` files per language (e.g. `app_fr.py`, `game_ar.py`, ...)  
✅ Works offline once installed  
✅ Command line friendly and easy to integrate

---

## 📦 Installation

### 1. Clone the repo

```bash
git clone https://github.com/yourusername/translafast-code-translator.git
cd translafast-code-translator
pywebcrwl 0.1.2
Web crawling tool
Requires Python: >=3.7

# pywebcrwl

**pywebcrwl** is a simple Python web crawler that extracts various types of information such as links, emails, phone numbers, keywords, and more from websites.

## Features

- Crawl and extract all pages from a given URL
- Extract email addresses (with optional domain filtering)
- Extract phone numbers (including international formats)
- Detect cities mentioned in the text
- Find matches for a given regular expression
- Extract all image URLs
- Extract all websites/domains mentioned on a page
- Extract downloadable documents (optionally by file extension)
- Extract raw HTML code of pages
- Identify keywords from the content
- Extract all sentences containing a specific word
- Extract website favicons
- Extract social media links
- Generate a summary (resume) of a page

## Installation

```bash
pip install pywebcrwl
crudtape 0.1.4
Simple in-memory CRUD store for rapid prototyping
Requires Python: >=3.8

# crudtape

> _"Like duct tape but for CRUD..."_  

A lightweight in-memory [CRUD](https://developer.mozilla.org/en-US/docs/Glossary/CRUD) store for Pydantic-style objects, designed for rapid prototyping. Powered by [TinyDB](https://tinydb.readthedocs.io/en/latest/index.html).

## Installation

```shell
pip install crudtape
```

Or add it as a dependency to you favorite build configuration file.

## Usage

The store is designed to work with any model class that implements the basic `Storable` [protocol](https://github.com/alesbukovsky/crudtape/blob/main/src/crudtape/store.py#L13), which defines a minimal subset of the Pydantic [model](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel/) interface.
Importantly, the store does not depend on Pydantic itself - you can use any compatible class. This means:

- Pydantic models (as-is)
- `@dataclass` decorated classes 
- Custom classes built from scratch

The only caveat is that the store manages the object IDs internally. In essence, a compatible model class needs to provide:

- `__init__` method that accepts keyword arguments, including an optional id of type int (used when constructing returned objects).
- `model_dump()` method returning a dictionary representation, excluding the `id` attribute (it will be ignored by the store otherwise).

An example model class using Pydantic:

```python
import BaseModel from pydantic

class Pet(BaseModel):
    name: str
    age: str
    id: int = None
```

The same but using `@dataclass` decorator:

```python
@dataclass
class Pet:
    name: str
    age: int
    id: int = None

    def model_dump(self, *args, **kwargs):
        return {"name": self.name, "age": self.age}
```

And once again, this time made from scratch:

```python
class Pet:
    def __init__(self, **data):
        self.name = data.get("name")
        self.age = data.get("age")
        self.id = data.get("id", None)

    def model_dump(self, *args, **kwargs):
        return {"name": self.name, "age": self.age}    
```        

The class is used to create a corresponding store instance:

```python
import Store from crudtape

store = Store(Pet)
```

The store offers basic self-explanatory CRUD operations, all typed to the specified model class and with decent error checking. See the [API reference](https://alesbukovsky.github.io/crudtape/) for full details.

```python
# insert an object
store.insert(Pet(name="Bob", age=3))

# list all objects 
store.all()

# get an object with given ID
store.get(1)

# update an object with given ID
store.update(1, Pet(name="Rob", age=5))

# delete an object with given ID
store.delete(1)
```

The store raises `StoreError` for general failures, with two exceptions: `NotFoundError` is raised when an object with the given ID doesn’t exist, and `TypeError` when an input object has the wrong type.