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

dfm_python/__init__.py

@@ -65,7 +65,7 @@ Note: DFMConfig and SeriesConfig are internal implementation details.
 For detailed documentation, see the README.md file and the tutorial notebooks/scripts.
 """
 
-__version__ = "0.5.0"
+__version__ = "0.5.2"
 
 # ============================================================================
 # PUBLIC API DEFINITION

dfm_python/lightning/scaling.py

@@ -124,7 +124,10 @@ class NoScalingStrategy:
 # Scaler Factory
 # ============================================================================
 
-def _create_scaler_transformer(scaler_type: Optional[str]) -> Any:
+def _create_scaler_transformer(
+    scaler_type: Optional[str],
+    use_robust_as_default: bool = False
+) -> Any:
     """Create a raw sklearn scaler for unified scaling.
     
     Returns a raw sklearn scaler that can be used directly in TransformerPipeline.
@@ -160,10 +163,13 @@ def _create_scaler_transformer(scaler_type: Optional[str]) -> Any:
     )
     
     if scaler_type is None or scaler_type == 'none':
-        # Passthrough: no scaling
-        return FunctionTransformer(func=lambda x: x, inverse_func=lambda x: x)
-    
-    scaler_type_lower = scaler_type.lower()
+        if use_robust_as_default:
+            scaler_type_lower = 'robust'
+        else:
+            # Passthrough: no scaling
+            return FunctionTransformer(func=lambda x: x, inverse_func=lambda x: x)
+    else:
+        scaler_type_lower = scaler_type.lower()
     
     if scaler_type_lower == 'standard':
         return StandardScaler()

dfm_python/models/base.py

@@ -590,11 +590,14 @@ class BaseFactorModel(pl.LightningModule):
         """
         pass
     
+    @abstractmethod
     def update(
         self,
         X_std: np.ndarray,
         *,
-        kalman_filter: Optional[Any] = None
+        history: Optional[int] = None,
+        kalman_filter: Optional[Any] = None,
+        scaler: Optional[Any] = None
     ) -> 'BaseFactorModel':
         """Update factor state with standardized data.
         
@@ -608,8 +611,16 @@ class BaseFactorModel(pl.LightningModule):
             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.
+        history : int, optional
+            Number of recent periods to use for factor state update. If None, uses
+            all provided data (default). If specified (e.g., 60), uses only the most
+            recent N periods. Initial state (Z_0, V_0) is always estimated from
+            full training data, but the update uses only recent history for efficiency.
         kalman_filter : Any, optional
             Kalman filter instance. If None, uses default or model's kalman filter.
+        scaler : Any, optional
+            If provided, attach/replace the model's scaler (e.g., refit on new regime).
+            When None, keep the existing scaler from training.
             
         Returns
         -------
@@ -620,48 +631,11 @@ class BaseFactorModel(pl.LightningModule):
         --------
         >>> # Update state with new data, then predict
         >>> model.update(X_std).predict(horizon=1)
-        >>> # Or update and predict separately
-        >>> model.update(X_std)
+        >>> # Or update with only recent 12 periods
+        >>> model.update(X_std, history=12)
         >>> forecast = model.predict(horizon=6)
         """
-        self._check_trained()
-        
-        result = self.result  # Use property which ensures non-None after _check_trained()
-        
-        # 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}"
-            )
-        
-        # Handle NaN/Inf values
-        X_std = np.where(np.isfinite(X_std), X_std, np.nan)
-        
-        # 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_std, result, kalman_filter
-            )
-        else:
-            # DFM: Use Kalman filter directly on standardized data
-            Z_last_updated = self._update_factor_state_dfm(
-                X_std, result, kalman_filter or getattr(self, 'kalman', None)
-            )
-        
-        # 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__} update(): Failed to update factor state, "
-                f"keeping current state"
-            )
-        
-        return self
+        pass
     
     def get_result(self) -> BaseResult:
         """Extract result from trained model.

dfm_python/models/ddfm.py

@@ -1388,12 +1388,120 @@ class DDFM(BaseFactorModel):
             Mx=Mx
         )
         
