Fix rune_resolve_attr to resolve not only the local variables, but also the function parameters. First simple function example.

Author: plamen-neykov

pyproject.toml

@@ -12,8 +12,8 @@ dependencies = [
    "tzdata>=2025.2"
 ]
 optional-dependencies.dev = [
-    "pytest>=8.4.1",
-    "pytest-cov>=6.2.1",
+    "pytest>=9.0.2",
+    "pytest-cov>=7.0.0",
     "pytest-mock>=3.14.1",
     "types-python-dateutil>=2.9.0.20250809"
 ]

src/rune/runtime/utils.py

@@ -69,9 +69,9 @@ def rune_resolve_attr(obj: Any | None, attrib: str) -> Any | list[Any] | None:
     attrib = rune_mangle_name(attrib)
 
     if inspect.isframe(obj):
-        obj = getattr(obj, 'f_locals')
+        return obj.f_locals.get(attrib)
     elif isinstance(obj, dict):
-        return obj[attrib]
+        return obj.get(attrib)
 
     return getattr(obj, attrib, None)
 

test/__init__.py

@@ -0,0 +1,54 @@
+# pylint: disable=line-too-long, invalid-name, missing-function-docstring, missing-module-docstring, superfluous-parens
+# pylint: disable=wrong-import-position, unused-import, unused-wildcard-import, wildcard-import, wrong-import-order, missing-class-docstring
+from __future__ import annotations
+import sys
+import inspect
+from decimal import Decimal
+from pydantic import validate_call
+from rune.runtime.utils import rune_all_elements, rune_resolve_attr
+from rune.runtime.conditions import rune_execute_local_conditions, rune_local_condition
+from rune.runtime.func_proxy import replaceable, create_module_attr_guardian
+from .RoundingModeEnum import RoundingModeEnum
+
+__all__ = ['RoundToNearest']
+
+
+@replaceable
+@validate_call
+def RoundToNearest(value: Decimal, nearest: Decimal, roundingMode: RoundingModeEnum) -> Decimal:
+    """
+    Round a number to the supplied nearest, using the supplied rounding mode.
+    
+    Parameters 
+    ----------
+    value : number
+    The original (unrounded) number.
+    
+    nearest : number
+    The nearest number to round to.
+    
+    roundingMode : RoundingModeEnum
+    The method of rounding (up to nearest/down to nearest).
+    
+    Returns
+    -------
+    roundedValue : number
+    
+    """
+    _pre_registry = {}
+    self = inspect.currentframe()
+    
+    # conditions
+    
+    @rune_local_condition(_pre_registry)
+    def condition_0_PositiveNearest():  #FIXME: here we should NOT generate cond_name(self) as it is a closure function
+        return rune_all_elements(rune_resolve_attr(self, "nearest"), ">", 0)
+    # Execute all registered conditions
+    rune_execute_local_conditions(_pre_registry, 'Pre-condition')  #FIXME: the generator needs to add the rine_ prefix
+    
+    roundedValue = Decimal(round(value, int(nearest)))
+    
+    
+    return roundedValue
+
+sys.modules[__name__].__class__ = create_module_attr_guardian(sys.modules[__name__].__class__)

test/functions/specs/RoundToNearest.py

@@ -0,0 +1,18 @@
+# pylint: disable=missing-module-docstring, invalid-name, line-too-long
+from enum import Enum
+import rune.runtime.metadata
+
+__all__ = ['RoundingModeEnum']
+
+class RoundingModeEnum(rune.runtime.metadata.EnumWithMetaMixin, Enum):
+    """
+    The enumerated values to specify the rounding direction when rounding of a number to nearest.  Used by function cdm.base.math.RoundToNearest.
+    """
+    DOWN = "Down"
+    """
+    A number will be rounded down to the specified nearest number. For example, 529 rounded down to the nearest 10 is 520.
+    """
+    UP = "Up"
+    """
+    A number will be rounded up to the specified nearest number. For example, 521 rounded up to the nearest 10 is 530.
+    """

test/functions/specs/RoundingModeEnum.py

@@ -0,0 +1,18 @@
+from decimal import Decimal
+import pytest
+from pydantic import ValidationError
+from test.functions.specs.RoundToNearest import RoundToNearest
+from test.functions.specs.RoundingModeEnum import RoundingModeEnum
+
+
+def test_simple_types():
+    x = RoundToNearest(Decimal(4.59989), Decimal(1), RoundingModeEnum.UP)
+    assert x == Decimal('4.6')
+
+    with pytest.raises(ValidationError):
+        x = RoundToNearest(
+            'some text',  # type: ignore
+            Decimal(1),
+            RoundingModeEnum.UP)
+
+# EOF