hapiclient 0.2.8__tar.gz → 0.3.0__tar.gz

{hapiclient-0.2.8 → hapiclient-0.3.0}/CHANGES.txt

@@ -120,3 +120,12 @@ v0.2.8b2:
 	2026-05-20 -- Refactor
 v0.2.8:
 	2026-06-04 -- Compat. fixes for hapiplot package.
+v0.2.8b0:
+	2026-06-08 -- Show time parsing error message
+v0.2.9:
+	2026-06-08 -- 93-occasional-crashes-due-to-undefined-variable-dt-in-get_csv-hapiclient-version-028
+v0.3.0:
+	2026-06-22 -- Try numpy if pandas csv read fails. https://github.com/hapi-server/client-python/pull/98
+	2026-06-22 -- Fix logging broken by refactor. https://github.com/hapi-server/client-python/pull/96
+	2026-06-22 -- Fix so test/test_logging.py passes (issue with using tox)
+	2026-07-08 -- 94-cache-files-can-be-corrupted-by-interrupted-writes

{hapiclient-0.2.8/hapiclient.egg-info → hapiclient-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hapiclient
-Version: 0.2.8
+Version: 0.3.0
 Summary: Interface to Heliophysics data server API
 Home-page: http://pypi.python.org/pypi/hapiclient/
 Author: Bob Weigel

{hapiclient-0.2.8 → hapiclient-0.3.0}/hapiclient/__init__.py

@@ -13,7 +13,7 @@ from hapiclient.hapitime import datetime2hapitime
 # Allow "from hapiclient import HAPIError"
 from hapiclient.util import HAPIError
 
-__version__ = '0.2.8'
+__version__ = '0.3.0'
 
 import sys
 import platform

{hapiclient-0.2.8 → hapiclient-0.3.0}/hapiclient/cache.py

@@ -125,10 +125,9 @@ def meta_cache_write(meta, SERVER, DATASET, opts):
   """Write metadata to JSON and PKL cache files."""
 
   import os
-  import json
-  import pickle
 
   from hapiclient.log import log
+  from hapiclient.util import write_atomic
 
   if not opts["cache"]:
     return
@@ -136,17 +135,11 @@ def meta_cache_write(meta, SERVER, DATASET, opts):
   paths = meta_cache_paths(SERVER, DATASET, opts['cachedir'])
   fnamejson, fnamepkl = paths['json'], paths['pkl']
 
-  server_dir = cachedir(opts["cachedir"], SERVER)
-  os.makedirs(server_dir, exist_ok=True)
-
   log('Writing %s ' % os.path.basename(fnamejson))
-  with open(fnamejson, 'w') as f:
-    json.dump(meta, f, indent=4)
+  write_atomic(fnamejson, meta)
 
   log('Writing %s ' % os.path.basename(fnamepkl))
-  with open(fnamepkl, 'wb') as f:
-    # protocol=2 used for Python 2.7 compatibility.
-    pickle.dump(meta, f, protocol=2)
+  write_atomic(fnamepkl, meta)
 
 
 def data_cache_paths(SERVER, DATASET, PARAMETERS, START, STOP, cachedir):
@@ -171,7 +164,7 @@ def data_cache_read_metax(SERVER, DATASET, PARAMETERS, START, STOP, opts):
   from hapiclient.log import log
 
   if not opts["usecache"]:
-    log('Not checking data cache because usecache is False.')
+    log('Not checking subsetted metadata cache because usecache is False.')
     return None
 
   fnamepklx = data_cache_paths(SERVER, DATASET, PARAMETERS, START, STOP, opts['cachedir'])['pkl']
@@ -215,11 +208,9 @@ def data_cache_write(data_result, meta, SERVER, DATASET, PARAMETERS, START, STOP
   """
 
   import os
-  import pickle
-  import warnings
-  import numpy as np
 
   from hapiclient.log import log
+  from hapiclient.util import write_atomic
 
   data_paths = data_cache_paths(SERVER, DATASET, PARAMETERS, START, STOP, opts['cachedir'])
   fnamecsv, fnamebin, fnamenpy, fnamepklx = data_paths['csv'], data_paths['bin'], data_paths['npy'], data_paths['pkl']
@@ -236,20 +227,8 @@ def data_cache_write(data_result, meta, SERVER, DATASET, PARAMETERS, START, STOP
     # Need to return after meta is updated.
     return
 
-  server_dir = cachedir(opts["cachedir"], SERVER)
-  os.makedirs(server_dir, exist_ok=True)
-
   log('Writing %s' % os.path.basename(fnamepklx))
-  with open(fnamepklx, 'wb') as f:
-    pickle.dump(meta, f, protocol=2)
+  write_atomic(fnamepklx, meta)
 
   log('Writing %s' % os.path.basename(fnamenpy))
-  with warnings.catch_warnings():
-    # Ignore warning that occurs when saving Unicode data.
-    kwargs = {
-        'message': r"Stored array in format 3\.0.*",
-        'category': UserWarning,
-        'module': r"numpy\.lib\.format"
-    }
-    warnings.filterwarnings("ignore", **kwargs)
-    np.save(fnamenpy, data_result)
+  write_atomic(fnamenpy, data_result)

{hapiclient-0.2.8 → hapiclient-0.3.0}/hapiclient/capabilities.py

@@ -31,12 +31,19 @@ def get_format(SERVER, format):
 
   if format != 'csv':
     caps = capabilities(SERVER)
-    sformats = caps["outputFormats"]  # Server formats
-    if format not in sformats:
+    if "outputFormats" not in caps:
+      return 'csv'
+
+    formats = caps.get("outputFormats", [])  # Server formats
+    if len(formats) == 0:
+      return 'csv'
+
+    if format not in formats:
       msg = 'Requested transport format "%s" not avaiable from %s. Will use "csv". Available options: %s'
-      warning(msg % (format, SERVER, ', '.join(sformats)))
+      warning(msg % (format, SERVER, ', '.join(formats)))
       format = 'csv'
-    if 'binary' not in sformats:
+
+    if 'binary' not in formats:
       format = 'csv'
 
   return format

{hapiclient-0.2.8 → hapiclient-0.3.0}/hapiclient/data.py

@@ -22,7 +22,7 @@ def data(SERVER, DATASET, PARAMETERS, START, STOP, opts):
     log('STOP was given as None. Getting stopDate for dataset.')
     meta = info(SERVER, DATASET, None, opts)
     STOP = meta['stopDate']
-    log('Using STOP = {STOP}')
+    log(f'Using STOP = {STOP}')
 
   tic_totalTime = time.time()
 

{hapiclient-0.2.8 → hapiclient-0.3.0}/hapiclient/get.py

@@ -174,12 +174,9 @@ def get_csv(meta, SERVER, DATASET, PARAMETERS, START, STOP, opts):
   if opts["cache"]:
     tic0 = time.time()
     urlretrieve(urlcsv, fnamecsv)
-    toc0 = time.time() - tic0
     log('Reading and parsing %s' % os.path.basename(fnamecsv))
-    tic = time.time()
     if os.path.getsize(fnamecsv) == 0:
       file_empty = True
-      data = np.array([], dtype=dt)
   else:
     from io import StringIO
     log('Writing %s to buffer' % urlcsv)
@@ -188,50 +185,64 @@ def get_csv(meta, SERVER, DATASET, PARAMETERS, START, STOP, opts):
     fnamecsv.seek(0, os.SEEK_END)
     if fnamecsv.tell() == 0:
       file_empty = True
-      data = np.array([], dtype=dt)
     else:
       fnamecsv.seek(0)
-    toc0 = time.time() - tic0
     log('Parsing StringIO buffer.')
-    tic = time.time()
 
-  if not file_empty:
+  toc0 = time.time() - tic0
+
+  tic1 = time.time()
+
+  if file_empty:
+    log("Response is empty. Returning empty data array.")
+    dt, _, _, _, _ = _compute_dt(meta, opts)
+    data = np.array([], dtype=dt)
+  else:
     if missing_length(meta, opts):
       data = _parse_csv_missing_length(fnamecsv, meta, opts, urlcsv)
     else:
       data = _parse_csv(fnamecsv, meta, opts, urlcsv)
 
-  toc = time.time() - tic
+  toc1 = time.time() - tic1
 
-  return data, toc0, toc
+  return data, toc0, toc1
 
 
 def _parse_csv(fnamecsv, meta, opts, urlcsv):
-  dt, cols, psizes, pnames, ptypes = _compute_dt(meta, opts)
+
   # All string and isotime parameters have a length in metadata.
-  if opts['method'] == 'numpy':
+
+  dt, cols, psizes, pnames, ptypes = _compute_dt(meta, opts)
+
+  kwargs_numpy = {
+      'dtype': dt,
+      'delimiter': ',',
+      'replace_space': ' ',
+      'deletechars': '',
+      'encoding': 'utf-8'
+  }
+
+  kwargs_pandas = {
+      'sep': ',',
+      'header': None,
+      'encoding': 'utf-8',
+      'skipinitialspace': True,
+      'keep_default_na': False,
+      'na_values': ['NaN', 'nan', 'Nan', 'naN', ' "NaN"', ' "nan"', ' "Nan"', ' "naN"', '"NaN"', '"nan"', '"Nan"', '"naN"']
+  }
+
+  def _numpy(fname_csv):
     try:
-      kwargs = {
-          'dtype': dt,
-          'delimiter': ',',
-          'replace_space': ' ',
-          'deletechars': '',
-          'encoding': 'utf-8'
-      }
-      data = np.genfromtxt(fnamecsv, **kwargs)
+      data = np.genfromtxt(fnamecsv, **kwargs_numpy)
+      return data
     except Exception as e:
       error('np.genfromtxt({}) gave {} using data from {}'.format(fnamecsv, e, urlcsv))
 
+  if opts['method'] == 'numpy':
+    return _numpy(fnamecsv)
+
   if opts['method'] == '' or opts['method'] == 'pandas':
     # Read file into Pandas DataFrame
-    kwargs = {
-        'sep': ',',
-        'header': None,
-        'encoding': 'utf-8',
-        'skipinitialspace': True,
-        'keep_default_na': False,
-        'na_values': ['NaN', 'nan', 'Nan', 'naN', ' "NaN"', ' "nan"', ' "Nan"', ' "naN"', '"NaN"', '"nan"', '"Nan"', '"naN"']
-    }
     """
     Note that this does not handle trailing whitespace after
     any of the na_values. (There is no skiptrailingspace option).
@@ -246,21 +257,26 @@ def _parse_csv(fnamecsv, meta, opts, urlcsv):
         csv_kwargs["converters"] = {i: strip_field for i in range(ncols)}
     """
     try:
-      df = pandas.read_csv(fnamecsv, **kwargs)
+      df = pandas.read_csv(fnamecsv, **kwargs_pandas)
     except Exception as e:
-      error('pandas.read_csv({}) gave {} using data from {}'.format(fnamecsv, e, urlcsv))
+      error('\npandas.read_csv("{}")\nwith kwargs\n   {}\ngave\n   "{}"\nusing data from\n   {}'.format(fnamecsv, kwargs_pandas, e, urlcsv))
 
-    # Allocate output N-D array (It is not possible to pass dtype=dt
-    # as computed to pandas.read_csv; pandas dtype is different
-    # from numpy's dtype.)
-    data = np.ndarray(shape=(len(df)), dtype=dt)
-    # Insert data from dataframe 'df' columns into N-D array 'data'
-    for i in range(0, len(pnames)):
-      shape = np.append(len(data), psizes[i])
-      # In numpy 1.8.2 and Python 2.7, this throws an error
-      # for no apparent reason. Works as expected in numpy 1.10.4
-      datap = df.values[:, np.arange(cols[i][0], cols[i][1] + 1)]
-      data[pnames[i]] = np.squeeze(np.reshape(datap, shape))
+    # Allocate output N-D array (It is not possible to pass dtype=dt as computed
+    # to pandas.read_csv; pandas dtypes are different from numpy's dtypes.)
+    try:
+      data = np.ndarray(shape=(len(df)), dtype=dt)
+      # Insert data from dataframe 'df' columns into N-D array 'data'
+      for i in range(0, len(pnames)):
+        shape = np.append(len(data), psizes[i])
+        datap = df.values[:, np.arange(cols[i][0], cols[i][1] + 1)]
+        data[pnames[i]] = np.squeeze(np.reshape(datap, shape))
+    except Exception as e:
+      try:
+        data = _numpy(fnamecsv)
+      except Exception as e2:
+        emsg = '\nError converting CSV response read using\n   pandas.read_csv("{}")\nwith\n   kwargs = {}\nto a ndarray:\n  "{}".'
+        emsg += '\nAlso,\n   np.genfromtxt("{}")\nwith kwargs\n   {}\ngave\n   "{}".'
+        error(emsg.format(urlcsv, kwargs_pandas, e, fnamecsv, kwargs_numpy, e2))
 
   return data
 

{hapiclient-0.2.8 → hapiclient-0.3.0}/hapiclient/hapi.py

@@ -7,7 +7,7 @@ from hapiclient.info import info
 from hapiclient.data import data
 
 # Backward compatibility: older code imports request2path from hapiclient.hapi
-from hapiclient.cache import request2path
+from hapiclient.cache import request2path # Do not remove.
 
 
 
@@ -45,7 +45,7 @@ def hapiopts():
 def hapi(*args, **kwargs):
     """Request data from a HAPI server.
 
-    Version: 0.2.8
+    Version: 0.3.0
 
 
     Examples
@@ -66,9 +66,9 @@ def hapi(*args, **kwargs):
     stop: str or None
         The end time of the requested data; end times are exclusive - the
         last data record returned by a HAPI server should have a timestamp
-        before `start`. If `None`, `stopDate` is used.
+        before `stop`. If `None`, `stopDate` is used.
     options: dict
-            `logging` (``False``) - Log to console
+            `logging` (``False``) - If ``True``, add a stdout handler to the Python ``logging`` module and set log level to INFO. If the Python ``logging`` module has already been configured for the ``hapiclient`` logger (external handlers or log level set), the ``logging`` kwarg is ignored.
 
             `cache` (``True``) - Save responses and processed responses in cachedir
 
@@ -210,13 +210,14 @@ def hapi(*args, **kwargs):
             # TODO: Consider warning.
             STOP = STOP + 'Z'
 
-    # Override defaults
-    opts = setopts(hapiopts(), kwargs)
 
-    msg = "logging keyword must be True, False, or a file-like object"
-    assert (isinstance(opts['logging'], bool) or hasattr(opts['logging'], 'write')), msg
+    if 'logging' in kwargs and not isinstance(kwargs['logging'], bool):
+        raise ValueError("logging keyword must be True or False")
+
+    configure_logging(kwargs.get('logging', None))
 
-    configure_logging(opts)
+    # Override defaults
+    opts = setopts(hapiopts(), kwargs)
 
     assert (opts['cache'] in [True, False]), "cache keyword must be True of False"
     assert (opts['usecache'] in [True, False]), "usecache keyword must be True of False"

{hapiclient-0.2.8 → hapiclient-0.3.0}/hapiclient/hapitime.py

@@ -274,7 +274,8 @@ def hapitime2datetime(Time, **kwargs):
         toc = time.time() - tic
         log("Pandas processing time = %.4fs, first time = %s" % (toc, Timeo))
         return Time
-    except:
+    except Exception as e:
+        log("Pandas processing failed with error: " + str(e))
         log("Pandas processing failed, first time = %s" % Time[0])
 
 

{hapiclient-0.2.8 → hapiclient-0.3.0}/hapiclient/log.py

@@ -5,12 +5,16 @@ _logger = _logging.getLogger("hapiclient")
 _INTERNAL_HANDLER_ATTR = "_hapiclient_internal_handler"
 _INTERNAL_LEVEL_ATTR = "_hapiclient_internal_level"
 
+# Disable propagation by default so hapiclient logs don't bubble up
+# to root logger (e.g., pytest's logger). Can be re-enabled by user.
+_logger.propagate = False
 
-def configure_logging(opts):
+
+def configure_logging(logging):
     """Configure the hapiclient logger based on opts['logging'].
 
     If the hapiclient logger has been configured externally (level != NOTSET
-    or handlers present), the logging kwarg.
+    or handlers present) and logging=False, the logging kwarg is ignored.
     """
     has_user_level = _logger.level != _logging.NOTSET and \
                      _logger.level != getattr(_logger, _INTERNAL_LEVEL_ATTR, None)
@@ -19,22 +23,26 @@ def configure_logging(opts):
         for handler in _logger.handlers
     )
 
-    if opts['logging']:
+    if logging is True:
         _logger.setLevel(_logging.INFO)
         setattr(_logger, _INTERNAL_LEVEL_ATTR, _logging.INFO)
         _logger.propagate = False
-        if not _logger.handlers:
+        _has_internal = any(getattr(h, _INTERNAL_HANDLER_ATTR, False) for h in _logger.handlers)
+        if not _has_internal:
             import sys
             _handler = _logging.StreamHandler(sys.stdout)
             _handler.setFormatter(_logging.Formatter("%(message)s"))
             setattr(_handler, _INTERNAL_HANDLER_ATTR, True)
             _logger.addHandler(_handler)
-    else:
+    if logging is False:
         if has_user_level or has_user_handlers:
+            #from .util import warning
             if has_user_handlers:
-                log("Ignoring logging=%s because standard Python logger for 'hapiclient' already configured with handlers." % opts['logging'])
+                pass
+                #warning("Ignoring logging=False because standard Python logger for 'hapiclient' already configured with handlers.")
             else:
-                log("Ignoring logging=%s because standard Python logger for 'hapiclient' already configured with log_level != NOTSET." % opts['logging'])
+                pass
+                #warning("Ignoring logging=False because standard Python logger for 'hapiclient' already configured with log_level != NOTSET.")
         else:
             _logger.setLevel(_logging.WARNING)
             setattr(_logger, _INTERNAL_LEVEL_ATTR, _logging.WARNING)

{hapiclient-0.2.8 → hapiclient-0.3.0}/hapiclient/util.py

@@ -1,4 +1,4 @@
-from hapiclient.log import log, configure_logging
+from hapiclient.log import log
 
 
 def setopts(defaults, given):
@@ -148,7 +148,7 @@ def warning(*args):
         import platform
         prefix = "\x1b[31mHAPIWarning:\x1b[0m "
         if platform.system() == 'Windows' and pythonshell() == 'shell':
-            prefix = "HAPIWarning: "        
+            prefix = "HAPIWarning: "
 
         return prefix
 
@@ -197,7 +197,6 @@ def error(msg, debug=False):
     from inspect import stack
     from os import path
 
-    debug = False
     if pythonshell() != 'shell':
         try:
             from IPython.core.interactiveshell import InteractiveShell
@@ -214,7 +213,7 @@ def error(msg, debug=False):
         import platform
         prefix = "\033[0;31mHAPIError:\033[0m "
         if platform.system() == 'Windows' and pythonshell() == 'shell':
-            prefix = "HAPIError: "        
+            prefix = "HAPIError: "
 
         return prefix
 
@@ -222,7 +221,7 @@ def error(msg, debug=False):
                                   filename=None, tb_offset=None,
                                   exception_only=False,
                                   running_compiled_code=False):
