ASDCache 0.2.3__tar.gz → 0.2.4__tar.gz

{asdcache-0.2.3 → asdcache-0.2.4}/ASDCache/ASDCache.py

@@ -3,14 +3,16 @@
 It contains both the [SpectraCache][(m).] and [BibCache][(m).] classes which allow you to interact with the ASD and the relevant bibliographic databases.
 """
 
+from pathlib import Path
 import importlib.util
 import warnings
+import numpy as np
 import pandas as pd
-from requests_cache import CachedSession, Response
+from requests_cache import CachedSession, CachedResponse, OriginalResponse
+from requests import Response
 from io import StringIO
 from datetime import timedelta
 import re
-import numpy as np
 from bs4 import BeautifulSoup
 import sys
 import logging
@@ -23,12 +25,10 @@ if importlib.util.find_spec("polars"):
 else:
     POLARS_AVAILABLE = False
 
-logging.basicConfig(
-    level=logging.INFO,
-    format="[%(asctime)s] %(levelname)s [%(name)s.%(funcName)s:%(lineno)d] %(message)s",
-    datefmt="%d/%b/%Y %H:%M:%S",
-    stream=sys.stdout,
-)
+from .utils import wavenumber_to_refractive_index, extract_state_from_response
+from ._version import version
+
+logger = logging.getLogger("ASDCache")
 
 ASDSchema = {
     "element": str,
@@ -61,8 +61,6 @@ ASDSchema = {
     "line_ref": str,
 }
 
-STATE_EXPR = r"spectra=([\w]+)\+?([IVX]+)?"
-"""Regex pattern for extracting (element,charge) tuple for a single-state query, which uses roman numerals."""
 SCI_EXPR = r"([+-]?\d*\.?\d+(?:[eE][+-]?\d+)?)"
 """Regex pattern for processing scientific notation"""
 
@@ -76,9 +74,9 @@ class SpectraCache:
 
     The `ASDCache` instance acts as an access point to the cache, which stores responses on the local system in a SQLite database.
 
-    Data retrieval from cache is much faster (order milliseconds) than fetching from the internet (order seconds), and avoids wastefull requests to the server.
+    Data retrieval from cache is much faster (order milliseconds) than fetching from the internet (order of seconds to minutes), and avoids wastefull requests to the server.
 
-    Cache time-to-live is one week by default.
+    Cache time-to-live is two weeks by default.
 
     Since the NIST ASD is usually updated less frequently than that, this is a compromise between having the latest data, and overall fast performance.
 
@@ -91,12 +89,12 @@ class SpectraCache:
         "submit": "Retrieve Data",
         "unit": 1,
         "de": 0,
-        "plot_out": 0,
+        # "plot_out": 0,
         "I_scale_type": 1,
         "format": 3,
         "line_out": 0,
-        "remove_js": "on",
-        "no_spaces": "on",
+        # "remove_js": "on",
+        # "no_spaces": "on",
         "en_unit": 0,
         "output": 0,
         "bibrefs": 1,
@@ -124,48 +122,30 @@ class SpectraCache:
         # "include_Ritz_E1": 1, # Does not appear mandatory in retrospect,  see issue #1
     }
     """Request parameters used by the NIST ASD form."""
-    column_order = [
-        "element",
-        "sp_num",
-        "obs_wl_vac(nm)",
-        "unc_obs_wl",
-        "obs_wl_air(nm)",
-        "ritz_wl_vac(nm)",
-        "unc_ritz_wl",
-        "ritz_wl_air(nm)",
-        "wn(cm-1)",
-        "intens",
-        "Aki(s^-1)",
-        "fik",
-        "S(a.u.)",
-        "log_gf",
-        "Acc",
-        "Ei(cm-1)",
-        "Ek(cm-1)",
-        "conf_i",
-        "term_i",
-        "J_i",
-        "conf_k",
-        "term_k",
-        "J_k",
-        "g_i",
-        "g_k",
-        "Type",
-        "tp_ref",
-        "line_ref",
-    ]
-    """Fixed order of columns for consistent schema of data."""
-
-    def __init__(self, use_polars_backend=False, cache_expiry=timedelta(weeks=1), strict_matching=True):
-        """Initialize an instance that handles cached data lookup of the NIST ASD."""
+
+    def __init__(
+        self,
+        use_polars_backend=False,
+        cache_expiry=timedelta(weeks=2),
+        strict_matching=True,
+        cache_path: Optional[Path] = None,
+    ):
+        """Initialize an instance that handles cached data lookup of the NIST ASD.
+
+        Args:
+            use_polars_backend (bool): Flag to use polars as DataFrame backend, if available
+            cache_expiry (timedelta): Span of time beyond which an entry will be considered expired, and a refresh attempted
+            strict_matching (bool): If true, use all request parameters to hash urls for cache matching (recommended).
+            cache_path (Path, Optional): Path to a location to store the cache in
+        """
         self.strict_matching = strict_matching
         self.session = CachedSession(
-            "NIST_ASD_cache",
+            "NIST_ASD_cache" if cache_path is None else cache_path,
             use_cache_dir=True,
             expire_after=cache_expiry,
             stale_if_error=True,
             filter_fn=self._check_response_success,
-            ignored_parameters=list(self.query_params.keys()) if self.strict_matching is False else None,
+            ignored_parameters=list(self.query_params.keys()) if self.strict_matching is False else [],
         )
         if (use_polars_backend) & (not POLARS_AVAILABLE):
             warnings.warn("Cannot find `polars` as a backend, falling back to `pandas`", stacklevel=2)
@@ -209,9 +189,7 @@ class SpectraCache:
 
         Note that this only works for data queries, not for bibliographic metadata by `BibCache`.
         """
