WavqWise

Sense. Forecast. Alert.

Pluggable temporal intelligence. 37 models. 5 pipelines. Real-time streaming. Auto GPU.

Quick Start | 5 Pipelines | 37 Models | Real-Time | Weather | Dam Monitoring | Colab

---

What Makes WavqWise Different

Feature	Nixtla	Darts	Prophet	WavqWise
Batch forecasting	Yes	Yes	Yes	Yes
Real-time streaming	No	No	No	Yes
Incremental update (no retrain)	No	No	No	Yes
Anomaly detection	No	No	No	Yes
EEG / Signal processing	No	No	No	Yes
Trading indicators	No	No	No	Yes
Weather (GraphCast / Aurora)	No	No	No	Yes
Dam / Water level monitoring	No	No	No	Yes
Auto GPU / ONNX / TensorRT	No	No	No	Yes
Plugin any external model	No	No	No	Yes
CLI + PNG charts + CSV/JSON export	No	No	No	Yes

---

Quick Start

pip install wavqwise

from wavqwise import WavqPipeline

pipeline = WavqPipeline()
pipeline.load("sales.csv", target="revenue", time="date")
forecast = pipeline.forecast(horizon=30, model="arima")
forecast.plot()

Change "arima" to "xgboost" or "chronos" : same code. Model is a parameter, not an architecture decision.

---

5 Pipelines

1. WavqPipeline : Forecasting

from wavqwise import WavqPipeline

pipeline = WavqPipeline()
pipeline.load("data.csv", target="sales", time="date")
forecast = pipeline.forecast(horizon=30, model="ema")

# Incremental update (not retrain)
pipeline.update(new_data)
forecast = pipeline.forecast(horizon=30)

# Compare models
pipeline.compare_models(["arima", "ema", "xgboost"], horizon=14)

# Auto-select best
pipeline.forecast(model="auto")

# Ensemble
pipeline.forecast(model=["arima", "ets", "xgboost"])

2. AnomalyPipeline : Detection with Severity

from wavqwise import AnomalyPipeline

detector = AnomalyPipeline()
detector.load("sensor.csv", target="temperature", time="timestamp")
result = detector.detect(method="zscore")  # or "iqr", "isolation_forest"
print(result.summary())
# Anomalies: 93/10000 (0.9%) | Method: zscore

3. SignalPipeline : EEG & Biosignals

from wavqwise import SignalPipeline

sig = SignalPipeline()
sig.load("eeg.csv", channels=["Fp1", "Fp2", "C3", "C4"], sample_rate=256)
sig.filter(low=1, high=50, notch=50)
bands = sig.extract_bands(["delta", "theta", "alpha", "beta", "gamma"])
events = sig.detect_events(threshold=3.0)

4. TradingPipeline : Financial Analysis

from wavqwise.trading.indicators.momentum import RSIIndicator
from wavqwise.trading.indicators.trend import MACDIndicator
from wavqwise.trading.indicators.volatility import BollingerBandsIndicator

stock = RSIIndicator(14).compute(stock_data)
stock = MACDIndicator().compute(stock)
stock = BollingerBandsIndicator(20, 2).compute(stock)

pipeline = WavqPipeline()
pipeline.load(stock, target="Close", time="Date")
forecast = pipeline.forecast(horizon=30, model="ema")

5. WeatherPipeline : Weather Forecasting

from wavqwise import WeatherPipeline

weather = WeatherPipeline()
weather.load_city("Chennai", days=365)  # Real data from Open-Meteo
forecast = weather.forecast(target="temperature_2m_mean", horizon=14, model="ema")
weather.compare_models(horizon=14)

---

Real-Time Streaming

The feature no other forecasting library has:

pipeline = WavqPipeline()
pipeline.load(history, target="temperature", time="timestamp")

stream = pipeline.stream(
    model="ema",
    anomaly_method="zscore",
    on_anomaly=lambda e: send_alert(e),
    on_forecast=lambda f: update_dashboard(f),
)

# Push data as it arrives
stream.push({"timestamp": "2025-01-01 10:00", "temperature": 72.3})

# Or connect to live source
stream.connect_csv("live_sensor.csv", poll_interval=5)
stream.connect_callback(my_sensor_reader, interval=1.0)

print(stream.summary())
# Stream: 500 points | 3 anomalies | window=200 | model=ema | LIVE

---

Dam Water Level Monitoring

49 real dams across 13 countries. Filter by any country, state, or river.

from wavqwise.weather.dam_database import DamDB

# Tamil Nadu only
DamDB.filter(country="India", state="Tamil Nadu")
# Returns: Mettur, Vaigai, Bhavanisagar, Amaravathi, Sathanur,
#          Krishnagiri, Papanasam, Sholayar (8 dams)

