modelflowib 2.75__tar.gz → 2.77__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelflowib
-Version: 2.75
+Version: 2.77
 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.75 → modelflowib-2.77}/modelclass.py

@@ -3188,7 +3188,7 @@ class Modify_Mixin():
         newnormalisation = [l.split() for l in lines]
         vars_before_normalization = {beforeendo.upper() for  beforeendo,afterendo in newnormalisation  }
         frml_normalize_strip = {(beforeendo.upper(),afterendo.upper()) : self.allvar[beforeendo]['frml'].replace('$','').split(' ',2)   for beforeendo,afterendo in newnormalisation }
-        frml_normalize_gross = {(beforeendo,afterendo) : (fname ,normal(expression,the_endo = afterendo,endo_lhs=False,add_factor=False))  for (beforeendo,afterendo),(frml,fname,expression)  in frml_normalize_strip.items() }
+        frml_normalize_gross = {(beforeendo,afterendo) : (fname ,normal(expression,the_endo = afterendo,endo_lhs=False,add_add_factor=False))  for (beforeendo,afterendo),(frml,fname,expression)  in frml_normalize_strip.items() }
         frmldict_normalized = {afterendo : f'FRML {fname} {nexpression.normalized}$'
                                for (beforeendo,afterendo),(fname,nexpression)  in frml_normalize_gross.items() }
 #        breakpoint() 
@@ -3282,8 +3282,10 @@ class Modify_Mixin():
 
         Parameters
         ----------
-        updateeq : TYPE
-            new equations seperated by newline . 
+        updateeq : str or Makemodel
+            new equations seperated by newline, or a Makemodel instance whose
+            normalized equations (including per-equation add factors and
+            fitted equations, when present) are used as the update.
         newfunks : TYPE, optional
             Additional userspecified functions. The default is [].
         calc_add : bool, optional
