From d89186b47dc25c5ef5907c146edf3f792d50774b Mon Sep 17 00:00:00 2001 Message-ID: From: Nicolas Graves Date: Wed, 2 Apr 2025 17:29:45 +0200 Subject: [PATCH] Update to python 3.11 --- property_cached/__init__.py | 21 +++------- tests/test_async_cached_property.py | 3 +- tests/test_coroutine_cached_property.py | 51 ++++++++++--------------- 3 files changed, 27 insertions(+), 48 deletions(-) diff --git a/property_cached/__init__.py b/property_cached/__init__.py index 3353048..c033542 100644 --- a/property_cached/__init__.py +++ b/property_cached/__init__.py @@ -3,6 +3,7 @@ import functools import pkg_resources import threading import weakref +from inspect import iscoroutinefunction from time import time @@ -31,12 +32,12 @@ class cached_property(property): if obj is None: return self - if asyncio and asyncio.iscoroutinefunction(self.func): - return self._wrap_in_coroutine(obj) - value = self.cache.get(obj, self._sentinel) if value is self._sentinel: - value = self.cache[obj] = self.func(obj) + if iscoroutinefunction(self.func): + self.cache[obj] = value = asyncio.ensure_future(self.func(obj)) + else: + self.cache[obj] = value = self.func(obj) return value @@ -49,18 +50,6 @@ class cached_property(property): def __delete__(self, obj): del self.cache[obj] - def _wrap_in_coroutine(self, obj): - - @functools.wraps(obj) - @asyncio.coroutine - def wrapper(): - value = self.cache.get(obj, self._sentinel) - if value is self._sentinel: - self.cache[obj] = value = asyncio.ensure_future(self.func(obj)) - return value - - return wrapper() - class threaded_cached_property(cached_property): """ diff --git a/tests/test_async_cached_property.py b/tests/test_async_cached_property.py index 1af139d..32b3410 100644 --- a/tests/test_async_cached_property.py +++ b/tests/test_async_cached_property.py @@ -9,8 +9,7 @@ import property_cached as cached_property def unittest_run_loop(f): def wrapper(*args, **kwargs): - coro = asyncio.coroutine(f) - future = coro(*args, **kwargs) + future = f(*args, **kwargs) loop = asyncio.get_event_loop() loop.run_until_complete(future) diff --git a/tests/test_coroutine_cached_property.py b/tests/test_coroutine_cached_property.py index 40e443b..5864301 100644 --- a/tests/test_coroutine_cached_property.py +++ b/tests/test_coroutine_cached_property.py @@ -14,8 +14,7 @@ import property_cached as cached_property def unittest_run_loop(f): def wrapper(*args, **kwargs): - coro = asyncio.coroutine(f) - future = coro(*args, **kwargs) + future = f(*args, **kwargs) loop = asyncio.get_event_loop() loop.run_until_complete(future) @@ -33,14 +32,12 @@ def CheckFactory(cached_property_decorator): self.control_total = 0 self.cached_total = 0 - @asyncio.coroutine - def add_control(self): + async def add_control(self): self.control_total += 1 return self.control_total @cached_property_decorator - @asyncio.coroutine - def add_cached(self): + async def add_cached(self): self.cached_total += 1 return self.cached_total @@ -52,74 +49,68 @@ class TestCachedProperty(unittest.TestCase): cached_property_factory = cached_property.cached_property - @asyncio.coroutine - def assert_control(self, check, expected): + async def assert_control(self, check, expected): """ Assert that both `add_control` and 'control_total` equal `expected` """ - value = yield from check.add_control() + value = await check.add_control() self.assertEqual(value, expected) self.assertEqual(check.control_total, expected) - @asyncio.coroutine - def assert_cached(self, check, expected): + async def assert_cached(self, check, expected): """ Assert that both `add_cached` and 'cached_total` equal `expected` """ print("assert_cached", check.add_cached) - value = yield from check.add_cached + value = await check.add_cached self.assertEqual(value, expected) self.assertEqual(check.cached_total, expected) @unittest_run_loop - @asyncio.coroutine - def test_cached_property(self): + async def test_cached_property(self): Check = CheckFactory(self.cached_property_factory) check = Check() # The control shows that we can continue to add 1 - yield from self.assert_control(check, 1) - yield from self.assert_control(check, 2) + await self.assert_control(check, 1) + await self.assert_control(check, 2) # The cached version demonstrates how nothing is added after the first - yield from self.assert_cached(check, 1) - yield from self.assert_cached(check, 1) + await self.assert_cached(check, 1) + await self.assert_cached(check, 1) # The cache does not expire with freeze_time("9999-01-01"): - yield from self.assert_cached(check, 1) + await self.assert_cached(check, 1) # Typically descriptors return themselves if accessed though the class # rather than through an instance. self.assertTrue(isinstance(Check.add_cached, self.cached_property_factory)) @unittest_run_loop - @asyncio.coroutine - def test_reset_cached_property(self): + async def test_reset_cached_property(self): Check = CheckFactory(self.cached_property_factory) check = Check() # Run standard cache assertion - yield from self.assert_cached(check, 1) - yield from self.assert_cached(check, 1) + await self.assert_cached(check, 1) + await self.assert_cached(check, 1) # Clear the cache del check.add_cached # Value is cached again after the next access - yield from self.assert_cached(check, 2) - yield from self.assert_cached(check, 2) + await self.assert_cached(check, 2) + await self.assert_cached(check, 2) @unittest_run_loop - @asyncio.coroutine - def test_none_cached_property(self): + async def test_none_cached_property(self): class Check(object): def __init__(self): self.cached_total = None @self.cached_property_factory - @asyncio.coroutine - def add_cached(self): + async def add_cached(self): return self.cached_total - yield from self.assert_cached(Check(), None) + await self.assert_cached(Check(), None) -- 2.49.0