# California only
DamDB.filter(country="USA", state="California")
# Returns: Oroville Dam, Shasta Dam

# All Indian dams
DamDB.filter(country="India")  # 22 dams across 10 states

# Search by river
DamDB.search("cauvery")  # Mettur Dam, KRS Dam

# Big dams worldwide
DamDB.filter(min_capacity=1000)  # 14 mega dams

# All countries
DamDB.list_countries()
# Australia, Brazil, China, Egypt, Ethiopia, Ghana,
# India, Italy, Japan, Switzerland, Turkey, USA, Zimbabwe

Flood Early Warning

pipeline = WavqPipeline()
pipeline.load(dam_data, target="water_level_ft", time="date")
forecast = pipeline.forecast(horizon=30, model="ema")

# Real-time flood monitoring
stream = pipeline.stream(
    model="ema",
    anomaly_method="zscore",
    on_anomaly=lambda e: flood_alert(e),
)
stream.push(new_sensor_reading)

---

Weather Forecasting

5 open-source weather foundation models (all free, all run locally):

Model	By	GitHub
GraphCast	Google DeepMind	google-deepmind/graphcast
GenCast	Google DeepMind	google-deepmind/gencast
Aurora	Microsoft	microsoft/aurora
Pangu-Weather	Huawei	198808xc/Pangu-Weather
FourCastNet	NVIDIA	NVlabs/FourCastNet

Real weather data via Open-Meteo API (free, no key, 20+ cities built-in):

from wavqwise import WeatherPipeline

weather = WeatherPipeline()
weather.load_city("Tokyo", days=365)
forecast = weather.forecast(target="temperature_2m_mean", horizon=30, model="ema")

# Weather indicators: heat index, wind chill, dew point, thermal comfort
# Multi-city comparison supported

---

Output Formats

Four output modes : no HTML dependency required:

from wavqwise.visualization.renderer import ResultRenderer, CLIPrinter, DataExporter

# PNG charts (matplotlib)
ResultRenderer.forecast_chart(history, forecast, target, time_col,
    source="India-WRIS", save_path="forecast.png")
ResultRenderer.dam_network_chart(dams, save_path="network.png")
ResultRenderer.anomaly_chart(data, save_path="anomalies.png")
ResultRenderer.comparison_chart(comparison, save_path="comparison.png")

# CLI tables (terminal)
CLIPrinter.table(["Dam", "Level", "Status"], rows)
CLIPrinter.dam_status("Mettur Dam", level=92, capacity=120)
CLIPrinter.forecast_summary(result)

# CSV / JSON export with source metadata
DataExporter.to_csv(data, "output.csv", source="india-wris.nrsc.gov.in")
DataExporter.to_json(data, "output.json", source="USGS")

# HTML interactive (optional, via folium)
from wavqwise.visualization.map_viz import WeatherMap
wmap = WeatherMap()
wmap.add_dam_marker("Mettur Dam", 11.79, 77.80, water_level=92, capacity=120)
wmap.save("dashboard.html")

---

Plugin Any External Model

# Way 1: Register your own class (needs fit + predict)
WavqPipeline.register("my_model", MyModelClass)
pipeline.forecast(model="my_model")

# Way 2: Wrap any sklearn model
from wavqwise.core.adapter import ModelAdapter
adapter = ModelAdapter.from_sklearn(GradientBoostingRegressor())
pipeline.forecast(model=adapter)

# Way 3: Adapters for popular PyPI libraries
from wavqwise.adapters import NixtlaAdapter, DartsAdapter, ProphetAdapter
pipeline.forecast(model=NixtlaAdapter("AutoARIMA"))
pipeline.forecast(model=DartsAdapter("NBEATSModel"))
pipeline.forecast(model=ProphetAdapter())

---

Auto GPU / ONNX / TensorRT

Auto-detected on startup. No configuration needed.

pipeline = WavqPipeline()
print(pipeline.runtime_info())

Priority: TensorRT → ONNX GPU → CUDA → MPS (Apple) → ONNX CPU → CPU

from wavqwise.runtime import ONNXExporter, ONNXPredictor

exporter = ONNXExporter()
exporter.export_sklearn(model, "model.onnx", n_features=13)
exporter.optimize_for_tensorrt("model.onnx")  # FP16

predictor = ONNXPredictor("model.onnx")  # Auto GPU
result = predictor.predict(input_array)
print(predictor.benchmark(input_array))

---

37 Pluggable Models

