[Feature] Add Svensson Nominal Yield Curve From Federal Reserve (#7338)

* add svensson yield curve, cleanup fomc documents endpoint, make provider a standalone extension, move apps from platform-api into extension, and update some models to add prefix/suffix in widget definitions

* black

* do what codeQL says

* black again

* use get_args instead of Literal.__args__

* linting

* test items

* grammar police

* test functions need to start with test_*

* test params

* add total factor productivity from sf fed

* openpyxl required for Excel file handling

* grammar police

* inflation expectations

* Update pr-description check action to properly handle quotes

---------

Co-authored-by: deeleeramone <>
Co-authored-by: Theodore Aptekarev <aptekarev@gmail.com>

Author: deeleeramone

.github/workflows/pr_description.yml

@@ -16,7 +16,7 @@ jobs:
       - name: Check PR description
         shell: bash
         run: |
-          body="${{ github.event.pull_request.body }}"
+          body="$(jq -r .pull_request.body "$GITHUB_EVENT_PATH")"
           if [ -z "$(echo "$body" | tr -d '[:space:]')" ]; then
             echo "::error::PR description is empty. Please provide a description of the change."
             exit 1

openbb_platform/core/openbb_core/provider/standard_models/federal_funds_rate.py

@@ -69,5 +69,6 @@ class FederalFundsRateData(Data):
         json_schema_extra={
             "x-unit_measurement": "currency",
             "x-frontend_multiply": 1e9,
+            "x-widget_config": {"prefix": "$", "suffix": "B"},
         },
     )

openbb_platform/core/openbb_core/provider/standard_models/money_measures.py

@@ -8,7 +8,7 @@
     DATA_DESCRIPTIONS,
     QUERY_DESCRIPTIONS,
 )
-from pydantic import Field
+from pydantic import AliasGenerator, ConfigDict, Field
 
 
 class MoneyMeasuresQueryParams(QueryParams):
@@ -30,22 +30,52 @@ class MoneyMeasuresQueryParams(QueryParams):
 class MoneyMeasuresData(Data):
     """Money Measures Data."""
 
+    model_config = ConfigDict(
+        json_schema_extra={
+            "x-widget_config": {
+                "$.refetchInterval": False,
+            }
+        },
+        alias_generator=AliasGenerator(
+            serialization_alias=lambda x: x,
+        ),
+    )
+
     month: dateType = Field(description=DATA_DESCRIPTIONS.get("date", ""))
-    M1: float = Field(description="Value of the M1 money supply in billions.")
-    M2: float = Field(description="Value of the M2 money supply in billions.")
+    m1: float = Field(
+        description="Value of the M1 money supply in billions.",
+        json_schema_extra={
+            "x-widget_config": {"prefix": "$", "suffix": "B", "headerName": "M1"}
+        },
+    )
+    m2: float = Field(
+        description="Value of the M2 money supply in billions.",
+        json_schema_extra={
+            "x-widget_config": {"prefix": "$", "suffix": "B", "headerName": "M2"}
+        },
+    )
     currency: float | None = Field(
-        description="Value of currency in circulation in billions.", default=None
+        description="Value of currency in circulation in billions.",
+        default=None,
+        json_schema_extra={"x-widget_config": {"prefix": "$", "suffix": "B"}},
     )
     demand_deposits: float | None = Field(
-        description="Value of demand deposits in billions.", default=None
+        description="Value of demand deposits in billions.",
+        default=None,
+        json_schema_extra={"x-widget_config": {"prefix": "$", "suffix": "B"}},
     )
     retail_money_market_funds: float | None = Field(
-        description="Value of retail money market funds in billions.", default=None
+        description="Value of retail money market funds in billions.",
+        default=None,
+        json_schema_extra={"x-widget_config": {"prefix": "$", "suffix": "B"}},
     )
     other_liquid_deposits: float | None = Field(
-        description="Value of other liquid deposits in billions.", default=None
+        description="Value of other liquid deposits in billions.",
+        default=None,
+        json_schema_extra={"x-widget_config": {"prefix": "$", "suffix": "B"}},
     )
     small_denomination_time_deposits: float | None = Field(
         description="Value of small denomination time deposits in billions.",
         default=None,
+        json_schema_extra={"x-widget_config": {"prefix": "$", "suffix": "B"}},
     )

