Merge branch 'main' into gh-636-backport-137281-param-order

Author: brianschubert

.github/codecov.yml

@@ -0,0 +1,6 @@
+# Inherits global settings from https://app.codecov.io/account/gh/python/yaml/
+# TODO: enable status checks to fail CI if coverage drops?
+# https://docs.codecov.com/docs/commit-status
+comment:
+  # https://docs.codecov.com/docs/pull-request-comments
+  layout: "condensed_header, diff, flags, files"

.github/workflows/ci.yml

@@ -67,39 +67,22 @@ jobs:
           allow-prereleases: true
 
       - name: Install coverage
-        if: ${{ !startsWith(matrix.python-version, 'pypy') }}
         run: |
-          # Be wary that this does not install typing_extensions in the future
-          pip install coverage
+          # Be wary that this does not install typing_extensions in the future.
+          # 'toml' extra is needed to read settings from pyproject.toml on Python <3.11
+          pip install 'coverage[toml]'
 
       - name: Test typing_extensions with coverage
-        if: ${{ !startsWith(matrix.python-version, 'pypy') }}
         run: |
           # Be wary of running `pip install` here, since it becomes easy for us to
           # accidentally pick up typing_extensions as installed by a dependency
           cd src
           python --version  # just to make sure we're running the right one
           # Run tests under coverage
-          export COVERAGE_FILE=.coverage_${{ matrix.python-version }}
           python -m coverage run -m unittest test_typing_extensions.py
-      - name: Test typing_extensions no coverage on pypy
-        if: ${{ startsWith(matrix.python-version, 'pypy') }}
-        run: |
-          # Be wary of running `pip install` here, since it becomes easy for us to
-          # accidentally pick up typing_extensions as installed by a dependency
-          cd src
-          python --version  # just to make sure we're running the right one
-          python -m unittest test_typing_extensions.py
+          # Create xml file for Codecov
+          coverage xml --rcfile=../pyproject.toml --fail-under=0
 
-      - name: Archive code coverage results
-        id: archive-coverage
-        if: ${{ !startsWith(matrix.python-version, 'pypy') }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: .coverage_${{ matrix.python-version }}
-          path: ./src/.coverage*
-          include-hidden-files: true
-          compression-level: 0 # no compression
       - name: Test CPython typing test suite
         # Test suite fails on PyPy even without typing_extensions
         if: ${{ !startsWith(matrix.python-version, 'pypy') }}
@@ -108,9 +91,16 @@ jobs:
           # Run the typing test suite from CPython with typing_extensions installed,
           # because we monkeypatch typing under some circumstances.
           python -c 'import typing_extensions; import test.__main__' test_typing -v
-    outputs:
-      # report if coverage was uploaded
-      cov_uploaded: ${{ steps.archive-coverage.outputs.artifact-id }}
+
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@5a1091511ad55cbe89839c7260b706298ca349f7
+        if: ${{ (github.event_name == 'push' || github.event_name == 'pull_request') }}
+        with:
+          token: ${{ secrets.CODECOV_ORG_TOKEN }}
+          flags: ${{ matrix.python-version }}
+          directory: src
+          fail_ci_if_error: true
+          verbose: true
 
   create-issue-on-failure:
     name: Create an issue if daily tests failed
@@ -140,95 +130,3 @@ jobs:
               title: `Daily tests failed on ${new Date().toDateString()}`,
               body: "Runs listed here: https://github.com/python/typing_extensions/actions/workflows/ci.yml",
             })