Category	Models
Traditional (11)	MA, EMA, ARIMA, SARIMA, ETS, Holt-Winters, Theta, CES, Croston, Naive, Seasonal Naive
ML (7)	XGBoost, LightGBM, CatBoost, Random Forest, Ridge, Lasso, ElasticNet
Neural (3)	NeuralProphet, N-BEATS, TFT
Foundation (5)	Chronos, TimesFM, Lag-Llama, Moirai, HuggingFace Hub
Cloud (3)	TimeGPT, Ollama, OpenAI
Weather (5)	GraphCast, GenCast, Aurora, Pangu-Weather, FourCastNet
Custom	Any class with fit() + predict() via WavqPipeline.register()

---

Real Data Sources (All Free, No API Key)

Source	URL	Coverage
Open-Meteo	api.open-meteo.com	Global weather, 80+ years history
India-WRIS	india-wris.nrsc.gov.in	5000+ Indian dams
CWC India	cwc.gov.in	91 major reservoirs
USGS	waterservices.usgs.gov	1.5M+ US water sites
Global Dam Watch	globaldamwatch.org	7000+ reservoirs worldwide
MNE (EEG)	mne.tools	Clinical EEG datasets
Yahoo Finance	via yfinance	Global stock data

---

Demos (11 scripts)

Demo	What it does	Run
Forecasting	Sales forecast + model comparison + incremental	python demos/demo_forecasting.py
Anomaly Detection	Sensor anomaly (Z-Score + IQR + severity)	python demos/demo_anomaly_detection.py
EEG Real Data	MNE clinical EEG classification	python demos/demo_eeg_real_data.py
EEG Classification	3-class mental state classification	python demos/demo_eeg_classification.py
EEG Analysis	Band power extraction + event detection	python demos/demo_eeg_analysis.py
Trading Real Data	AAPL with RSI/MACD/Bollinger/Stochastic	python demos/demo_trading_real_data.py
Trading Forecast	Stock price forecast + signals	python demos/demo_trading_forecast.py
Weather Forecast	Temperature/rain/wind for any city	python demos/demo_weather_forecast.py
Dam Monitoring	Tamil Nadu dams, flood alerts, streaming	python demos/demo_dam_monitoring.py
Dam World	49 dams, 13 countries, PNG + CLI + CSV output	python demos/demo_dam_world.py
Real-Time Stream	Live sensor monitoring with anomaly alerts	python demos/demo_realtime_streaming.py

---

Colab Notebooks (6 notebooks)

Notebook	Data	Open
Weather Forecast	Open-Meteo real weather
Dam Monitoring	49 dams, 13 countries
EEG Real Data	MNE clinical EEG
EEG Classification	Mental state classification
Trading Real Data	yfinance AAPL/TSLA/MSFT
Trading Forecast	Stock analysis + indicators

---

CLI

wavqwise forecast --input data.csv --target sales --model arima --horizon 30
wavqwise detect --input sensor.csv --target temp --method zscore
wavqwise models

---

Install

pip install wavqwise                    # Core
pip install wavqwise[traditional]       # + ARIMA, SARIMA, ETS
pip install wavqwise[ml]               # + XGBoost, LightGBM
pip install wavqwise[neural]           # + NeuralProphet, N-BEATS
pip install wavqwise[foundation]       # + Chronos, TimesFM
pip install wavqwise[signals]          # + EEG (MNE)
pip install wavqwise[trading]          # + yfinance, indicators
pip install wavqwise[database]         # + PostgreSQL, MongoDB, InfluxDB
pip install wavqwise[onnx-gpu]         # + ONNX Runtime GPU
pip install wavqwise[tensorrt]         # + TensorRT
pip install wavqwise[all]              # Everything

---

Docker

cd docker
docker-compose up -d
# WavqWise:    demos run automatically
# Jupyter:     localhost:8888
# TimescaleDB: localhost:5432
# Grafana:     localhost:3000

---

Testing (59 tests)

make smoke        # 22 smoke tests (does it run?)
make sanity       # 20 sanity tests (is output correct?)
make ab           # 5 A/B comparison tests (which model wins?)
make integration  # 7 integration tests (full pipeline flows)
make test         # All 59 tests

---

Architecture

---

Ecosystem

Library	Domain	Tagline	PyPI
SightRAG	Vision	See. Search. Retrieve.
Sonarwise	Audio	Hear. Search. Retrieve.
Docqwise	Documents	Read. Extract. Retrieve.
WavqWise	Temporal	Sense. Forecast. Alert.
Adaptive Intelligence	Orchestration	Learn. Remember. Adapt.
LLMEvalKit	Evaluation	Evaluate. Score. Improve.

---

License

Apache 2.0 License

Author

Venkatkumar Rajan