wwvb 4.1.0a0__py3-none-any.whl → 5.0.0__py3-none-any.whl

wwvb-5.0.0.dist-info/METADATA

@@ -0,0 +1,200 @@
+Metadata-Version: 2.1
+Name: wwvb
+Version: 5.0.0
+Summary: Generate WWVB timecodes for any desired time
+Author-email: Jeff Epler <jepler@gmail.com>
+Project-URL: Source, https://github.com/jepler/wwvbpy
+Project-URL: Documentation, https://github.com/jepler/wwvbpy
+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 :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: adafruit-circuitpython-datetime
+Requires-Dist: beautifulsoup4
+Requires-Dist: click
+Requires-Dist: leapseconddata
+Requires-Dist: platformdirs
+Requires-Dist: python-dateutil
+Requires-Dist: requests
+Requires-Dist: tzdata
+
+<!--
+SPDX-FileCopyrightText: 2021-2024 Jeff Epler
+
+SPDX-License-Identifier: GPL-3.0-only
+-->
+[![Test wwvbgen](https://github.com/jepler/wwvbpy/actions/workflows/test.yml/badge.svg)](https://github.com/jepler/wwvbpy/actions/workflows/test.yml)
+[![codecov](https://codecov.io/gh/jepler/wwvbpy/branch/main/graph/badge.svg?token=Exx0c3Gp65)](https://codecov.io/gh/jepler/wwvbpy)
+[![Update DUT1 data](https://github.com/jepler/wwvbpy/actions/workflows/cron.yml/badge.svg)](https://github.com/jepler/wwvbpy/actions/workflows/cron.yml)
+[![PyPI](https://img.shields.io/pypi/v/wwvb)](https://pypi.org/project/wwvb)
+[![CodeQL](https://github.com/jepler/wwvbpy/actions/workflows/codeql.yml/badge.svg)](https://github.com/jepler/wwvbpy/actions/workflows/codeql.yml)
+[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/jepler/wwvbpy/main.svg)](https://results.pre-commit.ci/latest/github/jepler/wwvbpy/main)
+
+# Purpose
+
+wwvbpy generates WWVB timecodes for any desired time.  These timecodes
+may be useful in testing WWVB decoder software.
+
+Where possible, wwvbpy uses existing facilities for calendar and time
+manipulation (datetime and dateutil).
+
+It uses DUT1/leap second data derived from IERS Bulletin "A" and from NIST's
+"Leap second and UT1-UTC information" page.  With regular updates to
+the "iersdata", wwvbpy should be able to correctly encode the time anywhere
+within the 100-year WWVB epoch.  (yes, WWVB uses a 2-digit year! In order to
+work with historical data, the epoch is arbitrarily assumed to run from 1970 to
+2069.)
+
+Programs include:
+ * `wwvbgen`, the main commandline generator program
+ * `wwvbdecode`, the main commandline decoder program
+ * `wwvbtk`, visualize the simulated WWVB signal in real-time using Tkinter
+ * `dut1table`, print the full history of dut1 values, including estimated future values
+ * `updateiers`, download the latest dut1 data including prospective data from IERS and NIST
+
+The package includes:
+ * `wwvb`, for generating WWVB timecodes
+ * `wwvb.decode`, a generator-based state machine for decoding WWVB timecodes (amplitude modulation only)
+ * `uwwvb`, a version of the decoder intended for use on constrained environments such as [CircuitPython](https://circuitpython.org).
+
+# Development status
+
+The author (@jepler) occasionally develops and maintains this project, but
+issues are not likely to be acted on.  They would be interested in adding
+co-maintainer(s).
+
+
+# WWVB Timecodes
+
+The National Institute of Standards and Technology operates the WWVB time
+signal service near Fort Collins, Colorado.  The signal can be received in most
+of the continental US.  Each minute, the signal transmits the current time,
+including information about leap years, daylight saving time, and leap seconds.
+The signal is composed of an amplitude channel and a phase modulation channel.
+
+The amplitude channel can be visualized as a sequence of (usually) 60 symbols,
+which by default wwvbgen displays as 0, 1, or 2.  The 0s and 1s encode
+information like the current day of the year, while the 2s appear in fixed
+locations to allow a receiver to determine the start of a minute.
+
+The phase channel (which is displayed with `--channel=phase` or
+`--channel=both`) consists of the same number of symbols per minute.  This
+channel is substantially more complicated than the phase channel.  It encodes
+the current time as minute-of-the-century, provides extended DST information,
+and includes error-correction information not available in the amplitude
+channel.
+
+# Usage
+
+~~~~
+Usage: python -m wwvb.gen [OPTIONS] [TIMESPEC]...
+
+  Generate WWVB timecodes
+
+  TIMESPEC: one of "year yday hour minute" or "year month day hour minute", or
+  else the current minute
+
+Options:
+  -i, --iers / -I, --no-iers      Whether to use IESR data for DUT1 and LS.
+                                  (Default: --iers)
+  -s, --leap-second               Force a positive leap second at the end of
+                                  the GMT month (Implies --no-iers)
+  -n, --negative-leap-second      Force a negative leap second at the end of
+                                  the GMT month (Implies --no-iers)
+  -S, --no-leap-second            Force no leap second at the end of the month
+                                  (Implies --no-iers)
+  -d, --dut1 INTEGER              Force the DUT1 value (Implies --no-iers)
+  -m, --minutes INTEGER           Number of minutes to show (default: 10)
+  --style [bar|cradek|default|duration|json|sextant]
+                                  Style of output
+  -t, --all-timecodes / -T, --no-all-timecodes
+                                  Show the 'WWVB timecode' line before each
+                                  minute
+  --channel [amplitude|phase|both]
+                                  Modulation to show (default: amplitude)
+  --help                          Show this message and exit.
+~~~~
+
+For example, to display the leap second that occurred at the end of 1998,
+~~~~
+$ python wwvbgen.py -m 7 1998 365 23 56
+WWVB timecode: year=98 days=365 hour=23 min=56 dst=0 ut1=-300 ly=0 ls=1
+'98+365 23:56  210100110200100001120011001102010100010200110100121000001002
+'98+365 23:57  210100111200100001120011001102010100010200110100121000001002
+'98+365 23:58  210101000200100001120011001102010100010200110100121000001002
+'98+365 23:59  2101010012001000011200110011020101000102001101001210000010022
+'99+001 00:00  200000000200000000020000000002000100101201110100121001000002
+'99+001 00:01  200000001200000000020000000002000100101201110100121001000002
+'99+001 00:02  200000010200000000020000000002000100101201110100121001000002
+~~~~
+(the leap second is the extra digit at the end of the 23:59 line; that minute
+consists of 61 seconds, instead of the normal 60)
+
+
+# How wwvbpy handles DUT1 data
+
+wwvbpy stores a compact representation of DUT1 values in `wwvb/iersdata_dist.py` or `wwvb_iersdata.py`.
+In this representation, one value is used for one day (0000UTC through 2359UTC).
+The letters `a` through `u` represent offsets of -1.0s through +1.0s
+in 0.1s increments; `k` represents 0s.  (In practice, only a smaller range
+of values, typically -0.7s to +0.8s, is seen)
+
+For 2001 through 2019, NIST has published the actual DUT1 values broadcast,
+and the date of each change, though it in the format of an HTML
+table and not designed for machine readability:
+
+https://www.nist.gov/pml/time-and-frequency-division/atomic-standards/leap-second-and-ut1-utc-information
+
+NIST does not update the value daily and does not seem to follow any
+specific rounding rule.  Rather, in WWVB "the resolution of the DUT1
+correction is 0.1 s, and represents an average value for an extended
+range of dates. Therefore, it will not agree exactly with the weekly
+UT1-UTC(NIST) values shown in the earlier table, which have 1 ms
+resolution and are updated weekly."  Like wwvbpy's compact
+representation of DUT1 values, the real WWVB does not appear to ever
+broadcast DUT1=-0.0.
+
+For a larger range of dates spanning 1973 through approximately one year from
+now, IERS publishes historical and prospective UT1-UTC values to multiple
+decimal places, in a machine readable fixed length format.
+
+wwvbpy merges the WWVB and IERS datasets, favoring the WWVB dataset for dates when it is available. There are some caveats to this, which are mostly commented in the `wwvb/updateiers.py` script.
+
+`wwvb/iersdata_dist.py` is updated monthly from github actions or with `iersdata --dist` from within the wwvbpy source tree. However, at this time, releases are not regularly made from the updated information.
+
+A site or user version of the file, `wwvb_iersdata.py` can be created or updated with `iersdata --site` or `iersdata --user`.  If the distributed iersdata is out of date, the generator will prompt you to run the update command.
+
+Leap seconds are inferred from the DUT1 data as follows: If X and Y are the
+1-digit-rounded DUT1 values for consecutive dates, and `X*Y<0`, then there is a
+leap second at the end of day X.  The direction of the leap second can be
+inferred from the sign of X, a 59-second minute if X is positive and a
+61-second minute if it is negative.  As long
+as DUT1 changes slowly enough during other times that there is at least one day
+of DUT1=+0.0, no incorrect (negative) leapsecond will be inferred. (something
+that should remain true for the next few centuries, until the length of the day
+is 100ms different from 86400 seconds)
+
+
+# The phase modulation channel
+
+This should be considered more experimental than the AM channel, as the
+tests only cover a single reference minute.  Further tests could be informed
+by the [other implementation I know of](http://www.leapsecond.com/tools/wwvb_pm.c), except that implementation appears incomplete.
+
+
+# Testing wwvbpy
+
+Run the testsuite, check coverage & type annotations with `gmake`.
+
+There are several test suites:
+ * `testwwvb.py`: Check output against expected values.  Uses hard coded leap seconds.  Tests amplitude and phase data, though the phase testcases are dubious as they were also generated by wwvbpy.
+ * `testuwwvb.py`: Test the reduced-functionality version against the main version
+ * `testls.py`: Check the IERS data through 2020-1-1 for expected leap seconds
+ * `testpm.py`: Check the phase modulation data against a test case from NIST documentation
+ * `testcli.py`: Check the commandline programs work as expected (limited tests to get 100% coverage)

wwvb-5.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+uwwvb.py,sha256=dyYlxZ6tIlcbKsWExNHKA8OtRfbziaCy5Xcj_97bGtA,5737
+wwvb/__init__.py,sha256=rDpr-XLoMld473qP-ufDunQxiDbLQDeS6eN7NOBtW84,30790
+wwvb/__version__.py,sha256=U7HnWMtKn0QTFHRJAzsVjr4cELMq3Toi6P5afKP6ah0,411
+wwvb/decode.py,sha256=llTLKBW49nl6COheM90NsyMnTNeVApl2oeCHtl6Tf3w,2759
+wwvb/dut1table.py,sha256=HVX1338RlQzAQ-bsMPEdmCqoyIxSWoJSoRu1YGyaJO4,875
+wwvb/gen.py,sha256=_fpUypu_2nZfG5Vjnya0B8C26nk1WOhnLMTCXwskAHs,3720
+wwvb/iersdata.json,sha256=cutY_J5jElAyLBsxfcDnP0eHY5fkQQ8Y1nDO77uEU4I,770
+wwvb/iersdata.json.license,sha256=1k5fhRCuOn0yXbwHtB21G0Nntnf0qMxstflMHuK3-Js,71
+wwvb/iersdata.py,sha256=_PSnGhNS5QU4AAk_aFbmR4Jru0pK_y-5JtNL6pAwtT8,1210
+wwvb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wwvb/tz.py,sha256=nlxKnzFPmqLLtC-cEDhWaJ3v3GCSPfqzVtUMf8EEdZ0,248
+wwvb/updateiers.py,sha256=2kIzgLD_109EpapdscZj7dGt8z-KzE7Yp4LhRi5NW7Q,5671
+wwvb/wwvbtk.py,sha256=QBJntkgLJPPjsxYC0szDZZXajijUbuwEmU_mjGEJ4GI,4599
+wwvb-5.0.0.dist-info/METADATA,sha256=nOmRifOcCGG1uEgKgr607Fxw-9vB8osk8IL1VBSQwug,10382
+wwvb-5.0.0.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+wwvb-5.0.0.dist-info/entry_points.txt,sha256=KSevvHWLEKxOxUQ-L-OQidD4Sj2BPEfhZ2TQhOgyys4,179
+wwvb-5.0.0.dist-info/top_level.txt,sha256=0IYdkhEAMgurpv_F-76rlyn4GdxepGFzG99tivVdQVU,11
+wwvb-5.0.0.dist-info/RECORD,,

{wwvb-4.1.0a0.dist-info → wwvb-5.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.3.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

wwvb-5.0.0.dist-info/entry_points.txt

@@ -0,0 +1,8 @@
+[console_scripts]
+dut1table = wwvb.dut1table:main
+updateiers = wwvb.updateiers:main
+wwvbdecode = wwvb.decode:main
+wwvbgen = wwvb.gen:main
+
+[gui_scripts]
+wwvbtk = wwvb.wwvbtk:main

wwvb-5.0.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+uwwvb
+wwvb

leapseconddata/__init__.py

@@ -1,342 +0,0 @@
-#!/usr/bin/env python3
-
-# SPDX-FileCopyrightText: 2021 Jeff Epler
-#
-# SPDX-License-Identifier: GPL-3.0-only
-
-"""Use the list of known and scheduled leap seconds
-
-For example, to retrieve the UTC-TAI offset on January 1, 2011:
-
-.. code-block:: python
-    :emphasize-lines: 2,3,5
-
-    >>> import datetime
-    >>> import leapseconddata
-    >>> ls = leapseconddata.LeapSecondData.from_standard_source()
-    >>> when = datetime.datetime(2011, 1, 1, tzinfo=datetime.timezone.utc)
-    >>> ls.tai_offset(when).total_seconds()
-    34.0
-
-"""
-
-from __future__ import annotations
-
-import datetime
-import hashlib
-import io
-import logging
-import pathlib
-import re
-import urllib.request
-from dataclasses import dataclass, field
-from typing import BinaryIO
-
-tai = datetime.timezone(datetime.timedelta(0), "TAI")
-
-NTP_EPOCH = datetime.datetime(1900, 1, 1, tzinfo=datetime.timezone.utc)
-
-
-@dataclass(frozen=True)
-class LeapSecondInfo:
-    """Information about a particular leap second"""
-
-    start: datetime.datetime
-    """The UTC timestamp just after the insertion of the leap second.
-
-    The leap second is actually the 61th second of the previous minute (xx:xx:60)"""
-
-    tai_offset: datetime.timedelta
-    """The new TAI-UTC offset.  Positive numbers indicate that TAI is ahead of UTC"""
-
-
-class ValidityError(ValueError):
-    """The leap second information is not valid for the given timestamp"""
-
-
-class InvalidHashError(ValueError):
-    """The file hash could not be verified"""
-
-
-def _from_ntp_epoch(value: int) -> datetime.datetime:
-    return NTP_EPOCH + datetime.timedelta(seconds=value)
-
-
-def datetime_is_tai(when: datetime.datetime) -> bool:
-    """Return true if the datetime is in the TAI timescale"""
-    return when.tzname() == "TAI"
-
-
-@dataclass(frozen=True)
-class LeapSecondData:
-    """Represent the list of known and scheduled leapseconds
-
-    :param List[LeapSecondInfo] leap_seconds: A list of leap seconds
-    :param Optional[datetime.datetime] valid_until: The expiration of the data
-    :param Optional[datetime.datetime] updated: The last update time of the data
-    """
-
-    leap_seconds: list[LeapSecondInfo]
-    """All known and scheduled leap seconds"""
-
-    valid_until: datetime.datetime | None = field(default=None)
-    """The list is valid until this UTC time"""
-
-    last_updated: datetime.datetime | None = field(default=None)
-    """The last time the list was updated to add a new upcoming leap second"""
-
-    def _check_validity(self, when: datetime.datetime | None) -> str | None:
-        if when is None:
-            when = datetime.datetime.now(datetime.timezone.utc)
-        if not self.valid_until:
-            return "Data validity unknown"
-        if when > self.valid_until:
-            return f"Data only valid until {self.valid_until:%Y-%m-%d}"
-        return None
-
-    def valid(self, when: datetime.datetime | None = None) -> bool:
-        """Return True if the data is valid at given datetime
-
-        If `when` is none, the validity for the current moment is checked.
-
-        :param when: Moment to check for validity
-        """
-        return self._check_validity(when) is None
-
-    @staticmethod
-    def _utc_datetime(when: datetime.datetime) -> datetime.datetime:
-        if when.tzinfo is not None and when.tzinfo is not datetime.timezone.utc:
-            when = when.astimezone(datetime.timezone.utc)
-        return when
-
-    def tai_offset(self, when: datetime.datetime, *, check_validity: bool = True) -> datetime.timedelta:
-        """For a given datetime, return the TAI-UTC offset
-
-        :param when: Moment in time to find offset for
-        :param check_validity: Check whether the database is valid for the given moment
-
-        For times before the first leap second, a zero offset is returned.
-        For times after the end of the file's validity, an exception is raised
-        unless `check_validity=False` is passed.  In this case, it will return
-        the offset of the last list entry.
-        """
-        is_tai = datetime_is_tai(when)
-        if not is_tai:
-            when = self._utc_datetime(when)
-        if check_validity:
-            message = self._check_validity(when)
-            if message is not None:
-                raise ValidityError(message)
-
-        if not self.leap_seconds:
-            return datetime.timedelta(0)
-
-        old_tai = datetime.timedelta()
-        for leap_second in self.leap_seconds:
-            start = leap_second.start
-            if is_tai:
-                start += leap_second.tai_offset - datetime.timedelta(seconds=1)
-            if when < start:
-                return old_tai
-            old_tai = leap_second.tai_offset
-        return self.leap_seconds[-1].tai_offset
-
-    def to_tai(self, when: datetime.datetime, *, check_validity: bool = True) -> datetime.datetime:
-        """Convert the given datetime object to TAI.
-
-        :param when: Moment in time to convert.  If naive, it is assumed to be in UTC.
-        :param check_validity: Check whether the database is valid for the given moment
-
-        Naive timestamps are assumed to be UTC.  A TAI timestamp is returned unchanged.
-        """
-        if datetime_is_tai(when):
-            return when
-        when = self._utc_datetime(when)
-        return (when + self.tai_offset(when, check_validity=check_validity)).replace(tzinfo=tai)
-
-    def tai_to_utc(self, when: datetime.datetime, *, check_validity: bool = True) -> datetime.datetime:
-        """Convert the given datetime object to UTC
-
-        For a leap second, the ``fold`` property of the returned time is True.
-
-        :param when: Moment in time to convert.  If not naive, its ``tzinfo`` must be `tai`.
-        :param check_validity: Check whether the database is valid for the given moment
-        """
-        if when.tzinfo is not None and when.tzinfo is not tai:
-            raise ValueError("Input timestamp is not TAI or naive")
-        if when.tzinfo is None:
-            when = when.replace(tzinfo=tai)
-        result = (when - self.tai_offset(when, check_validity=check_validity)).replace(tzinfo=datetime.timezone.utc)
-        if self.is_leap_second(when, check_validity=check_validity):
-            result = result.replace(fold=True)
-        return result
-
-    def is_leap_second(self, when: datetime.datetime, *, check_validity: bool = True) -> bool:
-        """Return True if the given timestamp is the leap second.
-
-        :param when: Moment in time to check.  If naive, it is assumed to be in UTC.
-        :param check_validity: Check whether the database is valid for the given moment
-
-        For a TAI timestamp, it returns True for the leap second (the one that
-        would be shown as :60 in UTC).  For a UTC timestamp, it returns True
-        for the :59 second if ``fold``, since the :60 second cannot be
-        represented.
-        """
-        if when.tzinfo is not tai:
-            when = self.to_tai(when, check_validity=check_validity) + datetime.timedelta(seconds=when.fold)
-        tai_offset1 = self.tai_offset(when, check_validity=check_validity)
-        tai_offset2 = self.tai_offset(when - datetime.timedelta(seconds=1), check_validity=check_validity)
-        return tai_offset1 != tai_offset2
-
-    @classmethod
-    def from_standard_source(
-        cls,
-        when: datetime.datetime | None = None,
-        *,
-        check_hash: bool = True,
-    ) -> LeapSecondData:
-        """Get the list of leap seconds from a standard source.
-
-        :param when: Check that the data is valid for this moment
-        :param check_hash: Whether to check the embedded hash
-
-        Using a list of standard sources, including network sources, find a
-        leap-second.list data valid for the given timestamp, or the current
-        time (if unspecified)
-        """
-        for location in [  # pragma no branch
-            "file:///usr/share/zoneinfo/leap-seconds.list",  # Debian Linux
-            "file:///var/db/ntpd.leap-seconds.list",  # FreeBSD
-            "https://raw.githubusercontent.com/eggert/tz/main/leap-seconds.list",
-            "https://www.meinberg.de/download/ntp/leap-seconds.list",
-        ]:
-            logging.debug("Trying leap second data from %s", location)
-            try:
-                candidate = cls.from_url(location, check_hash=check_hash)
-            except InvalidHashError:  # pragma no cover
-                logging.warning("Invalid hash while reading %s", location)
-                continue
-            if candidate is None:  # pragma no cover
-                continue
-            if candidate.valid(when):  # pragma no branch
-                logging.info("Using leap second data from %s", location)
-                return candidate
-            logging.warning("Validity expired for %s", location)  # pragma no cover
-
-        raise ValidityError("No valid leap-second.list file could be found")  # pragma no cover
-
-    @classmethod
-    def from_file(
-        cls,
-        filename: str = "/usr/share/zoneinfo/leap-seconds.list",
-        *,
-        check_hash: bool = True,
-    ) -> LeapSecondData:
-        """Retrieve the leap second list from a local file.
-
-        :param filename: Local filename to read leap second data from.  The
-            default is the standard location for the file on Debian systems.
-        :param check_hash: Whether to check the embedded hash
-        """
-        with pathlib.Path(filename).open("rb") as open_file:  # pragma no cover
-            return cls.from_open_file(open_file, check_hash=check_hash)
-
-    @classmethod
-    def from_url(
-        cls,
-        url: str = "https://raw.githubusercontent.com/eggert/tz/main/leap-seconds.list",
-        *,
-        check_hash: bool = True,
-    ) -> LeapSecondData | None:
-        """Retrieve the leap second list from a local file
-
-        :param filename: URL to read leap second data from.  The
-            default is maintained by the tzdata authors
-        :param check_hash: Whether to check the embedded hash
-        """
-        try:
-            with urllib.request.urlopen(url) as open_file:
-                return cls.from_open_file(open_file, check_hash=check_hash)
-        except urllib.error.URLError:  # pragma no cover
-            return None
-
-    @classmethod
-    def from_data(
-        cls,
-        data: bytes | str,
-        *,
-        check_hash: bool = True,
-    ) -> LeapSecondData:
-        """Retrieve the leap second list from local data
-
-        :param data: Data to parse as a leap second list
-        :param check_hash: Whether to check the embedded hash
-        """
-        if isinstance(data, str):
-            data = data.encode("ascii", "replace")
-        return cls.from_open_file(io.BytesIO(data), check_hash=check_hash)
-
-    @staticmethod
-    def _parse_content_hash(row: bytes) -> str:
-        """Transform the SHA1 content into a string that matches `hexdigest()`
-
-        The SHA1 hash of the leap second content is stored in an unusual way.
-        """
-        parts = row.split()
-        hash_parts = [int(s, 16) for s in parts[1:]]
-        return "".join(f"{i:08x}" for i in hash_parts)
-
-    @classmethod
-    def from_open_file(cls, open_file: BinaryIO, *, check_hash: bool = True) -> LeapSecondData:
-        """Retrieve the leap second list from an open file-like object
-
-        :param open_file: Binary IO object containing the leap second list
-        :param check_hash: Whether to check the embedded hash
-        """
-        leap_seconds: list[LeapSecondInfo] = []
-        valid_until = None
-        last_updated = None
-        content_to_hash = []
-        content_hash = None
-
-        hasher = hashlib.sha1()
-
-        for row in open_file:
-            row = row.strip()  # noqa: PLW2901
-            if row.startswith(b"#h"):
-                content_hash = cls._parse_content_hash(row)
-                continue
-
-            if row.startswith(b"#@"):
-                parts = row.split()
-                hasher.update(parts[1])
-                valid_until = _from_ntp_epoch(int(parts[1]))
-                continue
-
-            if row.startswith(b"#$"):
-                parts = row.split()
-                hasher.update(parts[1])
-                last_updated = _from_ntp_epoch(int(parts[1]))
-                continue
-
-            row = row.split(b"#")[0].strip()  # noqa: PLW2901
-            content_to_hash.extend(re.findall(rb"\d+", row))
-
-            parts = row.split()
-            if len(parts) != 2:  # noqa: PLR2004
-                continue
-            hasher.update(parts[0])
-            hasher.update(parts[1])
-
-            when = _from_ntp_epoch(int(parts[0]))
-            tai_offset = datetime.timedelta(seconds=int(parts[1]))
-            leap_seconds.append(LeapSecondInfo(when, tai_offset))
-
-        if check_hash:
-            if content_hash is None:
-                raise InvalidHashError("No #h line found")
-            digest = hasher.hexdigest()
-            if digest != content_hash:
-                raise InvalidHashError(f"Hash didn't match.  Expected {content_hash[:8]}..., got {digest[:8]}...")
-
-        return LeapSecondData(leap_seconds, valid_until, last_updated)