semvec/pypi-packages huggingface dataset:
lottocast 0.1.1
Lotto: A Python library for transforming deterministic into probabilistic forecasts.
Requires Python: >=3.11
Keywords: forecasting, probabilistic, quantile-regression

# Lotto

With Lotto, you can turn your determinstic day-ahead forecasts into probabilistic forecasts. Lotto builds on pandas and scikit-learn's quantile regression models (Lasso and Gradient Boosting).

## Features
- Automized feature engineering: lagged observations, lagged daily min/max observations, and weekday dummies.
- Flexible input handling: Additional explanatory variables are allowed.
- Day light saving time (DST) handling for seamless time-index conversions.
- Configurable cross-validation (`cv`) and hyperparameter search.
- Configuration loaders (`LottoConfig.from_dict` / `.from_json`) with strict typing.


## Installation
```
pip install lottocast
```

## Usage Example

### Lasso quantile regression for hourly data with defined model hyperparameters

```python
from lotto import Frequency, LottoConfig, ModelName, LottoModel

config = LottoConfig(
    model_name=ModelName.LASSO,
    frequency=Frequency.H,
    mdl_kwargs={"alpha": 0.1},
)

model = LottoModel(config)
model.fit(df_fit)
predictions = model.predict(df_predict)
```

### Gradient boosting model for quarter-hourly data with hyperparameter search

```python
from lotto import Frequency, LottoConfig, ModelName, LottoModel

config = LottoConfig(
    model_name=ModelName.GBR,
    frequency=Frequency.QH,
    run_hyperparam_search=True,
)

model = LottoModel(config)
model.fit(df_fit)
predictions = model.predict(df_predict)
```


## Hyperparameter search

Hyperparameters currently implemented in the hyperparamter search:
 - **Lasso**: `alpha`
 - **Gradient Boosting**: `learning_rate`, `n_estimators`


## Current limitations

* Only CE(S)T supported.
* Only one day-ahead supported, not several days aheads.
* Fixed quantiles: 1, 5, 10, 25, 50, 75, 90, 95, 99 %.

## Data Requirements
- Index name must be `delivery`, timezone `CET`, and composed of contiguous steps at the configured frequency (`Frequency.H` = 60 min, `Frequency.QH` = 15 min).
- Required columns: `obs` (historical outcomes) and `fcast` (determinstic forecast). Additional columns are allowed and will be cast to `float`.


## Contributing

Contributions are welcome!

Developer tooling reference:
- [`pytest`](https://docs.pytest.org/) for testing.
- [`pytest-cov`](https://pytest-cov.readthedocs.io/en/latest/) for analyzing test coverage.
- [`ruff`](https://docs.astral.sh/ruff/) for linting & formatting.
- [`ty`](https://docs.astral.sh/ty/) for type checking.
- [`uv`](https://docs.astral.sh/uv/) for project and dependency management.
aindex-diy 0.1.0
AI Agent Index - Route queries to the right AI agent. DIY framework for building your own agent registry.
Requires Python: >=3.9
Keywords: agents, ai, index, llm, multi-agent, routing

# AIndex-DIY

**AI Agent Index** - Route queries to the right AI agent.

A lightweight, DIY framework for building your own multi-agent routing system.

## Installation

```bash
pip install aindex-diy
```

## Quick Start

```python
from aindex_diy import AIndex

# Create an index from a JSON file
aindex = AIndex("my_agents.json")

# Or create programmatically
aindex = AIndex()
aindex.add_agent({
    "agent_id": "vision_bot",
    "name": "Vision Bot",
    "capabilities": ["vision", "image-analysis"],
    "keywords": ["image", "photo", "diagram"],
    "status": "approved",
    "state": {"health": "ok"}
})

# Route a query to the best agent
best = aindex.route("analyze this screenshot")
# Returns: "vision_bot"

# Find agents by capability
vision_agents = aindex.find_by_capability("vision")
# Returns: ["vision_bot"]

# Get agent details
agent = aindex.get_agent("vision_bot")
```

## Index Format

```json
{
    "agents": [
        {
            "agent_id": "my_agent",
            "name": "My Agent",
            "capabilities": ["code", "analysis"],
            "keywords": ["python", "debug"],
            "aliases": ["coder"],
            "status": "approved",
            "state": {"health": "ok"}
        }
    ],
    "indices": {
        "by_capability": {"code": ["my_agent"]},
        "by_keyword": {"python": ["my_agent"]},
        "by_alias": {"coder": "my_agent"}
    }
}
```

## Features

- **Simple routing** - Match queries to agents by keywords
- **Capability-based lookup** - Find agents by what they can do
- **Flexible indexing** - Auto-rebuilds indices when agents change
- **Health tracking** - Know which agents are online
- **Zero dependencies** - Pure Python, no external packages

## Custom Routing Rules

```python
aindex = AIndex()

# Override default routing keywords
aindex.routing_rules = {
    "vision": ["image", "photo", "screenshot"],
    "code": ["python", "javascript", "debug"],
    "research": ["analyze", "compare", "study"],
}

# Route with custom capability mapping
best = aindex.route(
    "debug this python code",
    capability_map={"code": "my_python_expert"}
)
```

## License

MIT - Build your own agent index!

---

Made with care by [HumoticaOS](https://humotica.com)