From 5d00ebdab23de0ffd80e767cf3b36579ce6f8ffa Mon Sep 17 00:00:00 2001
From: Spicer Bak <spicer.bak.frf@gmail.com>
Date: Thu, 16 Jul 2026 08:47:25 -0400
Subject: [PATCH 1/7] Cache server detection at module level with thread safety

Previously, get_thredds_server() ran socket.gethostbyname() on every call
to detect FRF vs external network. This adds module-level caching so the
IP address and server selection are computed once at first use.

Thread safety improvements:
- Use threading.RLock (reentrant lock) to prevent deadlock when
  get_thredds_server() calls _get_cached_ip() while holding the lock
- Double-checked locking pattern for safe concurrent initialization
- Catch OSError (Python 3 standard) instead of socket.error

Input validation:
- Validate ip_address is a string to prevent type confusion attacks
- Return safe defaults (empty string, False) for invalid inputs

Changes:
- Add _cache_lock (RLock), _cached_ip_address, _cached_server_result
- Add _get_cached_ip() helper for lazy thread-safe IP detection
- Modify get_thredds_server() to return cached result for default case
- Modify is_frf_network() to use cached IP with type validation
- Add clear_server_cache() for testing and network change scenarios
- Add 9 tests for caching behavior including thread safety

Addresses issue #50 task 2.1.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 murgtools/config.py  | 108 +++++++++++++++++++++++++++++-----
 tests/test_config.py | 135 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 230 insertions(+), 13 deletions(-)

diff --git a/murgtools/config.py b/murgtools/config.py
index cd79afd..032a797 100644
--- a/murgtools/config.py
+++ b/murgtools/config.py
@@ -6,6 +6,7 @@
 """
 
 import socket
+import threading
 
 # =============================================================================
 # THREDDS Server URLs
@@ -91,29 +92,97 @@
 # Helper Functions
 # =============================================================================
 
+# =============================================================================
+# Server Detection Cache (thread-safe)
+# =============================================================================
+# Cache is computed once at first use to avoid repeated socket operations.
+# Both FRF and CHL servers are trusted government endpoints - server selection
+# only affects performance (local vs remote), not security.
+
+# Use RLock (reentrant lock) because get_thredds_server calls _get_cached_ip
+# while holding the lock
+_cache_lock = threading.RLock()
+_cached_ip_address = None
+_cached_server_result = None
+
+
+def _get_cached_ip():
+    """Get the cached IP address, computing it once if needed (thread-safe).
+
+    Returns:
+        str: The machine's IP address, or empty string if detection failed.
+    """
+    global _cached_ip_address
+
+    # Fast path: check without lock first (safe because we only write once)
+    if _cached_ip_address is not None:
+        return _cached_ip_address
+
+    with _cache_lock:
+        # Double-check after acquiring lock
+        if _cached_ip_address is not None:
+            return _cached_ip_address
+
+        try:
+            _cached_ip_address = socket.gethostbyname(socket.gethostname())
+        except OSError:
+            # Covers socket.error, socket.gaierror, socket.herror in Python 3
+            _cached_ip_address = ''
+
+    return _cached_ip_address
+
 
 def get_thredds_server(server=None, ip_address=None):
-    """Select appropriate THREDDS server based on network location.
+    """Select appropriate THREDDS server based on network location (thread-safe).
+
+    Results are cached at module level for auto-detection (when server=None
+    and ip_address=None) to avoid repeated socket operations.
 
     Args:
         server (str, optional): Force server selection. 'FRF' for local,
             'CHL' for public. If None, auto-detect based on IP.
         ip_address (str, optional): IP address to check. If None,
-            uses current machine's IP.
+            uses cached machine IP.
 
     Returns:
         tuple: (server_url, server_prefix) where server_prefix is 'FRF' or 'frf'
             for use in constructing data paths.
     """
+    global _cached_server_result
+
+    # Fast path: return cached result for default auto-detection case
+    if server is None and ip_address is None:
+        # Check without lock first
+        if _cached_server_result is not None:
+            return _cached_server_result
+
+        with _cache_lock:
+            # Double-check after acquiring lock
+            if _cached_server_result is not None:
+                return _cached_server_result
+
+            # Compute and cache the result
+            detected_ip = _get_cached_ip()
+            on_frf_network = detected_ip.startswith(FRF_IP_PREFIXES)
+
+            if on_frf_network:
+                _cached_server_result = (THREDDS_FRF_LOCAL, 'FRF')
+            else:
+                _cached_server_result = (THREDDS_CHL_PUBLIC, 'frf')
+
+            return _cached_server_result
+
+    # Non-cached path: explicit server or ip_address provided
     if ip_address is None:
-        try:
-            ip_address = socket.gethostbyname(socket.gethostname())
-        except socket.error:
-            ip_address = ''
+        ip_address = _get_cached_ip()
+
+    # Validate ip_address is a string to prevent type confusion
+    if not isinstance(ip_address, str):
+        ip_address = ''
 
-    is_frf_network = ip_address.startswith(FRF_IP_PREFIXES)
+    on_frf_network = ip_address.startswith(FRF_IP_PREFIXES)
 
-    if server == 'FRF' or (server is None and is_frf_network):
+    if server == 'FRF' or (server is None and on_frf_network):
         return THREDDS_FRF_LOCAL, 'FRF'
     else:
         return THREDDS_CHL_PUBLIC, 'frf'
@@ -124,15 +193,28 @@ def is_frf_network(ip_address=None):
 
     Args:
         ip_address (str, optional): IP address to check. If None,
