python-aqi 1.0.0__py3-none-any.whl

aqi/__init__.py

@@ -0,0 +1,248 @@
+from aqi.algos import available_algos, get_algo, list_algos
+from aqi.constants import (
+    ALGO_EPA,
+    ALGO_EPA_2012,
+    ALGO_EPA_2015,
+    ALGO_EPA_2024,
+    ALGO_MEP,
+    ALGO_MEP_2012,
+    ALGO_MEP_2026,
+    POLLUTANT_CO_1H,
+    POLLUTANT_CO_8H,
+    POLLUTANT_CO_24H,
+    POLLUTANT_NO2_1H,
+    POLLUTANT_NO2_24H,
+    POLLUTANT_O3_1H,
+    POLLUTANT_O3_8H,
+    POLLUTANT_PM10,
+    POLLUTANT_PM25,
+    POLLUTANT_SO2_1H,
+    POLLUTANT_SO2_24H,
+)
+from aqi.exceptions import NotApplicableError, OutOfRangeError
+
+__author__ = 'Stefan "hr" Berder'
+__contact__ = "hr@bonz.org"
+__license__ = "BSD 3-Clause"
+__version__ = "1.0.0"
+
+# the pollutant and algorithm constants are part of the public API
+__all__ = [
+    "ALGO_EPA",
+    "ALGO_EPA_2012",
+    "ALGO_EPA_2015",
+    "ALGO_EPA_2024",
+    "ALGO_MEP",
+    "ALGO_MEP_2012",
+    "ALGO_MEP_2026",
+    "NotApplicableError",
+    "OutOfRangeError",
+    "POLLUTANT_CO_1H",
+    "POLLUTANT_CO_8H",
+    "POLLUTANT_CO_24H",
+    "POLLUTANT_NO2_1H",
+    "POLLUTANT_NO2_24H",
+    "POLLUTANT_O3_1H",
+    "POLLUTANT_O3_8H",
+    "POLLUTANT_PM10",
+    "POLLUTANT_PM25",
+    "POLLUTANT_SO2_1H",
+    "POLLUTANT_SO2_24H",
+    "available_algos",
+    "console_aqi",
+    "get_algo",
+    "list_algos",
+    "to_aqi",
+    "to_cc",
+    "to_iaqi",
+]
+
+
+def _load_algo(algo):
+    _aqi = get_algo(algo)
+    if _aqi is None:
+        raise ValueError(
+            f"Unknown algorithm {algo!r}, available: {', '.join(available_algos())}"
+        )
+    return _aqi
+
+
+def to_iaqi(elem, cc, algo=ALGO_EPA, extrapolate=False):
+    """Calculate an intermediate AQI for a given pollutant. This is the
+    heart of the algo.
+
+    .. warning:: the concentration is passed as a string so
+        :class:`decimal.Decimal` doesn't act up with binary floats.
+
+    :param elem: pollutant constant
+    :type elem: int
+    :param cc: pollutant concentration (µg/m³ or ppm)
+    :type cc: str
+    :param algo: algorithm, ``'epa'`` for the latest version of a family,
+                 ``'epa:2012'`` for a given version, or a module name like
+                 ``'aqi.algos.epa'`` (latest version)
+    :type algo: str
+    :param extrapolate: compute values beyond the scale when the standard
+                        describes how (EPA "Beyond the AQI")
+    :type extrapolate: bool
+    :raises OutOfRangeError: the concentration is not covered by the algorithm
+    """
+    _aqi = _load_algo(algo)
+    return _aqi.iaqi(elem, cc, extrapolate=extrapolate)
+
+
+def to_aqi(ccs, algo=ALGO_EPA, extrapolate=False):
+    """Calculate the AQI based on a list of pollutants
+
+    :param ccs: a list of tuples of pollutants concentrations with
+                pollutant constant and concentration as values
+    :type ccs: list
+    :param algo: algorithm, see :func:`to_iaqi`
+    :type algo: str
+    :param extrapolate: see :func:`to_iaqi`
+    :type extrapolate: bool
+    :raises OutOfRangeError: a concentration is not covered by the algorithm
+    """
+    _aqi = _load_algo(algo)
+    return _aqi.aqi(ccs, extrapolate=extrapolate)
+
+
+def to_cc(elem, iaqi, algo=ALGO_EPA, extrapolate=False):
+    """Calculate a concentration for a given pollutant.
+
+    .. warning:: the intermediate AQI is passed as a string
+
+    :param elem: pollutant constant
+    :type elem: int
+    :param iaqi: intermediate AQI
+    :type iaqi: str
+    :param algo: algorithm, ``'epa'`` for the latest version of a family,
+                 ``'epa:2012'`` for a given version, or a module name like
+                 ``'aqi.algos.epa'`` (latest version)
+    :type algo: str
+    :param extrapolate: see :func:`to_iaqi`
+    :type extrapolate: bool
+    :raises OutOfRangeError: the AQI value is not covered by the algorithm
+    """
+    _aqi = _load_algo(algo)
+    return _aqi.cc(elem, iaqi, extrapolate=extrapolate)
+
+
+def console_aqi():
+    """Console entry point, this function is used as an entry point to
+    the 'aqi' command.
+    """
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(
+        description="""Convert between AQI value and pollutant concentration (µg/m³ or
+    ppm)."""
+    )
+    parser.add_argument(
+        "-c",
+        dest="conv",
+        choices=["aqi", "cc"],
+        default="aqi",
+        help="Conversion to perform, defaults to 'aqi'",
+    )
+    parser.add_argument(
+        "-l",
+        action="store_true",
+        dest="list",
+        help="list the available algorithm versions and corresponding pollutants",
+    )
+    parser.add_argument(
+        "-v", action="store_true", dest="verbose", help="add IAQIs to the result"
+    )
+    parser.add_argument(
+        "-e",
+        action="store_true",
+        dest="extrapolate",
+        help="compute values beyond the AQI scale when the standard allows it "
+        "(EPA 'Beyond the AQI'), otherwise out of range values are an error",
+    )
+    parser.add_argument(
+        "algo",
+        nargs="?",
+        help="the formula to use for the AQI calculation: a family and version "
+        "like 'epa:2012', a family like 'epa' for its latest version, or the "
+        "python module path",
+    )
+    parser.add_argument(
+        "measures",
+        nargs="*",
+        metavar="measure",
+        help="pollutant measure, format is "
+        "element_name:concentration. Unknown "
+        "pollutants are silently ignored.",
+    )
+    args = parser.parse_args()
+
+    # list available algorithms
+    if args.list is True:
+        latest = {}
+        for name in available_algos():
+            latest[name.split(":")[0]] = name
+        for name, pollutants in list_algos():
+            elems = ", ".join(f"{elem} ({unit})" for elem, unit in pollutants)
+            note = " (latest)" if name in latest.values() else ""
+            print(f"{name}{note}: {elems}")
+    else:
+        # if not listing but missing other positional argument
+        if args.algo is None or args.measures is None:
+            sys.stderr.write("Missing algorithm or measure.\n")
+            parser.print_help()
+            sys.exit(1)
+        _aqi = get_algo(args.algo)
+        # couln't load the algo module or instanciate AQI class
+        if _aqi is None:
+            sys.stderr.write("Unknown algorithm or module is missing an AQI class\n")
+            parser.print_help()
+            sys.exit(1)
+        try:
+            if args.conv == "aqi":
+                ccs = []
+                for measure in args.measures:
+                    (elem, cc) = measure.split(":")
+                    ccs.append((elem, cc))
+
+                ret = _aqi.aqi(ccs, iaqis=args.verbose, extrapolate=args.extrapolate)
+                if args.verbose is True:
+                    iaqis = []
+                    for constant, iaqi in ret[1].items():
+                        iaqis.append(constant + ":" + str(iaqi))
+                    sys.stdout.write(" ".join(iaqis) + "\n")
+                    sys.stdout.write(str(ret[0]) + "\n")
+                else:
+                    sys.stdout.write(str(ret) + "\n")
+            else:
+                iaqis = []
+                for measure in args.measures:
+                    (elem, iaqi) = measure.split(":")
+                    iaqis.append((elem, iaqi))
+
+                ret = []
+                for iaqi in iaqis:
+                    ret.append(
+                        (
+                            iaqi[0],
+                            _aqi.cc(iaqi[0], iaqi[1], extrapolate=args.extrapolate),
+                        )
+                    )
+                if len(ret) == 1:
+                    sys.stdout.write(str(ret[0][1]) + "\n")
+                elif len(ret) > 1:
+                    ccs = []
+                    for elem, cc in ret:
+                        if cc is None:
+                            ccs.append(elem + ":na")
+                        else:
+                            ccs.append(elem + ":" + str(cc))
+                    sys.stdout.write("\n".join(ccs) + "\n")
+        except OutOfRangeError as err:
+            sys.stderr.write(f"Out of range: {err}\n")
+            sys.exit(3)
+
+    # end the script without a problem
+    sys.exit(0)

