fasttime 0.2.3

Small UTC date/time library based on Ben Joffe's fast 64-bit date algorithm
Documentation 
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
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278

"""
Tests for the fasttime Python bindings.
"""

import pytest
import fasttime


def test_date_creation():
    """Test creating dates."""
    date = fasttime.Date(2024, 1, 15)
    assert date.year == 2024
    assert date.month == 1
    assert date.day == 15


def test_date_from_days():
    """Test creating dates from days since epoch."""
    epoch = fasttime.Date.from_days_since_unix_epoch(0)
    assert epoch.year == 1970
    assert epoch.month == 1
    assert epoch.day == 1


def test_date_parse():
    """Test parsing dates from strings."""
    date = fasttime.Date.parse("2024-06-15")
    assert date.year == 2024
    assert date.month == 6
    assert date.day == 15


def test_date_invalid():
    """Test that invalid dates raise errors."""
    with pytest.raises(ValueError):
        fasttime.Date(2024, 13, 1)  # Invalid month
    
    with pytest.raises(ValueError):
        fasttime.Date(2024, 2, 30)  # Invalid day for February


def test_date_weekday():
    """Test weekday calculation."""
    date = fasttime.Date(2024, 1, 1)  # Was a Monday
    weekday = date.weekday()
    assert weekday.number_from_monday() == 1


def test_date_ordinal():
    """Test ordinal (day of year) calculation."""
    date = fasttime.Date(2024, 1, 1)
    assert date.ordinal() == 1
    
    date = fasttime.Date(2024, 12, 31)
    assert date.ordinal() == 366  # 2024 is a leap year


def test_date_add_days():
    """Test adding days to a date."""
    date = fasttime.Date(2024, 1, 1)
    next_day = date.add_days(1)
    assert next_day.year == 2024
    assert next_day.month == 1
    assert next_day.day == 2


def test_date_comparison():
    """Test date comparisons."""
    date1 = fasttime.Date(2024, 1, 1)
    date2 = fasttime.Date(2024, 12, 31)
    
    assert date1 < date2
    assert date1 <= date2
    assert date2 > date1
    assert date2 >= date1
    assert date1 == date1
    assert date1 != date2


def test_date_hash():
    """Test that dates can be hashed."""
    date1 = fasttime.Date(2024, 1, 1)
    date2 = fasttime.Date(2024, 1, 1)
    date3 = fasttime.Date(2024, 12, 31)
    
    assert hash(date1) == hash(date2)
    assert hash(date1) != hash(date3)
    
    # Test in sets
    dates = {date1, date2, date3}
    assert len(dates) == 2


def test_time_creation():
    """Test creating times."""
    time = fasttime.Time(14, 30, 45, nanosecond=123_456_789)
    assert time.hour == 14
    assert time.minute == 30
    assert time.second == 45
    assert time.nanosecond == 123_456_789


def test_time_parse():
    """Test parsing times from strings."""
    time = fasttime.Time.parse("14:30:45.123456789")
    assert time.hour == 14
    assert time.minute == 30
    assert time.second == 45
    assert time.nanosecond == 123_456_789


def test_time_invalid():
    """Test that invalid times raise errors."""
    with pytest.raises(ValueError):
        fasttime.Time(25, 0, 0)  # Invalid hour
    
    with pytest.raises(ValueError):
        fasttime.Time(0, 60, 0)  # Invalid minute


def test_datetime_creation():
    """Test creating datetimes."""
    date = fasttime.Date(2024, 6, 15)
    time = fasttime.Time(12, 30, 45)
    dt = fasttime.DateTime(date, time)
    
    assert dt.date == date
    assert dt.time == time


def test_datetime_from_timestamp():
    """Test creating datetimes from Unix timestamps."""
    dt = fasttime.DateTime.from_unix_timestamp(1_700_000_000, 123_456_789)
    assert dt.unix_timestamp() == 1_700_000_000
    assert dt.time.nanosecond == 123_456_789


def test_datetime_parse():
    """Test parsing datetimes from strings."""
    dt = fasttime.DateTime.parse("2024-06-15T12:30:45Z")
    assert dt.date.year == 2024
    assert dt.date.month == 6
    assert dt.date.day == 15
    assert dt.time.hour == 12
    assert dt.time.minute == 30
    assert dt.time.second == 45


