Use uv on CI

The asyncio function is deprecated starting from Python 3.14 and
will be removed from Python 3.16.

.github/workflows/codespell.yml

@@ -13,7 +13,7 @@ permissions:
 jobs:
   codespell:
     name: Check for spelling errors
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
 
     steps:
       - name: Checkout

.github/workflows/docs.yml

@@ -7,7 +7,7 @@ on:
 
 jobs:
   validate:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/main.yml

@@ -5,21 +5,22 @@ on:
     branches:
       - master
   pull_request:
+  schedule:
+    - cron: '0 16 * * 5'  # Every Friday 4pm
   workflow_dispatch:
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
         python-version:
-          - "3.8"
           - "3.9"
           - "3.10"
           - "3.11"
           - "3.12"
-          - "pypy-3.8"
+          - "3.13"
           - "pypy-3.9"
           - "pypy-3.10"
         urllib3-requirement:
@@ -27,10 +28,6 @@ jobs:
           - "urllib3<2"
 
         exclude:
-          - python-version: "3.8"
-            urllib3-requirement: "urllib3>=2"
-          - python-version: "pypy-3.8"
-            urllib3-requirement: "urllib3>=2"
           - python-version: "3.9"
             urllib3-requirement: "urllib3>=2"
           - python-version: "pypy-3.9"
@@ -40,18 +37,28 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
 
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
           cache: pip
+          allow-prereleases: true
 
       - name: Install project dependencies
         run: |
-          pip install --upgrade pip
-          pip install codecov '.[tests]' '${{ matrix.urllib3-requirement }}'
-          pip check
+          uv pip install --system --upgrade pip setuptools
+          uv pip install --system codecov '.[tests]' '${{ matrix.urllib3-requirement }}'
+          uv pip check
+
+      - name: Allow creation of user namespaces (e.g. to the unshare command)
+        run: |
+          # .. so that we don't get error:
+          # unshare: write failed /proc/self/uid_map: Operation not permitted
+          # Idea from https://github.com/YoYoGames/GameMaker-Bugs/issues/6015#issuecomment-2135552784 .
+          sudo sysctl kernel.apparmor_restrict_unprivileged_userns=0
 
       - name: Run online tests
         run: ./runtests.sh --cov=./vcr --cov-branch --cov-report=xml --cov-append -m online

.github/workflows/pre-commit-detect-outdated.yml

@@ -16,7 +16,7 @@ permissions:
 jobs:
   pre_commit_detect_outdated:
     name: Detect outdated pre-commit hooks
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
 
@@ -41,7 +41,7 @@ jobs:
 
       - name: Create pull request from changes (if any)
         id: create-pull-request
-        uses: peter-evans/create-pull-request@v5
+        uses: peter-evans/create-pull-request@v7
         with:
           author: 'pre-commit <pre-commit@tools.invalid>'
           base: master

.github/workflows/pre-commit.yml

@@ -11,10 +11,10 @@ on:
 jobs:
   pre-commit:
     name: Run pre-commit
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
     - uses: actions/checkout@v4
     - uses: actions/setup-python@v5
       with:
         python-version: 3.12
-    - uses: pre-commit/action@v3.0.0
+    - uses: pre-commit/action@v3.0.1

.pre-commit-config.yaml

@@ -3,14 +3,14 @@
 
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.1.13
+    rev: v0.11.2
     hooks:
       - id: ruff
-        args: ["--show-source"]
+        args: ["--output-format=full"]
       - id: ruff-format
 
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
+    rev: v5.0.0
     hooks:
       - id: check-merge-conflict
       - id: end-of-file-fixer

.readthedocs.yaml

@@ -7,7 +7,7 @@ version: 2
 
 # Set the version of Python and other tools you might need
 build:
-  os: ubuntu-22.04
+  os: ubuntu-24.04
   tools:
     python: "3.12"
 

docs/advanced.rst

@@ -427,3 +427,16 @@ If you want to save the cassette only when the test succeeds, set the Cassette
 
     # Since there was an exception, the cassette file hasn't been created.
     assert not os.path.exists('fixtures/vcr_cassettes/synopsis.yaml')
+
+Drop unused requests
+--------------------
+
+Even if any HTTP request is changed or removed from tests, previously recorded
+interactions remain in the cassette file.  If set the ``drop_unused_requests``
+option to ``True``, VCR will not save old HTTP interactions if they are not used.
+
+.. code:: python
+
+    my_vcr = VCR(drop_unused_requests=True)
+    with my_vcr.use_cassette('fixtures/vcr_cassettes/synopsis.yaml'):
+        ...  # your HTTP interactions here

docs/changelog.rst

@@ -7,6 +7,18 @@ For a full list of triaged issues, bugs and PRs and what release they are target
 
 All help in providing PRs to close out bug issues is appreciated. Even if that is providing a repo that fully replicates issues. We have very generous contributors that have added these to bug issues which meant another contributor picked up the bug and closed it out.
 
