semvec/pypi-packages huggingface dataset:
haystack-praisonai 0.1.0
Haystack integration for PraisonAI multi-agent framework
Requires Python: >=3.9
Keywords: haystack, praisonai, ai-agents, multi-agent, llm, rag

# haystack-praisonai

[Haystack](https://haystack.deepset.ai/) integration for [PraisonAI](https://github.com/MervinPraison/PraisonAI) multi-agent framework.

## Installation

```bash
pip install haystack-praisonai
```

## Quick Start

```python
from haystack import Pipeline
from haystack_praisonai import PraisonAIComponent

# Create pipeline with PraisonAI component
pipeline = Pipeline()
pipeline.add_component("praisonai", PraisonAIComponent())

# Run the pipeline
result = pipeline.run({"praisonai": {"query": "Research the latest AI trends"}})
print(result["praisonai"]["response"])
```

## Using a Specific Agent

```python
from haystack_praisonai import PraisonAIComponent

# Use a specific agent
researcher = PraisonAIComponent(agent="researcher")
result = researcher.run(query="Research quantum computing")
print(result["response"])
```

## Configuration

| Parameter | Default | Description |
|-----------|---------|-------------|
| `api_url` | `http://localhost:8080` | PraisonAI server URL |
| `agent` | `None` | Specific agent to run |
| `timeout` | `300` | Request timeout in seconds |

## Prerequisites

Start PraisonAI server:

```bash
pip install praisonai
praisonai serve agents.yaml --port 8080
```

## Links

- [PraisonAI Documentation](https://docs.praison.ai)
- [Haystack Documentation](https://docs.haystack.deepset.ai)

## License

MIT
slack-praisonai-bot 0.1.0
Slack bot powered by PraisonAI multi-agent framework
Requires Python: >=3.9
Keywords: slack, bot, praisonai, ai-agents, multi-agent, llm

# slack-praisonai-bot

Slack bot powered by [PraisonAI](https://github.com/MervinPraison/PraisonAI) multi-agent framework.

## Installation

```bash
pip install slack-praisonai-bot
```

## Quick Start

1. **Create a Slack App**
   - Go to [api.slack.com/apps](https://api.slack.com/apps)
   - Create New App → From scratch
   - Enable Socket Mode and get App Token
   - Add Bot Token Scopes: `app_mentions:read`, `chat:write`, `commands`
   - Install to Workspace and get Bot Token

2. **Start PraisonAI Server**
   ```bash
   pip install praisonai
   praisonai serve agents.yaml --port 8080
   ```

3. **Run the Bot**
   ```bash
   export SLACK_BOT_TOKEN=xoxb-your-bot-token
   export SLACK_APP_TOKEN=xapp-your-app-token
   export PRAISONAI_API_URL=http://localhost:8080
   slack-praisonai-bot
   ```

## Slash Commands

| Command | Description |
|---------|-------------|
| `/ask <query>` | Ask PraisonAI agents |
| `/agent <name> <query>` | Ask a specific agent |
| `/agents` | List available agents |

## App Mentions

Mention the bot in any channel: `@PraisonAI What are the latest AI trends?`

## Configuration

| Environment Variable | Description |
|---------------------|-------------|
| `SLACK_BOT_TOKEN` | Bot token (xoxb-...) |
| `SLACK_APP_TOKEN` | App token (xapp-...) |
| `PRAISONAI_API_URL` | PraisonAI server URL |
| `PRAISONAI_TIMEOUT` | Request timeout (default: 300) |

## Links

- [PraisonAI Documentation](https://docs.praison.ai)
- [Slack Bolt Documentation](https://slack.dev/bolt-python)

## License

MIT
yscope-spider-py 0.2.1
A distributed task execution framework.
Requires Python: >=3.10

# spider-py

This project is a Python package that provides access to Spider, a distributed task execution
framework, enabling seamless integration and task management in Python applications.

## Building/Packing

To manually build a package for distribution, follow the steps below.

### Requirements

* [Task] >= 3.40.0
* [uv] >= 0.7.0
* [MariaDB C Connector][mariadb-c-connector] >= 3.3.1

### Build Commands

* Build a Python wheel:

```shell
task build:spider-py
```

The command above will generate both a `.tar.gz` and a `.whl` package in the `build/spider-py`
directory at the Spider project root.

## Testing

Unit tests are divided into two categories: storage and non-storage tests. Non-storage tests do not
require any external services, while storage tests require a MariaDB instance to be available.

### Non-Storage Unit Tests

To run all non-storage unit tests:

```shell
task test:spider-py-non-storage-unit-tests
```

### Setup MariaDB for Storage Unit Tests

To run storage unit tests, we need to create a MariaDB instance first.

```shell
docker run \
        --detach \
        --rm \
        --name spider-storage \
        --env MARIADB_USER=spider \
        --env MARIADB_PASSWORD=password \
        --env MARIADB_DATABASE=spider-storage \
        --env MARIADB_ALLOW_EMPTY_ROOT_PASSWORD=true \
        --publish 3306:3306 mariadb:latest
```

After the docker container starts, set up the database table manually by using the SQL script
`tools/scripts/storage/init_db.sql` from the project root.

```shell
mysql -h 127.0.0.1 -u spider -ppassword spider-storage < tools/scripts/storage/init_db.sql
```

### Storage Unit Tests

To run all storage unit tests:

```shell
task test:spider-py-storage-unit-tests
```

This requires a running MariaDB instance as described above.

### All Unit Tests

To run all unit tests (both storage and non-storage):

```shell
task test:spider-py-unit-tests
```

This requires a running MariaDB instance as described above.

## Linting

To run all linting checks:

```shell
task lint:spider-py-check
```

To run all linting checks AND automatically fix any fixable issues:

```shell
task lint:spider-py-fix
```

[Task]: https://taskfile.dev
[uv]: https://docs.astral.sh/uv/
[mariadb-c-connector]: https://mariadb.com/docs/connectors/mariadb-connector-c
django-mitre 0.2.1
MITRE ATT&CK and MBC ingesters, models, and views
Requires Python: >=3.10

# MITRE ATT&CK and MBC for Django

This package utilizes MITRE's open data to incorporate their knowledge base into a Django project. The indented goal of this project is to provide the data as Django Models for integration into project's using MITRE references. The display of that information is secondary and only available because it is advantageous to be able to visualize the data in a familiar way.

This project syncs with the open data provided by MITRE in a git repository. We consume that data into database records and slightly modify the data for better visual representation.


## Installation in a Django project

Please refer to the [installation docs](docs/install.md) for details.

### Using the Example Project

There is an `example` directory located in this repository that contains an example Django project with the app loaded within it. See [usage docs](docs/example.md) for details.


## License

GPL v3 (see `LICENSE` file)


## Copyright

© 2025 The Shadowserver Foundation
spdx-python-model 0.0.4
SPDX Model Python Bindings
Requires Python: >=3.9

# spdx-python-model

Generated Python code for SPDX Spec version 3

All bindings in this repository are generated using
[shacl2code](https://github.com/JPEWdev/shacl2code) at the time the package is
built.

**NOTE:** The bindings are pretty low level, intended for more directly
manipulating SPDX files. While they are fully functions, they lack higher level
helper functions that may be useful for creating SPDX documents. If you want a
higher level approach, please see the
[SPDX Python Tools](https://github.com/spdx/tools-python) (however this repo
doesn't yet support SPDX 3)

## Installation (PyPi)

```shell
python3 -m pip install spdx-python-model
```

## Installation (Git)

If you would like to pull the bindings directly from Git instead of using a
released version from PyPi, the following command can be used:

```shell
python3 -m pip install git+https://github.com/spdx/spdx-python-model.git@main
```

Note that this will pull the latest version from the `main` branch. If you want
a specific commit, replace `main` with the git commit SHA

## Usage

Each version of the SPDX spec has a module named `v{MAJOR}_{MINOR}_{MICRO}`
that contains the bindings for that version under the `spdx_python_model` top
level. For example:

```python
import spdx_python_model

p = spdx_python_model.v3_0_1.Person()
```

Alternatively, if a shorter name is desired, a specific version can be imported
with another name:

```python
from spdx_python_model import v3_0_1 as spdx_3_0

p = spdx_3_0.Person()
```

## Testing

This repository has support for running tests against the bindings using `pytest`.
To run the tests, first setup a virtual environment and install the development
variant of the package in editable mode:

```shell
python3 -m venv .venv
. .venv/bin/activate
pip install -e '.[dev]'
```

Then the tests can be run with:

```shell
pytest -vx
```

## Making a new release

To make a new release of this repository, bump the version number found in
`src/spdx_python_model/version.py`, and merge it into the repo. After this,
make a new release in GitHub with the name `v` + *VERSION*, where *VERSION*
matches the version number specified in `version.py` (e.g. `v1.0.0`).

After this, GitHub actions will do the rest to build the package and publish it
to PyPi
telegram-praisonai-bot 0.1.0
Telegram bot powered by PraisonAI multi-agent framework
Requires Python: >=3.9
Keywords: telegram, bot, praisonai, ai-agents, multi-agent, llm

# telegram-praisonai-bot

Telegram bot powered by [PraisonAI](https://github.com/MervinPraison/PraisonAI) multi-agent framework.

## Installation

```bash
pip install telegram-praisonai-bot
```

## Quick Start

1. **Create a Telegram Bot**
   - Message [@BotFather](https://t.me/BotFather) on Telegram
   - Send `/newbot` and follow the instructions
   - Copy the bot token

2. **Start PraisonAI Server**
   ```bash
   pip install praisonai
   praisonai serve agents.yaml --port 8080
   ```

3. **Run the Bot**
   ```bash
   export TELEGRAM_BOT_TOKEN=your_telegram_token
   export PRAISONAI_API_URL=http://localhost:8080
   telegram-praisonai-bot
   ```

   Or create a `.env` file:
   ```env
   TELEGRAM_BOT_TOKEN=your_telegram_token
   PRAISONAI_API_URL=http://localhost:8080
   PRAISONAI_TIMEOUT=300
   ```

## Commands

| Command | Description |
|---------|-------------|
| `/start` | Start the bot and show welcome message |
| `/help` | Show help message |
| `/ask <query>` | Ask PraisonAI agents a question |
| `/agent <name> <query>` | Ask a specific agent |
| `/agents` | List available PraisonAI agents |

You can also just send a message directly and the bot will process it.

## Usage Examples

```
/ask What are the latest trends in AI?
/agent researcher Research quantum computing
/agents
```

## Programmatic Usage

```python
from telegram_praisonai_bot.bot import PraisonAITelegramBot

bot = PraisonAITelegramBot(
    token="YOUR_TELEGRAM_TOKEN",
    api_url="http://localhost:8080",
    timeout=300
)
bot.run()
```

## Using the Client Directly

```python
import asyncio
from telegram_praisonai_bot import PraisonAIClient

async def main():
    client = PraisonAIClient(api_url="http://localhost:8080")
    
    # Run workflow
    result = await client.run_workflow("Research AI trends")
    print(result)
    
    # Run specific agent
    result = await client.run_agent("Write an article", "writer")
    print(result)
    
    # List agents
    agents = await client.list_agents()
    print(agents)

asyncio.run(main())
```

## Configuration

| Environment Variable | Default | Description |
|---------------------|---------|-------------|
| `TELEGRAM_BOT_TOKEN` | (required) | Telegram bot token from @BotFather |
| `PRAISONAI_API_URL` | `http://localhost:8080` | PraisonAI server URL |
| `PRAISONAI_TIMEOUT` | `300` | Request timeout in seconds |

## Links

- [PraisonAI Documentation](https://docs.praison.ai)
- [PraisonAI GitHub](https://github.com/MervinPraison/PraisonAI)
- [python-telegram-bot Documentation](https://python-telegram-bot.org)

## License

MIT
qolab 0.43
Classes and functions useful for the quantum optics lab: qolab.
Keywords: scope, lockin, spectrum analyser, multimeter, DAQ, feedback, post processing

# qolab

Classes and functions useful for the quantum optics lab: qolab.

Designed to run experimental hardware and data analysis with python.

The package `qolab` was started in April 2021 by Eugeniy E. Mikhailov
within Quantum Optics Lab (QOLab), which explains it name.

## Installation

~~~~
pip install qolab
~~~~

## Build instructions

To build a python wheel package and put it in `./dist/` directory, run

~~~~~
flit build
~~~~~
discord-praisonai-bot 0.1.0
Discord bot powered by PraisonAI multi-agent framework
Requires Python: >=3.9
Keywords: discord, bot, praisonai, ai-agents, multi-agent, llm

# discord-praisonai-bot

Discord bot powered by [PraisonAI](https://github.com/MervinPraison/PraisonAI) multi-agent framework.

## Installation

```bash
pip install discord-praisonai-bot
```

## Quick Start

1. **Create a Discord Bot**
   - Go to [Discord Developer Portal](https://discord.com/developers/applications)
   - Create a new application
   - Go to Bot → Add Bot
   - Copy the token
   - Enable "Message Content Intent" under Privileged Gateway Intents

2. **Invite Bot to Server**
   - Go to OAuth2 → URL Generator
   - Select scopes: `bot`, `applications.commands`
   - Select permissions: `Send Messages`, `Use Slash Commands`
   - Copy and open the generated URL

3. **Start PraisonAI Server**
   ```bash
   pip install praisonai
   praisonai serve agents.yaml --port 8080
   ```

4. **Run the Bot**
   ```bash
   export DISCORD_TOKEN=your_discord_token
   export PRAISONAI_API_URL=http://localhost:8080
   discord-praisonai-bot
   ```

   Or create a `.env` file:
   ```env
   DISCORD_TOKEN=your_discord_token
   PRAISONAI_API_URL=http://localhost:8080
   PRAISONAI_TIMEOUT=300
   ```

## Commands

| Command | Description |
|---------|-------------|
| `/ask <query>` | Ask PraisonAI agents a question |
| `/ask <query> <agent>` | Ask a specific agent (e.g., researcher) |
| `/agents` | List available PraisonAI agents |
| `/praisonai` | Show bot information |

## Usage Examples

```
/ask What are the latest trends in AI?
/ask Research quantum computing researcher
/agents
```

## Programmatic Usage

```python
from discord_praisonai_bot import PraisonAIBot

bot = PraisonAIBot(
    token="YOUR_DISCORD_TOKEN",
    api_url="http://localhost:8080",
    timeout=300
)
bot.run_bot()
```

## Using the Client Directly

```python
import asyncio
from discord_praisonai_bot import PraisonAIClient

async def main():
    client = PraisonAIClient(api_url="http://localhost:8080")
    
    # Run workflow
    result = await client.run_workflow("Research AI trends")
    print(result)
    
    # Run specific agent
    result = await client.run_agent("Write an article", "writer")
    print(result)
    
    # List agents
    agents = await client.list_agents()
    print(agents)

asyncio.run(main())
```

## Configuration

| Environment Variable | Default | Description |
|---------------------|---------|-------------|
| `DISCORD_TOKEN` | (required) | Discord bot token |
| `PRAISONAI_API_URL` | `http://localhost:8080` | PraisonAI server URL |
| `PRAISONAI_TIMEOUT` | `300` | Request timeout in seconds |

## Links

- [PraisonAI Documentation](https://docs.praison.ai)
- [PraisonAI GitHub](https://github.com/MervinPraison/PraisonAI)
- [Discord.py Documentation](https://docs.pycord.dev)

## License

MIT