dfm-python 0.5.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

dfm_python/config/results.py

@@ -313,12 +313,14 @@ class NowcastResult:
     Examples
     --------
     >>> from dfm_python import DFM
+    >>> import numpy as np
     >>> model = DFM()
     >>> trainer.fit(model, data_module)
-    >>> # Get nowcast with full result
-    >>> result = model.nowcast('gdp', view_date='2024-01-15', return_result=True)
-    >>> print(f"Nowcast: {result.nowcast_value}")
-    >>> print(f"Available data: {result.data_availability['n_available']}")
+    >>> # Update state with new data, then predict
+    >>> X_std = np.random.randn(10, 5)  # Standardized data
+    >>> model.update(X_std)
+    >>> forecast = model.predict(horizon=1)
+    >>> print(f"Forecast: {forecast[0, 0]}")
     """
     target_series: str
     target_period: datetime

dfm_python/config/schema.py

@@ -398,6 +398,11 @@ class BaseModelConfig:
                     f"Block '{block_name}' validation failed: AR lag must be at least 1, got {ar_lag}. "
                     f"Please set ar_lag >= 1 for block '{block_name}'."
                 )
+            if ar_lag > 2:
+                raise ValueError(
+                    f"Block '{block_name}' validation failed: AR lag must be at most 2 (maximum supported VAR order is VAR(2)), got {ar_lag}. "
+                    f"Please set ar_lag to 1 (VAR(1)) or 2 (VAR(2)) for block '{block_name}'."
+                )
         
         # Auto-generate series_id if not provided and convert blocks to indices
         n_blocks = len(self.block_names)
@@ -608,7 +613,7 @@ class DFMConfig(BaseModelConfig):
     # ========================================================================
     # EM Algorithm Parameters (HOW - controls the algorithm)
     # ========================================================================
-    ar_lag: int = 1  # Number of lags in AR transition equation (lookback window)
+    ar_lag: int = 1  # Number of lags in AR transition equation (lookback window). Must be 1 or 2 (maximum supported order is VAR(2))
     threshold: float = 1e-5  # EM convergence threshold
     max_iter: int = 5000  # Maximum EM iterations
     
@@ -717,7 +722,7 @@ class DDFMConfig(BaseModelConfig):
     learning_rate: float = 0.001  # Learning rate for Adam optimizer (default: 0.001)
     epochs: int = 100  # Number of training epochs (default: 100)
     batch_size: int = 100  # Batch size for training (default: 100 to match original DDFM)
-    factor_order: int = 1  # VAR lag order for factor dynamics (1 or 2, default: 1)
+    factor_order: int = 1  # VAR lag order for factor dynamics. Must be 1 or 2 (maximum supported order is VAR(2), default: 1)
     use_idiosyncratic: bool = True  # Model idio components with AR(1) dynamics (default: True)
     min_obs_idio: int = 5  # Minimum observations for idio AR(1) estimation (default: 5)
     

dfm_python/models/base.py

@@ -16,16 +16,10 @@ import torch
 import pytorch_lightning as pl
 import pandas as pd
 
-if TYPE_CHECKING:
-    from ..config.results import NowcastResult
-
 from ..config import DFMConfig, make_config_source, ConfigSource, MergedConfigSource
 from ..config.results import BaseResult
 from ..config.schema import SeriesConfig, DEFAULT_BLOCK_NAME
 from ..logger import get_logger
-from .utils import create_nowcast_result
-from ..utils.time import parse_timestamp, get_latest_time
-from ..utils.data import create_data_view
 
 _logger = get_logger(__name__)
 
@@ -194,28 +188,6 @@ class BaseFactorModel(pl.LightningModule):
         
         return config
     
-    def _get_data_from_datamodule(self) -> Tuple[Any, Optional[np.ndarray], Optional[np.ndarray]]:
-        """Get processed data and standardization parameters from DataModule.
-        
-        Returns
-        -------
-        X_torch : torch.Tensor
-            Processed data tensor (T x N)
-        Mx : np.ndarray or None
-            Mean values for unstandardization (N,)
-        Wx : np.ndarray or None
-            Standard deviation values for unstandardization (N,)
-            
-        Raises
-        ------
-        ValueError
-            If DataModule is not available
-        """
-        data_module = self._get_datamodule()
-        X_torch = data_module.get_processed_data()
-        Mx, Wx = data_module.get_std_params()
-        return X_torch, Mx, Wx
-    
     def _get_datamodule(self):
         """Get DataModule from model or trainer.
         
@@ -250,7 +222,7 @@ class BaseFactorModel(pl.LightningModule):
     ) -> np.ndarray:
         """Forecast factors using VAR dynamics.
         
-        Supports VAR(1) and VAR(2) factor dynamics.
+        Supports VAR(1) and VAR(2) factor dynamics (maximum supported order is VAR(2)).
         
         Parameters
         ----------
@@ -259,7 +231,7 @@ class BaseFactorModel(pl.LightningModule):
         A : np.ndarray
             Transition matrix. For VAR(1): (m x m), for VAR(2): (m x 2m)
         p : int
-            VAR order (1 or 2)
+            VAR order. Must be 1 or 2 (maximum supported order is VAR(2))
         horizon : int
             Number of periods to forecast
         Z_prev : np.ndarray, optional
@@ -297,7 +269,7 @@ class BaseFactorModel(pl.LightningModule):
         else:
             raise ValueError(
                 f"{self.__class__.__name__} prediction failed: unsupported VAR order {p}. "
-                f"Only VAR(1) and VAR(2) are supported. Please use factor_order=1 or factor_order=2"
+                f"Maximum supported VAR order is VAR(2). Please use factor_order=1 (VAR(1)) or factor_order=2 (VAR(2))"
             )
         return Z_forecast
     
@@ -428,13 +400,22 @@ class BaseFactorModel(pl.LightningModule):
         Dict[str, torch.Tensor]
             Dictionary of torch tensors: A, C, Q, R, Z_0, V_0
         """