-
-  report-coverage:
-    name: Report coverage
-
-    runs-on: ubuntu-latest
-
-    needs: [tests]
-
-    permissions:
-      pull-requests: write
-
-    # Job will run even if tests failed but only if at least one artifact was uploaded
-    if: ${{ always() && needs.tests.outputs.cov_uploaded != '' }}
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3"
-      - name: Download coverage artifacts
-        uses: actions/download-artifact@v4
-        with:
-          pattern: .coverage_*
-          path: .
-          # merge only when files are named differently
-          merge-multiple: true
-      - name: Install dependencies
-        run: pip install coverage
-      - name: Combine coverage results
-        run: |
-          # List the files to see what we have
-          echo "Combining coverage files..."
-          ls -aR .coverage*
-          coverage combine .coverage*
-          echo "Creating coverage report..."
-          # Create xml file for further processing; Create even if below minimum
-          coverage xml --fail-under=0
-          # Write markdown report to job summary
-          coverage report --fail-under=0 --format=markdown -m >> "$GITHUB_STEP_SUMMARY"
-
-      # For future use in case we want to add a PR comment for 3rd party PRs which requires
-      # a workflow with elevated PR write permissions. Move below steps into a separate job.
-      - name: Archive code coverage report
-        id: cov_xml_upload
-        uses: actions/upload-artifact@v4
-        with:
-          name: coverage
-          path: coverage.xml
-      - name: Code Coverage Report (console)
-        run: |
-          # Create a coverage report (console), respects fail_under in pyproject.toml
-          coverage report
-
-      - name: Code Coverage Report
-        uses: irongut/CodeCoverageSummary@51cc3a756ddcd398d447c044c02cb6aa83fdae95 # v1.3.0
-        # Create markdown file even if coverage report fails due to fail_under
-        if: ${{ always() && steps.cov_xml_upload.outputs.artifact-id != '' }}
-        with:
-          filename: coverage.xml
-          badge: true
-          fail_below_min: true
-          format: markdown
-          hide_branch_rate: false
-          hide_complexity: true
-          indicators: true
-          output: both  # console, file or both
-          # Note: it appears fail below min is one off, use fail_under -1 here
-          thresholds: '95 98'
-
-      - name: Add link to report badge
-        if: ${{ always() && steps.cov_xml_upload.outputs.artifact-id != '' }}
-        run: |
-          run_url="${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}?pr=${{ github.event.pull_request.number }}"
-          sed -i "1s|^\(!.*\)$|[\1]($run_url)|" code-coverage-results.md
-
-      - name: Add Coverage PR Comment
-        uses: marocchino/sticky-pull-request-comment@52423e01640425a022ef5fd42c6fb5f633a02728  # v2.9.3
-        # Create PR comment when the branch is on the repo, otherwise we lack PR write permissions
-        # -> need another workflow with access to secret token
-        if: >-
-          ${{
-            always()
-            && github.event_name == 'pull_request'
-            && github.event.pull_request.head.repo.full_name == github.repository
-            && steps.cov_xml_upload.outputs.artifact-id != ''
-          }}
-        with:
-          hide_and_recreate: true
-          path: code-coverage-results.md

CHANGELOG.md

@@ -5,6 +5,12 @@
   with type variables. Now, parametrized `Generic` or `Protocol` base classes always
   dictate the number and the order of the type parameters. Patch by Brian Schubert,
   backporting a CPython PR by Nikita Sobolev.
