fred-loader 0.1.2__tar.gz → 0.1.4__tar.gz

{fred_loader-0.1.2/src/fred_loader.egg-info → fred_loader-0.1.4}/PKG-INFO

@@ -1,9 +1,21 @@
 Metadata-Version: 2.4
 Name: fred-loader
-Version: 0.1.2
+Version: 0.1.4
 Summary: A Python wrapper around the Federal Reserve FRED API that abstracts away series IDs, resampling rules, and macro scoring behind a clean, human-readable interface.
 Author: Ian Solberg
 License-Expression: MIT
+Project-URL: Homepage, https://github.com/iasolb/fred-loader
+Project-URL: Repository, https://github.com/iasolb/fred-loader
+Project-URL: Issues, https://github.com/iasolb/fred-loader/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{fred_loader-0.1.2 → fred_loader-0.1.4}/pyproject.toml

@@ -4,14 +4,25 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fred-loader"
-version = "0.1.2"
+version = "0.1.4"
 description = "A Python wrapper around the Federal Reserve FRED API that abstracts away series IDs, resampling rules, and macro scoring behind a clean, human-readable interface."
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [{ name = "Ian Solberg" }]
-classifiers = ["Typing :: Typed"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Typing :: Typed",
+]
 dependencies = [
     "fredapi",
     "pandas",
@@ -19,6 +30,11 @@ dependencies = [
     "python-dotenv",
 ]
 
+[project.urls]
+Homepage = "https://github.com/iasolb/fred-loader"
+Repository = "https://github.com/iasolb/fred-loader"
+Issues = "https://github.com/iasolb/fred-loader/issues"
+
 [project.optional-dependencies]
 dev = ["pytest"]
 

{fred_loader-0.1.2 → fred_loader-0.1.4}/src/fred_loader/load.py

@@ -38,7 +38,7 @@ Available categories::
 """
 
 import pandas as pd
-from .utils import Config, load_fred_master
+from .utils import Config, _say, load_fred_master
 from .macro_scores import score
 
 # Re-export every category so users only need `from fred_loader import ...`
@@ -139,5 +139,5 @@ def pull_fred(config: Config, apply_scores: bool = False) -> pd.DataFrame | None
     out_file = config.OUTPUT_PATH / config.FILENAME
     output.to_csv(out_file)
 
-    print(f"\nSaved → {out_file}")
+    _say(f"\nSaved -> {out_file}")
     return output

{fred_loader-0.1.2 → fred_loader-0.1.4}/src/fred_loader/macro_scores.py

@@ -772,7 +772,7 @@ def score(
     meaningful = [s for s in resolved if s.requires]
     if not meaningful:
         print(
-            "\n⚠  No scores can be computed from the columns present.\n"
+            "\n!  No scores can be computed from the columns present.\n"
             "   Scoring requires series from categories like INFLATION, LABOR,\n"
             "   RATES, or SEP.  Returning raw data unchanged."
         )

{fred_loader-0.1.2 → fred_loader-0.1.4}/src/fred_loader/utils.py

@@ -2,12 +2,60 @@ from fredapi import Fred
 import pandas as pd
 import os
 from dotenv import load_dotenv
+from pandas.tseries.frequencies import to_offset
 from pathlib import Path
 from typing import Optional
+import sys
 import time
 from .series import ALL_SERIES, CATEGORIES, SUBCATEGORIES
 
 
+def _say(line: str = "") -> None:
+    """Print one progress line, never raising on the stream's encoding.
+
+    A Windows script whose stdout is piped or redirected writes cp1252, which
+    cannot encode every character an API error, a custom series name or a file
+    path may carry. The line reports on work that already happened, so it
+    degrades to '?' instead of crashing the pull it describes.
+    """
+    encoding = getattr(sys.stdout, "encoding", None) or "utf-8"
+    print(line.encode(encoding, errors="replace").decode(encoding))
+
+
+# One row of the output stands for one of these, keyed by the offset's class
+# name so the lookup does not depend on how a pandas version spells the alias.
+_PERIOD_WORDS = {
+    "Week": "weeks",
+    "MonthEnd": "months",
+    "MonthBegin": "months",
+    "BusinessMonthEnd": "months",
+    "BusinessMonthBegin": "months",
+    "QuarterEnd": "quarters",
+    "QuarterBegin": "quarters",
+    "YearEnd": "years",
+    "YearBegin": "years",
+    "Day": "days",
+    "BusinessDay": "business days",
+    "Hour": "hours",
+}
+
+
+def _period_word(rule: str) -> str:
+    """Name the period one output row stands for under *rule*, else "rows".
+
+    The summary line said "weeks" whatever the rule, so a monthly pull
+    printed "56 weeks" (2026-10-17). A multiple such as "2W" says "rows",
+    since "weeks" would be wrong by the multiple.
+    """
+    try:
+        offset = to_offset(rule)
+    except ValueError:
+        return "rows"
+    if offset.n != 1:
+        return "rows"
+    return _PERIOD_WORDS.get(type(offset).__name__, "rows")
+
+
 # ╔═══════════════════════════════════════════════════════════════════════════╗
 # ║  SERIES RESOLVER                                                        ║
 # ╚═══════════════════════════════════════════════════════════════════════════╝
@@ -108,19 +156,30 @@ def available(category: str | None = None) -> None:
     print()
 
 
+def _words(text: str) -> list[str]:
+    """Lowercase words of *text*, with underscores read as spaces.
+
+    Friendly names are underscore_joined (``Headline_CPI``), so a reader
+    typing "headline cpi" has to land on them.
+    """
+    return text.lower().replace("_", " ").split()
+
+
 def search(keyword: str) -> list[str]:
     """Search the catalog by keyword, case-insensitive.
 
     Matches the FRED series id AND the friendly name, so both
-    `search("CPIAUCSL")` and `search("inflation")` work.
+    `search("CPIAUCSL")` and `search("inflation")` work. Spaces and
+    underscores are the same thing, and a multi-word query matches only
+    series carrying every word, so `search("headline cpi")` works too.
 
     Returns the list of matching series ids.
     """
-    kw = keyword.lower()
+    words = _words(keyword)
     hits = [
         series_id
         for series_id, (name, _freq) in ALL_SERIES.items()
-        if kw in series_id.lower() or kw in name.lower()
+        if all(w in " ".join(_words(f"{series_id} {name}")) for w in words)
     ]
 
     if not hits:
@@ -277,11 +336,11 @@ def load_fred_master(config: Config) -> pd.DataFrame:
 
                 frames[name] = s
                 agg = "mean" if native_freq in config.MEAN_FREQS else "last"
-                print(f"  ✓ {name:<40s} ({series_id:<18s} {native_freq} → {agg})")
+                _say(f"  ok   {name:<40s} ({series_id:<18s} {native_freq} -> {agg})")
                 time.sleep(0.5)  # be nice to the API
             except Exception as e:
                 failed.append((series_id, name, str(e)))
-                print(f"  ✗ {name:<40s} ({series_id}) — {e}")
+                _say(f"  FAIL {name:<40s} ({series_id}): {e}")
                 time.sleep(0.5)  # be nice to the API
 
         df = pd.DataFrame(frames)
@@ -289,12 +348,13 @@ def load_fred_master(config: Config) -> pd.DataFrame:
         df.index.name = "date"
 
         if failed:
-            print(f"\n⚠  {len(failed)} series failed:")
+            _say(f"\n!  {len(failed)} series failed:")
             for sid, nm, err in failed:
-                print(f"    {nm} ({sid}): {err}")
+                _say(f"    {nm} ({sid}): {err}")
 
-        print(
-            f"\nLoaded {len(frames)} series  |  {df.shape[0]} weeks  |  {df.columns.size} columns"
+        period = _period_word(config.RESAMPLE_RULE)
+        _say(
+            f"\nLoaded {len(frames)} series  |  {df.shape[0]} {period}  |  {df.columns.size} columns"
         )
         return df
 

{fred_loader-0.1.2 → fred_loader-0.1.4/src/fred_loader.egg-info}/PKG-INFO

@@ -1,9 +1,21 @@
 Metadata-Version: 2.4
 Name: fred-loader
-Version: 0.1.2
+Version: 0.1.4
 Summary: A Python wrapper around the Federal Reserve FRED API that abstracts away series IDs, resampling rules, and macro scoring behind a clean, human-readable interface.
 Author: Ian Solberg
 License-Expression: MIT
+Project-URL: Homepage, https://github.com/iasolb/fred-loader
+Project-URL: Repository, https://github.com/iasolb/fred-loader
+Project-URL: Issues, https://github.com/iasolb/fred-loader/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{fred_loader-0.1.2 → fred_loader-0.1.4}/src/fred_loader.egg-info/SOURCES.txt

@@ -14,5 +14,7 @@ src/fred_loader.egg-info/requires.txt
 src/fred_loader.egg-info/top_level.txt
 tests/test_discovery_and_resolver.py
 tests/test_macro_scores.py
+tests/test_output_encoding.py
+tests/test_package_metadata.py
 tests/test_pull_loop.py
 tests/test_typed.py

{fred_loader-0.1.2 → fred_loader-0.1.4}/tests/test_discovery_and_resolver.py

@@ -141,6 +141,25 @@ def test_search_returns_empty_and_says_so_when_nothing_matches(capsys):
     assert "No series matching" in capsys.readouterr().out
 
 
+def test_search_reads_spaces_as_underscores(capsys):
+    """Friendly names are underscore_joined, so the words a reader types must
+    still find them: "headline cpi" returned nothing until 2026-10-17."""
+    hits = search("headline cpi")
+    capsys.readouterr()
+    assert "CPIAUCSL" in hits
+
+
+def test_search_with_several_words_needs_every_word_in_any_order(capsys):
+    hits = search("cpi headline")
+    narrower_than = search("cpi")
+    capsys.readouterr()
+    assert "CPIAUCSL" in hits
+    for series_id in hits:
+        words = f"{series_id} {ALL_SERIES[series_id][0]}".lower().replace("_", " ")
+        assert "cpi" in words and "headline" in words
+    assert set(hits) < set(narrower_than)
+
+
 def test_info_reports_the_series_with_its_frequency_and_lineage(capsys):
     info("CPIAUCSL")
     out = capsys.readouterr().out

fred_loader-0.1.4/tests/test_output_encoding.py

@@ -0,0 +1,84 @@
+"""Printed output must never crash a stream that is not UTF-8.
+
+A Windows script whose stdout is piped or redirected writes cp1252. The pull
+loop printed check marks and arrows there and raised UnicodeEncodeError inside
+pull_all after the data had already arrived, so a successful pull read as a
+crash (2026-10-17). Each test runs its call under a strict cp1252 stdout,
+which is what that script sees. The swap happens inside the test body because
+pytest re-installs its own capture stream after fixture setup.
+
+Offline: the client is faked by patching ``fred_loader.utils.Fred``.
+"""
+from __future__ import annotations
+
+import io
+from contextlib import contextmanager, redirect_stdout
+from unittest.mock import MagicMock, patch
+
+import pandas as pd
+
+import fred_loader.utils as utils
+from fred_loader.load import pull_fred
+from fred_loader.utils import Config, available
+
+
+class _Cp1252Out:
+    def __init__(self):
+        self.raw = io.BytesIO()
+        self.stream = io.TextIOWrapper(
+            self.raw, encoding="cp1252", errors="strict", newline="\n"
+        )
+
+    def text(self) -> str:
+        self.stream.flush()
+        return self.raw.getvalue().decode("cp1252")
+
+
+@contextmanager
+def cp1252_stdout():
+    out = _Cp1252Out()
+    with redirect_stdout(out.stream):
+        yield out
+
+
+def test_say_degrades_a_character_the_stream_cannot_encode():
+    with cp1252_stdout() as out:
+        utils._say("before ✓ after")
+    assert out.text() == "before ? after\n"
+
+
+def test_a_pull_with_a_failure_prints_cleanly_to_cp1252(tmp_path):
+    def _get(series_id, observation_start=None):
+        if series_id == "BAD_ID":
+            raise RuntimeError("upstream said → no")
+        return pd.Series(
+            [1.0, 2.0, 3.0],
+            index=pd.DatetimeIndex(pd.date_range("2020-01-01", periods=3, freq="MS")),
+        )
+
+    mock_fred = MagicMock()
+    mock_fred.get_series.side_effect = _get
+    cfg = Config(
+        filename="enc.csv",
+        output_path=tmp_path,
+        start="2020-01-01",
+        series={"GOOD_ID": ("Good Series", "M"), "BAD_ID": ("Bad Series", "M")},
+    )
+
+    with patch("fred_loader.utils.Fred", return_value=mock_fred), \
+         patch("fred_loader.utils.time.sleep"), \
+         cp1252_stdout() as out:
+        df = pull_fred(cfg, apply_scores=False)
+
+    assert list(df.columns) == ["Good Series"]
+    text = out.text()
+    assert "ok   Good Series" in text
+    assert "FAIL Bad Series" in text
+    assert "upstream said ? no" in text
+    assert "Saved -> " in text
+
+
+def test_available_prints_cleanly_to_cp1252():
+    with cp1252_stdout() as out:
+        available()
+    assert "TOTAL" in out.text()

fred_loader-0.1.4/tests/test_package_metadata.py

@@ -0,0 +1,20 @@
+"""What a stranger sees on PyPI, pinned so it cannot quietly regress.
+
+Read as text, not with tomllib: the suite runs on Python 3.10, which has none.
+"""
+
+from pathlib import Path
+
+PYPROJECT = (Path(__file__).resolve().parent.parent / "pyproject.toml").read_text(
+    encoding="utf-8"
+)
+
+
+def test_the_pypi_page_links_back_to_the_repo():
+    assert "[project.urls]" in PYPROJECT
+    assert 'Repository = "https://github.com/iasolb/fred-loader"' in PYPROJECT
+
+
+def test_the_pypi_page_names_the_supported_pythons():
+    for version in ("3.10", "3.11", "3.12"):
+        assert f'"Programming Language :: Python :: {version}"' in PYPROJECT

{fred_loader-0.1.2 → fred_loader-0.1.4}/tests/test_pull_loop.py

@@ -276,6 +276,27 @@ def test_resample_rule_honoured(tmp_path):
     assert len(df_w) >= len(df_m)
 
 
+# ---------------------------------------------------------------------------
+# Test 8b: the summary line names the period the rule actually produced
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize(
+    "rule, word",
+    [("W-FRI", "weeks"), ("ME", "months"), ("QE", "quarters"), ("YE", "years"), ("2W", "rows")],
+)
+def test_summary_line_names_the_real_period(tmp_path, capsys, rule, word):
+    """It said "weeks" whatever the rule: a monthly pull printed "56 weeks"
+    (2026-10-17)."""
+    cfg = _config(tmp_path, resample_rule=rule)
+    mock_fred = _make_fred_mock(_fake_get_series())
+
+    with patch("fred_loader.utils.Fred", return_value=mock_fred):
+        df = load_fred_master(cfg)
+
+    summary = [ln for ln in capsys.readouterr().out.splitlines() if ln.startswith("Loaded ")]
+    assert summary == [f"Loaded 2 series  |  {len(df)} {word}  |  2 columns"]
+
+
 # ---------------------------------------------------------------------------
 # Test 9: pull_fred end-to-end — writes CSV, returns frame; apply_scores paths
 # ---------------------------------------------------------------------------