semvec/pypi-packages huggingface dataset:
qds-run 0.1.1
Quick Dirty Scripts
License: MIT
Requires Python: <4.0,>=3.10

# qds

`qds` (Quick Dirty Scripts) is a CLI tool that lets you create and run quick Python scripts from the command line with minimal setup.

## Installation

Install via pip:

```bash
pip install qds-run
```

## Overview

When you first run any `qds` command, it initializes a directory in your home folder:

- **`~/.qds/qds.toml`**
  A TOML file containing metadata about your scripts.

- **`~/.qds/<script>.py`**
  Python files where each script’s code lives.

You can then add, edit, list, rename, run, and delete these scripts directly from your terminal.

## Basic Usage

1. **Initialize your workspace**
   The first time you invoke any command, `~/.qds/qds.toml` and the `~/.qds/` folder will be created automatically.

2. **Create a new script skeleton**

   ```bash
   qds add <script_name>
   ```

   For example:

   ```bash
   qds add base64conv
   ```

   You’ll be prompted to enter a description; after confirming, a file named `~/.qds/base64conv.py` is created.

3. **Edit your script**
   Open `~/.qds/base64conv.py` in your editor. By default, it will contain a template like this:

   ```python
   from qds import qds

   @qds(
       args=[("text", str, "Sample text to be provided")],
   )
   def run(text: str) -> str:
       pass
   ```

   - **`@qds` decorator**

     - `args`: a list of `(name, type, description)` tuples defining the arguments your script accepts.

   - **`run` function**

     - The entry point; return a string to be printed.

4. **Run your script**

   You will be prompted to fill in the arguments.

   ```bash
   qds run base64conv
   ```

## Example: Text to Base64 Converter

1. Add the script:

   ```bash
   qds add base64conv
   ```

2. Edit `~/.qds/base64conv.py` so that `run` looks like this:

   ```python
   import base64
   from qds import qds

   @qds(
       args=[("text", str, "Text to encode to Base64")],
   )
   def run(text: str) -> str:
       encoded = base64.b64encode(text.encode("utf-8")).decode("utf-8")
       return encoded
   ```

3. Use it:

   ```bash
   $ qds run base64
   ```

## Available Commands

| Command         | Description                           |
| --------------- | ------------------------------------- |
| `qds add`       | Create a new script skeleton          |
| `qds delete`    | Delete an existing script             |
| `qds list`      | List all available scripts            |
| `qds rename`    | Rename a script                       |
| `qds run`       | Run a script with the given arguments |
| `qds update`    | Update the description of a script    |
| `qds view`      | Show the source code of a script      |
| `qds --help`    | Display help message                  |
| `qds --version` | Display application version           |
fastapi-filter-sort 0.1.5
Smart filtering, sorting, and searching for FastAPI with SQLAlchemy
License: MIT
Requires Python: <4.0,>=3.10
Keywords: fastapi, sqlalchemy, filters, query, sort, search, pagination, api, rest

# FastAPI Filter and Sort

This project is a FastAPI application that demonstrates filtering and sorting functionality for API endpoints.

## Features

- Filtering data based on query parameters
- Sorting data based on query parameters
- Easy to extend and customize

## Requirements

- Python 3.10+
- FastAPI
- SQLAlchemy
- Uvicorn
- Poetry

## Setup

1. Clone the repository:
    ```sh
    git clone https://github.com/bhadri01/fastapi-filter-sort.git
    cd fastapi-filter-sort
    ```
2. Create a virtual environment:
    ```sh
    python -m venv .venv
    . .venv/bin/activate
    ```

3. Install Poetry if you haven't already:
    ```sh
    pip install poetry
    ```

4. Install the dependencies:
    ```sh
    poetry lock
    poetry install
    ```

5. Run the application:
    ```sh
    poetry run python examples/main.py
    ```

## Contributing

1. Fork the repository.
2. Create a new branch (`git checkout -b feature/branch-name`).
3. Commit your changes (`git commit -am 'Add new feature'`).
4. Push to the branch (`git push origin feature/branch-name`).
5. Create a new Pull Request.

## License

This project is licensed under the MIT License.
epub-translate 0.0.1
Simple cli tool for translating ebooks in EPUB format into any language.
License: MIT
Requires Python: <4.0.0,>=3.10.0
Keywords: epub, ebook, translate, cli, translation, translator

<div align="center">
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/SpaceShaman/epub-translate/refs/heads/master/assets/logo-light.png" width="100" alt="epub-translate">
    <img src="https://raw.githubusercontent.com/SpaceShaman/epub-translate/refs/heads/master/assets/logo-dark.png" width="100" alt="epub-translate">
  </picture>
  <p><strong>epub-translate:</strong> a simple cli tool for translating ebooks in EPUB format into any language</p>
</div>

----
<div align="center">