aqi/algos/__init__.py

@@ -0,0 +1,62 @@
+import importlib
+
+# algorithm families and the module holding their versions, each module has
+# a ``VERSIONS`` dict (oldest first) and an ``AQI`` class, the latest version
+FAMILIES = {
+    "epa": "aqi.algos.epa",
+    "mep": "aqi.algos.mep",
+}
+
+
+def _versions(family):
+    return importlib.import_module(FAMILIES[family]).VERSIONS
+
+
+def available_algos():
+    """Return the names of all the algorithm versions, as ``family:version``
+    strings, ordered by family and then from the oldest to the latest version.
+    """
+    return [
+        f"{family}:{version}" for family in FAMILIES for version in _versions(family)
+    ]
+
+
+def get_algo(algo):
+    """Instanciate an AQI algorithm class. If the algorithm is unknown or
+    there is a problem during the import or instanciation, return None.
+
+    :param algo: one of
+
+        * a ``family:version`` string like ``'epa:2012'``
+        * a family name like ``'epa'``, the latest version
+        * a module canonical name like ``'aqi.algos.epa'``, the latest
+          version of the module (this is how algorithms were always named)
+    :type algo: str
+    """
+    family, sep, version = algo.partition(":")
+    if family in FAMILIES:
+        versions = _versions(family)
+        if not sep:
+            return versions[list(versions)[-1]]()
+        if version in versions:
+            return versions[version]()
+        return None
+    if sep:
+        return None
+
+    # a module path
+    try:
+        mod = importlib.import_module(algo)
+    except (ImportError, ValueError):
+        return None
+    try:
+        return mod.AQI()
+    except AttributeError:
+        return None
+
+
+def list_algos():
+    """Return a list of tuples with the name of each available algorithm
+    version and its corresponding pollutants
+    """
+    return [(name, get_algo(name).list_pollutants()) for name in available_algos()]

aqi/algos/base.py

