wwvb 4.0.0a0__py3-none-any.whl → 4.1.0a0__py3-none-any.whl

wwvb/decode.py

@@ -1,90 +0,0 @@
-# SPDX-FileCopyrightText: 2021 Jeff Epler
-#
-# SPDX-License-Identifier: GPL-3.0-only
-"""A stateful decoder of WWVB signals"""
-
-from __future__ import annotations
-
-import sys
-from typing import Generator
-
-import wwvb
-
-# State 1: Unsync'd
-#  Marker: State 2
-#  Other: State 1
-# State 2: One marker
-#  Marker: State 3
-#  Other: State 1
-# State 3: Two markers
-#  Marker: State 3
-#  Other: State 4
-# State 4: Decoding a minute, starting in second 1
-#  Second
-
-always_zero = {4, 10, 11, 14, 20, 21, 34, 35, 44, 54}
-
-
-def wwvbreceive() -> Generator[wwvb.WWVBTimecode | None, wwvb.AmplitudeModulation, None]:
-    """Decode WWVB signals statefully."""
-    minute: list[wwvb.AmplitudeModulation] = []
-    state = 1
-
-    value = yield None
-    while True:
-        # print(state, value, len(minute), "".join(str(int(i)) for i in minute))
-        if state == 1:
-            minute = []
-            if value == wwvb.AmplitudeModulation.MARK:
-                state = 2
-            value = yield None
-
-        elif state == 2:
-            state = 3 if value == wwvb.AmplitudeModulation.MARK else 1
-            value = yield None
-
-        elif state == 3:
-            if value != wwvb.AmplitudeModulation.MARK:
-                state = 4
-                minute = [wwvb.AmplitudeModulation.MARK, value]
-            value = yield None
-
-        else:  #  state == 4:
-            minute.append(value)
-            if len(minute) % 10 == 0 and value != wwvb.AmplitudeModulation.MARK:
-                # print("MISSING MARK", len(minute), "".join(str(int(i)) for i in minute))
-                state = 1
-            elif len(minute) % 10 and value == wwvb.AmplitudeModulation.MARK:
-                # print("UNEXPECTED MARK")
-                state = 1
-            elif len(minute) - 1 in always_zero and value != wwvb.AmplitudeModulation.ZERO:
-                # print("UNEXPECTED NONZERO")
-                state = 1
-            elif len(minute) == 60:
-                # print("FULL MINUTE")
-                tc = wwvb.WWVBTimecode(60)
-                tc.am[:] = minute
-                minute = []
-                state = 2
-                value = yield tc
-            else:
-                value = yield None
-
-
-def main() -> None:
-    """Read symbols on stdin and print any successfully-decoded minutes"""
-    decoder = wwvbreceive()
-    next(decoder)
-    decoder.send(wwvb.AmplitudeModulation.MARK)
-    for s in sys.argv[1:]:
-        for c in s:
-            decoded = decoder.send(wwvb.AmplitudeModulation(int(c)))
-            if decoded:
-                print(decoded)
-                w = wwvb.WWVBMinute.from_timecode_am(decoded)
-                if w:
-                    print(w)
-
-
-if __name__ == "__main__":  # pragma no cover
-    main()

wwvb/dut1table.py

@@ -1,32 +0,0 @@
-#!/usr/bin/env python3
-
-# SPDX-FileCopyrightText: 2021 Jeff Epler
-#
-# SPDX-License-Identifier: GPL-3.0-only
-
-"""Print the table of historical DUT1 values"""
-
-from datetime import timedelta
-from itertools import groupby
-
-import wwvb
-
-from .iersdata import DUT1_DATA_START, DUT1_OFFSETS
-
-
-def main() -> None:
-    """Print the table of historical DUT1 values"""
-    date = DUT1_DATA_START
-    for key, it in groupby(DUT1_OFFSETS):
-        dut1_ms = (ord(key) - ord("k")) / 10.0
-        count = len(list(it))
-        end = date + timedelta(days=count - 1)
-        dut1_next = wwvb.get_dut1(date + timedelta(days=count), warn_outdated=False)
-        ls = f" LS on {end:%F} 23:59:60 UTC" if dut1_ms * dut1_next < 0 else ""
-        print(f"{date:%F} {dut1_ms: 3.1f} {count:4d}{ls}")
-        date += timedelta(days=count)
-    print(date)
-
-
-if __name__ == "__main__":  # pragma no branch
-    main()

