modelflowib 2.77__tar.gz → 2.78__tar.gz

{modelflowib-2.77 → modelflowib-2.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelflowib
-Version: 2.77
+Version: 2.78
 Summary: A tool to solve and manage dynamic economic and financial models
 Author-email: Ib Hansen <Ib.Hansen.Iv@gmail.com>
 License-Expression: MIT

{modelflowib-2.77 → modelflowib-2.78}/modelconstruct_estimation.py

@@ -1781,15 +1781,34 @@ def _estimation_record_to_markdown(record: dict) -> str:
 
     coefs = _estimator_coefficients_for_markdown(est)
     if coefs:
-        lines.extend([
-            "",
-            "| Parameter | Estimate |",
-            "|:--|--:|",
-        ])
+        try:
+            tvals = est.tvalues.to_dict()
+        except Exception:
+            tvals = {}
+        # NaN != NaN — only add the column when at least one t-stat exists.
+        has_t = any(v == v for v in tvals.values())
+        if has_t:
+            lines.extend([
+                "",
+                "| Parameter | Estimate | t-stat |",
+                "|:--|--:|--:|",
+            ])
+        else:
+            lines.extend([
+                "",
+                "| Parameter | Estimate |",
+                "|:--|--:|",
+            ])
         for key in sorted(coefs, key=lambda x: (str(x).split("__")[0], int(str(x).split("__")[-1]) if str(x).split("__")[-1].lstrip("-").isdigit() else str(x))):
-            lines.append(
-                f"| {_markdown_escape_cell(key)} | {_markdown_escape_cell(_markdown_format_number(coefs[key]))} |"
+            row = (
+                f"| {_markdown_escape_cell(key)} "
+                f"| {_markdown_escape_cell(_markdown_format_number(coefs[key]))} |"
             )
+            if has_t:
+                t = tvals.get(key)
+                t_cell = f"{t:.3f}" if t is not None and t == t else ""
+                row += f" {_markdown_escape_cell(t_cell)} |"
+            lines.append(row)
 
     return "\n".join(lines) + "\n"
 
@@ -2429,6 +2448,31 @@ class Makemodel(BaseExplode):
         """
         return MakeModelReport(self, title=title, plot_format=plot_format, report_all=report_all)
 
+    @property
+    def tvalues(self):
+        """t-statistics for all estimated equations as a DataFrame.
+
+        Rows are parameter tokens (``C__1``, ``C__2``, ...), one column per
+        estimated equation named by its endogenous variable. NaN where a
+        parameter is not in that equation or the backend provides no
+        t-statistic (fixed/derived parameters, failed covariance, EViews
+        ``NA`` rows).
+
+        Per-equation access: ``rec['estimator_object'].tvalues`` on the
+        entries of :attr:`estimation_records`.
+        """
+        import pandas as pd
+        cols = {}
+        for rec in self.estimation_records:
+            est = rec.get('estimator_object')
+            try:
+                ser = est.tvalues
+            except Exception:
+                continue
+            name = getattr(est, 'endo_var', '') or rec.get('frmlname', '')
+            cols[name] = ser
+        return pd.DataFrame(cols)
+
     @property
     def markdown_with_estimation(self) -> str:
         """Original Markdown input with compact estimation tables inserted.
@@ -2816,6 +2860,19 @@ class Listmodels(BaseExplode):
         """
         return MakeModelReport(self, title=title, plot_format=plot_format, report_all=report_all)
 
+    @property
+    def tvalues(self):
+        """t-statistics of all member Makemodels, combined column-wise.
+
+        See :attr:`Makemodel.tvalues` for the layout.
+        """
+        import pandas as pd
+        frames = [mex.tvalues for mex in self.makemodels]
+        frames = [f for f in frames if not f.empty]
+        if not frames:
+            return pd.DataFrame()
+        return pd.concat(frames, axis=1)
+
     @property
     def markdown_with_estimation(self) -> str:
         """Concatenate member Makemodel markdown-with-estimation strings."""

{modelflowib-2.77 → modelflowib-2.78}/modelestimator_new.py

@@ -99,6 +99,7 @@ from lmfit import Parameters, minimize
 from matplotlib.gridspec import GridSpec
 
 from modelclass import model
+from modelmanipulation import check_syntax
 import modelnormalize as nz
 
 
@@ -904,6 +905,13 @@ class Eq_parent:
         raw = self.org_eq.upper()
         eq_body, constraint_text = _split_st_clause(raw)
 
+        # 2a) Syntax-check the equation text BEFORE parameter-token
+        #     normalization. Typos like ``C(1)2020`` (missing ``*D``) or a
+        #     missing ``+`` between terms are clean SyntaxErrors here, but
+        #     after normalization they can merge into single valid
+        #     identifiers and slip through to give degenerate fits.
+        self._check_eq_syntax(eq_body)
+
         # 2) Normalize parameter tokens in both equation body AND constraints
         #    so names align downstream (e.g. ``C(1)`` -> ``C__1``).
         eq = _normalize_param_tokens(eq_body, self.est_param, self.param_names)
@@ -946,6 +954,7 @@ class Eq_parent:
         #    Subclasses that need a custom dataframe layout (e.g. mfcalc-built
         #    regressors for OLS) handle that themselves.
         if self.input_df is not None:
+            self._check_unknown_variables()
             self.eq_var_df = (
                 self.mdummy.insertModelVar(self.input_df)
                 .loc[:, self.varname_all]
@@ -953,7 +962,49 @@ class Eq_parent:
             )
             self.estimation_df = self.eq_var_df
 
-    # -- variable discovery (cached, derived from mdummy) ---------------------
+    @staticmethod
+    def _check_eq_syntax(eq_body: str) -> None:
+        """Raise ``SyntaxError`` (with a pinpointed location) if the equation
+        text does not parse as Python expressions.
+
+        Each side of the first ``=`` is checked separately — the full
+        statement would be an invalid Python assignment whenever the LHS is
+        a transformation like ``DLOG(...)``. Whitespace is preserved, which
+        is what makes missing-operator typos detectable.
+        """
+        checkable = eq_body.replace("@ABS(", "ABS(")
+        sides = [side.strip() for side in checkable.split("=", 1)]
+        check_syntax([side for side in sides if side])
+
+    def _check_unknown_variables(self) -> None:
+        """Print a diagnosis and raise for variables with no data column.
+
+        Every variable in the equation that is not a parameter placeholder
+        (active prefix or ``param_names``) or a helper slot must exist in
+        ``input_df``. Anything else would be inserted as an all-NaN column
+        by ``insertModelVar`` and silently degrade or break the fit —
+        typically a misspelled variable name or a forgotten ``param_names``
+        entry (``ALFA(1)`` with ``'alfa'`` not declared reads as a lead of
+        an unknown variable ALFA).
+        """
+        helpers = {"ACTUAL", "FITTED", "RESIDUALS"}
+        known = set(self.input_df.columns) | set(self.c_params) | helpers
+        unknown = sorted(set(self.varname_all) - known)
+        if unknown:
+            # Print the diagnosis, then raise a bare SyntaxError — same
+            # style as check_syntax. IPython renders SyntaxError without
+            # the frame stack, so the notebook shows the message above
+            # instead of a long construction call stack.
+            print(
+                f"{type(self).__name__}({self.endo_var}): the equation "
+                f"references variables with no column in input_df:\n"
+                f"    {unknown}\n"
+                f"Equation: {self.org_eq_clean}\n"
+                "Check for misspelled variable names or missing param_names "
+                "entries — such variables would otherwise enter the "
+                "estimation as all-NaN columns."
+            )
+            raise SyntaxError("Unknown variables in equation - see above") from None
 
     @property
     def mdummy(self):
@@ -1079,6 +1130,10 @@ class EstimatorBackend(Eq_parent, ABC):
         Default is a no-op. Override to reject equation forms the backend
         cannot handle.
 
+    :meth:`_tvalues_dict`
+        Default returns ``{}`` (no t-statistics). Override to return
+        ``{<prefix>__n: t}`` so the :attr:`tvalues` Series is populated.
+
     Standard attributes set during ``__post_init__``
     ------------------------------------------------
     regression_model : Any
@@ -1230,6 +1285,29 @@ class EstimatorBackend(Eq_parent, ABC):
                     break
         return mapped
 
+    # ---- t-statistics ------------------------------------------------------
+
+    def _tvalues_dict(self) -> Dict[str, float]:
+        """Backend-specific t-statistics keyed by ``{est_param}__n`` token.
+
+        Default: no t-statistics available. Backends override where the
+        fitted result exposes (or allows computing) them.
+        """
+        return {}
+
+    @cached_property
+    def tvalues(self) -> pd.Series:
+        """t-statistics as a Series keyed like :attr:`coef_ser`.
+
+        Parameters without an available t-statistic (fixed, derived, or the
+        backend could not provide one) are NaN.
+        """
+        tvals = self._tvalues_dict()
+        return pd.Series(
+            {p: tvals.get(p, float("nan")) for p in self.c_params},
+            name=self.caption, dtype=float,
+        )
+
     # ---- A/F and residuals (computed once, cached) -------------------------
 
     @cached_property
@@ -1486,6 +1564,13 @@ class Estimate_ols(EstimatorBackend):
             "<caption><h3>OLS Regression Results</h3></caption>",
         )
 
+    def _tvalues_dict(self) -> Dict[str, float]:
+        """statsmodels exposes t-statistics directly, keyed by regressor
+        column name — map those back to the canonical parameter tokens."""
+        return self._map_statsmodels_params(
+            self.regression_model.tvalues.to_dict()
+        )
+
     # ---- override estimation_smpl: OLS reports its EFFECTIVE sample --------
 
     @cached_property
@@ -1610,6 +1695,33 @@ class Estimate_nls_lmfit(EstimatorBackend):
             "<h2>Fit Result</h2>", "<h3>NLS Regression Results</h3>"
         )
 
+    def _tvalues_dict(self) -> Dict[str, float]:
+        """lmfit provides standard errors (from the covariance matrix when
+        ``calc_covar=True``); t = value / stderr. Fixed parameters, derived
+        (``expr``) parameters without propagated errors, and fits where the
+        covariance could not be estimated have ``stderr`` None (or NaN) and
+        are omitted (→ NaN in :attr:`tvalues`)."""
+        res = self.regression_model
+        out: Dict[str, float] = {}
+        for name, p in res.params.items():
+            # stderr is None when lmfit produced no uncertainties, and can
+            # be NaN when the covariance matrix is ill-conditioned.
+            if p.stderr and p.stderr == p.stderr:
+                out[name] = p.value / p.stderr
+        if not out and any(p.vary for p in res.params.values()):
+            print(
+                f"[{type(self).__name__}({self.endo_var})] WARNING: lmfit "
+                f"produced no parameter uncertainties "
+                f"(errorbars={getattr(res, 'errorbars', None)}), so no "
+                "t-values are available. Common causes: singular or "
+                "ill-conditioned Jacobian (collinear or huge-scale "
+                "regressors), parameters stuck at a bound, or a fit that "
+                "did not converge. Inspect "
+                "est.regression_model.params.pretty_print() and "
+                "est.regression_model.message."
+            )
+        return out
+
 
 # =============================================================================
 # Estimate_nls_eviews — nonlinear least squares via EViews (py2eviews)
@@ -1702,6 +1814,26 @@ class Estimate_nls_eviews(EstimatorBackend):
     def _render_summary_html(self) -> str:
         return eviews_output_to_html(self.regression_model)
 
+    def _tvalues_dict(self) -> Dict[str, float]:
+        """Parse the t-Statistic column from the EViews spool text.
+
+        Only the coefficient vector is read back from EViews numerically;
+        the coefficient table (Coefficient, Std. Error, t-Statistic, Prob.)
+        exists only as text in the spool. Rows where EViews prints ``NA``
+        simply do not match and stay NaN in :attr:`tvalues`.
+        """
+        if not isinstance(self.regression_model, str):
+            return {}
+        num = r"(-?[\d.]+(?:[eE][+-]?\d+)?)"
+        out: Dict[str, float] = {}
+        for m in re.finditer(
+            rf"^\s*C\((\d+)\)\s+{num}\s+{num}\s+{num}",
+            self.regression_model,
+            flags=re.MULTILINE,
+        ):
+            out[f"{self.est_param}__{m.group(1)}"] = float(m.group(4))
+        return out
+
 
 # =============================================================================
 # Estimate_nls — factory class dispatching on solver

{modelflowib-2.77 → modelflowib-2.78}/modelflowib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelflowib
-Version: 2.77
+Version: 2.78
 Summary: A tool to solve and manage dynamic economic and financial models
 Author-email: Ib Hansen <Ib.Hansen.Iv@gmail.com>
 License-Expression: MIT

{modelflowib-2.77 → modelflowib-2.78}/modelhtml.py

@@ -118,6 +118,7 @@ def _mmr_md_to_html(
 
     in_p = in_ul = in_ol = in_bll = in_fence = in_table = False
     tbl_hdr_done = False
+    pending_est = False
 
     def ep():
         nonlocal in_p
@@ -148,9 +149,24 @@ def _mmr_md_to_html(
     def end_all():
         ep(); eul(); eol(); ebll(); etbl()
 
+    def flush_est():
+        # Emit the panel for the last estimated equation once all of its
+        # '>>' continuation lines have been rendered, so the equation is not
+        # split around its estimation output.
+        nonlocal pending_est, rec_i, panel_i
+        if pending_est:
+            pending_est = False
+            if rec_i < len(est_records):
+                ebll()
+                out.append(_mmr_est_panel(est_records[rec_i], panel_i, plot_format))
+                panel_i += 1; rec_i += 1
+
     for raw in lines:
         s = raw.strip()
 
+        if pending_est and not s.startswith('>>'):
+            flush_est()
+
         # code fence (```)
         if s.startswith('```'):
             if in_fence:
@@ -192,20 +208,20 @@ def _mmr_md_to_html(
                 end_all()
                 out.append('<pre class="mmr-bll"><code>'); in_bll = True
             out.append(_mmr_annotate_bll(content, var_desc))
+            # The estimator tag may sit on a continuation line.
+            if _mmr_has_estimator_tag(raw):
+                pending_est = True
             continue
 
         # BLL equation >
         if s.startswith('>'):
             content = s[1:].strip()
-            has_est = _mmr_has_estimator_tag(raw)
             if not in_bll:
                 end_all()
                 out.append('<pre class="mmr-bll"><code>'); in_bll = True
             out.append(_mmr_annotate_bll(content, var_desc))
-            if has_est and rec_i < len(est_records):
-                ebll()
-                out.append(_mmr_est_panel(est_records[rec_i], panel_i, plot_format))
-                panel_i += 1; rec_i += 1
+            if _mmr_has_estimator_tag(raw):
+                pending_est = True
             continue
 
         # markdown table row
@@ -262,6 +278,7 @@ def _mmr_md_to_html(
 
     if in_fence:
         out.append('</code></pre>')
+    flush_est()
     end_all()
 
     # leftover estimation records not matched to any source line

{modelflowib-2.77 → modelflowib-2.78}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "modelflowib"                       # PyPI distribution name
-version = "2.77"                           # OVERWRITTEN at build time from MF_VERSION
+version = "2.78"                           # OVERWRITTEN at build time from MF_VERSION
                                             # (set_pyproject_version.py / make_pip.py -v)
 description = "A tool to solve and manage dynamic economic and financial models"
 readme = "README.md"