+- Fix incorrect behaviour on Python 3.9 and Python 3.10 that meant that
+  calling `isinstance` with `typing_extensions.Concatenate[...]` or
+  `typing_extensions.Unpack[...]` as the first argument could have a different
+  result in some situations depending on whether or not a profiling function had been
+  set using `sys.setprofile`. This affected both CPython and PyPy implementations.
+  Patch by Brian Schubert.
 - Fix `__init_subclass__()` behavior in the presence of multiple inheritance involving
   an `@deprecated`-decorated base class. Backport of CPython PR
   [#138210](https://github.com/python/cpython/pull/138210) by Brian Schubert.

src/test_typing_extensions.py

@@ -6270,6 +6270,47 @@ def test_is_param_expr(self):
             self.assertTrue(typing._is_param_expr(concat))
             self.assertTrue(typing._is_param_expr(typing_concat))
 
+    def test_isinstance_results_unaffected_by_presence_of_tracing_function(self):
+        # See https://github.com/python/typing_extensions/issues/661
+
+        code = textwrap.dedent(
+            """\
+            import sys, typing
+
+            def trace_call(*args):
+                return trace_call
+
+            def run():
+                sys.modules.pop("typing_extensions", None)
+                from typing_extensions import Concatenate
+                return isinstance(Concatenate[...], typing._GenericAlias)
+            isinstance_result_1 = run()
+            sys.setprofile(trace_call)
+            isinstance_result_2 = run()
+            sys.stdout.write(f"{isinstance_result_1} {isinstance_result_2}")
+            """
+        )
+
+        # Run this in an isolated process or it pollutes the environment
+        # and makes other tests fail:
+        try:
+            proc = subprocess.run(
+                [sys.executable, "-c", code], check=True, capture_output=True, text=True,
+            )
+        except subprocess.CalledProcessError as exc:
+            print("stdout", exc.stdout, sep="\n")
+            print("stderr", exc.stderr, sep="\n")
+            raise
+
+        # Sanity checks that assert the test is working as expected
+        self.assertIsInstance(proc.stdout, str)
+        result1, result2 = proc.stdout.split(" ")
+        self.assertIn(result1, {"True", "False"})
+        self.assertIn(result2, {"True", "False"})
+
+        # The actual test:
+        self.assertEqual(result1, result2)
+
 class TypeGuardTests(BaseTestCase):
     def test_basics(self):
         TypeGuard[int]  # OK
@@ -6692,6 +6733,46 @@ def test_type_var_inheritance(self):
         self.assertFalse(isinstance(Unpack[Ts], TypeVar))
         self.assertFalse(isinstance(Unpack[Ts], typing.TypeVar))
 
+    def test_isinstance_results_unaffected_by_presence_of_tracing_function(self):
+        # See https://github.com/python/typing_extensions/issues/661
+
+        code = textwrap.dedent(
+            """\
+            import sys, typing
+
+            def trace_call(*args):
+                return trace_call
+
+            def run():
+                sys.modules.pop("typing_extensions", None)
+                from typing_extensions import TypeVarTuple, Unpack
+                return isinstance(Unpack[TypeVarTuple("Ts")], typing.TypeVar)
+            isinstance_result_1 = run()
+            sys.setprofile(trace_call)
+            isinstance_result_2 = run()
+            sys.stdout.write(f"{isinstance_result_1} {isinstance_result_2}")
+            """
+        )
+
+        # Run this in an isolated process or it pollutes the environment
+        # and makes other tests fail:
+        try:
+            proc = subprocess.run(
+                [sys.executable, "-c", code], check=True, capture_output=True, text=True,
+            )
+        except subprocess.CalledProcessError as exc:
+            print("stdout", exc.stdout, sep="\n")
+            print("stderr", exc.stderr, sep="\n")
+            raise
+
+        # Sanity checks that assert the test is working as expected
+        self.assertIsInstance(proc.stdout, str)
+        result1, result2 = proc.stdout.split(" ")
+        self.assertIn(result1, {"True", "False"})
+        self.assertIn(result2, {"True", "False"})
+
+        # The actual test:
+        self.assertEqual(result1, result2)
 
 class TypeVarTupleTests(BaseTestCase):
 

src/typing_extensions.py

@@ -1986,7 +1986,9 @@ class _ConcatenateGenericAlias(list):
         __class__ = typing._GenericAlias
 
         def __init__(self, origin, args):
-            super().__init__(args)
+            # Cannot use `super().__init__` here because of the `__class__` assignment
+            # in the class body (https://github.com/python/typing_extensions/issues/661)
+            list.__init__(self, args)
             self.__origin__ = origin
             self.__args__ = args
 
@@ -2545,7 +2547,10 @@ def __typing_is_unpacked_typevartuple__(self):
         def __getitem__(self, args):
             if self.__typing_is_unpacked_typevartuple__:
                 return args
-            return super().__getitem__(args)
+            # Cannot use `super().__getitem__` here because of the `__class__` assignment
+            # in the class body on Python <=3.11
+            # (https://github.com/python/typing_extensions/issues/661)
+            return typing._GenericAlias.__getitem__(self, args)
 
     @_UnpackSpecialForm
     def Unpack(self, parameters):