wwvb/gen.py

@@ -1,128 +0,0 @@
-#!/usr/bin/python3
-"""A command-line program for generating wwvb timecodes"""
-
-# Copyright (C) 2011-2020 Jeff Epler <jepler@gmail.com>
-# SPDX-FileCopyrightText: 2021 Jeff Epler
-#
-# SPDX-License-Identifier: GPL-3.0-only
-
-from __future__ import annotations
-
-import datetime
-import sys
-from typing import Any
-
-import click
-import dateutil.parser
-
-from . import WWVBMinute, WWVBMinuteIERS, print_timecodes, print_timecodes_json, styles
-
-
-def parse_timespec(ctx: Any, param: Any, value: list[str]) -> datetime.datetime:  # noqa: ARG001
-    """Parse a time specifier from the commandline"""
-    try:
-        if len(value) == 5:
-            year, month, day, hour, minute = map(int, value)
-            return datetime.datetime(year, month, day, hour, minute, tzinfo=datetime.timezone.utc)
-        if len(value) == 4:
-            year, yday, hour, minute = map(int, value)
-            return datetime.datetime(year, 1, 1, hour, minute, tzinfo=datetime.timezone.utc) + datetime.timedelta(
-                days=yday - 1,
-            )
-        if len(value) == 1:
-            return dateutil.parser.parse(value[0])
-        if len(value) == 0:
-            return datetime.datetime.now(datetime.timezone.utc)
-        raise ValueError("Unexpected number of arguments")
-    except ValueError as e:
-        raise click.UsageError(f"Could not parse timespec: {e}") from e
-
-
-@click.command()
-@click.option(
-    "--iers/--no-iers",
-    "-i/-I",
-    default=True,
-    help="Whether to use IESR data for DUT1 and LS.  (Default: --iers)",
-)
-@click.option(
-    "--leap-second",
-    "-s",
-    "leap_second",
-    flag_value=1,
-    default=None,
-    help="Force a positive leap second at the end of the GMT month (Implies --no-iers)",
-)
-@click.option(
-    "--negative-leap-second",
-    "-n",
-    "leap_second",
-    flag_value=-1,
-    help="Force a negative leap second at the end of the GMT month (Implies --no-iers)",
-)
-@click.option(
-    "--no-leap-second",
-    "-S",
-    "leap_second",
-    flag_value=0,
-    help="Force no leap second at the end of the month (Implies --no-iers)",
-)
-@click.option("--dut1", "-d", type=int, help="Force the DUT1 value (Implies --no-iers)")
-@click.option("--minutes", "-m", default=10, help="Number of minutes to show (default: 10)")
-@click.option(
-    "--style",
-    default="default",
-    type=click.Choice(sorted(["json", *list(styles.keys())])),
-    help="Style of output",
-)
-@click.option(
-    "--all-timecodes/--no-all-timecodes",
-    "-t/-T",
-    default=False,
-    type=bool,
-    help="Show the 'WWVB timecode' line before each minute",
-)
-@click.option(
-    "--channel",
-    type=click.Choice(["amplitude", "phase", "both"]),
-    default="amplitude",
-    help="Modulation to show (default: amplitude)",
-)
-@click.argument("timespec", type=str, nargs=-1, callback=parse_timespec)
-def main(
-    *,
-    iers: bool,
-    leap_second: bool,
-    dut1: int,
-    minutes: int,
-    style: str,
-    channel: str,
-    all_timecodes: bool,
-    timespec: datetime.datetime,
-) -> None:
-    """Generate WWVB timecodes
-
-    TIMESPEC: one of "year yday hour minute" or "year month day hour minute", or else the current minute
-    """
-    if (leap_second is not None) or (dut1 is not None):
-        iers = False
-
-    newut1 = None
-    newls = None
-
-    if iers:
-        constructor: type[WWVBMinute] = WWVBMinuteIERS
-    else:
-        constructor = WWVBMinute
-        newut1 = -500 * (leap_second or 0) if dut1 is None else dut1
-        newls = bool(leap_second)
-
-    w = constructor.from_datetime(timespec, newls=newls, newut1=newut1)
-    if style == "json":
-        print_timecodes_json(w, minutes, channel, file=sys.stdout)
-    else:
-        print_timecodes(w, minutes, channel, style, all_timecodes=all_timecodes, file=sys.stdout)
-
-
-if __name__ == "__main__":  # pragma no branch
-    main()

