Извлечение исторических секунд прыжка из tzdata

Есть ли способ извлечь момент исторических секунд прыжка из базы данных часовых поясов, которая распространяется в большинстве дистрибутивов Linux? Я ищу решение в python, но все, что работает в командной строке, тоже будет хорошо.

Моим вариантом использования является конвертирование между gps-временем (которое в основном представляет собой количество секунд с момента включения первого GPS-спутника в 1980 году) и UTC или локального времени. Время от времени UTC настраивается на прыжковые секунды, тогда как gps-time увеличивается линейно. Это эквивалентно преобразованию между UTC и TAI. TAI также игнорирует секунды прыжка, поэтому TAI и gps-время должны всегда развиваться с одинаковым смещением. На работе мы используем gps-time как стандарт времени для синхронизации астрономических наблюдений по всему миру.

У меня есть рабочие функции, которые конвертируют между gps-временем и UTC, но мне пришлось жестко закодировать таблицу секунд прыжка, и я получаю здесь (файл tzdata2013xx.tar.gz содержит файл с именем leapseconds). Я должен обновлять этот файл вручную каждые несколько лет, когда объявляется новый leapsecond. Я бы предпочел получить эту информацию из стандартной tzdata, которая автоматически обновляется через обновления системы несколько раз в год.

Я уверен, что информация скрыта в некоторых двоичных файлах где-то в /usr/share/zoneinfo/. Мне удалось извлечь часть из них, используя struct.unpack (man tzfile дает некоторую информацию о формате), но я никогда не работал полностью. Существуют ли стандартные пакеты, которые могут получить доступ к этой информации? Я знаю о pytz, который, как представляется, получает стандартную информацию о DST из той же базы данных, но не дает доступа к високосным секундам. Я также нашел tai64n, но, глядя на его исходный код, он просто содержит жестко закодированную таблицу.

ИЗМЕНИТЬ

Вдохновленный ответом steveha и некоторым кодом в pytz/tzfile.py, я наконец получил рабочее решение (проверено на py2.5 и py2.7 ):

from struct import unpack, calcsize
from datetime import datetime

def print_leap(tzfile = '/usr/share/zoneinfo/right/UTC'):
    with open(tzfile, 'rb') as f:
        # read header
        fmt = '>4s c 15x 6l'
        (magic, format, ttisgmtcnt, ttisstdcnt,leapcnt, timecnt,
            typecnt, charcnt) =  unpack(fmt, f.read(calcsize(fmt)))
        assert magic == 'TZif'.encode('US-ASCII'), 'Not a timezone file'
        print 'Found %i leapseconds:' % leapcnt

        # skip over some uninteresting data
        fmt = '>%(timecnt)dl %(timecnt)dB %(ttinfo)s %(charcnt)ds' % dict(
            timecnt=timecnt, ttinfo='lBB'*typecnt, charcnt=charcnt)
        f.read(calcsize(fmt))

        #read leap-seconds
        fmt = '>2l'
        for i in xrange(leapcnt):
            tleap, nleap = unpack(fmt, f.read(calcsize(fmt)))
            print datetime.utcfromtimestamp(tleap-nleap+1)

с результатом

In [2]: print_leap()
Found 25 leapseconds:
1972-07-01 00:00:00
1973-01-01 00:00:00
1974-01-01 00:00:00
...
2006-01-01 00:00:00
2009-01-01 00:00:00
2012-07-01 00:00:00

Хотя это и решает мой вопрос, я, вероятно, не пойду на это решение. Вместо этого я буду включать leap-seconds.list с моим кодом, как это предложил Мэтт Джонсон. Это, кажется, авторитетный список, используемый в качестве источника для tzdata, и, вероятно, обновляется NIST два раза в год. Это означает, что мне придется делать обновление вручную, но этот файл является простым для анализа и включает в себя дату истечения срока действия (которая, как представляется, отсутствует).

Ответы

import datetime
import struct

TZFILE_MAGIC = 'TZif'.encode('US-ASCII')

def leap_seconds(f):
    """
    Return a list of tuples of this format: (timestamp, number_of_seconds)
        timestamp: a 32-bit timestamp, seconds since the UNIX epoch
        number_of_seconds: how many leap-seconds occur at timestamp

    """
    fmt = ">4s c 15x 6l"
    size = struct.calcsize(fmt)
    (tzfile_magic, tzfile_format, ttisgmtcnt, ttisstdcnt, leapcnt, timecnt,
        typecnt, charcnt) =  struct.unpack(fmt, f.read(size))
    #print("DEBUG: tzfile_magic: {} tzfile_format: {} ttisgmtcnt: {} ttisstdcnt: {} leapcnt: {} timecnt: {} typecnt: {} charcnt: {}".format(tzfile_magic, tzfile_format, ttisgmtcnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt))

    # Make sure it is a tzfile(5) file
    assert tzfile_magic == TZFILE_MAGIC, (
            "Not a tzfile; file magic was: '{}'".format(tzfile_magic))

    # comments below show struct codes such as "l" for 32-bit long integer
    offset = (timecnt*4  # transition times, each "l"
        + timecnt*1  # indices tying transition time to ttinfo values, each "B"
        + typecnt*6  # ttinfo structs, each stored as "lBB"
        + charcnt*1)  # timezone abbreviation chars, each "c"

    f.seek(offset, 1) # seek offset bytes from current position

    fmt = '>{}l'.format(leapcnt*2)
    #print("DEBUG: leapcnt: {}  fmt: '{}'".format(leapcnt, fmt))
    size = struct.calcsize(fmt)
    data = struct.unpack(fmt, f.read(size))

    lst = [(data[i], data[i+1]) for i in range(0, len(data), 2)]
    assert all(lst[i][0] < lst[i+1][0] for i in range(len(lst)-1))
    assert all(lst[i][1] == lst[i+1][1]-1 for i in range(len(lst)-1))

    return lst

def print_leaps(leap_lst):
    # leap_lst is tuples: (timestamp, num_leap_seconds)
    for ts, num_secs in leap_lst:
        print(datetime.datetime.utcfromtimestamp(ts - num_secs+1))

if __name__ == '__main__':
    import os
    zoneinfo_fname = '/usr/share/zoneinfo/right/UTC'
    with open(zoneinfo_fname, 'rb') as f:
        leap_lst = leap_seconds(f)
    print_leaps(leap_lst)

import ephem, datetime
ephem.delta_t(datetime.datetime.now()) - 32.184
Out[2]: 35.01972996360122