def dt2ymdhms(dtin, with_microsec=True):
"""
Time conversion
Python's Datetime => Lists of Years, Months, Days, Hours, Minutes, Seconds
Parameters
----------
dtin : datetime or list/numpy.array of datetime
Python DateTime
with_microsec : bool
if False : rounding the microsecs to the nearest sec
Returns
-------
tuple with year , month , day , hour , minute , second , microsecond
"""
if not cnv_gen.is_iterable(dtin):
if with_microsec:
return (dtin.year, dtin.month, dtin.day, dtin.hour, dtin.minute,
dtin.second, dtin.microsecond)
else:
dt2 = roundTime(dtin, 1)
return (dt2.year, dt2.month, dt2.day, dt2.hour, dt2.minute,
dt2.second)
else:
return [dt2ymdhms(e, with_microsec) for e in dtin]
def dt2posix(dtin, out_array=False):
"""
Time conversion
Python's Datetime => POSIX Time
Parameters
----------
dtin : datetime or list/numpy.array of datetime.
Datetime(s). Can handle several datetimes in an iterable.
out_array : bool
if iterable as input, force the output as a Numpy array
Returns
-------
L : float or list/numpy.array of floats
POSIX Time(s)
"""
if not cnv_gen.is_iterable(dtin):
D = dtin - dt.datetime(1970, 1, 1)
return D.days * 86400 + D.seconds + D.microseconds * 10**-6
else:
L = [dt2posix(e) for e in dtin]
if out_array:
return np.array(L)
else:
return L
def dt_round(dtin=None, roundTo=60):
"""
Round a datetime object to any time laps in seconds
Parameters
----------
dtin : datetime or list/numpy.array of datetime
Datetime you want to round, default now.
Can handle several datetimes in an iterable.
roundTo : int
Closest number of seconds to round to, default 1 minute.
Returns
-------
dtout : datetime or list/numpy.array of datetime
Rounded Datetime
Note
----
Based on :
http://stackoverflow.com/questions/3463930/how-to-round-the-minute-of-a-datetime-object-python
"""
import datetime as dtmod
if cnv_gen.is_iterable(dtin):
return [dt_round(e, roundTo=roundTo) for e in dtin]
else:
if dtin == None:
dtin = dtmod.datetime.now()
seconds = (dtin - dtin.min).seconds
# // is a floor division, not a comment on following line:
rounding = (seconds + roundTo / 2) // roundTo * roundTo
return dtin + dtmod.timedelta(0, rounding - seconds, -dtin.microsecond)
def dt2str(dtin, str_format="%Y-%m-%d %H:%M:%S"):
"""
Time conversion
Python's Datetime => String
Just a wrapper of strftime
Parameters
----------
dtin : datetime or list/numpy.array of datetime.
Datetime(s). Can handle several datetimes in an iterable.
Returns
-------
L : string or list of strings
Time as string(s)
Source
------
https://stackoverflow.com/questions/7999935/python-datetime-to-string-without-microsecond-component
http://www.jacksay.com/tutoriaux/bash-shell/bashshell-utilisation-commande-date.html
"""
if cnv_gen.is_iterable(dtin):
return [dt2str(e) for e in dtin]
else:
return dtin.strftime(str_format)
def dt2gpsweek_decimal(dtin, return_middle_of_day=True):
"""
Time conversion
Python's datetime => GPS week
Return the GPS week in a decimal mode
(Easier for plots)
Parameters
----------
dtin : datetime or list/numpy.array of datetime
Datetime(s). Can handle several datetimes in an iterable.
return_middle_of_day : bool
if False, return the decimal part of the week at the begining of the day
Returns
-------
GPS_week_decimal : float
decimal GPS week
Is a list of float if the input is an iterable
"""
if cnv_gen.is_iterable(dtin):
return np.array([dt2gpsweek_decimal(e) for e in dtin])
else:
if return_middle_of_day:
mod = 0.5
else:
mod = 0
week, day = dt2gpstime(dtin)
return float(week) + (float(day + mod) / 7)
def numpy_datetime2dt(npdtin):
"""
Time conversion
Numpy Datetime => Datetime
Parameters
----------
npdtin : np.datetime64 or list/numpy.array of np.datetime64
Numpy Datetime. Can handle several time in a list.
Returns
-------
python_datetime : datetime or list/numpy.array of datetime
Converted Datetime(s)
Source
------
https://stackoverflow.com/questions/29753060/how-to-convert-numpy-datetime64-into-datetime/29755657
"""
if cnv_gen.is_iterable(npdtin):
return [numpy_datetime2dt(e) for e in npdtin]
else:
python_datetime = npdtin.astype('M8[ms]').astype('O')
return python_datetime
def jjulCNES2dt(jjulin):
"""
Time conversion
Julian Day CNES => Python's Datetime
Parameters
----------
jjulin : float/int or list/numpy.array of float/int.
Julian Day CNES. Can handle several float/int in an iterable.
Returns
-------
L : datetime or list of datetime.
Datetime(s)
Note
----
Julian Day CNES starts at 0h Jan 1, 1950 (JD − 2433282.5)
https://www.aviso.altimetry.fr/fr/donnees/outils/jours-calendaires-ou-jours-juliens.html
"""
if cnv_gen.is_iterable(jjulin):
return [jjulCNES2dt(e) for e in jjulin]
else:
return dt.datetime(1950, 0o1, 0o1, 00, 00, 00) + dt.timedelta(
float(jjulin))
def dt_gpstime2dt_utc(dtgpsin, out_array=False):
"""
Time conversion
Datetime in GPS Time Scale => Datetime in UTC Time Scale
Correct both the Leap second and the 19sec difference between GPS Time and UTC
Parameters
----------
dtin : datetime or list/numpy.array of datetime.
Datetime(s) in GPS Time Scale. Can handle several datetimes in an iterable.
out_array : bool
if iterable as input, force the output as a Numpy array
Returns
-------
L : datetime or list/numpy.array of datetime.
Datetime(s) in UTC Time Scale
"""
# on converti le dt gps en dt utc
if cnv_gen.is_iterable(dtgpsin):
Out = [dt_gpstime2dt_utc(e) for e in dtgpsin]
if not out_array:
return Out
else:
return np.array(Out)
else:
leapsec = find_leapsecond(dtgpsin)
dtutc = dtgpsin + dt.timedelta(seconds=19) - dt.timedelta(
seconds=leapsec)
return dtutc
def tgipsy2dt(tin):
"""
Time conversion
GIPSY Time => Datetime
Parameters
----------
tin : float or list/numpy.array of float
GIPSY time(s). Can handle several time float in a list.
Returns
-------
dtout : datetime or list/numpy.array of datetime
Converted Datetime(s)
Note
----
GIPSY time is not the 'real' J2000
but only counted starting from 1st January 2000 at Noon
"""
if cnv_gen.is_iterable(tin):
return [tgipsy2dt(e) for e in tin]
else:
j2000 = dt.datetime(2000, 1, 1, 12, 0)
tout = j2000 + dt.timedelta(seconds=float(tin))
return tout
return tout
def date_string_2_dt(strin):
"""
Time conversion
String => Python's Datetime
Wrapper of dateutil.parser.parse
The input string should looks like a timestamp
Parameters
----------
strin : string or list/numpy.array of strings.
string(s). Can handle several datetimes in an iterable.
Returns
-------
L : datetime or list of datetime.
Datetime(s)
"""
import dateutil.parser
if cnv_gen.is_iterable(strin):
return np.array([date_string_2_dt(e) for e in strin])
else:
return dateutil.parser.parse(strin)
def dt2gpstime(dtin,dayinweek=True):
"""
Time conversion
Python's datetime => GPS time
Parameters
----------
dtin : datetime or list/numpy.array of datetime
Datetime(s). Can handle several datetimes in an iterable.
dayinweek : bool
if True : returns GPS week, day in GPS week
if False : returns GPS week, sec in GPS week
Returns
-------
GPS_week, GPS_day/GPS_sec : tuple of int
GPS week or GPS day/GPS sec
Is a list of tuple if the input is an iterable
"""
if cnv_gen.is_iterable(dt):
return [dt2gpstime(e) for e in dtin]
else:
week , secs = utc2gpstime(dtin.year,dtin.month,dtin.day,dtin.hour,
dtin.minute,dtin.second)
if dayinweek:
day = np.floor(np.divide(secs,86400))
return int(week) , int(day)
else:
return int(week) , int(secs)
def posix2dt(posixin, out_array=False):
"""
Time conversion
POSIX Time => Python's Datetime
Parameters
----------
posixin : float or list/numpy.array of floats.
POSIX Time. Can handle several time in a list.
out_array : bool
if iterable as input, force the output as a Numpy array
Returns
-------
L : datetime or list/numpy.array of datetime.
Converted Datetime(s)
"""
if not cnv_gen.is_iterable(posixin):
if np.isnan(posixin):
return dt.datetime(1970, 1, 1)
else:
return dt.datetime(1970, 1, 1) + dt.timedelta(seconds=posixin)
else:
L = [posix2dt(e) for e in posixin]
if out_array:
return np.array(L)
else:
return L
def doy2dt(year, days, hours=0, minutes=0, seconds=0):
"""
Time conversion
Day of Year Time => Python's datetime
Parameters
----------
year, days : float or list/numpy.array of floats.
year, days of year
hours, minutes, seconds : float or list/numpy.array of floats, optional
hours, minutes, seconds
Returns
-------
L : datetime or list/numpy.array of datetime.
Datetime(s)
"""
if not cnv_gen.is_iterable(year):
# All this because Python cant handle int with a starting with 0 (like 08)
# => SyntaxError: invalid token
year = int(str(year))
days = int(str(days))
hours = float(str(hours))
minutes = float(str(minutes))
seconds = float(str(seconds))
tempsecs = seconds + 60 * minutes + 3600 * hours
#finalsecs = np.floor(tempsecs)
finalmicrosec = np.round(tempsecs * 10**6)
return dt.datetime(year, 1, 1) + dt.timedelta(days - 1) + \
dt.timedelta(microseconds=finalmicrosec)
else:
if not cnv_gen.is_iterable(hours):
hours = [0] * len(year)
if not cnv_gen.is_iterable(minutes):
minutes = [0] * len(year)
if not cnv_gen.is_iterable(seconds):
seconds = [0] * len(year)
outlis = []
for y, d, h, m, s in zip(year, days, hours, minutes, seconds):
outlis.append(doy2dt(y, d, h, m, s))
return outlis
def posix2dt_in_local_timezone(posixin):
if not cnv_gen.is_iterable(posixin):
if np.isnan(posixin):
return dt.datetime(1970, 1, 1)
else:
return dt.datetime.fromtimestamp(posixin)
else:
return [posix2dt_in_local_timezone(e) for e in posixin]
def gpsweek_decimal2dt(gpsweekdec_in):
if cnv_gen.is_iterable(gpsweekdec_in):
return [gpsweek_decimal2dt(e) for e in gpsweekdec_in]
else:
week_floor = np.floor(gpsweekdec_in)
week_dec_part = gpsweekdec_in - week_floor
dt_out = gpstime2dt(week_floor, week_dec_part * 7)
return dt_out
def datestr_gins_filename_2_dt(datestrin):
"""
Time conversion
GINS filename time format => Python's Datetime
GINS filename time format : 'YYMMDD_HHMMSS'
It is the time format used in the listing names
Parameters
----------
datestrin : string or list/numpy.array of string.
GINS filename time format string(s).
Can handle several string in an iterable.
Returns
-------
dtout : datetime or list of datetime.
Datetime(s)
"""
if cnv_gen.is_iterable(datestrin):
return [datestr_gins_filename_2_dt(e) for e in datestrin]
else:
#### CASE WHERE THE DATE LOOKS LIKE 00000:00000
yr = int(datestrin[0:2])
mm = int(datestrin[2:4])
dd = int(datestrin[4:6])
hh = int(datestrin[7:9])
mmin = int(datestrin[9:11])
ss = int(datestrin[11:13])
if yr > 50:
year = 1900 + yr
else:
year = 2000 + yr
return dt.datetime(year,mm,dd,hh,mmin,ss)
hh = int(datestrin[7:9])
mmin = int(datestrin[9:11])
ss = int(datestrin[11:13])
if yr > 50:
year = 1900 + yr
else:
year = 2000 + yr
return dt.datetime(year,mm,dd,hh,mmin,ss)
def dt2gpstime(dtin, dayinweek=True, inp_ref="utc"):
"""
Time conversion
Python's datetime => GPS time
Parameters
----------
dtin : datetime or list/numpy.array of datetime
Datetime(s). Can handle several datetimes in an iterable.
inp_ref : str
"utc" : apply the 19 sec & leap second correction at the epoch
"gps" : no correction applied
"tai" : apply -19 sec correction
dayinweek : bool
if True : returns GPS week, day in GPS week
if False : returns GPS week, sec in GPS week
Returns
-------
GPS_week, GPS_day/GPS_sec : tuple of int
GPS week or GPS day/GPS sec
Is a list of tuple if the input is an iterable
"""
if cnv_gen.is_iterable(dtin):
return [dt2gpstime(e) for e in dtin]
else:
week_raw, secs_raw = utc2gpstime(dtin.year, dtin.month, dtin.day,
dtin.hour, dtin.minute, dtin.second)
utc_offset = find_leapsecond(dtin)
if inp_ref == "utc":
### utc : utc2gpstime did the job
week, secs = week_raw, secs_raw
elif inp_ref == "tai":
### tai : utc2gpstime did the job, but needs leap sec correction again
week, secs = week_raw, secs_raw - utc_offset
elif inp_ref == "gps":
### tai : utc2gpstime did the job, but needs leap sec & 19sec correction again
week, secs = week_raw, secs_raw + 19 - utc_offset
if dayinweek:
day = np.floor(np.divide(secs, 86400))
return int(week), int(day)
else:
return int(week), int(secs)
def datestr_sinex_2_dt(datestrin):
"""
Time conversion
SINEX time format => Python's Datetime
SINEX time format : 'YY:DDD:SSSSS' or 'YYYY:DDD:SSSSS'
Parameters
----------
datestrin : string or list/numpy.array of string.
SINEX time format string(s). Can handle several string in an iterable.
Returns
-------
dtout : datetime or list of datetime.
Datetime(s)
"""
if cnv_gen.is_iterable(datestrin):
return [datestr_sinex_2_dt(e) for e in datestrin]
else:
#### CASE WHERE THE DATE LOOKS LIKE 00000:00000
if re.search("[0-9]{5}:[0-9]{5}", datestrin):
datestr_list = list(datestrin)
datestr_list.insert(2, ":")
datestrin = "".join(datestr_list)
elif '00:000:00000' in datestrin:
return dt.datetime(1970, 1, 1)
dateint = [int(e) for e in datestrin.split(':')]
yr = dateint[0]
doy = dateint[1]
sec = dateint[2]
## case for year with only 2 digits
if re.match("[0-9]{2}:[0-9]{3}:[0-9]{5}", datestrin):
if yr > 50:
year = 1900 + yr
else:
year = 2000 + yr
else:
year = yr
return doy2dt(year, doy, seconds=sec)
def MJD2dt(mjd_in, seconds=None):
# cf http://en.wikipedia.org/wiki/Julian_day
"""
Time conversion
Modified Julian Day => Python's Datetime
Parameters
----------
mjd_in : float/int or list/numpy.array of float/int.
Modified Julian Day. Can handle several float/int in an iterable.
Returns
-------
L : datetime or list of datetime.
Datetime(s)
Note
----
Modified Julian Day starts at 0h Nov 17, 1858 (JD − 2400000.5)
https://en.wikipedia.org/wiki/Julian_day
"""
# ITERABLE CASE
if cnv_gen.is_iterable(mjd_in):
if seconds:
if len(seconds) != len(mjd_in):
print("ERR : MJD2dt : len(seconds) != len(mjd_in) !!")
raise Exception
else:
seconds = np.zeros(len(mjd_in))
return [
dt.datetime(1858, 11, 17) + dt.timedelta(days=m, seconds=sec)
for m, sec in zip(mjd_in, seconds)
]
# NON ITERABLE / FLOAT CASE
else:
if not seconds:
seconds = 0
return dt.datetime(1858, 11, 17) + dt.timedelta(days=mjd_in,
seconds=seconds)
def dt2fracday(dtin):
"""
Python's datetime => Seconds in days
Parameters
----------
dtin : datetime or list/numpy.array of datetime
Datetime(s). Can handle several datetimes in an iterable.
Returns
-------
fraction_day : float
Fractional of the day
Is a list of int if the input is an iterable
"""
if cnv_gen.is_iterable(dtin):
return [dt2fracday(e) for e in dtin]
else:
return dtin.hour / 24 + dtin.minute / (60*24) + dtin.second / (60*60*24)
def dt2year_decimal(dtin):
"""
Time conversion
Python's Datetime => Decimal Year
Parameters
----------
dtin : datetime or list/numpy.array of datetime.
Datetime(s). Can handle several datetimes in an iterable.
Returns
-------
L : float or list/numpy.array of floats
Decimal Year(s)
"""
if cnv_gen.is_iterable(dtin):
return np.array([dt2year_decimal(e) for e in dtin])
else:
return toYearFraction(dtin)
def year_decimal2dt(yearin):
"""
Time conversion
Decimal Year => Python's Datetime
Parameters
----------
yearin : float or list/numpy.array of floats.
Decimal year(s). Can handle several floats in an iterable.
Returns
-------
L : datetime or list of datetime.
Datetime(s)
"""
if cnv_gen.is_iterable(yearin):
return [year_decimal2dt(e) for e in yearin]
else:
return convert_partial_year(yearin)
def dt2secinday(dtin):
"""
Time conversion
Python's datetime => Seconds in days
Parameters
----------
dtin : datetime or list/numpy.array of datetime
Datetime(s). Can handle several datetimes in an iterable.
Returns
-------
secinday : int
Seconds in the day
Is a list of int if the input is an iterable
"""
if cnv_gen.is_iterable(dtin):
return [dt2secinday(e) for e in dtin]
else:
return dtin.hour * 3600 + dtin.minute * 60 + dtin.second
def matlab_time2dt(matlab_datenum):
"""
Time conversion
MATLAB Time => Datetime
Parameters
----------
matlab_datenum : float or list/numpy.array of float
MATLAB time(s). Can handle several time floats in a list.
Returns
-------
python_datetime : datetime or list/numpy.array of datetime
Converted Datetime(s)
"""
if cnv_gen.is_iterable(matlab_datenum):
return [matlab_time2dt(e) for e in matlab_datenum]
else:
python_datetime = dt.datetime.fromordinal(int(matlab_datenum)) + \
dt.timedelta(days=matlab_datenum%1) - dt.timedelta(days = 366)
return python_datetime
def dt2doy_year(dtin, outputtype=str):
"""
Time conversion
Python's datetime => Day of Year, Year
Parameters
----------
dtin : datetime or list/numpy.array of datetime
Datetime(s). Can handle several datetimes in an iterable.
Returns
-------
doy , year : tuple of int
Day of Year and Year
Is a list of tuple if the input is an iterable
"""
if cnv_gen.is_iterable(dtin):
return [dt2doy_year(e, outputtype=outputtype) for e in dtin]
else:
return outputtype(dtin.strftime('%j')), outputtype(dtin.strftime('%Y'))
def dt_in_local_timezone2posix(dtin):
if not cnv_gen.is_iterable(dtin):
return time.mktime(dtin.timetuple()) + dtin.microsecond * 0.000001
else:
return [dt_in_local_timezone2posix(e) for e in dtin]