wwvb/iersdata.py

@@ -1,28 +0,0 @@
-# -*- python3 -*-
-"""Retrieve iers data, possibly from user or site data or from the wwvbpy distribution"""
-
-# Copyright (C) 2021 Jeff Epler <jepler@gmail.com>
-# SPDX-FileCopyrightText: 2021 Jeff Epler
-#
-# SPDX-License-Identifier: GPL-3.0-only
-
-import datetime
-import pathlib
-
-import platformdirs
-
-__all__ = ["DUT1_DATA_START", "DUT1_OFFSETS", "start", "span", "end"]
-from .iersdata_dist import DUT1_DATA_START, DUT1_OFFSETS
-
-for location in [
-    platformdirs.user_data_dir("wwvbpy", "unpythonic.net"),
-    platformdirs.site_data_dir("wwvbpy", "unpythonic.net"),
-]:  # pragma no cover
-    path = pathlib.Path(location) / "wwvbpy_iersdata.py"
-    if path.exists():
-        exec(path.read_text(encoding="utf-8"), globals(), globals())
-        break
-
-start = datetime.datetime.combine(DUT1_DATA_START, datetime.time()).replace(tzinfo=datetime.timezone.utc)
-span = datetime.timedelta(days=len(DUT1_OFFSETS))
-end = start + span

wwvb/iersdata_dist.py

@@ -1,38 +0,0 @@
-# -*- python3 -*-
-# fmt: off
-"""File generated from public data - not subject to copyright"""
-# SPDX-FileCopyrightText: Public domain
-# SPDX-License-Identifier: CC0-1.0
-# isort: skip_file
-import datetime
-__all__ = ["DUT1_DATA_START", "DUT1_OFFSETS"]
-DUT1_DATA_START = datetime.date(1972, 1, 1)
-d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s = tuple("defghijklmnopqrs")
-DUT1_OFFSETS = str( # 19720101
-    i*182+s*123+k*30+i*31+s*19+r*31+q*29+p*28+o*30+n*36+m*40     # 19730909
-    +l*39+k*33+j*31+i*31+h*18+r*19+q*38+p*32+o*31+n*33+m*48+l*45 # 19741010
-    +k*37+j*33+i*34+h*15+r*22+q*34+p*33+o*34+n*37+m*49+l*45+k*36 # 19751118
-    +j*32+i*36+h*7+r*28+q*33+p*32+o*30+n*33+m*42+l*42+k*34+j*29  # 19761201
-    +i*33+h*30+r*6+q*36+p*34+o*31+n*32+m*42+l*51+k*37+j*32+i*33  # 19771231
-    +h*31+q*32+p*29+o*29+n*30+m*32+l*47+k*47+j*36+i*33+h*32+g*18 # 19790116
-    +q*16+p*35+o*33+n*32+m*35+l*45+k*51+j*39+i*39+h*38+g*2+q*40  # 19800319
-    +p*39+o*38+n*43+m*57+l*50+k*39+j*42+i*41+h*43+g*37+f*39+e*39 # 19810719
-    +o*19+n*62+m*43+l*45+k*48+j*44+i*39+h*44+g*21+q*44+p*48+o*43 # 19821223
-    +n*41+m*36+l*34+k*34+j*38+i*47+s+r*64+q*50+p*42+o*56+n*57    # 19840517
-    +m*52+l*100+k*61+j*62+i*66+h*52+g*67+f+p*103+o*56+n*68+m*69  # 19860807
-    +l*107+k*82+j*72+i*67+h*63+g*113+f*63+e*51+o*11+n*60+m*59    # 19880907
-    +l*121+k*71+j*71+i*67+h*57+g*93+f*61+e*48+d*12+n*41+m*44     # 19900511
-    +l*46+k*61+j*66+i*47+h*45+g*15+q*32+p*44+o*41+n*48+m*74+l*49 # 19911129
-    +k*45+j*44+i*40+h*37+g*38+f*50+e*5+o*60+n*49+m*40+l*40+k*38  # 19930322
-    +j*38+i*36+h*39+g*25+q*31+p*50+o*41+n*41+m*43+l*41+k*39+j*40 # 19940630
-    +i*39+s*24+r*57+q*43+p*41+o*39+n*38+m*35+l*37+k*43+j*69+i*44 # 19951124
-    +h*42+g*37+q*4+p*51+o*45+n*44+m*69+l*70+k*50+j*54+i*53+h*40  # 19970612
-    +g*49+f*18+p*59+o*53+n*52+m*57+l*48+k*53+j*127+i*70+h*30     # 19990303
-    +r*62+q*79+p*152+o*82+n*106+m*184+l*125+k*217+j*133+i*252    # 20030402
-    +h*161+g*392+f*322+e*290+n*116+m*154+l*85+k*83+j*91+i*168    # 20080312
-    +h*105+g*147+f*105+e*42+o*70+n*91+m*154+l*119+k*84+j*217     # 20110511
-    +i*126+h*176+g*97+f*91+e*52+o*116+n*98+m*70+l*133+k*91+j*91  # 20140507
-    +i*77+h*140+g*91+f*84+e*70+d*34+n*72+m*76+l*66+k*53+j*56     # 20160831
-    +i*105+h*77+g*45+q*25+p*63+o*91+n*154+m*105+l*190+k*118      # 20190501
-    +j*105+i*807+j*376+k*768+l*47+k*3+l*4+k*252,                  # 20250705
-)