@@ -0,0 +1,242 @@
+import math
+from decimal import (
+    ROUND_CEILING,
+    ROUND_DOWN,
+    ROUND_HALF_EVEN,
+    Decimal,
+    localcontext,
+)
+from fractions import Fraction
+
+from aqi.exceptions import NotApplicableError, OutOfRangeError
+
+
+def derive_piecewise(parent, bp=None, prec=None, units=None, aqi=None):
+    """Build the ``piecewise`` table of a new version of a standard from the
+    previous one, only the given parts are replaced.
+
+    :param parent: the ``piecewise`` dict of the previous version
+    :param bp: breakpoints by pollutant to replace or add
+    :param prec: precisions by pollutant to replace or add
+    :param units: units by pollutant to replace or add
+    :param aqi: new list of AQI bands, replaces the whole list
+    :return: a new dict, ``parent`` is left untouched
+    """
+    return {
+        "aqi": list(parent["aqi"] if aqi is None else aqi),
+        "bp": {**parent["bp"], **(bp or {})},
+        "prec": {**parent["prec"], **(prec or {})},
+        "units": {**parent["units"], **(units or {})},
+    }
+
+
+class BaseAQI:
+    """A generic AQI class"""
+
+    def iaqi(self, elem, cc, extrapolate=False):
+        """Calculate an intermediate AQI for a given pollutant. This is
+        the heart of the algo. Return the IAQI for the given pollutant.
+
+        .. warning:: the concentration is passed as a string so
+            :class:`decimal.Decimal` doesn't act up with binary floats.
+
+        :param elem: pollutant constant
+        :type elem: int
+        :param cc: pollutant concentration (µg/m³ or ppm)
+        :type cc: str
+        :param extrapolate: compute values beyond the scale if the standard
+                            allows it, otherwise raise
+        :type extrapolate: bool
+        :raises OutOfRangeError: the concentration is not covered
+        """
+        raise NotImplementedError
+
+    def aqi(self, ccs, iaqis=False, extrapolate=False):
+        """Calculate the AQI based on a list of pollutants. Return an
+        AQI value, if `iaqis` is set to True, send back a tuple
+        containing the AQI and a dict of IAQIs.
+
+        :param ccs: a list of tuples of pollutants concentrations with
+                    pollutant constant and concentration as values
+        :type ccs: list
+        :param iaqis: return IAQIs with result
+        :type iaqis: bool
+        :param extrapolate: see :meth:`iaqi`
+        :type extrapolate: bool
+        """
+        _iaqis = {}
+        skipped = None
+        for elem, cc in ccs:
+            try:
+                _iaqi = self.iaqi(elem, cc, extrapolate=extrapolate)
+            except NotApplicableError as err:
+                # blank in the table: the standard says to disregard the value
+                skipped = err
+                continue
+            if _iaqi is not None:
+                _iaqis[elem] = _iaqi
+        if not _iaqis and skipped is not None:
+            raise skipped
+        _aqi = max(_iaqis.values())
+        if iaqis:
+            return (_aqi, _iaqis)
+        else:
+            return _aqi
+
+    def cc(self, elem, iaqi, extrapolate=False):
+        """Calculate a concentration for a given pollutant. Return the
+        concentration for the given pollutant based on the intermediate AQI.
+
+        .. warning:: the intermediate AQI is passed as a string
+
+        :param elem: pollutant constant
+        :type elem: int
+        :param cc: intermediate AQI
+        :type cc: str
+        :param extrapolate: see :meth:`iaqi`
+        :type extrapolate: bool
+        :raises OutOfRangeError: the AQI value is not covered
+        """
+        raise NotImplementedError
+
+    def list_pollutants(self):
+        """List pollutants covered by an algorithm, return a list of
+        pollutant names.
+        """
+        raise NotImplementedError
+
+
+class PiecewiseAQI(BaseAQI):
+    """A piecewise function AQI class (like EPA or MEP)
+
+    A pollutant's breakpoints are a list with one ``(low, high)`` tuple per AQI
+    band, ``None`` for a band the standard leaves blank. Values outside of the
+    breakpoints raise :class:`OutOfRangeError` (:class:`NotApplicableError`
+    for a blank band). An
+    algorithm whose standard describes how to go beyond the top of the scale
+    sets ``extrapolation`` to True: a pollutant whose table covers the whole
+    scale then extends its last band when ``extrapolate`` is requested.
+    """
+
+    piecewise = None
+    extrapolation = False
+
+    #: how an IAQI is rounded to an integer, ``ROUND_HALF_EVEN`` or
+    #: ``ROUND_CEILING`` (HJ 633 rounds up)
+    rounding = ROUND_HALF_EVEN
+    #: how a concentration is brought to the precision of its pollutant,
+    #: ``ROUND_DOWN`` truncates (EPA), ``ROUND_HALF_EVEN`` is GB/T 8170 (HJ 633)
+    cc_rounding = ROUND_DOWN
+    #: pollutants whose IAQI is fixed above the top of the table, by pollutant,
+    #: instead of being out of range (HJ 633-2026 table 3 notes b and c)
+    saturation = {}
+    #: pollutants that the standard does not compute above the top of the
+    #: table (HJ 633-2012 notes), :class:`NotApplicableError` is raised
+    undefined_above = ()
+
+    def _check(self, elem):
+        if self.piecewise is None:
+            raise NameError("piecewise struct is not defined")
+        return elem in self.piecewise["bp"]
+
+    def _can_extrapolate(self, elem):
+        """Only pollutants with a band for every AQI band can extend the top"""
+        return self.extrapolation and len(self.piecewise["bp"][elem]) == len(
+            self.piecewise["aqi"]
+        )
+
+    def iaqi(self, elem, cc, extrapolate=False):
+        if not self._check(elem):
+            return None
+
+        raw = Decimal(cc)
+        prec = self.piecewise["prec"][elem]
+        # a pollutant without precision is used as given
+        _cc = raw if prec is None else raw.quantize(prec, rounding=self.cc_rounding)
+
+        # define breakpoints for this pollutant at this concentration
+        bps = self.piecewise["bp"][elem]
+        filled = [bp for bp in bps if bp is not None]
+        low, high = filled[0][0], filled[-1][1]
+        # a negative value must not be truncated to zero
+        if raw < 0:
+            raise OutOfRangeError(elem, raw, low, high)
+
+        idx = None
+        for i, bp in enumerate(bps):
+            if bp is not None and bp[0] <= _cc <= bp[1]:
+                idx = i
+                break
+        if idx is None:
+            if _cc > high and elem in self.saturation:
+                return Decimal(self.saturation[elem])
+            elif _cc > high and elem in self.undefined_above:
+                raise NotApplicableError(elem, _cc, low, high)
+            elif _cc > high and extrapolate and self._can_extrapolate(elem):
+                idx = len(bps) - 1
+            elif _cc < low and bps[0] is None:
+                raise NotApplicableError(elem, _cc, low, high)
+            else:
+                raise OutOfRangeError(elem, _cc, low, high)
+        bplo, bphi = bps[idx]
+        # get corresponding AQI boundaries
+        (aqilo, aqihi) = self.piecewise["aqi"][idx]
+
+        if self.rounding == ROUND_CEILING:
+            # computed exactly so that rounding up an exact value does not
+            # push it to the next integer
+            value = (Fraction(aqihi) - Fraction(aqilo)) / (
+                Fraction(bphi) - Fraction(bplo)
+            ) * (Fraction(_cc) - Fraction(bplo)) + Fraction(aqilo)
+            return Decimal(math.ceil(value))
+
+        # equation
+        value = (aqihi - aqilo) / (bphi - bplo) * (_cc - bplo) + aqilo
+        return value.quantize(Decimal("1."), rounding=self.rounding)
+
+    def cc(self, elem, iaqi, extrapolate=False):
+        if not self._check(elem):
+            return None
+
+        _iaqi = int(iaqi)
+
+        # define aqi breakpoints for this pollutant at this IAQI
+        bps = self.piecewise["aqi"]
+        ccs = self.piecewise["bp"][elem]
+        low, high = bps[0][0], bps[-1][1]
+        if _iaqi < low:
+            raise OutOfRangeError(elem, _iaqi, low, high)
+
+        idx = None
+        for i, bp in enumerate(bps):
+            if bp[0] <= _iaqi <= bp[1]:
+                idx = i
+                break
+        if idx is None:
+            if extrapolate and self._can_extrapolate(elem):
+                idx = len(bps) - 1
+            else:
+                raise OutOfRangeError(elem, _iaqi, low, high)
+        elif idx >= len(ccs):
+            # this pollutant has no band for this part of the scale
+            raise OutOfRangeError(elem, _iaqi, low, bps[len(ccs) - 1][1])
+        elif ccs[idx] is None:
+            first = next(i for i, bp in enumerate(ccs) if bp is not None)
+            raise NotApplicableError(elem, _iaqi, bps[first][0], bps[-1][1])
+        bplo, bphi = bps[idx]
+        # get corresponding concentration boundaries
+        (cclo, cchi) = ccs[idx]
+
+        # equation
+        prec = self.piecewise["prec"][elem]
+        if prec is None:
+            # no rounding: truncated so that rounding the IAQI of the result
+            # up does not reach the next integer
+            with localcontext() as ctx:
+                ctx.rounding = ROUND_DOWN
+                return (cchi - cclo) / (bphi - bplo) * (_iaqi - bplo) + cclo
+        value = (cchi - cclo) / (bphi - bplo) * (_iaqi - bplo) + cclo
+        return Decimal(value).quantize(prec, rounding=self.cc_rounding)
+
+    def list_pollutants(self):
+        return self.piecewise["units"].items()