-            uses current machine's IP.
+            uses cached machine IP.
 
     Returns:
         bool: True if on FRF network, False otherwise.
     """
     if ip_address is None:
-        try:
-            ip_address = socket.gethostbyname(socket.gethostname())
-        except socket.error:
-            return False
+        ip_address = _get_cached_ip()
+
+    # Validate ip_address is a string to prevent type confusion
+    if not isinstance(ip_address, str):
+        return False
 
     return ip_address.startswith(FRF_IP_PREFIXES)
+
+
+def clear_server_cache():
+    """Clear the cached server detection results (thread-safe).
+
+    Useful for testing or if network configuration changes during runtime.
+    """
+    global _cached_ip_address, _cached_server_result
+
+    with _cache_lock:
+        _cached_ip_address = None
+        _cached_server_result = None
diff --git a/tests/test_config.py b/tests/test_config.py
index a6ec5a1..05292b3 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -98,11 +98,146 @@ def test_force_chl_server(self):
     def test_socket_error_defaults_to_chl(self):
         """Verify socket errors default to CHL server."""
         with patch('socket.gethostbyname', side_effect=OSError('Network error')):
+            config.clear_server_cache()  # Clear cache to force re-detection
             url, prefix = config.get_thredds_server()
             assert url == config.THREDDS_CHL_PUBLIC
             assert prefix == 'frf'
 
 
+class TestServerCaching:
+    """Tests for server detection caching functionality."""
+
+    def setup_method(self):
+        """Clear the cache before each test."""
+        config.clear_server_cache()
+
+    def teardown_method(self):
+        """Clear the cache after each test."""
+        config.clear_server_cache()
+
+    def test_cache_returns_same_result(self):
+        """Verify cached result is returned on subsequent calls."""
+        # First call should compute and cache
+        result1 = config.get_thredds_server()
+        # Second call should return cached result
+        result2 = config.get_thredds_server()
+
+        assert result1 == result2
+
+    def test_cache_avoids_repeated_socket_calls(self):
+        """Verify socket operations are only called once with caching."""
+        with patch('murgtools.config.socket.gethostbyname', return_value='192.168.1.1') as mock_socket:
+            config.clear_server_cache()
+
+            # Multiple calls should only trigger one socket operation
+            config.get_thredds_server()
+            config.get_thredds_server()
+            config.get_thredds_server()
+
+            # Socket should only be called once (for IP detection)
+            assert mock_socket.call_count == 1
+
+    def test_clear_cache_resets_detection(self):
+        """Verify clear_server_cache resets the cached state."""
+        with patch('murgtools.config.socket.gethostbyname', return_value='192.168.1.1') as mock_socket:
+            config.clear_server_cache()
+
+            # First call
+            config.get_thredds_server()
+            assert mock_socket.call_count == 1
+
+            # Clear cache
+            config.clear_server_cache()
+
+            # Second call should trigger socket again
+            config.get_thredds_server()
+            assert mock_socket.call_count == 2
+
+    def test_explicit_ip_bypasses_cache(self):
+        """Verify explicit ip_address parameter still works correctly."""
+        config.clear_server_cache()
+
+        # Cache with external IP
+        with patch('murgtools.config.socket.gethostbyname', return_value='192.168.1.1'):
+            url1, prefix1 = config.get_thredds_server()
+            assert prefix1 == 'frf'  # External network
+
+        # Explicit FRF IP should return FRF server regardless of cache
+        url2, prefix2 = config.get_thredds_server(ip_address='134.164.129.1')
+        assert prefix2 == 'FRF'
+
+    def test_explicit_server_bypasses_cache(self):
+        """Verify explicit server parameter still works correctly."""
+        config.clear_server_cache()
+
+        # Cache with external IP
+        with patch('murgtools.config.socket.gethostbyname', return_value='192.168.1.1'):
+            url1, prefix1 = config.get_thredds_server()
+            assert prefix1 == 'frf'  # External network
+
+        # Explicit FRF server should return FRF regardless of cache
+        url2, prefix2 = config.get_thredds_server(server='FRF')
+        assert prefix2 == 'FRF'
+
+    def test_is_frf_network_uses_cached_ip(self):
+        """Verify is_frf_network uses cached IP address."""
+        with patch('murgtools.config.socket.gethostbyname', return_value='134.164.129.1') as mock_socket:
+            config.clear_server_cache()
+
+            # Multiple calls should only trigger one socket operation
+            config.is_frf_network()
+            config.is_frf_network()
+            config.is_frf_network()
+
+            assert mock_socket.call_count == 1
+
+    def test_thread_safety_concurrent_access(self):
+        """Verify cache is thread-safe under concurrent access."""
+        import threading
+        import time
+
+        config.clear_server_cache()
+        results = []
+        errors = []
+
+        def worker():
+            try:
+                for _ in range(10):
+                    result = config.get_thredds_server()
+                    results.append(result)
+            except Exception as e:
+                errors.append(e)
+
+        # Run multiple threads concurrently
+        threads = [threading.Thread(target=worker) for _ in range(5)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        # No errors should occur
+        assert len(errors) == 0, f"Thread errors: {errors}"
+
+        # All results should be identical
+        assert len(set(results)) == 1, "Inconsistent results across threads"
+
+    def test_invalid_ip_address_type_handled(self):
+        """Verify non-string ip_address is handled safely."""
+        # Should not raise, should return CHL (external) server
+        url, prefix = config.get_thredds_server(ip_address=12345)
+        assert prefix == 'frf'
+
+        url, prefix = config.get_thredds_server(ip_address=None)
+        # None triggers cache lookup, which is valid
+        assert prefix in ('frf', 'FRF')
+
+    def test_is_frf_network_invalid_ip_returns_false(self):
+        """Verify is_frf_network returns False for invalid ip_address types."""
+        assert config.is_frf_network(ip_address=12345) is False
+        assert config.is_frf_network(ip_address=['134.164.1.1']) is False
+        assert config.is_frf_network(ip_address={'ip': '134.164.1.1'}) is False
+
+
 class TestIsFrfNetwork:
     """Tests for is_frf_network helper function."""
 

From abaf54372d7a6b6f5b943d1cd33c5b42409bb70d Mon Sep 17 00:00:00 2001
From: Spicer Bak <spicer.bak.frf@gmail.com>
Date: Thu, 16 Jul 2026 11:33:04 -0400
Subject: [PATCH 2/7] Add disk-based data caching system (OFF by default)

Implements a comprehensive data caching system for murgtools that stores
retrieved data to disk to avoid repeated network requests.

Features:
- Caching is OFF by default, must be explicitly enabled
- Enable via code: enable_cache() or DataCache(enabled=True)
- Enable via environment: MURGTOOLS_CACHE_ENABLED=1
- Default cache directory: /data/getdata (configurable)
- Default TTL: 180 days / 6 months (configurable)
- Force refresh: cache.get(..., force_refresh=True)
- Clear all or by age: clear_cache(older_than_days=30)
- Thread-safe with RLock

Configuration options:
- cache_dir: Custom cache directory path
- ttl_days: Time-to-live in days (0 = never expire)
- Environment variables for all settings

New files:
- murgtools/cache.py: DataCache class and helper functions
- tests/test_cache.py: 34 comprehensive tests

Addresses issue #50 (partial - data caching infrastructure).

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 murgtools/__init__.py |   7 +
 murgtools/cache.py    | 571 ++++++++++++++++++++++++++++++++++++++++++
 murgtools/config.py   |  17 ++
 tests/test_cache.py   | 498 ++++++++++++++++++++++++++++++++++++
 4 files changed, 1093 insertions(+)
 create mode 100644 murgtools/cache.py
 create mode 100644 tests/test_cache.py

diff --git a/murgtools/__init__.py b/murgtools/__init__.py
index 53b56d0..d437578 100644
--- a/murgtools/__init__.py
+++ b/murgtools/__init__.py
@@ -4,6 +4,7 @@
 from .getdata import forecastData, getSatelliteImagery, alt_PlotData
 from .getdata import getArgusImagery, threadGetArgusImagery
 from .plotting import conditions_plot, bin_data
+from .cache import DataCache, get_cache, enable_cache, disable_cache, clear_cache
 
 __all__ = [
     "getObs",
@@ -18,4 +19,10 @@
     "alt_PlotData",
     "conditions_plot",
     "bin_data",
+    # Cache functions
+    "DataCache",
+    "get_cache",
+    "enable_cache",
+    "disable_cache",
+    "clear_cache",
 ]
diff --git a/murgtools/cache.py b/murgtools/cache.py
new file mode 100644
index 0000000..141506f
--- /dev/null
+++ b/murgtools/cache.py
@@ -0,0 +1,571 @@
+"""Data caching module for murgtools.
+
+This module provides disk-based caching for retrieved data to avoid repeated
+network requests. Caching is OFF by default and must be explicitly enabled.
+
+Features:
+    - Disk-based persistence at configurable location (default: /data/getdata)
+    - Configurable TTL (default: 6 months / 180 days)
+    - Thread-safe operations
+    - Force refresh capability
+    - Automatic cache invalidation for stale data
+
+Usage:
+    from murgtools.cache import DataCache
+
+    # Create cache instance (caching disabled by default)
+    cache = DataCache()
+
+    # Enable caching
+    cache = DataCache(enabled=True)
+
+    # Custom configuration
+    cache = DataCache(
+        enabled=True,
+        cache_dir='/custom/path',
+        ttl_days=90,  # 3 months
+    )
+
+    # Force refresh even if cache is valid
+    data = cache.get(key, fetch_func, force_refresh=True)
+
+Environment Variables:
+    MURGTOOLS_CACHE_ENABLED: Set to '1' or 'true' to enable caching
+    MURGTOOLS_CACHE_DIR: Override default cache directory
+    MURGTOOLS_CACHE_TTL_DAYS: Override default TTL in days
+"""
+
+import hashlib
+import json
+import logging
+import os
+import pickle
+import threading
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional, Tuple, Union
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+
+class CacheError(Exception):
+    """Base exception for cache-related errors."""
+    pass
+
+
+class CacheMetadata:
+    """Metadata for a cached entry."""
+
+    def __init__(self, created_at: float, data_source: str, time_range: Optional[Tuple] = None,
+                 extra_info: Optional[Dict] = None):
+        """Initialize cache metadata.
+
+        Args:
+            created_at: Unix timestamp when cache was created.
+            data_source: Identifier for the data source (e.g., URL, gauge name).
+            time_range: Optional tuple of (start_epoch, end_epoch) for time-series data.
+            extra_info: Optional dictionary with additional metadata.
+        """
+        self.created_at = created_at
+        self.data_source = data_source
+        self.time_range = time_range
+        self.extra_info = extra_info or {}
+
+    def to_dict(self) -> Dict:
+        """Convert metadata to dictionary for serialization."""
+        return {
+            'created_at': self.created_at,
+            'data_source': self.data_source,
+            'time_range': self.time_range,
+            'extra_info': self.extra_info,
+            'version': '1.0',
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'CacheMetadata':
+        """Create metadata from dictionary."""
+        return cls(
+            created_at=data['created_at'],
+            data_source=data['data_source'],
+            time_range=data.get('time_range'),
+            extra_info=data.get('extra_info', {}),
+        )
+
+    def is_expired(self, ttl_days: int) -> bool:
+        """Check if the cache entry has expired.
+
+        Args:
+            ttl_days: Time-to-live in days.
+
+        Returns:
+            True if expired, False otherwise.
+        """
+        if ttl_days <= 0:
+            return False  # TTL of 0 means never expire
+
+        expiry_time = self.created_at + (ttl_days * 24 * 60 * 60)
+        return time.time() > expiry_time
+
+    def age_days(self) -> float:
+        """Get the age of this cache entry in days."""
+        return (time.time() - self.created_at) / (24 * 60 * 60)
+
+
+class DataCache:
+    """Thread-safe disk-based data cache.
+
+    Caching is OFF by default. Enable it explicitly via the `enabled` parameter
+    or by setting the MURGTOOLS_CACHE_ENABLED environment variable.
+    """
+
+    def __init__(self, enabled: Optional[bool] = None, cache_dir: Optional[str] = None,
+                 ttl_days: Optional[int] = None):
+        """Initialize the data cache.
+
+        Args:
+            enabled: Whether caching is enabled. If None, checks environment
+                variable MURGTOOLS_CACHE_ENABLED, otherwise defaults to False.
+            cache_dir: Directory to store cache files. If None, checks environment
+                variable MURGTOOLS_CACHE_DIR, otherwise uses config.DEFAULT_CACHE_DIR.
+            ttl_days: Time-to-live in days. If None, checks environment variable
+                MURGTOOLS_CACHE_TTL_DAYS, otherwise uses config.DEFAULT_CACHE_TTL_DAYS.
+                Set to 0 for no expiration.
+        """
+        self._lock = threading.RLock()
+
+        # Determine if caching is enabled
+        if enabled is not None:
+            self._enabled = enabled
+        else:
+            env_enabled = os.environ.get(config.ENV_CACHE_ENABLED, '').lower()
+            self._enabled = env_enabled in ('1', 'true', 'yes', 'on')
+
+        # Determine cache directory
+        if cache_dir is not None:
+            self._cache_dir = Path(cache_dir)
+        else:
+            env_dir = os.environ.get(config.ENV_CACHE_DIR)
+            self._cache_dir = Path(env_dir) if env_dir else Path(config.DEFAULT_CACHE_DIR)
+
+        # Determine TTL
+        if ttl_days is not None:
+            self._ttl_days = ttl_days
+        else:
+            env_ttl = os.environ.get(config.ENV_CACHE_TTL_DAYS)
+            if env_ttl:
+                try:
+                    self._ttl_days = int(env_ttl)
+                except ValueError:
+                    logger.warning(f"Invalid TTL value '{env_ttl}', using default")
+                    self._ttl_days = config.DEFAULT_CACHE_TTL_DAYS
+            else:
+                self._ttl_days = config.DEFAULT_CACHE_TTL_DAYS
+
+        # Create cache directory if enabled and directory doesn't exist
+        if self._enabled:
+            self._ensure_cache_dir()
+
+    @property
+    def enabled(self) -> bool:
+        """Whether caching is enabled."""
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, value: bool):
+        """Enable or disable caching."""
+        with self._lock:
+            self._enabled = value
+            if value:
+                self._ensure_cache_dir()
+
+    @property
+    def cache_dir(self) -> Path:
+        """The cache directory path."""
+        return self._cache_dir
+
+    @cache_dir.setter
+    def cache_dir(self, value: Union[str, Path]):
+        """Set the cache directory."""
+        with self._lock:
+            self._cache_dir = Path(value)
+            if self._enabled:
+                self._ensure_cache_dir()
+
+    @property
+    def ttl_days(self) -> int:
+        """Time-to-live in days."""
+        return self._ttl_days
+
+    @ttl_days.setter
+    def ttl_days(self, value: int):
+        """Set the TTL in days."""
+        if value < 0:
+            raise ValueError("TTL must be non-negative")
+        self._ttl_days = value
+
+    def _ensure_cache_dir(self):
+        """Create cache directory if it doesn't exist."""
+        try:
+            self._cache_dir.mkdir(parents=True, exist_ok=True)
+        except PermissionError as e:
+            logger.warning(f"Cannot create cache directory {self._cache_dir}: {e}")
+            logger.warning("Caching will be disabled")
+            self._enabled = False
+        except OSError as e:
+            logger.warning(f"Error creating cache directory {self._cache_dir}: {e}")
+            self._enabled = False
+
+    def _generate_cache_key(self, data_source: str, time_range: Optional[Tuple] = None,
+                            extra_params: Optional[Dict] = None) -> str:
+        """Generate a unique cache key based on request parameters.
+
+        Args:
+            data_source: Identifier for the data source.
+            time_range: Optional tuple of (start_epoch, end_epoch).
+            extra_params: Optional additional parameters that affect the data.
+
+        Returns:
+            A hex string suitable for use as a filename.
+        """
+        key_parts = [data_source]
+
+        if time_range:
+            key_parts.append(f"t{time_range[0]}-{time_range[1]}")
+
+        if extra_params:
+            # Sort keys for deterministic ordering
+            sorted_params = sorted(extra_params.items())
+            key_parts.append(json.dumps(sorted_params, sort_keys=True))
+
+        key_string = '|'.join(str(p) for p in key_parts)
+        return hashlib.sha256(key_string.encode()).hexdigest()[:32]
+
+    def _get_cache_paths(self, cache_key: str) -> Tuple[Path, Path]:
+        """Get paths for data and metadata files.
+
+        Args:
+            cache_key: The cache key.
+
+        Returns:
+            Tuple of (data_path, metadata_path).
+        """
+        data_path = self._cache_dir / f"{cache_key}.pkl"
+        meta_path = self._cache_dir / f"{cache_key}.meta.json"
+        return data_path, meta_path
+
+    def get(self, data_source: str, fetch_func: Callable[[], Any],
+            time_range: Optional[Tuple] = None, extra_params: Optional[Dict] = None,
+            force_refresh: bool = False) -> Any:
+        """Get data from cache or fetch it.
+
+        Args:
+            data_source: Identifier for the data source (e.g., URL, gauge name).
+            fetch_func: Callable that fetches the data if not cached.
+            time_range: Optional tuple of (start_epoch, end_epoch) for time-series data.
+            extra_params: Optional additional parameters that affect the data.
+            force_refresh: If True, bypass cache and fetch fresh data.
+
+        Returns:
+            The requested data (from cache or freshly fetched).
+        """
+        # If caching is disabled, just fetch
+        if not self._enabled:
+            return fetch_func()
+
+        cache_key = self._generate_cache_key(data_source, time_range, extra_params)
+
+        with self._lock:
+            # Check cache unless force_refresh is requested
+            if not force_refresh:
+                cached_data = self._read_cache(cache_key)
+                if cached_data is not None:
+                    return cached_data
+
+            # Fetch fresh data
+            data = fetch_func()
+
+            # Store in cache
+            if data is not None:
+                self._write_cache(cache_key, data, data_source, time_range, extra_params)
+
+            return data
+
+    def _read_cache(self, cache_key: str) -> Optional[Any]:
+        """Read data from cache if valid.
+
+        Args:
+            cache_key: The cache key.
+
+        Returns:
+            Cached data if valid, None otherwise.
+        """
+        data_path, meta_path = self._get_cache_paths(cache_key)
+
+        # Check if cache files exist
+        if not data_path.exists() or not meta_path.exists():
+            return None
+
+        try:
+            # Read and validate metadata
+            with open(meta_path, 'r') as f:
+                meta_dict = json.load(f)
+            metadata = CacheMetadata.from_dict(meta_dict)
+
+            # Check if expired
+            if metadata.is_expired(self._ttl_days):
+                logger.debug(f"Cache expired for {cache_key} (age: {metadata.age_days():.1f} days)")
+                self._remove_cache(cache_key)
+                return None
+
+            # Read data
+            with open(data_path, 'rb') as f:
+                data = pickle.load(f)
+
+            logger.debug(f"Cache hit for {cache_key} (age: {metadata.age_days():.1f} days)")
+            return data
+
+        except (json.JSONDecodeError, pickle.UnpicklingError, KeyError, OSError) as e:
+            logger.warning(f"Error reading cache {cache_key}: {e}")
+            self._remove_cache(cache_key)
+            return None
+
+    def _write_cache(self, cache_key: str, data: Any, data_source: str,
+                     time_range: Optional[Tuple], extra_params: Optional[Dict]):
+        """Write data to cache.
+
+        Args:
+            cache_key: The cache key.
+            data: The data to cache.
+            data_source: Identifier for the data source.
+            time_range: Optional time range tuple.
+            extra_params: Optional extra parameters.
+        """
+        data_path, meta_path = self._get_cache_paths(cache_key)
+
+        try:
+            # Create metadata
+            metadata = CacheMetadata(
+                created_at=time.time(),
+                data_source=data_source,
+                time_range=time_range,
+                extra_info=extra_params,
+            )
+
+            # Write metadata first (smaller, validates we can write)
+            with open(meta_path, 'w') as f:
+                json.dump(metadata.to_dict(), f, indent=2)
+
+            # Write data
+            with open(data_path, 'wb') as f:
+                pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
+
+            logger.debug(f"Cached data for {cache_key}")
+
+        except (OSError, pickle.PicklingError) as e:
+            logger.warning(f"Error writing cache {cache_key}: {e}")
+            # Clean up partial writes
+            self._remove_cache(cache_key)
+
+    def _remove_cache(self, cache_key: str):
+        """Remove cache files for a key.
+
+        Args:
+            cache_key: The cache key.
+        """
+        data_path, meta_path = self._get_cache_paths(cache_key)
+
+        for path in (data_path, meta_path):
+            try:
+                if path.exists():
+                    path.unlink()
+            except OSError as e:
+                logger.warning(f"Error removing cache file {path}: {e}")
+
+    def clear(self, older_than_days: Optional[int] = None):
+        """Clear cache entries.
+
+        Args:
+            older_than_days: If specified, only clear entries older than this.
+                If None, clear all entries.
+        """
+        if not self._cache_dir.exists():
+            return
+
+        with self._lock:
+            cleared = 0
+            for meta_path in self._cache_dir.glob("*.meta.json"):
+                try:
+                    with open(meta_path, 'r') as f:
+                        meta_dict = json.load(f)
+                    metadata = CacheMetadata.from_dict(meta_dict)
+
+                    if older_than_days is None or metadata.age_days() > older_than_days:
+                        cache_key = meta_path.stem.replace('.meta', '')
+                        self._remove_cache(cache_key)
+                        cleared += 1
+
+                except (json.JSONDecodeError, KeyError, OSError) as e:
+                    logger.warning(f"Error reading metadata {meta_path}: {e}")
+                    # Remove corrupted entry
+                    cache_key = meta_path.stem.replace('.meta', '')
+                    self._remove_cache(cache_key)
+                    cleared += 1
+
+            logger.info(f"Cleared {cleared} cache entries")
+
+    def get_stats(self) -> Dict:
+        """Get cache statistics.
+
+        Returns:
+            Dictionary with cache statistics.
+        """
+        if not self._cache_dir.exists():
+            return {
+                'enabled': self._enabled,
+                'cache_dir': str(self._cache_dir),
+                'ttl_days': self._ttl_days,
+                'entry_count': 0,
+                'total_size_mb': 0,
+            }
+
+        entry_count = 0
+        total_size = 0
+        oldest_entry = None
+        newest_entry = None
+
+        for data_path in self._cache_dir.glob("*.pkl"):
+            entry_count += 1
+            total_size += data_path.stat().st_size
+
+            meta_path = data_path.with_suffix('.meta.json')
+            if meta_path.exists():
+                try:
+                    with open(meta_path, 'r') as f:
+                        meta_dict = json.load(f)
+                    created = meta_dict.get('created_at', 0)
+                    if oldest_entry is None or created < oldest_entry:
+                        oldest_entry = created
+                    if newest_entry is None or created > newest_entry:
+                        newest_entry = created
+                except (json.JSONDecodeError, OSError):
+                    pass
+
+        return {
+            'enabled': self._enabled,
+            'cache_dir': str(self._cache_dir),
+            'ttl_days': self._ttl_days,
+            'entry_count': entry_count,
+            'total_size_mb': round(total_size / (1024 * 1024), 2),
+            'oldest_entry': datetime.fromtimestamp(oldest_entry).isoformat() if oldest_entry else None,
+            'newest_entry': datetime.fromtimestamp(newest_entry).isoformat() if newest_entry else None,
+        }
+
+    def is_cached(self, data_source: str, time_range: Optional[Tuple] = None,
+                  extra_params: Optional[Dict] = None) -> bool:
+        """Check if data is cached and valid.
+
+        Args:
+            data_source: Identifier for the data source.
+            time_range: Optional time range tuple.
+            extra_params: Optional extra parameters.
+
+        Returns:
+            True if valid cache exists, False otherwise.
+        """
+        if not self._enabled:
+            return False
+
+        cache_key = self._generate_cache_key(data_source, time_range, extra_params)
+        data_path, meta_path = self._get_cache_paths(cache_key)
+
+        if not data_path.exists() or not meta_path.exists():
+            return False
+
+        try:
+            with open(meta_path, 'r') as f:
+                meta_dict = json.load(f)
+            metadata = CacheMetadata.from_dict(meta_dict)
+            return not metadata.is_expired(self._ttl_days)
+        except (json.JSONDecodeError, KeyError, OSError):
+            return False
+
+    def invalidate(self, data_source: str, time_range: Optional[Tuple] = None,
+                   extra_params: Optional[Dict] = None):
+        """Invalidate (remove) a specific cache entry.
+
+        Args:
+            data_source: Identifier for the data source.
+            time_range: Optional time range tuple.
+            extra_params: Optional extra parameters.
+        """
+        cache_key = self._generate_cache_key(data_source, time_range, extra_params)
+        with self._lock:
+            self._remove_cache(cache_key)
+
+
+# Global cache instance (disabled by default)
+_global_cache: Optional[DataCache] = None
+_global_cache_lock = threading.Lock()
+
+
+def get_cache(enabled: Optional[bool] = None, cache_dir: Optional[str] = None,
+              ttl_days: Optional[int] = None) -> DataCache:
+    """Get or create the global cache instance.
+
+    Args:
+        enabled: Whether to enable caching. If None on first call, defaults to False.
+        cache_dir: Cache directory. If None, uses default or environment variable.
+        ttl_days: TTL in days. If None, uses default or environment variable.
+
+    Returns:
+        The global DataCache instance.
+    """
+    global _global_cache
+
+    with _global_cache_lock:
+        if _global_cache is None:
+            _global_cache = DataCache(enabled=enabled, cache_dir=cache_dir, ttl_days=ttl_days)
+        else:
+            # Update settings if provided
+            if enabled is not None:
+                _global_cache.enabled = enabled
+            if cache_dir is not None:
+                _global_cache.cache_dir = cache_dir
+            if ttl_days is not None:
+                _global_cache.ttl_days = ttl_days
+
+        return _global_cache
+
+
+def enable_cache(cache_dir: Optional[str] = None, ttl_days: Optional[int] = None) -> DataCache:
+    """Enable the global cache with optional configuration.
+
+    Convenience function to enable caching with one call.
+
+    Args:
+        cache_dir: Cache directory. If None, uses default.
+        ttl_days: TTL in days. If None, uses default (180 days).
+
+    Returns:
+        The enabled DataCache instance.
+    """
+    return get_cache(enabled=True, cache_dir=cache_dir, ttl_days=ttl_days)
+
+
+def disable_cache():
+    """Disable the global cache."""
+    cache = get_cache()
+    cache.enabled = False
+
+
+def clear_cache(older_than_days: Optional[int] = None):
+    """Clear the global cache.
+
+    Args:
+        older_than_days: If specified, only clear entries older than this.
+    """
+    cache = get_cache()
+    cache.clear(older_than_days=older_than_days)
diff --git a/murgtools/config.py b/murgtools/config.py
index 032a797..a842298 100644
--- a/murgtools/config.py
+++ b/murgtools/config.py
@@ -88,6 +88,23 @@
 
 ARGUS_IMAGE_TYPES = ('timex', 'var', 'snap', 'bright', 'dark')
 