+-  7.0.0
+    - Drop support for python 3.8 (major version bump) - thanks @jairhenrique
+    - Various linting and test fixes - thanks @jairhenrique
+    - Bugfix for urllib2>=2.3.0 - missing version_string (#888)
+    - Bugfix for asyncio.run - thanks @alekeik1
+-  6.0.2
+    - Ensure body is consumed only once (#846) - thanks @sathieu
+    - Permit urllib3 2.x for non-PyPy Python >=3.10
+    - Fix typos in test commands - thanks @chuckwondo
+    - Several test and workflow improvements - thanks @hartwork and @graingert
+-  6.0.1
+    - Bugfix with to Tornado cassette generator (thanks @graingert)
 -  6.0.0
     - BREAKING: Fix issue with httpx support (thanks @parkerhancock) in #784. NOTE: You may have to recreate some of your cassettes produced in previous releases due to the binary format being saved incorrectly in previous releases
     - BREAKING: Drop support for `boto` (vcrpy still supports boto3, but is dropping the deprecated `boto` support in this release. (thanks @jairhenrique)

docs/conf.py

@@ -316,5 +316,5 @@ texinfo_documents = [
 
 
 # Example configuration for intersphinx: refer to the Python standard library.
-intersphinx_mapping = {"https://docs.python.org/": None}
+intersphinx_mapping = {"python": ("https://docs.python.org/3", None)}
 html_theme = "alabaster"

docs/contributing.rst

@@ -115,8 +115,8 @@ in this example::
     pyenv local 3.12.0 pypy3.10
 
     # Run the whole test suite
-    pip install .[test]
-    ./run_tests.sh
+    pip install .[tests]
+    ./runtests.sh
 
 
 Troubleshooting on MacOSX

docs/installation.rst

@@ -9,7 +9,7 @@ with pip::
 Compatibility
 -------------
 
-VCR.py supports Python 3.8+, and `pypy <http://pypy.org>`__.
+VCR.py supports Python 3.9+, and `pypy <http://pypy.org>`__.
 
 The following HTTP libraries are supported:
 

docs/requirements.txt

@@ -1,2 +1,2 @@
-sphinx<8
-sphinx_rtd_theme==2.0.0
+sphinx<9
+sphinx_rtd_theme==3.0.2

pyproject.toml

@@ -1,21 +1,17 @@
 [tool.codespell]
 skip = '.git,*.pdf,*.svg,.tox'
 ignore-regex = "\\\\[fnrstv]"
-#
-# ignore-words-list = ''
 
 [tool.pytest.ini_options]
-addopts = [
-    "--strict-config",
-    "--strict-markers",
-]
+addopts = ["--strict-config", "--strict-markers"]
+asyncio_default_fixture_loop_scope = "function"
 markers = ["online"]
-filterwarnings = [
-    "error",
-    '''ignore:datetime\.datetime\.utcfromtimestamp\(\) is deprecated and scheduled for removal in a future version.*:DeprecationWarning''',
-]
 
 [tool.ruff]
+line-length = 110
+target-version = "py39"
+
+[tool.ruff.lint]
 select = [
     "B",   # flake8-bugbear
     "C4",  # flake8-comprehensions
@@ -29,8 +25,6 @@ select = [
     "UP",  # pyupgrade
     "W",   # pycodestyle warning
 ]
-line-length = 110
-target-version = "py38"
 
-[tool.ruff.isort]
+[tool.ruff.lint.isort]
 known-first-party = ["vcr"]

setup.py

@@ -3,10 +3,8 @@
 import codecs
 import os
 import re
-import sys
 
 from setuptools import find_packages, setup
-from setuptools.command.test import test as TestCommand
 
 long_description = open("README.rst").read()
 here = os.path.abspath(os.path.dirname(__file__))
@@ -28,20 +26,6 @@ def find_version(*file_paths):
     raise RuntimeError("Unable to find version string.")
 
 
-class PyTest(TestCommand):
-    def finalize_options(self):
-        TestCommand.finalize_options(self)
-        self.test_args = []
-        self.test_suite = True
-
-    def run_tests(self):
-        # import here, cause outside the eggs aren't loaded
-        import pytest
-
-        errno = pytest.main(self.test_args)
-        sys.exit(errno)
-
-
 install_requires = [
     "PyYAML",
     "wrapt",
@@ -55,6 +39,9 @@ install_requires = [
     "urllib3 <2; python_version <'3.10'",
     # https://github.com/kevin1024/vcrpy/pull/775#issuecomment-1847849962
     "urllib3 <2; platform_python_implementation =='PyPy'",
+    # Workaround for Poetry with CPython >= 3.10, problem description at:
+    # https://github.com/kevin1024/vcrpy/pull/826
+    "urllib3; platform_python_implementation !='PyPy' and python_version >='3.10'",
 ]
 
 extras_require = {
@@ -91,7 +78,7 @@ setup(
     author_email="me@kevinmccarthy.org",
     url="https://github.com/kevin1024/vcrpy",
     packages=find_packages(exclude=["tests*"]),
-    python_requires=">=3.8",
+    python_requires=">=3.9",
     install_requires=install_requires,
     license="MIT",
     extras_require=extras_require,
@@ -102,11 +89,11 @@ setup(
         "Intended Audience :: Developers",
         "Programming Language :: Python",
         "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 :: 3 :: Only",
         "Programming Language :: Python :: Implementation :: CPython",
         "Programming Language :: Python :: Implementation :: PyPy",

tests/integration/conftest.py

@@ -1,16 +0,0 @@
-import os
-import ssl
-
-import pytest
-
-
-@pytest.fixture
-def httpbin_ssl_context():
-    ssl_ca_location = os.environ["REQUESTS_CA_BUNDLE"]
-    ssl_cert_location = os.environ["REQUESTS_CA_BUNDLE"].replace("cacert.pem", "cert.pem")
-    ssl_key_location = os.environ["REQUESTS_CA_BUNDLE"].replace("cacert.pem", "key.pem")
-
-    ssl_context = ssl.create_default_context(cafile=ssl_ca_location)
-    ssl_context.load_cert_chain(ssl_cert_location, ssl_key_location)
-
-    return ssl_context

tests/integration/test_aiohttp.py

@@ -1,7 +1,10 @@
 import logging
+import ssl
 import urllib.parse
 
 import pytest
+import pytest_httpbin.certs
+import yarl
 
 import vcr
 
@@ -11,6 +14,8 @@ aiohttp = pytest.importorskip("aiohttp")
 
 from .aiohttp_utils import aiohttp_app, aiohttp_request  # noqa: E402
 
+HTTPBIN_SSL_CONTEXT = ssl.create_default_context(cafile=pytest_httpbin.certs.where())
+
 
 def run_in_loop(fn):
     async def wrapper():
@@ -338,7 +343,7 @@ def test_double_requests(tmpdir, httpbin):
         assert cassette.play_count == 2
 
 
-def test_cookies(httpbin_both, httpbin_ssl_context, tmpdir):
+def test_cookies(httpbin_both, tmpdir):
     async def run(loop):
         cookies_url = httpbin_both.url + (
             "/response-headers?"
@@ -353,12 +358,12 @@ def test_cookies(httpbin_both, httpbin_ssl_context, tmpdir):
         # ------------------------- Record -------------------------- #
         with vcr.use_cassette(tmp) as cassette:
             async with aiohttp.ClientSession(loop=loop, cookie_jar=aiohttp.CookieJar(unsafe=True)) as session:
-                cookies_resp = await session.get(cookies_url, ssl=httpbin_ssl_context)
+                cookies_resp = await session.get(cookies_url, ssl=HTTPBIN_SSL_CONTEXT)
                 home_resp = await session.get(
                     home_url,
                     cookies=req_cookies,
                     headers=req_headers,
-                    ssl=httpbin_ssl_context,
+                    ssl=HTTPBIN_SSL_CONTEXT,
                 )
                 assert cassette.play_count == 0
         assert_responses(cookies_resp, home_resp)
@@ -366,12 +371,12 @@ def test_cookies(httpbin_both, httpbin_ssl_context, tmpdir):
         # -------------------------- Play --------------------------- #
         with vcr.use_cassette(tmp, record_mode=vcr.mode.NONE) as cassette:
             async with aiohttp.ClientSession(loop=loop, cookie_jar=aiohttp.CookieJar(unsafe=True)) as session:
-                cookies_resp = await session.get(cookies_url, ssl=httpbin_ssl_context)
+                cookies_resp = await session.get(cookies_url, ssl=HTTPBIN_SSL_CONTEXT)
                 home_resp = await session.get(
                     home_url,
                     cookies=req_cookies,
                     headers=req_headers,
-                    ssl=httpbin_ssl_context,
+                    ssl=HTTPBIN_SSL_CONTEXT,
                 )
                 assert cassette.play_count == 2
         assert_responses(cookies_resp, home_resp)
@@ -388,7 +393,7 @@ def test_cookies(httpbin_both, httpbin_ssl_context, tmpdir):
     run_in_loop(run)
 
 
-def test_cookies_redirect(httpbin_both, httpbin_ssl_context, tmpdir):
+def test_cookies_redirect(httpbin_both, tmpdir):
     async def run(loop):
         # Sets cookie as provided by the query string and redirects
         cookies_url = httpbin_both.url + "/cookies/set?Cookie_1=Val_1"
@@ -397,9 +402,9 @@ def test_cookies_redirect(httpbin_both, httpbin_ssl_context, tmpdir):
         # ------------------------- Record -------------------------- #
         with vcr.use_cassette(tmp) as cassette:
             async with aiohttp.ClientSession(loop=loop, cookie_jar=aiohttp.CookieJar(unsafe=True)) as session:
-                cookies_resp = await session.get(cookies_url, ssl=httpbin_ssl_context)
+                cookies_resp = await session.get(cookies_url, ssl=HTTPBIN_SSL_CONTEXT)
                 assert not cookies_resp.cookies
-                cookies = session.cookie_jar.filter_cookies(cookies_url)
+                cookies = session.cookie_jar.filter_cookies(yarl.URL(cookies_url))
                 assert cookies["Cookie_1"].value == "Val_1"
                 assert cassette.play_count == 0
 
@@ -408,9 +413,9 @@ def test_cookies_redirect(httpbin_both, httpbin_ssl_context, tmpdir):
         # -------------------------- Play --------------------------- #
         with vcr.use_cassette(tmp, record_mode=vcr.mode.NONE) as cassette:
             async with aiohttp.ClientSession(loop=loop, cookie_jar=aiohttp.CookieJar(unsafe=True)) as session:
-                cookies_resp = await session.get(cookies_url, ssl=httpbin_ssl_context)
+                cookies_resp = await session.get(cookies_url, ssl=HTTPBIN_SSL_CONTEXT)
                 assert not cookies_resp.cookies
-                cookies = session.cookie_jar.filter_cookies(cookies_url)
+                cookies = session.cookie_jar.filter_cookies(yarl.URL(cookies_url))
                 assert cookies["Cookie_1"].value == "Val_1"
                 assert cassette.play_count == 2
 
@@ -422,9 +427,9 @@ def test_cookies_redirect(httpbin_both, httpbin_ssl_context, tmpdir):
                 "Cookie_1=Val_1; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
             ]
             async with aiohttp.ClientSession(loop=loop, cookie_jar=aiohttp.CookieJar(unsafe=True)) as session:
-                cookies_resp = await session.get(cookies_url, ssl=httpbin_ssl_context)
+                cookies_resp = await session.get(cookies_url, ssl=HTTPBIN_SSL_CONTEXT)
                 assert not cookies_resp.cookies
-                cookies = session.cookie_jar.filter_cookies(cookies_url)
+                cookies = session.cookie_jar.filter_cookies(yarl.URL(cookies_url))
                 assert cookies["Cookie_1"].value == "Val_1"
 
     run_in_loop(run)

tests/integration/test_basic.py

@@ -39,7 +39,7 @@ def test_basic_json_use(tmpdir, httpbin):
     test_fixture = str(tmpdir.join("synopsis.json"))
     with vcr.use_cassette(test_fixture, serializer="json"):
         response = urlopen(httpbin.url).read()
-        assert b"A simple HTTP Request & Response Service." in response
+        assert b"HTTP Request & Response Service" in response
 
 
 def test_patched_content(tmpdir, httpbin):

tests/integration/test_config.py

@@ -5,6 +5,7 @@ from urllib.request import urlopen
 import pytest
 
 import vcr
+from vcr.cassette import Cassette
 
 
 @pytest.mark.online
@@ -85,3 +86,21 @@ def test_dont_record_on_exception(tmpdir, httpbin):
             assert b"Not in content" in urlopen(httpbin.url).read()
 
     assert not os.path.exists(str(tmpdir.join("dontsave2.yml")))
+
+
+def test_set_drop_unused_requests(tmpdir, httpbin):
+    my_vcr = vcr.VCR(drop_unused_requests=True)
+    file = str(tmpdir.join("test.yaml"))
+
+    with my_vcr.use_cassette(file):
+        urlopen(httpbin.url)
+        urlopen(httpbin.url + "/get")
+
+    cassette = Cassette.load(path=file)
+    assert len(cassette) == 2
+
+    with my_vcr.use_cassette(file):
+        urlopen(httpbin.url)
+
+    cassette = Cassette.load(path=file)
+    assert len(cassette) == 1

tests/integration/test_httplib2.py

@@ -1,4 +1,5 @@
 """Integration tests with httplib2"""
+
 from urllib.parse import urlencode
 
 import pytest

tests/integration/test_proxy.py

@@ -1,5 +1,6 @@
 """Test using a proxy."""
 
+import asyncio
 import http.server
 import socketserver
 import threading
@@ -36,6 +37,35 @@ class Proxy(http.server.SimpleHTTPRequestHandler):
         self.end_headers()
         self.copyfile(upstream_response, self.wfile)
 
+    def do_CONNECT(self):
+        host, port = self.path.split(":")
+
+        asyncio.run(self._tunnel(host, port, self.connection))
+
+    async def _tunnel(self, host, port, client_sock):
+        target_r, target_w = await asyncio.open_connection(host=host, port=port)
+
+        self.send_response(http.HTTPStatus.OK)
+        self.end_headers()
+
+        source_r, source_w = await asyncio.open_connection(sock=client_sock)
+
+        async def channel(reader, writer):
+            while True:
+                data = await reader.read(1024)
+                if not data:
+                    break
+                writer.write(data)
+                await writer.drain()
+
+            writer.close()
+            await writer.wait_closed()
+
+        await asyncio.gather(
+            channel(target_r, source_w),
+            channel(source_r, target_w),
+        )
+
 
 @pytest.fixture(scope="session")
 def proxy_server():
@@ -52,10 +82,26 @@ def test_use_proxy(tmpdir, httpbin, proxy_server):
     with vcr.use_cassette(str(tmpdir.join("proxy.yaml"))):
         response = requests.get(httpbin.url, proxies={"http": proxy_server})
 
-    with vcr.use_cassette(str(tmpdir.join("proxy.yaml")), mode="once") as cassette:
+    with vcr.use_cassette(str(tmpdir.join("proxy.yaml")), mode="none") as cassette:
         cassette_response = requests.get(httpbin.url, proxies={"http": proxy_server})
 
-    for key in set(cassette_response.headers.keys()) & set(response.headers.keys()):
-        assert cassette_response.headers[key] == response.headers[key]
     assert cassette_response.headers == response.headers
     assert cassette.play_count == 1
+
+
+def test_use_https_proxy(tmpdir, httpbin_secure, proxy_server):
+    """Ensure that it works with an HTTPS proxy."""
+    with vcr.use_cassette(str(tmpdir.join("proxy.yaml"))):
+        response = requests.get(httpbin_secure.url, proxies={"https": proxy_server})
+
+    with vcr.use_cassette(str(tmpdir.join("proxy.yaml")), mode="none") as cassette:
+        cassette_response = requests.get(
+            httpbin_secure.url,
+            proxies={"https": proxy_server},
+        )
+
+    assert cassette_response.headers == response.headers
+    assert cassette.play_count == 1
+
+    # The cassette URL points to httpbin, not the proxy
+    assert cassette.requests[0].url == httpbin_secure.url + "/"

tests/integration/test_register_persister.py

@@ -66,7 +66,7 @@ def test_load_cassette_with_custom_persister(tmpdir, httpbin):
 
     with my_vcr.use_cassette(test_fixture, serializer="json"):
         response = urlopen(httpbin.url).read()
-        assert b"A simple HTTP Request & Response Service." in response
+        assert b"HTTP Request & Response Service" in response
 
 
 def test_load_cassette_persister_exception_handling(tmpdir, httpbin):

tests/integration/test_requests.py

@@ -1,4 +1,5 @@
 """Test requests' interaction with vcr"""
+
 import pytest
 
 import vcr

tests/integration/test_tornado.py

@@ -1,4 +1,5 @@
 """Test requests' interaction with vcr"""
+
 import asyncio
 import functools
 import inspect

tests/unit/test_cassettes.py

@@ -11,6 +11,7 @@ import yaml
 from vcr.cassette import Cassette
 from vcr.errors import UnhandledHTTPRequestError
 from vcr.patch import force_reset
+from vcr.request import Request
 from vcr.stubs import VCRHTTPSConnection
 
 
@@ -410,3 +411,25 @@ def test_find_requests_with_most_matches_many_similar_requests(mock_get_matchers
         (1, ["method", "path"], [("query", "failed : query")]),
         (3, ["method", "path"], [("query", "failed : query")]),
     ]
+
+
+def test_used_interactions(tmpdir):
+    interactions = [
+        {"request": {"body": "", "uri": "foo1", "method": "GET", "headers": {}}, "response": "bar1"},
+        {"request": {"body": "", "uri": "foo2", "method": "GET", "headers": {}}, "response": "bar2"},
+        {"request": {"body": "", "uri": "foo3", "method": "GET", "headers": {}}, "response": "bar3"},
+    ]
+    file = tmpdir.join("test_cassette.yml")
+    file.write(yaml.dump({"interactions": [interactions[0], interactions[1]]}))
+
+    cassette = Cassette.load(path=str(file))
+    request = Request._from_dict(interactions[1]["request"])
+    cassette.play_response(request)
+    assert len(cassette._played_interactions) < len(cassette._old_interactions)
+
+    request = Request._from_dict(interactions[2]["request"])
+    cassette.append(request, interactions[2]["response"])
+    assert len(cassette._new_interactions()) == 1
+
+    used_interactions = cassette._played_interactions + cassette._new_interactions()
+    assert len(used_interactions) == 2

tests/unit/test_stubs.py

@@ -1,9 +1,12 @@
 import contextlib
+import http.client as httplib
+from io import BytesIO
+from tempfile import NamedTemporaryFile
 from unittest import mock
 
 from pytest import mark
 
-from vcr import mode
+from vcr import mode, use_cassette
 from vcr.cassette import Cassette
 from vcr.stubs import VCRHTTPSConnection
 
@@ -21,3 +24,52 @@ class TestVCRConnection:
             vcr_connection.cassette = Cassette("test", record_mode=mode.ALL)
             vcr_connection.real_connection.connect()
             assert vcr_connection.real_connection.sock is not None
+
+    def test_body_consumed_once_stream(self, tmpdir, httpbin):
+        self._test_body_consumed_once(
+            tmpdir,
+            httpbin,
+            BytesIO(b"1234567890"),
+            BytesIO(b"9876543210"),
+            BytesIO(b"9876543210"),
+        )
+
+    def test_body_consumed_once_iterator(self, tmpdir, httpbin):
+        self._test_body_consumed_once(
+            tmpdir,
+            httpbin,
+            iter([b"1234567890"]),
+            iter([b"9876543210"]),
+            iter([b"9876543210"]),
+        )
+
+    # data2 and data3 should serve the same data, potentially as iterators
+    def _test_body_consumed_once(
+        self,
+        tmpdir,
+        httpbin,
+        data1,
+        data2,
+        data3,
+    ):
+        with NamedTemporaryFile(dir=tmpdir, suffix=".yml") as f:
+            testpath = f.name
+            # NOTE: ``use_cassette`` is not okay with the file existing
+            #       already.  So we using ``.close()`` to not only
+            #       close but also delete the empty file, before we start.
+            f.close()
+            host, port = httpbin.host, httpbin.port
+            match_on = ["method", "uri", "body"]
+            with use_cassette(testpath, match_on=match_on):
+                conn1 = httplib.HTTPConnection(host, port)
+                conn1.request("POST", "/anything", body=data1)
+                conn1.getresponse()
+                conn2 = httplib.HTTPConnection(host, port)
+                conn2.request("POST", "/anything", body=data2)
+                conn2.getresponse()
+            with use_cassette(testpath, match_on=match_on) as cass:
+                conn3 = httplib.HTTPConnection(host, port)
+                conn3.request("POST", "/anything", body=data3)
+                conn3.getresponse()
+            assert cass.play_counts[0] == 0
+            assert cass.play_counts[1] == 1

tests/unit/test_util.py

@@ -0,0 +1,33 @@
+from io import BytesIO, StringIO
+
+import pytest
+
+from vcr import request
+from vcr.util import read_body
+
+
+@pytest.mark.parametrize(
+    "input_, expected_output",
+    [
+        (BytesIO(b"Stream"), b"Stream"),
+        (StringIO("Stream"), b"Stream"),
+        (iter(["StringIter"]), b"StringIter"),
+        (iter(["String", "Iter"]), b"StringIter"),
+        (iter([b"BytesIter"]), b"BytesIter"),
+        (iter([b"Bytes", b"Iter"]), b"BytesIter"),
+        (iter([70, 111, 111]), b"Foo"),
+        (iter([]), b""),
+        ("String", b"String"),
+        (b"Bytes", b"Bytes"),
+    ],
+)
+def test_read_body(input_, expected_output):
+    r = request.Request("POST", "http://host.com/", input_, {})
+    assert read_body(r) == expected_output
+
+
+def test_unsupported_read_body():
+    r = request.Request("POST", "http://host.com/", iter([[]]), {})
+    with pytest.raises(ValueError) as excinfo:
+        assert read_body(r)
+    assert excinfo.value.args == ("Body type <class 'list'> not supported",)

tests/unit/test_vcr.py

@@ -372,3 +372,19 @@ def test_path_class_as_cassette():
     )
     with use_cassette(path):
         pass
+
+
+def test_use_cassette_generator_return():
+    ret_val = object()
+
+    vcr = VCR()
+
+    @vcr.use_cassette("test")
+    def gen():
+        return ret_val
+        yield
+
+    with pytest.raises(StopIteration) as exc_info:
+        next(gen())
+
+    assert exc_info.value.value is ret_val

vcr/__init__.py

@@ -4,7 +4,7 @@ from logging import NullHandler
 from .config import VCR
 from .record_mode import RecordMode as mode  # noqa: F401
 
-__version__ = "6.0.0"
+__version__ = "7.0.0"
 
 logging.getLogger(__name__).addHandler(NullHandler())
 

vcr/cassette.py

@@ -3,7 +3,7 @@ import contextlib
 import copy
 import inspect
 import logging
-from asyncio import iscoroutinefunction
+from inspect import iscoroutinefunction
 
 import wrapt
 
@@ -125,7 +125,7 @@ class CassetteContextDecorator:
         duration of the generator.
         """
         with self as cassette:
-            yield from fn(cassette)
+            return (yield from fn(cassette))
 
     def _handle_function(self, fn):
         with self as cassette:
@@ -177,6 +177,7 @@ class Cassette:
         custom_patches=(),
         inject=False,
         allow_playback_repeats=False,
+        drop_unused_requests=False,
     ):
         self._persister = persister or FilesystemPersister
         self._path = path
@@ -189,6 +190,7 @@ class Cassette:
         self.record_mode = record_mode
         self.custom_patches = custom_patches
         self.allow_playback_repeats = allow_playback_repeats
+        self.drop_unused_requests = drop_unused_requests
 
         # self.data is the list of (req, resp) tuples
         self.data = []
@@ -196,6 +198,10 @@ class Cassette:
         self.dirty = False
         self.rewound = False
 
+        # Subsets of self.data to store old and played interactions
+        self._old_interactions = []
+        self._played_interactions = []
+
     @property
     def play_count(self):
         return sum(self.play_counts.values())
@@ -215,7 +221,7 @@ class Cassette:
 
     @property
     def write_protected(self):
-        return self.rewound and self.record_mode == RecordMode.ONCE or self.record_mode == RecordMode.NONE
+        return (self.rewound and self.record_mode == RecordMode.ONCE) or self.record_mode == RecordMode.NONE
 
     def append(self, request, response):
         """Add a request, response pair to this cassette"""
@@ -257,6 +263,7 @@ class Cassette:
         for index, response in self._responses(request):
             if self.play_counts[index] == 0 or self.allow_playback_repeats:
                 self.play_counts[index] += 1
+                self._played_interactions.append((request, response))
                 return response
         # The cassette doesn't contain the request asked for.
         raise UnhandledHTTPRequestError(
@@ -317,12 +324,36 @@ class Cassette:
 
         return final_best_matches
 
+    def _new_interactions(self):
+        """List of new HTTP interactions (request/response tuples)"""
+        new_interactions = []
+        for request, response in self.data:
+            if all(
+                not requests_match(request, old_request, self._match_on)
+                for old_request, _ in self._old_interactions
+            ):
+                new_interactions.append((request, response))
+        return new_interactions
+
     def _as_dict(self):
         return {"requests": self.requests, "responses": self.responses}
 
+    def _build_used_interactions_dict(self):
+        interactions = self._played_interactions + self._new_interactions()
+        cassete_dict = {
+            "requests": [request for request, _ in interactions],
+            "responses": [response for _, response in interactions],
+        }
+        return cassete_dict
+
     def _save(self, force=False):
+        if self.drop_unused_requests and len(self._played_interactions) < len(self._old_interactions):
+            cassete_dict = self._build_used_interactions_dict()
+            force = True
+        else:
+            cassete_dict = self._as_dict()
         if force or self.dirty:
-            self._persister.save_cassette(self._path, self._as_dict(), serializer=self._serializer)
+            self._persister.save_cassette(self._path, cassete_dict, serializer=self._serializer)
             self.dirty = False
 
     def _load(self):
@@ -330,6 +361,7 @@ class Cassette:
             requests, responses = self._persister.load_cassette(self._path, serializer=self._serializer)
             for request, response in zip(requests, responses):
                 self.append(request, response)
+                self._old_interactions.append((request, response))
             self.dirty = False
             self.rewound = True
         except (CassetteDecodeError, CassetteNotFoundError):

vcr/config.py

@@ -48,6 +48,7 @@ class VCR:
         func_path_generator=None,
         decode_compressed_response=False,
         record_on_exception=True,
+        drop_unused_requests=False,
     ):
         self.serializer = serializer
         self.match_on = match_on
@@ -81,6 +82,7 @@ class VCR:
         self.decode_compressed_response = decode_compressed_response
         self.record_on_exception = record_on_exception
         self._custom_patches = tuple(custom_patches)
+        self.drop_unused_requests = drop_unused_requests
 
     def _get_serializer(self, serializer_name):
         try:
@@ -151,6 +153,7 @@ class VCR:
             "func_path_generator": func_path_generator,
             "allow_playback_repeats": kwargs.get("allow_playback_repeats", False),
             "record_on_exception": record_on_exception,
+            "drop_unused_requests": kwargs.get("drop_unused_requests", self.drop_unused_requests),
         }
         path = kwargs.get("path")
         if path:

vcr/matchers.py

@@ -3,11 +3,10 @@ import logging
 import urllib
 import xmlrpc.client
 from string import hexdigits
-from typing import List, Set
 
 from .util import read_body
 
-_HEXDIG_CODE_POINTS: Set[int] = {ord(s.encode("ascii")) for s in hexdigits}
+_HEXDIG_CODE_POINTS: set[int] = {ord(s.encode("ascii")) for s in hexdigits}
 
 log = logging.getLogger(__name__)
 
@@ -109,7 +108,7 @@ def _dechunk(body):
     CHUNK_GAP = b"\r\n"
     BODY_LEN: int = len(body)
 
-    chunks: List[bytes] = []
+    chunks: list[bytes] = []
     pos: int = 0
 
     while True:

vcr/patch.py

@@ -1,4 +1,5 @@
 """Utilities for patching in cassettes"""
+
 import contextlib
 import functools
 import http.client as httplib

vcr/request.py

@@ -3,7 +3,7 @@ import warnings
 from io import BytesIO
 from urllib.parse import parse_qsl, urlparse
 
-from .util import CaseInsensitiveDict
+from .util import CaseInsensitiveDict, _is_nonsequence_iterator
 
 log = logging.getLogger(__name__)
 
@@ -17,13 +17,25 @@ class Request:
         self.method = method
         self.uri = uri
         self._was_file = hasattr(body, "read")
+        self._was_iter = _is_nonsequence_iterator(body)
         if self._was_file:
             self.body = body.read()
+        elif self._was_iter:
+            self.body = list(body)
         else:
             self.body = body
         self.headers = headers
         log.debug("Invoking Request %s", self.uri)
 
+    @property
+    def uri(self):
+        return self._uri
+
+    @uri.setter
+    def uri(self, uri):
+        self._uri = uri
+        self.parsed_uri = urlparse(uri)
+
     @property
     def headers(self):
         return self._headers
@@ -36,7 +48,11 @@ class Request:
 
     @property
     def body(self):
-        return BytesIO(self._body) if self._was_file else self._body
+        if self._was_file:
+            return BytesIO(self._body)
+        if self._was_iter:
+            return iter(self._body)
+        return self._body
 
     @body.setter
     def body(self, value):
@@ -54,30 +70,29 @@ class Request:
 
     @property
     def scheme(self):
-        return urlparse(self.uri).scheme
+        return self.parsed_uri.scheme
 
     @property
     def host(self):
-        return urlparse(self.uri).hostname
+        return self.parsed_uri.hostname
 
     @property
     def port(self):
-        parse_uri = urlparse(self.uri)
-        port = parse_uri.port
+        port = self.parsed_uri.port
         if port is None:
             try:
-                port = {"https": 443, "http": 80}[parse_uri.scheme]
+                port = {"https": 443, "http": 80}[self.parsed_uri.scheme]
             except KeyError:
                 pass
         return port
 
     @property
     def path(self):
-        return urlparse(self.uri).path
+        return self.parsed_uri.path
 
     @property
     def query(self):
-        q = urlparse(self.uri).query
+        q = self.parsed_uri.query
         return sorted(parse_qsl(q))
 
     # alias for backwards compatibility

vcr/stubs/__init__.py

@@ -66,6 +66,7 @@ class VCRHTTPResponse(HTTPResponse):
         self.reason = recorded_response["status"]["message"]
         self.status = self.code = recorded_response["status"]["code"]
         self.version = None
+        self.version_string = None
         self._content = BytesIO(self.recorded_response["body"]["string"])
         self._closed = False
         self._original_response = self  # for requests.session.Session cookie extraction
@@ -186,22 +187,34 @@ class VCRConnection:
         """
         Returns empty string for the default port and ':port' otherwise
         """
-        port = self.real_connection.port
+        port = (
+            self.real_connection.port
+            if not self.real_connection._tunnel_host
+            else self.real_connection._tunnel_port
+        )
         default_port = {"https": 443, "http": 80}[self._protocol]
         return f":{port}" if port != default_port else ""
 
+    def _real_host(self):
+        """Returns the request host"""
+        if self.real_connection._tunnel_host:
+            # The real connection is to an HTTPS proxy
+            return self.real_connection._tunnel_host
+        else:
+            return self.real_connection.host
+
     def _uri(self, url):
         """Returns request absolute URI"""
         if url and not url.startswith("/"):
             # Then this must be a proxy request.
             return url
-        uri = f"{self._protocol}://{self.real_connection.host}{self._port_postfix()}{url}"
+        uri = f"{self._protocol}://{self._real_host()}{self._port_postfix()}{url}"
         log.debug("Absolute URI: %s", uri)
         return uri
 
     def _url(self, uri):
         """Returns request selector url from absolute URI"""
-        prefix = f"{self._protocol}://{self.real_connection.host}{self._port_postfix()}"
+        prefix = f"{self._protocol}://{self._real_host()}{self._port_postfix()}"
         return uri.replace(prefix, "", 1)
 
     def request(self, method, url, body=None, headers=None, *args, **kwargs):

vcr/stubs/aiohttp_stubs.py

@@ -1,10 +1,12 @@
 """Stubs for aiohttp HTTP clients"""
+
 import asyncio
 import functools
 import json
 import logging
+from collections.abc import Mapping
 from http.cookies import CookieError, Morsel, SimpleCookie
-from typing import Mapping, Union
+from typing import Union
 
 from aiohttp import ClientConnectionError, ClientResponse, CookieJar, RequestInfo, hdrs, streams
 from aiohttp.helpers import strip_auth_from_url

vcr/stubs/boto3_stubs.py

@@ -1,4 +1,5 @@
 """Stubs for boto3"""
+
 from botocore.awsrequest import AWSHTTPConnection as HTTPConnection
 from botocore.awsrequest import AWSHTTPSConnection as VerifiedHTTPSConnection
 

vcr/stubs/httpx_stubs.py

@@ -166,6 +166,22 @@ def async_vcr_send(cassette, real_send):
     return _inner_send
 
 
+def _run_async_function(sync_func, *args, **kwargs):
+    """
+    Safely run an asynchronous function from a synchronous context.
+    Handles both cases:
+    - An event loop is already running.
+    - No event loop exists yet.
+    """
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(sync_func(*args, **kwargs))
+    else:
+        # If inside a running loop, create a task and wait for it
+        return asyncio.ensure_future(sync_func(*args, **kwargs))
+
+
 def _sync_vcr_send(cassette, real_send, *args, **kwargs):
     vcr_request, response = _shared_vcr_send(cassette, real_send, *args, **kwargs)
     if response:
@@ -174,7 +190,7 @@ def _sync_vcr_send(cassette, real_send, *args, **kwargs):
         return response
 
     real_response = real_send(*args, **kwargs)
-    asyncio.run(_record_responses(cassette, vcr_request, real_response, aread=False))
+    _run_async_function(_record_responses, cassette, vcr_request, real_response, aread=False)
     return real_response
 
 

vcr/stubs/tornado_stubs.py

@@ -1,4 +1,5 @@
 """Stubs for tornado HTTP clients"""
+
 import functools
 from io import BytesIO
 

vcr/util.py

@@ -89,9 +89,28 @@ def compose(*functions):
     return composed
 
 
+def _is_nonsequence_iterator(obj):
+    return hasattr(obj, "__iter__") and not isinstance(
+        obj,
+        (bytearray, bytes, dict, list, str),
+    )
+
+
 def read_body(request):
     if hasattr(request.body, "read"):
         return request.body.read()
+    if _is_nonsequence_iterator(request.body):
+        body = list(request.body)
+        if body:
+            if isinstance(body[0], str):
+                return "".join(body).encode("utf-8")
+            elif isinstance(body[0], (bytes, bytearray)):
+                return b"".join(body)
+            elif isinstance(body[0], int):
+                return bytes(body)
+            else:
+                raise ValueError(f"Body type {type(body[0])} not supported")
+        return b""
     return request.body