aqi/algos/epa.py

@@ -0,0 +1,207 @@
+from decimal import Decimal
+
+from aqi.algos.base import PiecewiseAQI, derive_piecewise
+from aqi.constants import (
+    POLLUTANT_CO_8H,
+    POLLUTANT_NO2_1H,
+    POLLUTANT_O3_1H,
+    POLLUTANT_O3_8H,
+    POLLUTANT_PM10,
+    POLLUTANT_PM25,
+    POLLUTANT_SO2_1H,
+)
+
+
+class EPA_2012(PiecewiseAQI):
+    """Implementation of the EPA AQI algorithm, as python-aqi has always
+    computed it: the PM2.5 breakpoints of the 2012 revision (annual standard
+    lowered to 12 µg/m³) and the 1997 ozone 8 hour breakpoints.
+
+    Source: Technical Assistance Document EPA-454/B-13-001, December 2013, and
+    the Federal Register of 15 January 2013 (78 FR 3286), both in
+    ``docs/standards``. The ``(0, 0)`` first bands of 1 hour ozone are a known
+    flaw (issue 15) that is kept here, later versions leave them blank.
+
+    Above 500 the EPA calls values "Beyond the AQI" and computes them with
+    the Hazardous breakpoints (Technical Assistance Document, Q&A), this is
+    available with ``extrapolate=True``.
+    """
+
+    extrapolation = True
+
+    piecewise = {
+        "aqi": [
+            (0, 50),
+            (51, 100),
+            (101, 150),
+            (151, 200),
+            (201, 300),
+            (301, 400),
+            (401, 500),
+        ],
+        "bp": {
+            POLLUTANT_O3_8H: [
+                (Decimal("0.000"), Decimal("0.059")),
+                (Decimal("0.060"), Decimal("0.075")),
+                (Decimal("0.076"), Decimal("0.095")),
+                (Decimal("0.096"), Decimal("0.115")),
+                (Decimal("0.116"), Decimal("0.374")),
+            ],
+            POLLUTANT_O3_1H: [
+                (0, 0),
+                (0, 0),
+                (Decimal("0.125"), Decimal("0.164")),
+                (Decimal("0.165"), Decimal("0.204")),
+                (Decimal("0.205"), Decimal("0.404")),
+                (Decimal("0.405"), Decimal("0.504")),
+                (Decimal("0.505"), Decimal("0.604")),
+            ],
+            POLLUTANT_PM10: [
+                (Decimal("0"), Decimal("54")),
+                (Decimal("55"), Decimal("154")),
+                (Decimal("155"), Decimal("254")),
+                (Decimal("255"), Decimal("354")),
+                (Decimal("355"), Decimal("424")),
+                (Decimal("425"), Decimal("504")),
+                (Decimal("505"), Decimal("604")),
+            ],
+            POLLUTANT_PM25: [
+                (Decimal("0.0"), Decimal("12.0")),
+                (Decimal("12.1"), Decimal("35.4")),
+                (Decimal("35.5"), Decimal("55.4")),
+                (Decimal("55.5"), Decimal("150.4")),
+                (Decimal("150.5"), Decimal("250.4")),
+                (Decimal("250.5"), Decimal("350.4")),
+                (Decimal("350.5"), Decimal("500.4")),
+            ],
+            POLLUTANT_CO_8H: [
+                (Decimal("0.0"), Decimal("4.4")),
+                (Decimal("4.5"), Decimal("9.4")),
+                (Decimal("9.5"), Decimal("12.4")),
+                (Decimal("12.5"), Decimal("15.4")),
+                (Decimal("15.5"), Decimal("30.4")),
+                (Decimal("30.5"), Decimal("40.4")),
+                (Decimal("40.5"), Decimal("50.4")),
+            ],
+            POLLUTANT_SO2_1H: [
+                (Decimal("0"), Decimal("35")),
+                (Decimal("36"), Decimal("75")),
+                (Decimal("76"), Decimal("185")),
+                (Decimal("186"), Decimal("304")),
+                (Decimal("305"), Decimal("604")),
+                (Decimal("605"), Decimal("804")),
+                (Decimal("805"), Decimal("1004")),
+            ],
+            POLLUTANT_NO2_1H: [
+                (Decimal("0"), Decimal("53")),
+                (Decimal("54"), Decimal("100")),
+                (Decimal("101"), Decimal("360")),
+                (Decimal("361"), Decimal("649")),
+                (Decimal("650"), Decimal("1249")),
+                (Decimal("1250"), Decimal("1649")),
+                (Decimal("1650"), Decimal("2049")),
+            ],
+        },
+        "prec": {
+            POLLUTANT_O3_8H: Decimal(".001"),
+            POLLUTANT_O3_1H: Decimal(".001"),
+            POLLUTANT_PM10: Decimal("1."),
+            POLLUTANT_PM25: Decimal(".1"),
+            POLLUTANT_CO_8H: Decimal(".1"),
+            POLLUTANT_SO2_1H: Decimal("1."),
+            POLLUTANT_NO2_1H: Decimal("1."),
+        },
+        "units": {
+            POLLUTANT_O3_8H: "ppm",
+            POLLUTANT_O3_1H: "ppm",
+            POLLUTANT_PM10: "µg/m³",
+            POLLUTANT_PM25: "µg/m³",
+            POLLUTANT_CO_8H: "ppm",
+            POLLUTANT_SO2_1H: "ppb",
+            POLLUTANT_NO2_1H: "ppb",
+        },
+    }
+
+
+class EPA_2015(EPA_2012):
+    """EPA AQI after the 2015 ozone standard (0.070 ppm): new 8 hour ozone
+    breakpoints, 1 hour ozone starts at 0.125 ppm (AQI 101) and the lower
+    bands are blank, as in the table of the standard.
+
+    Source: Technical Assistance Document EPA-454/B-18-007, September 2018,
+    Table 5 (``docs/standards``).
+    """
+
+    piecewise = derive_piecewise(
+        EPA_2012.piecewise,
+        bp={
+            POLLUTANT_O3_8H: [
+                (Decimal("0.000"), Decimal("0.054")),
+                (Decimal("0.055"), Decimal("0.070")),
+                (Decimal("0.071"), Decimal("0.085")),
+                (Decimal("0.086"), Decimal("0.105")),
+                (Decimal("0.106"), Decimal("0.200")),
+            ],
+            POLLUTANT_O3_1H: [
+                None,
+                None,
+                (Decimal("0.125"), Decimal("0.164")),
+                (Decimal("0.165"), Decimal("0.204")),
+                (Decimal("0.205"), Decimal("0.404")),
+                (Decimal("0.405"), Decimal("0.504")),
+                (Decimal("0.505"), Decimal("0.604")),
+            ],
+        },
+    )
+
+
+class EPA_2024(EPA_2015):
+    """EPA AQI after the 2024 PM2.5 standard (annual 9 µg/m³), effective
+    6 May 2024: new PM2.5 breakpoints, and a single Hazardous category,
+    AQI 301 to 500, for every pollutant. Its top is the concentration of
+    AQI 500, so PM10, CO, SO2, NO2 and 1 hour ozone above their old 400 are
+    now on one linear band instead of two (PM10 504 µg/m³ is 389, not 400).
+
+    Source: Technical Assistance Document EPA-403/B-26-003, May 2026, Table 6
+    (same table as EPA-454/B-24-002, May 2024), in ``docs/standards``.
+    """
+
+    _hazardous = {
+        POLLUTANT_O3_1H: (Decimal("0.405"), Decimal("0.604")),
+        POLLUTANT_PM10: (Decimal("425"), Decimal("604")),
+        POLLUTANT_CO_8H: (Decimal("30.5"), Decimal("50.4")),
+        POLLUTANT_SO2_1H: (Decimal("605"), Decimal("1004")),
+        POLLUTANT_NO2_1H: (Decimal("1250"), Decimal("2049")),
+    }
+
+    piecewise = derive_piecewise(
+        EPA_2015.piecewise,
+        aqi=[(0, 50), (51, 100), (101, 150), (151, 200), (201, 300), (301, 500)],
+        bp={
+            POLLUTANT_PM25: [
+                (Decimal("0.0"), Decimal("9.0")),
+                (Decimal("9.1"), Decimal("35.4")),
+                (Decimal("35.5"), Decimal("55.4")),
+                (Decimal("55.5"), Decimal("125.4")),
+                (Decimal("125.5"), Decimal("225.4")),
+                (Decimal("225.5"), Decimal("325.4")),
+            ],
+            **{
+                elem: [*EPA_2015.piecewise["bp"][elem][:5], hazardous]
+                for elem, hazardous in _hazardous.items()
+            },
+        },
+    )
+
+
+# oldest first, the last one is the latest and the default
+VERSIONS = {
+    "2012": EPA_2012,
+    "2015": EPA_2015,
+    "2024": EPA_2024,
+}
+
+#: the latest version of the EPA algorithm
+EPA = list(VERSIONS.values())[-1]
+#: historical name, the module is loaded by ``aqi.algos.get_algo``
+AQI = EPA