@@ -3297,32 +3299,50 @@ class Modify_Mixin():
             a dataframe with calculated add factors. Origin is the original models lastdf.
 
         '''
-        
-            
-        updatefunks=list(set(self.funks+newfunks) ) # 
-        
-        newmodelname = newname if newname else self.name+' Updated'      
-    
-        dfvars = set(self.lastdf.columns)    
-    
-        updatemodel = mp.tofrml(updateeq)   # create the moedl with the usual processing of frml's 
-        while '  ' in updatemodel:
-            updatemodel = updatemodel.replace('  ', ' ')
-        frml2   = updatemodel.split('$') 
-        frml2_strip = [mp.split_frml(f+'$') for f in frml2 if len(f)>2]
-        frml2_normal = [[frml,fname, 
-                         normal(expression[:-1],do_preprocess=do_preprocess,add_add_factor=add_add_factor,
-                                make_fixable = pt.kw_frml_name(fname.upper(),'FIXABLE'))]
-                           for allfrml,frml,fname,expression in frml2_strip] 
-        frmldict_update = {nexpression.endo_var: f'{frml} {fname} {nexpression.normalized}$' for 
-                           frml,fname,nexpression in frml2_normal} 
-        
-        
-        if add_add_factor:
-            frmldict_calc_add = {nexpression.endo_var: f'{frml} {fname} {nexpression.calc_add_factor}$' for 
-                    frml,fname,nexpression in frml2_normal if nexpression.endo_var in self.endogene|self.exogene|dfvars } 
-        else: 
-            frmldict_calc_add={}
+        from modelconstruct_estimation import Makemodel   # local to avoid circular import
+
+        updatefunks=list(set(self.funks+newfunks) ) #
+
+        newmodelname = newname if newname else self.name+' Updated'
+
+        dfvars = set(self.lastdf.columns)
+        new_var_description = self.var_description
+
+        if isinstance(updateeq, Makemodel):
+            # the Makemodel has already expanded, optionally estimated and normalized the
+            # equations, and decided add factor/fixable/fitted per equation from its flags
+            updatefunks = list(set(updatefunks + updateeq.funks))
+            new_var_description = {**self.var_description, **updateeq.var_description}
+            frml2_normal = [['FRML', fname, nexpression]
+                            for fname, (parts, nexpression)
+                            in zip(updateeq.normal_output_frmlnames, updateeq.normal)]
+            frmldict_update = {nexpression.endo_var: f'{frml} {fname} {nexpression.normalized}$' for
+                               frml,fname,nexpression in frml2_normal}
+            frmldict_update = {**frmldict_update,
+                               **{f'{nexpression.endo_var}_FITTED': f'FRML <FIT> {nexpression.fitted}$'
+                                  for frml,fname,nexpression in frml2_normal if len(nexpression.fitted)}}
+            frmldict_calc_add = {nexpression.endo_var: f'{frml} <CALC_ADD_FACTOR> {nexpression.calc_add_factor}$' for
+                    frml,fname,nexpression in frml2_normal
+                    if len(nexpression.calc_add_factor) and nexpression.endo_var in self.endogene|self.exogene|dfvars }
+        else:
+            updatemodel = mp.tofrml(updateeq)   # create the moedl with the usual processing of frml's
+            while '  ' in updatemodel:
+                updatemodel = updatemodel.replace('  ', ' ')
+            frml2   = updatemodel.split('$')
+            frml2_strip = [mp.split_frml(f+'$') for f in frml2 if len(f)>2]
+            frml2_normal = [[frml,fname,
+                             normal(expression[:-1],do_preprocess=do_preprocess,add_add_factor=add_add_factor,
+                                    make_fixable = pt.kw_frml_name(fname.upper(),'FIXABLE'))]
+                               for allfrml,frml,fname,expression in frml2_strip]
+            frmldict_update = {nexpression.endo_var: f'{frml} {fname} {nexpression.normalized}$' for
+                               frml,fname,nexpression in frml2_normal}
+
+
+            if add_add_factor:
+                frmldict_calc_add = {nexpression.endo_var: f'{frml} {fname} {nexpression.calc_add_factor}$' for
+                        frml,fname,nexpression in frml2_normal if nexpression.endo_var in self.endogene|self.exogene|dfvars }
+            else:
+                frmldict_calc_add={}
         # breakpoint()
             
         frmldict    = {k: v['frml'] for (k,v) in self.allvar.items() if k in self.endogene } # frml's in the existing model 
@@ -3331,8 +3351,8 @@ class Modify_Mixin():
         newfrml     = '\n'.join([f for f in newfrmldict.values()])
         newmodel    =  self.__class__(newfrml,modelname = f'updated {self.name}',
                                       funks=updatefunks,
-                                 var_description=self.var_description, 
-                                 model_description = self.model_description, 
+                                 var_description=new_var_description,
+                                 model_description = self.model_description,
                                  var_groups = self.var_groups , 
                                  reports = self.reports , 
                                  substitution = self.substitution, 

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

@@ -982,6 +982,16 @@ from IPython.display import display, Markdown, Math
 import re
 from IPython.display import display, Markdown, Math
 
+class Markdown(Markdown):
+    """IPython Markdown, but with the markdown source as the text/plain fallback.
+
+    The stock class reprs as '<IPython.core.display.Markdown object>', and that
+    string is what latex/pdf exporters show, as they can not render the
+    text/markdown mime type and fall back to text/plain. With the source as
+    repr, exported documents show the model text instead."""
+    def __repr__(self):
+        return str(self.data)
+
 def display_model(cell: str, spec: str = "markdown"):
     """
     Display a model specification.
@@ -1165,8 +1175,12 @@ def _parse_smpl(smpl, df=None):
     Preferred FRML syntax is::
 
         <smpl=start end>
+        <smpl=(start end)>
 
-    where ``start`` and ``end`` are separated by one or more blanks. The
+    where ``start`` and ``end`` are separated by one or more blanks, with the
+    brackets optional. A comma may separate them when the value does not pass
+    through a FRML tag -- ``smpl='2000, 2025'`` as a keyword argument -- but not
+    inside ``<...>``, where the tag parser splits options on commas first. The
     labels are **not** coerced to integers, because the dataframe index may be
     a PeriodIndex, DatetimeIndex, quarterly strings, or another custom index
     type. If ``df`` is supplied, its index is used via ``slice_locs`` to
@@ -1256,16 +1270,28 @@ def _parse_smpl(smpl, df=None):
     if not text:
         return None
 
+    # Accept a parenthesised spelling, so <smpl=(2000 2025)> reads the same as
+    # the Python-side smpl=(2000, 2025) tuple. Note that inside a FRML tag only
+    # the blank-separated form works: kw_frml_name splits the tag's options on
+    # commas without regard for brackets, so <smpl=(2000,2025)> would arrive
+    # here already broken in two.
+    closing = {'(': ')', '[': ']'}
+    if len(text) > 1 and text[0] in closing and text[-1] == closing[text[0]]:
+        text = text[1:-1].strip()
+        if not text:
+            return None
+
     # New preferred syntax: <smpl=start end>. Keep old colon syntax so older
     # notebooks do not break.
-    if ':' in text and len(text.split()) == 1:
+    if ':' in text and ',' not in text and len(text.split()) == 1:
         start, end = [p.strip() for p in text.split(':', 1)]
     else:
-        parts = text.split()
+        parts = [p for p in re.split(r'[,\s]+', text) if p]
         if len(parts) != 2:
             raise ModelSpecificationError(
-                "SMPL must be written as 'start end' separated by blanks "
-                f"(or legacy 'start:end'); got {smpl!r}"
+                "SMPL must be written as 'start end' separated by blanks, "
+                "optionally bracketed as '(start end)' (or legacy "
+                f"'start:end'); got {smpl!r}"
             )
         start, end = parts
 
@@ -1631,11 +1657,17 @@ def _estimate_and_bake_expression(
     estimator_name,
     input_df=None,
     smpl=None,
+    smpl_is_local: bool = False,
     caption: Optional[str] = None,
     estimator_kwargs: Optional[dict] = None,
     estimator_classes: Optional[dict] = None,
 ):
-    """Instantiate an estimator/factory, run it, and return (baked_expression, estimator_obj)."""
+    """Instantiate an estimator/factory, run it, and return (baked_expression, estimator_obj).
+
+    ``smpl_is_local`` marks a sample that came from this equation's own
+    ``<smpl=...>`` rather than from the model-wide default, which decides
+    whether it may override a model-wide ``estimator_kwargs['smpl']``.
+    """
     estimator_constructor = _get_estimator_class(estimator_name, estimator_classes)
     kwargs = dict(estimator_kwargs or {})
 
@@ -1644,13 +1676,16 @@ def _estimate_and_bake_expression(
     # still override the factory's stored defaults.
     if input_df is not None and 'input_df' not in kwargs:
         kwargs['input_df'] = input_df
-    if smpl is not None and 'smpl' not in kwargs:
+    # An equation-local <smpl=...> outranks the model-wide estimator_kwargs; a
+    # model-wide Makemodel.smpl does not.
+    if smpl is not None and (smpl_is_local or 'smpl' not in kwargs):
         kwargs['smpl'] = smpl
     if caption is not None and 'caption' not in kwargs:
         kwargs['caption'] = caption
 
     estimator_obj = _instantiate_estimator(estimator_constructor, expression, kwargs)
-    estimator_obj = _require_estimator_backend_instance(estimator_obj, estimator_name)
+    # Validates in place and raises; it returns the same object, so do not rebind.
+    _require_estimator_backend_instance(estimator_obj, estimator_name)
     fit_result = _maybe_run_estimator_fit(estimator_obj)
 
     baked = _extract_expression_from_estimator(estimator_obj, fit_result)
@@ -1768,20 +1803,39 @@ def _markdown_with_estimation_blocks(original_text: str, estimation_records: lis
     """Insert estimation markdown blocks after estimator-tagged source lines.
 
     This preserves the original user-facing Markdown as much as possible. For
-    the common notebook syntax, each line beginning with ``>`` and containing
+    the common notebook syntax, each equation beginning with ``>`` and containing
     ``<estimator=...>`` gets the next estimation block inserted immediately
     after it. If template expansion creates more estimated equations than can
     be matched to source lines, the remaining blocks are appended at the end.
+
+    An equation can be spread over several lines: a ``>`` line followed by
+    ``>>`` continuations, which the parser joins into one statement. The block
+    goes after the last of those, so the whole equation is shown before its
+    estimation output rather than being split around it.
     """
     records = list(estimation_records or [])
     if not records:
         return original_text
 
+    lines = original_text.splitlines()
     out = []
     rec_i = 0
-    for line in original_text.splitlines():
+    i = 0
+    while i < len(lines):
+        line = lines[i]
         out.append(line)
-        if rec_i < len(records) and _line_has_estimator_tag(line):
+        i += 1
+
+        if not _line_has_estimator_tag(line):
+            continue
+
+        # Carry the rest of the equation across before inserting the block.
+        # The tag may sit on the '>' line or on any of its continuations.
+        while i < len(lines) and lines[i].lstrip().startswith(">>"):
+            out.append(lines[i])
+            i += 1
+
+        if rec_i < len(records):
             out.append(_estimation_record_to_markdown(records[rec_i]).rstrip())
             rec_i += 1
 
@@ -1795,6 +1849,34 @@ def _markdown_with_estimation_blocks(original_text: str, estimation_records: lis
     return "\n".join(out)
 
 
+def _strip_markdown_list_blocks(text: str) -> str:
+    """Remove ``>list`` / ``>tlist`` definition blocks from markdown model text.
+
+    A list block is a line whose content (after the leading ``>``) begins with
+    ``list`` or ``tlist``, together with any immediately following ``>>``
+    continuation lines. Equation lines and their ``>>`` continuations are left
+    untouched, because those continuations follow a ``>`` equation line rather
+    than a ``>list`` line.
+
+    Used by ``markdown_with_estimation_no_list`` to support the
+    ``render_list=0`` rendering path of the ``%%Makemymodel`` magic.
+    """
+    out = []
+    in_list = False
+    for line in text.splitlines():
+        stripped = line.lstrip()
+        if in_list:
+            if stripped.startswith('>>'):
+                # Continuation of the current list definition.
+                continue
+            in_list = False
+        if re.match(r'>\s*(list|tlist)\b', stripped, flags=re.IGNORECASE):
+            in_list = True
+            continue
+        out.append(line)
+    return '\n'.join(out)
+
+
 @dataclass
 class BaseExplode:
     """Common parent for Makemodel and Listmodels."""
@@ -1939,9 +2021,80 @@ class BaseExplode:
 
 @dataclass
 class Makemodel(BaseExplode):
+    """Expand a model template (markdown or modelflow) into solvable FRMLs.
+
+    Every attribute below can be inspected with a ``show`` prefix, which prints
+    it nicely, for instance ``consumption.showpost_sum``. The stages follow the
+    order in which ``__post_init__`` produces them.
+
+    **1. Input and options (what you pass in)**
+
+    | Attribute | Description |
+    |---|---|
+    | `showoriginal_statements` | Input expressions |
+    | `showlist_defs` | Lists definitions |
+    | `showtype_input` | Originaal as type modelflow or markdown |
+    | `showreplacements` | list of string tupels with string replacements |
+    | `showfunks` | List of user specified functions to be used in model |
+    | `showmodelname` | A optional name for this (sub) model |
+    | `showvar_description` | Variable descriptions (user-supplied, merged with descriptions from estimated equations) |
+
+    **2. Estimation setup (used only for `<estimator=...>` equations)**
+
+    | Attribute | Description |
+    |---|---|
+    | `showinput_df` | DataFrame used when tagged equations are estimated |
+    | `showestimator` | Default estimator for tagged equations: method name or callable factory |
+    | `showsmpl` | Model-wide default estimation sample. `None` unless passed to the constructor or the magic -- a per-equation `<smpl=start end>` or a `with_defaults(smpl=...)` factory does not show up here. The sample each equation really used is in `showestimation_records` |
+    | `showestimator_kwargs` | Shared kwargs passed to estimator constructors |
+    | `showestimator_classes` | Optional method-name to estimator-class mapping |
+    | `showestimator_namespace` | Optional namespace for resolving `<estimator=name>`; defaults to caller locals/globals |
+
+    **3. Expansion pipeline (in the order they are produced)**
+
+    | Attribute | Description |
+    |---|---|
+    | `showclean_frml_statements` | With frml and nice lists |
+    | `showpost_doable` | Expanded after doable |
+    | `showpost_do` | Frmls after do expansion |
+    | `showpost_sum` | Frmls after expanding sums |
+    | `showexpanded_frml` | frmls after expanding |
+
+    **4. Lists**
+
+    | Attribute | Description |
+    |---|---|
+    | `showmodellist` | The lists defined in string as a dictionary |
+    | `showlists` | Same as `showmodellist` |
+    | `showlist_specification` | All list specifications in string |
+
+    `modellist` is built between `post_do` and `post_sum` (it feeds the sum
+    expansion), `list_specification` is derived at the very end.
+
+    **5. Normalization and estimation output**
+
+    | Attribute | Description |
+    |---|---|
+    | `shownormal_input_expressions` | Expressions sent to modelnormalize, after optional estimation |
+    | `showestimation_records` | Information about equations estimated during construction |
+    | `shownormal_expressions` | List of normal expressions |
+    | `shownormal_output_frmlnames` | FRML names emitted; estimation flags are preserved |
+    | `shownormal_main` | Normalized frmls |
+    | `shownormal_fit` | Normalized frmls for fitted values |
+    | `shownormal_calc_add` | Normalized frmls to calculate add factors |
+    | `shownormal_frml` | Output normalized expressions (`normal_main` + `normal_fit` + `normal_calc_add`) |
+    | `show` | The finished `normal_frml`, printed |
+
+    **6. Rendering**
+
+    | Attribute | Description |
+    |---|---|
+    | `showmarkdown_model` | As markdown |
+    """
+
     # original_statements   : str       = field(default="",        metadata={"description": "Input expressions"})
     # normal_frml           : str       = field(default="",        metadata={"description": "Output normalized expressions"})
-    
+
     normal_main           : str       = field(init=False,        metadata={"description": "Normalized frmls"})
     normal_fit            : str       = field(init=False,        metadata={"description": "Normalized frmls for fitted values"})
     normal_calc_add       : str       = field(init=False,        metadata={"description": "Normalized frmls to calculate add factors"})
@@ -2084,7 +2237,9 @@ class Makemodel(BaseExplode):
                 ))
         
         self.normal_expressions = [n for p,n  in self.normal ]
-        
+
+        self._warn_on_repeated_endogenous()
+
         # udrullet = lagarray_unroll(udrullet,funks=funks )
         # udrullet = creatematrix(udrullet,listin=modellist)
         # udrullet = createarray(udrullet,listin=modellist)
@@ -2115,6 +2270,35 @@ class Makemodel(BaseExplode):
         self.list_specification = self.get_lists()
         return
 
+    def _warn_on_repeated_endogenous(self):
+        """Warn when a variable is defined by more than one kept equation.
+
+        Nothing is removed: every equation stays in the emitted FRML, and
+        ``model()`` resolves the collision by letting the last definition win
+        (``modelclass.py``, where each repeat overwrites the variable's entry in
+        ``allvar``). That is usually what a notebook author means when they
+        re-estimate an equation further down, but it is worth saying out loud,
+        because the earlier equations are then dead weight -- and because a
+        typo in a mnemonic looks exactly like a deliberate redefinition.
+        """
+        equations_by_endo = {}
+        for position, (parts, normal) in enumerate(self.normal, start=1):
+            endo = getattr(normal, 'endo_var', '')
+            if endo:
+                equations_by_endo.setdefault(endo, []).append(position)
+
+        for endo, positions in equations_by_endo.items():
+            if len(positions) < 2:
+                continue
+            listed = ', '.join(str(p) for p in positions)
+            print(
+                f"⚠️  {endo} is defined by {len(positions)} equations "
+                f"(kept equations {listed}). The last of them, equation "
+                f"{positions[-1]}, is the one used when the model is solved; "
+                f"the earlier ones go into the FRML but are never evaluated. "
+                f"Tag any you do not want with <DROP>."+'\n'
+            )
+
     def _expression_after_optional_estimation(self, parts, *, equation_index: Optional[int] = None,
                                               estimator_flag: Any = ...) -> str:
         """Return parts.expression, or an estimated/baked version when tagged.
@@ -2175,6 +2359,7 @@ class Makemodel(BaseExplode):
             estimator_name=estimator_name,
             input_df=self.input_df,
             smpl=smpl,
+            smpl_is_local=local_smpl is not None,
             caption=local_caption,
             estimator_kwargs=self.estimator_kwargs,
             estimator_classes=self.estimator_classes,
@@ -2263,6 +2448,20 @@ class Makemodel(BaseExplode):
         """Alias for :attr:`markdown_with_estimation`."""
         return self.markdown_with_estimation
 
+    @property
+    def markdown_with_estimation_no_list(self) -> str:
+        """Like :attr:`markdown_with_estimation`, with ``>list`` blocks removed.
+
+        Same inline estimation tables as :attr:`markdown_with_estimation`, but
+        ``>list``/``>tlist`` definition blocks are stripped from the rendered
+        Markdown. Used by the ``%%Makemymodel`` magic when ``render_list=0`` is
+        combined with the default ``render_est`` rendering path.
+        """
+        return _markdown_with_estimation_blocks(
+            _strip_markdown_list_blocks(self.original_statements),
+            self.estimation_records,
+        )
+
     @property
     def clean_frml(self) -> str:
         """Normalized equations with add-factors, exogenization, and fitted-value flags stripped."""
@@ -2630,6 +2829,14 @@ class Listmodels(BaseExplode):
         """Alias for :attr:`markdown_with_estimation`."""
         return self.markdown_with_estimation
 
+    @property
+    def markdown_with_estimation_no_list(self) -> str:
+        """Concatenate member Makemodel markdown-with-estimation-no-list strings."""
+        return "\n\n".join(
+            mex.markdown_with_estimation_no_list
+            for mex in self.makemodels
+        )
+
     # __str__(self):
         
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelflowib
-Version: 2.75
+Version: 2.77
 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.75 → modelflowib-2.77}/modeljupytermagic.py

@@ -27,6 +27,10 @@ from modelclass import model
 from modelmanipulation import explode
 from model_latex_class import a_latex_model
 from modelconstruct_estimation import Makemodel, display_model
+# Markdown subclass whose text/plain fallback is the markdown source itself,
+# so latex/pdf exports show the model text instead of
+# '<IPython.core.display.Markdown object>'. Shadows the IPython import above.
+from modelconstruct_estimation import Markdown
 from modelhelp import debug_var
 from modelreport import LatexRepo
 
@@ -589,7 +593,7 @@ try:
             if dict_name in user_ns:
                 segs = list(user_ns[dict_name].keys())
                 print(f"Model `{name}` built from segments: {', '.join(segs)}")
-            print(f"✅ Created Mexplode model: {name}")
+            print(f"✅ Created Makemodel: {name}")
             print(emodel)
 
         return emodel

{modelflowib-2.75 → modelflowib-2.77}/modelnormalize.py

@@ -129,8 +129,19 @@ def funk_find_arg(funk_match, streng):
             return streng[:start], match[1:index], match[index + 1:]
     assert 1==2,f'Parantese mismatch in {streng}'
 
+def funk_check_arg(funk,arg,udtryk,udtryk_up):
+    '''Guards against variables named like a function.
+
+    A lagged variable with a function name, fx DIFF(-1), matches DIFF( and would
+    silently be swallowed as a function call. If the argument is a pure signed
+    integer it must be such a lag, so raise an informative error instead.'''
+    if re.fullmatch(r'[+-]?\d+',arg.replace(' ','')):
+        raise Exception(f"A variable can not be named {funk}, as {funk}( is a function in the business language.\n"
+                        f"{funk}({arg}) looks like a lagged variable {funk}. Rename the variable.\n"
+                        f"Original expression: {udtryk}\n"
+                        f"Processed so far   : {udtryk_up}")
+
 
- 
 def preprocess(udtryk,funks=[]):
     '''
     test processing expanding dlog,diff,movavg,pct,logit functions 
@@ -146,16 +157,21 @@ def preprocess(udtryk,funks=[]):
 
     '''
     udtryk_up = udtryk.upper().replace(' ','')
+    udtryk_up = funk_replace('PCT','PCT_GROWTH',udtryk_up)
+
     while  dlog_match := funk_in('DLOG',udtryk_up):
          fordlog,dlogudtryk_up,efterdlog=funk_find_arg(dlog_match,udtryk_up)
-         udtryk_up=fordlog+'DIFF(LOG('+dlogudtryk_up+'))'+efterdlog 
-          
+         funk_check_arg('DLOG',dlogudtryk_up,udtryk,udtryk_up)
+         udtryk_up=fordlog+'DIFF(LOG('+dlogudtryk_up+'))'+efterdlog
+
     while  logit_match := funk_in('LOGIT',udtryk_up):
          forlogit,logitudtryk_up,efterlogit=funk_find_arg(logit_match,udtryk_up)
-         udtryk_up=forlogit+'(LOG('+logitudtryk_up+'/(1.0 -'+logitudtryk_up+')))'+efterlogit 
-         
+         funk_check_arg('LOGIT',logitudtryk_up,udtryk,udtryk_up)
+         udtryk_up=forlogit+'(LOG('+logitudtryk_up+'/(1.0 -'+logitudtryk_up+')))'+efterlogit
+
     while  movavg_match := funk_in('MOVAVG', udtryk_up):
          forkaede,kaedeudtryk,efterkaede=funk_find_arg(movavg_match,udtryk_up)
+         funk_check_arg('MOVAVG',kaedeudtryk,udtryk,udtryk_up)
          arg=kaedeudtryk.split(',',1)
          avg='(('
          term=arg[0]
@@ -168,19 +184,23 @@ def preprocess(udtryk,funks=[]):
      
     while  pct_match := funk_in('PCT_GROWTH',udtryk_up):
         forpc,pcudtryk,efterpc=funk_find_arg(pct_match,udtryk_up)
-        udtryk_up=f'{forpc} (100 * ( ({pcudtryk}) / ({lagone(pcudtryk,funks=funks)}) -1)) {efterpc}'           
+        funk_check_arg('PCT_GROWTH',pcudtryk,udtryk,udtryk_up)
+        udtryk_up=f'{forpc} (100 * ( ({pcudtryk}) / ({lagone(pcudtryk,funks=funks)}) -1)) {efterpc}'
 
     while  pct_match := funk_in('PCY',udtryk_up):
         forpc,pcudtryk,efterpc=funk_find_arg(pct_match,udtryk_up)
-        udtryk_up=f'{forpc} (100 * ( ({pcudtryk}) / ({lagone(pcudtryk,funks=funks,laglead=-4)}) -1)) {efterpc}'           
-         
+        funk_check_arg('PCY',pcudtryk,udtryk,udtryk_up)
+        udtryk_up=f'{forpc} (100 * ( ({pcudtryk}) / ({lagone(pcudtryk,funks=funks,laglead=-4)}) -1)) {efterpc}'
+
     while  diff_match := funk_in('DIFF' , udtryk_up):
         fordif,difudtryk_up,efterdif=funk_find_arg(diff_match,udtryk_up)
-        udtryk_up=fordif+'(('+difudtryk_up+')-('+lagone(difudtryk_up+'',funks=funks)+'))'+efterdif  
-         
+        funk_check_arg('DIFF',difudtryk_up,udtryk,udtryk_up)
+        udtryk_up=fordif+'(('+difudtryk_up+')-('+lagone(difudtryk_up+'',funks=funks)+'))'+efterdif
+
     while  diff_match := funk_in('D' , udtryk_up):
         # print(f'{udtryk_up} on D')
         fordif,difudtryk_up,efterdif=funk_find_arg(diff_match,udtryk_up)
+        funk_check_arg('D',difudtryk_up,udtryk,udtryk_up)
         difudtryk_up = difudtryk_up.replace(' ','').replace(',0,1','') if difudtryk_up.endswith(',0,1')  else difudtryk_up
         udtryk_up=fordif+'(('+difudtryk_up+')-('+lagone(difudtryk_up+'',funks=funks)+'))'+efterdif  
          
@@ -407,7 +427,7 @@ if __name__ == '__main__':
     normal('a+b = c',add_add_factor=1,make_fitted=1).fprint
     normal('PCT_growth(a) = n(-1)',add_add_factor=0).fprint
     normal('a = movavg(pct(b),2)',add_add_factor=0).fprint
-    normal('pct_growth(c) = pct_growth(d)',add_add_factor=0).fprint
+    normal('pct_growth(c) = pct_growth(dd)',add_add_factor=0).fprint
     normal('pct_growth(c) = z+pct(b) + pct(e)').fprint
     normal('pct_growth(c) = z+pct(b) + pct(e)').fprint
     normal('a = pct_growth(b)',add_add_factor=0).fprint