Skip to content

Commit aee87a5

Browse files
andrewleap-optimizelyandrewleap-optimizely
authored
feat: add lru cache (#395)
* add lru cache
1 parent 9912671 commit aee87a5

File tree

3 files changed

+267
-0
lines changed

3 files changed

+267
-0
lines changed

‎optimizely/odp/__init__.py

+12
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
# Copyright 2022, Optimizely
2+
# Licensed under the Apache License, Version 2.0 (the "License");
3+
# you may not use this file except in compliance with the License.
4+
# You may obtain a copy of the License at
5+
#
6+
# http://www.apache.org/licenses/LICENSE-2.0
7+
#
8+
# Unless required by applicable law or agreed to in writing, software
9+
# distributed under the License is distributed on an "AS IS" BASIS,
10+
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11+
# See the License for the specific language governing permissions and
12+
# limitations under the License.

‎optimizely/odp/lru_cache.py

+120
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,120 @@
1+
# Copyright 2022, Optimizely
2+
# Licensed under the Apache License, Version 2.0 (the "License");
3+
# you may not use this file except in compliance with the License.
4+
# You may obtain a copy of the License at
5+
#
6+
# http://www.apache.org/licenses/LICENSE-2.0
7+
#
8+
# Unless required by applicable law or agreed to in writing, software
9+
# distributed under the License is distributed on an "AS IS" BASIS,
10+
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11+
# See the License for the specific language governing permissions and
12+
# limitations under the License.
13+
14+
from __future__ import annotations
15+
from dataclasses import dataclass, field
16+
import threading
17+
from time import time
18+
from collections import OrderedDict
19+
from typing import Optional, Generic, TypeVar, Hashable
20+
from sys import version_info
21+
22+
if version_info < (3, 8):
23+
from typing_extensions import Protocol
24+
else:
25+
from typing import Protocol # type: ignore
26+
27+
# generic type definitions for LRUCache parameters
28+
K = TypeVar('K', bound=Hashable, contravariant=True)
29+
V = TypeVar('V')
30+
31+
32+
class LRUCache(Generic[K, V]):
33+
"""Least Recently Used cache that invalidates entries older than the timeout."""
34+
35+
def __init__(self, capacity: int, timeout_in_secs: int):
36+
self.lock = threading.Lock()
37+
self.map: OrderedDict[K, CacheElement[V]] = OrderedDict()
38+
self.capacity = capacity
39+
self.timeout = timeout_in_secs
40+
41+
def lookup(self, key: K) -> Optional[V]:
42+
"""Return the non-stale value associated with the provided key and move the
43+
element to the end of the cache. If the selected value is stale, remove it from
44+
the cache and clear the entire cache if stale.
45+
"""
46+
if self.capacity <= 0:
47+
return None
48+
49+
with self.lock:
50+
if key not in self.map:
51+
return None
52+
53+
self.map.move_to_end(key)
54+
element = self.map[key]
55+
56+
if element._is_stale(self.timeout):
57+
del self.map[key]
58+
return None
59+
60+
return element.value
61+
62+
def save(self, key: K, value: V) -> None:
63+
"""Insert and/or move the provided key/value pair to the most recent end of the cache.
64+
If the cache grows beyond the cache capacity, the least recently used element will be
65+
removed.
66+
"""
67+
if self.capacity <= 0:
68+
return
69+
70+
with self.lock:
71+
if key in self.map:
72+
self.map.move_to_end(key)
73+
74+
self.map[key] = CacheElement(value)
75+
76+
if len(self.map) > self.capacity:
77+
self.map.popitem(last=False)
78+
79+
def reset(self) -> None:
80+
""" Clear the cache."""
81+
if self.capacity <= 0:
82+
return
83+
with self.lock:
84+
self.map.clear()
85+
86+
def peek(self, key: K) -> Optional[V]:
87+
"""Returns the value associated with the provided key without updating the cache."""
88+
if self.capacity <= 0:
89+
return None
90+
with self.lock:
91+
element = self.map.get(key)
92+
return element.value if element is not None else None
93+
94+
95+
@dataclass
96+
class CacheElement(Generic[V]):
97+
"""Individual element for the LRUCache."""
98+
value: V
99+
timestamp: float = field(default_factory=time)
100+
101+
def _is_stale(self, timeout: float) -> bool:
102+
"""Returns True if the provided timeout has passed since the element's timestamp."""
103+
if timeout <= 0:
104+
return False
105+
return time() - self.timestamp >= timeout
106+
107+
108+
class OptimizelySegmentsCache(Protocol):
109+
"""Protocol for implementing custom cache."""
110+
def reset(self) -> None:
111+
""" Clear the cache."""
112+
...
113+
114+
def lookup(self, key: str) -> Optional[list[str]]:
115+
"""Return the value associated with the provided key."""
116+
...
117+
118+
def save(self, key: str, value: list[str]) -> None:
119+
"""Save the key/value pair in the cache."""
120+
...

‎tests/test_lru_cache.py

+135
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,135 @@
1+
# Copyright 2022, Optimizely
2+
# Licensed under the Apache License, Version 2.0 (the "License");
3+
# you may not use this file except in compliance with the License.
4+
# You may obtain a copy of the License at
5+
#
6+
# http:#www.apache.org/licenses/LICENSE-2.0
7+
#
8+
# Unless required by applicable law or agreed to in writing, software
9+
# distributed under the License is distributed on an "AS IS" BASIS,
10+
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11+
# See the License for the specific language governing permissions and
12+
# limitations under the License.
13+
14+
from __future__ import annotations
15+
import time
16+
from unittest import TestCase
17+
from optimizely.odp.lru_cache import LRUCache, OptimizelySegmentsCache
18+
19+
20+
class LRUCacheTest(TestCase):
21+
def test_min_config(self):
22+
cache = LRUCache(1000, 2000)
23+
self.assertEqual(1000, cache.capacity)
24+
self.assertEqual(2000, cache.timeout)
25+
26+
cache = LRUCache(0, 0)
27+
self.assertEqual(0, cache.capacity)
28+
self.assertEqual(0, cache.timeout)
29+
30+
def test_save_and_lookup(self):
31+
max_size = 2
32+
cache = LRUCache(max_size, 1000)
33+
34+
self.assertIsNone(cache.peek(1))
35+
cache.save(1, 100) # [1]
36+
cache.save(2, 200) # [1, 2]
37+
cache.save(3, 300) # [2, 3]
38+
self.assertIsNone(cache.peek(1))
39+
self.assertEqual(200, cache.peek(2))
40+
self.assertEqual(300, cache.peek(3))
41+
42+
cache.save(2, 201) # [3, 2]
43+
cache.save(1, 101) # [2, 1]
44+
self.assertEqual(101, cache.peek(1))
45+
self.assertEqual(201, cache.peek(2))
46+
self.assertIsNone(cache.peek(3))
47+
48+
self.assertIsNone(cache.lookup(3)) # [2, 1]
49+
self.assertEqual(201, cache.lookup(2)) # [1, 2]
50+
cache.save(3, 302) # [2, 3]
51+
self.assertIsNone(cache.peek(1))
52+
self.assertEqual(201, cache.peek(2))
53+
self.assertEqual(302, cache.peek(3))
54+
55+
self.assertEqual(302, cache.lookup(3)) # [2, 3]
56+
cache.save(1, 103) # [3, 1]
57+
self.assertEqual(103, cache.peek(1))
58+
self.assertIsNone(cache.peek(2))
59+
self.assertEqual(302, cache.peek(3))
60+
61+
self.assertEqual(len(cache.map), max_size)
62+
self.assertEqual(len(cache.map), cache.capacity)
63+
64+
def test_size_zero(self):
65+
cache = LRUCache(0, 1000)
66+
67+
self.assertIsNone(cache.lookup(1))
68+
cache.save(1, 100) # [1]
69+
self.assertIsNone(cache.lookup(1))
70+
71+
def test_size_less_than_zero(self):
72+
cache = LRUCache(-2, 1000)
73+
74+
self.assertIsNone(cache.lookup(1))
75+
cache.save(1, 100) # [1]
76+
self.assertIsNone(cache.lookup(1))
77+
78+
def test_timeout(self):
79+
max_timeout = .5
80+
81+
cache = LRUCache(1000, max_timeout)
82+
83+
cache.save(1, 100) # [1]
84+
cache.save(2, 200) # [1, 2]
85+
cache.save(3, 300) # [1, 2, 3]
86+
time.sleep(1.1) # wait to expire
87+
cache.save(4, 400) # [1, 2, 3, 4]
88+
cache.save(1, 101) # [2, 3, 4, 1]
89+
90+
self.assertEqual(101, cache.lookup(1)) # [4, 1]
91+
self.assertIsNone(cache.lookup(2))
92+
self.assertIsNone(cache.lookup(3))
93+
self.assertEqual(400, cache.lookup(4))
94+
95+
def test_timeout_zero(self):
96+
max_timeout = 0
97+
cache = LRUCache(1000, max_timeout)
98+
99+
cache.save(1, 100) # [1]
100+
cache.save(2, 200) # [1, 2]
101+
time.sleep(1) # wait to expire
102+
103+
self.assertEqual(100, cache.lookup(1), "should not expire when timeout is 0")
104+
self.assertEqual(200, cache.lookup(2))
105+
106+
def test_timeout_less_than_zero(self):
107+
max_timeout = -2
108+
cache = LRUCache(1000, max_timeout)
109+
110+
cache.save(1, 100) # [1]
111+
cache.save(2, 200) # [1, 2]
112+
time.sleep(1) # wait to expire
113+
114+
self.assertEqual(100, cache.lookup(1), "should not expire when timeout is less than 0")
115+
self.assertEqual(200, cache.lookup(2))
116+
117+
def test_reset(self):
118+
cache = LRUCache(1000, 600)
119+
cache.save('wow', 'great')
120+
cache.save('tow', 'freight')
121+
122+
self.assertEqual(cache.lookup('wow'), 'great')
123+
self.assertEqual(len(cache.map), 2)
124+
125+
cache.reset()
126+
127+
self.assertEqual(cache.lookup('wow'), None)
128+
self.assertEqual(len(cache.map), 0)
129+
130+
cache.save('cow', 'crate')
131+
self.assertEqual(cache.lookup('cow'), 'crate')
132+
133+
# type checker test
134+
# confirm that LRUCache matches OptimizelySegmentsCache protocol
135+
_: OptimizelySegmentsCache = LRUCache(0, 0)

0 commit comments

Comments
 (0)