-        return not (
-            not response.ok or response.content.startswith(b"<!DOCTYPE") or b"Error Message" in response.content
-        )
+        return not (not response.ok or response.content.startswith(b"<!DOCTYPE"))
 
     def _get_data(self, species: str, wl_range: tuple[float, float] = (170, 1000), **kwargs) -> Response:
         """Retrieve raw, ASCII-formatted data from the NIST ASD with a GET request.
@@ -236,14 +214,17 @@ class SpectraCache:
         response.raise_for_status()
         # Check if response is not a HTML document instead of ASCII formatted data, indicating query error.
         if response.content.startswith(b"<!DOCTYPE"):
-            logging.error(
-                "NIST ASD responded with HTML instead of ASCII-data for species=%s, wl_range=%s\nQuery: %s",
+            body = BeautifulSoup(response.text, features="html.parser").body
+            reason = body.text.strip().replace("\n", " ") if body else ""
+            logger.error(
+                "NIST ASD responded with %s instead of ASCII-data for species=%s, wl_range=%s\nQuery: %s",
+                reason,
                 species,
                 wl_range,
                 response.url,
             )
             raise ASDQueryError(
-                f"Query for {species=} {wl_range=} did not receive ASCII-data. This means the ASD could not interpret your query. Check if your query is malformed."
+                f"Query for {species=} {wl_range=} did not receive ASCII-data. {reason=} This means the ASD could not interpret your query. Check if your query is malformed."
             )
         return response
 
@@ -260,7 +241,7 @@ class SpectraCache:
             for elem in self.species_expr.search(u).group(1).split("%3B")
         ]
 
-    def fetch(self, species, wl_range=(170, 1000), **kwargs) -> "pd.DataFrame|pl.DataFrame":
+    def fetch(self, species, wl_range=(170, 1000)) -> "pd.DataFrame|pl.DataFrame":
         """Fetch information on a species from the ASD, first checking the cache.
 
         This supports loading multiple species in one go by using the same notation as the NIST ASD form.