+# =============================================================================
+# Data Cache Configuration
+# =============================================================================
+# Caching is OFF by default. Users must explicitly enable it.
+# Cache stores retrieved data to disk to avoid repeated network requests.
+
+# Default cache directory (user can override)
+DEFAULT_CACHE_DIR = '/data/getdata'
+
+# Default cache TTL in days (6 months = ~180 days)
+DEFAULT_CACHE_TTL_DAYS = 180
+
+# Environment variable names for configuration overrides
+ENV_CACHE_ENABLED = 'MURGTOOLS_CACHE_ENABLED'
+ENV_CACHE_DIR = 'MURGTOOLS_CACHE_DIR'
+ENV_CACHE_TTL_DAYS = 'MURGTOOLS_CACHE_TTL_DAYS'
+
 # =============================================================================
 # Helper Functions
 # =============================================================================
diff --git a/tests/test_cache.py b/tests/test_cache.py
new file mode 100644
index 0000000..2d599a5
--- /dev/null
+++ b/tests/test_cache.py
@@ -0,0 +1,498 @@
+"""Tests for murgtools.cache module."""
+
+import json
+import os
+import pickle
+import tempfile
+import threading
+import time
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from murgtools import cache
+from murgtools.cache import DataCache, CacheMetadata, get_cache, enable_cache, disable_cache, clear_cache
+
+
+class TestCacheMetadata:
+    """Tests for CacheMetadata class."""
+
+    def test_to_dict_and_from_dict(self):
+        """Test serialization round-trip."""
+        meta = CacheMetadata(
+            created_at=1000000.0,
+            data_source='test_source',
+            time_range=(100, 200),
+            extra_info={'param': 'value'},
+        )
+
+        meta_dict = meta.to_dict()
+        restored = CacheMetadata.from_dict(meta_dict)
+
+        assert restored.created_at == meta.created_at
+        assert restored.data_source == meta.data_source
+        assert restored.time_range == meta.time_range
+        assert restored.extra_info == meta.extra_info
+
+    def test_is_expired_within_ttl(self):
+        """Test that recent entries are not expired."""
+        meta = CacheMetadata(created_at=time.time(), data_source='test')
+        assert meta.is_expired(ttl_days=180) is False
+
+    def test_is_expired_after_ttl(self):
+        """Test that old entries are expired."""
+        # Created 200 days ago
+        created = time.time() - (200 * 24 * 60 * 60)
+        meta = CacheMetadata(created_at=created, data_source='test')
+        assert meta.is_expired(ttl_days=180) is True
+
+    def test_is_expired_zero_ttl_never_expires(self):
+        """Test that TTL of 0 means never expire."""
+        # Created 1000 days ago
+        created = time.time() - (1000 * 24 * 60 * 60)
+        meta = CacheMetadata(created_at=created, data_source='test')
+        assert meta.is_expired(ttl_days=0) is False
+
+    def test_age_days(self):
+        """Test age calculation."""
+        # Created 10 days ago
+        created = time.time() - (10 * 24 * 60 * 60)
+        meta = CacheMetadata(created_at=created, data_source='test')
+        assert 9.9 < meta.age_days() < 10.1
+
+
+class TestDataCache:
+    """Tests for DataCache class."""
+
+    def setup_method(self):
+        """Create a temporary cache directory for each test."""
+        self.temp_dir = tempfile.mkdtemp()
+        # Reset global cache
+        cache._global_cache = None
+
+    def teardown_method(self):
+        """Clean up temporary directory."""
+        import shutil
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+        # Reset global cache
+        cache._global_cache = None
+
+    def test_cache_disabled_by_default(self):
+        """Verify caching is disabled by default."""
+        c = DataCache(cache_dir=self.temp_dir)
+        assert c.enabled is False
+
+    def test_cache_can_be_enabled(self):
+        """Verify caching can be enabled."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+        assert c.enabled is True
+
+    def test_cache_disabled_returns_fresh_data(self):
+        """Verify disabled cache always calls fetch function."""
+        c = DataCache(enabled=False, cache_dir=self.temp_dir)
+        call_count = 0
+
+        def fetch():
+            nonlocal call_count
+            call_count += 1
+            return {'data': call_count}
+
+        result1 = c.get('source', fetch)
+        result2 = c.get('source', fetch)
+
+        assert call_count == 2
+        assert result1['data'] == 1
+        assert result2['data'] == 2
+
+    def test_cache_enabled_returns_cached_data(self):
+        """Verify enabled cache returns cached data."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+        call_count = 0
+
+        def fetch():
+            nonlocal call_count
+            call_count += 1
+            return {'data': call_count}
+
+        result1 = c.get('source', fetch)
+        result2 = c.get('source', fetch)
+
+        assert call_count == 1
+        assert result1['data'] == 1
+        assert result2['data'] == 1
+
+    def test_force_refresh_bypasses_cache(self):
+        """Verify force_refresh fetches fresh data."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+        call_count = 0
+
+        def fetch():
+            nonlocal call_count
+            call_count += 1
+            return {'data': call_count}
+
+        result1 = c.get('source', fetch)
+        result2 = c.get('source', fetch, force_refresh=True)
+
+        assert call_count == 2
+        assert result1['data'] == 1
+        assert result2['data'] == 2
+
+    def test_different_sources_cached_separately(self):
+        """Verify different data sources have separate cache entries."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+
+        result1 = c.get('source1', lambda: 'data1')
+        result2 = c.get('source2', lambda: 'data2')
+
+        assert result1 == 'data1'
+        assert result2 == 'data2'
+
+    def test_different_time_ranges_cached_separately(self):
+        """Verify different time ranges have separate cache entries."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+
+        result1 = c.get('source', lambda: 'data1', time_range=(100, 200))
+        result2 = c.get('source', lambda: 'data2', time_range=(200, 300))
+
+        assert result1 == 'data1'
+        assert result2 == 'data2'
+
+    def test_expired_cache_returns_fresh_data(self):
+        """Verify expired cache entries are refreshed."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir, ttl_days=1)
+
+        # First fetch
+        result1 = c.get('source', lambda: 'old_data')
+
+        # Manually make the cache old by modifying metadata
+        cache_key = c._generate_cache_key('source')
+        _, meta_path = c._get_cache_paths(cache_key)
+        with open(meta_path, 'r') as f:
+            meta_dict = json.load(f)
+        # Set created_at to 10 days ago
+        meta_dict['created_at'] = time.time() - (10 * 24 * 60 * 60)
+        with open(meta_path, 'w') as f:
+            json.dump(meta_dict, f)
+
+        # Second fetch should get fresh data
+        result2 = c.get('source', lambda: 'new_data')
+
+        assert result1 == 'old_data'
+        assert result2 == 'new_data'
+
+    def test_is_cached(self):
+        """Test is_cached method."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+
+        assert c.is_cached('source') is False
+
+        c.get('source', lambda: 'data')
+
+        assert c.is_cached('source') is True
+
+    def test_invalidate(self):
+        """Test cache invalidation."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+
+        c.get('source', lambda: 'data1')
+        assert c.is_cached('source') is True
+
+        c.invalidate('source')
+        assert c.is_cached('source') is False
+
+        result = c.get('source', lambda: 'data2')
+        assert result == 'data2'
+
+    def test_clear_all(self):
+        """Test clearing all cache entries."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+
+        c.get('source1', lambda: 'data1')
+        c.get('source2', lambda: 'data2')
+
+        assert c.is_cached('source1') is True
+        assert c.is_cached('source2') is True
+
+        c.clear()
+
+        assert c.is_cached('source1') is False
+        assert c.is_cached('source2') is False
+
+    def test_clear_older_than(self):
+        """Test clearing entries older than a threshold."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+
+        # Create two entries
+        c.get('source1', lambda: 'data1')
+        c.get('source2', lambda: 'data2')
+
+        # Make source1 old
+        cache_key = c._generate_cache_key('source1')
+        _, meta_path = c._get_cache_paths(cache_key)
+        with open(meta_path, 'r') as f:
+            meta_dict = json.load(f)
+        meta_dict['created_at'] = time.time() - (100 * 24 * 60 * 60)  # 100 days ago
+        with open(meta_path, 'w') as f:
+            json.dump(meta_dict, f)
+
+        # Clear entries older than 50 days
+        c.clear(older_than_days=50)
+
+        assert c.is_cached('source1') is False  # Old, should be cleared
+        assert c.is_cached('source2') is True   # New, should remain
+
+    def test_get_stats(self):
+        """Test cache statistics."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+
+        stats = c.get_stats()
+        assert stats['enabled'] is True
+        assert stats['entry_count'] == 0
+
+        c.get('source1', lambda: 'data1')
+        c.get('source2', lambda: 'data2')
+
+        stats = c.get_stats()
+        assert stats['entry_count'] == 2
+        assert stats['total_size_mb'] >= 0  # Small files may round to 0
+
+    def test_ttl_setting(self):
+        """Test TTL getter and setter."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir, ttl_days=90)
+        assert c.ttl_days == 90
+
+        c.ttl_days = 30
+        assert c.ttl_days == 30
+
+    def test_ttl_negative_raises_error(self):
+        """Test that negative TTL raises ValueError."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+        with pytest.raises(ValueError):
+            c.ttl_days = -1
+
+    def test_cache_dir_setting(self):
+        """Test cache_dir getter and setter."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+        assert c.cache_dir == Path(self.temp_dir)
+
+        new_dir = tempfile.mkdtemp()
+        try:
+            c.cache_dir = new_dir
+            assert c.cache_dir == Path(new_dir)
+        finally:
+            import shutil
+            shutil.rmtree(new_dir, ignore_errors=True)
+
+    def test_thread_safety(self):
+        """Test thread-safe concurrent access."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+        results = []
+        errors = []
+        fetch_count = 0
+        fetch_lock = threading.Lock()
+
+        def fetch():
+            nonlocal fetch_count
+            with fetch_lock:
+                fetch_count += 1
+            time.sleep(0.01)  # Simulate network delay
+            return 'data'
+
+        def worker(source):
+            try:
+                for _ in range(5):
+                    result = c.get(source, fetch)
+                    results.append(result)
+            except Exception as e:
+                errors.append(e)
+
+        threads = [threading.Thread(target=worker, args=(f'source{i % 3}',)) for i in range(10)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        assert len(errors) == 0, f"Thread errors: {errors}"
+        assert all(r == 'data' for r in results)
+        # With 3 unique sources and proper caching, should have at most 3 fetches
+        # (may have more due to race conditions before cache is populated)
+        assert fetch_count <= 10
+
+
+class TestEnvironmentVariables:
+    """Tests for environment variable configuration."""
+
+    def setup_method(self):
+        """Save original environment."""
+        self.orig_env = {
+            k: os.environ.get(k) for k in [
+                'MURGTOOLS_CACHE_ENABLED',
+                'MURGTOOLS_CACHE_DIR',
+                'MURGTOOLS_CACHE_TTL_DAYS',
+            ]
+        }
+        # Clear environment
+        for k in self.orig_env:
+            if k in os.environ:
+                del os.environ[k]
+        # Reset global cache
+        cache._global_cache = None
+        self.temp_dir = tempfile.mkdtemp()
+
+    def teardown_method(self):
+        """Restore original environment."""
+        for k, v in self.orig_env.items():
+            if v is None:
+                if k in os.environ:
+                    del os.environ[k]
+            else:
+                os.environ[k] = v
+        # Reset global cache
+        cache._global_cache = None
+        import shutil
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+
+    def test_env_cache_enabled(self):
+        """Test MURGTOOLS_CACHE_ENABLED environment variable."""
+        os.environ['MURGTOOLS_CACHE_ENABLED'] = '1'
+        os.environ['MURGTOOLS_CACHE_DIR'] = self.temp_dir
+
+        c = DataCache()
+        assert c.enabled is True
+
+    def test_env_cache_enabled_true_string(self):
+        """Test MURGTOOLS_CACHE_ENABLED with 'true' string."""
+        os.environ['MURGTOOLS_CACHE_ENABLED'] = 'true'
+        os.environ['MURGTOOLS_CACHE_DIR'] = self.temp_dir
+
+        c = DataCache()
+        assert c.enabled is True
+
+    def test_env_cache_dir(self):
+        """Test MURGTOOLS_CACHE_DIR environment variable."""
+        custom_dir = tempfile.mkdtemp()
+        try:
+            os.environ['MURGTOOLS_CACHE_DIR'] = custom_dir
+            c = DataCache()
+            assert c.cache_dir == Path(custom_dir)
+        finally:
+            import shutil
+            shutil.rmtree(custom_dir, ignore_errors=True)
+
+    def test_env_cache_ttl(self):
+        """Test MURGTOOLS_CACHE_TTL_DAYS environment variable."""
+        os.environ['MURGTOOLS_CACHE_TTL_DAYS'] = '90'
+        os.environ['MURGTOOLS_CACHE_DIR'] = self.temp_dir
+
+        c = DataCache()
+        assert c.ttl_days == 90
+
+    def test_env_cache_ttl_invalid(self):
+        """Test invalid TTL value falls back to default."""
+        os.environ['MURGTOOLS_CACHE_TTL_DAYS'] = 'invalid'
+        os.environ['MURGTOOLS_CACHE_DIR'] = self.temp_dir
+
+        c = DataCache()
+        assert c.ttl_days == 180  # default
+
+
+class TestGlobalCacheFunctions:
+    """Tests for global cache functions."""
+
+    def setup_method(self):
+        """Reset global cache."""
+        cache._global_cache = None
+        self.temp_dir = tempfile.mkdtemp()
+
+    def teardown_method(self):
+        """Reset global cache and clean up."""
+        cache._global_cache = None
+        import shutil
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+
+    def test_get_cache_returns_same_instance(self):
+        """Test get_cache returns singleton."""
+        c1 = get_cache(cache_dir=self.temp_dir)
+        c2 = get_cache()
+        assert c1 is c2
+
+    def test_enable_cache(self):
+        """Test enable_cache convenience function."""
+        c = enable_cache(cache_dir=self.temp_dir)
+        assert c.enabled is True
+
+    def test_disable_cache(self):
+        """Test disable_cache convenience function."""
+        enable_cache(cache_dir=self.temp_dir)
+        disable_cache()
+        c = get_cache()
+        assert c.enabled is False
+
+    def test_clear_cache(self):
+        """Test clear_cache convenience function."""
+        c = enable_cache(cache_dir=self.temp_dir)
+        c.get('source', lambda: 'data')
+        assert c.is_cached('source') is True
+
+        clear_cache()
+        assert c.is_cached('source') is False
+
+
+class TestCacheWithComplexData:
+    """Tests for caching complex data types."""
+
+    def setup_method(self):
+        """Create temporary cache directory."""
+        self.temp_dir = tempfile.mkdtemp()
+        cache._global_cache = None
+
+    def teardown_method(self):
+        """Clean up."""
+        import shutil
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+        cache._global_cache = None
+
+    def test_cache_numpy_arrays(self):
+        """Test caching numpy arrays."""
+        import numpy as np
+
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+
+        data = {'array': np.array([1.0, 2.0, 3.0]), 'value': 42}
+        c.get('source', lambda: data)
+
+        # Clear memory and reload from cache
+        result = c.get('source', lambda: None)
+
+        assert np.array_equal(result['array'], data['array'])
+        assert result['value'] == 42
+
+    def test_cache_nested_dict(self):
+        """Test caching nested dictionaries."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+
+        data = {
+            'level1': {
+                'level2': {
+                    'values': [1, 2, 3],
+                    'name': 'test',
+                }
+            }
+        }
+        c.get('source', lambda: data)
+        result = c.get('source', lambda: None)
+
+        assert result == data
+
+    def test_cache_with_extra_params(self):
+        """Test caching with extra parameters."""
+        c = DataCache(enabled=True, cache_dir=self.temp_dir)
+
+        # Different extra_params should create different cache entries
+        result1 = c.get('source', lambda: 'data1', extra_params={'gaugenumber': 'gauge1'})
+        result2 = c.get('source', lambda: 'data2', extra_params={'gaugenumber': 'gauge2'})
+
+        assert result1 == 'data1'
+        assert result2 == 'data2'