+        # Convert to numpy (handles torch inputs) and attempt scaler inverse_transform if available
+        X_forecast = np.asarray(
+            X_forecast.detach().cpu().numpy() if hasattr(X_forecast, "detach") else X_forecast
+        )
+        scaler = getattr(self, "scaler", None)
+        if scaler is not None and hasattr(scaler, "inverse_transform"):
+            try:
+                X_forecast = scaler.inverse_transform(X_forecast)
+            except Exception as e:
+                _logger.warning(
+                    f"DDFM prediction: scaler.inverse_transform failed, returning unstandardized values. "
+                    f"error={e}"
+                )
+        
         if return_series and return_factors:
             return X_forecast, Z_forecast
         if return_series:
             return X_forecast
         return Z_forecast
     
+    def update(
+        self,
+        X_std: np.ndarray,
+        *,
+        history: Optional[int] = None,
+        kalman_filter: Optional[Any] = None,
+        scaler: Optional[Any] = None
+    ) -> 'DDFM':
+        """Update factor state with standardized data.
+        
+        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
+        ----------
+        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.
+        history : int, optional
+            Number of recent periods to use for factor state update. If None, uses
+            all provided data (default). If specified (e.g., 60), uses only the most
+            recent N periods. Initial state (Z_0, V_0) is always estimated from
+            full training data, but the update uses only recent history for efficiency.
+        kalman_filter : Any, optional
+            Kalman filter instance. If None, uses default or model's kalman filter.
+            
+        Returns
+        -------
+        DDFM
+            Self for method chaining
+            
+        Examples
+        --------
+        >>> # Update state with new data, then predict
+        >>> model.update(X_std).predict(horizon=1)
+        >>> # Or update with only recent 12 periods
+        >>> model.update(X_std, history=12)
+        >>> forecast = model.predict(horizon=6)
+        """
+        self._check_trained()
+        
+        # Optionally replace scaler (e.g., if refit on new regime)
+        if scaler is not None:
+            self.scaler = scaler
+        
+        result = self.result  # Use property which ensures non-None after _check_trained()
+        
+        # Validate input shape
+        if not isinstance(X_std, np.ndarray):
+            X_std = np.asarray(X_std)
+        if X_std.ndim != 2:
+            raise ValueError(
+                f"DDFM update(): X_std must be 2D array (T x N), "
+                f"got shape {X_std.shape}"
+            )
+        
+        # Handle NaN/Inf values
+        X_std = np.where(np.isfinite(X_std), X_std, np.nan)
+        
+        # Filter to recent history if specified
+        # Note: Initial state (Z_0, V_0) from result is estimated from full training data,
+        # but we use only recent history for the update step
+        if history is not None and history > 0:
+            if X_std.shape[0] > history:
+                X_recent = X_std[-history:, :]
+                _logger.debug(
+                    f"DDFM update(): Using {history} most recent periods out of {X_std.shape[0]} total periods"
+                )
+            else:
+                X_recent = X_std
+                _logger.debug(
+                    f"DDFM update(): history={history} specified but data has only {X_std.shape[0]} periods, using all data"
+                )
+        else:
+            X_recent = X_std
+        
+        # Update factor state using encoder to extract factors, then Kalman filter
+        Z_last_updated = self._update_factor_state_ddfm(
+            X_recent, result, kalman_filter
+        )
+        
+        # Update result.Z[-1, :] permanently
+        if Z_last_updated is not None:
+            result.Z[-1, :] = Z_last_updated
+        else:
+            _logger.warning(
+                f"DDFM update(): Failed to update factor state, "
+                f"keeping current state"
+            )
+            
+        return self
+    
     @property
     def result(self) -> DDFMResult:
         """Get model result from training state.

dfm_python/models/dfm.py

@@ -89,6 +89,7 @@ class DFM(BaseFactorModel):
         max_iter: int = 100,
         nan_method: int = 2,
         nan_k: int = 3,
+        tent_weights_dict: Optional[dict] = None,
         **kwargs
     ):
         """Initialize DFM instance.
@@ -119,6 +120,8 @@ class DFM(BaseFactorModel):
         self.max_iter = max_iter
         self.nan_method = nan_method
         self.nan_k = nan_k
+        # Optional tent weights to control aggregation (e.g., disable tent by passing {'q':[1.0]})
+        self.tent_weights_dict = tent_weights_dict
         
         # Determine number of factors
         if num_factors is None:
@@ -200,7 +203,7 @@ class DFM(BaseFactorModel):
             nQ=0,
             i_idio=None,
             clock=getattr(self.config, 'clock', 'm'),