aqi/algos/mep.py

@@ -0,0 +1,128 @@
+from decimal import ROUND_CEILING, ROUND_HALF_EVEN, Decimal
+
+from aqi.algos.base import PiecewiseAQI, derive_piecewise
+from aqi.constants import (
+    POLLUTANT_CO_1H,
+    POLLUTANT_CO_24H,
+    POLLUTANT_NO2_1H,
+    POLLUTANT_NO2_24H,
+    POLLUTANT_O3_1H,
+    POLLUTANT_O3_8H,
+    POLLUTANT_PM10,
+    POLLUTANT_PM25,
+    POLLUTANT_SO2_1H,
+    POLLUTANT_SO2_24H,
+)
+
+# HJ 633-2012 table 1: the concentration limit of each IAQI, 0 to 500 (the IAQI
+# are 0, 50, 100, 150, 200, 300, 400 and 500), blank cells are left out
+_LIMITS_2012 = {
+    POLLUTANT_SO2_24H: "0 50 150 475 800 1600 2100 2620",
+    POLLUTANT_SO2_1H: "0 150 500 650 800",
+    POLLUTANT_NO2_24H: "0 40 80 180 280 565 750 940",
+    POLLUTANT_NO2_1H: "0 100 200 700 1200 2340 3090 3840",
+    POLLUTANT_CO_24H: "0 2 4 14 24 36 48 60",
+    POLLUTANT_CO_1H: "0 5 10 35 60 90 120 150",
+    POLLUTANT_O3_8H: "0 100 160 215 265 800",
+    POLLUTANT_O3_1H: "0 160 200 300 400 800 1000 1200",
+    POLLUTANT_PM10: "0 50 150 250 350 420 500 600",
+    POLLUTANT_PM25: "0 35 75 115 150 250 350 500",
+}
+
+_UNITS = {
+    POLLUTANT_SO2_24H: "µg/m³",
+    POLLUTANT_SO2_1H: "µg/m³",
+    POLLUTANT_NO2_24H: "µg/m³",
+    POLLUTANT_NO2_1H: "µg/m³",
+    POLLUTANT_PM10: "µg/m³",
+    POLLUTANT_CO_24H: "mg/m³",
+    POLLUTANT_CO_1H: "mg/m³",
+    POLLUTANT_O3_1H: "µg/m³",
+    POLLUTANT_O3_8H: "µg/m³",
+    POLLUTANT_PM25: "µg/m³",
+}
+
+
+def _bands(limits):
+    """Each band goes from a limit to the next one: the formula (1) of the
+    standards interpolates between neighbouring limits of the table"""
+    points = [Decimal(limit) for limit in limits.split()]
+    return list(zip(points, points[1:]))
+
+
+class MEP_2012(PiecewiseAQI):
+    """MEP AQI algorithm, HJ 633-2012 (in force from 1 January 2016, replaced
+    by HJ 633-2026 on 1 March 2026).
+
+    The calculation follows the standard: the formula (1) interpolates between
+    neighbouring limits of table 1, concentrations are used as they are given
+    (the standard does not round them) and IAQI and AQI are rounded up
+    (clause 6.2). SO2 1 hour and O3 8 hour above 800 µg/m³ are not computed
+    (notes 2 and 3 of table 1): :class:`NotApplicableError`, and :meth:`aqi`
+    leaves them out, the 24 hour SO2 and the 1 hour O3 are used instead.
+
+    Before 1.0 this class was laid out like the EPA tables (gaps between bands,
+    concentrations truncated to integers, IAQI rounded half to even), so some
+    results differ from python-aqi 0.6, see the changelog.
+
+    Source: HJ 633-2012, table 1 and clauses 4.2 and 6.2 (``docs/standards``).
+    """
+
+    rounding = ROUND_CEILING
+    undefined_above = (POLLUTANT_SO2_1H, POLLUTANT_O3_8H)
+
+    piecewise = {
+        "aqi": [(0, 50), (50, 100), (100, 150), (150, 200), (200, 300), (300, 400)]
+        + [(400, 500)],
+        "bp": {elem: _bands(limits) for elem, limits in _LIMITS_2012.items()},
+        "prec": dict.fromkeys(_LIMITS_2012),
+        "units": _UNITS,
+    }
+
+
+class MEP_2026(MEP_2012):
+    """MEP AQI algorithm, HJ 633-2026 (replaces HJ 633-2012, effective
+    1 March 2026).
+
+    Compared with HJ 633-2012 the limits of IAQI 100 change for PM10 (150 to
+    120 µg/m³) and PM2.5 (75 to 60 µg/m³). The calculation is the same except
+    that concentrations are rounded to integers and CO to one decimal
+    following GB/T 8170, half to even (clause 4.2.2), and that above the table
+    SO2 1 hour is IAQI 200 and O3 8 hour is IAQI 300 (notes b and c), any other
+    value is out of range.
+
+    Source: HJ 633-2026, table 3 and clauses 4.2.2 to 4.2.6
+    (``docs/standards``, transcription in ``hj633-2026-table.rst``).
+    """
+
+    cc_rounding = ROUND_HALF_EVEN
+    saturation = {POLLUTANT_SO2_1H: 200, POLLUTANT_O3_8H: 300}
+    undefined_above = ()
+
+    piecewise = derive_piecewise(
+        MEP_2012.piecewise,
+        bp={
+            elem: _bands(limits)
+            for elem, limits in {
+                POLLUTANT_PM10: "0 50 120 250 350 420 500 600",
+                POLLUTANT_PM25: "0 35 60 115 150 250 350 500",
+            }.items()
+        },
+        prec={
+            **dict.fromkeys(_LIMITS_2012, Decimal("1.")),
+            POLLUTANT_CO_24H: Decimal("0.1"),
+            POLLUTANT_CO_1H: Decimal("0.1"),
+        },
+    )
+
+
+# oldest first, the last one is the latest and the default
+VERSIONS = {
+    "2012": MEP_2012,
+    "2026": MEP_2026,
+}
+
+#: the latest version of the MEP algorithm
+MEP = list(VERSIONS.values())[-1]
+#: historical name, the module is loaded by ``aqi.algos.get_algo``
+AQI = MEP

