Date handling

The Date object

class beyond.dates.date.Date(*args, scale='UTC', **kwargs)

Date object

All computations and in-memory saving are made in MJD and TAI. In the current implementation, the Date object does not handle the leap second.

The constructor can take:

  • the same arguments as the standard library’s datetime object (year, month, day, hour, minute, second, microsecond)

  • MJD as float

  • MJD as int for days and float for seconds

  • a Date or datetime object

Keyword Arguments

scale (str) – One of the following scales : “UT1”, “UTC”, “GPS”, “TDB”, “TAI”, “TT”

Examples

Date(2016, 11, 17, 19, 16, 40)
Date(2016, 11, 17, 19, 16, 40, scale="TAI")
Date(57709.804455)  # MJD
Date(57709, 69540.752649)
Date(datetime(2016, 11, 17, 19, 16, 40))  # built-in datetime object
Date.now()

Date objects interact with timedelta as datetime do.

eop

Value of the Earth Orientation Parameters for this particular date (see Earth Orientation and leap second)

scale

Scale in which this date is represented

change_scale(new_scale)
Parameters

new_scale (str) –

Returns

new Date object representing the same instant, with a different timescale

Return type

Date

property datetime

Conversion of the Date object into a datetime.datetime

The resulting object is a timezone-naive instance with the same scale as the originating Date object.

property jd

Compute the Julian Date, which is the number of days from the January 1, 4712 B.C., 12:00.

Returns

float

property mjd

Date in terms of MJD

Returns

float

classmethod now(scale='UTC')
Parameters

scale (str) –

Returns

Current time in the chosen scale

Return type

Date

classmethod range(*args, **kwargs)

See DateRange for arguments and documentation

strftime(fmt)

Format the date following the given format

classmethod strptime(data, format, scale='UTC')

Convert a string representation of a date to a Date object

class beyond.dates.date.DateRange(start, stop, step, *, inclusive=False)

Object representing a range of Date objects

Allow for manipulation of the range before any computation. It has a lenght, can be used as an iterable, and be checked against for membership.

Example

>>> start = Date(2021, 2, 9, 23, 35, 58)
>>> stop = timedelta(hours=1, minutes=1)
>>> step = timedelta(minutes=15)
>>> r = Date.range(start, stop, step)
>>> len(r)
5
>>> for d in r:  # iterable
...     print(d)
...
2021-02-09T23:35:58 UTC
2021-02-09T23:50:58 UTC
2021-02-10T00:05:58 UTC
2021-02-10T00:20:58 UTC
2021-02-10T00:35:58 UTC
>>> Date(2021, 2, 9, 23, 45) in r  # membership test
True
property dur

duration of the DateRange object

Type

timedelta

inclusive

inclusive flag

Type

bool

start

Begining of the range

Type

Date

step

Step size, can be positive or negative

Type

timedelta

stop

End of the range

Type

Date

Earth Orientation and leap second

Input data

In order to parse Earth Orientation Parameters (EOP) input data, you can use the following classes

class beyond.dates.eop.Finals(path, encoding='ascii')

History of Earth orientation correction for IAU1980 model

Three files are available here for this model:

  • finals.all, from 1976-01-02 to present, updated weekly

  • finals.data, from 1992-01-01 to present, updated weekly

  • finals.daily, last 90 days + 90 days of prediction, updated daily

See the associated metadata for more informations about the content of these files.

class beyond.dates.eop.Finals2000A(path, encoding='ascii')

History of Earth orientation correction for IAU2000 model

Three files are available here for this model:

  • finals2000A.all, from 1976-01-02 to present, updated weekly

  • finals2000A.data, from 1992-01-01 to present, updated weekly

  • finals2000A.daily, last 90 days + 90 days of prediction, updated daily

See the associated metadata for more informations about the content of these files.

class beyond.dates.eop.TaiUtc(path, encoding='ascii')

File listing all leap seconds throught history

This file could be retrieved here, but this server seems discontinued.

Databases

Beyond provides a simple (as simplistic) database implementation for EOP : SimpleEopDatabase.

class beyond.dates.eop.SimpleEopDatabase

Simple implementation of database

Uses tai-utc.dat, finals.all and finals2000A.all files directly without caching nor interpolation.

In order to use these files, you have to provide the directory containing them as a config variable. Optionally, you can provide the type of data you want to extract from finals files (‘all’, ‘data’ or ‘daily’).

from beyond.config import config
config.update({
    'eop': {
        'folder': "/path/to/eop/data/",
        'type': "all"
    }
})

If you need/want another database engine, you just have to create a new class defining a __getitem__ method and register it under the name you wish.

There is two methods for registering a database. The first one, is via the register() decorator

from beyond.dates.eop import register

@register('sqlite')
class SqliteEnvDatabase:

    def __getitem__(self, mjd: float):

        # retrieve data
        if data is None:
            raise KeyError(mjd)

        return data

The second is via the entry point beyond.eopdb.

If you create a python package that contain an EOP database, you can declare that database directly during install time. For that, in the setup.py file of your package, you have to provide the import path to this database in the following fashion:

from setuptools import setup

setup(
    name=mypackage,
    version="12.4.beta",
    description="My awesome package",
    author="John Doe",
    ...
    entry_points={
        'beyond.eopdb': [
            "my_personnal_db = mypackage.module:MyDatabase"
        ]
    }
)

This way, the class MyDatabase will always be available to the beyond library, and will be instantiated if needed (i.e. if the dbname config variable is set to “my_personnal_db”).

Internals

In order to access different databases with the same interface, beyond uses the EopDb class. It is this class that handle registered databases, and select the activated one.

class beyond.dates.eop.EopDb

Class handling the different EOP databases available, in a simple abstraction layer.

By defining a simple parameter in the config dict, this class will handle the instanciation of the database and queries in a transparent manner.

see dbname and missing policy configurations.

DEFAULT_DBNAME = 'default'

Default name used for EOP database lookup.

MIS_DEFAULT = 'pass'

Default behaviour in case of missing value

classmethod db(dbname=None)

Retrieve the database

Parameters

dbname – Specify the name of the database to retrieve. If set to None, take the name from the configuration (see configuration)

Returns

object

classmethod get(mjd: float, dbname: Optional[str] = None) beyond.dates.eop.Eop

Retrieve Earth Orientation Parameters and timescales differences for a given date

Parameters
  • mjd – Date expressed as Mean Julian Date

  • dbname – Name of the database to use

Returns

Interpolated data for this particuliar MJD

Return type

Eop

classmethod register(klass, name='default')

Register an Eop Database

The only requirement of this database is that it should have __getitem__ method accepting MJD as float.

beyond.dates.eop.register(name='default')

Decorator for registering an Eop Database

Example:

@register
class SqliteEnvDatabase:
    # sqlite implementation
    # this database will be known as 'default'

@register('json')
class JsonEnvDatabase:
    # JSON implementation

EopDb.get(58090.2)                    # get Eop from SqliteEnvDatabase
EopDb.get(58090.2, dbname='default')  # same as above
EopDb.get(58090.2, dbname='json')     # get Eop from JsonEnvDatabase