-            tent_weights_dict=None,
+            tent_weights_dict=self.tent_weights_dict,
             frequencies=None,
             idio_chain_lengths=None,
             config=self.config
@@ -280,7 +283,7 @@ class DFM(BaseFactorModel):
             nQ=0,
             i_idio=torch.ones(y.shape[0], device=y.device, dtype=y.dtype),
             blocks=self.blocks.to(y.device),
-            tent_weights_dict={},
+            tent_weights_dict=self.tent_weights_dict,
             clock=getattr(self.config, 'clock', 'm'),
             frequencies=None,
             idio_chain_lengths=torch.zeros(y.shape[0], device=y.device, dtype=y.dtype),
@@ -832,6 +835,21 @@ class DFM(BaseFactorModel):
                             f"(max deviation: {max_deviation:.1f} std devs). "
                             f"Possible numerical instability."
                         )
+        
+        # Convert to numpy (handles torch inputs) and attempt scaler inverse_transform if available
+        X_forecast = np.asarray(
+            X_forecast.detach().cpu().numpy() if hasattr(X_forecast, "detach") else X_forecast
+        )
+        scaler = getattr(self, "scaler", None)
+        if scaler is not None and hasattr(scaler, "inverse_transform"):
+            try:
+                X_forecast = scaler.inverse_transform(X_forecast)
+            except Exception as e:
+                _logger.warning(
+                    f"DFM prediction: scaler.inverse_transform failed, returning unstandardized values. "
+                    f"error={e}"
+                )
+        
         if return_factors and np.any(~np.isfinite(Z_forecast)):
             nan_count = np.sum(~np.isfinite(Z_forecast))
             raise ValueError(
@@ -846,6 +864,100 @@ class DFM(BaseFactorModel):
             return X_forecast
         return Z_forecast
     
+    def update(
+        self,
+        X_std: np.ndarray,
+        *,
+        history: Optional[int] = None,
+        kalman_filter: Optional[Any] = None,
+        scaler: Optional[Any] = None
+    ) -> 'DFM':
+        """Update factor state with standardized data.
+        
+        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
+        ----------
+        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.
+        history : int, optional
+            Number of recent periods to use for factor state update. If None, uses
+            all provided data (default). If specified (e.g., 60), uses only the most
+            recent N periods. Initial state (Z_0, V_0) is always estimated from
+            full training data, but the update uses only recent history for efficiency.
+        kalman_filter : Any, optional
+            Kalman filter instance. If None, uses default or model's kalman filter.
+            
+        Returns
+        -------
+        DFM
+            Self for method chaining
+            
+        Examples
+        --------
+        >>> # Update state with new data, then predict
+        >>> model.update(X_std).predict(horizon=1)
+        >>> # Or update with only recent 12 periods
+        >>> model.update(X_std, history=12)
+        >>> forecast = model.predict(horizon=6)
+        """
+        self._check_trained()
+        
+        # Optionally replace scaler (e.g., if refit on new regime)
+        if scaler is not None:
+            self.scaler = scaler
+        
+        result = self.result  # Use property which ensures non-None after _check_trained()
+        
+        # Validate input shape
+        if not isinstance(X_std, np.ndarray):
+            X_std = np.asarray(X_std)
+        if X_std.ndim != 2:
+            raise ValueError(
+                f"DFM update(): X_std must be 2D array (T x N), "
+                f"got shape {X_std.shape}"
+            )
+        
+        # Handle NaN/Inf values
+        X_std = np.where(np.isfinite(X_std), X_std, np.nan)
+        
+        # Filter to recent history if specified
+        # Note: Initial state (Z_0, V_0) from result is estimated from full training data,
+        # but we use only recent history for the update step
+        if history is not None and history > 0:
+            if X_std.shape[0] > history:
+                X_recent = X_std[-history:, :]
+                _logger.debug(
+                    f"DFM update(): Using {history} most recent periods out of {X_std.shape[0]} total periods"
+                )
+            else:
+                X_recent = X_std
+                _logger.debug(
+                    f"DFM update(): history={history} specified but data has only {X_std.shape[0]} periods, using all data"
+                )
+        else:
+            X_recent = X_std
+        
+        # Update factor state using Kalman filter directly on standardized data
+        Z_last_updated = self._update_factor_state_dfm(
+            X_recent, result, kalman_filter or getattr(self, 'kalman', None)
+        )
+        
+        # Update result.Z[-1, :] permanently
+        if Z_last_updated is not None:
+            result.Z[-1, :] = Z_last_updated
+        else:
+            _logger.warning(
+                f"DFM update(): Failed to update factor state, "
+                f"keeping current state"
+            )
+            
+        return self
+    
     @property
     def result(self) -> DFMResult:
         """Get model result from training state.

dfm_python/ssm/em.py

@@ -570,7 +570,7 @@ class EMAlgorithm(nn.Module):
         resNaN = x_clean.clone()
         resNaN[indNaN] = torch.nan
         
-        # Determine tent kernel size (pC) for quarterly-monthly aggregation
+        # Determine tent kernel size (pC) for slower-frequency aggregation
         pC = 5  # Default: quarterly to monthly uses 5 periods [1,2,3,2,1]
         if R_mat is not None:
             pC = R_mat.shape[1]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dfm-python
-Version: 0.5.1
+Version: 0.5.2
 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
@@ -59,25 +59,25 @@ Description-Content-Type: text/markdown
 [![PyPI version](https://img.shields.io/pypi/v/dfm-python.svg)](https://pypi.org/project/dfm-python/)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 
-A comprehensive Python implementation of **Dynamic Factor Models (DFM)** and **Deep Dynamic Factor Models (DDFM)** for forecasting high-dimensional time series. Built with PyTorch Lightning for production-ready training and inference.
+A comprehensive Python implementation of **Dynamic Factor Models (DFM)** and **Deep Dynamic Factor Models (DDFM)** for forecasting high-dimensional time series. Built with PyTorch Lightning.
 
 ## Features
 
 ### Core Capabilities
-- ✅ **Mixed-frequency data**: Monthly, quarterly, semi-annual, annual series in one model
-- ✅ **Clock-based framework**: All factors evolve at a common clock frequency
-- ✅ **Block structure**: Flexible factor organization (global + sector-specific factors)
-- ✅ **Idiosyncratic components**: Per-series state augmentation for better fit
-- ✅ **Preprocessed data**: Users handle preprocessing (imputation, scaling) using sktime or other tools
-- ✅ **Forecasting**: Generate predictions for any horizon
-- ✅ **Nowcasting**: Estimate current period values using incomplete data
-- ✅ **Deep DFM (DDFM)**: Nonlinear encoder with PyTorch for capturing complex factor structures
+- **Mixed-frequency data**: Monthly, quarterly, semi-annual, annual series in one model
+- **Clock-based framework**: All factors evolve at a common clock frequency
+- **Block structure**: Flexible factor organization (global + sector-specific factors)
+- **Idiosyncratic components**: Per-series state augmentation for better fit
+- **Preprocessed data**: Users handle preprocessing (imputation, scaling) using sktime or other tools
+- **Forecasting**: Generate predictions for any horizon
+- **Nowcasting**: Estimate current period values using incomplete data
+- **Deep DFM (DDFM)**: Nonlinear encoder with PyTorch for capturing complex factor structures
 
 ### Technical Features
-- ✅ **PyTorch Lightning**: Standard training interface with DataModule and Trainer
-- ✅ **Multiple configuration methods**: YAML files, Python dictionaries, or Hydra
-- ✅ **Advanced numerical stability**: Adaptive regularization, spectral radius capping, variance floors
-- ✅ **Production-ready**: Comprehensive error handling, extensive testing, well-documented
+- **PyTorch Lightning**: Standard training interface with DataModule and Trainer
+- **Multiple configuration methods**: YAML files, Python dictionaries, or Hydra
+- **Advanced numerical stability**: Adaptive regularization, spectral radius capping, variance floors
+- **Error handling**: Comprehensive error handling, extensive testing, well-documented
 
 ## Installation
 
@@ -391,17 +391,17 @@ pytest src/test/test_trainer.py -v
 ## Project Status
 
 **Version**: 0.5.1  
-**Status**: Stable and production-ready  
-**Python**: 3.10+
+**Status**: Stable  
+**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  
+- **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.1.dist-info → dfm_python-0.5.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-dfm_python/__init__.py,sha256=C_3NmIr6G7CyDoWB87Osp5b8XZR65LpHmflxMthue74,5683
+dfm_python/__init__.py,sha256=NU9ZxIsniiU9q1IVL8AuGVej9_ROM7nyIFD5dh4MfT4,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=hzXL6MwaIxzA4uzouh6Bc_57lbpedphN9ErTMgfkpeE,15967
@@ -14,19 +14,19 @@ dfm_python/encoder/pca.py,sha256=FsvCqXD0AuASxymV2-5oAM2QVv_syhSyL3CmxVOXxgM,105
 dfm_python/encoder/vae.py,sha256=nKgt327-oQ1KT6q3hdABI9z_1K26cKSLVXC1Criy0KA,21250
 dfm_python/lightning/__init__.py,sha256=_2DFZnMX3BOybuZZ76VJJ8gmMLZ7tFyO3yyN-A4_ECI,1247
 dfm_python/lightning/data_module.py,sha256=cZuBdGbk6meaeiw9ZPGkcsUW4v25ZP_km-u0Pkoh5bg,34815
-dfm_python/lightning/scaling.py,sha256=PrHCCNS7Z06xkq7_AiQv2bru2Cvra5mejQk6tAzr_hw,16844
+dfm_python/lightning/scaling.py,sha256=-8zYrBm3y4_Ke0ODh1-SJnC0pWef3ZJT6GRv8owo2o8,16997
 dfm_python/logger/__init__.py,sha256=2GwtfOG2ttbtJ5CrO6338R6GIao3YuY0HLiBeCoC0Ns,1066
 dfm_python/logger/inference_logger.py,sha256=TmXiWl703boJ3mIR-WgGpy6hfeF8a68OW9vrZppTTCE,10091
 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=-mKK2onDilvPLVRRrW3W7GYsMZxLMHjZWj6n6gL_xnw,30041
-dfm_python/models/ddfm.py,sha256=yZe7pxc81ZOsCwzoJ78UHXhEu5adRxkdTEvq-L17Sho,59415
-dfm_python/models/dfm.py,sha256=r4MnjhGv9bPB2spiluF6cWKw0cuwR_qq7pfw5oz8dlM,33675
+dfm_python/models/base.py,sha256=WIx1d38bsaRkpfA4iYVG0_x7R1N8zVfi922LAlXqsEg,29261
+dfm_python/models/ddfm.py,sha256=4mGsMJ_2P_EOnOItLIrs7_by6EF25NX2dldrG1O5GYY,63758
+dfm_python/models/dfm.py,sha256=BgHqCiiUprS3rtOOaj31LXJ8RnzESVdSOTZ-sxReNwc,38287
 dfm_python/models/mcmc.py,sha256=QXBVxeBHREkc9K_xCGR1Y4sIFUkmX_RbRcgNktojuEc,23978
 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/em.py,sha256=sUiwuBVLTQBNHlBJ9YwemVY0wJYMTUqkuhyjPohENNw,63429
 dfm_python/ssm/kalman.py,sha256=KC6Q71VxM2NSdBVB5107QsNUm-_kE59MiyqrzImWz7E,45931
 dfm_python/ssm/utils.py,sha256=SYsu4E2zHAXXLfR2iQWNX-ywuzmwZj5kT4owHlyfvjU,13637
 dfm_python/trainer/__init__.py,sha256=gc8jRjM-y2XN911LldwYUYHAAuFEvzUJJvXhG6B3Sv4,25654
@@ -38,7 +38,7 @@ dfm_python/utils/diagnostics.py,sha256=UwrJfnn8VACATfQEkTcWw9eEJlTik-VCgTZ1dJABZ
 dfm_python/utils/helpers.py,sha256=iOVwkP5pti-q-HKOAkp6bUPAp7BPV7BBgh8jL76g9go,13049
 dfm_python/utils/statespace.py,sha256=P-GQiCP9HzI2d9PgYst4nmRuocEXr9gG1yzGYsYWkMg,44159
 dfm_python/utils/time.py,sha256=o6NRPuk4Ynk8kPaUnzR6xq3pPAO6aLUTR9N_3hn_N88,35651
-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,,
+dfm_python-0.5.2.dist-info/METADATA,sha256=FC2_7glZDt_csfDlluuCi0tlOh-cpwwjPg4MkScIU3k,12018
+dfm_python-0.5.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dfm_python-0.5.2.dist-info/licenses/LICENSE,sha256=6e87br6LCDHjy2hdIR1-sdBQy351qdmSEbOg6jQ7ZXY,1063
+dfm_python-0.5.2.dist-info/RECORD,,