semvec/pypi-packages huggingface dataset:
iauto 0.1.10
iauto is a low-code engine for building and deploying AI agents
License: MIT
Requires Python: >=3.8
Keywords: AI, Automation, LLM, RPA

<img src="./docs/assets/img/icon.svg" title="iauto" height="128">

[Documentation](https://shellc.github.io/iauto)

# iauto

`iauto` is a low-code engine for building and deploying AI agents.

- **AI**: Cutting-edge AI capabilities.
- **Low-Code**: Define your agents using YAML.
- **Automation**: Integrated automation frameworks like [Appium](https://github.com/appium/appium) and [Playwright](https://playwright.dev/python/).
- **Extensible**: Well-designed Python API.

## News

- Integrated [autogen](https://github.com/microsoft/autogen): Create your Multi-Agent system efficiently with iauto.
- Run most open source LLMs locally using [llama.cpp](https://github.com/ggerganov/llama.cpp) and [llama-cpp-python](https://github.com/abetlen/llama-cpp-python).

## Quick Start

### Installation

Python version requirement: >=3.8

`iauto` can be installed from PyPI using `pip`. It is recommended to create a new virtual environment before installation to avoid conflicts.

```bash
pip install -U iauto
```

If you want to run LLM locally, you can enable hardware acceleration in the following ways.

To enable cuBLAS acceleration on NVIDIA GPU:

```bash
CMAKE_ARGS="-DGGML_CUBLAS=ON" pip install -U iauto
```

To enable Metal on Apple silicon devices:

```bash
CMAKE_ARGS="-DGGML_METAL=ON" pip install -U iauto
```

## Command-line tool

Usage:

```bash
python -m iauto --help

or

ia --help
```

Run playbook:

```bash
ia run ./your-plabook.yaml
```

**[Example playbooks](./playbooks)**

## Playground

`iauto` provides a web-based application for running playbooks, LLM Chat, ReAct reasoning, and Multi-Agent tasks.

Launch playground:

```bash
ia playground
```

**Screenshot:**

![Playground screenshot](./docs/assets/img/screenshot_playground_llm.png)

## Contribution

We are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.

### Development setup

- Code Style: [PEP-8](https://peps.python.org/pep-0008/)
- Docstring Style: [Google Style](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html)

```bash
# Create python venv
python -m venv .venv
source .venv/bin/activate

# Install dependencies
pip install -r requirements.txt
pip install -r requirements-dev.txt

# Apply autopep8, isort and flake8 as pre commit hooks
pre-commit install
```

### Build

```bash
./build.sh
```

## License

[MIT](./LICENSE)

<img src="./docs/assets/img/icon.svg" title="iauto" height="16"> icon license: https://openmoji.org/library/emoji-1F9BE
streamlit-process-manager 0.0.1a0
Manage the heck out of long-running processes in streamlit
License: MIT
Requires Python: !=3.9.7,>=3.8

# Streamlit Process Manager
![Streamlit Process Monitor Animation](.github/ProcessMonitor.gif)

Let's be honest, trying to manage external processes or subprocesses from a [Streamlit](https://github.com/streamlit/streamlit) app is tricky. The execution model makes it difficult to keep track of which processes are supposed to be running and which ones aren't. Half the time you end up spawning twenty different processes all trying to access the same file and stomping all over one another.

Streamlit Process Manager attempts to make a that a bit easier. It looks something like this:

```python
import streamlit_process_manager as spm

# Get the global ProcessManager
pm = spm.get_manager()

# Configure the Process and start it
my_program = ["python", "my_program.py"]
output_file = "program_output.txt"
process = pm.single(spm.Process(my_program, output_file))
process.start_safe()

# Run the process and monitor it in streamlit!
spm.st_process_monitor(process).loop_until_finished()
```

> ⚠️ **DISCLAIMER** ⚠️
>
> Runing processes on your machine from a public-facing
  application like a Streamlit app can be _incredibly_ risky and comes
  with all sorts of security considerations. Use this project on public apps
  at your own risk, and **never** inject user-provided values or arguments
  into your processes without serious consideration of all the possible injection
  attacks you might be opening your server up to.

## Installation

`pip install streamlit-process-monitor`

Requires
* `Python 3.8.*` or above
* `Streamlit 1.30.*` or above
* `psutil 5.9.8` or above


## Development

This project uses [`pdm`](https://pdm-project.org/) for most of its development tooling. Ensure you have `python3.8` installed, then run

```
pip install pdm
pdm venv create 3.8
pdm install --dev --group test --group lint
```

to get started, then run

```
pdm check
```

to verify that everything is set up and ready to go.

> If you must use Python 3.12 or greater, you may have issues with numpy 1.24 needing to be
  built from source since it only supports python versions up to 3.11.

### Testing with tox

If you have multiple versions of Python available on your system you can use `tox` to run tests
on all of them at once. `tox` should be installed when you install the `--dev` dependencies so
you can just run it. Any Python's not available on your system will be skipped.

```
pdm run tox
```