diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml
index f6f3060..75454c8 100644
--- a/.github/workflows/python-package.yml
+++ b/.github/workflows/python-package.yml
@@ -8,26 +8,27 @@ on:
     branches: [ master ]
     paths-ignore:
       - '**.md'    
-      - '**.rst'    
   pull_request:
-    branches: [ master ]
     paths-ignore:
       - '**.md'    
-      - '**.rst'    
 
 jobs:
   run:
     runs-on: ${{ matrix.operating-system }}
     strategy:
       matrix:
-        # operating-system: [ubuntu-latest, windows-latest, macos-latest]
-        operating-system: [ubuntu-latest, windows-latest]
-        python-version: [3.5, 3.6, 3.7, 3.8]
+        operating-system: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: [3.8, 3.9, "3.10", "3.11", "3.12", "3.13"]
+        include:
+          - python-version: "pypy-3.9"
+            operating-system: ubuntu-latest
+          - python-version: "pypy-3.10"
+            operating-system: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index cd945af..2a68ff6 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -103,13 +103,16 @@ Before you submit a pull request, check that it meets these guidelines:
 1. The pull request should include tests.
 2. If the pull request adds functionality, the docs should be updated. Put
    your new functionality into a function with a docstring, and add the
-   feature to the list in README.rst.
-3. The pull request should work for Python 2.7, and 3.3, 3.4, 3.5, 3.6 and for PyPy. Check https://travis-ci.org/pydanny/cached-property/pull_requests and make sure that the tests pass for all supported Python versions.
+   feature to the list in README.md.
+3. The pull request should work for all Python versions defined as classifiers in `setup.py`.
+   Make sure that the [GitHub Action tests](https://github.com/pydanny/cached-property/actions) 
+   pass for all supported Python versions.
 
 ## Tips
 
 To run a subset of tests:
 
 ```bash
-$ python -m unittest tests.test_cached-property
+$ pytest tests/test_cached-property.py
+$ pytest tests/test_cached-property.py::TestCachedProperty
 ```
diff --git a/HISTORY.md b/HISTORY.md
index 2d6a4f4..3c9d034 100644
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -1,9 +1,9 @@
 # History
 
-## 2.0 (2020-09-??)
+## 2.0.0 (2024-??-??)
 
-* Remove formal support for Python 2.7
-* Convert RST to MD
+* Remove support for Python versions < 3.8
+* Add formal support for Python versions up to 3.13
 
 ## 1.5.2 (2020-09-21)
 
diff --git a/MANIFEST.in b/MANIFEST.in
index ae5ca21..152dfc2 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,12 +1,8 @@
-include AUTHORS.rst
-include CONTRIBUTING.rst
-include HISTORY.rst
+include AUTHORS.md
+include CONTRIBUTING.md
+include HISTORY.md
 include LICENSE
-include README.rst
+include README.md
 
 recursive-include tests *
-include conftest.py
 recursive-exclude * __pycache__
-recursive-exclude * *.py[co]
-
-recursive-include docs *.rst conftest.py Makefile make.bat
diff --git a/README.md b/README.md
index 51b887f..b47bc6a 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ Let's define a class with an expensive property. Every time you stay there the
 price goes up by $50!
 
 ```python
-class Monopoly(object):
+class Monopoly:
 
     def __init__(self):
         self.boardwalk_price = 500
@@ -101,7 +101,7 @@ unfortunately causes problems with the standard `cached_property`. In this case,
 ```python
 from cached_property import threaded_cached_property
 
-class Monopoly(object):
+class Monopoly:
 
     def __init__(self):
         self.boardwalk_price = 500
@@ -135,7 +135,7 @@ Now use it:
 >>> self.assertEqual(m.boardwalk, 550)
 ```
 
-## Working with async/await (Python 3.5+)
+## Working with async/await
 
 The cached property can be async, in which case you have to use await
 as usual to get the value. Because of the caching, the value is only
@@ -144,7 +144,7 @@ computed once and then cached:
 ```python
 from cached_property import cached_property
 
-class Monopoly(object):
+class Monopoly:
 
     def __init__(self):
         self.boardwalk_price = 500
@@ -214,7 +214,7 @@ is why they are broken out into seperate tools. See https://github.com/pydanny/c
 
 ## Credits
 
-* Pip, Django, Werkzueg, Bottle, Pyramid, and Zope for having their own implementations. This package originally used an implementation that matched the Bottle version.
+* Pip, Django, Werkzeug, Bottle, Pyramid, and Zope for having their own implementations. This package originally used an implementation that matched the Bottle version.
 * Reinout Van Rees for pointing out the `cached_property` decorator to me.
 * My awesome wife [@audreyfeldroy](https://github.com/audreyfeldroy) who created [`cookiecutter`](https://github.com/cookiecutter/cookiecutter), which meant rolling this out took me just 15 minutes.
 * @tinche for pointing out the threading issue and providing a solution.
diff --git a/cached_property.py b/cached_property.py
index 3135871..e4cdbae 100644
--- a/cached_property.py
+++ b/cached_property.py
@@ -1,21 +1,15 @@
-# -*- coding: utf-8 -*-
-
 __author__ = "Daniel Greenfeld"
 __email__ = "pydanny@gmail.com"
-__version__ = "1.5.2"
+__version__ = "2.0.0"
 __license__ = "BSD"
 
 from functools import wraps
 from time import time
 import threading
-
-try:
-    import asyncio
-except (ImportError, SyntaxError):
-    asyncio = None
+import asyncio
 
 
-class cached_property(object):
+class cached_property:
     """
     A property that is only computed once per instance and then replaces itself
     with an ordinary attribute. Deleting the attribute resets the property.
@@ -30,7 +24,7 @@ def __get__(self, obj, cls):
         if obj is None:
             return self
 
-        if asyncio and asyncio.iscoroutinefunction(self.func):
+        if asyncio.iscoroutinefunction(self.func):
             return self._wrap_in_coroutine(obj)
 
         value = obj.__dict__[self.func.__name__] = self.func(obj)
@@ -38,7 +32,6 @@ def __get__(self, obj, cls):
 
     def _wrap_in_coroutine(self, obj):
         @wraps(obj)
-        @asyncio.coroutine
         def wrapper():
             future = asyncio.ensure_future(self.func(obj))
             obj.__dict__[self.func.__name__] = future
@@ -47,7 +40,7 @@ def wrapper():
         return wrapper()
 
 
-class threaded_cached_property(object):
+class threaded_cached_property:
     """
     A cached_property version for use in environments where multiple threads
     might concurrently try to access the property.
@@ -74,7 +67,7 @@ def __get__(self, obj, cls):
                 return obj_dict.setdefault(name, self.func(obj))
 
 
-class cached_property_with_ttl(object):
+class cached_property_with_ttl:
     """
     A property that is only computed once per instance and then replaces itself
     with an ordinary attribute. Setting the ttl to a number expresses how long
diff --git a/conftest.py b/conftest.py
deleted file mode 100644
index 0563f64..0000000
--- a/conftest.py
+++ /dev/null
@@ -1,20 +0,0 @@
-
-import sys
-
-# Whether "import asyncio" works
-has_asyncio = sys.version_info[0] == 3 and sys.version_info[1] >= 4
-
-# Whether the async and await keywords work
-has_async_await = sys.version_info[0] == 3 and sys.version_info[1] >= 5
-
-
-print("conftest.py", has_asyncio, has_async_await)
-
-
-collect_ignore = []
-
-if not has_asyncio:
-    collect_ignore.append("tests/test_coroutine_cached_property.py")
-
-if not has_async_await:
-    collect_ignore.append("tests/test_async_cached_property.py")
diff --git a/requirements.txt b/requirements.txt
index 2be3192..837806a 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,5 +1,5 @@
 # Testing and deployment packages.
-coverage==4.4.2
-pytest==3.8.2
-pytest-cov==2.6.0
-freezegun==0.3.10
\ No newline at end of file
+coverage==7.6.1
+pytest==8.3.3
+pytest-cov==5.0.0
+freezegun==1.5.1
\ No newline at end of file
diff --git a/setup.cfg b/setup.cfg
index 0a8df87..0bcaa1a 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,2 +1,2 @@
 [wheel]
-universal = 1
\ No newline at end of file
+universal = 0
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 8fc7658..4d08b9b 100755
--- a/setup.py
+++ b/setup.py
@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 
 import os
 import sys
@@ -53,12 +52,14 @@ def read(fname):
         "Intended Audience :: Developers",
         "License :: OSI Approved :: BSD License",
         "Natural Language :: English",
-        "Programming Language :: Python :: 2",
-        "Programming Language :: Python :: 2.7",
-        "Programming Language :: Python :: 3",     
-        "Programming Language :: Python :: 3.5",
-        "Programming Language :: Python :: 3.6",
-        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3",
         "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Programming Language :: Python :: Implementation :: CPython",
+        "Programming Language :: Python :: Implementation :: PyPy",
     ],
 )
diff --git a/tests/__init__.py b/tests/__init__.py
index 40a96af..e69de29 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -1 +0,0 @@
-# -*- coding: utf-8 -*-
diff --git a/tests/test_async_cached_property.py b/tests/test_async_cached_property.py
index 4ba84f3..e03ac82 100644
--- a/tests/test_async_cached_property.py
+++ b/tests/test_async_cached_property.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 import asyncio
 import time
 import unittest
@@ -7,23 +6,13 @@
 import cached_property
 
 
-def unittest_run_loop(f):
-    def wrapper(*args, **kwargs):
-        coro = asyncio.coroutine(f)
-        future = coro(*args, **kwargs)
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(future)
-
-    return wrapper
-
-
 def CheckFactory(cached_property_decorator, threadsafe=False):
     """
     Create dynamically a Check class whose add_cached method is decorated by
     the cached_property_decorator.
     """
 
-    class Check(object):
+    class Check:
         def __init__(self):
             self.control_total = 0
             self.cached_total = 0
@@ -63,7 +52,7 @@ def call_add_cached():
     return Check
 
 
-class TestCachedProperty(unittest.TestCase):
+class TestCachedProperty(unittest.IsolatedAsyncioTestCase):
     """Tests for cached_property"""
 
     cached_property_factory = cached_property.cached_property
@@ -72,18 +61,17 @@ async def assert_control(self, check, expected):
         """
         Assert that both `add_control` and 'control_total` equal `expected`
         """
-        self.assertEqual(await check.add_control(), expected)
-        self.assertEqual(check.control_total, expected)
+        self.assertEqual(expected, await check.add_control())
+        self.assertEqual(expected, check.control_total)
 
     async def assert_cached(self, check, expected):
         """
         Assert that both `add_cached` and 'cached_total` equal `expected`
         """
         print("assert_cached", check.add_cached)
-        self.assertEqual(await check.add_cached, expected)
-        self.assertEqual(check.cached_total, expected)
+        self.assertEqual(expected, await check.add_cached)
+        self.assertEqual(expected, check.cached_total)
 
-    @unittest_run_loop
     async def test_cached_property(self):
         Check = CheckFactory(self.cached_property_factory)
         check = Check()
@@ -104,7 +92,6 @@ async def test_cached_property(self):
         # rather than through an instance.
         self.assertTrue(isinstance(Check.add_cached, self.cached_property_factory))
 
-    @unittest_run_loop
     async def test_reset_cached_property(self):
         Check = CheckFactory(self.cached_property_factory)
         check = Check()
@@ -120,9 +107,8 @@ async def test_reset_cached_property(self):
         await self.assert_cached(check, 2)
         await self.assert_cached(check, 2)
 
-    @unittest_run_loop
     async def test_none_cached_property(self):
-        class Check(object):
+        class Check:
             def __init__(self):
                 self.cached_total = None
 
diff --git a/tests/test_cached_property.py b/tests/test_cached_property.py
index 5082416..75d8df9 100644
--- a/tests/test_cached_property.py
+++ b/tests/test_cached_property.py
@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 import time
 import unittest
 from threading import Lock, Thread
@@ -14,7 +12,7 @@ def CheckFactory(cached_property_decorator, threadsafe=False):
     the cached_property_decorator.
     """
 
-    class Check(object):
+    class Check:
         def __init__(self):
             self.control_total = 0
             self.cached_total = 0
@@ -40,7 +38,7 @@ def add_cached(self):
         def run_threads(self, num_threads):
             threads = []
             for _ in range(num_threads):
-                thread = Thread(target=lambda: self.add_cached)
+                thread = Thread(target=self.add_cached)
                 thread.start()
                 threads.append(thread)
             for thread in threads:
@@ -58,15 +56,15 @@ def assert_control(self, check, expected):
         """
         Assert that both `add_control` and 'control_total` equal `expected`
         """
-        self.assertEqual(check.add_control, expected)
-        self.assertEqual(check.control_total, expected)
+        self.assertEqual(expected, check.add_control)
+        self.assertEqual(expected, check.control_total)
 
     def assert_cached(self, check, expected):
         """
         Assert that both `add_cached` and 'cached_total` equal `expected`
         """
-        self.assertEqual(check.add_cached, expected)
-        self.assertEqual(check.cached_total, expected)
+        self.assertEqual(expected, check.add_cached)
+        self.assertEqual(expected, check.cached_total)
 
     def test_cached_property(self):
         Check = CheckFactory(self.cached_property_factory)
@@ -104,7 +102,7 @@ def test_reset_cached_property(self):
         self.assert_cached(check, 2)
 
     def test_none_cached_property(self):
-        class Check(object):
+        class Check:
             def __init__(self):
                 self.cached_total = None
 
@@ -118,30 +116,8 @@ def test_set_cached_property(self):
         Check = CheckFactory(self.cached_property_factory)
         check = Check()
         check.add_cached = "foo"
-        self.assertEqual(check.add_cached, "foo")
-        self.assertEqual(check.cached_total, 0)
-
-    def test_threads(self):
-        Check = CheckFactory(self.cached_property_factory, threadsafe=True)
-        check = Check()
-        num_threads = 5
-
-        # cached_property_with_ttl is *not* thread-safe!
-        check.run_threads(num_threads)
-        # This assertion hinges on the fact the system executing the test can
-        # spawn and start running num_threads threads within the sleep period
-        # (defined in the Check class as 1 second). If num_threads were to be
-        # massively increased (try 10000), the actual value returned would be
-        # between 1 and num_threads, depending on thread scheduling and
-        # preemption.
-        self.assert_cached(check, num_threads)
-        self.assert_cached(check, num_threads)
-
-        # The cache does not expire
-        with freeze_time("9999-01-01"):
-            check.run_threads(num_threads)
-            self.assert_cached(check, num_threads)
-            self.assert_cached(check, num_threads)
+        self.assertEqual("foo", check.add_cached)
+        self.assertEqual(0, check.cached_total)
 
 
 class TestThreadedCachedProperty(TestCachedProperty):
@@ -188,26 +164,6 @@ def test_ttl_expiry(self):
         self.assert_cached(check, 2)
         self.assert_cached(check, 2)
 
-    def test_threads_ttl_expiry(self):
-        Check = CheckFactory(self.cached_property_factory(ttl=100000), threadsafe=True)
-        check = Check()
-        num_threads = 5
-
-        # Same as in test_threads
-        check.run_threads(num_threads)
-        self.assert_cached(check, num_threads)
-        self.assert_cached(check, num_threads)
-
-        # The cache expires in the future
-        with freeze_time("9999-01-01"):
-            check.run_threads(num_threads)
-            self.assert_cached(check, 2 * num_threads)
-            self.assert_cached(check, 2 * num_threads)
-
-        # Things are not reverted when we are back to the present
-        self.assert_cached(check, 2 * num_threads)
-        self.assert_cached(check, 2 * num_threads)
-
 
 class TestThreadedCachedPropertyWithTTL(
     TestThreadedCachedProperty, TestCachedPropertyWithTTL
diff --git a/tests/test_coroutine_cached_property.py b/tests/test_coroutine_cached_property.py
index 3a1ea57..29758fd 100644
--- a/tests/test_coroutine_cached_property.py
+++ b/tests/test_coroutine_cached_property.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """
 The same tests as in :mod:`.test_async_cached_property`, but with the old
 yield from instead of the new async/await syntax. Used to test Python 3.4
@@ -6,120 +5,98 @@
 """
 
 import unittest
-import asyncio
 from freezegun import freeze_time
 
 import cached_property
 
 
-def unittest_run_loop(f):
-    def wrapper(*args, **kwargs):
-        coro = asyncio.coroutine(f)
-        future = coro(*args, **kwargs)
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(future)
-
-    return wrapper
-
-
 def CheckFactory(cached_property_decorator):
     """
     Create dynamically a Check class whose add_cached method is decorated by
     the cached_property_decorator.
     """
 
-    class Check(object):
+    class Check:
         def __init__(self):
             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
 
     return Check
 
 
-class TestCachedProperty(unittest.TestCase):
+class TestCachedProperty(unittest.IsolatedAsyncioTestCase):
     """Tests for cached_property"""
 
     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()  # noqa
-        self.assertEqual(value, expected)
-        self.assertEqual(check.control_total, expected)
+        value = yield check.add_control()
+        self.assertEqual(expected, value)
+        self.assertEqual(expected, check.control_total)
 
-    @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
-        self.assertEqual(value, expected)
-        self.assertEqual(check.cached_total, expected)
+        value = yield check.add_cached
+        self.assertEqual(expected, value)
+        self.assertEqual(expected, check.cached_total)
 
-    @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)
+        yield self.assert_control(check, 1)
+        yield 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)
+        yield self.assert_cached(check, 1)
+        yield self.assert_cached(check, 1)
 
         # The cache does not expire
         with freeze_time("9999-01-01"):
-            yield from self.assert_cached(check, 1)
+            yield 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)
+        yield self.assert_cached(check, 1)
+        yield 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)
+        yield self.assert_cached(check, 2)
+        yield self.assert_cached(check, 2)
 
-    @unittest_run_loop
-    @asyncio.coroutine
-    def test_none_cached_property(self):
-        class Check(object):
+    async def test_none_cached_property(self):
+        class Check:
             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)
+        yield self.assert_cached(Check(), None)
diff --git a/tox.ini b/tox.ini
index a1b4751..e83ad16 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,5 +1,5 @@
 [tox]
-envlist = py35, py36, py37, py38
+envlist = py38, py39, py310, py310, py311, py312, py313
 
 [testenv]
 setenv =