Time Series Quickstart

import pandas as pd
import numpy as np
import asyncio
from synthefy.api_client import SynthefyAsyncAPIClient

async def main():
    # Create your data
    df = pd.DataFrame({
        'date': pd.date_range('2024-01-01', periods=130, freq='D'),
        'sales': np.random.normal(100, 10, 130) + np.sin(np.arange(130) * 2 * np.pi / 7) * 5,
        'promotion_active': np.random.choice([0, 1], 130)
    })

    # Split your data into "what we know" vs "what we want to predict"
    cutoff_date = '2024-03-15'  # Everything before this date is history

    # Historical data: what the model learns from
    history_df = df[df['date'] <= cutoff_date].copy()

    # Future data: what we want to forecast (with known metadata but unknown sales)
    future_dates = pd.date_range('2024-03-16', periods=30, freq='D')
    target_df = pd.DataFrame({
        'date': future_dates,
        'sales': np.nan,  # We don't know future sales - this is what we want to predict!
        'promotion_active': [1, 0, 0, 1, 0, 0, 1, 0, 0, 1] * 3  # Known future promotions
    })

    # Make the forecast
    # The model uses historical sales + future metadata to predict future sales
    async with SynthefyAsyncAPIClient() as client:
        forecast_dfs = await client.forecast_dfs(
            history_dfs=[history_df],      # What we know (past sales + metadata)
            target_dfs=[target_df],       # What we want to predict (future sales)
            target_col='sales',           # The column we want to forecast
            timestamp_col='date',         # The time column
            metadata_cols=['promotion_active'],  # Additional context
            leak_cols=[],                 # No columns with future information
            model='Migas-1.0'
        )

    # Get your predictions
    forecast_df = forecast_dfs[0]
    print(forecast_df.head())

# Run the async function
asyncio.run(main())

import asyncio
import pandas as pd
import numpy as np
from synthefy.data_models import ForecastV2Request
from synthefy.api_client import SynthefyAsyncAPIClient

async def main():
    # Create sample time series data
    dates = pd.date_range('2023-01-01', '2023-03-31', freq='D')
    data = {
        'date': dates,
        'sales': np.random.normal(100, 10, len(dates)),
        'store_id': 1,
        'category_id': 101,
        'promotion_active': np.random.choice([0, 1], len(dates), p=[0.7, 0.3])
    }
    df = pd.DataFrame(data)

    # Use from_dfs_pre_split for backtesting with date-based windows
    request = ForecastV2Request.from_dfs_pre_split(
        dfs=[df],
        timestamp_col='date',
        target_cols=['sales'],
        model='Migas-1.0',
        cutoff_date='2023-03-01',  # Start backtesting from March 1st
        forecast_window='7D',      # 7-day forecast windows
        stride='7D',              # Move forward 7 days between windows
        metadata_cols=['store_id', 'category_id', 'promotion_active'],
        leak_cols=['promotion_active']  # Promotion data may leak into target
    )

    print(f"Created {len(request.samples)} forecast windows for backtesting")
    print("Window details:")
    for i, sample in enumerate(request.samples):
        history_start = sample[0].history_timestamps[0]
        history_end = sample[0].history_timestamps[-1]
        target_start = sample[0].target_timestamps[0]
        target_end = sample[0].target_timestamps[-1]
        print(f"  Window {i+1}: History {history_start} to {history_end}, Target {target_start} to {target_end}")

    # Make async forecast request
    async with SynthefyAsyncAPIClient() as client:
        response = await client.forecast(request)

    # Process results for each window
    for i, forecast_row in enumerate(response.forecasts):
        print(f"Window {i+1}: {len(forecast_row[0].timestamps)} forecast points")

        # Access forecast values
        if forecast_row[0].values:
            print(f"  Forecast values: {forecast_row[0].values[:3]}...")  # First 3 values

            # You can now compare these forecasts with actual values from df
            # to calculate metrics like MAE, RMSE, etc.

asyncio.run(main())