semvec/pypi-packages huggingface dataset:
mcai-worker-sdk 2.1.1
MCAI SDK to develop Python worker
License: MIT
Requires Python: >=3.8
Keywords: AMQP, micro-service, python

# Python SDK for Media Cloud AI workers

Based on [mcai_worker_sdk](https://gitlab.com/media-cloud-ai/sdks/rs_mcai_worker_sdk), this SDK uses the [PyO3 crate](https://github.com/PyO3/pyo3) to export a compiled module compatible with CPython ABI.

## Documentation

Please, check the docs [here](https://media-cloud-ai.gitlab.io/sdks/py_mcai_worker_sdk/mcai_worker_sdk/) and [here](https://media-cloud-ai.gitlab.io/sdks/py_mcai_worker_sdk/mcai_worker_sdk_media/) for the SDK with the media feature enabled.

## Build

Before using the Python module you should build it as a CPython library. This will require a virtualenv (where the module will be installed) and [maturin](https://github.com/PyO3/maturin) to compile the module.

```bash
virtualenv venv # Create your environment
source venv/bin/activate # Launch it
```

You can then either build the module in development mode (this will build and install the module in your virtualenv):

```bash
maturin develop --features extension-module # Build and install the module
```

Or build the wheel file and install it manually via `pip`:

```bash
maturin build --features extension-module # Build the wheel file to install the module
pip install path/to/generated/wheel/file
```

You will now be able to import the module in your Python's scripts by doing:

```python
import mcai_worker_sdk as mcai
```

Check out [maturin's docs](https://www.maturin.rs/distribution.html#build-wheels) for more information on building the module!

### Supported version

We intempt to support as many distribution and architecture as we can, however if `pip` doesn't find any compatible version for your installation it will download the source and try to compile them directly.

This operation supposes that you have at least __Rust 1.62__.

We currently support the following version of Python implementations:
- [x] CPython 3.8 : manylinux
- [x] CPython 3.9 : manylinux, macosx x86_64
- [x] CPython 3.10 : manylinux, macosx x86_64, macosx arm64
- [x] CPython 3.11 : manylinux, macosx arm54
- [x] Pypy 3.8 : manylinux
- [x] Pypy 3.9 : manylinux

And the following core architectures:
- [x] x86_64


## Test

To run tests you must have `json-strong-typing` installed:

```bash
pip install json-strong-typing
```

Then launch tests basically:

```bash
cargo test
cargo test --features media
```

### Running examples

#### Build the Python module

In your virtual environment:

```bash
maturin develop
```

#### Simple worker

```bash
RUST_LOG=debug \
SOURCE_ORDERS="examples/message.json" \
PYTHON_WORKER_FILENAME="worker.py" \
SOURCE_PATH="README.md" \
DESTINATION_PATH="README.md.out" \
python worker.py
```

#### Media worker

First set the media filename:

```bash
export SOURCE_PATH="/folder/filename.ext"
```

Then run the SDK with these parameters:

```bash
RUST_LOG=debug \
SOURCE_ORDERS="examples/message.json" \
PYTHON_WORKER_FILENAME="media_worker.py" \
DESTINATION_PATH="results.json" \
cargo run --features media
```
kassalappy 1.2.0
Python client for the Kassal.app API
License: MIT
Requires Python: <3.13,>=3.10

# kassalappy: Python Client for Kassal.app API

kassalappy is a Python client library designed to interact with the Kassalapp API, providing a convenient way to access its features programmatically. It also includes a command-line interface (CLI) for easy interaction with the API from the terminal.

## Features

- Asynchronous design using `aiohttp` for non-blocking API calls.
- Pydantic models for data validation and serialization.
- Custom exceptions for handling API errors.
- CLI with commands for health checks, managing shopping lists, searching products, and more.
- Tabulated output for CLI commands for better readability.

## Installation

To install kassalappy, you can use pip:

```bash
pip install kassalappy
```

## Usage

### As a Library

To use kassalappy as a library, you need to create an instance of the `Kassalapp` class with your API access token:

```python
from kassalappy import Kassalapp

client = Kassalapp(access_token='your_access_token_here')
```

You can then use the client to perform various operations, such as:

```python
# Check API health
health_status = await client.healthy()

# Get shopping lists
shopping_lists = await client.get_shopping_lists()

# Search for products
products = await client.product_search(search='milk')
```

### As a CLI

kassalappy also provides a CLI for interacting with the Kassalapp API. Here are some examples of CLI commands:

```bash
# Check API health
kassalappy health --token your_access_token_here

# Get shopping lists
kassalappy shopping-lists --token your_access_token_here

# Search for products
kassalappy product "milk" --token your_access_token_here
```

## Documentation

For more detailed information about the API endpoints and data models, refer to the official Kassalapp API documentation: [Kassal.app API Docs](https://kassal.app/docs/api)

## Contributing

Contributions to kassalappy are welcome! Please follow the standard GitHub flow for submitting pull requests.

## License

kassalappy is released under the MIT License. See the LICENSE file for more details.

---

This README provides a general overview of the kassalappy client. For specific details on the API methods and CLI commands, please refer to the source code and the official API documentation.
simplecmd-discordpy 2.0.1
Uma biblioteca mais simples para a criação de comandos no Discord.py
License: MIT
Requires Python: >=3.9
Keywords: simplecmd discordpy comandos

# **simplecmd_discordpy**

**(PT-BR):** Biblioteca simples para criar comandos no `discord.py`, ideal para iniciantes. Não visa substituir outras bibliotecas, mas oferece uma maneira fácil de configurar e organizar comandos para bots no Discord.

**(ENG):** A simple library to create commands for `discord.py`, perfect for beginners. It doesn't aim to replace other libraries, but provides an easier way to set up and organize commands for Discord bots.

---

## **Instalação**

Para instalar a biblioteca, execute o seguinte comando:
```bash
pip install simplecmd_discordpy
```


## Usage example
```python
import simplecmd_discordpy as scmd
import discord

TOKEN = "your_token_here"
scmd.config.set(logs=True, prefix=f"$") # Adiciona as configurações necessárias

intents = discord.Intents.default()
intents.message_content = True
client = discord.Client(intents=intents)

@scmd.command("ping") # Função para criar comandos
async def ping_cmd(msg, client, *args):
    if args:
        await msg.channel.send(f"Pong🏓" + ''.join(args[0]), reference=msg)
    else:
        await msg.channel.send(f"Pong🏓", reference=msg)

@client.event
async def on_message(message):
    if message.author.bot:
        return
    if message.author.id == client.user.id:
        return
    await scmd.load(message) # Carrega Todos Os Comandos
client.run(TOKEN)
```

## Example by Folder
```python
import discord
import simplecmd_discordpy as scmd

TOKEN = "your_token_here"
scmd.config.set(logs=True, prefix="$", folder="commands") # Adiciona as configurações necessárias

intents = discord.Intents.default()
intents.message_content = True
client = discord.Client(intents=intents)

@client.event
async def on_message(message):
    if message.author.id == client.user.id:
        return
    await scmd.load_files(message, client) # Carrega todos os comandos por arquivo

client.run(TOKEN)
```

* Já no arquivo `commands/say.py`
```python
import discord

async def run(msg, client, *args):
    if args:
        # Se houver argumentos passados para o comando
        argumento = " ".join(args)  # Junta todos os argumentos em uma única string
        await msg.channel.send(argumento)
    else:
        # Se não houver argumentos
        await msg.channel.send("Você precisa mencionar alguma coisa que o bot deve falar")
```
apis-acdhch-django-invite 0.2.0
Invite Links for APIS Instances
License: MIT
Requires Python: <4.0,>=3.11

# apis_acdhch_django_invite

Invite app for Django applications.

This app provides an invite link that only works with valid tokens. The invite tokens can be generated in Django's admin interface.
The invite endpoint is `/invite/<token>`.

# Installation

Add `apis_acdhch_django_invite` to your `INSTALLED_APPS`.
Include the apis-acdhch-django-invite urls in your `urls.py`:
```
urlpatterns += [path("", include("apis_acdhch_django_invite.urls")),]
```
spaceai 0.2.0
A Python library for space AI benchmarking
License: MIT
Requires Python: <4.0,>=3.10

<p align="center">
<picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/continualist/space-ai/refs/heads/main/docs/_static/images/logo.jpeg?"><img width=450 alt="spaceai-logo" src="https://raw.githubusercontent.com/continualist/space-ai/refs/heads/main/docs/_static/images/logo.jpeg"/>
</picture>
</p>

![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Feclypse-org%2Feclypse%2Fmain%2Fpyproject.toml)
[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&)](https://github.com/pre-commit/pre-commit)
[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)

[![Import sorted with isort](https://img.shields.io/badge/isort-checked-brightgreen)](https://pycqa.github.io/isort/)
[![IMport cleaned with pycln](https://img.shields.io/badge/pycln-checked-brightgreen)](https://github.com/hadialqattan/pycln)
[![Code style: black](https://img.shields.io/badge/code%20style-black-black)](https://github.com/psf/black)
[![Doc style: docformatter](https://img.shields.io/badge/doc%20style-docformatter-black)](https://github.com/PyCQA/docformatter)

SpaceAI is a comprehensive library designed for space mission data analysis and machine learning model benchmarking. It provides tools for data preprocessing, model training, and evaluation, specifically tailored for space-related datasets. The library includes implementations of various machine learning models, such as ESNs (Echo State Networks) and LSTMs (Long Short-Term Memory networks), and offers a range of utilities to facilitate the development and testing of these models. With SpaceAI, researchers and engineers can streamline their workflow and focus on deriving insights from space mission data.

Here's the link to the documentation: [https://space-ai.readthedocs.io/en/latest/](https://spaceai.readthedocs.io/en/latest/)

## Installation

To install SpaceAI and all its dependencies, you can run the following commands:
```bash

pip install spaceai

```

## Credits
We thank [eclypse-org](https://github.com/eclypse-org) and [Jacopo Massa](https://github.com/jacopo-massa) for the structure and the template of the documentation!