[![GitHub License](https://img.shields.io/github/license/SpaceShaman/epub-translate)](https://github.com/SpaceShaman/epub-translate?tab=MIT-1-ov-file)
[![Tests](https://img.shields.io/github/actions/workflow/status/SpaceShaman/epub-translate/release.yml?label=tests)](https://app.codecov.io/github/SpaceShaman/epub-translate)
[![Codecov](https://img.shields.io/codecov/c/github/SpaceShaman/epub-translate)](https://app.codecov.io/github/SpaceShaman/epub-translate)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/epub-translate)](https://pypi.org/project/epub-translate)
[![PyPI - Version](https://img.shields.io/pypi/v/epub-translate)](https://pypi.org/project/epub-translate)
[![Typer](https://img.shields.io/badge/cli-Typer-blue?logo=typer&logoColor=blue)](https://typer.tiangolo.com/)
[![Code style: black](https://img.shields.io/badge/code%20style-black-black)](https://github.com/psf/black)
[![Linting: Ruff](https://img.shields.io/badge/linting-Ruff-black?logo=ruff&logoColor=black)](https://github.com/astral-sh/ruff)
[![Pytest](https://img.shields.io/badge/testing-Pytest-red?logo=pytest&logoColor=red)](https://docs.pytest.org/)

</div>

## Installation

You can install `epub-translate` using pip:

```bash
pip install epub-translate
```

## Usage

You can use `epub-translate` from the command line:

```bash
epub-translate translate <input_file> <output_language>
```

## Configuration

Before you can use `epub-translate`, you need to configure it with your OpenAI API key. You can do this using the following command:

```bash
epub-translate configure --api-key <your_openai_api_key>
```

You can also set the specific model you want to use for translation:

```bash
epub-translate configure --model <your_model_name>
```
grok-export-viewer 0.1.3
Convert and browse Grok Chat export JSON as Markdown, HTML, CSV, SQLite, and JSON.
License: MIT
Requires Python: >=3.8
Keywords: chat, converter, csv, export, grok, html, json, markdown, sqlite

# Grok Export Viewer

[![PyPI](https://img.shields.io/pypi/v/grok-export-viewer)](https://pypi.org/project/grok-export-viewer/)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/your-username/grok-export-viewer/blob/main/LICENSE)
[![Python](https://img.shields.io/pypi/pyversions/grok-export-viewer)](https://pypi.org/project/grok-export-viewer/)

Convert, browse, and search your **Grok Chat export** (`prod-grok-backend.json`) offline into **Markdown**, **HTML (with live search)**, **CSV**, **SQLite**, or **JSON**.

## Installation

```bash
pip install grok-export-viewer
```

## Usage

```bash
# Place your JSON file in data/
grok-export-viewer -s data/prod-grok-backend.json -f html
open data/html/index.html  # macOS (use xdg-open on Linux, start on Windows)

# Other formats: md, csv, json, sqlite
grok-export-viewer -s data/prod-grok-backend.json -f csv
```

## Sample Input JSON

Below is an example structure for prod-grok-backend.json:

```json
{
  "conversations": [
    {
      "conversation": { "title": "Sample Chat" },
      "responses": [
        { "response": { "sender": "user", "message": "Hello" } },
        { "response": { "sender": "grok", "message": "Hi!" } }
      ]
    }
  ]
}
```

## Features

- Convert Grok JSON exports to multiple formats.
- HTML output includes a searchable index.
- Lightweight and offline processing.
- Supports Python 3.8+.

## Development

```bash
git clone https://github.com/your-username/grok-export-viewer.git
cd grok-export-viewer
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
pip install -e ".[test]"
python -m pytest
```

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.

## Changelog

See [CHANGELOG.md](CHANGELOG.md) for release history.

## License

MIT License. See [LICENSE](LICENSE) for details.
iloveapi 1.0.0
Python api client made for iLoveIMG & iLovePDF based on iLoveAPI (https://www.iloveapi.com/docs/api-reference).
License: MIT
Requires Python: >=3.9
Keywords: iloveapi, iloveimg, ilovepdf, api, sdk, client

# iloveapi-python

Python api client made for iLoveIMG & iLovePDF based on iLoveAPI (https://www.iloveapi.com/docs/api-reference).

## Features

- Fully typed code
- Asyncio support
- REST API & workflow API encapsulation

## Installation

```shell
pip install iloveapi
```

## Getting Started

Simply compress image:

```python
from iloveapi import ILoveApi

client = ILoveApi(
    public_key="<project_public_******>",
    secret_key="<secret_key_******>",
)
task = client.create_task("compressimage")
task.process_files("p1.png")
task.download("output.png")
```

Multiple images:

```python
task = client.create_task("compressimage")
task.process_files(
    "p1.png",
    ("custom_name.png", "p2.png"),
    ("custom_name.png", b"..PNG..."),
    {
        "file": b"..PNG...",
        "filename": "custom_name.png",
        "rotate": 2,  # add image parameter
        "password": "xxx",  # for PDF
    }
)
task.download("output.zip")  # zip format
```

Async support:

```python
task = await client.create_task_async("compressimage")
await task.process_files_async("p1.png")
await task.download_async("output.png")
```

Directly call REST API:

```python
response = client.rest.start("compressimage")  # getting httpx response
response = await client.rest.start_async("compressimage")  # async
```

## TODO

- [ ] Typed parameter for all processing tools
- [ ] Command-line interface

## Why not pydantic?

Image / PDF processing tools usually focus on results rather than JSON data, as data type validation is not important to the user.