gpstime 0.9.2__tar.gz → 0.10.0__tar.gz

{gpstime-0.9.2/gpstime.egg-info → gpstime-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gpstime
-Version: 0.9.2
+Version: 0.10.0
 Summary: GPS-aware datetime module
 Author-email: Jameson Graef Rollins <jameson.rollins@ligo.org>
 License-Expression: GPL-3.0-or-later
@@ -18,6 +18,8 @@ Requires-Dist: platformdirs; python_version >= "3.10"
 Requires-Dist: appdirs; python_version < "3.10"
 Requires-Dist: python-dateutil
 Requires-Dist: requests
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
 Dynamic: license-file
 
 GPS-aware datetime module

{gpstime-0.9.2 → gpstime-0.10.0}/gpstime/__init__.py

@@ -24,7 +24,7 @@ import argparse
 import subprocess
 
 from dateutil.parser import parse as duparse
-from dateutil.tz import tzutc, tzlocal
+from dateutil.tz import tzutc, tzlocal, tzoffset
 
 try:
     from .__version__ import version as __version__
@@ -36,7 +36,7 @@ except ModuleNotFoundError:
     # (3.2.0-1)
     except TypeError:
         __version__ = setuptools_scm.get_version()
-    except LookupError:
+    except Exception:
         __version__ = '?.?.?'
 
 from .leaps import LEAPDATA
@@ -49,6 +49,37 @@ ISO_FORMAT = '%Y-%m-%dT%H:%M:%S.%fZ'
 # UNIX time for GPS 0 (1980-01-06T00:00:00Z)
 GPS0 = 315964800
 
+# Timezone abbreviation mappings for dateutil parser.
+# These are needed because abbreviations like "PST" are ambiguous and not
+# part of the IANA timezone database. Without this mapping, dateutil will
+# only recognize abbreviations that match the current local timezone.
+# Note: Some abbreviations are ambiguous (e.g., CST = US Central or China Standard).
+# We default to US interpretations for ambiguous abbreviations.
+TZINFOS = {
+    # US timezones
+    'PST': tzoffset('PST', -8*3600),   # Pacific Standard Time
+    'PDT': tzoffset('PDT', -7*3600),   # Pacific Daylight Time
+    'MST': tzoffset('MST', -7*3600),   # Mountain Standard Time
+    'MDT': tzoffset('MDT', -6*3600),   # Mountain Daylight Time
+    'CST': tzoffset('CST', -6*3600),   # Central Standard Time (US)
+    'CDT': tzoffset('CDT', -5*3600),   # Central Daylight Time
+    'EST': tzoffset('EST', -5*3600),   # Eastern Standard Time
+    'EDT': tzoffset('EDT', -4*3600),   # Eastern Daylight Time
+    # European timezones
+    'GMT': tzoffset('GMT', 0),         # Greenwich Mean Time
+    'UTC': tzoffset('UTC', 0),         # Coordinated Universal Time
+    'WET': tzoffset('WET', 0),         # Western European Time
+    'WEST': tzoffset('WEST', 1*3600),  # Western European Summer Time
+    'CET': tzoffset('CET', 1*3600),    # Central European Time
+    'CEST': tzoffset('CEST', 2*3600),  # Central European Summer Time
+    'EET': tzoffset('EET', 2*3600),    # Eastern European Time
+    'EEST': tzoffset('EEST', 3*3600),  # Eastern European Summer Time
+    # Other common timezones
+    'JST': tzoffset('JST', 9*3600),    # Japan Standard Time
+    'KST': tzoffset('KST', 9*3600),    # Korea Standard Time
+    'IST': tzoffset('IST', 5*3600+1800),  # India Standard Time (UTC+5:30)
+}
+
 ##################################################
 
 
@@ -89,7 +120,7 @@ def _du_date_parse(string='now'):
     """Parse date/time string to UNIX timestamp with dateutils parse
 
     """
-    return float(duparse(string).timestamp())
+    return float(duparse(string, tzinfos=TZINFOS).timestamp())
 
 
 def _date_parse(string="now"):

{gpstime-0.9.2 → gpstime-0.10.0}/gpstime/__main__.py

@@ -1,11 +1,40 @@
 import argparse
+import os
+import sys
+from datetime import datetime
 
-from dateutil.tz import tzutc, tzlocal
+from dateutil.tz import tzutc, tzlocal, gettz
 
 from . import __version__
 from . import ISO_FORMAT, gpstime, GPSTimeParseAction
 
 
+def check_tz_validity():
+    """Check if TZ environment variable is valid.
+
+    Some timezone abbreviations (like 'EDT') are not valid POSIX timezone
+    values and will cause the system to fall back to UTC. This function
+    detects this condition and warns the user.
+
+    Returns:
+        True if TZ is unset or valid, False if TZ is set but invalid.
+    """
+    tz_env = os.environ.get('TZ')
+    if not tz_env:
+        return True
+
+    # Use dateutil's gettz to check if TZ is recognized.
+    # gettz returns tzlocal() for unrecognized values, and tzfile() for valid ones.
+    tz_result = gettz(tz_env)
+    if isinstance(tz_result, tzlocal):
+        print(f"warning: TZ='{tz_env}' is not a valid timezone specification; "
+              f"use IANA names (e.g., 'America/New_York') or POSIX format "
+              f"(e.g., 'EST5EDT')",
+              file=sys.stderr)
+        return False
+    return True
+
+
 PARSER = argparse.ArgumentParser(
     description="""GPS time conversion
 
@@ -54,6 +83,11 @@ def tzname(tz):
 def main():
     args = PARSER.parse_args()
 
+    tz_valid = check_tz_validity()
+
+    if args.tz == 'local' and not tz_valid:
+        sys.exit("error: -l/--local requires a valid TZ environment variable")
+
     if args.tz == 'gps' and args.format == ISO_FORMAT:
         PARSER.error("argument -g/--gps: not allowed with argument -i/--iso")
 
@@ -70,7 +104,8 @@ def main():
     if not args.tz:
         ltz = tzlocal()
         utz = tzutc()
-        print('{}: {}'.format(tzname(ltz), gt.astimezone(ltz).strftime(args.format)))
+        if tz_valid:
+            print('{}: {}'.format(tzname(ltz), gt.astimezone(ltz).strftime(args.format)))
         print('{}: {}'.format('UTC', gt.astimezone(utz).strftime(args.format)))
         print('{}: {:.6f}'.format('GPS', gps))
     elif args.tz == 'gps':

{gpstime-0.9.2 → gpstime-0.10.0}/gpstime/__version__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.9.2'
-__version_tuple__ = version_tuple = (0, 9, 2)
+__version__ = version = '0.10.0'
+__version_tuple__ = version_tuple = (0, 10, 0)
 
-__commit_id__ = commit_id = 'gfa330f139'
+__commit_id__ = commit_id = 'g4e7f71cba'

gpstime-0.10.0/gpstime/test_gpstime.py

@@ -0,0 +1,502 @@
+import datetime
+import os
+import shutil
+import sys
+import time
+from contextlib import contextmanager
+
+import pytest
+from dateutil.tz import tzutc
+
+import gpstime
+
+
+@contextmanager
+def temporary_tz(tz_value):
+    """Context manager to temporarily set the TZ environment variable."""
+    old_tz = os.environ.get('TZ')
+    try:
+        if tz_value is None:
+            os.environ.pop('TZ', None)
+        else:
+            os.environ['TZ'] = tz_value
+        time.tzset()
+        yield
+    finally:
+        if old_tz is None:
+            os.environ.pop('TZ', None)
+        else:
+            os.environ['TZ'] = old_tz
+        time.tzset()
+
+
+def cu_date_available():
+    """return True if coreutils date parser available"""
+    return shutil.which("date") is not None
+
+
+# Helper functions for roundtrip tests
+def roundtrip_gps(gps):
+    assert gpstime.unix2gps(gpstime.gps2unix(gps)) == gps
+
+
+def roundtrip_unix(unix):
+    assert gpstime.gps2unix(gpstime.unix2gps(unix)) == unix
+
+
+##################################################
+
+
+def test_conversion():
+    assert gpstime.gps2unix(1133585676) == 1449550459
+    assert gpstime.unix2gps(1449550459) == 1133585676
+    assert 1133585676 == gpstime.unix2gps(gpstime.gps2unix(1133585676))
+
+
+def test_conversion_past():
+    assert gpstime.gps2unix(123456789) == 439421586
+    assert gpstime.unix2gps(439421586) == 123456789
+
+
+def test_conversion_onleap():
+    assert gpstime.gps2unix(425520006) == 741484798
+    assert gpstime.gps2unix(425520007) == 741484799
+    assert gpstime.gps2unix(425520008) == 741484799
+    assert gpstime.gps2unix(425520009) == 741484800
+    assert gpstime.unix2gps(741484798) == 425520006
+    assert gpstime.unix2gps(741484799) == 425520007
+    assert gpstime.unix2gps(741484800) == 425520009
+
+
+def test_roundtrip():
+    roundtrip_gps(123456789)
+    roundtrip_unix(439421586)
+
+
+@pytest.mark.xfail
+def test_roundtrip_onleap():
+    roundtrip_gps(425520008)
+
+
+def test_gpstime_new():
+    assert gpstime.gpstime(2015, 12, 8, 4, 54, 19, 0, tzutc()).gps() == 1133585676.0
+
+
+def test_gpstime_fromdatetime():
+    dt = datetime.datetime(2015, 12, 8, 4, 54, 19, 0, tzutc())
+    gt = gpstime.gpstime.fromdatetime(dt)
+    assert isinstance(gt, gpstime.gpstime)
+    assert gt.gps() == 1133585676.0
+
+
+def test_gpstime_parse_now_roundtrip():
+    gt0 = gpstime.gpstime.parse()
+    gt1 = gpstime.gpstime.parse(gt0.gps())
+    assert gt0 == gt1
+
+
+def test_gpstime_parse_utc():
+    assert gpstime.gpstime.parse('Dec 08 2015 04:54:19.2 UTC').gps() == 1133585676.2
+
+
+def test_gpstime_parse_utc2():
+    assert gpstime.gpstime.parse('2014-07-03 17:16:14 UTC').gps() == 1088442990.0
+
+
+def test_gpstime_parse_local():
+    assert gpstime.gpstime.parse('Dec 08 2015 04:54:19.2 PST').gps() == 1133614476.2
+
+
+def test_gpstime_parse_gps():
+    assert gpstime.gpstime.parse(1133585676.2).gps() == 1133585676.2
+
+
+def test_gpstime_parse_gps_iso():
+    assert gpstime.gpstime.parse(1133585676.2).iso() == '2015-12-08T04:54:19.200000Z'
+
+
+def test_gpstime_parse_iso():
+    assert gpstime.gpstime.parse('2015-12-08T04:54:19.200000Z').iso() == '2015-12-08T04:54:19.200000Z'
+
+
+def test_gpstime_parse_iso_alt():
+    assert gpstime.gpstime.parse('2015-12-08_04:54:19.200000Z').iso() == '2015-12-08T04:54:19.200000Z'
+
+
+@pytest.mark.skipif(not cu_date_available(), reason="coreutils date not available")
+def test_gpstime_parse_timestamp():
+    assert gpstime.gpstime.parse('@1474821047').gps() == 1158856264
+
+
+@pytest.mark.skipif(not cu_date_available(), reason="coreutils date not available")
+def test_gpstime_parse_now0():
+    assert isinstance(gpstime.gpstime.parse(), gpstime.gpstime)
+
+
+@pytest.mark.skipif(not cu_date_available(), reason="coreutils date not available")
+def test_gpstime_parse_now1():
+    assert isinstance(gpstime.gpstime.parse('now'), gpstime.gpstime)
+
+
+@pytest.mark.skipif(not cu_date_available(), reason="coreutils date not available")
+def test_gpstime_parse_relative0():
+    assert isinstance(gpstime.gpstime.parse('yesterday'), gpstime.gpstime)
+
+
+@pytest.mark.skipif(not cu_date_available(), reason="coreutils date not available")
+def test_gpstime_parse_relative1():
+    assert isinstance(gpstime.gpstime.parse('1 month ago'), gpstime.gpstime)
+
+
+def test_gpstime_parse_tconvert():
+    assert gpstime.gpstime.tconvert('2015-12-08T04:54:19.200000Z') == gpstime.gpstime.tconvert(1133585676.2)
+
+
+def test_gpstime_fromgps():
+    assert gpstime.gpstime.fromgps(1133585676).iso() == '2015-12-08T04:54:19.000000Z'
+
+
+def test_gpstime_fromgps_rounding():
+    assert gpstime.gpstime.fromgps(1133585676.274).iso() == '2015-12-08T04:54:19.274000Z'
+    assert gpstime.gpstime.fromgps(1133585676.874).iso() == '2015-12-08T04:54:19.874000Z'
+
+
+@pytest.mark.skipif(not cu_date_available(), reason="coreutils date not available")
+def test_non_standard_iso_format():
+    """Tests whether dates with '/' separators are parsed as iso dates.
+    Core utils instead parses them as if the 'T' character meant
+    a military time zone.
+    """
+    # both date utils and core utils will parse this using the default timezone
+    # date utils will also parse this using the default time zone
+    # but core utils will parse this using the military timezone 'T'
+    assert gpstime.gpstime.parse('2025-02-08T04:54:19') == gpstime.gpstime.parse('2025/02/08T04:54:19')
+
+
+def test_gpstime_fromgps_timestamp():
+    assert gpstime.gpstime.fromgps(1133585676).timestamp() == 1449550459
+
+
+def test_gpstime_fromgpsns_timestamp():
+    assert gpstime.gpstime.fromgpsns(1133585676200000000).gps() == 1133585676.2
+
+
+def test_gpstime_tconvert_classmethod():
+    assert gpstime.gpstime.tconvert(1133585676.2).gps() == 1133585676.2
+
+
+def test_gpstime_tconvert_iso():
+    assert gpstime.tconvert('2015-12-08T04:54:19.200000Z') == 1133585676.2
+
+
+def test_gpstime_tconvert_gps():
+    assert gpstime.tconvert(1133585676.2) == '2015-12-08 04:54:19.200000 UTC'
+
+
+@pytest.mark.xfail
+def test_gpstime_parse_leap():
+    assert gpstime.gpstime.parse('Jun 30 1993 23:59:60 UTC').gps() == 425520008
+
+
+@pytest.mark.xfail
+def test_gpstime_parse_gps_leap():
+    assert gpstime.gpstime.parse(425520008).iso() == '1993-06-30T23:59:60.000000Z'
+
+
+@pytest.mark.skipif(sys.version_info < (3, 8), reason="returns datetime in python < 3.8")
+def test_gpstime_add():
+    dt = gpstime.gpstime.parse(1133585676.2)
+    delta = datetime.timedelta(seconds=1)
+    assert isinstance(dt + delta, gpstime.gpstime)
+    dt += delta
+    assert isinstance(dt, gpstime.gpstime)
+
+
+@pytest.mark.skipif(sys.version_info < (3, 8), reason="returns datetime in python < 3.8")
+def test_gpstime_subtract():
+    dt = gpstime.gpstime.parse(1133585676.2)
+    delta = datetime.timedelta(seconds=1)
+    assert isinstance(dt - delta, gpstime.gpstime)
+    dt -= delta
+    assert isinstance(dt, gpstime.gpstime)
+
+
+##################################################
+# TZ environment variable tests
+##################################################
+
+
+def test_parse_with_explicit_utc_ignores_tz_env():
+    """Parsing with explicit UTC should return same result regardless of TZ."""
+    expected_gps = 1133585676.2
+    date_string = 'Dec 08 2015 04:54:19.2 UTC'
+
+    with temporary_tz('America/New_York'):
+        result_ny = gpstime.gpstime.parse(date_string).gps()
+
+    with temporary_tz('Asia/Tokyo'):
+        result_tokyo = gpstime.gpstime.parse(date_string).gps()
+
+    with temporary_tz('UTC'):
+        result_utc = gpstime.gpstime.parse(date_string).gps()
+
+    assert result_ny == expected_gps
+    assert result_tokyo == expected_gps
+    assert result_utc == expected_gps
+
+
+def test_parse_with_tz_utc():
+    """Parsing without explicit timezone when TZ=UTC."""
+    with temporary_tz('UTC'):
+        gt = gpstime.gpstime.parse('2015-12-08 04:54:19.2')
+        assert isinstance(gt, gpstime.gpstime)
+        assert gt.gps() == 1133585676.2
+
+
+def test_parse_with_tz_new_york():
+    """Parsing without explicit timezone when TZ=America/New_York."""
+    with temporary_tz('America/New_York'):
+        gt = gpstime.gpstime.parse('2015-12-08 04:54:19.2')
+        assert isinstance(gt, gpstime.gpstime)
+        # New York is UTC-5 in December (EST), so 04:54:19 EST = 09:54:19 UTC
+        # GPS for 2015-12-08 09:54:19.2 UTC
+        assert gt.gps() == 1133603676.2
+
+
+def test_parse_with_tz_los_angeles():
+    """Parsing without explicit timezone when TZ=America/Los_Angeles."""
+    with temporary_tz('America/Los_Angeles'):
+        gt = gpstime.gpstime.parse('2015-12-08 04:54:19.2')
+        assert isinstance(gt, gpstime.gpstime)
+        # Los Angeles is UTC-8 in December (PST), so 04:54:19 PST = 12:54:19 UTC
+        # GPS for 2015-12-08 12:54:19.2 UTC
+        assert gt.gps() == 1133614476.2
+
+
+def test_parse_with_tz_tokyo():
+    """Parsing without explicit timezone when TZ=Asia/Tokyo."""
+    with temporary_tz('Asia/Tokyo'):
+        gt = gpstime.gpstime.parse('2015-12-08 04:54:19.2')
+        assert isinstance(gt, gpstime.gpstime)
+        # Tokyo is UTC+9, so 04:54:19 JST = 19:54:19 UTC previous day (Dec 7)
+        # GPS for 2015-12-07 19:54:19.2 UTC
+        assert gt.gps() == 1133553276.2
+
+
+def test_parse_with_tz_offset_format():
+    """Parsing with TZ set to POSIX offset format."""
+    with temporary_tz('EST+5'):
+        gt = gpstime.gpstime.parse('2015-12-08 04:54:19.2')
+        assert isinstance(gt, gpstime.gpstime)
+        # EST+5 means UTC-5, so 04:54:19 = 09:54:19 UTC
+        assert gt.gps() == 1133603676.2
+
+
+def test_parse_with_invalid_tz_falls_back():
+    """Parsing with invalid TZ value should still return a gpstime object."""
+    with temporary_tz('Invalid/Timezone'):
+        gt = gpstime.gpstime.parse('2015-12-08 04:54:19.2 UTC')
+        assert isinstance(gt, gpstime.gpstime)
+        # Explicit UTC in string should still work
+        assert gt.gps() == 1133585676.2
+
+
+def test_parse_with_empty_tz():
+    """Parsing with empty TZ string."""
+    with temporary_tz(''):
+        gt = gpstime.gpstime.parse('2015-12-08 04:54:19.2 UTC')
+        assert isinstance(gt, gpstime.gpstime)
+        assert gt.gps() == 1133585676.2
+
+
+def test_parse_with_tz_unset():
+    """Parsing with TZ environment variable unset."""
+    with temporary_tz(None):
+        gt = gpstime.gpstime.parse('2015-12-08 04:54:19.2 UTC')
+        assert isinstance(gt, gpstime.gpstime)
+        assert gt.gps() == 1133585676.2
+
+
+def test_parse_iso_format_with_various_tz():
+    """ISO format with Z suffix should be consistent across TZ settings."""
+    iso_string = '2015-12-08T04:54:19.200000Z'
+    expected_gps = 1133585676.2
+
+    for tz in ['UTC', 'America/New_York', 'Europe/London', 'Asia/Tokyo']:
+        with temporary_tz(tz):
+            gt = gpstime.gpstime.parse(iso_string)
+            assert gt.gps() == expected_gps, f"Failed for TZ={tz}"
+
+
+def test_parse_with_pst_in_string():
+    """Parsing with PST timezone in string should be consistent regardless of TZ env."""
+    date_string = 'Dec 08 2015 04:54:19.2 PST'
+    # PST is UTC-8, so 04:54:19 PST = 12:54:19 UTC
+    expected_gps = 1133614476.2
+
+    for tz in ['UTC', 'America/New_York', 'Asia/Tokyo']:
+        with temporary_tz(tz):
+            gt = gpstime.gpstime.parse(date_string)
+            assert gt.gps() == expected_gps, f"Failed for TZ={tz}"
+
+
+def test_parse_with_est_in_string():
+    """Parsing with EST timezone in string should be consistent regardless of TZ env."""
+    date_string = 'Dec 08 2015 04:54:19.2 EST'
+    # EST is UTC-5, so 04:54:19 EST = 09:54:19 UTC
+    expected_gps = 1133603676.2
+
+    for tz in ['UTC', 'America/Los_Angeles', 'Europe/London']:
+        with temporary_tz(tz):
+            gt = gpstime.gpstime.parse(date_string)
+            assert gt.gps() == expected_gps, f"Failed for TZ={tz}"
+
+
+def test_parse_with_cet_in_string():
+    """Parsing with CET timezone in string should be consistent regardless of TZ env."""
+    date_string = 'Dec 08 2015 04:54:19.2 CET'
+    # CET is UTC+1, so 04:54:19 CET = 03:54:19 UTC
+    expected_gps = 1133582076.2
+
+    for tz in ['UTC', 'America/New_York', 'Asia/Tokyo']:
+        with temporary_tz(tz):
+            gt = gpstime.gpstime.parse(date_string)
+            assert gt.gps() == expected_gps, f"Failed for TZ={tz}"
+
+
+def test_parse_with_jst_in_string():
+    """Parsing with JST timezone in string should be consistent regardless of TZ env."""
+    date_string = 'Dec 08 2015 04:54:19.2 JST'
+    # JST is UTC+9, so 04:54:19 JST = 19:54:19 UTC previous day (Dec 7)
+    expected_gps = 1133553276.2
+
+    for tz in ['UTC', 'America/New_York', 'Europe/London']:
+        with temporary_tz(tz):
+            gt = gpstime.gpstime.parse(date_string)
+            assert gt.gps() == expected_gps, f"Failed for TZ={tz}"
+
+
+def test_parse_with_numeric_offset_plus():
+    """Parsing with positive numeric timezone offset in string."""
+    date_string = '2015-12-08 04:54:19.2 +0530'
+    # +0530 is UTC+5:30, so 04:54:19 +0530 = 23:24:19.2 UTC previous day (Dec 7)
+    expected_gps = 1133565876.2
+
+    for tz in ['UTC', 'America/New_York', 'Asia/Tokyo']:
+        with temporary_tz(tz):
+            gt = gpstime.gpstime.parse(date_string)
+            assert gt.gps() == expected_gps, f"Failed for TZ={tz}"
+
+
+def test_parse_with_numeric_offset_minus():
+    """Parsing with negative numeric timezone offset in string."""
+    date_string = '2015-12-08 04:54:19.2 -0700'
+    # -0700 is UTC-7, so 04:54:19 -0700 = 11:54:19 UTC
+    expected_gps = 1133610876.2
+
+    for tz in ['UTC', 'America/New_York', 'Asia/Tokyo']:
+        with temporary_tz(tz):
+            gt = gpstime.gpstime.parse(date_string)
+            assert gt.gps() == expected_gps, f"Failed for TZ={tz}"
+
+
+def test_parse_with_iso_offset_format():
+    """Parsing ISO format with explicit timezone offset."""
+    date_string = '2015-12-08T04:54:19.2+05:30'
+    # +05:30 is UTC+5:30, so 04:54:19 +0530 = 23:24:19.2 UTC previous day (Dec 7)
+    expected_gps = 1133565876.2
+
+    for tz in ['UTC', 'America/Los_Angeles', 'Europe/Paris']:
+        with temporary_tz(tz):
+            gt = gpstime.gpstime.parse(date_string)
+            assert gt.gps() == expected_gps, f"Failed for TZ={tz}"
+
+
+def test_parse_with_iso_negative_offset():
+    """Parsing ISO format with negative timezone offset."""
+    date_string = '2015-12-08T04:54:19.2-08:00'
+    # -08:00 is UTC-8 (PST), so 04:54:19 -08:00 = 12:54:19 UTC
+    expected_gps = 1133614476.2
+
+    for tz in ['UTC', 'America/New_York', 'Asia/Tokyo']:
+        with temporary_tz(tz):
+            gt = gpstime.gpstime.parse(date_string)
+            assert gt.gps() == expected_gps, f"Failed for TZ={tz}"
+
+
+def test_parse_with_gmt_offset_in_string():
+    """Parsing with GMT offset notation in string."""
+    date_string = 'Dec 08 2015 04:54:19.2 GMT-5'
+    # Note: GMT-5 uses POSIX semantics where negative means east of GMT (UTC+5)
+    # so 04:54:19 GMT-5 = 23:54:19 UTC previous day (Dec 7)
+    expected_gps = 1133567676.2
+
+    for tz in ['UTC', 'America/Los_Angeles', 'Asia/Tokyo']:
+        with temporary_tz(tz):
+            gt = gpstime.gpstime.parse(date_string)
+            assert gt.gps() == expected_gps, f"Failed for TZ={tz}"
+
+
+def test_parse_pdt_daylight_saving():
+    """Parsing with PDT (Pacific Daylight Time) in string."""
+    # Using a date in summer when PDT applies
+    date_string = 'Jul 15 2015 12:00:00 PDT'
+    # PDT is UTC-7, so 12:00:00 PDT = 19:00:00 UTC
+    expected_gps = 1121022017.0
+
+    for tz in ['UTC', 'America/New_York', 'Europe/London']:
+        with temporary_tz(tz):
+            gt = gpstime.gpstime.parse(date_string)
+            assert gt.gps() == expected_gps, f"Failed for TZ={tz}"
+
+
+def test_parse_edt_daylight_saving():
+    """Parsing with EDT (Eastern Daylight Time) in string."""
+    # Using a date in summer when EDT applies
+    date_string = 'Jul 15 2015 12:00:00 EDT'
+    # EDT is UTC-4, so 12:00:00 EDT = 16:00:00 UTC
+    expected_gps = 1121011217.0
+
+    for tz in ['UTC', 'America/Los_Angeles', 'Asia/Tokyo']:
+        with temporary_tz(tz):
+            gt = gpstime.gpstime.parse(date_string)
+            assert gt.gps() == expected_gps, f"Failed for TZ={tz}"
+
+
+##################################################
+# TZ validity warning tests
+##################################################
+
+
+def test_check_tz_validity_warns_on_invalid_tz(capsys):
+    """Invalid TZ abbreviations should trigger a warning."""
+    from gpstime.__main__ import check_tz_validity
+
+    for invalid_tz in ['EDT', 'PST', 'CDT', 'INVALID']:
+        with temporary_tz(invalid_tz):
+            check_tz_validity()
+            captured = capsys.readouterr()
+            assert 'warning' in captured.err.lower(), f"Expected warning for TZ={invalid_tz}"
+            assert invalid_tz in captured.err, f"Warning should mention TZ={invalid_tz}"
+
+
+def test_check_tz_validity_no_warning_on_valid_tz(capsys):
+    """Valid TZ values should not trigger a warning."""
+    from gpstime.__main__ import check_tz_validity
+
+    for valid_tz in ['UTC', 'GMT', 'America/New_York', 'America/Los_Angeles',
+                     'Europe/London', 'Asia/Tokyo', 'EST5EDT', 'PST8PDT']:
+        with temporary_tz(valid_tz):
+            check_tz_validity()
+            captured = capsys.readouterr()
+            assert 'warning' not in captured.err.lower(), f"Unexpected warning for TZ={valid_tz}"
+
+
+def test_check_tz_validity_no_warning_when_tz_unset(capsys):
+    """No warning when TZ environment variable is not set."""
+    from gpstime.__main__ import check_tz_validity
+
+    with temporary_tz(None):
+        check_tz_validity()
+        captured = capsys.readouterr()
+        assert captured.err == '', "No warning expected when TZ is unset"

{gpstime-0.9.2 → gpstime-0.10.0/gpstime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gpstime
-Version: 0.9.2
+Version: 0.10.0
 Summary: GPS-aware datetime module
 Author-email: Jameson Graef Rollins <jameson.rollins@ligo.org>
 License-Expression: GPL-3.0-or-later
@@ -18,6 +18,8 @@ Requires-Dist: platformdirs; python_version >= "3.10"
 Requires-Dist: appdirs; python_version < "3.10"
 Requires-Dist: python-dateutil
 Requires-Dist: requests
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
 Dynamic: license-file
 
 GPS-aware datetime module

{gpstime-0.9.2 → gpstime-0.10.0}/gpstime.egg-info/SOURCES.txt

@@ -7,7 +7,7 @@ gpstime/__init__.py
 gpstime/__main__.py
 gpstime/__version__.py
 gpstime/leaps.py
-gpstime/test.py
+gpstime/test_gpstime.py
 gpstime.egg-info/PKG-INFO
 gpstime.egg-info/SOURCES.txt
 gpstime.egg-info/dependency_links.txt

{gpstime-0.9.2 → gpstime-0.10.0}/gpstime.egg-info/requires.txt

@@ -6,3 +6,6 @@ appdirs
 
 [:python_version >= "3.10"]
 platformdirs
+
+[test]
+pytest

{gpstime-0.9.2 → gpstime-0.10.0}/pyproject.toml

@@ -31,6 +31,11 @@ dependencies = [
     "requests",
 ]
 
+[project.optional-dependencies]
+test = [
+    "pytest",
+]
+
 [project.urls]
 Homepage = "https://git.ligo.org/cds/software/gpstime"
 
@@ -47,7 +52,7 @@ write_to = "gpstime/__version__.py"
 source = ["gpstime"]
 omit = [
     "__version__.py",
-    "test.py",
+    "test_gpstime.py",
 ]
 
 [tool.coverage.report]
@@ -56,5 +61,5 @@ precision = 1
 show_missing = true
 omit = [
     "__version__.py",
-    "test.py",
+    "test_gpstime.py",
 ]

gpstime-0.9.2/gpstime/test.py

@@ -1,197 +0,0 @@
-import datetime
-import unittest
-import shutil
-import sys
-
-from dateutil.tz import tzutc
-
-import gpstime
-
-##################################################
-
-def cu_date_available():
-    """return True if coreutils date parser available"""
-    if shutil.which("date"):
-        return True
-    return False
-
-
-class TestGPStime(unittest.TestCase):
-
-    def roundtrip_gps(self, gps):
-        self.assertEqual(gpstime.unix2gps(gpstime.gps2unix(gps)), gps)
-
-    def roundtrip_unix(self, unix):
-        self.assertEqual(gpstime.gps2unix(gpstime.unix2gps(unix)), unix)
-
-    ##########
-
-    def test_conversion(self):
-        self.assertEqual(gpstime.gps2unix(1133585676), 1449550459)
-        self.assertEqual(gpstime.unix2gps(1449550459), 1133585676)
-        self.assertEqual(1133585676, gpstime.unix2gps(gpstime.gps2unix(1133585676)))
-
-    def test_conversion_past(self):
-        self.assertEqual(gpstime.gps2unix(123456789), 439421586)
-        self.assertEqual(gpstime.unix2gps(439421586), 123456789)
-
-    def test_conversion_onleap(self):
-        self.assertEqual(gpstime.gps2unix(425520006), 741484798)
-        self.assertEqual(gpstime.gps2unix(425520007), 741484799)
-        self.assertEqual(gpstime.gps2unix(425520008), 741484799)
-        self.assertEqual(gpstime.gps2unix(425520009), 741484800)
-        self.assertEqual(gpstime.unix2gps(741484798), 425520006)
-        self.assertEqual(gpstime.unix2gps(741484799), 425520007)
-        self.assertEqual(gpstime.unix2gps(741484800), 425520009)
-
-    def test_roundtrip(self):
-        self.roundtrip_gps(123456789)
-        self.roundtrip_unix(439421586)
-
-    @unittest.expectedFailure
-    def test_roundtrip_onleap(self):
-        self.roundtrip_gps(425520008)
-
-    def test_gpstime_new(self):
-        self.assertEqual(gpstime.gpstime(2015, 12, 8, 4, 54, 19, 0, tzutc()).gps(),
-                         1133585676.0)
-
-    def test_gpstime_fromdatetime(self):
-        dt = datetime.datetime(2015, 12, 8, 4, 54, 19, 0, tzutc())
-        gt = gpstime.gpstime.fromdatetime(dt)
-        self.assertIsInstance(gt, gpstime.gpstime)
-        self.assertEqual(gt.gps(), 1133585676.0)
-
-    def test_gpstime_parse_now_roundtrip(self):
-        gt0 = gpstime.gpstime.parse()
-        gt1 = gpstime.gpstime.parse(gt0.gps())
-        self.assertEqual(gt0, gt1)
-
-    def test_gpstime_parse_utc(self):
-        self.assertEqual(gpstime.gpstime.parse('Dec 08 2015 04:54:19.2 UTC').gps(),
-                         1133585676.2)
-
-    def test_gpstime_parse_utc2(self):
-        self.assertEqual(gpstime.gpstime.parse('2014-07-03 17:16:14 UTC').gps(),
-                         1088442990.0)
-
-    def test_gpstime_parse_local(self):
-        self.assertEqual(gpstime.gpstime.parse('Dec 08 2015 04:54:19.2 PST').gps(),
-                         1133614476.2)
-
-    def test_gpstime_parse_gps(self):
-        self.assertEqual(gpstime.gpstime.parse(1133585676.2).gps(),
-                         1133585676.2)
-
-    def test_gpstime_parse_gps_iso(self):
-        self.assertEqual(gpstime.gpstime.parse(1133585676.2).iso(),
-                         '2015-12-08T04:54:19.200000Z')
-
-    def test_gpstime_parse_iso(self):
-        self.assertEqual(gpstime.gpstime.parse('2015-12-08T04:54:19.200000Z').iso(),
-                         '2015-12-08T04:54:19.200000Z')
-
-    def test_gpstime_parse_iso_alt(self):
-        self.assertEqual(gpstime.gpstime.parse('2015-12-08_04:54:19.200000Z').iso(),
-                         '2015-12-08T04:54:19.200000Z')
-
-    @unittest.skipIf(not cu_date_available(), "coreutils date not available")
-    def test_gpstime_parse_timestamp(self):
-        self.assertEqual(gpstime.gpstime.parse('@1474821047').gps(),
-                         1158856264)
-
-    @unittest.skipIf(not cu_date_available(), "coreutils date not available")
-    def test_gpstime_parse_now0(self):
-        self.assertIsInstance(gpstime.gpstime.parse(), gpstime.gpstime)
-
-    @unittest.skipIf(not cu_date_available(), "coreutils date not available")
-    def test_gpstime_parse_now1(self):
-        self.assertIsInstance(gpstime.gpstime.parse('now'), gpstime.gpstime)
-
-    @unittest.skipIf(not cu_date_available(), "coreutils date not available")
-    def test_gpstime_parse_relative0(self):
-        self.assertIsInstance(gpstime.gpstime.parse('yesterday'), gpstime.gpstime)
-
-    @unittest.skipIf(not cu_date_available(), "coreutils date not available")
-    def test_gpstime_parse_relative1(self):
-        self.assertIsInstance(gpstime.gpstime.parse('1 month ago'), gpstime.gpstime)
-
-    def test_gpstime_parse_tconvert(self):
-        self.assertEqual(gpstime.gpstime.tconvert('2015-12-08T04:54:19.200000Z'),
-                         gpstime.gpstime.tconvert(1133585676.2))
-
-    def test_gpstime_fromgps(self):
-        self.assertEqual(gpstime.gpstime.fromgps(1133585676).iso(),
-                         '2015-12-08T04:54:19.000000Z')
-
-    def test_gpstime_fromgps_rounding(self):
-        self.assertEqual(gpstime.gpstime.fromgps(1133585676.274).iso(),
-                         '2015-12-08T04:54:19.274000Z')
-        self.assertEqual(gpstime.gpstime.fromgps(1133585676.874).iso(),
-                         '2015-12-08T04:54:19.874000Z')
-
-    @unittest.skipIf(not cu_date_available(), "coreutils date not available")
-    def test_non_standard_iso_format(self):
-        """ Tests whether dates with '/' separators are parsed as iso dates.
-        Core utils instead parses them as if the 'T' character meant
-        a military time zone.
-        """
-
-        # both date utils and core utils will parse this using the default timezone
-        self.assertEqual(gpstime.gpstime.parse('2025-02-08T04:54:19'),
-
-        # date utils will also parse this using the default time zone
-        # but core utils will parse this using the military timezone 'T'
-                         gpstime.gpstime.parse('2025/02/08T04:54:19'))
-
-
-    def test_gpstime_fromgps_timestamp(self):
-        self.assertEqual(gpstime.gpstime.fromgps(1133585676).timestamp(),
-                         1449550459)
-
-    def test_gpstime_fromgpsns_timestamp(self):
-        self.assertEqual(gpstime.gpstime.fromgpsns(1133585676200000000).gps(),
-                         1133585676.2)
-
-    def test_gpstime_tconvert_classmethod(self):
-        self.assertEqual(gpstime.gpstime.tconvert(1133585676.2).gps(),
-                         1133585676.2)
-
-    def test_gpstime_tconvert_iso(self):
-        self.assertEqual(gpstime.tconvert('2015-12-08T04:54:19.200000Z'),
-                         1133585676.2)
-
-    def test_gpstime_tconvert_gps(self):
-        self.assertEqual(gpstime.tconvert(1133585676.2),
-                         '2015-12-08 04:54:19.200000 UTC')
-
-    @unittest.expectedFailure
-    def test_gpstime_parse_leap(self):
-        self.assertEqual(gpstime.gpstime.parse('Jun 30 1993 23:59:60 UTC').gps(),
-                         425520008)
-
-    @unittest.expectedFailure
-    def test_gpstime_parse_gps_leap(self):
-        self.assertEqual(gpstime.gpstime.parse(425520008).iso(),
-                         '1993-06-30T23:59:60.000000Z')
-
-    @unittest.skipIf(sys.version_info < (3, 8), "returns datetime in python < 3.8")
-    def test_gpstime_add(self):
-        dt = gpstime.gpstime.parse(1133585676.2)
-        delta = datetime.timedelta(seconds=1)
-        self.assertTrue(isinstance(dt + delta, gpstime.gpstime))
-        dt += delta
-        self.assertTrue(isinstance(dt, gpstime.gpstime))
-
-    @unittest.skipIf(sys.version_info < (3, 8), "returns datetime in python < 3.8")
-    def test_gpstime_subtract(self):
-        dt = gpstime.gpstime.parse(1133585676.2)
-        delta = datetime.timedelta(seconds=1)
-        self.assertTrue(isinstance(dt - delta, gpstime.gpstime))
-        dt -= delta
-        self.assertTrue(isinstance(dt, gpstime.gpstime))
-
-##################################################
-
-if __name__ == '__main__':
-    unittest.main(verbosity=5, failfast=False, buffer=True)