Run Detail
completedqwen3.5-9b30 answersRecorded for this video
Provider
openrouter
Challenge Version
v1.0
Turns
30
Duration
532.4s
Total Tokens
94,164
Input Tokens
3,990
Output Tokens
90,174
Reasoning Tokens
84,307
Reasoning Effort
default
Cached Input Tokens
1,600
Est. Cost
$0.0212
Started
11/4/2026, 10:05:19 PM
OR Provider
DeepInfra
Finish Reason
length
Generation ID
gen-1793830079-k5aAGrOtCL0teYLrla0g
Turns (30)
Turn #1Raw score: 1
88 in49 out64 cached137 total2.0s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write is_leap(year: int) -> bool to return whether year is a leap year in the Gregorian calendar.
assistant
def is_leap(year: int) -> bool:
return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
Turn #2Raw score: 1
88 in49 out64 cached137 total2.2s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write is_leap(year: int) -> bool to return whether year is a leap year in the Gregorian calendar.
assistant
def is_leap(year: int) -> bool:
return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
Turn #3Raw score: 1
88 in49 out137 total1.3s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write is_leap(year: int) -> bool to return whether year is a leap year in the Gregorian calendar.
assistant
def is_leap(year: int) -> bool:
return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
Turn #4Raw score: 1
122 in5,178 out5,064 reasoning5,300 total43.1s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write rle(s: str) -> str to perform run-length encoding on s. Replace each run of consecutive identical characters with that character followed by the run length. rle("aaabcc") returns "a3b1c2" and rle("") returns "".
assistant
def rle(s: str) -> str:
if not s:
return ""
result = []
current_char = s[0]
count = 1
for char in s[1:]:
if char == current_char:
count += 1
else:
result.append(current_char + str(count))
current_char = char
count = 1
result.append(current_char + str(count))
return "".join(result)
Turn #5Raw score: 1
122 in526 out414 reasoning64 cached648 total5.0s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write rle(s: str) -> str to perform run-length encoding on s. Replace each run of consecutive identical characters with that character followed by the run length. rle("aaabcc") returns "a3b1c2" and rle("") returns "".
assistant
def rle(s: str) -> str:
if not s:
return ""
result = []
count = 1
for i in range(1, len(s)):
if s[i] == s[i - 1]:
count += 1
else:
result.append(s[i - 1] + str(count))
count = 1
result.append(s[-1] + str(count))
return "".join(result)
Turn #6Raw score: 1
122 in4,069 out3,947 reasoning64 cached4,191 total34.2s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write rle(s: str) -> str to perform run-length encoding on s. Replace each run of consecutive identical characters with that character followed by the run length. rle("aaabcc") returns "a3b1c2" and rle("") returns "".
assistant
def rle(s: str) -> str:
if not s:
return ""
result = []
current_char = s[0]
count = 1
for i in range(1, len(s)):
if s[i] == current_char:
count += 1
else:
result.append(f"{current_char}{count}")
current_char = s[i]
count = 1
result.append(f"{current_char}{count}")
return "".join(result)
Turn #7Raw score: 1
117 in4,497 out4,404 reasoning4,614 total37.5s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write chunks(items, n: int) -> list[list]. items is an iterable, which may be a generator. Return consecutive lists of n elements, where the last list may be shorter. Raise ValueError when n is less than 1.
assistant
from itertools import islice
def chunks(items, n: int) -> list[list]:
if n < 1:
raise ValueError("n must be at least 1")
it = iter(items)
result = []
while True:
chunk = list(islice(it, n))
if not chunk:
break
result.append(chunk)
return result
Turn #8Raw score: 1
117 in708 out599 reasoning64 cached825 total7.1s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write chunks(items, n: int) -> list[list]. items is an iterable, which may be a generator. Return consecutive lists of n elements, where the last list may be shorter. Raise ValueError when n is less than 1.
assistant
def chunks(items, n: int) -> list[list]:
if n < 1:
raise ValueError("n must be at least 1")
result = []
current_chunk = []
for item in items:
current_chunk.append(item)
if len(current_chunk) == n:
result.append(current_chunk)
current_chunk = []
if current_chunk:
result.append(current_chunk)
return result
Turn #9Raw score: 1
117 in3,401 out3,305 reasoning3,518 total37.8s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write chunks(items, n: int) -> list[list]. items is an iterable, which may be a generator. Return consecutive lists of n elements, where the last list may be shorter. Raise ValueError when n is less than 1.
assistant
from itertools import islice
def chunks(items, n: int) -> list[list]:
if n < 1:
raise ValueError("n must be at least 1")
iterator = iter(items)
result = []
while True:
chunk = list(islice(iterator, n))
if not chunk:
break
result.append(chunk)
return result
Turn #10Raw score: 0
155 in1,649 out1,275 reasoning1,804 total9.9s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write round_half_up(value: str, digits: int) -> str. The string value represents a decimal number. Round it to digits decimal places, rounding exact ties away from zero based on the exact value written in value. Return a string with exactly digits decimal places, and omit the decimal point when digits is 0. round_half_up("2.675", 2) returns "2.68".
assistant
def round_half_up(value: str, digits: int) -> str:
if '.' in value:
integer_part, fractional_part = value.split('.')
else:
integer_part = value
fractional_part = ''
# Normalize fractional part by removing trailing zeros
fractional_part = fractional_part.rstrip('0')
# If no fractional part or digits is 0, no rounding needed
if digits == 0 or not fractional_part:
return str(int(integer_part))
# Determine rounding digit position
if len(fractional_part) <= digits:
# Pad with zeros
fractional_part += '0' * (digits - len(fractional_part))
round_digit = int(fractional_part[digits])
remaining = ''
else:
round_digit = int(fractional_part[digits])
remaining = fractional_part[digits + 1:]
# Round up if digit >= 5 or exact tie (5 followed by zeros)
need_round_up = round_digit >= 5 or (round_digit == 5 and remaining == '')
# If rounding up, add 1 to the integer part
integer_val = int(integer_part)
if need_round_up and integer_val >= 0:
integer_val += 1
elif need_round_up and integer_val < 0:
integer_val -= 1
# Build the result
if digits == 0:
return str(integer_val)
# Format fractional part with exactly 'digits' decimal places
fractional_part = fractional_part.ljust(digits, '0')
return f"{integer_val}.{fractional_part}"
Turn #11Raw score: 0
155 in1,189 out880 reasoning128 cached1,344 total7.0s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write round_half_up(value: str, digits: int) -> str. The string value represents a decimal number. Round it to digits decimal places, rounding exact ties away from zero based on the exact value written in value. Return a string with exactly digits decimal places, and omit the decimal point when digits is 0. round_half_up("2.675", 2) returns "2.68".
assistant
def round_half_up(value: str, digits: int) -> str:
sign = 1
if value[0] == '-':
sign = -1
value = value[1:]
if '.' not in value:
int_part, frac_part = value, ''
else:
int_part, frac_part = value.split('.', 1)
# Pad or truncate fractional part to match digits
frac_part = frac_part.ljust(digits, '0')[:digits]
# Determine rounding: look at digit at position digits
round_digit = int(frac_part[-1]) if frac_part else 0
remaining = frac_part[:-1] if frac_part else ''
# Round up if round_digit >= 5
carry = 1 if round_digit >= 5 else 0
carry_str = '1' if carry else '0'
# Add carry to last digit of integer part
int_val = int(int_part)
int_val += carry
int_part = str(int_val)
# Build result
if digits == 0:
return str(sign * int_val)
else:
# Reconstruct fractional part with remaining digits
frac_result = remaining + ('0' * (digits - len(remaining)))
return f"{sign * int_val}.{frac_result}"
Turn #12Raw score: 1
155 in1,075 out961 reasoning128 cached1,230 total6.2s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write round_half_up(value: str, digits: int) -> str. The string value represents a decimal number. Round it to digits decimal places, rounding exact ties away from zero based on the exact value written in value. Return a string with exactly digits decimal places, and omit the decimal point when digits is 0. round_half_up("2.675", 2) returns "2.68".
assistant
from decimal import Decimal, ROUND_HALF_UP
def round_half_up(value: str, digits: int) -> str:
d = Decimal(value)
if digits == 0:
rounded = d.quantize(Decimal('1'), rounding=ROUND_HALF_UP)
return str(int(rounded))
quantize_str = '0.' + '0' * digits
rounded = d.quantize(Decimal(quantize_str), rounding=ROUND_HALF_UP)
return str(rounded)
Turn #13Raw score: 0
150 in8,000 out8,000 reasoning8,150 total46.0s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write parse_kv(line: str) -> dict[str, str]. The string line contains key=value pairs separated by one or more spaces. A value may be enclosed in double quotes; if so, it may contain spaces and =, and the quotes are not included in the parsed value. A value may be empty, as in c=. If a key repeats, use the last value. Return {} for an empty line.
Turn #14Raw score: 0
150 in972 out827 reasoning128 cached1,122 total5.5s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write parse_kv(line: str) -> dict[str, str]. The string line contains key=value pairs separated by one or more spaces. A value may be enclosed in double quotes; if so, it may contain spaces and =, and the quotes are not included in the parsed value. A value may be empty, as in c=. If a key repeats, use the last value. Return {} for an empty line.
assistant
def parse_kv(line: str) -> dict[str, str]:
if not line.strip():
return {}
result = {}
parts = line.split()
for part in parts:
if '=' in part:
eq_pos = part.index('=')
key = part[:eq_pos]
value = part[eq_pos + 1:]
if value.startswith('"') and value.endswith('"') and len(value) >= 2:
value = value[1:-1]
result[key] = value
else:
result[part] = ''
return result
Turn #15Raw score: 0
150 in8,000 out8,000 reasoning128 cached8,150 total45.9s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write parse_kv(line: str) -> dict[str, str]. The string line contains key=value pairs separated by one or more spaces. A value may be enclosed in double quotes; if so, it may contain spaces and =, and the quotes are not included in the parsed value. A value may be empty, as in c=. If a key repeats, use the last value. Return {} for an empty line.
Turn #16Raw score: 0
136 in795 out645 reasoning931 total4.6s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write merge_intervals(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]. The input intervals may be in any order. Merge intervals that overlap or touch, so (1, 2) and (2, 3) become (1, 3). Return the merged intervals as tuples sorted by start, and leave the input list unchanged.
assistant
def merge_intervals(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]:
if not intervals:
return []
sorted_intervals = sorted(intervals, key=lambda x: x[0])
merged = []
current_start, current_end = sorted_intervals[0]
for start, end in sorted_intervals[1:]:
if end >= start:
current_end = max(current_end, end)
else:
merged.append((current_start, current_end))
current_start, current_end = start, end
merged.append((current_start, current_end))
return merged
Turn #17Raw score: 1
136 in5,244 out5,097 reasoning128 cached5,380 total30.0s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write merge_intervals(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]. The input intervals may be in any order. Merge intervals that overlap or touch, so (1, 2) and (2, 3) become (1, 3). Return the merged intervals as tuples sorted by start, and leave the input list unchanged.
assistant
def merge_intervals(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]:
if not intervals:
return []
sorted_intervals = sorted(intervals, key=lambda x: x[0])
merged = []
current_start, current_end = sorted_intervals[0]
for start, end in sorted_intervals[1:]:
if start <= current_end:
current_end = max(current_end, end)
else:
merged.append((current_start, current_end))
current_start, current_end = start, end
merged.append((current_start, current_end))
return merged
Turn #18Raw score: 1
136 in864 out665 reasoning128 cached1,000 total5.2s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write merge_intervals(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]. The input intervals may be in any order. Merge intervals that overlap or touch, so (1, 2) and (2, 3) become (1, 3). Return the merged intervals as tuples sorted by start, and leave the input list unchanged.
assistant
def merge_intervals(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]:
if not intervals:
return []
# Sort intervals by start time (creates a copy, input remains unchanged)
sorted_intervals = sorted(intervals, key=lambda x: x[0])
merged = []
current_start, current_end = sorted_intervals[0]
for start, end in sorted_intervals[1:]:
if start <= current_end:
# Intervals overlap or touch, extend the current interval
current_end = max(current_end, end)
else:
# No overlap, save the current interval and start a new one
merged.append((current_start, current_end))
current_start, current_end = start, end
# Append the final interval
merged.append((current_start, current_end))
return merged
Turn #19Raw score: 1
112 in1,238 out1,195 reasoning1,350 total80.3s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write add_months(d: datetime.date, months: int) -> datetime.date to add months calendar months to d. months may be negative. If the day does not exist in the target month, use the last day of that month.
assistant
from datetime import date
import calendar
def add_months(d: date, months: int) -> date:
year = d.year
month = d.month
month += months
while month > 12:
month -= 12
year += 1
while month < 1:
month += 12
year -= 1
last_day = calendar.monthrange(year, month)[1]
new_day = min(d.day, last_day)
return date(year, month, new_day)
Turn #20Raw score: 1
112 in707 out569 reasoning819 total19.8s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write add_months(d: datetime.date, months: int) -> datetime.date to add months calendar months to d. months may be negative. If the day does not exist in the target month, use the last day of that month.
assistant
from datetime import date
import calendar
def add_months(d: date, months: int) -> date:
year = d.year
month = d.month + months
while month > 12:
month -= 12
year += 1
while month <= 0:
month += 12
year -= 1
try:
return date(year, month, d.day)
except ValueError:
last_day = calendar.monthrange(year, month)[1]
return date(year, month, last_day)
Turn #21Raw score: 0
112 in8,000 out5,853 reasoning8,112 total219.2s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write add_months(d: datetime.date, months: int) -> datetime.date to add months calendar months to d. months may be negative. If the day does not exist in the target month, use the last day of that month.
Turn #22Raw score: 1
136 in776 out661 reasoning912 total4.7s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write top_k_words(text: str, k: int) -> list[tuple[str, int]]. A word is a maximal sequence of ASCII letters and apostrophes. Words compare case-insensitively and are returned in lowercase. Return the k most frequent words as (word, count) tuples, sorted by highest count first, breaking ties alphabetically by word.
assistant
import re
def top_k_words(text: str, k: int) -> list[tuple[str, int]]:
words = re.findall(r"[A-Za-z']+", text)
counts = {}
for word in words:
word_lower = word.lower()
counts[word_lower] = counts.get(word_lower, 0) + 1
sorted_words = sorted(counts.items(), key=lambda x: (-x[1], x[0]))
return sorted_words[:k]
Turn #23Raw score: 1
136 in5,703 out5,615 reasoning128 cached5,839 total32.7s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write top_k_words(text: str, k: int) -> list[tuple[str, int]]. A word is a maximal sequence of ASCII letters and apostrophes. Words compare case-insensitively and are returned in lowercase. Return the k most frequent words as (word, count) tuples, sorted by highest count first, breaking ties alphabetically by word.
assistant
import re
from collections import Counter
def top_k_words(text: str, k: int) -> list[tuple[str, int]]:
words = re.findall(r"[A-Za-z']+", text)
counts = Counter(word.lower() for word in words)
return sorted(counts.items(), key=lambda x: (-x[1], x[0]))[:k]
Turn #24Raw score: 1
136 in6,851 out6,763 reasoning128 cached6,987 total39.5s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write top_k_words(text: str, k: int) -> list[tuple[str, int]]. A word is a maximal sequence of ASCII letters and apostrophes. Words compare case-insensitively and are returned in lowercase. Return the k most frequent words as (word, count) tuples, sorted by highest count first, breaking ties alphabetically by word.
assistant
import re
from collections import Counter
def top_k_words(text: str, k: int) -> list[tuple[str, int]]:
words = re.findall(r"[A-Za-z']+", text)
counts = Counter(word.lower() for word in words)
return sorted(counts.items(), key=lambda x: (-x[1], x[0]))[:k]
Turn #25Raw score: 0
172 in8,000 out8,000 reasoning8,172 total81.5s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write flatten(obj: dict, sep: str = ".") -> dict. Flatten nested dicts and lists into a single level, joining keys with sep and using list indices as keys. Keep an empty dict or empty list as the value at its key. flatten({"a": {"b": 1}, "c": [{"d": 2}, 3], "e": {}}) returns {"a.b": 1, "c.0.d": 2, "c.1": 3, "e": {}}.
Turn #26Raw score: 0
172 in866 out704 reasoning128 cached1,038 total9.8s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write flatten(obj: dict, sep: str = ".") -> dict. Flatten nested dicts and lists into a single level, joining keys with sep and using list indices as keys. Keep an empty dict or empty list as the value at its key. flatten({"a": {"b": 1}, "c": [{"d": 2}, 3], "e": {}}) returns {"a.b": 1, "c.0.d": 2, "c.1": 3, "e": {}}.
assistant
def flatten(obj: dict, sep: str = ".") -> dict:
result: dict = {}
def _flatten(current_obj: dict, prefix: str):
if isinstance(current_obj, dict):
for key, value in current_obj.items():
new_prefix = f"{prefix}{sep}{key}" if prefix else key
_flatten(value, new_prefix)
elif isinstance(current_obj, list):
for index, item in enumerate(current_obj):
new_prefix = f"{prefix}{sep}{index}" if prefix else str(index)
_flatten(item, new_prefix)
else:
result[prefix] = current_obj
_flatten(obj, "")
return result
Turn #27Raw score: 0
172 in1,816 out1,612 reasoning128 cached1,988 total18.8s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write flatten(obj: dict, sep: str = ".") -> dict. Flatten nested dicts and lists into a single level, joining keys with sep and using list indices as keys. Keep an empty dict or empty list as the value at its key. flatten({"a": {"b": 1}, "c": [{"d": 2}, 3], "e": {}}) returns {"a.b": 1, "c.0.d": 2, "c.1": 3, "e": {}}.
assistant
def flatten(obj: dict, sep: str = ".") -> dict:
result = {}
def _flatten(current_obj: dict, prefix: str = ""):
for key, value in current_obj.items():
new_key = f"{prefix}{sep}{key}" if prefix else key
if isinstance(value, dict):
if value:
_flatten(value, new_key)
else:
result[new_key] = {}
elif isinstance(value, list):
if value:
for i, item in enumerate(value):
if isinstance(item, dict):
_flatten(item, f"{new_key}{sep}{i}")
else:
result[f"{new_key}{sep}{i}"] = item
else:
result[new_key] = []
else:
result[new_key] = value
_flatten(obj)
return result
Turn #28Raw score: 1
142 in756 out744 reasoning898 total59.5s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write lru(maxsize: int), a decorator factory that caches a function's results by its positional arguments without using functools.lru_cache or functools.cache. It stores at most maxsize results. When the cache is full, evict the least recently used result. A cache hit counts as a use. The decorated function must preserve its original __name__.
assistant
from collections import OrderedDict
def lru(maxsize: int):
def decorator(func):
cache = OrderedDict()
cache_capacity = maxsize
def wrapper(*args, **kwargs):
cache_key = args
if cache_key in cache:
cache.move_to_end(cache_key)
return cache[cache_key]
result = func(*args, **kwargs)
cache[cache_key] = result
if len(cache) > cache_capacity:
cache.popitem(last=False)
return result
wrapper.__name__ = func.__name__
return wrapper
return decorator
Turn #29Raw score: 0
142 in8,000 out7,502 reasoning8,142 total371.9s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write lru(maxsize: int), a decorator factory that caches a function's results by its positional arguments without using functools.lru_cache or functools.cache. It stores at most maxsize results. When the cache is full, evict the least recently used result. A cache hit counts as a use. The decorated function must preserve its original __name__.
Turn #30Raw score: 0
142 in1,147 out1,006 reasoning1,289 total30.0s
user
Write Python 3.13 code. Answer with one ```python code block that defines the function described below. Use only the standard library. Do not include explanations, examples, tests, input() calls, or print() calls.
Write lru(maxsize: int), a decorator factory that caches a function's results by its positional arguments without using functools.lru_cache or functools.cache. It stores at most maxsize results. When the cache is full, evict the least recently used result. A cache hit counts as a use. The decorated function must preserve its original __name__.
assistant
class LRUCache:
def __init__(self, maxsize):
self.maxsize = maxsize
self.cache = {}
self.order = [] # most recently used at the end
def get(self, key):
if key not in self.cache:
return None
self.order.remove(key)
self.order.append(key)
return self.cache[key]
def put(self, key, value):
if key in self.cache:
self.cache[key] = value
self.order.remove(key)
self.order.append(key)
else:
if len(self.cache) >= self.maxsize:
lru_key = self.order.pop(0)
del self.cache[lru_key]
self.cache[key] = value
self.order.append(key)
def lru(maxsize: int):
def decorator(func):
cache = LRUCache(maxsize)
def wrapper(*args, **kwargs):
key = args
if key in cache.cache:
cache.get(key)
else:
cache.put(key, None)
result = func(*args, **kwargs)
cache.put(key, result)
return result
wrapper.__name__ = func.__name__
return wrapper
return decorator