aqi/constants.py

@@ -0,0 +1,23 @@
+# constants for pollutants names
+POLLUTANT_O3_8H = "o3_8h"
+POLLUTANT_O3_1H = "o3_1h"
+POLLUTANT_PM10 = "pm10"
+POLLUTANT_PM25 = "pm25"
+POLLUTANT_CO_1H = "co_1h"
+POLLUTANT_CO_8H = "co_8h"
+POLLUTANT_CO_24H = "co_24h"
+POLLUTANT_SO2_1H = "so2_1h"
+POLLUTANT_SO2_24H = "so2_24h"
+POLLUTANT_NO2_1H = "no2_1h"
+POLLUTANT_NO2_24H = "no2_24h"
+
+# constants for algorithms, canonical module name, always the latest version
+ALGO_EPA = "aqi.algos.epa"
+ALGO_MEP = "aqi.algos.mep"
+
+# constants for a given version of an algorithm, "family:version"
+ALGO_EPA_2012 = "epa:2012"
+ALGO_EPA_2015 = "epa:2015"
+ALGO_EPA_2024 = "epa:2024"
+ALGO_MEP_2012 = "mep:2012"
+ALGO_MEP_2026 = "mep:2026"

aqi/exceptions.py

@@ -0,0 +1,32 @@
+class OutOfRangeError(ValueError):
+    """A concentration or an AQI value is outside of what an algorithm covers.
+
+    Standards define a scale (0 to 500 for the EPA AQI), values outside of it
+    are not capped because that would hide how far off the scale they are.
+    Code using the library decides what to do with them.
+
+    :param elem: pollutant constant
+    :param value: the value that was refused
+    :param low: lowest value covered by the algorithm for this pollutant
+    :param high: highest value covered by the algorithm for this pollutant
+    """
+
+    def __init__(self, elem, value, low, high):
+        self.elem = elem
+        self.value = value
+        self.low = low
+        self.high = high
+        super().__init__(
+            f"{elem}: {value} is not covered by the algorithm "
+            f"(valid range is {low} to {high})"
+        )
+
+
+class NotApplicableError(OutOfRangeError):
+    """The standard leaves this part of the scale blank for the pollutant.
+
+    EPA 1 hour ozone has no value below 0.125 ppm (AQI 101): the standard says
+    to disregard it and to use 8 hour ozone. :meth:`BaseAQI.aqi` does so, a
+    direct call to ``iaqi`` or ``cc`` raises this error. HJ 633-2012 does the
+    same above the table for SO2 1 hour and O3 8 hour.
+    """

python_aqi-1.0.0.dist-info/METADATA