wwvb/testcli.py

@@ -1,291 +0,0 @@
-#!/usr/bin/python3
-"""Test most wwvblib commandline programs"""
-
-# ruff: noqa: N802 D102
-# Copyright (C) 2011-2020 Jeff Epler <jepler@gmail.com>
-# SPDX-FileCopyrightText: 2021 Jeff Epler
-#
-# SPDX-License-Identifier: GPL-3.0-only
-
-import json
-import os
-import subprocess
-import sys
-import unittest
-from typing import Any, Sequence
-
-coverage_add = ("-m", "coverage", "run", "--branch", "-p") if "COVERAGE_RUN" in os.environ else ()
-
-
-class CLITestCase(unittest.TestCase):
-    """Test various CLI commands within wwvbpy"""
-
-    def programOutput(self, *args: str) -> str:
-        env = os.environ.copy()
-        env["PYTHONIOENCODING"] = "utf-8"
-        return subprocess.check_output(args, stdin=subprocess.DEVNULL, encoding="utf-8", env=env)
-
-    def moduleArgs(self, *args: str) -> Sequence[str]:
-        return (sys.executable, *coverage_add, "-m", *args)
-
-    def moduleOutput(self, *args: str) -> str:
-        return self.programOutput(sys.executable, *coverage_add, "-m", *args)
-
-    def assertProgramOutput(self, expected: str, *args: str) -> None:
-        """Check the output from invoking a program matches the expected"""
-        actual = self.programOutput(*args)
-        self.assertMultiLineEqual(expected, actual, f"args={args}")
-
-    def assertProgramOutputStarts(self, expected: str, *args: str) -> None:
-        """Check the output from invoking a program matches the expected"""
-        actual = self.programOutput(*args)
-        self.assertMultiLineEqual(expected, actual[: len(expected)], f"args={args}")
-
-    def assertModuleOutput(self, expected: str, *args: str) -> None:
-        """Check the output from invoking a `python -m modulename` program matches the expected"""
-        actual = self.moduleOutput(*args)
-        self.assertMultiLineEqual(expected, actual, f"args={args}")
-
-    def assertStarts(self, expected: str, actual: str, *args: str) -> None:
-        self.assertMultiLineEqual(expected, actual[: len(expected)], f"args={args}")
-
-    def assertModuleJson(self, expected: Any, *args: str) -> None:
-        """Check the output from invoking a `python -m modulename` program matches the expected"""
-        actual = self.moduleOutput(*args)
-        self.assertEqual(json.loads(actual), expected)
-
-    def assertModuleOutputStarts(self, expected: str, *args: str) -> None:
-        """Check the output from invoking a `python -m modulename` program matches the expected"""
-        actual = self.moduleOutput(*args)
-        self.assertStarts(expected, actual, *args)
-
-    def assertProgramError(self, *args: str) -> None:
-        """Check the output from invoking a program fails"""
-        env = os.environ.copy()
-        env["PYTHONIOENCODING"] = "utf-8"
-        with self.assertRaises(subprocess.SubprocessError):
-            subprocess.check_output(
-                args,
-                stdin=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-                encoding="utf-8",
-                env=env,
-            )
-
-    def assertModuleError(self, *args: str) -> None:
-        """Check the output from invoking a `python -m modulename` program fails"""
-        self.assertProgramError(*self.moduleArgs(*args))
-
-    def test_gen(self) -> None:
-        """Test wwvb.gen"""
-        self.assertModuleOutput(
-            """\
-WWVB timecode: year=2020 days=001 hour=12 min=30 dst=0 ut1=-200 ly=1 ls=0
-2020-001 12:30  201100000200010001020000000002000100010200100001020000010002
-""",
-            "wwvb.gen",
-            "-m",
-            "1",
-            "2020-1-1 12:30",
-        )
-
-        self.assertModuleOutput(
-            """\
-WWVB timecode: year=2020 days=001 hour=12 min=30 dst=0 ut1=-200 ly=1 ls=0
-2020-001 12:30  201100000200010001020000000002000100010200100001020000010002
-""",
-            "wwvb.gen",
-            "-m",
-            "1",
-            "2020",
-            "1",
-            "12",
-            "30",
-        )
-
-        self.assertModuleOutput(
-            """\
-WWVB timecode: year=2020 days=001 hour=12 min=30 dst=0 ut1=-200 ly=1 ls=0
-2020-001 12:30  201100000200010001020000000002000100010200100001020000010002
-""",
-            "wwvb.gen",
-            "-m",
-            "1",
-            "2020",
-            "1",
-            "1",
-            "12",
-            "30",
-        )
-
-        self.assertModuleError("wwvb.gen", "-m", "1", "2021", "7")
-
-        # Asserting a leap second
-        self.assertModuleOutput(
-            """\
-WWVB timecode: year=2020 days=001 hour=12 min=30 dst=0 ut1=-500 ly=1 ls=1
-2020-001 12:30  201100000200010001020000000002000100010201010001020000011002
-""",
-            "wwvb.gen",
-            "-m",
-            "1",
-            "-s",
-            "2020-1-1 12:30",
-        )
-
-        # Asserting a different ut1 value
-        self.assertModuleOutput(
-            """\
-WWVB timecode: year=2020 days=001 hour=12 min=30 dst=0 ut1=-300 ly=1 ls=0
-2020-001 12:30  201100000200010001020000000002000100010200110001020000010002
-""",
-            "wwvb.gen",
-            "-m",
-            "1",
-            "-d",
-            "-300",
-            "2020-1-1 12:30",
-        )
-
-    def test_dut1table(self) -> None:
-        """Test the dut1table program"""
-        self.assertModuleOutputStarts(
-            """\
-1972-01-01 -0.2  182 LS on 1972-06-30 23:59:60 UTC
-1972-07-01  0.8  123
-1972-11-01  0.0   30
-1972-12-01 -0.2   31 LS on 1972-12-31 23:59:60 UTC
-""",
-            "wwvb.dut1table",
-        )
-
-    def test_json(self) -> None:
-        """Test the JSON output format"""
-        self.assertModuleJson(
-            [
-                {
-                    "year": 2021,
-                    "days": 340,
-                    "hour": 3,
-                    "minute": 40,
-                    "amplitude": "210000000200000001120011001002000000010200010001020001000002",
-                    "phase": "111110011011010101000100100110011110001110111010111101001011",
-                },
-                {
-                    "year": 2021,
-                    "days": 340,
-                    "hour": 3,
-                    "minute": 41,
-                    "amplitude": "210000001200000001120011001002000000010200010001020001000002",
-                    "phase": "001010011100100011000101110000100001101000001111101100000010",
-                },
-            ],
-            "wwvb.gen",
-            "-m",
-            "2",
-            "--style",
-            "json",
-            "--channel",
-            "both",
-            "2021-12-6 3:40",
-        )
-        self.assertModuleJson(
-            [
-                {
-                    "year": 2021,
-                    "days": 340,
-                    "hour": 3,
-                    "minute": 40,
-                    "amplitude": "210000000200000001120011001002000000010200010001020001000002",
-                },
-                {
-                    "year": 2021,
-                    "days": 340,
-                    "hour": 3,
-                    "minute": 41,
-                    "amplitude": "210000001200000001120011001002000000010200010001020001000002",
-                },
-            ],
-            "wwvb.gen",
-            "-m",
-            "2",
-            "--style",
-            "json",
-            "--channel",
-            "amplitude",
-            "2021-12-6 3:40",
-        )
-        self.assertModuleJson(
-            [
-                {
-                    "year": 2021,
-                    "days": 340,
-                    "hour": 3,
-                    "minute": 40,
-                    "phase": "111110011011010101000100100110011110001110111010111101001011",
-                },
-                {
-                    "year": 2021,
-                    "days": 340,
-                    "hour": 3,
-                    "minute": 41,
-                    "phase": "001010011100100011000101110000100001101000001111101100000010",
-                },
-            ],
-            "wwvb.gen",
-            "-m",
-            "2",
-            "--style",
-            "json",
-            "--channel",
-            "phase",
-            "2021-12-6 3:40",
-        )
-
-    def test_sextant(self) -> None:
-        """Test the sextant output format"""
-        self.assertModuleOutput(
-            """\
-WWVB timecode: year=2021 days=340 hour=03 min=40 dst=0 ut1=-100 ly=0 ls=0 --style=sextant
-2021-340 03:40  \
-🬋🬩🬋🬹🬩🬹🬩🬹🬩🬹🬍🬎🬍🬎🬩🬹🬩🬹🬋🬍🬩🬹🬩🬹🬍🬎🬩🬹🬍🬎🬩🬹🬍🬎🬋🬹🬋🬎🬋🬍🬍🬎🬩🬹🬋🬎🬋🬎🬩🬹🬍🬎🬋🬎🬩🬹🬩🬹🬋🬍🬍🬎🬩🬹🬩🬹🬩🬹🬩🬹🬍🬎🬍🬎🬋🬎🬩🬹🬋🬩🬩🬹🬍🬎🬩🬹🬋🬹🬩🬹🬍🬎🬩🬹🬋🬎🬩🬹🬋🬩🬩🬹🬩🬹🬍🬎🬋🬹🬍🬎🬍🬎🬩🬹🬍🬎🬩🬹🬋🬩
-
-2021-340 03:41  \
-🬋🬍🬋🬎🬩🬹🬍🬎🬩🬹🬍🬎🬍🬎🬩🬹🬋🬹🬋🬩🬍🬎🬍🬎🬩🬹🬍🬎🬍🬎🬍🬎🬩🬹🬋🬹🬋🬎🬋🬍🬍🬎🬩🬹🬋🬎🬋🬹🬩🬹🬩🬹🬋🬎🬍🬎🬍🬎🬋🬍🬩🬹🬍🬎🬍🬎🬍🬎🬍🬎🬩🬹🬩🬹🬋🬎🬩🬹🬋🬍🬍🬎🬍🬎🬍🬎🬋🬎🬩🬹🬩🬹🬩🬹🬋🬹🬩🬹🬋🬍🬩🬹🬩🬹🬍🬎🬋🬎🬍🬎🬍🬎🬍🬎🬍🬎🬩🬹🬋🬍
-
-""",
-            "wwvb.gen",
-            "-m",
-            "2",
-            "--style",
-            "sextant",
-            "2021-12-6 3:40",
-        )
-
-    def test_now(self) -> None:
-        """Test outputting timecodes for 'now'"""
-        self.assertModuleOutputStarts(
-            "WWVB timecode: year=",
-            "wwvb.gen",
-            "-m",
-            "1",
-        )
-
-    def test_decode(self) -> None:
-        """Test the commandline decoder"""
-        self.assertModuleOutput(
-            """\
-201100000200100001020011001012000000010200010001020001000002
-year=2021 days=350 hour=22 min=30 dst=0 ut1=-100 ly=0 ls=0
-""",
-            "wwvb.decode",
-            "201100000200100001020011001012000000010200010001020001000002",
-        )
-
-        self.assertModuleOutput(
-            """\
-201101111200100001020011001012000000010200010001020001000002
-""",
-            "wwvb.decode",
-            "201101111200100001020011001012000000010200010001020001000002",
-        )