From 68a48764c26f49c5be037f6bb1d999f76fd0d37f Mon Sep 17 00:00:00 2001
From: Spicer Bak <spicer.bak.frf@gmail.com>
Date: Thu, 16 Jul 2026 11:38:42 -0400
Subject: [PATCH 3/7] Integrate data caching with getObs class

Adds caching support to getObs for caching retrieved oceanographic data
to disk. Caching is OFF by default and must be explicitly enabled.

getObs class changes:
- Add use_cache, cache_dir, cache_ttl_days parameters to __init__
- Add force_refresh parameter to control cache bypass
- Add _get_with_cache() helper method for cache integration
- Refactor getWaveData() to use caching via _getWaveData_impl()

Cache module improvements:
- Add NumpyJSONEncoder for handling numpy types in metadata
- Fix JSON serialization of numpy int64/float64 values

Usage example:
    obs = getObs(d1, d2, use_cache=True, cache_dir='/data/getdata')
    data = obs.getWaveData(gaugenumber='waverider-26m')
    # Second call returns cached data:
    data = obs.getWaveData(gaugenumber='waverider-26m')
    # Force refresh:
    data = obs.getWaveData(gaugenumber='waverider-26m', force_refresh=True)

Tests:
- Add 5 integration tests for getObs caching

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 murgtools/cache.py              |  17 ++++-
 murgtools/getdata/getDataFRF.py |  86 ++++++++++++++++++++++++-
 tests/test_cache.py             | 109 ++++++++++++++++++++++++++++++++
 3 files changed, 208 insertions(+), 4 deletions(-)