openbb_platform/core/openbb_core/provider/standard_models/overnight_bank_funding_rate.py

@@ -59,5 +59,6 @@ class OvernightBankFundingRateData(Data):
         json_schema_extra={
             "x-unit_measurement": "currency",
             "x-frontend_multiply": 1e9,
+            "x-widget_config": {"prefix": "$", "suffix": "B"},
         },
     )

openbb_platform/core/openbb_core/provider/standard_models/sofr.py

@@ -59,5 +59,6 @@ class SOFRData(Data):
         json_schema_extra={
             "x-unit_measurement": "currency",
             "x-frontend_multiply": 1e9,
+            "x-widget_config": {"prefix": "$", "suffix": "B"},
         },
     )

openbb_platform/core/openbb_core/provider/utils/lru.py

@@ -0,0 +1,40 @@
+"""Utilities for LRU caching."""
+
+# pylint: disable=W0613
+
+import time
+from collections.abc import Callable
+from functools import lru_cache, update_wrapper
+from math import floor
+from typing import Any
+
+
+def ttl_cache(maxsize: int = 128, typed: bool = False, ttl: int = -1):
+    """Cache a function's return value each ttl seconds."""
+    if ttl <= 0:
+        ttl = 65536
+
+    hash_gen = _ttl_hash_gen(ttl)
+
+    def wrapper(func: Callable) -> Callable:
+        """Wrap the function for ttl_cache."""
+
+        @lru_cache(maxsize, typed)
+        def ttl_func(ttl_hash, *args, **kwargs):
+            return func(*args, **kwargs)
+
+        def wrapped(*args, **kwargs) -> Any:
+            """Wrap the function for ttl_cache."""
+            th = next(hash_gen)
+            return ttl_func(th, *args, **kwargs)
+
+        return update_wrapper(wrapped, func)
+
+    return wrapper
+
+
+def _ttl_hash_gen(seconds: int):
+    start_time = time.time()
+
+    while True:
+        yield floor((time.time() - start_time) / seconds)

openbb_platform/core/tests/provider/utils/test_lru.py