wwvb/testdaylight.py

@@ -1,60 +0,0 @@
-#!/usr/bin/python3
-"""Test of daylight saving time calculations"""
-
-# SPDX-FileCopyrightText: 2021 Jeff Epler
-#
-# SPDX-License-Identifier: GPL-3.0-only
-
-import datetime
-import unittest
-
-import wwvb
-from wwvb.tz import Mountain
-
-
-class TestDaylight(unittest.TestCase):
-    """Test of daylight saving time calculations"""
-
-    def test_onset(self) -> None:
-        """Test that the onset of DST is the same in Mountain and WWVBMinute (which uses ls bits)"""
-        for h in [8, 9, 10]:
-            for dm in range(-1441, 1442):
-                d = datetime.datetime(2021, 3, 14, h, 0, tzinfo=datetime.timezone.utc) + datetime.timedelta(minutes=dm)
-                m = wwvb.WWVBMinute.from_datetime(d)
-                self.assertEqual(
-                    m.as_datetime_local().replace(tzinfo=Mountain),
-                    d.astimezone(Mountain),
-                )
-
-    def test_end(self) -> None:
-        """Test that the end of DST is the same in Mountain and WWVBMinute (which uses ls bits)"""
-        for h in [7, 8, 9]:
-            for dm in range(-1441, 1442):
-                d = datetime.datetime(2021, 11, 7, h, 0, tzinfo=datetime.timezone.utc) + datetime.timedelta(minutes=dm)
-                m = wwvb.WWVBMinute.from_datetime(d)
-                self.assertEqual(
-                    m.as_datetime_local().replace(tzinfo=Mountain),
-                    d.astimezone(Mountain),
-                )
-
-    def test_midsummer(self) -> None:
-        """Test that middle of DST is the same in Mountain and WWVBMinute (which uses ls bits)"""
-        for h in [7, 8, 9]:
-            for dm in (-1, 0, 1):
-                d = datetime.datetime(2021, 7, 7, h, 0, tzinfo=datetime.timezone.utc) + datetime.timedelta(minutes=dm)
-                m = wwvb.WWVBMinute.from_datetime(d)
-                self.assertEqual(
-                    m.as_datetime_local().replace(tzinfo=Mountain),
-                    d.astimezone(Mountain),
-                )
-
-    def test_midwinter(self) -> None:
-        """Test that middle of standard time is the same in Mountain and WWVBMinute (which uses ls bits)"""
-        for h in [7, 8, 9]:
-            for dm in (-1, 0, 1):
-                d = datetime.datetime(2021, 12, 25, h, 0, tzinfo=datetime.timezone.utc) + datetime.timedelta(minutes=dm)
-                m = wwvb.WWVBMinute.from_datetime(d)
-                self.assertEqual(
-                    m.as_datetime_local().replace(tzinfo=Mountain),
-                    d.astimezone(Mountain),
-                )