-        
+
         exception = sys.exc_info()
         if not debug and exception[0].__name__ == "HAPIError":
             sys.stderr.write(prefix() + str(exception[1]))
@@ -347,26 +346,19 @@ def urlopen(url, parse_json=False):
 
 
 def urlretrieve(url, fname):
-    """Download URL to file
+    """Download URL to file atomically.
 
     res = urlretrieve(url, fname)
     """
 
-    import os
-    import shutil
-
-    dirname = os.path.dirname(fname)
-    if not os.path.exists(dirname):
-        os.makedirs(dirname)
+    log('Writing')
+    log('  %s' % url)
+    log('to')
+    log('  %s' % fname)
+    res = urlopen(url)
+    write_atomic(fname, res)
 
-    with open(fname, 'wb') as out:
-        res = urlopen(url)
-        log('Writing')
-        log('%s' % url)
-        log('to')
-        log('%s' % os.path.basename(fname))
-        shutil.copyfileobj(res, out)
-        return res
+    return res
 
 
 def subset_meta(meta, params):
@@ -394,7 +386,7 @@ def subset_meta(meta, params):
     pa = [meta['parameters'][0]]  # First parameter is always the time parameter
 
     params_reordered = []  # Re-ordered params
-    # If time parameter explicity requested, put it first in params_reordered.
+    # If time parameter explicitly requested, put it first in params_reordered.
     if meta['parameters'][0]['name'] in p:
         params_reordered = [meta['parameters'][0]['name']]
 
@@ -454,3 +446,63 @@ def missing_length(meta, opts):
             return True
 
     return False
+
+
+def write_atomic(path, data):
+
+  import os
+  import json
+  import pickle
+  import pathlib
+  import secrets
+  import warnings
+
+  import numpy
+
+  path = pathlib.Path(path)
+  path.parent.mkdir(parents=True, exist_ok=True)
+  tmp_ext = f".{secrets.token_hex(3)}.tmp"
+  tmp_path = path.with_suffix(path.suffix + tmp_ext)
+
+  try:
+
+    if path.suffix == '.json':
+      with tmp_path.open('w') as f:
+        json.dump(data, f, indent=2)
+
+    if path.suffix == '.pkl':
+      with tmp_path.open('wb') as f:
+        pickle.dump(data, f, protocol=2)
+
+    if path.suffix == '.npy':
+      with warnings.catch_warnings():
+        # Ignore warning that occurs when saving Unicode data.
+        kwargs = {
+            'message': r"Stored array in format 3\.0.*",
+            'category': UserWarning,
+            'module': r"numpy\.lib\.format"
+        }
+        warnings.filterwarnings("ignore", **kwargs)
+        with tmp_path.open('wb') as f:
+          numpy.save(f, data)
+
+    if path.suffix in ('.bin', '.csv'):
+      with tmp_path.open('wb') as f:
+        if isinstance(data, (bytes, bytearray)):
+          f.write(data)
+        else:
+          # Assume a file-like / streaming response object.
+          import shutil
+          shutil.copyfileobj(data, f)
+
+    try:
+      os.replace(tmp_path, path)
+    except Exception as e:
+      warning(f"Failed to rename cache file from {tmp_path} to {path}: {e}")
+
+  except Exception as e:
+    warning(f"Failed to write cache file {tmp_path}: {e}")
+    try:
+      tmp_path.unlink()
+    except OSError:
+        warning(f"Failed to remove temporary cache file {tmp_path}")

{hapiclient-0.2.8 → hapiclient-0.3.0/hapiclient.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hapiclient
-Version: 0.2.8
+Version: 0.3.0
 Summary: Interface to Heliophysics data server API
 Home-page: http://pypi.python.org/pypi/hapiclient/
 Author: Bob Weigel

{hapiclient-0.2.8 → hapiclient-0.3.0}/hapiclient.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ hapiclient.egg-info/SOURCES.txt
 hapiclient.egg-info/dependency_links.txt
 hapiclient.egg-info/requires.txt
 hapiclient.egg-info/top_level.txt
+test/test_cache.py
 test/test_chunking.py
 test/test_datetime2hapitime.py
 test/test_hapi_data_requests.py

{hapiclient-0.2.8 → hapiclient-0.3.0}/setup.py

@@ -32,7 +32,7 @@ if sys.argv[1] == 'develop':
 # version is modified by misc/version.py (executed from Makefile). Do not edit.
 setup(
     name='hapiclient',
-    version='0.2.8',
+    version='0.3.0',
     author='Bob Weigel',
     author_email='rweigel@gmu.edu',
     packages=find_packages(),

hapiclient-0.3.0/test/test_cache.py

@@ -0,0 +1,119 @@
+# See ../README.md for instructions on running tests.
+import shutil
+
+from hapiclient.hapi import hapi
+
+from util import compare
+
+from util.get_logger import get_logger
+logger = get_logger(__name__)
+
+kwargs = {
+    'cache': False,
+    'usecache': False,
+    'cachedir': '/tmp/hapi-data',
+    'logging': False
+}
+
+server = 'http://hapi-server.org/servers/TestData2.0/hapi'
+dataset = 'dataset1'
+start = '1970-01-01'
+stop  = '1970-01-01T00:00:03'
+
+def test_cache_short():
+
+    # Compare read with empty cache with read with hot cache and usecache=True
+
+    opts = {**kwargs, 'cache': True}
+
+    opts['usecache'] = False
+    shutil.rmtree(opts['cachedir'], ignore_errors=True)
+    data, _  = hapi(server, dataset, 'scalarint,vectorint', start, stop, **opts)
+
+    opts['usecache'] = True
+    data2, _  = hapi(server, dataset, 'scalarint,vectorint', start, stop, **opts)
+
+    assert compare.equal(data, data2)
+
+
+def test_cache_error():
+
+    from unittest.mock import patch
+
+    import io
+    import contextlib
+    import pathlib
+    import tempfile
+    from hapiclient.util import write_atomic
+
+    def assert_warns(fn, expected):
+        buf = io.StringIO()
+        with contextlib.redirect_stderr(buf):
+            result = fn()
+            print(buf.getvalue())
+        msg = f"Expected '{expected}' in stderr: {buf.getvalue()!r}"
+        assert expected in buf.getvalue(), msg
+        return result
+
+    # Direct calls to write_atomic()
+    with tempfile.TemporaryDirectory() as tmpdir:
+        path = pathlib.Path(tmpdir) / 'test.json'
+        data = {'key': 'value'}
+
+        def call_write_atomic():
+            write_atomic(str(path), data)
+
+        # Simulate write failure
+        with patch('json.dump', side_effect=OSError('No space left on device')):
+            assert_warns(call_write_atomic, 'Failed to write cache file')
+        assert not path.exists(), 'File should not exist after write failure'
+
+        # Simulate os.replace failure after successful write
+        with patch('os.replace', side_effect=OSError('Permission denied')):
+            assert_warns(call_write_atomic, 'Failed to rename cache file from')
+        assert not path.exists(), 'File should not exist after rename failure'
+
+        # Simulate write failure AND unlink failure
+        patch1 = patch('json.dump', side_effect=OSError('No space left on device'))
+        patch2 = patch('pathlib.Path.unlink', side_effect=OSError('Permission denied'))
+        with patch1, patch2:
+            assert_warns(call_write_atomic, 'Failed to remove temporary cache file')
+
+        # Simulate successful write
+        write_atomic(str(path), data)
+        assert path.exists(), 'File should exist after successful write'
+
+
+    # Indirect calls to write_atomic()
+    dataset = 'dataset1'
+    start = '1970-01-01'
+    stop  = '1970-01-01T00:00:03'
+
+    opts = {**kwargs, 'cache': True, 'usecache': False}
+
+    def call_hapi():
+        data, meta = hapi(server, dataset, 'scalarint,vectorint', start, stop, **opts)
+        return data, meta
+
+    def assert_data_valid(data):
+        msg = hapi(server, dataset, 'scalarint,vectorint', start, stop, **opts)
+        assert data['Time'][0] == b'1970-01-01T00:00:00.000Z', msg
+
+    with patch('pickle.dump', side_effect=OSError('No space left on device')):
+        data, _ = assert_warns(call_hapi, 'Failed to write cache file')
+    assert_data_valid(data)
+
+    with patch('os.replace', side_effect=OSError('Permission denied')):
+        data, _ = assert_warns(call_hapi, 'Failed to rename cache file from')
+    assert_data_valid(data)
+
+    p1 = patch('pickle.dump', side_effect=OSError('No space left on device'))
+    p2 = patch('pathlib.Path.unlink', side_effect=OSError('Permission denied'))
+    with p1, p2:
+        data, _ = assert_warns(call_hapi, 'Failed to remove temporary cache file')
+    assert_data_valid(data)
+
+
+if __name__ == '__main__':
+  test_cache_short()
+  test_cache_error()

{hapiclient-0.2.8 → hapiclient-0.3.0}/test/test_chunking.py

@@ -11,7 +11,7 @@ from util.get_logger import get_logger
 
 logger = get_logger(__name__)
 
-hapi_logging = True
+hapi_logging = False
 if logging.getLevelName(logger.level) == 'DEBUG':
     hapi_logging = True
 

{hapiclient-0.2.8 → hapiclient-0.3.0}/test/test_hapi_data_requests.py

@@ -97,25 +97,6 @@ def test_all_test_servers():
             pytest.fail("test_server('%s') raised: %s" % (version, e))
 
 
-def test_cache_short():
-
-    # Compare read with empty cache with read with hot cache and usecache=True
-    dataset = 'dataset1'
-    start = '1970-01-01'
-    stop  = '1970-01-01T00:00:03'
-
-    opts = {**kwargs, 'cache': True}
-
-    opts['usecache'] = False
-    shutil.rmtree(opts['cachedir'], ignore_errors=True)
-    data, meta  = hapi(server, dataset, 'scalarint,vectorint', start, stop, **opts)
-
-    opts['usecache'] = True
-    data2, meta2  = hapi(server, dataset, 'scalarint,vectorint', start, stop, **opts)
-
-    assert compare.equal(data, data2)
-
-
 def test_subset_short():
 
     dataset = 'dataset1'
@@ -213,12 +194,42 @@ def test_unicode():
             assert compare.cache(server, dataset, parameter, opts.copy(), logger=logger)
 
 
+def test_empty_response():
+    from hapiclient import hapi
+
+    server  = 'http://hapi-server.org/servers/TestData2.0/hapi'
+    dataset = 'dataset1'
+
+    # Time range with no data.
+    start   = '1970-01-01T00:00:00.1Z'
+    stop    = '1970-01-01T00:00:00.2Z'
+
+    _kwargs = kwargs.copy()
+    _kwargs['cache'] = False
+    _kwargs['usecache'] = False
+    data_csv, meta = hapi(server, dataset, '', start, stop, format='csv', **_kwargs)
+    data_bin, meta = hapi(server, dataset, '', start, stop, format='binary', **_kwargs)
+
+    assert len(data_csv) == 0
+    assert compare.equal(data_csv, data_bin)
+
+    for i in range(2):
+        _kwargs = kwargs.copy()
+        _kwargs['cache'] = True
+        _kwargs['usecache'] = True
+        data_csv, meta = hapi(server, dataset, '', start, stop, format='csv', **_kwargs)
+        data_bin, meta = hapi(server, dataset, '', start, stop, format='binary', **_kwargs)
+
+        assert len(data_csv) == 0
+        assert compare.equal(data_csv, data_bin)
+
+
 if __name__ == '__main__':
+    test_empty_response()
     test_subset_short()
     test_reader_timing_short()
     test_reader_timing_long()
     test_all_test_servers()
     test_subset_short()
-    test_cache_short()
     test_request2path()
     test_unicode()

{hapiclient-0.2.8 → hapiclient-0.3.0}/test/test_hapi_metadata_requests.py

@@ -2,7 +2,6 @@
 import os
 import json
 import pytest
-import logging
 
 from hapiclient.hapi import hapi
 
@@ -13,7 +12,7 @@ kwargs = {
     'cache': False,
     'usecache': False,
     'cachedir': '/tmp/hapi-data',
-    'logging': logger.getEffectiveLevel() >= logging.INFO
+    'logging': False
 }
 
 serverbad = 'http://hapi-server.org/servers/TestData/xhapi'

{hapiclient-0.2.8 → hapiclient-0.3.0}/test/test_hapitime2datetime.py

@@ -27,7 +27,7 @@ def test_api():
   ]
 
   for Time in times:
-    logger.info("  Testing hapitime2datetime(" + str(Time) + ")")
+    logger.debug("  Testing hapitime2datetime(" + str(Time) + ")")
     t = hapitime2datetime(Time)
     assert t[0].strftime("%Y-%m-%dT%H:%M:%S.%fZ") == expected
     _assert_utc(t[0])
@@ -35,7 +35,7 @@ def test_api():
 
 def test_parsing():
 
-  logger.info("test_parsing()")
+  logger.debug("test_parsing()")
 
   expected = '1989-01-01T00:00:00.000000Z'
 
@@ -76,7 +76,7 @@ def test_parsing():
   ]
 
   for i in range(len(dts)):
-    logger.info("  Testing hapitime2datetime('" + str(dts[i]) + "')")
+    logger.debug("  Testing hapitime2datetime('" + str(dts[i]) + "')")
     t = hapitime2datetime(dts[i])
     assert t[0].strftime("%Y-%m-%dT%H:%M:%S.%fZ") == expected
     _assert_utc(t[0])

{hapiclient-0.2.8 → hapiclient-0.3.0}/test/test_logging.py

@@ -12,8 +12,11 @@ stop       = '1970-01-01T00:01:00'
 def _reset_logger():
   """Remove all handlers and reset level on the hapiclient logger."""
   logger = logging.getLogger("hapiclient")
-  logger.handlers.clear()
+  for handler in list(logger.handlers):
+    logger.removeHandler(handler)
+    handler.close()
   logger.setLevel(logging.NOTSET)
+  logger.propagate = False
   if hasattr(logger, "_hapiclient_internal_level"):
     delattr(logger, "_hapiclient_internal_level")
 
@@ -87,30 +90,6 @@ class TestStandardLoggingConsole:
     assert 'Running hapi.py version' in output
 
 
-class TestStandardLoggingFile:
-  """Method 4: Standard logging with FileHandler."""
-
-  def setup_method(self):
-    _reset_logger()
-
-  def teardown_method(self):
-    _reset_logger()
-
-  def test_logs_to_file(self, tmp_path):
-    logfile = tmp_path / "hapiclient.log"
-    logger = logging.getLogger("hapiclient")
-    logger.setLevel(logging.INFO)
-    handler = logging.FileHandler(str(logfile))
-    handler.setFormatter(logging.Formatter("%(asctime)s %(message)s"))
-    logger.addHandler(handler)
-
-    data, meta = hapi(server, dataset, parameters, start, stop)
-    handler.close()
-
-    content = logfile.read_text()
-    assert 'Running hapi.py version' in content
-
-
 class TestLoggingKeywordFalse:
   """Default: logging=False suppresses INFO messages."""
 
@@ -129,9 +108,6 @@ class TestLoggingKeywordFalse:
 
 if __name__ == "__main__":
     import pytest
-    #pytest.main([__file__])
     pytest.main([__file__ + "::TestLoggingKeywordFalse", "-v"])
     pytest.main([__file__ + "::TestLoggingKeywordTrue", "-v"])
-    pytest.main([__file__ + "::TestLoggingKeywordFileObject", "-v"])
     pytest.main([__file__ + "::TestStandardLoggingConsole", "-v"])
-    pytest.main([__file__ + "::TestStandardLoggingFile", "-v"])