diff --git a/murgtools/cache.py b/murgtools/cache.py
index 141506f..4bca675 100644
--- a/murgtools/cache.py
+++ b/murgtools/cache.py
@@ -46,8 +46,23 @@
 from pathlib import Path
 from typing import Any, Callable, Dict, Optional, Tuple, Union
 
+import numpy as np
+
 from . import config
 
+
+class NumpyJSONEncoder(json.JSONEncoder):
+    """JSON encoder that handles numpy types."""
+
+    def default(self, obj):
+        if isinstance(obj, np.integer):
+            return int(obj)
+        if isinstance(obj, np.floating):
+            return float(obj)
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return super().default(obj)
+
 logger = logging.getLogger(__name__)
 
 
@@ -356,7 +371,7 @@ def _write_cache(self, cache_key: str, data: Any, data_source: str,
 
             # Write metadata first (smaller, validates we can write)
             with open(meta_path, 'w') as f:
-                json.dump(metadata.to_dict(), f, indent=2)
+                json.dump(metadata.to_dict(), f, indent=2, cls=NumpyJSONEncoder)
 
             # Write data
             with open(data_path, 'wb') as f:
diff --git a/murgtools/getdata/getDataFRF.py b/murgtools/getdata/getDataFRF.py
index b24b004..0b494ca 100755
--- a/murgtools/getdata/getDataFRF.py
+++ b/murgtools/getdata/getDataFRF.py
@@ -23,6 +23,7 @@
 
 from murgtools.utils import geoprocess as gp, sblib as sb
 from murgtools import config
+from murgtools.cache import DataCache, get_cache
 from murgtools.exceptions import InvalidGaugeError
 
 def gettime(allEpoch, epochStart, epochEnd, indexRef=0):
@@ -216,8 +217,27 @@ def removeDuplicatesFromDictionary(inputDict):
 
 class getObs:
     """Class focused on retrieving observational data."""
-    def __init__(self, d1, d2, **kwargs):
-        """Data are returned in self.dataindex are inclusive at start, exclusive at end."""
+    def __init__(self, d1, d2, use_cache=False, cache_dir=None, cache_ttl_days=None, **kwargs):
+        """Initialize observation data retriever.
+
+        Data are returned in self.dataindex are inclusive at start, exclusive at end.
+
+        Args:
+            d1 (datetime): Start date for data retrieval.
+            d2 (datetime): End date for data retrieval.
+            use_cache (bool): Enable disk caching of retrieved data. Default False.
+                When enabled, data is cached to disk and reused on subsequent calls
+                with the same parameters. Cache expires after cache_ttl_days.
+            cache_dir (str, optional): Directory for cache files.
+                Default: /data/getdata (or MURGTOOLS_CACHE_DIR env var).
+            cache_ttl_days (int, optional): Cache time-to-live in days.
+                Default: 180 days / 6 months (or MURGTOOLS_CACHE_TTL_DAYS env var).
+
+        Keyword Args:
+            server (str): Force server selection ('FRF' or 'CHL').
+            force_refresh (bool): If True, bypass cache and fetch fresh data.
+                Only applies when use_cache=True.
+        """
         # this is active wave gauge list for looping through as needed
         self.waveGaugeList = ['waverider-26m', 'waverider-17m', 'waverider-17m-1d', 'waverider-20m-1d', 'awac-11m',
                               'awac-jpier-11m', '8m-array', 'awac-6m', 'awac-4.5m', 'adop-3.5m',
@@ -243,6 +263,14 @@ def __init__(self, d1, d2, **kwargs):
         self.chlDataLoc = config.THREDDS_CHL_ALT
         self.server = kwargs.get('server', None)
         self._comp_time()
+
+        # Cache configuration
+        self._use_cache = use_cache
+        self._force_refresh = kwargs.get('force_refresh', False)
+        if use_cache:
+            self._cache = DataCache(enabled=True, cache_dir=cache_dir, ttl_days=cache_ttl_days)
+        else:
+            self._cache = None
         # assert type(self.d2) == DT.datetime, 'd1 need to be in python "Datetime" data types'
         # assert type(self.d1) == DT.datetime, 'd2 need to be in python "Datetime" data types'
 
@@ -270,7 +298,40 @@ def _roundtime(self, dt=None, roundto=60):
         rounding = (seconds + roundto / 2) // roundto * roundto
         return dt + DT.timedelta(0, rounding - seconds, -dt.microsecond)
 
-    def getWaveData(self, gaugenumber=0, roundto=30, removeBadDataFlag=4, **kwargs):
+    def _get_with_cache(self, data_type, fetch_func, extra_params=None, force_refresh=False):
+        """Retrieve data with optional caching.
+
+        Args:
+            data_type (str): Type of data being retrieved (e.g., 'wave', 'wind', 'bathy').
+            fetch_func (callable): Function that fetches the data from the server.
+            extra_params (dict, optional): Additional parameters that affect the data
+                (e.g., gauge number, variable names). Used in cache key generation.
+            force_refresh (bool): If True, bypass cache and fetch fresh data.
+
+        Returns:
+            The requested data dictionary.
+        """
+        if not self._use_cache or self._cache is None:
+            return fetch_func()
+
+        # Build cache key components
+        data_source = f"getObs.{data_type}"
+        time_range = (self.epochd1, self.epochd2)
+
+        # Include server in extra_params for cache key
+        cache_params = {'server': self.server}
+        if extra_params:
+            cache_params.update(extra_params)
+
+        return self._cache.get(
+            data_source=data_source,
+            fetch_func=fetch_func,
+            time_range=time_range,
+            extra_params=cache_params,
+            force_refresh=force_refresh or self._force_refresh,
+        )
+
+    def getWaveData(self, gaugenumber=0, roundto=30, removeBadDataFlag=4, force_refresh=False, **kwargs):
         """This function pulls down the data from the thredds server and puts the data into a dictionary.
 
         TODO: Set optional date input from function arguments to change self.start self.end
@@ -283,6 +344,8 @@ def getWaveData(self, gaugenumber=0, roundto=30, removeBadDataFlag=4, **kwargs):
           removeBadDataFlag (int): this will remove data with a directional flag of 3/4 signaling questionable or
              failed directional spectra (default = 4, remove failed (directional) spectral data time periods)
              valid values: [3, 4, False]  False will not remove any data
+          force_refresh (bool): If True and caching is enabled, bypass cache and fetch fresh data.
+             Default False.
 
         Keyword Args:
             "returnAB" (bool): if this is True function will return a's and b's for time period (default=False)
@@ -317,6 +380,23 @@ def getWaveData(self, gaugenumber=0, roundto=30, removeBadDataFlag=4, **kwargs):
         """
         returnAB = kwargs.get('returnAB', False)
         spec = kwargs.get('spec', False)
+
+        # Use caching if enabled
+        cache_params = {
+            'gaugenumber': gaugenumber,
+            'roundto': roundto,
+            'removeBadDataFlag': removeBadDataFlag,
+            'returnAB': returnAB,
+            'spec': spec,
+        }
+
+        def fetch_data():
+            return self._getWaveData_impl(gaugenumber, roundto, removeBadDataFlag, returnAB, spec)
+
+        return self._get_with_cache('wave', fetch_data, cache_params, force_refresh)
+
+    def _getWaveData_impl(self, gaugenumber, roundto, removeBadDataFlag, returnAB, spec):
+        """Internal implementation of getWaveData (without caching)."""
         # Making gauges flexible
         self._waveGaugeURLlookup(gaugenumber)
         # parsing out data of interest in time
diff --git a/tests/test_cache.py b/tests/test_cache.py
index 2d599a5..066495f 100644
--- a/tests/test_cache.py
+++ b/tests/test_cache.py
@@ -496,3 +496,112 @@ def test_cache_with_extra_params(self):
 
         assert result1 == 'data1'
         assert result2 == 'data2'
+
+
+class TestGetObsCacheIntegration:
+    """Tests for getObs class caching integration."""
+
+    def setup_method(self):
+        """Create temporary cache directory."""
+        self.temp_dir = tempfile.mkdtemp()
+        cache._global_cache = None
+
+    def teardown_method(self):
+        """Clean up."""
+        import shutil
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+        cache._global_cache = None
+
+    def test_getobs_cache_disabled_by_default(self):
+        """Test that getObs has caching disabled by default."""
+        import datetime as DT
+        from murgtools.getdata.getDataFRF import getObs
+
+        d1 = DT.datetime(2024, 1, 1)
+        d2 = DT.datetime(2024, 1, 2)
+
+        obs = getObs(d1, d2)
+        assert obs._use_cache is False
+        assert obs._cache is None
+
+    def test_getobs_cache_can_be_enabled(self):
+        """Test that getObs caching can be enabled."""
+        import datetime as DT
+        from murgtools.getdata.getDataFRF import getObs
+
+        d1 = DT.datetime(2024, 1, 1)
+        d2 = DT.datetime(2024, 1, 2)
+
+        obs = getObs(d1, d2, use_cache=True, cache_dir=self.temp_dir)
+        assert obs._use_cache is True
+        assert obs._cache is not None
+        assert obs._cache.enabled is True
+
+    def test_getobs_cache_custom_ttl(self):
+        """Test that getObs accepts custom TTL."""
+        import datetime as DT
+        from murgtools.getdata.getDataFRF import getObs
+
+        d1 = DT.datetime(2024, 1, 1)
+        d2 = DT.datetime(2024, 1, 2)
+
+        obs = getObs(d1, d2, use_cache=True, cache_dir=self.temp_dir, cache_ttl_days=90)
+        assert obs._cache.ttl_days == 90
+
+    def test_getobs_get_with_cache_helper(self):
+        """Test the _get_with_cache helper method."""
+        import datetime as DT
+        from murgtools.getdata.getDataFRF import getObs
+
+        d1 = DT.datetime(2024, 1, 1)
+        d2 = DT.datetime(2024, 1, 2)
+
+        # Test with caching disabled
+        obs_no_cache = getObs(d1, d2)
+        call_count = 0
+
+        def fetch():
+            nonlocal call_count
+            call_count += 1
+            return {'data': call_count}
+
+        # Without cache, should call fetch each time
+        result1 = obs_no_cache._get_with_cache('test', fetch)
+        result2 = obs_no_cache._get_with_cache('test', fetch)
+        assert call_count == 2
+
+        # Test with caching enabled
+        call_count = 0
+        obs_with_cache = getObs(d1, d2, use_cache=True, cache_dir=self.temp_dir)
+
+        result3 = obs_with_cache._get_with_cache('test', fetch)
+        result4 = obs_with_cache._get_with_cache('test', fetch)
+        assert call_count == 1  # Only called once due to caching
+        assert result3 == result4
+
+    def test_getobs_force_refresh(self):
+        """Test force_refresh parameter."""
+        import datetime as DT
+        from murgtools.getdata.getDataFRF import getObs
+
+        d1 = DT.datetime(2024, 1, 1)
+        d2 = DT.datetime(2024, 1, 2)
+
+        obs = getObs(d1, d2, use_cache=True, cache_dir=self.temp_dir)
+        call_count = 0
+
+        def fetch():
+            nonlocal call_count
+            call_count += 1
+            return {'data': call_count}
+
+        # First call caches
+        result1 = obs._get_with_cache('test', fetch)
+        # Second call returns cached
+        result2 = obs._get_with_cache('test', fetch)
+        assert call_count == 1
+
+        # Force refresh should call again
+        result3 = obs._get_with_cache('test', fetch, force_refresh=True)
+        assert call_count == 2
+        assert result3['data'] == 2

From 0445515ff59ad27da373f87ee9bbe274a8688aaa Mon Sep 17 00:00:00 2001
From: Spicer Bak <spicer.bak.frf@gmail.com>
Date: Thu, 16 Jul 2026 11:52:02 -0400
Subject: [PATCH 4/7] Add caching support to all major getObs data retrieval
 methods

Extends caching integration to all commonly used data retrieval methods
in the getObs class. Each method now accepts force_refresh parameter.

Methods with caching support:
- getWaveData (already done in previous commit)
- getCurrents - ocean currents data
- getWind - wind measurements
- getWL - water level (NOAA tide)
- getGaugeWL - gauge water level
- getCTD - CTD measurements
- getALT - altimeter data
- getLidarRunup - lidar runup measurements
- getBathyTransectFromNC - bathymetry transects

Each method follows the same pattern:
1. Add force_refresh parameter
2. Create _impl method with actual logic
3. Wrap with _get_with_cache helper

Usage:
    obs = getObs(d1, d2, use_cache=True)

    # All these calls are now cacheable:
    waves = obs.getWaveData(gaugenumber='waverider-26m')
    currents = obs.getCurrents(gaugenumber='awac-11m')
    wind = obs.getWind()
    wl = obs.getWL()
    bathy = obs.getBathyTransectFromNC()

    # Force refresh any cached data:
    waves = obs.getWaveData(gaugenumber='waverider-26m', force_refresh=True)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 murgtools/getdata/getDataFRF.py | 102 +++++++++++++++++++++++++++++---
 1 file changed, 93 insertions(+), 9 deletions(-)

diff --git a/murgtools/getdata/getDataFRF.py b/murgtools/getdata/getDataFRF.py
index 0b494ca..c7335e9 100755
--- a/murgtools/getdata/getDataFRF.py
+++ b/murgtools/getdata/getDataFRF.py
@@ -563,7 +563,7 @@ def getWaveSpec(self, gaugenumber=0, roundto=30, removeBadDataFlag=4, **kwargs):
         # else:
         return self.getWaveData(gaugenumber, roundto, removeBadDataFlag, returnAB=returnAB, spec=True)
 
-    def getCurrents(self, gaugenumber=5, roundto=1):
+    def getCurrents(self, gaugenumber=5, roundto=1, force_refresh=False):
         """This function pulls down the currents data from the Thredds Server.
 
         Args:
@@ -587,6 +587,8 @@ def getCurrents(self, gaugenumber=5, roundto=1):
           increments
             data is rounded to the nearst [roundto] (default 1 min)
 
+          force_refresh (bool): If True and caching is enabled, bypass cache and fetch fresh data.
+
         Returns:
             dict, None if error is encoutered
                 'name' (str): gauge name
@@ -617,6 +619,15 @@ def getCurrents(self, gaugenumber=5, roundto=1):
                 'meanP' (array): mean pressure
 
         """
+        cache_params = {'gaugenumber': gaugenumber, 'roundto': roundto}
+
+        def fetch_data():
+            return self._getCurrents_impl(gaugenumber, roundto)
+
+        return self._get_with_cache('currents', fetch_data, cache_params, force_refresh)
+
+    def _getCurrents_impl(self, gaugenumber, roundto):
+        """Internal implementation of getCurrents (without caching)."""
         valid_gauges = [2, 3, 4, 5, 6, 'awac-11m', 'awac-8m', 'awac-6m', 'awac-4.5m', 'awac-5m',
                         'adop-3.5m', 'awac-jpier-11m', 'awac-jpier', 'jpier-11m',
                         'sig769-300', '769-300',
@@ -700,7 +711,7 @@ def getCurrents(self, gaugenumber=5, roundto=1):
             self.curpacket = None
             return self.curpacket
 
-    def getWind(self, gaugenumber=0, collectionlength=10):
+    def getWind(self, gaugenumber=0, collectionlength=10, force_refresh=False):
         """This function retrieves the wind data.
 
         Collection length is the time over which the wind record exists ie data is collected in 10 minute increments
@@ -718,6 +729,8 @@ def getWind(self, gaugenumber=0, collectionlength=10):
 
             '732 wind gauge' in [3]
 
+          force_refresh (bool): If True and caching is enabled, bypass cache and fetch fresh data.
+
         Returns:
             dict, will return None if an error is encountered
                 'name' (str):  station name
@@ -753,6 +766,15 @@ def getWind(self, gaugenumber=0, collectionlength=10):
                 'gaugeht' (float): gauge height for uncorrected wind measurements
 
         """
+        cache_params = {'gaugenumber': gaugenumber, 'collectionlength': collectionlength}
+
+        def fetch_data():
+            return self._getWind_impl(gaugenumber, collectionlength)
+
+        return self._get_with_cache('wind', fetch_data, cache_params, force_refresh)
+
+    def _getWind_impl(self, gaugenumber, collectionlength):
+        """Internal implementation of getWind (without caching)."""
         # Making gauges flexible
         # different Gauges
         if gaugenumber in ['derived', 'Derived', 0]:
@@ -842,7 +864,7 @@ def getWind(self, gaugenumber=0, collectionlength=10):
             print('     ---- ERROR: Problem finding wind !!!')
             return None
 
-    def getWL(self, collectionlength=6):
+    def getWL(self, collectionlength=6, force_refresh=False):
         """This function retrieves the water level data from the server.
 
         WL data on server is NAVD88
@@ -853,6 +875,7 @@ def getWL(self, collectionlength=6):
 
         Args:
           collectionlength (int): dictates what value to round time to (Default value = 6)
+          force_refresh (bool): If True and caching is enabled, bypass cache and fetch fresh data.
 
         Returns:
           dictionary with keys
@@ -873,6 +896,15 @@ def getWL(self, collectionlength=6):
             'predictedWL': predicted tide
 
         """
+        cache_params = {'collectionlength': collectionlength}
+
+        def fetch_data():
+            return self._getWL_impl(collectionlength)
+
+        return self._get_with_cache('waterlevel', fetch_data, cache_params, force_refresh)
+
+    def _getWL_impl(self, collectionlength):
+        """Internal implementation of getWL (without caching)."""
         # this is the back end of the url for waterlevel
         self.dataloc = 'oceanography/waterlevel/eopNoaaTide/eopNoaaTide.ncml'
 
@@ -904,7 +936,7 @@ def getWL(self, collectionlength=6):
             self.WLpacket = None
         return self.WLpacket
 
-    def getGaugeWL(self, gaugenumber=5, roundto=1):
+    def getGaugeWL(self, gaugenumber=5, roundto=1, force_refresh=False):
         """This function pulls down the water level data at a particular gauge from the Server.
 
         Args:
@@ -912,6 +944,7 @@ def getGaugeWL(self, gaugenumber=5, roundto=1):
             roundto: the time over which the wind record exists ie data is collected in 10 minute
             increments
                         data is rounded to the nearst [roundto] (default 1 min)
+            force_refresh (bool): If True and caching is enabled, bypass cache and fetch fresh data.
 
         Returns
             wlpacket (dict) with keys below
@@ -932,6 +965,15 @@ def getGaugeWL(self, gaugenumber=5, roundto=1):
                 'yFRF': yFRF position of the gage
 
         """
+        cache_params = {'gaugenumber': gaugenumber, 'roundto': roundto}
+
+        def fetch_data():
+            return self._getGaugeWL_impl(gaugenumber, roundto)
+
+        return self._get_with_cache('gaugewl', fetch_data, cache_params, force_refresh)
+
+    def _getGaugeWL_impl(self, gaugenumber, roundto):
+        """Internal implementation of getGaugeWL (without caching)."""
         # Making gauges flexible
         self._wlGageURLlookup(gaugenumber)
         # parsing out data of interest in time
@@ -985,7 +1027,7 @@ def getGaugeWL(self, gaugenumber=5, roundto=1):
                             'name': str(self.ncfile.title), }
             return wlpacket
 
-    def getBathyTransectFromNC(self, profilenumbers=None, method=1, forceReturnAll=False):
+    def getBathyTransectFromNC(self, profilenumbers=None, method=1, forceReturnAll=False, force_refresh=False):
         """This function gets the bathymetric data from the server.
 
         Args:
@@ -997,6 +1039,8 @@ def getBathyTransectFromNC(self, profilenumbers=None, method=1, forceReturnAll=F
           forceReturnAll (bool): (Default Value = False)
                 This will force the survey to take and return all indices between start and end,
                 not the single
+          force_refresh (bool): If True and caching is enabled, bypass cache and fetch fresh data.
+
         Returns:
           dictionary with keys, will return None if call fails
             'xFRF': x coordinate in frf
@@ -1022,6 +1066,15 @@ def getBathyTransectFromNC(self, profilenumbers=None, method=1, forceReturnAll=F
             'Ellipsoid': which ellipsoid is used
 
         """
+        cache_params = {'profilenumbers': profilenumbers, 'method': method, 'forceReturnAll': forceReturnAll}
+
+        def fetch_data():
+            return self._getBathyTransectFromNC_impl(profilenumbers, method, forceReturnAll)
+
+        return self._get_with_cache('bathytransect', fetch_data, cache_params, force_refresh)
+
+    def _getBathyTransectFromNC_impl(self, profilenumbers, method, forceReturnAll):
+        """Internal implementation of getBathyTransectFromNC (without caching)."""
         # do check here on profile numbers
         # acceptableProfileNumbers = [None, ]
         self.dataloc = 'geomorphology/elevationTransects/survey/surveyTransects.ncml'  # location
@@ -1734,13 +1787,14 @@ def get_sensor_locations(self, datafile='frf_sensor_locations.pkl', window_days=
 
         return sensor_locations
 
-    def getLidarRunup(self, removeMasked=True):
+    def getLidarRunup(self, removeMasked=True, force_refresh=False):
         """This function will get the wave runup measurements from the lidar mounted in the dune.
 
         Args:
           removeMasked: if data come back as masked, remove from the arrays removeMasked will
             toggle the removing of data points from the tsTime series based on the flag
             status (Default value = True)
+          force_refresh (bool): If True and caching is enabled, bypass cache and fetch fresh data.
 
         Returns:
           dictionary with collected data.  keys listed below (for more info see the netCDF file
@@ -1773,6 +1827,15 @@ def getLidarRunup(self, removeMasked=True):
             measurement
 
         """
+        cache_params = {'removeMasked': removeMasked}
+
+        def fetch_data():
+            return self._getLidarRunup_impl(removeMasked)
+
+        return self._get_with_cache('lidarrunup', fetch_data, cache_params, force_refresh)
+
+    def _getLidarRunup_impl(self, removeMasked):
+        """Internal implementation of getLidarRunup (without caching)."""
         self.dataloc = 'oceanography/waves/lidarWaveRunup/lidarWaveRunup.ncml'
         self.ncfile, self.allEpoch, _ = getnc(dataLoc=self.dataloc, callingClass=self.callingClass,
                                                dtRound=1 * 60)
@@ -1833,14 +1896,15 @@ def getLidarRunup(self, removeMasked=True):
             out = None
         return out
 
-    def getCTD(self):
+    def getCTD(self, force_refresh=False):
         """THIS FUNCTION IS CURRENTLY BROKEN.
 
         THE PROBLEM IS THAT self.cshore_ncfile does not have any keys?
         TODO fix this function
         This function gets the CTD data from the thredds server
 
-        Args:  None
+        Args:
+            force_refresh (bool): If True and caching is enabled, bypass cache and fetch fresh data.
 
         Returns:
             dict: output dictionary with keys listed below, will return None if error happens
@@ -1861,6 +1925,15 @@ def getCTD(self):
                 'sigmaT':
 
         """
+        cache_params = {}
+
+        def fetch_data():
+            return self._getCTD_impl()
+
+        return self._get_with_cache('ctd', fetch_data, cache_params, force_refresh)
+
+    def _getCTD_impl(self):
+        """Internal implementation of getCTD (without caching)."""
         # do check here on profile numbers
         # acceptableProfileNumbers = [None, ]
         self.dataloc = 'oceanography/ctd/eop-ctd/eop-ctd.ncml'  # location of the gridded surveys
@@ -1906,7 +1979,7 @@ def getCTD(self):
 
         return ctd_Dict
 
-    def getALT(self, gaugeName=None, removeMasked=True):
+    def getALT(self, gaugeName=None, removeMasked=True, force_refresh=False):
         """This function gets the Altimeter data from the thredds server.
 
         Args:
@@ -1917,6 +1990,8 @@ def getALT(self, gaugeName=None, removeMasked=True):
 
           removeMasked (bool): remove the data that are masked (Default value = True)
 
+          force_refresh (bool): If True and caching is enabled, bypass cache and fetch fresh data.
+
         Returns:
           a dictionary with below keys with selected data, for more info see netCDF files on server
             'name': file title
@@ -1944,6 +2019,15 @@ def getALT(self, gaugeName=None, removeMasked=True):
             'bottomElev': Kalman filtered elevation
 
         """
+        cache_params = {'gaugeName': gaugeName, 'removeMasked': removeMasked}
+
+        def fetch_data():
+            return self._getALT_impl(gaugeName, removeMasked)
+
+        return self._get_with_cache('altimeter', fetch_data, cache_params, force_refresh)
+
+    def _getALT_impl(self, gaugeName, removeMasked):
+        """Internal implementation of getALT (without caching)."""
         # location of the data
         gauge_list = ['Alt769-150', 'Alt769-200', 'Alt769-250', 'Alt769-300', 'Alt769-350',
                       'Alt861-150', 'Alt861-200', 'Alt861-250', 'Alt861-300', 'Alt861-350',

From 50e367d82b37ebef7fa7ffaab2d4ff999395d50c Mon Sep 17 00:00:00 2001
From: Spicer Bak <spicer.bak.frf@gmail.com>
Date: Thu, 16 Jul 2026 14:17:26 -0400
Subject: [PATCH 5/7] Address review comments on PR #58

Fixes:
1. Remove unused `get_cache` import from getDataFRF.py
2. NumpyJSONEncoder: Add fallback to str() for unknown types (datetime, Path, etc.)
3. _generate_cache_key: Use NumpyJSONEncoder for consistent serialization
4. DataCache.get(): Release lock during fetch_func() to allow concurrent fetches

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .claude/settings.json                         |  10 +++++
 .mcp-debug-tools/config.json                  |   7 ++++
 .../combined_asv_wave_conditions_2023.png     | Bin 0 -> 133945 bytes
 murgtools/cache.py                            |  35 +++++++++++++-----
 murgtools/getdata/getDataFRF.py               |   2 +-
 5 files changed, 43 insertions(+), 11 deletions(-)
 create mode 100644 .claude/settings.json
 create mode 100644 .mcp-debug-tools/config.json
 create mode 100644 examples/combined_asv_wave_conditions_2023.png

diff --git a/.claude/settings.json b/.claude/settings.json
new file mode 100644
index 0000000..f91d88d
--- /dev/null
+++ b/.claude/settings.json
@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(gh pr *)",
+      "Bash(pip show *)",
+      "Bash(find /home/slug/repos/murgTools -maxdepth 3 -name \"*.tif\" 2>&1 | head -20; ls /tmp/*.tif 2>/dev/null | head -5)",
+      "Read(//tmp/**)"
+    ]
+  }
+}
diff --git a/.mcp-debug-tools/config.json b/.mcp-debug-tools/config.json
new file mode 100644
index 0000000..be67b51
--- /dev/null
+++ b/.mcp-debug-tools/config.json
@@ -0,0 +1,7 @@
+{
+  "vscodeInstanceId": "vscode-2474-1774366165262",
+  "port": 8890,
+  "pid": 2474,
+  "workspacePath": "/home/slug/repos/murgTools",
+  "workspaceName": "murgTools"
+}
\ No newline at end of file
diff --git a/examples/combined_asv_wave_conditions_2023.png b/examples/combined_asv_wave_conditions_2023.png
new file mode 100644
index 0000000000000000000000000000000000000000..e844ba27e1685e36a6ee2278994b8a22ab595dde
GIT binary patch
literal 133945
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

literal 0
HcmV?d00001

diff --git a/murgtools/cache.py b/murgtools/cache.py
index 4bca675..0c37a5b 100644
--- a/murgtools/cache.py
+++ b/murgtools/cache.py
@@ -52,7 +52,11 @@
 
 
 class NumpyJSONEncoder(json.JSONEncoder):
-    """JSON encoder that handles numpy types."""
+    """JSON encoder that handles numpy types and other non-JSON-serializable objects.
+
+    Falls back to string representation for unknown types to ensure cache
+    operations don't fail unexpectedly.
+    """
 
     def default(self, obj):
         if isinstance(obj, np.integer):
@@ -61,7 +65,17 @@ def default(self, obj):
             return float(obj)
         if isinstance(obj, np.ndarray):
             return obj.tolist()
-        return super().default(obj)
+        # Handle datetime objects
+        if hasattr(obj, 'isoformat'):
+            return obj.isoformat()
+        # Handle Path objects
+        if hasattr(obj, '__fspath__'):
+            return str(obj)
+        # Fallback to string for unknown types (graceful degradation)
+        try:
+            return super().default(obj)
+        except TypeError:
+            return str(obj)
 
 logger = logging.getLogger(__name__)
 
@@ -251,9 +265,9 @@ def _generate_cache_key(self, data_source: str, time_range: Optional[Tuple] = No
             key_parts.append(f"t{time_range[0]}-{time_range[1]}")
 
         if extra_params:
-            # Sort keys for deterministic ordering
+            # Sort keys for deterministic ordering, use custom encoder for numpy types
             sorted_params = sorted(extra_params.items())
-            key_parts.append(json.dumps(sorted_params, sort_keys=True))
+            key_parts.append(json.dumps(sorted_params, sort_keys=True, cls=NumpyJSONEncoder))
 
         key_string = '|'.join(str(p) for p in key_parts)
         return hashlib.sha256(key_string.encode()).hexdigest()[:32]
@@ -292,21 +306,22 @@ def get(self, data_source: str, fetch_func: Callable[[], Any],
 
         cache_key = self._generate_cache_key(data_source, time_range, extra_params)
 
+        # Check cache first (with lock)
         with self._lock:
-            # Check cache unless force_refresh is requested
             if not force_refresh:
                 cached_data = self._read_cache(cache_key)
                 if cached_data is not None:
                     return cached_data
 
-            # Fetch fresh data
-            data = fetch_func()
+        # Fetch fresh data WITHOUT holding the lock (allows concurrent fetches)
+        data = fetch_func()
 
-            # Store in cache
-            if data is not None:
+        # Store in cache (with lock)
+        if data is not None:
+            with self._lock:
                 self._write_cache(cache_key, data, data_source, time_range, extra_params)
 
-            return data
+        return data
 
     def _read_cache(self, cache_key: str) -> Optional[Any]:
         """Read data from cache if valid.
diff --git a/murgtools/getdata/getDataFRF.py b/murgtools/getdata/getDataFRF.py
index c7335e9..2da804f 100755
--- a/murgtools/getdata/getDataFRF.py
+++ b/murgtools/getdata/getDataFRF.py
@@ -23,7 +23,7 @@
 
 from murgtools.utils import geoprocess as gp, sblib as sb
 from murgtools import config
-from murgtools.cache import DataCache, get_cache
+from murgtools.cache import DataCache
 from murgtools.exceptions import InvalidGaugeError
 
 def gettime(allEpoch, epochStart, epochEnd, indexRef=0):

From 5979c16295940f7ba3602e01cdcda48fad94b810 Mon Sep 17 00:00:00 2001
From: Spicer Bak <spicer.bak.frf@gmail.com>
Date: Thu, 16 Jul 2026 15:37:54 -0400
Subject: [PATCH 6/7] Address PR #58 review comments

- Remove unused timedelta import from cache.py
- Fix thread safety in _get_cached_ip() by always using lock
  (clear_server_cache can reset the value, so lock-free fast path was unsafe)
- Remove accidentally committed .claude/ and .mcp-debug-tools/ directories
- Add .claude/ and .mcp-debug-tools/ to .gitignore

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .claude/settings.json        | 10 ----------
 .gitignore                   |  4 ++++
 .mcp-debug-tools/config.json |  7 -------
 murgtools/cache.py           |  2 +-
 murgtools/config.py          |  7 +------
 5 files changed, 6 insertions(+), 24 deletions(-)
 delete mode 100644 .claude/settings.json
 delete mode 100644 .mcp-debug-tools/config.json

diff --git a/.claude/settings.json b/.claude/settings.json
deleted file mode 100644
index f91d88d..0000000
--- a/.claude/settings.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(gh pr *)",
-      "Bash(pip show *)",
-      "Bash(find /home/slug/repos/murgTools -maxdepth 3 -name \"*.tif\" 2>&1 | head -20; ls /tmp/*.tif 2>/dev/null | head -5)",
-      "Read(//tmp/**)"
-    ]
-  }
-}
diff --git a/.gitignore b/.gitignore
index 44c81c6..9dcfc55 100755
--- a/.gitignore
+++ b/.gitignore
@@ -111,3 +111,7 @@ Thumbs.db
 *.nc
 *.pickle
 *.pkl
+
+# Local development configs
+.claude/
+.mcp-debug-tools/
diff --git a/.mcp-debug-tools/config.json b/.mcp-debug-tools/config.json
deleted file mode 100644
index be67b51..0000000
--- a/.mcp-debug-tools/config.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-  "vscodeInstanceId": "vscode-2474-1774366165262",
-  "port": 8890,
-  "pid": 2474,
-  "workspacePath": "/home/slug/repos/murgTools",
-  "workspaceName": "murgTools"
-}
\ No newline at end of file
diff --git a/murgtools/cache.py b/murgtools/cache.py
index 0c37a5b..b62967b 100644
--- a/murgtools/cache.py
+++ b/murgtools/cache.py
@@ -42,7 +42,7 @@
 import pickle
 import threading
 import time
-from datetime import datetime, timedelta
+from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, Dict, Optional, Tuple, Union
 
diff --git a/murgtools/config.py b/murgtools/config.py
index a842298..c836444 100644
--- a/murgtools/config.py
+++ b/murgtools/config.py
@@ -131,12 +131,7 @@ def _get_cached_ip():
     """
     global _cached_ip_address
 
-    # Fast path: check without lock first (safe because we only write once)
-    if _cached_ip_address is not None:
-        return _cached_ip_address
-
     with _cache_lock:
-        # Double-check after acquiring lock
         if _cached_ip_address is not None:
             return _cached_ip_address
 
@@ -146,7 +141,7 @@ def _get_cached_ip():
             # Covers socket.error, socket.gaierror, socket.herror in Python 3
             _cached_ip_address = ''
 
-    return _cached_ip_address
+        return _cached_ip_address
 
 
 def get_thredds_server(server=None, ip_address=None):

From a44ba9d03a9bcdde048992277316eb1883452dd1 Mon Sep 17 00:00:00 2001
From: Spicer Bak <spicer.bak.frf@gmail.com>
Date: Thu, 16 Jul 2026 15:50:22 -0400
Subject: [PATCH 7/7] Address additional PR #58 review comments

- Remove unused pickle import from test_cache.py
- Use TTL setter in __init__ for validation (prevents negative TTL)
- Include resolved server URL in cache key (not just self.server which
  can be None for auto-detect, causing cache collisions across networks)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 murgtools/cache.py              | 6 +++---
 murgtools/getdata/getDataFRF.py | 6 ++++--
 tests/test_cache.py             | 1 -
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/murgtools/cache.py b/murgtools/cache.py
index b62967b..ab4b7dc 100644
--- a/murgtools/cache.py
+++ b/murgtools/cache.py
@@ -179,14 +179,14 @@ def __init__(self, enabled: Optional[bool] = None, cache_dir: Optional[str] = No
             env_dir = os.environ.get(config.ENV_CACHE_DIR)
             self._cache_dir = Path(env_dir) if env_dir else Path(config.DEFAULT_CACHE_DIR)
 
-        # Determine TTL
+        # Determine TTL (use setter for validation)
         if ttl_days is not None:
-            self._ttl_days = ttl_days
+            self.ttl_days = ttl_days  # Use setter for validation
         else:
             env_ttl = os.environ.get(config.ENV_CACHE_TTL_DAYS)
             if env_ttl:
                 try:
-                    self._ttl_days = int(env_ttl)
+                    self.ttl_days = int(env_ttl)  # Use setter for validation
                 except ValueError:
                     logger.warning(f"Invalid TTL value '{env_ttl}', using default")
                     self._ttl_days = config.DEFAULT_CACHE_TTL_DAYS
diff --git a/murgtools/getdata/getDataFRF.py b/murgtools/getdata/getDataFRF.py
index 2da804f..002cbe8 100755
--- a/murgtools/getdata/getDataFRF.py
+++ b/murgtools/getdata/getDataFRF.py
@@ -318,8 +318,10 @@ def _get_with_cache(self, data_type, fetch_func, extra_params=None, force_refres
         data_source = f"getObs.{data_type}"
         time_range = (self.epochd1, self.epochd2)
 
-        # Include server in extra_params for cache key
-        cache_params = {'server': self.server}
+        # Include resolved server URL in extra_params for cache key
+        # Use FRFdataloc (the actual server being used) rather than self.server
+        # (which may be None for auto-detect)
+        cache_params = {'server_url': self.FRFdataloc}
         if extra_params:
             cache_params.update(extra_params)
 
diff --git a/tests/test_cache.py b/tests/test_cache.py
index 066495f..7fd6b95 100644
--- a/tests/test_cache.py
+++ b/tests/test_cache.py
@@ -2,7 +2,6 @@
 
 import json
 import os
-import pickle
 import tempfile
 import threading
 import time