History

Unreleased

New features:

  • A CEF (Cluster Exchange Format) codec, built on CEFast: get_codec("cef") reads CEF 2.0 files, with their support axes (DEPEND_i), column names (LABEL_i or REPRESENTATION_i), units and fill values. CEF attributes are also given their ISTP names (DISPLAY_TYPE, VAR_TYPE, SI_conversion), so plots work as for CDF files.

  • CSA: the 1081 datasets the archive only serves as CEF are now listed and readable (auxiliary data, magnetic footprints, L-star, MAARBLE wave products…).

  • CSA: data is downloaded as CEF by default, about twice as fast as CDF, which CSA converts on each request. spz.config.csa.output_format or output_format="CDF_ISTP" on a request switches back to CDF for the datasets CSA serves as CDF. Each format keeps its own cache entries: data cached from CDF before is downloaded again as CEF. CSA requests skip proxies older than 0.27.0, whose speasy can’t take the format.

Bug fixes:

  • The name of a numpy result showed <built-in function input> for each plain argument: np.power(b, 2) was named power(b, <built-in function input>). It is now power(b, 2).

  • Slicing a variable by time:

    • var["2016-06-03":"2016-06-04"] silently returned the whole variable; strings now work, like in get_data;

    • a naive datetime was read in the computer’s local time zone, so in Paris var[datetime(2016, 6, 3):] started at 22:00 the day before. Naive datetimes are UTC, like everywhere else in Speasy;

    • any other kind of bound raises TypeError instead of being ignored.

  • CDPP 3DView: when its list of coordinate frames could not be fetched, get_data silently replaced the requested frame by J2000. With 3DView down but the proxy or the local cache still serving data, a GSE request could return J2000 positions. The requested frame is now always kept.

  • The HAPI writers (hapi/csv, hapi/binary) write headers that validate against the HAPI 3.2 schema:

    • a fill value is written as one number ("-1e+31", "NaN"), not as an array ("[-1e+31]"); a fill value no double can hold is dropped instead of aborting the write;

    • startDate/stopDate are always written. They default to the span of the records, and new start_date/stop_date arguments to save_variables set the dataset’s full range;

    • an empty variable is written as a “no data” (1201) response, which needs start_date/stop_date (or with_headers=False), instead of raising IndexError;

    • timestamps keep their microseconds or nanoseconds instead of being cut to milliseconds;

    • 64-bit integers too large for HAPI’s 32-bit integers are written as doubles instead of wrapping around;

    • hapi/csv writes missing values as NaN instead of an empty field;

    • single-column variables are written as scalars, without the ambiguous "size": [1];

    • empty units become null, bin units default to "dimensionless", and blank labels are left out; per-element units are written as one string when they all agree, as an array when they match a 1-D size, and are dropped otherwise, instead of crashing;

    • vectorComponents are only written in a shape HAPI accepts for the parameter;

    • dimensions bins can’t describe get "centers": null: ISTP vector components (text labels), so CDAWeb vectors can be written at all, and coordinate grids spanning several dimensions;

    • a time-varying axis spanning several dimensions is written with its full size instead of a header that disagrees with its data;

    • bins follow the order of the array’s dimensions, and the reader keeps a dimension without centers as an index axis so the following axes stay on their own dimension;

    • hapi/csv can write arrays with more than one dimension besides time;

    • hapi/csv can read back a header-only “no data” file;

    • bin centers containing NaN or infinity are written as null instead of invalid JSON;

    • the HAPI readers accept bins given only by their ranges, centered on each range.

  • CDAWeb with the default BEST (or FILE) access method passed on no cache option: prefer_cache, disable_cache and disable_proxy were ignored, whether the data came from the archive or from the web service fallback. prefer_cache=True now reaches the archive.

  • Direct archives (CDAWeb’s archive path included) honour prefer_cache for their folder listings too: once the 12 h listing cache had expired, every request listed the folders again, which fails offline. With an expired cache, a cached CDAWeb request now makes no network request at all, where it made one listing plus a HEAD request per file.

  • CSA works behind an HTTP proxy (HTTP_PROXY). It used to be disabled there because of an astroquery bug (astropy/astroquery#3228). Its inventory is now fetched with speasy’s own small TAP client (speasy.core.tap), so astroquery is no longer a dependency, along with the 14 packages only it pulled in. In the CSA inventory, empty fields are now None instead of ''.

New features:

  • get_data(..., force_refresh=True) downloads the data again even when the cache is up to date, and stores the result in the cache. It works with every provider, and always bypasses the proxy server.

  • speasy.DataIndex(path), a persistent data index (#122): a folder that keeps exactly the data a study used, never expires, and works offline. DataIndex.get_data downloads only what the index doesn’t hold yet; refresh=True and update_all_data() download it again on request. export_data and import_data hand an index to someone else as a single tar. It stores whatever speasy.get_data gives (time series, datasets, timetables, catalogs), and DataIndex.get_data takes the same arguments. Inside a with spz.DataIndex(path): block, plain spz.get_data goes through the index, so existing code becomes reproducible unchanged; it is back to normal when the block ends. The speasy index command fills (fill, with the same ranges as cache warm), inspects, exports and imports one.

  • numcodecs is now a dependency (except under Pyodide), so data from the community cache server always comes blosc compressed. The blosc extra is kept, empty, so speasy[blosc] still installs. speasy.core.proxy.blosc_arrays encodes numpy arrays in that same format, the inverse of unblosc_arrays.

  • CDAWeb parameters in the inventory carry their DEPEND_0, the name of their time variable, so parameters sharing a time axis can be told apart from the inventory alone.

  • Direct archives (and speasy.core.any_files) can read files from FTP servers: use an ftp:// URL in url_pattern or master_file. Folder listing (use_file_list, random splits) and the file cache work as for HTTP.

  • DataProvider.request_options(**kwargs), a classmethod, gives the get_data options that change the returned data, with their defaults filled in: the coordinate system for SSCWeb, the frame and sampling for CDPP 3DView, and the output format, restricted period and template inputs for AMDA. It works without starting the provider. speasy.core.dataprovider.provider_class(name) gives the class registered under a provider name or alias.

  • CDAWeb waveform datasets stored as buckets (PSP FIELDS burst, SolO RPW TDS and LFR, Van Allen Probes EMFISIS, TRACERS TS1/TS2 MSC, Voyager PWS) are served as flat time series with one timestamp per sample. SolO RPW LFR variables are split per sampling rate (<variable>_F0, _F1, _F2), and the SolO RPW waveform datasets missing from CDAWeb’s inventory are added to it.

1.9.1 (2026-10-06)

Bug fixes:

  • SpeasyVariable.clamp_with_nan() works on multi-component variables (e.g. amda/imf) instead of raising IndexError, and clamps each value on its own. A per-component VALIDMIN/VALIDMAX is applied per column, and an explicit valid_min=0 or valid_max=0 is no longer ignored.

  • SpeasyVariable.sanitized() no longer ignores an explicit valid_min=0 or valid_max=0, accepts per-component bounds as arrays, and filters with a single bound when only VALIDMIN or VALIDMAX is set.

  • A zero-lifetime cache entry is expired immediately by @jeandet in https://github.com/SciQLop/speasy/pull/397

  • Fix clamp_with_nan on multi-component variables by @Beforerr in https://github.com/SciQLop/speasy/pull/396

1.9.0 (2026-10-03)

Bug fixes:

  • New data appended to an AMDA dataset (e.g. ACE) now shows up. Before, a request reaching past the end of a dataset cached the missing part as empty, for good, because AMDA does not change a dataset’s version when it only appends data. Fragments past the end of a dataset’s coverage are now kept for one hour only. Empty AMDA fragments cached by Speasy 1.8.6 or older are fetched again once.

New features:

  • Data providers register themselves: a provider declares NAME / ALIASES on its class and decorates it with @register_provider. Adding one no longer means editing Speasy’s core. Packages can ship providers through a speasy.providers entry point.

  • dir() on speasy and on the inventories lists every enabled provider, started or not.

Behavior changes:

  • file is now a full alias of the archive provider: get_data("file/...") works, list_providers() includes it, and disabled_providers = file disables the archive.

  • speasy.amda and the other provider attributes are no longer copied into the module namespace at import. They always reflect the current provider, including after a successful update_inventories() retry. vars(speasy) no longer lists them.

  • Providers start on first use. import speasy no longer contacts any web service or builds any inventory. The first get_data(), speasy.amda or speasy.inventories.tree.cda access starts that provider, so it takes longer. SPEASY_SKIP_INIT_PROVIDERS now has no effect, and update_inventories() still starts every enabled provider.

  • list_providers() lists the enabled providers, started or not. A provider whose web service is down is still listed. Using it raises an error that says it failed to start and how to retry.

  • Code that walks speasy.inventories.tree.__dict__ (or vars()) only sees providers that have started. Use attribute access or dir(), which start providers as needed.

  • Initialize providers on first use when SPEASY_SKIP_INIT_PROVIDERS is set by @Beforerr in https://github.com/SciQLop/speasy/pull/389

  • Self-registering data providers and a speasy.providers entry point by @jeandet in https://github.com/SciQLop/speasy/pull/391

  • Start providers on first use by default by @jeandet in https://github.com/SciQLop/speasy/pull/393

1.8.6 (2026-10-01)

Bug fixes:

  • 3DView’s frame and body lists are now fetched with retries, like the rest of Speasy’s requests. A transient 502 from 3DView no longer breaks the inventory with a JSONDecodeError, and a lasting HTTP error is reported as Cdpp3dViewWebException.

Performance:

  • Reading data from the cache needs much less memory. A cached read used to peak at about 2.5x the size of the returned data; it now peaks at about 1.5x. Cached reads are also faster, because each fragment is copied fewer times.

  • speasy.products.variable.merge accepts any iterable of variables, and frees each one once it is copied into the result.

  • Retry transient errors when fetching 3DView frames and bodies by @jeandet in https://github.com/SciQLop/speasy/pull/386

  • Cut the memory peak of cached reads from 2.5x to 1.5x by @jeandet in https://github.com/SciQLop/speasy/pull/387

1.8.5 (2026-09-28)

Behavior changes:

  • Speasy now requires pysciqlop-cache 0.3 and pycdfpp 0.15. pycdfpp was only pulled in through pyistp before, which accepted any version from 0.6.

  • The data cache now stores values with pysciqlop-cache’s pickle-oob serializer. Existing caches switch over in place, nothing is cleared. Going back to pysciqlop-cache 0.2 afterwards is not supported: it can’t open such a cache, and Speasy then starts a fresh one.

  • On WebAssembly, Speasy needs Pyodide 314 or later: micropip then installs pycdfpp 0.15’s wasm wheel from PyPI. Pyodide 0.29 and older can’t install that wheel.

Performance:

  • Numpy arrays in cached variables are stored outside the pickle stream, copied without holding the GIL, and time axes are compressed: several threads reading or writing the cache no longer block each other, and the cache takes less disk.

  • Store variables with pysciqlop-cache’s pickle-oob serializer by @jeandet in https://github.com/SciQLop/speasy/pull/380

  • Parse CDAWeb master CDFs sequentially again by @jeandet in https://github.com/SciQLop/speasy/pull/382

1.8.4 (2026-09-25)

Bug fixes:

  • Inventory entries whose name contains # (e.g. AMDA’s “Earth flyby #2”) got an invalid attribute name and could not be reached through spz.inventories.tree. # is now replaced by _.

  • Fix ‘#’ symbol in inventory by @brenard-irap in https://github.com/SciQLop/speasy/pull/378

1.8.3 (2026-09-24)

Behavior changes:

  • Speasy now requires pysciqlop-cache 0.2.2. Existing caches are kept as they are; nothing is migrated. 0.2.2 raises OSError when a cache value can’t be written (full disk, quota), instead of silently dropping it.

New features:

  • AMDA private parameters: once your AMDA credentials are configured, parameters you can access through an AMDA private group appear under spz.inventories.tree.amda.PrivateParameters. They are cached like public data but never go through the proxy server. (https://github.com/SciQLop/speasy/pull/372)

Performance:

1.8.2 (2026-09-18)

Behavior changes:

  • An AMDA request longer than max_chunk_size_days is downloaded in several chunks. If one chunk failed quietly, the other chunks were returned as if complete and the hole was cached as empty fragments, served empty forever. Such a request now raises FailedChunkedRequest and nothing is cached.

  • Empty cache fragments written before 1.8.2 (previously: before 1.8.1) are no longer trusted and are refetched on read, since 1.8.1 could still write the empty fragments described above. Genuine empty ranges written by 1.8.2+ are kept.

  • pysciqlop-cache is now capped below 0.2 until Speasy has been verified against it.

Bug fixes:

  • speasy.cda.get_data(..., method='BEST') no longer crashes with AttributeError: 'DatasetIndex' object has no attribute 'filenaming' on datasets CDAWeb does not serve as a file archive (e.g. VOYAGER1_HELIO1HR_POSITION, the ..._LinkTo_..._sscweb ephemeris entries). These now fall back to the web service, as BEST is meant to.

Performance:

1.8.1 (2026-09-02)

Behavior changes:

  • Empty cache fragments (zero rows, or all-NaN/inf) written before 1.8.1 are no longer trusted: they are treated as a cache miss and refetched on read, then rewritten so they are trusted afterwards. This heals fragments that older Speasy cached empty – during upstream backfill latency, or from a request that ran past a product’s coverage – and then served empty indefinitely. Genuine empty ranges written by 1.8.1+ are kept. (https://github.com/SciQLop/speasy/pull/360)

  • AMDA/CSA requests no longer crash the whole call when the server is unreachable; the failure is now reported per-request instead. (https://github.com/SciQLop/speasy/pull/359)

  • Raised the minimum pysciqlop-cache version to 0.1.11. Below that version, running under a forked worker pool (e.g. gunicorn --preload) could make two different cache keys collide on the same file-backed blob path, since forked workers inherited the same Mersenne Twister RNG state used to generate those paths – the last writer would silently win, and a read could get back another product’s bytes. This only affects deployments that fork a shared cache after creating it; a normal single-process Speasy install was not exposed.

  • Don’t crash when AMDA/CSA server is unreachable by @jeandet in https://github.com/SciQLop/speasy/pull/359

  • Self-heal empty cache fossils via a per-entry epoch by @jeandet in https://github.com/SciQLop/speasy/pull/360

Dependency updates (dependabot):

1.8.0 (2026-08-31)

Behavior changes:

Dependency updates (dependabot):

New contributor: @RichardHitier (first contribution in https://github.com/SciQLop/speasy/pull/268)

1.7.1 (2025-12-25)

1.7.0 (2025-11-25)

1.6.1 (2025-09-05)

1.6.0 (2025-09-05)

1.5.2 (2025-06-03)

1.5.1 (2025-02-25)

1.5.0 (2025-02-25)

1.4.0 (2024-07-04)

1.3.2 (2024-06-18)

1.3.1 (2024-06-07)

1.3.0 (2024-06-26)

1.2.7 (2024-04-17)

1.2.6 (2024-04-17)

  • Emergency release because sscweb Json schema has changed by @jeandet

1.2.5 (2024-04-17)

1.2.4 (2024-03-12)

1.2.3 (2024-02-22)

1.2.2 (2023-11-28)

1.2.1 (2023-11-07)

1.2.0 (2023-10-31)

1.1.2 (2023-06-01)

1.1.1 (2023-04-06)

  • Fixes bug in v1.1.0 where AMDA CDF requests were not correctly written in cache.

1.1.0 (2023-04-06)

1.0.5 (2022-12-22)

1.0.4 (2022-12-05)

  • [AMDA] Fix broken user product detection

  • [AMDA] Add WS entry point in config

  • Add tolerance for network failures

  • Add option to disable webservices

  • Fix cache issue with some CDF files

1.0.3 (2022-10-18)

  • correct typo in README.rst

  • uses cache setting also when loading inventory from proxy

  • Matplotlib was accidentally working with DataContainer instead of Numpy array

  • Amda csv read hardening

  • also replace comma in dynamic inventory names

1.0.2 (2022-10-07)

  • fixes regression on CSA inventory

  • fixes rare issue on variable merge

1.0.1 (2022-10-06)

  • several documentation improvements

  • SpeasyVaraible can be sliced with numpy.datetime64

  • comparing SpeasyVaraible with NaNs works as expected now (ignore NaNs)

  • fixes cda inventory issue where some datasets were missing

  • speasy loading time reduction by only downloading inventory from proxy if it has changed

1.0.0 (2022-09-25)

This is the first stable release of Speasy, this means that some part of the API won’t change until next major release, they will only get bug fixes or backward compatible enhancements. Since last release, a lot of new features has landed:

  • now Speasy fully support AMDA, CDAWeb, SSCWeb and CSA web-services which represent around 55000 products.

  • for CSA and CDAWeb uses CDF file format thanks to pycdfpp and PyISTP speeds up download and allow 2D+ data handling

  • for each web-service Speasy provides an inventory of available products

  • for each web-service except SSCWeb, Speasy automatically discard outdated data from local cache

  • get_data function has evolved to accept many complex combination of products and time intervals

  • get_data function is now part of the stable API of Speasy

  • on disk cache loading algorithm has been improved and is now at least 10x faster

  • (unstable) plotting API is under heavy rework and will continue to evolve in next releases but already support spectrogram plots and handles as much as possible information such as axes label or units

  • by default Speasy proxy is enabled (for new fresh installs)

  • SpeasyVariable object has been rewritten to better handle ND data and provide nice slicing features

From now upcoming releases will mostly fix bugs, extend plotting API and follow web-services evolution.

0.10.0 (2022-02-03)

  • Adds support for all AMDA products, even private ones

  • Adds support for AMDA credentials

  • Adds dynamic inventory for AMDA and SSC

  • Adds possibility to set config values from ENV

  • Drops Python 3.6 support and adds 3.10

  • New API documentation using numpydoc

  • New user documentation using numpydoc

  • Most code examples are tested with doctest

  • Renames SSCWeb module get_orbit to get_trajectory

0.9.1 (2021-11-25)

0.9.0 (2021-07-29)

  • Adds SPWC migration tool

  • Rename SpwcVariable to SpeasyVariable

0.8.3 (2021-07-28)

  • Package renamed from SPWC to SPEASY

  • Some doc and CI improvements

0.8.2 (2021-04-20)

  • sscweb trajectories are always in km

0.8.1 (2021-04-18)

  • Fixes minimum request duration for sscweb

0.8.0 (2021-04-18)

  • Full support for trajectories and 0.2 proxy version

0.7.2 (2020-11-13)

  • ccsweb/proxy: Fix missing coordinate system parameter

0.7.1 (2020-11-13)

  • Fix project URL on PyPi

0.7.0 (2020-11-13)

  • SSCWEB support to get satellites trajectories.

  • Few bug fixes.

  • Totally disabled cdf support for now.

0.1.0 (2019-12-07)

  • First release on PyPI.