[566baa]: MySQLdb / times.py  Maximize  Restore  History

Download this file

244 lines (190 with data), 7.1 kB

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
"""
times module
------------
WARNING: The doctests only pass if you're in the right timezone and
daylight savings time setting. XXX
This module provides some help functions for dealing with MySQL data.
Most of these you will not have to use directly.
Uses Python datetime module to handle time-releated columns."""
from time import localtime
from datetime import date, datetime, time, timedelta
# These are required for DB-API (PEP-249)
Date = date
Time = time
TimeDelta = timedelta
Timestamp = datetime
def DateFromTicks(ticks):
"""Convert UNIX ticks into a date instance.
>>> DateFromTicks(1172466380)
datetime.date(2007, 2, 26)
>>> DateFromTicks(0)
datetime.date(1969, 12, 31)
>>> DateFromTicks(2**31-1)
datetime.date(2038, 1, 18)
This is a standard DB-API constructor.
"""
return date(*localtime(ticks)[:3])
def TimeFromTicks(ticks):
"""Convert UNIX ticks into a time instance.
>>> TimeFromTicks(1172466380)
datetime.time(0, 6, 20)
>>> TimeFromTicks(0)
datetime.time(18, 0)
>>> TimeFromTicks(2**31-1)
datetime.time(21, 14, 7)
This is a standard DB-API constructor.
"""
return time(*localtime(ticks)[3:6])
def TimestampFromTicks(ticks):
"""Convert UNIX ticks into a datetime instance.
>>> TimestampFromTicks(1172466380)
datetime.datetime(2007, 2, 25, 23, 6, 20)
>>> TimestampFromTicks(0)
datetime.datetime(1969, 12, 31, 18, 0)
>>> TimestampFromTicks(2**31-1)
datetime.datetime(2038, 1, 18, 21, 14, 7)
This is a standard DB-API constructor.
"""
return datetime(*localtime(ticks)[:6])
def timedelta_to_str(obj):
"""Format a timedelta as a string.
>>> timedelta_to_str(timedelta(seconds=-86400))
'-1 00:00:00'
>>> timedelta_to_str(timedelta(hours=73, minutes=15, seconds=32))
'3 01:15:32'
"""
seconds = int(obj.seconds) % 60
minutes = int(obj.seconds / 60) % 60
hours = int(obj.seconds / 3600) % 24
return '%d %02d:%02d:%02d' % (obj.days, hours, minutes, seconds)
def datetime_to_str(obj):
"""Convert a datetime to an ISO-format string.
>>> datetime_to_str(datetime(2007, 2, 25, 23, 6, 20))
'2007-02-25 23:06:20'
"""
return obj.strftime("%Y-%m-%d %H:%M:%S")
def datetime_or_orig(obj):
"""Returns a DATETIME or TIMESTAMP column value as a datetime object:
>>> datetime_or_orig('2007-02-25 23:06:20')
datetime.datetime(2007, 2, 25, 23, 6, 20)
>>> datetime_or_orig('2007-02-25T23:06:20')
datetime.datetime(2007, 2, 25, 23, 6, 20)
Illegal values are returned unchanged:
>>> datetime_or_orig('2007-02-31T23:06:20')
'2007-02-31T23:06:20'
>>> datetime_or_orig('0000-00-00 00:00:00')
'0000-00-00 00:00:00'
"""
if ' ' in obj:
sep = ' '
elif 'T' in obj:
sep = 'T'
else:
return date_or_orig(obj)
try:
ymd, hms = obj.split(sep, 1)
return datetime(*[ int(x) for x in ymd.split('-')+hms.split(':') ])
except ValueError:
return obj
def timedelta_or_orig(obj):
"""Returns a TIME column as a timedelta object:
>>> timedelta_or_orig('25:06:17')
datetime.timedelta(1, 3977)
>>> timedelta_or_orig('-25:06:17')
datetime.timedelta(-2, 83177)
Illegal values are returned unchanged:
>>> timedelta_or_orig('random crap')
'random crap'
Note that MySQL always returns TIME columns as (+|-)HH:MM:SS, but
can accept values as (+|-)DD HH:MM:SS. The latter format will not
be parsed correctly by this function.
"""
from math import modf
try:
hours, minutes, seconds = obj.split(':')
tdelta = timedelta(
hours = int(hours),
minutes = int(minutes),
seconds = int(seconds),
microseconds = int(modf(float(seconds))[0]*1000000),
)
if hours < 0:
return -tdelta
else:
return tdelta
except ValueError:
return obj
def time_or_orig(obj):
"""Returns a TIME column as a time object:
>>> time_or_orig('15:06:17')
datetime.time(15, 6, 17)
Illegal values are returned unchanged:
>>> time_or_orig('-25:06:17')
'-25:06:17'
>>> time_or_orig('random crap')
'random crap'
Note that MySQL always returns TIME columns as (+|-)HH:MM:SS, but
can accept values as (+|-)DD HH:MM:SS. The latter format will not
be parsed correctly by this function.
Also note that MySQL's TIME column corresponds more closely to
Python's timedelta and not time. However if you want TIME columns
to be treated as time-of-day and not a time offset, then you can
use set this function as the converter for FIELD_TYPE.TIME.
"""
from math import modf
try:
hour, minute, second = obj.split(':')
return time(hour=int(hour), minute=int(minute), second=int(second),
microsecond=int(modf(float(second))[0]*1000000))
except ValueError:
return obj
def date_or_orig(obj):
"""Returns a DATE column as a date object:
>>> date_or_orig('2007-02-26')
datetime.date(2007, 2, 26)
Illegal values are returned unchanged:
>>> date_or_orig('2007-02-31')
'2007-02-31'
>>> date_or_orig('0000-00-00')
'0000-00-00'
"""
try:
return date(*map(int, obj.split('-', 2)))
except ValueError:
return obj
def datetime_to_sql(connection, obj):
"""Format a DateTime object as an ISO timestamp."""
return connection.string_literal(datetime_to_str(obj))
def timedelta_to_sql(connection, obj):
"""Format a timedelta as an SQL literal."""
return connection.string_literal(timedelta_to_str(obj))
def timestamp_or_orig(timestamp):
"""Convert a MySQL TIMESTAMP to a Timestamp object.
MySQL >= 4.1 returns TIMESTAMP in the same format as DATETIME:
>>> timestamp_or_orig('2007-02-25 22:32:17')
datetime.datetime(2007, 2, 25, 22, 32, 17)
MySQL < 4.1 uses a big string of numbers:
>>> timestamp_or_orig('20070225223217')
datetime.datetime(2007, 2, 25, 22, 32, 17)
Illegal values are returned unchanged:
>>> timestamp_or_orig('2007-02-31 22:32:17')
'2007-02-31 22:32:17'
>>> timestamp_or_orig('00000000000000')
'00000000000000'
"""
try:
if timestamp[4] == '-':
return datetime_or_orig(timestamp)
timestamp += "0"*(14-len(timestamp)) # padding
year, month, day, hour, minute, second = \
int(timestamp[:4]), int(timestamp[4:6]), int(timestamp[6:8]), \
int(timestamp[8:10]), int(timestamp[10:12]), int(timestamp[12:14])
except IndexError:
return timestamp
try:
return datetime(year, month, day, hour, minute, second)
except ValueError:
return timestamp
if __name__ == "__main__":
import doctest
doctest.testmod()