@@ -0,0 +1,291 @@
+Metadata-Version: 2.5
+Name: python-aqi
+Version: 1.0.0
+Summary: A library to convert between AQI value and pollutant concentration (µg/m³ or ppm)
+Project-URL: Homepage, https://github.com/hrbonz/python-aqi
+Project-URL: Documentation, https://python-aqi.readthedocs.io/
+Author-email: "Stefan \"hr\" Berder" <hr@bonz.org>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: EPA,MEP,air quality,pm2.5
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Programming Language :: Python :: 3
+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
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+
+###########################
+python-aqi - AQI conversion
+###########################
+
+A library to convert between AQI value and pollutant concentration
+(µg/m³ or ppm) using the following algorithms:
+
+* United States Environmental Protection Agency (EPA)
+* China Ministry of Environmental Protection (MEP)
+
+The versions of each standard are kept, see `the documentation
+<https://python-aqi.readthedocs.io/>`_ for how an AQI is computed, the
+standards and versions, and the API reference.
+
+.. image:: https://github.com/hrbonz/python-aqi/actions/workflows/ci.yml/badge.svg?branch=master
+    :target: https://github.com/hrbonz/python-aqi/actions/workflows/ci.yml
+    :alt: Testing Status
+
+.. image:: https://readthedocs.org/projects/python-aqi/badge/?version=latest
+    :target: https://readthedocs.org/projects/python-aqi/?badge=latest
+    :alt: Documentation Status
+
+.. image:: http://img.shields.io/badge/license-BSD%203--Clause-blue.svg
+    :target: http://opensource.org/licenses/BSD-3-Clause
+    :alt: license BSD 3-Clause
+
+
+Install
+=======
+
+With pip::
+
+    $ pip install python-aqi
+
+With `uv <https://docs.astral.sh/uv/>`_, to add it to a project::
+
+    $ uv add python-aqi
+
+or to install the ``aqi`` command line tool::
+
+    $ uv tool install python-aqi
+
+
+Usage
+=====
+
+Library
+-------
+
+Convert a pollutant to its IAQI (Intermediate Air Quality Index)::
+
+    import aqi
+    myaqi = aqi.to_iaqi(aqi.POLLUTANT_PM25, '12', algo=aqi.ALGO_EPA)
+
+Get an AQI out of several pollutant concentrations, default algorithm is EPA::
+
+    import aqi
+    myaqi = aqi.to_aqi([
+        (aqi.POLLUTANT_PM25, '12'),
+        (aqi.POLLUTANT_PM10, '24'),
+        (aqi.POLLUTANT_O3_8H, '0.087')
+    ])
+
+The algorithm is a standard and its version: ``'epa:2012'``, or ``'epa'`` for
+the latest version of the family (``aqi.ALGO_EPA``, ``aqi.ALGO_EPA_2012`` and
+the matching ``MEP`` constants are available). Old versions stay selectable, the
+default is always the latest. ``aqi.available_algos()`` lists them all::
+
+    aqi.available_algos()
+    # ['epa:2012', 'epa:2015', 'epa:2024', 'mep:2012', 'mep:2026']
+
+The EPA versions are named after the revision that changed the table:
+
+* ``epa:2012``: what python-aqi computed until 0.6, PM2.5 Good up to 12.0
+  µg/m³ and the 1997 ozone 8 hour breakpoints
+* ``epa:2015``: new ozone 8 hour breakpoints (0.054, 0.070, 0.085, 0.105, 0.200
+  ppm), 1 hour ozone only above 0.125 ppm
+* ``epa:2024``: new PM2.5 breakpoints (Good up to 9.0 µg/m³) and a single
+  Hazardous category, 301 to 500, for every pollutant. This is the default.
+
+The MEP (China) versions follow the standards. The name ``MEP`` stands for the
+Ministry of Environmental Protection, which published HJ 633-2012. The ministry
+was renamed Ministry of Ecology and Environment (MEE) in 2018 and publishes
+HJ 633-2026 under that name, the library keeps ``MEP`` for all versions so that
+the name used by existing code does not change:
+
+* ``mep:2012``: HJ 633-2012, IAQI interpolated between the limits of the
+  table and IAQI and AQI rounded up, concentrations used as given
+* ``mep:2026``: HJ 633-2026, effective 1 March 2026. The limits of IAQI 100
+  change for PM10 (150 to 120 µg/m³) and PM2.5 (75 to 60 µg/m³), and the
+  calculation follows the standard: IAQI interpolated between the limits of
+  the table, IAQI and AQI rounded up, concentrations rounded to integers (CO to
+  one decimal). This is the default for MEP.
+
+``mep:2012`` used to be laid out like the EPA tables and now follows
+HJ 633-2012 (``aqi.to_iaqi(aqi.POLLUTANT_PM25, '60', algo=aqi.ALGO_MEP_2012)``
+is 82, it was 81). The default changed with the 2024 and 2026 versions: the same PM2.5 concentration can
+now give a different AQI, ``aqi.to_iaqi(aqi.POLLUTANT_PM25, '12.1')`` is 57,
+it was 51, and ``aqi.to_iaqi(aqi.POLLUTANT_PM25, '60', algo=aqi.ALGO_MEP)`` is
+100, it was 81. Use ``algo=aqi.ALGO_EPA_2012`` to keep the old EPA results.
+
+1 hour ozone has no value under 0.125 ppm in the EPA table. ``to_aqi`` ignores
+it when other pollutants are given (the standard says to disregard it), for
+``to_iaqi`` and ``to_cc`` it raises ``aqi.NotApplicableError``, an
+``OutOfRangeError``.
+
+Convert an IAQI to its pollutant concentration::
+
+    import aqi
+    mycc = aqi.to_cc(aqi.POLLUTANT_PM25, '22', algo=aqi.ALGO_EPA)
+
+Out of range values
+~~~~~~~~~~~~~~~~~~~
+
+A concentration (or an AQI) that is not covered by the algorithm raises
+``aqi.OutOfRangeError``, a subclass of ``ValueError`` that carries ``elem``,
+``value``, ``low`` and ``high``. Values are never capped: a capped value would
+hide how far above the scale a measure is, so what to do with it is up to the
+calling code::
+
+    try:
+        myaqi = aqi.to_aqi([(aqi.POLLUTANT_PM25, '800')])
+    except aqi.OutOfRangeError as err:
+        print(err.elem, err.value, err.high)
+
+The EPA calls AQI values above 500 "Beyond the AQI" and explains how to
+compute them: use the regular formula with the Hazardous breakpoints. This is
+available on request with ``extrapolate=True``::
+
+    aqi.to_aqi([(aqi.POLLUTANT_PM25, '800')], extrapolate=True)  # 1445
+
+This only applies to the EPA algorithm and to pollutants whose table covers
+the whole scale. 8 hour ozone, for example, stops at 300 because the EPA uses
+1 hour ozone above that. The MEP standard has no such method, so ``extrapolate=True``
+still raises with it. HJ 633-2026 does fix the IAQI of two pollutants above
+their table: SO2 1 hour above 800 µg/m³ is 200 and O3 8 hour above 800 µg/m³
+is 300 (HJ 633-2012 said they are not computed: ``mep:2012`` raises
+``aqi.NotApplicableError`` and ``to_aqi`` leaves them out).
+
+
+Command line
+------------
+
+List supported algorithms and pollutants::
+
+    $ aqi -l
+    epa:2012: o3_8h (ppm), o3_1h (ppm), pm10 (µg/m³), pm25 (µg/m³), co_8h (ppm), so2_1h (ppb), no2_1h (ppb)
+    epa:2015: o3_8h (ppm), o3_1h (ppm), pm10 (µg/m³), pm25 (µg/m³), co_8h (ppm), so2_1h (ppb), no2_1h (ppb)
+    epa:2024 (latest): o3_8h (ppm), o3_1h (ppm), pm10 (µg/m³), pm25 (µg/m³), co_8h (ppm), so2_1h (ppb), no2_1h (ppb)
+    mep:2012: so2_24h (µg/m³), so2_1h (µg/m³), no2_24h (µg/m³), no2_1h (µg/m³), pm10 (µg/m³), co_24h (mg/m³), co_1h (mg/m³), o3_1h (µg/m³), o3_8h (µg/m³), pm25 (µg/m³)
+    mep:2026 (latest): so2_24h (µg/m³), so2_1h (µg/m³), no2_24h (µg/m³), no2_1h (µg/m³), pm10 (µg/m³), co_24h (mg/m³), co_1h (mg/m³), o3_1h (µg/m³), o3_8h (µg/m³), pm25 (µg/m³)
+
+Pick the version of a standard with ``family:version``, ``epa`` alone means the
+latest version, the module names (``aqi.algos.epa``) still work and also mean
+the latest::
+
+    $ aqi epa:2012 pm25:12
+    50
+
+Convert PM2.5 to IAQI using EPA algorithm::
+
+    $ aqi aqi.algos.epa pm25:12
+    56
+
+Convert PM2.5 to IAQI using EPA algorithm (full length)::
+
+    $ aqi -c aqi aqi.algos.epa pm25:12
+    56
+
+Convert pollutants concentrations to AQI using EPA algorithm::
+
+    $ aqi aqi.algos.epa pm25:40.9 o3_8h:0.077 co_8h:8.4
+    122
+
+Convert pollutants concentrations to AQI using EPA algorithm, display IAQIs::
+
+    $ aqi -v aqi.algos.epa pm25:40.9 o3_8h:0.077 co_8h:8.4
+    pm25:114 o3_8h:122 co_8h:90
+    122
+
+Convert PM2.5 IAQI to concentration using EPA algorithm::
+
+    $ aqi -c cc aqi.algos.epa pm25:39
+    7.0
+
+Out of range values are an error, the message goes to stderr and the exit
+code is 3::
+
+    $ aqi aqi.algos.epa pm25:800
+    Out of range: pm25: 800.0 is not covered by the algorithm (valid range is 0.0 to 325.4)
+
+``-e`` computes EPA values beyond the scale ("Beyond the AQI")::
+
+    $ aqi -e aqi.algos.epa pm25:800
+    1445
+
+
+Development
+===========
+
+Set up the development environment (ruff, pre-commit, hatch, coverage)::
+
+    $ uv sync
+    $ uv run pre-commit install
+
+Code is linted and formatted with `ruff <https://docs.astral.sh/ruff/>`_
+through `pre-commit <https://pre-commit.com/>`_, the checks run on each
+commit. To run them on all files::
+
+    $ uv run pre-commit run --all-files
+
+Test the package::
+
+    $ uv run python -m unittest discover
+
+The same checks and the tests on Python 3.9 to 3.14 run on GitHub Actions
+(``.github/workflows/ci.yml``) for each push and pull request.
+
+
+Release
+=======
+
+A release is made from ``master`` with a clean tree, after adding a
+``X.Y.Z (unreleased)`` section to ``docs/changelog.rst``::
+
+    $ make release SEGMENT=major   # or minor, patch (the default)
+
+It runs, in this order:
+
+``make bump``
+    runs the tests, bumps the version with ``hatch version``, refreshes
+    ``uv.lock``, dates the changelog section, commits ``release: bump to
+    X.Y.Z`` and tags ``X.Y.Z`` (no ``v``).
+``make publish``
+    builds the tagged commit and uploads it to PyPI with ``uv publish``. The
+    token is a PyPI API token in the ``UV_PUBLISH_TOKEN`` environment
+    variable, it is not stored in the repository.
+``make push``
+    pushes the commit and the tag to ``origin`` (``REMOTE=...`` to change it)
+    once the upload worked.
+
+
+Project
+=======
+
+* `Source code on github <https://github.com/hrbonz/python-aqi>`_
+* `Documentation on readthedocs <https://python-aqi.readthedocs.io/>`_
+* `Package on pypi <https://pypi.python.org/pypi/python-aqi>`_
+
+
+Resources
+=========
+
+* EPA AQI: Technical Assistance Document for the Reporting of Daily Air
+  Quality – the Air Quality Index (AQI) December 2013) found at http://www.epa.gov/airnow/aqi-technical-assistance-document-dec2013.pdf
+* National Ambient Air Quality Standards for Particulate Matter found at http://www.gpo.gov/fdsys/pkg/FR-2013-01-15/pdf/2012-30946.pdf
+* MEP AQI:
+
+    * GB3095—2012 (2012/02/29) found at http://www.mep.gov.cn/gkml/hbb/bwj/201203/t20120302_224147.htm
+    * HJ633-2012 (2012/02/29) found at https://www.mee.gov.cn/ywgz/fgbz/bz/bzwb/jcffbz/201203/W020120410332725219541.pdf
+
+
+License
+=======
+
+python-aqi is published under a BSD 3-clause license, see the LICENSE file
+distributed with the project.