def test_datetime_now_utc():
    """Test getting current UTC time."""
    now = fasttime.DateTime.now_utc()
    assert now.date.year >= 2024  # Should be in the future


def test_datetime_add_duration():
    """Test adding durations to datetimes."""
    dt = fasttime.DateTime.parse("2024-01-01T00:00:00Z")
    one_hour = fasttime.Duration.seconds(3600)
    
    later = dt.add_duration(one_hour)
    assert later.time.hour == 1


def test_datetime_difference():
    """Test calculating differences between datetimes."""
    dt1 = fasttime.DateTime.parse("2024-01-01T00:00:00Z")
    dt2 = fasttime.DateTime.parse("2024-01-01T01:00:00Z")
    
    diff = dt2.difference(dt1)
    assert diff.total_seconds() == 3600


def test_duration_creation():
    """Test creating durations."""
    seconds = fasttime.Duration.seconds(60)
    millis = fasttime.Duration.milliseconds(1000)
    
    assert seconds.total_seconds() == 60
    assert millis.total_seconds() == 1


def test_duration_arithmetic():
    """Test duration arithmetic."""
    dur1 = fasttime.Duration.seconds(10)
    dur2 = fasttime.Duration.seconds(5)
    
    total = dur1 + dur2
    diff = dur1 - dur2
    neg = -dur1
    
    assert total.total_seconds() == 15
    assert diff.total_seconds() == 5
    assert neg.total_seconds() == -10


def test_duration_comparison():
    """Test duration comparisons."""
    short = fasttime.Duration.seconds(10)
    long = fasttime.Duration.seconds(100)
    
    assert short < long
    assert short <= long
    assert long > short
    assert long >= short
    assert short == short
    assert short != long


def test_utc_offset_creation():
    """Test creating UTC offsets."""
    offset = fasttime.UtcOffset.from_hours_minutes(True, 5, 30)
    assert offset.as_seconds() == 5 * 3600 + 30 * 60
    
    offset_neg = fasttime.UtcOffset.from_hours_minutes(False, 8, 0)
    assert offset_neg.as_seconds() == -8 * 3600


def test_utc_offset_is_utc():
    """Test checking if offset is UTC."""
    utc = fasttime.UtcOffset.from_seconds(0)
    not_utc = fasttime.UtcOffset.from_hours_minutes(True, 5, 0)
    
    assert utc.is_utc()
    assert not not_utc.is_utc()


def test_offset_datetime_from_local():
    """Test creating offset datetimes from local time."""
    date = fasttime.Date(2024, 6, 15)
    time = fasttime.Time(18, 0, 0)
    offset = fasttime.UtcOffset.from_hours_minutes(True, 5, 30)
    
    odt = fasttime.OffsetDateTime.from_local(date, time, offset)
    assert odt.offset == offset


def test_offset_datetime_parse():
    """Test parsing offset datetimes."""
    odt = fasttime.OffsetDateTime.parse("2024-06-15T12:00:00+05:30")
    assert odt.offset.as_seconds() == 5 * 3600 + 30 * 60


def test_offset_datetime_to_local():
    """Test converting offset datetime to local."""
    odt = fasttime.OffsetDateTime.parse("2024-06-15T12:00:00Z")
    local = odt.to_local()
    
    assert local.date.year == 2024
    assert local.date.month == 6
    assert local.date.day == 15


def test_round_trip_date():
    """Test round-trip conversion for dates."""
    original = fasttime.Date(2024, 6, 15)
    days = original.days_since_unix_epoch()
    reconstructed = fasttime.Date.from_days_since_unix_epoch(days)
    
    assert original == reconstructed


def test_round_trip_datetime():
    """Test round-trip conversion for datetimes."""
    original = fasttime.DateTime.parse("2024-06-15T12:30:45.123456789Z")
    timestamp = original.unix_timestamp()
    nanos = original.time.nanosecond
    reconstructed = fasttime.DateTime.from_unix_timestamp(timestamp, nanos)
    
    assert original == reconstructed


def test_round_trip_offset_datetime():
    """Test round-trip conversion for offset datetimes."""
    original = "2024-06-15T12:00:00+05:30"
    odt = fasttime.OffsetDateTime.parse(original)
    serialized = str(odt)
    
    assert original == serialized