@@ -0,0 +1,244 @@
+"""Tests for the LRU cache utilities."""
+
+import time
+
+from openbb_core.provider.utils.lru import _ttl_hash_gen, ttl_cache
+
+
+class TestTtlHashGen:
+    """Tests for _ttl_hash_gen."""
+
+    def test_yields_same_value_within_ttl_window(self):
+        """Test that the generator yields the same value within a TTL window."""
+        gen = _ttl_hash_gen(seconds=10)
+        first = next(gen)
+        second = next(gen)
+        assert first == second
+
+    def test_yields_different_value_after_ttl_expires(self):
+        """Test that the generator yields a different value after TTL expires."""
+        gen = _ttl_hash_gen(seconds=1)
+        first = next(gen)
+        time.sleep(1.1)
+        second = next(gen)
+        assert second > first
+
+    def test_increments_by_one_per_ttl_period(self):
+        """Test that the hash increments by 1 for each TTL period elapsed."""
+        gen = _ttl_hash_gen(seconds=1)
+        first = next(gen)
+        time.sleep(2.1)
+        second = next(gen)
+        assert second >= first + 2
+
+
+class TestTtlCache:
+    """Tests for ttl_cache decorator."""
+
+    def test_caches_return_value(self):
+        """Test that the decorated function's return value is cached."""
+        call_count = 0
+
+        @ttl_cache(ttl=60)
+        def expensive_function():
+            nonlocal call_count
+            call_count += 1
+            return "result"
+
+        result1 = expensive_function()
+        result2 = expensive_function()
+
+        assert result1 == "result"
+        assert result2 == "result"
+        assert call_count == 1
+
+    def test_cache_expires_after_ttl(self):
+        """Test that the cache expires after TTL seconds."""
+        call_count = 0
+
+        @ttl_cache(ttl=1)
+        def expensive_function():
+            nonlocal call_count
+            call_count += 1
+            return f"result_{call_count}"
+
+        result1 = expensive_function()
+        assert call_count == 1
+
+        time.sleep(1.1)
+
+        result2 = expensive_function()
+        assert call_count == 2
+        assert result1 == "result_1"
+        assert result2 == "result_2"
+
+    def test_caches_with_arguments(self):
+        """Test that caching works correctly with function arguments."""
+        call_count = 0
+
+        @ttl_cache(ttl=60)
+        def func_with_args(x, y):
+            nonlocal call_count
+            call_count += 1
+            return x + y
+
+        result1 = func_with_args(1, 2)
+        result2 = func_with_args(1, 2)
+        result3 = func_with_args(3, 4)
+
+        assert result1 == 3
+        assert result2 == 3
+        assert result3 == 7
+        assert call_count == 2  # Called once for (1,2) and once for (3,4)
+
+    def test_caches_with_kwargs(self):
+        """Test that caching works correctly with keyword arguments."""
+        call_count = 0
+
+        @ttl_cache(ttl=60)
+        def func_with_kwargs(a, b=10):
+            nonlocal call_count
+            call_count += 1
+            return a * b
+
+        result1 = func_with_kwargs(5, b=2)
+        result2 = func_with_kwargs(5, b=2)
+        result3 = func_with_kwargs(5, b=3)
+
+        assert result1 == 10
+        assert result2 == 10
+        assert result3 == 15
+        assert call_count == 2
+
+    def test_default_ttl_is_large(self):
+        """Test that default TTL (when <= 0) is set to a large value."""
+        call_count = 0
+
+        @ttl_cache(ttl=0)
+        def func():
+            nonlocal call_count
+            call_count += 1
+            return "cached"
+
+        func()
+        func()
+        func()
+
+        assert call_count == 1
+
+    def test_negative_ttl_uses_default(self):
+        """Test that negative TTL uses the default large value."""
+        call_count = 0
+
+        @ttl_cache(ttl=-1)
+        def func():
+            nonlocal call_count
+            call_count += 1
+            return "cached"
+
+        func()
+        func()
+
+        assert call_count == 1
+
+    def test_maxsize_limits_cache(self):
+        """Test that maxsize parameter limits the cache size."""
+        call_count = 0
+
+        @ttl_cache(maxsize=2, ttl=60)
+        def func(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # Fill cache
+        func(1)  # call 1
+        func(2)  # call 2
+
+        # These should be cached
+        func(1)
+        func(2)
+        assert call_count == 2
+
+        # This evicts the oldest (1)
+        func(3)  # call 3
+        assert call_count == 3
+
+        # 1 was evicted, so this is a new call
+        func(1)  # call 4
+        assert call_count == 4
+
+    def test_typed_parameter(self):
+        """Test that typed=True distinguishes between types."""
+        call_count = 0
+
+        @ttl_cache(maxsize=128, typed=True, ttl=60)
+        def func(x):
+            nonlocal call_count
+            call_count += 1
+            return x
+
+        func(1)
+        func(1.0)  # Different type, should be cached separately
+
+        assert call_count == 2
+
+    def test_preserves_function_metadata(self):
+        """Test that the decorator preserves function name and docstring."""
+
+        @ttl_cache(ttl=60)
+        def my_function():
+            """My docstring."""
+            return "result"
+
+        assert my_function.__name__ == "my_function"
+        assert my_function.__doc__ == "My docstring."
+
+    def test_works_with_none_return_value(self):
+        """Test that None return values are cached correctly."""
+        call_count = 0
+
+        @ttl_cache(ttl=60)
+        def func_returning_none():
+            nonlocal call_count
+            call_count += 1
+
+        result1 = func_returning_none()
+        result2 = func_returning_none()
+
+        assert result1 is None
+        assert result2 is None
+        assert call_count == 1
+
+    def test_works_with_mutable_return_value(self):
+        """Test caching with mutable return values (returns same object)."""
+        call_count = 0
+
+        @ttl_cache(ttl=60)
+        def func_returning_list():
+            nonlocal call_count
+            call_count += 1
+            return [1, 2, 3]
+
+        result1 = func_returning_list()
+        result2 = func_returning_list()
+
+        assert result1 == [1, 2, 3]
+        assert result1 is result2  # Same cached object
+        assert call_count == 1
+
+    def test_concurrent_calls_within_ttl(self):
+        """Test that concurrent-like calls within TTL share cache."""
+        call_count = 0
+
+        @ttl_cache(ttl=60)
+        def func():
+            nonlocal call_count
+            call_count += 1
+            return "result"
+
+        # Simulate multiple rapid calls
+        results = [func() for _ in range(100)]
+
+        assert all(r == "result" for r in results)
+        assert call_count == 1