python_aqi-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+aqi/__init__.py,sha256=5HrsQQKmyYjjkjK5Nhwildlsmb9scapww3G2rsehBKQ,8013
+aqi/constants.py,sha256=oMDTcc2cGfDpr_-ks9Bmqgbq8wbykqyAzKXhH-3O24k,663
+aqi/exceptions.py,sha256=-XPw7iFnxVV3AUt9dzleSAM8-hdV7SjObM-EO2Mfu4M,1277
+aqi/algos/__init__.py,sha256=UDD6UDQkif428L_siDxt3JJwcp9JrzFWm1Q9R90KdtA,1856
+aqi/algos/base.py,sha256=v7E9nZLGjO5V0-K-gMTcA80fgSm1PYjBiWQ_v5trGJs,9307
+aqi/algos/epa.py,sha256=LrDC6QD_SSSIMXXtnTWjALjGCl8YeneyZ3jrWcIuBAw,7593
+aqi/algos/mep.py,sha256=6JTQdFaDSg0UUK_K06EfG0_LRxC5iOHDFkWaO5yzpB8,4487
+python_aqi-1.0.0.dist-info/METADATA,sha256=nIr2pPpEqRx7ihFMhpaWqFL3Xrcsj0EM8PDMP3YuAgo,10848
+python_aqi-1.0.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+python_aqi-1.0.0.dist-info/entry_points.txt,sha256=8hD9G44U89jRxY04bcdbtdlR74_B85P3zZ_rz6RasPg,40
+python_aqi-1.0.0.dist-info/licenses/LICENSE,sha256=0sCaGMpUPnZH6XEvjxudkJMOAJiNU_x-fQF8Awoj9cU,1489
+python_aqi-1.0.0.dist-info/RECORD,,

python_aqi-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

python_aqi-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aqi = aqi:console_aqi

python_aqi-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,12 @@
+Copyright (c) 2014, Stefan "hr" Berder
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.