semvec/pypi-packages huggingface dataset:
droidflow 0.0.2.2
A multi agent orchestrator library
Requires Python: >=3.7

# droidflow

**droidflow** is a lightweight multi-agent orchestration library designed to coordinate reasoning, planning, and tool-using agents. It is built for financial and data-driven applications, but is flexible enough for general AI agent workflows.

---

## Features

- **PlannerAgent** – Breaks down a user query into minimal actionable steps  
- **RouterAgent** – Routes sub-tasks to the appropriate specialized agent  
- **DomainAgent** – Wraps tools (functions/APIs) into callable interfaces  
- **ReasonerAgent** – Executes reasoning with tool calls when needed  
- Simple `State` & `History` management for contextual workflows  
- Easy integration with LLMs (Google Generative AI, OpenAI, etc.)  

---

## Installation

```bash
pip install droidflow

## Quick Example

```python
from droidflow.planer import PlannerAgent
from droidflow.router import RouterAgent
from droidflow.domain import DomainAgent, ToolFunction
from droidflow.model import State

# Example tool function
def get_stock_price(symbol: str) -> str:
    return f"Price of {symbol} is 100"

# Register tool
tool_fn = ToolFunction("get_stock_price", get_stock_price, state_enabled=False)

# Dummy LLM (replace with Google Generative AI, OpenAI, etc.)
class DummyLLM:
    def generate_content(self, prompt):
        print(f"[LLM called] {prompt}")
        class Response: text = "SINGLE_CALL"
        return Response()

llm = DummyLLM()

# Create agents
stock_agent = DomainAgent(llm, [tool_fn], name="stock_agent", mode=True)
planner = PlannerAgent(llm, "You are a planner for stock tasks.")
router = RouterAgent(llm, agents=[stock_agent])

# Run
plans = planner.plan("Get the price of AAPL stock")
print("Plans:", plans)

result = router.route(plans)
print("Final result:", result)
viihdecli 0.22.1
Command line interface for handling Elisa Viihde recordings
Requires Python: >=3.8

# ViihdeCLI
Command-line interface for Elisa Viihde. **In Finnish.**
### Features
- Downloading recordings using [ViihdexDL](https://pypi.org/project/viihdexdl/) and [FFmpeg](https://www.ffmpeg.org/)
	- If multiple files are selected to be downloaded, downloads are queued
- Filtering recordings based on e.g. name, channel, start time, duration, show type and actors
	- Either recordings of a folder or all recordings, regardless of their folder can be listed and then filtered
- Flexible selection of recordings to be downloaded, deleted, or moved to another folder
- Duplicate search with multiple modes
### Documentation
[Documentation](https://github.com/Qotscha/viihdecli/blob/main/LUEMINUT.md) in Finnish.
QuikUI 0.3.0
Build UIs quickly with Jinga2, FastAPI, Pydantic, htmx, and a little bit of magic
Requires Python: <4,>=3.10

# Overview

QuikUI is a library for contextual server-side rendering of Pydantic models into HTML components,
using Jinja2 for template-based rendering, and designed to work seamlessly with FastAPI-based apps.
One of the main benefits of QuikUI is that it allows you to create completely custom HTML for your
models just by subclassing `quikui.BaseComponent` in your model's class heirarchy, allowing you
to easily integrate HTML rendering into your existing FastAPI applications by just adding the
`quikui.render_component` decorator. Further, this rendering is contextual using a heuristic on
FastAPI requests, such that if a web browser makes a request to a supported endpoint in your app,
the app will respond with rendered html instead of converting your model to JSON in response.

## Installation

To install QuikUI, use `pip` or your favorite package installation tool:

```sh
$ pip install quikui
```

## Example

We have example in this repository that you can run via:

```sh
uvicorn example:app
```

## Usage

It is recommended that you subclass `quikui.BaseComponent` in a base class used by your heirarchy,
so that you can configure your own template directory:

```py
import quikui as qk


class Component(qk.BaseComponent):
    quikui_template_package_name = "your_package_name"
    # a folder called `templates/` under this package should contain your html templates


# Now you can subclass `Component` to enable rendering of your models.
```

Models are rendered according to their class name, so if you have a class like:

```py
class MyModel(Component, ...):
    a_field: str = Field(...)  # Works with any Pydantic Model type
    ...
```

Then it is expected to have a file under your package's template directory named `MyModel.html`:

```html
{# This is a Jinj2 template #}
<{{ __quikui_component_name__ }} class="{{ quikui_css_classes }}" {{ quikui_extra_attributes }}>
  {{ a_field }}
...
```

The template can use any named field of your model (the type is not converted, so handle
accordingly), or it can the QuikUI-provided fields `__quikui_component_name__` (the name of the model e.g.
`MyModel`), `quikui_css_classes` (which is the set of CSS classes that should be added),
and `quikui_extra_attributes` (which is a rendered "safe" string of html attributes in `k="v"` format, including the `class` attribute).

Additionally, there are two extra fields that are injected into your model when subclassing (which
are hidden from your model export via `model_dump` and `model_dump_json`) that you should use to
customize your objects: `attrs=dict(...)` (a mapping of html5-compatible string attribute names to string or bool values) and `css=set(...)` (a set of string css class names to concatenate together).

## Contributing

Open an [issue](https://github.com/fubuloubu/QuikUI/issues).