+        # Ensure V_0 is always 2D (defensive check for edge cases)
+        V_0 = result.V_0
+        if isinstance(V_0, np.ndarray):
+            if V_0.ndim == 0:
+                V_0 = np.atleast_2d(V_0)
+            elif V_0.ndim == 1:
+                # If 1D, reshape to (m x m) - assume it's a single value for m=1 case
+                V_0 = np.atleast_2d(V_0).T if V_0.shape[0] == 1 else np.atleast_2d(V_0)
+        
         return {
             'A': torch.tensor(result.A, dtype=torch.float32),
             'C': torch.tensor(C if C is not None else result.C, dtype=torch.float32),
             'Q': torch.tensor(result.Q, dtype=torch.float32),
             'R': torch.tensor(R if R is not None else result.R, dtype=torch.float32),
             'Z_0': torch.tensor(result.Z_0, dtype=torch.float32),
-            'V_0': torch.tensor(result.V_0, dtype=torch.float32)
+            'V_0': torch.tensor(V_0, dtype=torch.float32)
         }
     
     def _update_factor_state_dfm(
@@ -494,33 +475,66 @@ class BaseFactorModel(pl.LightningModule):
         """
         if not hasattr(self, 'encoder') or self.encoder is None:
             _logger.warning(
-                f"{self.__class__.__name__} predict(): Encoder not available, "
-                "using training state instead"
+                f"{self.__class__.__name__} update(): Encoder not available, "
+                "cannot update factor state"
             )
             return None
         
-        # Extract factors using encoder
-        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        self.encoder.eval()
-        X_tensor = torch.tensor(X_recent_std, device=device, dtype=torch.float32)
-        with torch.no_grad():
-            factors_raw = self.encoder(X_tensor).cpu().numpy()  # (T x m)
-        
-        # For DDFM: C = I (identity), R = small noise
-        m = factors_raw.shape[1]
-        C = np.eye(m)
-        R = np.eye(m) * 1e-8
-        
-        # Convert to torch: (m x T) format for Kalman filter
-        Y = torch.tensor(factors_raw.T, dtype=torch.float32)
-        params = self._result_to_torch_params(result, C=C, R=R)
-        
-        # Run Kalman smoother
-        kf = self._get_kalman_filter(kalman_filter)
-        zsmooth, _, _, _ = kf(Y, params['A'], params['C'], params['Q'],
-                              params['R'], params['Z_0'], params['V_0'])
-        
-        return zsmooth.T[-1, :].cpu().numpy()
+        try:
+            # Extract factors using encoder
+            device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+            self.encoder.eval()
+            X_tensor = torch.tensor(X_recent_std, device=device, dtype=torch.float32)
+            with torch.no_grad():
+                factors_raw = self.encoder(X_tensor).cpu().numpy()  # (T x m)
+            
+            # Validate factors shape
+            if factors_raw.ndim != 2 or factors_raw.shape[0] == 0:
+                _logger.warning(
+                    f"{self.__class__.__name__} update(): Invalid factors shape {factors_raw.shape}, "
+                    "cannot update factor state"
+                )
+                return None
+            
+            # For DDFM: C = I (identity), R = small noise
+            m = factors_raw.shape[1]
+            C = np.eye(m)
+            R = np.eye(m) * 1e-8
+            
+            # Convert to torch: (m x T) format for Kalman filter
+            Y = torch.tensor(factors_raw.T, dtype=torch.float32)
+            params = self._result_to_torch_params(result, C=C, R=R)
+            
+            # Run Kalman smoother
+            kf = self._get_kalman_filter(kalman_filter)
+            kf_result = kf(Y, params['A'], params['C'], params['Q'],
+                          params['R'], params['Z_0'], params['V_0'])
+            
+            # Handle return value - Kalman filter returns (zsmooth, Vsmooth, VVsmooth, loglik)
+            if isinstance(kf_result, tuple) and len(kf_result) >= 1:
+                zsmooth = kf_result[0]
+            else:
+                zsmooth = kf_result
+            
+            # zsmooth is (m x (T+1)), transpose to ((T+1) x m), then get last row
+            if not isinstance(zsmooth, torch.Tensor):
+                zsmooth = torch.tensor(zsmooth, dtype=torch.float32)
+            
+            zsmooth_T = zsmooth.T  # ((T+1) x m)
+            if zsmooth_T.ndim == 2 and zsmooth_T.shape[0] > 0:
+                return zsmooth_T[-1, :].cpu().numpy()
+            else:
+                _logger.warning(
+                    f"{self.__class__.__name__} update(): Invalid zsmooth shape {zsmooth_T.shape}, "
+                    "cannot extract last state"
+                )
+                return None
+                
+        except Exception as e:
+            _logger.warning(
+                f"{self.__class__.__name__} update(): Failed to update factor state: {e}"
+            )
+            return None
     
     @property
     def result(self) -> BaseResult:
@@ -576,149 +590,78 @@ class BaseFactorModel(pl.LightningModule):
         """
         pass
     
-    def nowcast(
+    def update(
         self,
-        target_series: str,
-        view_date: Optional[Union[datetime, str]] = None,
-        target_period: Optional[Union[datetime, str]] = None,
+        X_std: np.ndarray,
         *,
-        return_result: bool = False,
-        horizon: int = 1
-    ) -> Union[float, 'NowcastResult']:
-        """Calculate nowcast for target series.
-        
-        This method performs nowcasting by:
-        1. Creating a data view with masking based on release dates
-        2. Re-running Kalman filter with masked data to update factor state
-        3. Calling predict() with the updated state
+        kalman_filter: Optional[Any] = None
+    ) -> 'BaseFactorModel':
+        """Update factor state with standardized data.
         
-        This is equivalent to: masking → Kalman filter update → predict()
+        This method permanently updates the last factor state (result.Z[-1, :])
+        using the provided standardized data. Users should handle all preprocessing
+        (masking, imputation, standardization) before calling this method.
         
         Parameters
         ----------
-        target_series : str
-            Target series ID to nowcast
-        view_date : datetime or str, optional
-            Data view date (when data is available). If None, uses latest available.
-        target_period : datetime or str, optional
-            Target period for nowcast. If None, uses latest available period.
-        return_result : bool, default False
-            If True, returns NowcastResult with additional information.
-            If False, returns only the nowcast value (float).
-        horizon : int, default 1
-            Forecast horizon. For nowcasting, typically 1 (current period).
+        X_std : np.ndarray
+            Standardized data array (T x N), where T is number of time periods
+            and N is number of series. Data should already be standardized using
+            result.Mx and result.Wx.
+        kalman_filter : Any, optional
+            Kalman filter instance. If None, uses default or model's kalman filter.
             
         Returns
         -------
-        float or NowcastResult
-            Nowcast value if return_result=False, or NowcastResult if return_result=True
+        BaseFactorModel
+            Self for method chaining
             
         Examples
         --------
-        >>> model = DFM()
-        >>> trainer.fit(model, data_module)
-        >>> # Simple nowcast
-        >>> value = model.nowcast('gdp', view_date='2024-01-15', target_period='2024Q1')
-        >>> # With full result
-        >>> result = model.nowcast('gdp', view_date='2024-01-15', return_result=True)
+        >>> # Update state with new data, then predict
+        >>> model.update(X_std).predict(horizon=1)
+        >>> # Or update and predict separately
+        >>> model.update(X_std)
+        >>> forecast = model.predict(horizon=6)
         """
         self._check_trained()
         
-        # Get DataModule
-        data_module = self._get_datamodule()
-        raw_data = data_module.data
-        time_index = data_module.time_index
+        result = self.result  # Use property which ensures non-None after _check_trained()
         
-        # Convert to numpy
-        X = raw_data.to_numpy() if hasattr(raw_data, 'to_numpy') else np.asarray(raw_data)
-        
-        # Parse view_date
-        if view_date is None:
-            view_date_dt = get_latest_time(time_index)
-        elif isinstance(view_date, str):
-            view_date_dt = parse_timestamp(view_date)
-        else:
-            view_date_dt = view_date
-        
-        # Create data view with masking
-        X_view, Time_view, _ = create_data_view(
-            X=X,
-            Time=time_index,
-            Z=None,
-            config=self.config,
-            view_date=view_date_dt,
-            X_frame=raw_data if isinstance(raw_data, pd.DataFrame) else None
-        )
+        # Validate input shape
+        if not isinstance(X_std, np.ndarray):
+            X_std = np.asarray(X_std)
+        if X_std.ndim != 2:
+            raise ValueError(
+                f"{self.__class__.__name__} update(): X_std must be 2D array (T x N), "
+                f"got shape {X_std.shape}"
+            )
         
-        # Standardize masked data
-        result = self._result
-        X_view_std = self._standardize_data(X_view, result.Mx, result.Wx)
-        X_view_std = np.where(np.isfinite(X_view_std), X_view_std, np.nan)
+        # Handle NaN/Inf values
+        X_std = np.where(np.isfinite(X_std), X_std, np.nan)
         
-        # Update factor state using masked data (model-specific)
+        # Update factor state (model-specific)
         if hasattr(self, 'encoder') and self.encoder is not None:
             # DDFM: Extract factors via encoder, then use Kalman filter
-            Z_last_updated = self._update_factor_state_ddfm(X_view_std, result, None)
+            Z_last_updated = self._update_factor_state_ddfm(
+                X_std, result, kalman_filter
+            )
         else:
             # DFM: Use Kalman filter directly on standardized data
             Z_last_updated = self._update_factor_state_dfm(
-                X_view_std, result, getattr(self, 'kalman', None)
+                X_std, result, kalman_filter or getattr(self, 'kalman', None)
             )
         
-        if Z_last_updated is None:
-            Z_last_updated = result.Z[-1, :]
+        # Update result.Z[-1, :] permanently
+        if Z_last_updated is not None:
+            result.Z[-1, :] = Z_last_updated
+        else:
             _logger.warning(
-                f"{self.__class__.__name__} nowcast(): Failed to update factor state, "
-                f"using training state instead"
+                f"{self.__class__.__name__} update(): Failed to update factor state, "
+                f"keeping current state"
             )
         
-        # Temporarily update result.Z[-1, :] with updated state
-        original_Z_last = result.Z[-1, :].copy()
-        result.Z[-1, :] = Z_last_updated
-        
-        try:
-            # Call predict() with updated state
-            X_forecast = self.predict(horizon=horizon, return_series=True, return_factors=False)
-            
-            # Extract nowcast value for target series
-            series_ids = [s.series_id for s in self.config.series if s.series_id]
-            try:
-                target_idx = series_ids.index(target_series)
-            except ValueError:
-                available = ', '.join(str(sid) for sid in series_ids[:5])
-                raise ValueError(
-                    f"{self.__class__.__name__} nowcast failed: target_series '{target_series}' not found. "
-                    f"Available: {available}..."
-                )
-            
-            # Get nowcast value (first period of forecast)
-            if isinstance(X_forecast, np.ndarray):
-                nowcast_value = float(X_forecast[0, target_idx])
-            else:
-                nowcast_value = float(X_forecast[0][target_idx])
-            
-            if return_result:
-                # Calculate data availability
-                data_availability = {
-                    'n_available': int(np.sum(np.isfinite(X_view))),
-                    'n_missing': int(np.sum(np.isnan(X_view)))
-                }
-                
-                # Create NowcastResult using utility function
-                return create_nowcast_result(
-                    target_series=target_series,
-                    target_period=target_period,
-                    view_date=view_date_dt,
-                    nowcast_value=nowcast_value,
-                    factors_at_view=Z_last_updated,
-                    data_availability=data_availability,
-                    dfm_result=result
-                )
-            else:
-                return nowcast_value
-        finally:
-            # Restore original state
-            result.Z[-1, :] = original_Z_last
+        return self
     
     def get_result(self) -> BaseResult:
         """Extract result from trained model.

dfm_python/models/ddfm.py

@@ -32,7 +32,6 @@ from ..encoder.vae import Decoder, Encoder, extract_decoder_params
 from ..logger import get_logger
 from ..utils.data import rem_nans_spline
 from ..utils.helpers import (
-    find_series_index,
     get_clock_frequency,
 )
 from ..utils.statespace import (
@@ -40,8 +39,6 @@ from ..utils.statespace import (
     estimate_var2,
 )
 from ..utils.time import (
-    convert_to_timestamp,
-    find_time_index,
     TimeIndex,
 )
 from .base import BaseFactorModel
@@ -49,6 +46,7 @@ from .utils import (
     estimate_var_ddfm,
     validate_factors_ddfm,
     validate_training_data_ddfm,
+    forecast_var_factors,
 )
 
 if TYPE_CHECKING:
@@ -73,13 +71,14 @@ class DDFMModel:
     This class implements a DDFM with:
     - Nonlinear encoder (MLP) to extract factors from observations
     - Linear decoder for interpretability
-    - Linear factor dynamics (VAR)
+    - Linear factor dynamics (VAR) - supports VAR(1) and VAR(2), maximum order is VAR(2)
     - Kalman filtering for final smoothing
     
     The model is trained using gradient descent (Adam optimizer) to minimize
     reconstruction error, then factor dynamics are estimated via OLS, and
     final smoothing is performed using Kalman filter.
     
+    Note: Maximum supported VAR order for factor dynamics is VAR(2).
     """
     
     def __init__(
@@ -120,7 +119,7 @@ class DDFMModel:
         batch_size : int
             Batch size for training. Default: 100 (matches original DDFM)
         factor_order : int
-            VAR lag order for factor dynamics (1 or 2). Default: 1
+            VAR lag order for factor dynamics. Must be 1 or 2 (maximum supported order is VAR(2)). Default: 1
         use_idiosyncratic : bool
             Whether to model idiosyncratic components with AR(1) dynamics. Default: True
         min_obs_idio : int
@@ -141,7 +140,7 @@ class DDFMModel:
         if factor_order not in [1, 2]:
             raise ValueError(
                 f"DDFM initialization failed: factor_order must be 1 or 2, got {factor_order}. "
-                f"Please provide a valid factor_order value (1 for VAR(1) or 2 for VAR(2))"
+                f"Maximum supported VAR order is VAR(2). Please provide factor_order=1 (VAR(1)) or factor_order=2 (VAR(2))"
             )
         
         self.encoder_layers = encoder_layers or [64, 32]
@@ -212,45 +211,16 @@ class DDFMModel:
             )
         
         # Extract parameters
-        A = self._result.A  # Factor dynamics (m x m) for VAR(1) or (m x 2m) for VAR(2)
+        A = self._result.A
         C = self._result.C
         Wx = self._result.Wx
         Mx = self._result.Mx
-        Z_last = self._result.Z[-1, :]  # Last factor estimate (m,)
-        p = self._result.p  # VAR order
+        Z_last = self._result.Z[-1, :]
+        p = self._result.p
         
-        # Deterministic forecast
-        if p == 1:
-            # VAR(1): f_t = A @ f_{t-1}
-            Z_forecast = np.zeros((horizon, Z_last.shape[0]))
-            Z_forecast[0, :] = A @ Z_last
-            for h in range(1, horizon):
-                Z_forecast[h, :] = A @ Z_forecast[h - 1, :]
-        elif p == 2:
-            # VAR(2): f_t = A1 @ f_{t-1} + A2 @ f_{t-2}
-            # Need last two factor values
-            if self._result.Z.shape[0] < 2:
-                # Fallback to VAR(1) if not enough history
-                Z_forecast = np.zeros((horizon, Z_last.shape[0]))
-                A1 = A[:, :Z_last.shape[0]]
-                Z_forecast[0, :] = A1 @ Z_last
-                for h in range(1, horizon):
-                    Z_forecast[h, :] = A1 @ Z_forecast[h - 1, :]
-            else:
-                Z_prev = self._result.Z[-2, :]  # f_{t-2}
-                A1 = A[:, :Z_last.shape[0]]
-                A2 = A[:, Z_last.shape[0]:]
-                Z_forecast = np.zeros((horizon, Z_last.shape[0]))
-                Z_forecast[0, :] = A1 @ Z_last + A2 @ Z_prev
-                if horizon > 1:
-                    Z_forecast[1, :] = A1 @ Z_forecast[0, :] + A2 @ Z_last
-                for h in range(2, horizon):
-                    Z_forecast[h, :] = A1 @ Z_forecast[h - 1, :] + A2 @ Z_forecast[h - 2, :]
-        else:
-            raise ValueError(
-                f"DDFM prediction failed: unsupported VAR order {p}. "
-                f"Only VAR(1) and VAR(2) are supported. Please use factor_order=1 or factor_order=2"
-            )
+        # Forecast factors using VAR dynamics
+        Z_prev = self._result.Z[-2, :] if self._result.Z.shape[0] >= 2 and p == 2 else None
+        Z_forecast = forecast_var_factors(Z_last, A, p, horizon, Z_prev)
         
         # Transform to observations
         X_forecast_std = Z_forecast @ C.T
@@ -261,76 +231,6 @@ class DDFMModel:
         if return_series:
             return X_forecast
         return Z_forecast
-    
-    def get_state(
-        self,
-        t: Union[int, datetime],
-        target_series: str,
-        lookback: Optional[int] = None
-    ) -> Dict[str, Any]:
-        """Get DFM state at time t.
-        
-        Note: Requires data to be stored during fit(). Data is automatically
-        stored from DataModule during fit().
-        """
-        if not hasattr(self, '_data') or self._data is None:
-            raise ValueError(
-                f"DDFM get_state failed: model has not been fitted with DataModule yet. "
-                f"Please call trainer.fit(model, data_module) first to store data"
-            )
-        
-        if lookback is None:
-            clock = get_clock_frequency(self._config, 'm')
-            lookback = get_periods_per_year(clock)
-        
-        t = convert_to_timestamp(t, self._time, None)
-        i_series = find_series_index(self._config, target_series)
-        
-        # Convert data to numpy if needed
-        if hasattr(self._data, 'to_numpy'):
-            X_data = self._data.to_numpy()
-        else:
-            X_data = np.asarray(self._data)
-        
-        # For get_state, we use the raw data directly
-        X_view = X_data
-        
-        # Placeholder for nowcast (use src.nowcast for actual nowcasting functionality)
-        baseline_nowcast = np.nan
-        
-        baseline_forecast, actual_history, residuals, factors_history = [], [], [], []
-        t_idx = find_time_index(self._time, t)
-        if t_idx is None:
-            raise ValueError(
-                f"DDFM get_state failed: time {t} not found in model_instance._time. "
-                f"Please provide a valid time value that exists in the model's time index"
-            )
-        
-        for i in range(max(0, t_idx - lookback + 1), t_idx + 1):
-            if i < X_data.shape[0]:
-                # Use smoothed value from result if available, otherwise NaN
-                if self._result is not None and hasattr(self._result, 'X_sm') and i < self._result.X_sm.shape[0]:
-                    forecast_val = self._result.X_sm[i, i_series] if i_series < self._result.X_sm.shape[1] else np.nan
-                else:
-                    forecast_val = np.nan
-                baseline_forecast.append(forecast_val)
-                actual_val = X_data[i, i_series] if i_series < X_data.shape[1] else np.nan
-                actual_history.append(actual_val)
-                residuals.append(actual_val - forecast_val)
-                if self._result is not None and hasattr(self._result, 'Z') and i < self._result.Z.shape[0]:
-                    factors_history.append(self._result.Z[i, :])
-                else:
-                    factors_history.append(np.array([]))
-        
-        return {
-            'time': t,
-            'target_series': target_series,
-            'baseline_nowcast': baseline_nowcast,
-            'baseline_forecast': np.array(baseline_forecast),
-            'actual_history': np.array(actual_history),
-            'residuals': np.array(residuals),
-            'factors_history': factors_history
-        }
 
 # ============================================================================
 # High-level API Classes
@@ -346,6 +246,8 @@ class DDFM(BaseFactorModel):
     Lightning training patterns. It inherits from BaseFactorModel and implements
     DDFM training using autoencoder and MCMC procedure.
     
+    Note: Maximum supported VAR order for factor dynamics is VAR(2) (set via factor_order parameter).
+    
     Example (Standard Lightning Pattern):
         >>> from dfm_python import DDFM, DFMDataModule, DDFMTrainer
         >>> import pandas as pd
@@ -429,7 +331,7 @@ class DDFM(BaseFactorModel):
         batch_size : int, default 100
             Batch size for training (matches original DDFM)
         factor_order : int, default 1
-            VAR lag order for factor dynamics (1 or 2)
+            VAR lag order for factor dynamics. Must be 1 or 2 (maximum supported order is VAR(2))
         use_idiosyncratic : bool, default True
             Whether to model idiosyncratic components
         min_obs_idio : int, default 5
@@ -459,6 +361,13 @@ class DDFM(BaseFactorModel):
         # We create a minimal default block that will be ignored by DDFM
         config = self._initialize_config(config)
         
+        # Validate factor_order
+        if factor_order not in [1, 2]:
+            raise ValueError(
+                f"DDFM initialization failed: factor_order must be 1 or 2, got {factor_order}. "
+                f"Maximum supported VAR order is VAR(2). Please provide factor_order=1 (VAR(1)) or factor_order=2 (VAR(2))"
+            )
+        
         self.encoder_layers = encoder_layers or [64, 32]
         self.activation = activation
         self.use_batch_norm = use_batch_norm
@@ -1158,6 +1067,12 @@ class DDFM(BaseFactorModel):
         Q = Q_f
         Z_0 = factors[0, :]
         V_0 = np.cov(factors.T)
+        # Ensure V_0 is always 2D (np.cov returns scalar when m=1)
+        if V_0.ndim == 0:
+            V_0 = np.atleast_2d(V_0)
+        elif V_0.ndim == 1:
+            # If 1D, reshape to (m x m)
+            V_0 = np.atleast_2d(V_0).T if V_0.shape[0] == 1 else np.atleast_2d(V_0)
         
         # Estimate R from residuals
         R_diag = np.var(residuals, axis=0)
@@ -1217,7 +1132,9 @@ class DDFM(BaseFactorModel):
     def on_train_start(self) -> None:
         """Called when training starts. Run MCMC training."""
         # Get processed data and standardization params from DataModule
-        X_torch, Mx, Wx = self._get_data_from_datamodule()
+        data_module = self._get_datamodule()
+        X_torch = data_module.get_processed_data()
+        Mx, Wx = data_module.get_std_params()
         
         # Early validation: Check data dimensions and model configuration before training
         # This catches configuration issues early with clear error messages
@@ -1496,71 +1413,4 @@ class DDFM(BaseFactorModel):
         """Reset model state."""
         super().reset()
         return self
-    
-    # nowcast() is inherited from BaseFactorModel
-    
-    def get_state(
-        self,
-        t: Union[int, datetime],
-        target_series: str,
-        lookback: Optional[int] = None
-    ) -> Dict[str, Any]:
-        """Get DFM state at time t.
-        
-        Returns state information including baseline forecast, actual history,
-        residuals, and factor history for the specified time period.
-        """
-        if not hasattr(self, '_data') or self._data is None:
-            raise ValueError(
-                f"DDFM get_state failed: model has not been fitted with DataModule yet. "
-                f"Please call trainer.fit(model, data_module) first to store data"
-            )
-        
-        if lookback is None:
-            lookback = 12  # Default lookback
-        
-        i_series = find_series_index(self._config, target_series)
-        
-        # Convert data to numpy if needed
-        if hasattr(self._data, 'to_numpy'):
-            X_data = self._data.to_numpy()
-        else:
-            X_data = np.asarray(self._data)
-        
-        # Placeholder for nowcast (use src.nowcast for actual nowcasting functionality)
-        baseline_nowcast = np.nan
-        
-        baseline_forecast, actual_history, residuals, factors_history = [], [], [], []
-        t_idx = find_time_index(self._time, t)
-        if t_idx is None:
-            raise ValueError(
-                f"DDFM get_state failed: time {t} not found in model_instance._time. "
-                f"Please provide a valid time value that exists in the model's time index"
-            )
-        
-        for i in range(max(0, t_idx - lookback + 1), t_idx + 1):
-            if i < X_data.shape[0]:
-                # Use smoothed value from result if available, otherwise NaN
-                if self._result is not None and hasattr(self._result, 'X_sm') and i < self._result.X_sm.shape[0]:
-                    forecast_val = self._result.X_sm[i, i_series] if i_series < self._result.X_sm.shape[1] else np.nan
-                else:
-                    forecast_val = np.nan
-                baseline_forecast.append(forecast_val)
-                actual_val = X_data[i, i_series] if i_series < X_data.shape[1] else np.nan
-                actual_history.append(actual_val)
-                residuals.append(actual_val - forecast_val)
-                if self._result is not None and hasattr(self._result, 'Z') and i < self._result.Z.shape[0]:
-                    factors_history.append(self._result.Z[i, :])
-                else:
-                    factors_history.append(np.array([]))
-        
-        return {
-            'time': t,
-            'target_series': target_series,
-            'baseline_nowcast': baseline_nowcast,
-            'baseline_forecast': np.array(baseline_forecast),
-            'actual_history': np.array(actual_history),
-            'residuals': np.array(residuals),
-            'factors_history': factors_history
-        }
 

dfm_python/models/dfm.py

@@ -664,7 +664,9 @@ class DFM(BaseFactorModel):
     def on_train_start(self) -> None:
         """Called when training starts. Run EM algorithm."""
         # Get processed data and standardization params from DataModule
-        X_torch, Mx, Wx = self._get_data_from_datamodule()
+        data_module = self._get_datamodule()
+        X_torch = data_module.get_processed_data()
+        Mx, Wx = data_module.get_std_params()
         
         # Run EM algorithm
         self.fit_em(X_torch, Mx=Mx, Wx=Wx)
@@ -863,8 +865,5 @@ class DFM(BaseFactorModel):
         """Reset model state."""
         super().reset()
         return self
-    
-    # nowcast() is inherited from BaseFactorModel
-    
 
 

dfm_python/models/utils.py

@@ -5,16 +5,12 @@ organization and maintainability.
 """
 
 import logging
-from typing import Tuple, Optional, Union, Any, Dict
-from datetime import datetime
+from typing import Tuple, Optional
 import numpy as np
 import torch
-import pandas as pd
 
 from ..logger import get_logger
 from ..utils.statespace import estimate_var1, estimate_var2
-from ..utils.time import parse_timestamp
-from ..config.results import NowcastResult
 
 _logger = get_logger(__name__)
 
@@ -32,7 +28,7 @@ def estimate_var_ddfm(
         Factors array (T x m), where T is number of time periods and m is number of factors.
         Must be 2D array with at least 2 observations.
     factor_order : int
-        VAR order, must be 1 or 2.
+        VAR order. Must be 1 or 2 (maximum supported order is VAR(2)).
     num_factors : int, optional
         Number of factors. Used for fallback when factors shape is invalid.
         If None, inferred from factors.shape[1].
@@ -49,7 +45,7 @@ def estimate_var_ddfm(
     Raises
     ------
     ValueError
-        If factor_order is not 1 or 2.
+        If factor_order is not 1 or 2 (maximum supported order is VAR(2)).
     """
     # Validate factors shape - check for 0-dimensional array first
     factors = np.asarray(factors)
@@ -113,7 +109,10 @@ def estimate_var_ddfm(
         elif factor_order == 2:
             A_f, Q_f = estimate_var2(factors)
         else:
-            raise ValueError(f"DDFM VAR estimation failed: factor_order must be 1 or 2, got {factor_order}. Please set factor_order to 1 (VAR(1)) or 2 (VAR(2))")
+            raise ValueError(
+                f"DDFM VAR estimation failed: factor_order must be 1 or 2, got {factor_order}. "
+                f"Maximum supported VAR order is VAR(2). Please set factor_order to 1 (VAR(1)) or 2 (VAR(2))"
+            )
         
         # Validate Q_f shape
         if Q_f.ndim == 0:
@@ -307,7 +306,7 @@ def validate_training_data_ddfm(
     num_factors : int
         Number of factors to extract
     factor_order : int
-        VAR order for factor dynamics (1 or 2)
+        VAR order for factor dynamics. Must be 1 or 2 (maximum supported order is VAR(2))
     encoder_layers : list
         Encoder hidden layer dimensions
     encoder : torch.nn.Module, optional
@@ -407,61 +406,65 @@ def validate_training_data_ddfm(
         )
 
 
-# ============================================================================
-# Nowcast utility functions
-# ============================================================================
-
-def create_nowcast_result(
-    target_series: str,
-    target_period: Optional[Union[datetime, str]],
-    view_date: datetime,
-    nowcast_value: float,
-    factors_at_view: Optional[np.ndarray] = None,
-    data_availability: Optional[Dict[str, int]] = None,
-    dfm_result: Optional[Any] = None,
-    confidence_interval: Optional[Tuple[float, float]] = None
-) -> NowcastResult:
-    """Create NowcastResult object.
+def forecast_var_factors(
+    Z_last: np.ndarray,
+    A: np.ndarray,
+    p: int,
+    horizon: int,
+    Z_prev: Optional[np.ndarray] = None
+) -> np.ndarray:
+    """Forecast factors using VAR dynamics (standalone function).
+    
+    Supports VAR(1) and VAR(2) factor dynamics (maximum supported order is VAR(2)). 
+    This is a module-level function that can be used by classes that don't inherit from BaseFactorModel.
     
     Parameters
     ----------
-    target_series : str
-        Target series ID that was nowcasted
-    target_period : datetime or str, optional
-        Target period for the nowcast. If None, uses view_date.
-    view_date : datetime
-        View date (when data is available)
-    nowcast_value : float
-        The calculated nowcast value
-    factors_at_view : np.ndarray, optional
-        Factor values at the view_date (m,)
-    data_availability : Dict[str, int], optional
-        Dictionary with 'n_available' and 'n_missing' keys
-    dfm_result : BaseResult, optional
-        Full DFM/DDFM result for this view
-    confidence_interval : Tuple[float, float], optional
-        Confidence interval (lower, upper) for the nowcast
+    Z_last : np.ndarray
+        Last factor state (m,)
+    A : np.ndarray
+        Transition matrix. For VAR(1): (m x m), for VAR(2): (m x 2m)
+    p : int
+        VAR order. Must be 1 or 2 (maximum supported order is VAR(2))
+    horizon : int
+        Number of periods to forecast
+    Z_prev : np.ndarray, optional
+        Previous factor state for VAR(2) (m,). Required if p == 2.
         
     Returns
     -------
-    NowcastResult
-        NowcastResult object with all provided information
+    np.ndarray
+        Forecasted factors (horizon x m)
     """
-    # Parse target_period
-    if target_period is None:
-        target_period_dt = view_date
-    elif isinstance(target_period, datetime):
-        target_period_dt = target_period
+    if p == 1:
+        # VAR(1): f_t = A @ f_{t-1}
+        Z_forecast = np.zeros((horizon, Z_last.shape[0]))
+        Z_forecast[0, :] = A @ Z_last
+        for h in range(1, horizon):
+            Z_forecast[h, :] = A @ Z_forecast[h - 1, :]
+    elif p == 2:
+        # VAR(2): f_t = A1 @ f_{t-1} + A2 @ f_{t-2}
+        if Z_prev is None:
+            # Fallback to VAR(1) if not enough history
+            A1 = A[:, :Z_last.shape[0]]
+            Z_forecast = np.zeros((horizon, Z_last.shape[0]))
+            Z_forecast[0, :] = A1 @ Z_last
+            for h in range(1, horizon):
+                Z_forecast[h, :] = A1 @ Z_forecast[h - 1, :]
+        else:
+            A1 = A[:, :Z_last.shape[0]]
+            A2 = A[:, Z_last.shape[0]:]
+            Z_forecast = np.zeros((horizon, Z_last.shape[0]))
+            Z_forecast[0, :] = A1 @ Z_last + A2 @ Z_prev
+            if horizon > 1:
+                Z_forecast[1, :] = A1 @ Z_forecast[0, :] + A2 @ Z_last
+            for h in range(2, horizon):
+                Z_forecast[h, :] = A1 @ Z_forecast[h - 1, :] + A2 @ Z_forecast[h - 2, :]
     else:
-        target_period_dt = parse_timestamp(str(target_period))
-    
-    return NowcastResult(
-        target_series=target_series,
-        target_period=target_period_dt,
-        view_date=view_date,
-        nowcast_value=nowcast_value,
-        factors_at_view=factors_at_view,
-        data_availability=data_availability,
-        dfm_result=dfm_result,
-        confidence_interval=confidence_interval
-    )
+        raise ValueError(
+            f"VAR forecasting failed: unsupported VAR order {p}. "
+            f"Maximum supported VAR order is VAR(2). Please use p=1 (VAR(1)) or p=2 (VAR(2))"
+        )
+    return Z_forecast
+
+

dfm_python/utils/data.py

@@ -527,6 +527,9 @@ def create_data_view(
     from ..utils.time import get_latest_time
     from ..utils.helpers import get_series_ids
     
+    if Time is None:
+        raise ValueError("Time index is required for create_data_view")
+    
     if isinstance(view_date, str):
         view_date = parse_timestamp(view_date)
     elif view_date is None:
@@ -541,6 +544,8 @@ def create_data_view(
     # Prepare time list
     if isinstance(Time, TimeIndex):
         time_list = [to_python_datetime(t) for t in Time]
+    elif Time is None:
+        raise ValueError("Time index is required for create_data_view")
     else:
         time_list = []
         for t in Time:

dfm_python/utils/statespace.py

@@ -534,6 +534,8 @@ def _safe_divide(numerator: np.ndarray, denominator: np.ndarray, default: float
 def estimate_var1(factors: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
     """Estimate VAR(1) dynamics for factors.
     
+    Note: Maximum supported VAR order is VAR(2). Use estimate_var2() for VAR(2) estimation.
+    
     Parameters
     ----------
     factors : np.ndarray
@@ -591,6 +593,8 @@ def estimate_var1(factors: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
 def estimate_var2(factors: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
     """Estimate VAR(2) dynamics for factors.
     
+    Note: VAR(2) is the maximum supported VAR order in this implementation.
+    
     Parameters
     ----------
     factors : np.ndarray
@@ -956,8 +960,8 @@ def estimate_state_space_params(
         A2 = None
     else:
         raise NotImplementedError(
-            f"Only VAR(1) or VAR(2) for common factors are supported. "
-            f"Got factor_order={factor_order}"
+            f"Only VAR(1) or VAR(2) for common factors are supported (maximum supported order is VAR(2)). "
+            f"Got factor_order={factor_order}. Please use factor_order=1 (VAR(1)) or factor_order=2 (VAR(2))"
         )
     
     # Estimate idiosyncratic AR(1) dynamics

{dfm_python-0.5.0.dist-info → dfm_python-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dfm-python
-Version: 0.5.0
+Version: 0.5.1
 Summary: Dynamic Factor Model (DFM) estimation and nowcasting in Python
 Project-URL: Homepage, https://github.com/yourusername/dfm-python
 Project-URL: Documentation, https://github.com/yourusername/dfm-python#readme
@@ -160,11 +160,12 @@ trainer.fit(ddfm_model, dm)
 Xf, Zf = ddfm_model.predict(horizon=6)
 ```
 
-### Example 3: Nowcasting
+### Example 3: Nowcasting with update().predict()
 
 ```python
 from dfm_python import DFM, DFMDataModule, DFMTrainer
 import pandas as pd
+import numpy as np
 
 # Load data and train model (same as above)
 df = pd.read_csv('data/macro.csv')
@@ -179,14 +180,25 @@ model.load_config('config/model/dfm.yaml')
 trainer = DFMTrainer(max_iter=10, threshold=1e-4)
 trainer.fit(model, dm)
 
-# Nowcast a target series at a specific view date
-result = model.nowcast(
-    target_series='KOEQUIPTE',
-    view_date='2024-01-15'
-)
+# Get standardization parameters from trained model
+result = model.result
+Mx = result.Mx  # Mean for standardization
+Wx = result.Wx  # Standard deviation for standardization
+
+# Prepare new data (in practice, this would be real-time incomplete data)
+# Standardize using the same parameters from training
+X_new_raw = df_processed.iloc[-5:].values  # Last 5 periods as example
+X_new_std = (X_new_raw - Mx) / Wx
+
+# Update model state with new standardized data, then predict
+# Pattern: model.update(X_std).predict(horizon=1)
+X_nowcast, Z_nowcast = model.update(X_new_std).predict(horizon=1)
 
-print(f"Nowcast value: {result.nowcast_value}")
-print(f"Confidence interval: {result.confidence_interval}")
+# Extract nowcast for target series
+target_idx = df_processed.columns.get_loc('KOEQUIPTE')
+nowcast_value = X_nowcast[0, target_idx]
+
+print(f"Nowcast value: {nowcast_value:.6f}")
 ```
 
 ## Configuration
@@ -294,8 +306,10 @@ trainer.fit(model, datamodule)  # Standard Lightning pattern
 # Prediction
 Xf, Zf = model.predict(horizon=6)  # Forecast future values
 
-# Nowcasting
-result = model.nowcast(target_series, view_date)  # Estimate current period
+# Nowcasting (update state with new data, then predict)
+result = model.result
+X_new_std = (X_new_raw - result.Mx) / result.Wx  # Standardize new data
+X_nowcast, Z_nowcast = model.update(X_new_std).predict(horizon=1)  # Update and predict
 ```
 
 ### Result Objects
@@ -376,9 +390,18 @@ pytest src/test/test_trainer.py -v
 
 ## Project Status
 
-**Version**: 0.4.9  
+**Version**: 0.5.1  
 **Status**: Stable and production-ready  
-**Python**: 3.10+  
+**Python**: 3.10+
+
+### What's New in 0.5.1
+
+- ✨ **New `update()` method**: Replaces legacy `nowcast()` with flexible `update().predict()` pattern
+- 🔧 **Improved API**: Users now control all preprocessing (masking, imputation, standardization)
+- 🧹 **Code cleanup**: Removed legacy code and overengineering (~200+ lines removed)
+- 🐛 **Bug fixes**: Fixed DDFM `update()` method for single-factor models
+- 📚 **Updated tutorials**: All 4 tutorials rewritten with new pattern and VAR(1) configuration
+- ✅ **VAR(1) only**: Simplified to VAR(1) factor dynamics throughout  
 
 ## License
 

{dfm_python-0.5.0.dist-info → dfm_python-0.5.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
 dfm_python/__init__.py,sha256=C_3NmIr6G7CyDoWB87Osp5b8XZR65LpHmflxMthue74,5683
 dfm_python/config/__init__.py,sha256=NrTwjNzQRcYlk5Ht0hTF8o-6CCl5e4S_JxQAp1mNyCs,1507
 dfm_python/config/adapter.py,sha256=X-mjWlg6ebWp-VAxjAUssgHnmr8AXOvSxhTTVSHOIIk,27475
-dfm_python/config/results.py,sha256=jyvoSzEcRJah1epOlgPEXVB9PJfFbc9ohJ-LMmtrbYw,15959
-dfm_python/config/schema.py,sha256=BCtWaW1cK0yAKxov8CedCSwjn38SkPCCPX3mNnK4r3k,50554
+dfm_python/config/results.py,sha256=hzXL6MwaIxzA4uzouh6Bc_57lbpedphN9ErTMgfkpeE,15967
+dfm_python/config/schema.py,sha256=wed_cYz2Nu6tGzQPRZDqHm6GgkeKl6O0AIawzg5yGng,50967
 dfm_python/config/utils.py,sha256=W9bZeoLvfJmjV5dEWAKXJ9PKzJaNp084vpJZLGjxWbU,19298
 dfm_python/data/__init__.py,sha256=KRhXiRN9DYPM1QfgBeXE3PCaOMYNl1kb7E9mEEGSpWE,925
 dfm_python/data/dataloader.py,sha256=cN2epDGZiwjGl5Df6Qr0B72ehzRe9_ZD6s5DqPkdYQ8,3898
@@ -20,11 +20,11 @@ dfm_python/logger/inference_logger.py,sha256=TmXiWl703boJ3mIR-WgGpy6hfeF8a68OW9v
 dfm_python/logger/logger.py,sha256=1YzsUnvAnAK9CTcfttdSIMtgFvylO13LjQPMEsSs9xc,5187
 dfm_python/logger/train_logger.py,sha256=9VYhzwNYH1Rn7IQipKTY5wmVJcX1n6HDgnUZH0hChPY,17732
 dfm_python/models/__init__.py,sha256=3JsYZOqDGkl1eG8Zrc4-5gf7Sw47PzzDg2XBhsudB04,724
-dfm_python/models/base.py,sha256=bvp_D0hrpTS9senXycJOida1kHSzrzSdH1d4-I5rrFg,32160
-dfm_python/models/ddfm.py,sha256=lpx98MmEDl4xPnqjIy1AwbYBsHS0PMGotzcsLFJQZh0,65834
-dfm_python/models/dfm.py,sha256=jDwMldT2QsSNwW-OKGLKOtBwBnJfsPXJ5S2WescB0tY,33652
+dfm_python/models/base.py,sha256=-mKK2onDilvPLVRRrW3W7GYsMZxLMHjZWj6n6gL_xnw,30041
+dfm_python/models/ddfm.py,sha256=yZe7pxc81ZOsCwzoJ78UHXhEu5adRxkdTEvq-L17Sho,59415
+dfm_python/models/dfm.py,sha256=r4MnjhGv9bPB2spiluF6cWKw0cuwR_qq7pfw5oz8dlM,33675
 dfm_python/models/mcmc.py,sha256=QXBVxeBHREkc9K_xCGR1Y4sIFUkmX_RbRcgNktojuEc,23978
-dfm_python/models/utils.py,sha256=y2kFaIW0sV2sfbkc7t-UKiEPWqE_5dG0WVD2SLS_Ir4,19955
+dfm_python/models/utils.py,sha256=LAtvBqUYxnnl4dIaWl6MC-NHSuoyeNkHZppfWB1lCxQ,20193
 dfm_python/ssm/__init__.py,sha256=dFpt8_3jb_foISDNhma_JUAzch0VrKZcaeWP9zwpwoM,1161
 dfm_python/ssm/em.py,sha256=yRYA930YAqOn4B4oxsPER_-vzO8hDPzMYA_eGnn4Sec,63430
 dfm_python/ssm/kalman.py,sha256=KC6Q71VxM2NSdBVB5107QsNUm-_kE59MiyqrzImWz7E,45931
@@ -33,12 +33,12 @@ dfm_python/trainer/__init__.py,sha256=gc8jRjM-y2XN911LldwYUYHAAuFEvzUJJvXhG6B3Sv
 dfm_python/trainer/ddfm.py,sha256=pqaLzxppJnCDXxPPpFRP7CGMMBVO12veaik6XofgBKU,7646
 dfm_python/trainer/dfm.py,sha256=FQy82Jgkt0u5ecsQ3UtbktDmGc8hCET67OimGh0HmOE,6098
 dfm_python/utils/__init__.py,sha256=QJiyCM8NXq4I96rxgrC4A3BiM2aTBHhFLSHQHpvXz5g,4022
-dfm_python/utils/data.py,sha256=QgDf_sTilUG66lD2gjQvdcl1USSBtfXbU6Nozar2lUI,21747
+dfm_python/utils/data.py,sha256=ofY3_z-HZxMq2bT84IL5bw7XGOsP863Abj513XHvM1E,21940
 dfm_python/utils/diagnostics.py,sha256=UwrJfnn8VACATfQEkTcWw9eEJlTik-VCgTZ1dJABZmw,26049
 dfm_python/utils/helpers.py,sha256=iOVwkP5pti-q-HKOAkp6bUPAp7BPV7BBgh8jL76g9go,13049
-dfm_python/utils/statespace.py,sha256=BKGWxkR5F8eOS6tshwvBizNdXdF0NFFAmEn_19DOuOo,43882
+dfm_python/utils/statespace.py,sha256=P-GQiCP9HzI2d9PgYst4nmRuocEXr9gG1yzGYsYWkMg,44159
 dfm_python/utils/time.py,sha256=o6NRPuk4Ynk8kPaUnzR6xq3pPAO6aLUTR9N_3hn_N88,35651
-dfm_python-0.5.0.dist-info/METADATA,sha256=qz3ZiFKdMCtV70RbdktTZZkcdvvAYNLXjPFWeMbxPxg,10882
-dfm_python-0.5.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-dfm_python-0.5.0.dist-info/licenses/LICENSE,sha256=6e87br6LCDHjy2hdIR1-sdBQy351qdmSEbOg6jQ7ZXY,1063
-dfm_python-0.5.0.dist-info/RECORD,,
+dfm_python-0.5.1.dist-info/METADATA,sha256=pf5lWV4TFMr4lKSNeUrtpHV_-ym3h_EaslIrAiioH8U,12159
+dfm_python-0.5.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dfm_python-0.5.1.dist-info/licenses/LICENSE,sha256=6e87br6LCDHjy2hdIR1-sdBQy351qdmSEbOg6jQ7ZXY,1063
+dfm_python-0.5.1.dist-info/RECORD,,