@@ -273,7 +254,8 @@ class SpectraCache:
 
         Both these operations will fetch data online and be stored as separate cache entries.
         """
-        response = self._get_data(species, wl_range, **kwargs)
+        # TODO: add kwargs for read-only/offline access etc.
+        response = self._get_data(species, wl_range)
         return self.create_dataframe(response)
 
     def create_dataframe(self, response) -> "pd.DataFrame|pl.DataFrame":
@@ -290,7 +272,7 @@ class SpectraCache:
 
         Note that this conversion is only performed for lines with $200 nm < \lambda < 2000 nm$, like the ASD.
 
-        For lines outside of this range, the conversion falls back to their vacuum wavelength.
+        For lines outside of this range, it uses NaN values.
         """
         schema = {
             "obs_wl_vac(nm)": str,
@@ -331,25 +313,25 @@ class SpectraCache:
         else:
             df["Type"] = df.loc[:, "Type"].astype(str).replace("nan", "E1")
         df["tp_ref"] = df.loc[:, "tp_ref"].fillna("")
-        df["obs_wl_air(nm)"] = df["obs_wl_vac(nm)"]
-        df["obs_wl_air(nm)"] = df[df["wn(cm-1)"].between(5000, 50000)]["obs_wl_air(nm)"] / cls.wn_to_n_refractive(
-            df[df["wn(cm-1)"].between(5000, 50000)]["wn(cm-1)"]
+        df["obs_wl_air(nm)"] = np.nan
+        air_equiv_range = df["wn(cm-1)"].between(5000, 50000)  # range where air wavelength is computed.
+        df["obs_wl_air(nm)"] = df.loc[air_equiv_range, "obs_wl_vac(nm)"] / wavenumber_to_refractive_index(
+            df.loc[air_equiv_range, "wn(cm-1)"]
         )
-        df["ritz_wl_air(nm)"] = df["ritz_wl_vac(nm)"]
-        df["ritz_wl_air(nm)"] = df[df["wn(cm-1)"].between(5000, 50000)]["ritz_wl_air(nm)"] / cls.wn_to_n_refractive(
-            df[df["wn(cm-1)"].between(5000, 50000)]["wn(cm-1)"]
+        df["ritz_wl_air(nm)"] = np.nan
+        df["ritz_wl_air(nm)"] = df.loc[air_equiv_range, "ritz_wl_vac(nm)"] / wavenumber_to_refractive_index(
+            df.loc[air_equiv_range, "wn(cm-1)"]
         )
         df = df.drop([c for c in df.columns if "Unnamed" in c], axis=1).reset_index(drop=True)
         if "element" not in df.columns:
             # cast roman numerals to int for consistency with queries with multiple ionization states, e.g. Ar I vs Ar I-II
             # As 'element' and 'sp_num' columns are only missing for single-species queries, assign as constants, not vectors.
-            element, numeral = re.search(STATE_EXPR, response.url).groups()
-            numeric: int = cls.roman_to_int(numeral)
+            element, numeric = extract_state_from_response(response)
             df["element"] = element
             df["sp_num"] = numeric
         df["unc_obs_wl"] = pd.to_numeric(df["unc_obs_wl"]) if "unc_obs_wl" in df.columns else np.nan
         df["unc_ritz_wl"] = pd.to_numeric(df["unc_ritz_wl"]) if "unc_ritz_wl" in df.columns else np.nan
-        return df.loc[:, cls.column_order]
+        return df.loc[:, list(ASDSchema)]
 
     @classmethod
     def _from_polars(cls, response: Response) -> "pl.DataFrame":
@@ -359,7 +341,7 @@ class SpectraCache:
 
         Note that this conversion is only performed for lines with $200 nm < \lambda < 2000 nm$, like the ASD.
 
-        For lines outside of this range, the conversion falls back to their vacuum wavelength.
+        For lines outside of this range, it uses NaN values.
         """
         schema = {
             "obs_wl_vac(nm)": pl.String,
@@ -401,67 +383,27 @@ class SpectraCache:
             pl.col("tp_ref").replace(None, ""),
         ).drop([""])
         # compute air wavelengths between 5000 cm-1 and 50000 cm-1
+        air_equiv_range = pl.col("wn(cm-1)").is_between(5000, 50000)
         df = df.with_columns(
-            pl.when(pl.col("wn(cm-1)").is_between(5000, 50000))
-            .then(
-                pl.col("obs_wl_vac(nm)").cast(pl.Float64)
-                / pl.col("wn(cm-1)").map_elements(cls.wn_to_n_refractive, return_dtype=pl.Float64)
-            )
-            .otherwise(pl.col("obs_wl_vac(nm)"))
-            .cast(pl.Float64)
+            pl.when(air_equiv_range)
+            .then(pl.col("obs_wl_vac(nm)") / wavenumber_to_refractive_index(pl.col("wn(cm-1)")))
+            .otherwise(np.nan)
             .alias("obs_wl_air(nm)"),
-            pl.when(pl.col("wn(cm-1)").is_between(5000, 50000))
-            .then(
-                pl.col("ritz_wl_vac(nm)").cast(pl.Float64)
-                / pl.col("wn(cm-1)").map_elements(cls.wn_to_n_refractive, return_dtype=pl.Float64)
-            )
-            .otherwise(pl.col("ritz_wl_vac(nm)"))
-            .cast(pl.Float64)
+            pl.when(air_equiv_range)
+            .then(pl.col("ritz_wl_vac(nm)") / wavenumber_to_refractive_index(pl.col("wn(cm-1)")))
+            .otherwise(np.nan)
             .alias("ritz_wl_air(nm)"),
         )
         if "element" not in df.columns:
-            element, numeral = re.search(STATE_EXPR, response.url).groups()
-            numeric: int = cls.roman_to_int(numeral) if numeral else 1
-            # cast roman numerals to int for consistency with queries with multiple ionization states, e.g. Ar I vs Ar I-II
+            element, numeric = extract_state_from_response(response)
             df = df.with_columns(pl.lit(element).alias("element"), pl.lit(numeric, dtype=pl.Int64).alias("sp_num"))
-        exprs = [pl.col(c).cast(pl.Float64) for c in ["unc_obs_wl", "unc_ritz_wl"] if c in df.columns]
+        # Cast to float, or create column filled with `null` if missing.
+        exprs = [
+            (pl.col(c) if c in df.columns else pl.lit(None).alias(c)).cast(pl.Float64)
+            for c in ["unc_obs_wl", "unc_ritz_wl"]
+        ]
         df = df.with_columns(exprs)
-        return df.select(*cls.column_order)
-
-    @staticmethod
-    def roman_to_int(roman: str) -> int:
-        """Transform Roman numerals to integers.
-
-        Does only support numerals including up to `L`.
-        """
-        roman_numerals = {"I": 1, "V": 5, "X": 10, "L": 50}
-        total = 0
-        previous = 0
-        for char in reversed(roman):
-            current_value = roman_numerals[char]
-            if current_value < previous:
-                total -= current_value  # Subtract if the current value is less than the previous value
-            else:
-                total += current_value
-            previous = current_value
-        return total
-
-    @staticmethod
-    def wn_to_n_refractive(wavenumbers: float) -> float:
-        r"""Calculate the refractive index $n$ in air for a transition, using the 5-term Sellmeier formula used by NIST.
-
-        The used Sellmeier formula is the one from E.R. Peck and K. Reeder [J. Opt. Soc. Am. 62, 958 (1972)](http://dx.doi.org/10.1364/JOSA.62.000958).
-
-        This formula is fitted to data in the range of 185 nm to 1700 nm for  air at 15 °C, 101 325 Pa pressure, with 0.033 % CO2.
-
-        This is the same formula used by the NIST ASD to calculate air wavelengths in the interval of 200 nm to 2000 nm.
-
-        See also [the ASD documentation on the topic](https://physics.nist.gov/PhysRefData/ASD/Html/lineshelp.html#Conversion%20between%20air%20and%20vacuum%20wavelengths).
-
-        Using this refractive index, air equivalent wavelengths consistent with the ASD can be calculated, without the need to query them separately.
-        """
-        sigma = wavenumbers * 1e-4  # um^-1
-        return 1 + 1e-8 * (8060.51 + 2480990 / (132.274 - sigma**2) + 17455.7 / (39.32957 - sigma**2))
+        return df.select(*ASDSchema)
 
     def get_all_cached(self) -> "pd.DataFrame|pl.DataFrame":
         """Retrieve all cached data into a single dataframe."""
@@ -530,7 +472,7 @@ class BibCache:
         """
         is_success = (response.status_code == 200) & (b"There was a problem" not in response.content)
         if not is_success:
-            logging.warning(f"Request was unsuccesful status:{response.status_code} , url:{response.url}")
+            logger.warning(f"Request was unsuccesful status:{response.status_code} , url:{response.url}")
         return is_success
 
     @classmethod
@@ -546,9 +488,10 @@ class BibCache:
             comment (str):   An additional comment included in the reference, can be fetched separately.
         """
         if reference_code.startswith("n"):
-            db, ref, comment = "T", None, "n"
-        elif (not reference_code.startswith("LS")) & (cls.reference_expr.match(reference_code) is not None):
-            db, ref, comment = cls.reference_expr.match(reference_code).groups()
+            return ("T", None, "n")
+        matched = cls.reference_expr.match(reference_code)
+        if (not reference_code.startswith("LS")) and (matched is not None):
+            db, ref, comment = matched.groups()
             comment = comment if "LS" not in reference_code else "LS"
         else:
             db, ref, comment = "T", None, "LS"

{asdcache-0.2.3 → asdcache-0.2.4}/ASDCache/__init__.py

@@ -1,6 +1,6 @@
-r"""`ASDcache` is a package to fetch data from the  NIST Atomic Spectra Database (ASD), utlizing caching for fast responses.
+r"""`ASDCache` is a package to fetch data from the  NIST Atomic Spectra Database (ASD), utlizing caching for fast responses.
 
-To make the most use out of the cache, `ASDcache` is opinionated in the information it retrieves from the ASD; it always requests the same schema of information and locally computes additional fields.
+To make the most use out of the cache, `ASDCache` is opinionated in the information it retrieves from the ASD; it always requests the same schema of information and locally computes additional fields.
 
 Data is initially fetched from the online published NIST page, using the tab-separated ASCII output format.
 
@@ -13,12 +13,12 @@ To ensure a consistent schema of the retrieved data, lines are always retrieved
 
 Wavenumbers and Ritz wavelength will be included in the response.
 
-In the range $5000\ \mathrm{cm}^{-1}<\nu<50000\ \mathrm{cm}^{-1}$ the air equivalent observed and Ritz wavelengths are calculated using the same Sellmeier equation as the NIST ASD (see [here][.SpectraCache.wn_to_n_refractive]).
+In the range $5000\ \mathrm{cm}^{-1}<\nu<50000\ \mathrm{cm}^{-1}$ the air equivalent observed and Ritz wavelengths are calculated using the same Sellmeier equation as the NIST ASD (see [here][.utils.wavenumber_to_refractive_index]).
 This is consistent with the approach of the ASD.
 
 ## Making use of the cache
 
-Each response from the NIST page is cached (1 week by default) on the local system.
+Each response from the NIST page is cached (2 weeks by default) on the local system.
 
 This makes it much faster to load the same data, even across different script runs and/or user programs/sessions.
 

{asdcache-0.2.3 → asdcache-0.2.4}/ASDCache/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.3'
-__version_tuple__ = version_tuple = (0, 2, 3)
+__version__ = version = '0.2.4'
+__version_tuple__ = version_tuple = (0, 2, 4)
 
 __commit_id__ = commit_id = None

asdcache-0.2.4/ASDCache/utils.py

@@ -0,0 +1,66 @@
+"""Module containing small helper utility functions for extracting and processing input from the ASD."""
+
+import re
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from requests import Response
+
+ROMAN_NUMERALS = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000}
+STATE_EXPR = r"spectra=([\w]+)\+?([IVX]+)?"
+"""Regex pattern for extracting (element,charge) tuple for a single-state query, which uses roman numerals."""
+
+
+def roman_to_int(roman: str) -> int:
+    """Parse a Roman numeral into an integer.
+
+    Supports numerals up to "M".
+    """
+    roman = roman.upper().strip()
+    total = 0
+    previous = 0
+    for char in reversed(roman):
+        current_value = ROMAN_NUMERALS[char]
+        if current_value < previous:
+            total -= current_value  # Subtract if the current value is less than the previous value
+        else:
+            total += current_value
+        previous = current_value
+    return total
+
+
+def wavenumber_to_refractive_index(wavenumbers: float) -> float:
+    r"""Calculate the refractive index $n$ in air for a transition, using the 5-term Sellmeier formula used by NIST.
+
+    The used Sellmeier formula is the one from E.R. Peck and K. Reeder [J. Opt. Soc. Am. 62, 958 (1972)](http://dx.doi.org/10.1364/JOSA.62.000958).
+
+    This formula is fitted to data in the range of 185 nm to 1700 nm for  air at 15 °C, 101 325 Pa pressure, with 0.033 % CO2.
+
+    This is the same formula used by the NIST ASD to calculate air wavelengths in the interval of 200 nm to 2000 nm.
+
+    See also [the ASD documentation on the topic](https://physics.nist.gov/PhysRefData/ASD/Html/lineshelp.html#Conversion%20between%20air%20and%20vacuum%20wavelengths).
+
+    Using this refractive index, air equivalent wavelengths consistent with the ASD can be calculated, without the need to query them separately.
+    """
+    sigma = wavenumbers * 1e-4  # um^-1
+    return 1 + 1e-8 * (8060.51 + 2480990 / (132.274 - sigma**2) + 17455.7 / (39.32957 - sigma**2))
+
+
+def extract_state_from_response(response: "Response") -> tuple[str, int]:
+    """Extract the element and ionization state from the url of a response.
+
+    When querying only a single state, e.g. 'H I', this information will not be present as a column in data: the `element` and `sp_num` columns will not be included.
+
+    This information is parsed from the query url instead, so it can be added.
+
+    Since the `sp_num` column is of an integer type, the roman numerals in the url are converted to integers.
+    """
+    matched = re.search(STATE_EXPR, str(response.url))
+    if not matched:
+        raise ValueError(
+            "URL did not contain a `spectra` parameter satisfying %s; Could not identify element and sp_num",
+            STATE_EXPR,
+        )
+    element, numeral = matched.groups()
+    numeric: int = roman_to_int(numeral) if numeral else 1
+    return element, numeric

{asdcache-0.2.3 → asdcache-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ASDCache
-Version: 0.2.3
+Version: 0.2.4
 Summary: A Python module to retrieve data from the NIST Atomic Spectra Database (ASD), using caching for fast, efficient data handling
 Project-URL: Documentation, https://antoinetue.github.io/asdcache
 Project-URL: Source, https://github.com/AntoineTUE/asdcache
@@ -12,14 +12,16 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.9
 Requires-Dist: beautifulsoup4>=4.12
-Requires-Dist: numpy>=2.0
+Requires-Dist: numpy>=1.20.3
 Requires-Dist: pandas>=2.0
 Requires-Dist: requests-cache>=1.2.0
 Provides-Extra: docs
@@ -37,8 +39,8 @@ Requires-Dist: pygments>=2.20.0; extra == 'docs'
 Requires-Dist: ruff>=0.15.13; extra == 'docs'
 Provides-Extra: polars
 Requires-Dist: polars[pandas]; extra == 'polars'
-Provides-Extra: polars-lts
-Requires-Dist: polars[pandas,rtcompat]; extra == 'polars-lts'
+Provides-Extra: polars-compat
+Requires-Dist: polars[pandas,rtcompat]; extra == 'polars-compat'
 Description-Content-Type: text/markdown
 
 # ASDCache
@@ -52,6 +54,7 @@ Description-Content-Type: text/markdown
 [![PyPI - Version](https://img.shields.io/pypi/v/ASDCache)](https://pypi.python.org/pypi/ASDCache)
 [![PyPI - Python versions](https://img.shields.io/pypi/pyversions/ASDCache.svg)](https://pypi.python.org/pypi/ASDCache)
 [![PyPI - Downloads](https://img.shields.io/pypi/dm/ASDCache)](https://pypistats.org/packages/asdcache)
+[![Pepy Total Downloads](https://img.shields.io/pepy/dt/asdcache)](https://pepy.tech/projects/asdcache)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
 
@@ -69,7 +72,7 @@ The main goals and benefits of `ASDCache` are:
 - [x] Retrieve a consistent schema of the data that represents the 'human readable' format, but enforce strictly numeric data for important columns
     - [ ] This removes footnotes and other annotations, be sure to check the ASD itself as well for this information.
 - [x]  Use caching to dramatically speed up data retrieval, from minutes down to milliseconds in some cases
-    - [x] Cache time-to-live is 1 week by default, meaning you still get updates to the ASD in a reasonable time frame
+    - [x] Cache time-to-live is two weeks by default, meaning you still get updates to the ASD in a reasonable time frame
     - [x] The cache time-to-live can be adjusted
 - [x]  Cache data to allow working offline, or even transfering the ASD data to an offline system.
     - [x] The cache is only updated when a request for new data succeeds
@@ -78,6 +81,7 @@ The main goals and benefits of `ASDCache` are:
 `ASDCache` is not affiliated with NIST or the NIST ASD in any way, it simply tries to help make it more accessible.
 
 ## Installing
+
 `ASDCache` can be installed with `pip`.
 
 ```console
@@ -99,6 +103,7 @@ Installing the `polars` feature is not required, in case `polars` is already ins
 Documentation for `ASDCache` is available on [this page](https://antoinetue.github.io/ASDCache).
 
 ### Example
+
 A brief example below demonstrates how to use `SpectraCache` to query the NIST ASD for spectroscopic data for different species and plot their respective relative intensities.
 
 Note that these relative intensities are in principle not comparable between different species or sources and merely serve as a guide.

{asdcache-0.2.3 → asdcache-0.2.4}/pyproject.toml

@@ -19,17 +19,19 @@ classifiers = [
     "Topic :: Scientific/Engineering",
     "Intended Audience :: Science/Research",
     "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
-dependencies = ["requests_cache>=1.2.0", "pandas>=2.0","numpy>=2.0", "beautifulsoup4>=4.12"]
+dependencies = ["requests_cache>=1.2.0", "pandas>=2.0","numpy>=1.20.3", "beautifulsoup4>=4.12"]
 dynamic = ["version"]
 
 [project.optional-dependencies]
 polars = ["polars[pandas]"]
-polars-lts = ["polars[rtcompat,pandas]"]
+polars-compat = ["polars[rtcompat,pandas]"]
 docs = [
     "properdocs>=1.6.7",
     "mkdocs-material==9.7.6",
@@ -69,7 +71,7 @@ exclude = ["/.github"]
 minversion = "6.0"
 addopts = "-ra -q --doctest-glob='*.md'"
 testpaths = ["tests"]
-markers = ["full: test using the full NIST ASD"]
+markers = ["online: run test that retrieve data online from the ASD"]
 
 [tool.coverage.run]
 branch = true
@@ -158,7 +160,6 @@ dependencies = [
     "pytest-recording",
     "pytest-sugar~=1.1.1",
     "hypothesis",
-    'virtualenv<21; python_version<"3.10"',
 ]
 
 
@@ -191,22 +192,32 @@ fix = [
 
 [tool.hatch.envs.hatch-test.overrides]
 matrix.pandas.dependencies = [
-    { value = "pandas>=2.0.0", if = ["pandas-2.0"] },
-    { value = "numpy>=2.0", if = ["pandas-2.0"] },
-    { value = "pandas>=3.0.0", if = ["pandas-3.0"] },
-    { value = "numpy>=2.0", if = ["pandas-3.0"] },
+    { value = "pandas>=2.0", if = ["pandas-2.x"] },
+    { value = "pandas>=3.0", if = ["pandas-3.x"] },
+]
+matrix.numpy.dependencies = [
+    { value = "numpy>=2.0", if = ["numpy-2.x"] },
+    {value = "numpy<2.0", if =  ["numpy-legacy"]},
 ]
 matrix.polars.features = [
     { value = "polars", if = ["polars"]},
-    { value = "polars-lts", if = ["polars-lts"]},
+    { value = "polars-compat", if = ["polars-compat"]},
 ]
 
 [[tool.hatch.envs.hatch-test.matrix]]
 python = ["3.9","3.10"]
-pandas = ["pandas-2.0"]
-polars = ["polars","polars-lts"]
+numpy = ["numpy-2.x","numpy-legacy"]
+pandas = ["pandas-2.x"]
+polars = ["polars","polars-compat"]
+
+[[tool.hatch.envs.hatch-test.matrix]]
+python = ["3.11","3.12","3.13", "3.14"]
+numpy = ["numpy-2.x","numpy-legacy"]
+pandas = ["pandas-2.x","pandas-3.x"]
+polars = ["polars","polars-compat"]
 
 [[tool.hatch.envs.hatch-test.matrix]]
-python = ["3.11","3.12","3.13"]
-pandas = ["pandas-2.0","pandas-3.0"]
-polars = ["polars","polars-lts"]
+python = ["3.13", "3.14"]
+numpy = ["numpy-2.x"]
+pandas = ["pandas-2.x","pandas-3.x"]
+polars = ["polars","polars-compat"]