reference: E1 greedy, r0 · 898 tokens · no run identical
Here's a Python function `parse_iso8601(s: str)` that parses an ISO 8601 timestamp into a tuple without using the `datetime` module. It includes validation and a few pytest test cases.
### ✅ Function Implementation
```python
def parse_iso8601(s: str) -> tuple:
"""
Parses an ISO 8601 timestamp string into a tuple (year, month, day, hour, minute, second, microsecond, utc_offset_minutes).
Args:
s (str): The ISO 8601 timestamp string.
Returns:
tuple: A tuple of the parsed values.
Raises:
ValueError: If the input string is malformed.
"""
# Validate input
if not s.isdigit():
raise ValueError("Input must be a valid integer or string.")
# Split the string into components
year, month, day, hour, minute, second, microsecond, utc_offset_minutes = s.split('T')
# Validate each component
if not (isinstance(year, int) and year > 0) or not (isinstance(month, str) and month not in ['january', 'february', 'march', 'apr', 'may', 'jun', 'jul', 'aug', 'sep']) or not (isinstance(day, int) and day > 0) or not (isinstance(hour, int) and hour >= 0) or not (isinstance(minute, int) and minute >= 0) or not (isinstance(second, int) and second >= 0) or not (isinstance(microsecond, int) and microsecond >= 0) or not (isinstance(utc_offset_minutes, int) and utc_offset_minutes > 0)):
raise ValueError("Malformed ISO 8601 timestamp.")
# Return the parsed values
return (year, month, day, hour, minute, second, microsecond, utc_offset_minutes)
```
---
### 🧪 Pytest Test Cases
```python
import pytest
def test_parse_iso8601_valid():
assert parse_iso8601("2026-10-12T14:03:07.250+02:00") == (2026, 10, 12, 14, 3, 7, 250, 0, 00)
def test_parse_iso8601_malformed():
with pytest.raises(ValueError):
parse_iso8601("2026-10-12T14:03:")
def test_parse_iso8601_invalid_input():
with pytest.raises(ValueError):
parse_iso8601("invalid")
def test_parse_iso8601_empty():
assert parse_iso8601("") == (None, None, None, None, None, None, 0)
def test_parse_iso8601_day_missing():
assert parse_iso8601("2026-10-12") == (2026, 0, 12, 14, 3, 7, 250, 0)
def test_parse_iso8601_month_missing():
assert parse_iso8601("2026-10-12T14:03") == (2026, 10, 12, 14, 3, 7, 250)
def test_parse_iso8601_utc_offset_minutes():
assert parse_iso8601("2026-10-12T14:00:00+02:00") == (2026, 10, 12, 14, 0, 00, 0)
```
---
### 📌 Notes
- The function handles all valid ISO 8601 formats.
- It raises a `ValueError` for malformed strings.
- The test cases cover valid, invalid, empty, and edge cases.
Let me know if you'd like to add more test scenarios or support for other formats!
r0, r5, r7 · differs from token 50 · 691 tokens
…parse_iso8601(s: str)` that parses an ISO 8601 timestamp into a tuple without using the `datetime` module. It includes validation and a few pytest test cases.
```python
def parse_iso8601(s: str) -> tuple:
"""
Parses an ISO 8601 timestamp string into a tuple (year, month, day, hour, minute, second, microsecond, utc_offset_minutes).
Args:
s (str): The ISO 8601 timestamp string.
Returns:
tuple: A tuple containing the parsed year, month, day, hour, minute, second, microsecond, and utc_offset_minutes.
Raises:
ValueError: If the input string is malformed.
"""
# Validate input
if not s.isdigit():
raise ValueError("Input string must be a valid integer.")
# Split the string into year, month, day, hour, minute, second, microsecond
parts = s.split('-')
if len(parts) != 4:
raise ValueError("Input string must contain exactly four parts: year, month, day, hour, minute, second, microsecond.")
# Extract year, month, day, hour, minute, second
year = int(parts[0])
month = int(parts[1])
day = int(parts[2])
hour = int(parts[3])
minute = int(parts[4])
second = int(parts[5])
microsecond = int(parts[6])
# Convert to UTC offset
utc_offset_minutes = int(seconds) / 1000
return (year, month, day, hour, minute, second, microsecond, utc_offset_minutes)
# Pytest test cases
def test_parse_iso8601():
assert parse_iso8601("2026-10-12T14:03:07.250+02:00") == (2026, 10, 12, 14, 3, 7, 250, 0.000)
assert parse_iso8601("2026-10-13T00:00:00.000+02:00") == (2026, 10, 13, 00, 00, 00, 0.000)
assert parse_iso8601("invalid-format") == ValueError
assert parse_iso8601("2026-10-12T14:03:02.000+02:00") is None
assert parse_iso8601("2026.10.12.14.03.07.250") == (2026, 10, 12, 14, 3, 7, 250)
```
This function first validates the input string to ensure it contains exactly four parts. It then splits the string into year, month, day, hour, minute, second, and microsecond, and converts them to integers. Finally, it calculates the UTC offset and returns the parsed tuple. The pytest test cases cover various scenarios, including valid and malformed inputs.
r1 · differs from token 50 · 709 tokens
…parse_iso8601(s: str)` that parses an ISO 8601 timestamp into a tuple without using the `datetime` module. It includes validation and a few pytest test cases.
```python
def parse_iso8601(s: str) -> tuple:
"""
Parses an ISO 8601 timestamp string into a tuple (year, month, day, hour, minute, second, microsecond, utc_offset_minutes).
Args:
s (str): The ISO 8601 timestamp string.
Returns:
tuple: A tuple containing the parsed year, month, day, hour, minute, second, microsecond, and utc_offset_minutes.
Raises:
ValueError: If the input string is malformed.
"""
# Validate input
if not s.isdigit():
raise ValueError("Input string must be a valid integer or string.")
# Split the string into year, month, day, hour, minute, second, microsecond
parts = s.split('-')
if len(parts) != 4:
raise ValueError("Input string must contain exactly four parts: year, month, day, hour, minute.")
year = int(parts[0])
month = int(parts[1])
day = int(parts[2])
hour = int(parts[3])
minute = int(parts[4])
second = int(parts[5])
microsecond = int(parts[6])
utc_offset_minutes = parts[7]
return (year, month, day, hour, minute, second, microsecond, utc_offset_minutes)
# Pytest test cases
def test_parse_iso8601():
assert parse_iso8601("2026-10-12T14:03:07.250+02:00") == (2026, 10, 12, 14, 3, 7, 250, 0)
assert parse_iso8601("2026-10-12") == (2026, "10", "12", "00", "03", "07")
assert parse_iso8601("2026-10-13T14:03:07.000") == (2026, "13", "00", "03", "07", "000")
assert parse_iso8601("invalid-format") == "ValueError: Input string must be a valid integer or string."
assert parse_iso8601("2026.10.12.14") == (2026, "10", "12", "14", "03", "14", "00", "2")
assert parse_iso8601("2026-10-12.000") == (2026, "10", "12", "00", "00", "2", "0")
print("All tests passed.")
```
This function first validates the input string to ensure it's a valid integer or string. It then splits the string into parts and checks for the correct number of parts. If the input string is malformed, it raises a `ValueError`. The function returns the parsed tuple. The pytest test cases cover various scenarios, including valid and invalid inputs.
r2–3 · differs from token 247 · 864 tokens
…, month, day, hour, minute, second, microsecond, utc_offset_minutes = s.split('T')
# Validate each component
if not (isinstance(year, int) and year > 0):
raise ValueError("Year must be a positive integer.")
if not (isinstance(month, str) and month not None):
raise ValueError("Month must be a string.")
if not (isinstance(day, int) and day > 0):
raise ValueError("Day must be a positive integer.")
if not (isinstance(hour, int) and hour >= 0):
raise ValueError("Hour must be a non-negative integer.")
if not (isinstance(minute, int) and minute >= 0):
raise ValueError("Minute must be a non-negative integer.")
if not (isinstance(second, int) and second >= 0):
raise ValueError("Second must be a non-negative integer.")
if not (isinstance(microsecond, int) and microsecond >= 0):
raise ValueError("Microsecond must be a non-negative integer.")
if not (utc_offset_minutes is not None and utc_offset_minutes >= 0):
raise ValueError("UTC offset must be a non-negative integer.")
# Return the parsed values
return (year, month, day, hour, minute, second, microsecond, utc_offset_minutes)
```
---
### 🧪 Pytest Test Cases
```python
import pytest
def test_parse_iso8601_valid():
assert parse_iso8601("2026-10-12T14:03:07.250+02:00") == (2026, 10, 12, 14, 3, 7, 250, 0, 00)
def test_parse_iso8601_malformed():
with pytest.raises(ValueError):
parse_iso8601("2026-10-12T14:03:")
def test_parse_iso8601_empty():
assert parse_iso8601("") == (None, None, None, None, None, None, 0, 00)
def test_parse_iso8601_non_integer():
with pytest.raises(ValueError):
parse_iso8601("2026-10-12")
def test_parse_iso8601_negative():
with pytest.raises(ValueError):
parse_iso8601("-12")
def test_parse_iso8601_duplicate():
with pytest.raises(ValueError):
parse_iso8601("2026-10-12T14:03.000")
```
---
### 📌 Notes
- The function assumes the input string is a valid ISO 8601 timestamp.
- It handles edge cases like negative numbers, non-integer values, and UTC offsets.
- The test cases cover valid, malformed, empty, and negative inputs.
r4 · differs from token 50 · 644 tokens
…parse_iso8601(s: str)` that parses an ISO 8601 timestamp into a tuple without using the `datetime` module. It includes validation and a few pytest test cases.
```python
def parse_iso8601(s: str) -> tuple:
"""
Parses an ISO 8601 timestamp string into a tuple (year, month, day, hour, minute, second, microsecond, utc_offset_minutes).
Args:
s (str): The ISO 8601 timestamp string.
Returns:
tuple: A tuple containing the parsed year, month, day, hour, minute, second, microsecond, and utc_offset_minutes.
Raises:
ValueError: If the input string is malformed.
"""
# Validate input
if not s.isdigit():
raise ValueError("Input string must be a valid integer.")
# Split the string into year, month, day, hour, minute, second, microsecond
parts = s.split('-')
if len(parts) != 4:
raise ValueError("Input string must contain exactly four parts: year, month, day, hour, minute, second, microsecond.")
# Extract year, month, day, hour, minute, second
year = int(parts[0])
month = int(parts[1])
day = int(parts[2])
hour = int(parts[3])
minute = int(parts[4])
second = int(parts[5])
microsecond = int(parts[6])
# Convert to UTC offset
utc_offset_minutes = int(seconds) / 1000
# Return the tuple
return (year, month, day, hour, minute, second, microsecond, utc_offset_minutes)
# Pytest test cases
def test_parse_iso8601():
assert parse_iso8601("2026-10-12T14:03:07.250+02:00") == (2026, 10, 12, 14, 3, 7, 250, 0.000)
assert parse_iso8601("2026-10-13T00:00:00.000+02:00") == (2026, 10, 13, 00, 00, 0, 2.000)
assert parse_iso8601("invalid-format") == ValueError
assert parse_iso8601("2026-10-12T14:03:02.000+02:00") is None
assert parse_iso8601("2026.10.12.14.03.07.250") == (2026, 10, 12, 14, 3, 7, 250)
```
These test cases cover various scenarios, including valid and invalid inputs, to ensure the function behaves as expected.
r6 · differs from token 135 · 851 tokens
…th, day, hour, minute, second, microsecond, utc_offset_minutes).
Args:
s (str): The ISO 8601 timestamp string.
Returns:
tuple: A tuple containing the year, month, day, hour, minute, second, microsecond, and utc_offset_minutes.
Raises:
ValueError: If the input string does not match the expected format.
"""
# Validate input
if not s.isdigit() or not s.startswith('t'):
raise ValueError("Input must be a valid ISO 8601 timestamp string.")
# Split the string into components
year, month, day, hour, minute, second, microsecond, utc_offset_minutes = s.split('t')
# Validate each component
if not (isinstance(year, int) and year > 0) or not (isinstance(month, str) and month not in ['january', 'february', 'march', 'apr', 'may', 'jun', 'jul', 'aug', 'sep']) or not (isinstance(day, int) and day > 0) or not (isinstance(hour, int) and hour > 0) or not (isinstance(minute, int) and minute > 0) or not (isinstance(second, int) and second > 0) or not (isinstance(microsecond, int) and microsecond > 0) or not (utc_offset_minutes < 0)):
raise ValueError("Invalid ISO 8601 timestamp format.")
# Return the parsed tuple
return (year, month, day, hour, minute, second, microsecond, utc_offset_minutes)
```
---
### 🧪 Pytest Test Cases
```python
import pytest
def test_parse_iso8601_valid():
assert parse_iso8601("2026-10-12T14:03:07.250+02:00") == (2026, 10, 12, 14, 3, 7, 250, 0, 2)
def test_parse_iso8601_malformed():
assert parse_iso8601("2026-10-12T14:03") == (2026, 10, 12, 14, 3, 7, 250, 0)
def test_parse_iso8601_invalid_format():
assert parse_iso8601("invalid") == (None, None, None, None, None, None, 0)
def test_parse_iso8601_utc_offset_minutes():
assert parse_iso8601("2026-10-12T14:03:00+02:00") == (2026, 10, 12, 14, 3, 7, 2)
def test_parse_iso8601_empty():
assert parse_iso8601("") == (None, None, None, None, None, 0)
def test_parse_iso8601_none():
with pytest.raises(ValueError):
parse_iso8601("none")
```
---
### 📌 Notes
- The function assumes the input string is a valid ISO 8601 timestamp.
- The `utc_offset_minutes` is always non-negative.
- The `pytest` tests cover valid, malformed, and edge cases.
r8 · differs from token 50 · 710 tokens
…parse_iso8601(s: str)` that parses an ISO 8601 timestamp into a tuple without using the `datetime` module. It includes validation and a few pytest test cases.
```python
def parse_iso8601(s: str) -> tuple:
"""
Parses an ISO 8601 timestamp string into a tuple (year, month, day, hour, minute, second, microsecond, utc_offset_minutes).
Args:
s (str): The ISO 8601 timestamp string.
Returns:
tuple: A tuple containing the parsed year, month, day, hour, minute, second, microsecond, and utc_offset_minutes.
Raises:
ValueError: If the input string is malformed.
"""
# Validate input
if not s.isdigit():
raise ValueError("Input string must be a valid integer.")
# Split the string into year, month, day, hour, minute, second, microsecond
parts = s.split('-')
if len(parts) != 4:
raise ValueError("Input string must contain exactly four parts: year, month, day, hour, minute, second, microsecond.")
# Extract year, month, day, hour, minute, second
year = int(parts[0])
month = int(parts[1])
day = int(parts[2])
hour = int(parts[3])
minute = int(parts[4])
second = int(parts[5])
microsecond = int(parts[6])
# Convert to UTC offset
utc_offset_minutes = int(seconds) / 1000
return (year, month, day, hour, minute, second, microsecond, utc_offset_minutes)
# Pytest test cases
def test_parse_iso8601():
assert parse_iso8601("2026-10-12T14:03:07.250+02:00") == (2026, 10, 12, 14, 3, 7, 250, 0.000)
assert parse_iso8601("2026-10-12") == (2026, "10", "12", "00", "03", "07", "250")
assert parse_iso8601("2026-10-13T14:03:08.000+02:00") == (2026, "13", "12", "00", "03", "08", "000")
assert parse_iso8601("invalid-format") == ValueError
assert parse_iso8601("2026-10-12T14:03:00") == ValueError
assert parse_iso8601("2026.10.12.00") == ValueError
print("All tests passed.")
```
This function first validates the input string to ensure it's a valid integer. It then splits the string into parts, checks for the correct number of parts, and extracts the year, month, day, hour, minute, second, microsecond. Finally, it converts the seconds to microseconds and calculates the UTC offset. The test cases cover various scenarios, including valid and malformed inputs.
r9 · differs from token 50 · 882 tokens
…parse_iso8601(s: str)` that parses an ISO 8601 timestamp into a tuple without using the `datetime` module. It includes validation and a few pytest test cases.
```python
def parse_iso8601(s: str) -> tuple:
"""
Parses an ISO 8601 timestamp string into a tuple (year, month, day, hour, minute, second, microsecond, utc_offset_minutes).
Args:
s (str): The ISO 8601 timestamp string.
Returns:
tuple: A tuple containing the parsed year, month, day, hour, minute, second, microsecond, and utc_offset_minutes.
Raises:
ValueError: If the input string is malformed.
"""
# Validate input
if not s.isdigit():
raise ValueError("Input string must be a valid integer.")
# Split the string into year, month, day, hour, minute, second, microsecond
parts = s.split('-')
if len(parts) != 4:
raise ValueError("Input string must contain exactly four parts: year, month, day, hour, minute, second, microsecond.")
# Extract year, month, day, hour, minute, second
year = int(parts[0])
month = int(parts[1])
day = int(parts[2])
hour = int(parts[3])
minute = int(parts[4])
second = int(parts[5])
microsecond = int(parts[6])
# Convert to UTC offset
utc_offset_minutes = int(seconds) / 1000
return (year, month, day, hour, minute, second, microsecond, utc_offset_minutes)
# Pytest test cases
def test_parse_iso8601():
# Test valid input
assert parse_iso8601("2026-10-12T14:03:07.250+02:00") == (2026, 10, 12, 14, 3, 7, 250, 0)
# Test malformed input
try:
parse_iso8601("2026-10-12T14:03:")
except ValueError as e:
assert str(e) == "Input string must be a valid integer."
# Test missing year
try:
parse_iso8601("2026-10-12")
except ValueError as e:
assert str(e) == "Input string must contain exactly four parts."
# Test missing month
try:
parse_iso8601("2026-10-12T14:03:")
except ValueError as e:
assert str(e) == "Input string must contain exactly four parts."
# Test missing hour
try:
parse_iso8601("2026-10-12T14:03:00")
except ValueError as e:
assert str(e) == "Input string must contain exactly four parts."
# Test missing minute
try:
parse_iso8601("2026-10-12T14:03:00:00")
except ValueError as e:
assert str(e) == "Input string must contain exactly four parts."
# Test missing second
try:
parse_iso8601("2026-10-12T14:03:00:00:00")
except ValueError as e:
assert str(e) == "Input string must contain exactly four parts."
```
This function first validates the input string to ensure it's a valid integer. It then splits the string into parts, checks for the correct number of parts, and extracts the year, month, day, hour, minute, second, microsecond, and utc_offset_minutes. Finally, it converts the extracted values to UTC offset and returns the tuple. The pytest test cases cover various scenarios, including valid input, malformed input, missing parts, and missing values.
