Add warning for python 2.7 on release/v2 (#675)

* add warning

* remove ubuntu-18.04

* remove macos-10.15

* fix pypy3

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @actions/actions-service

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,44 +1,38 @@
 ---
 name: Bug report
-about: Create a report to help us improve
+about: Create a bug report
 title: ''
-labels: bug
+labels: bug, needs triage
 assignees: ''
 
 ---
 
-**Describe the bug**
+<!--- Please direct any generic questions related to actions to our support community forum at https://github.community/c/code-to-cloud/github-actions/41 --->
+<!--- Before opening up a new bug report, please make sure to check for similar existing issues -->
+
+**Description:**
 A clear and concise description of what the bug is.
 
-**Which version of the action are you using?**
+**Action version:**
+Specify the action version
 
-- [ ] `v1`
+**Platform:**
-- [ ] `v2`
+- [ ] Ubuntu
-- [ ] Some other tag (such as `v2.0.1` or `master`)
+- [ ] macOS
-
-**Environment**
-- [ ] self-hosted
-- [ ] Linux
 - [ ] Windows
-- [ ] Mac
 
-If applicable, please specify if you're using a container
+**Runner type:**
+- [ ] Hosted
+- [ ] Self-hosted
 
-**Python Versions**
+**Tools version:**
-Please list all of the effected versions of Python (`3.8.2`, etc.)
+<!--- Please list all of the affected Python versions (`3.8.2`, etc.)-->
 
-**To Reproduce**
+**Repro steps:**  
-Steps to reproduce the behavior:
+A description with steps to reproduce the issue. If your have a public example or repo to share, please provide the link.
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
 
-**Run/Repo Url**
+**Expected behavior:**
-If applicable, and if your repo/run is public, please include a URL so it is easier for us to investigate.
+A description of what you expected to happen.
 
-**Screenshots**
+**Actual behavior:**
-If applicable, add screenshots to help explain your problem.
+A description of what is actually happening.
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,18 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: feature request, needs triage
+assignees: ''
+---
+<!--- Please direct any generic questions related to actions to our support community forum at https://github.community/c/code-to-cloud/github-actions/41 --->
+<!--- Before opening up a new feature request, please make sure to check for similar existing issues and pull requests -->
+
+**Description:**
+Describe your proposal.
+
+**Justification:**
+Justification or a use case for your proposal.
+
+**Are you willing to submit a PR?**
+<!--- We accept contributions! -->

.github/pull_request_template.md

@@ -0,0 +1,9 @@
+**Description:**
+Describe your changes.
+
+**Related issue:**
+Add link to the related issue.
+
+**Check list:**
+- [ ] Mark if documentation changes are required.
+- [ ] Mark if tests were added or updated to cover the changes.

.github/workflows/check-dist.yml

@@ -0,0 +1,51 @@
+# `dist/index.js` is a special file in Actions.
+# When you reference an action with `uses:` in a workflow,
+# `index.js` is the code that will run.
+# For our project, we generate this file through a build process from other source files.
+# We need to make sure the checked-in `index.js` actually matches what we expect it to be.
+name: Check dist/
+
+on:
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+  pull_request:
+    paths-ignore:
+      - '**.md'
+  workflow_dispatch:
+
+jobs:
+  check-dist:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set Node.js 12.x
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12.x
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Rebuild the dist/ directory
+        run: npm run build
+
+      - name: Compare the expected and actual dist/ directories
+        run: |
+          if [ "$(git diff --ignore-space-at-eol dist/ | wc -l)" -gt "0" ]; then
+            echo "Detected uncommitted changes after build.  See status below:"
+            git diff
+            exit 1
+          fi
+        id: diff
+
+      # If index.js was different than expected, upload the expected version as an artifact
+      - uses: actions/upload-artifact@v2
+        if: ${{ failure() && steps.diff.conclusion == 'failure' }}
+        with:
+          name: dist
+          path: dist/

.github/workflows/codeql-analysis.yml

@@ -2,6 +2,7 @@ name: "Code scanning - action"
 
 on:
   push:
+  pull_request:
   schedule:
     - cron: '25 3 * * 5'
 

.github/workflows/e2e-cache.yml

@@ -0,0 +1,109 @@
+name: e2e-cache
+
+on:
+  pull_request:
+    paths-ignore:
+      - '**.md'
+  push:
+    branches:
+      - main
+      - releases/*
+    paths-ignore:
+      - '**.md'
+
+permissions:
+  contents: read
+jobs:
+  python-pip-dependencies-caching:
+    name: Test pip (Python ${{ matrix.python-version}}, ${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ['3.9', 'pypy-3.7-v7.x']
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Python
+        uses: ./
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pip'
+      - name: Install dependencies
+        run: pip install numpy pandas requests
+
+  python-pipenv-dependencies-caching:
+    name: Test pipenv (Python ${{ matrix.python-version}}, ${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ['3.9', 'pypy-3.9-v7.x']
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Python
+        uses: ./
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pipenv'
+      - name: Install pipenv
+        run: curl https://raw.githubusercontent.com/pypa/pipenv/main/get-pipenv.py | python
+      - name: Install dependencies
+        shell: pwsh
+        run: |
+          mv ./__tests__/data/Pipfile.lock .
+          mv ./__tests__/data/Pipfile .
+          if ("${{ matrix.python-version }}" -Match "pypy") {
+            pipenv install --keep-outdated --python pypy
+          } else {
+            pipenv install --keep-outdated --python ${{ matrix.python-version }}
+          }
+
+  python-pip-dependencies-caching-path:
+    name: Test pip (Python ${{ matrix.python-version}}, ${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ['3.9', 'pypy-3.7-v7.x']
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Python
+        uses: ./
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pip'
+          cache-dependency-path: __tests__/data/requirements.txt
+      - name: Install dependencies
+        run: pip install numpy pandas requests
+
+  python-pipenv-dependencies-caching-path:
+    name: Test pipenv (Python ${{ matrix.python-version}}, ${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ['3.9', 'pypy-3.9-v7.x']
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Python
+        uses: ./
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pipenv'
+          cache-dependency-path: '**/pipenv-requirements.txt'
+      - name: Install pipenv
+        run: curl https://raw.githubusercontent.com/pypa/pipenv/main/get-pipenv.py | python
+      - name: Install dependencies
+        shell: pwsh
+        run: |
+          mv ./__tests__/data/Pipfile.lock .
+          mv ./__tests__/data/Pipfile .
+          if ("${{ matrix.python-version }}" -Match "pypy") {
+            pipenv install --keep-outdated --python pypy
+          } else {
+            pipenv install --keep-outdated --python ${{ matrix.python-version }}
+          }

.github/workflows/licensed.yml

@@ -1,8 +1,12 @@
 name: Licensed
 
 on:
-  push: {branches: main}
+  push:
-  pull_request: {branches: main}
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
 
 jobs:
   test:
@@ -10,11 +14,15 @@ jobs:
     name: Check licenses
     steps:
       - uses: actions/checkout@v2
+      - name: Set Node.js 12.x
+        uses: actions/setup-node@v2
+        with:
+          node-version: 12.x
       - run: npm ci
       - name: Install licensed
         run: |
           cd $RUNNER_TEMP
-          curl -Lfs -o licensed.tar.gz https://github.com/github/licensed/releases/download/2.12.2/licensed-2.12.2-linux-x64.tar.gz
+          curl -Lfs -o licensed.tar.gz https://github.com/github/licensed/releases/download/3.3.1/licensed-3.3.1-linux-x64.tar.gz
           sudo tar -xzf licensed.tar.gz
           sudo mv licensed /usr/local/bin/licensed
       - run: licensed status

.github/workflows/release-new-action-version.yml

@@ -0,0 +1,27 @@
+name: Release new action version
+on:
+  release:
+    types: [released]
+  workflow_dispatch:
+    inputs:
+      TAG_NAME:
+        description: 'Tag name that the major tag will point to'
+        required: true
+
+env:
+  TAG_NAME: ${{ github.event.inputs.TAG_NAME || github.event.release.tag_name }}
+permissions:
+  contents: write
+
+jobs:
+  update_tag:
+    name: Update the major tag to include the ${{ github.event.inputs.TAG_NAME || github.event.release.tag_name }} changes
+    environment:
+      name: releaseNewActionVersion
+    runs-on: ubuntu-latest
+    steps:
+    - name: Update the ${{ env.TAG_NAME }} tag
+      uses: actions/publish-action@v0.1.0
+      with:
+        source-tag: ${{ env.TAG_NAME }}
+        slack-webhook: ${{ secrets.SLACK_WEBHOOK }}

.github/workflows/test-pypy.yml

@@ -0,0 +1,46 @@
+name: Validate PyPy e2e
+on: 
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+  pull_request:
+    paths-ignore:
+      - '**.md'
+  schedule:
+    - cron: 30 3 * * *
+
+jobs:
+  setup-pypy:
+    name: Setup PyPy ${{ matrix.pypy }} ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-latest, windows-latest, ubuntu-latest]
+        pypy:
+        - 'pypy-2.7'
+        - 'pypy-3.7'
+        - 'pypy-2.7-v7.3.4'
+        - 'pypy-3.7-v7.3.5'
+        - 'pypy-3.7-v7.3.4'
+        - 'pypy-3.7-v7.3.x'
+        - 'pypy-3.7-v7.x'
+        - 'pypy-2.7-v7.3.4rc1'
+        - 'pypy-3.7-nightly'
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+  
+      - name: setup-python ${{ matrix.pypy }}
+        uses: ./
+        with:
+          python-version: ${{ matrix.pypy }}
+  
+      - name: PyPy and Python version
+        run: python --version
+  
+      - name: Run simple code
+        run: python -c 'import math; print(math.factorial(5))'

.github/workflows/test-python.yml

@@ -1,4 +1,4 @@
-name: Validate 'setup-python'
+name: Validate Python e2e
 on: 
   push:
     branches:
@@ -9,7 +9,7 @@ on:
     paths-ignore:
       - '**.md'
   schedule:
-    - cron: 0 0 * * *
+    - cron: 30 3 * * *
 
 jobs:
   default-version:
@@ -18,7 +18,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-latest, windows-latest, ubuntu-16.04, ubuntu-18.04]
+        os: [macos-latest, windows-latest, ubuntu-20.04]
     steps:
     - name: Checkout
       uses: actions/checkout@v2
@@ -38,7 +38,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-latest, windows-latest, ubuntu-16.04, ubuntu-18.04]
+        os: [macos-latest, windows-latest, ubuntu-20.04]
         python: [3.5.4, 3.6.7, 3.7.5, 3.8.1]
     steps:
     - name: Checkout
@@ -68,7 +68,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-latest, windows-latest, ubuntu-16.04, ubuntu-18.04]
+        os: [macos-latest, windows-latest, ubuntu-20.04]
     steps:
     - name: Checkout
       uses: actions/checkout@v2
@@ -90,3 +90,19 @@ jobs:
 
     - name: Run simple code
       run: python -c 'import math; print(math.factorial(5))'
+
+  setup-pypy-legacy:
+    name: Setup PyPy ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-11, windows-2019, ubuntu-20.04]
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: setup-python pypy3
+      uses: ./
+      with:
+        python-version: 'pypy-3.8'

.github/workflows/workflow.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ${{ matrix.operating-system }}
     strategy:
       matrix:
-        operating-system: [ubuntu-latest, windows-latest]
+        operating-system: [ubuntu-20.04, windows-latest]
     steps:
     - name: Checkout
       uses: actions/checkout@v2

.licensed.yml

@@ -9,6 +9,7 @@ allowed:
   - mit
   - cc0-1.0
   - unlicense
+  - 0bsd
 
 reviewed:
   npm:

README.md

@@ -9,6 +9,7 @@ This action sets up a Python environment for use in actions by:
 - optionally installing and adding to PATH a version of Python that is already installed in the tools cache.
 - downloading, installing and adding to PATH an available version of Python from GitHub Releases ([actions/python-versions](https://github.com/actions/python-versions/releases)) if a specific version is not available in the tools cache.
 - failing if a specific version of Python is not preinstalled or available for download.
+- optionally caching dependencies for pip and pipenv.
 - registering problem matchers for error output.
 
 # What's new
@@ -17,6 +18,8 @@ This action sets up a Python environment for use in actions by:
   - Allows for pinning to a specific patch version of Python without the worry of it ever being removed or changed.
 - Automatic setup and download of Python packages if using a self-hosted runner.
 - Support for pre-release versions of Python.
+- Support for installing any version of PyPy on-flight
+- Support for built-in caching of pip and pipenv dependencies
 
 # Usage
 
@@ -40,11 +43,11 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [ '2.x', '3.x', 'pypy2', 'pypy3' ]
+        python-version: [ '2.x', '3.x', 'pypy-2.7', 'pypy-3.7', 'pypy-3.8' ]
     name: Python ${{ matrix.python-version }} sample
     steps:
       - uses: actions/checkout@v2
-      - name: Setup python
+      - name: Set up Python
         uses: actions/setup-python@v2
         with:
           python-version: ${{ matrix.python-version }}
@@ -60,12 +63,12 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        python-version: [2.7, 3.6, 3.7, 3.8, pypy2, pypy3]
+        python-version: ['2.7', '3.7', '3.8', '3.9', '3.10', 'pypy-2.7', 'pypy-3.8']
         exclude:
           - os: macos-latest
-            python-version: 3.8
+            python-version: '3.8'
           - os: windows-latest
-            python-version: 3.6
+            python-version: '3.6'
     steps:
       - uses: actions/checkout@v2
       - name: Set up Python
@@ -73,7 +76,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
       - name: Display Python version
-        run: python -c "import sys; print(sys.version)"
+        run: python --version
 ```
 
 Download and set up a version of Python that does not come preinstalled on an image:
@@ -84,14 +87,13 @@ jobs:
     strategy:
       matrix:
         # in this example, there is a newer version already installed, 3.7.7, so the older version will be downloaded
-        python-version: [3.5, 3.6, 3.7.4, 3.8]
+        python-version: ['3.7.4', '3.8', '3.9', '3.10']
     steps:
     - uses: actions/checkout@v2
     - uses: actions/setup-python@v2
       with:
         python-version: ${{ matrix.python-version }}
     - run: python my_script.py
-
 ```
 
 Download and set up an accurate pre-release version of Python:
@@ -100,7 +102,7 @@ steps:
 - uses: actions/checkout@v2
 - uses: actions/setup-python@v2
   with:
-    python-version: '3.9.0-beta.4'
+    python-version: '3.11.0-alpha.1'
 - run: python my_script.py
 ```
 
@@ -110,10 +112,31 @@ steps:
 - uses: actions/checkout@v2
 - uses: actions/setup-python@v2
   with:
-    python-version: '3.9.0-alpha - 3.9.0' # SemVer's version range syntax
+    python-version: '3.11.0-alpha - 3.11.0' # SemVer's version range syntax
 - run: python my_script.py
 ```
 
+Download and set up PyPy:
+
+```yaml
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+        - 'pypy-3.7' # the latest available version of PyPy that supports Python 3.7
+        - 'pypy-3.7-v7.3.3' # Python 3.7 and PyPy 7.3.3
+        - 'pypy-3.8' # the latest available version of PyPy that supports Python 3.8
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+    - run: python my_script.py
+```
+More details on PyPy syntax and examples of using preview / nightly versions of PyPy can be found in the [Available versions of PyPy](#available-versions-of-pypy) section.
+
 # Getting started with Python + Actions
 
 Check out our detailed guide on using [Python with GitHub Actions](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/using-python-with-github-actions).
@@ -123,13 +146,27 @@ Check out our detailed guide on using [Python with GitHub Actions](https://help.
 `setup-python` is able to configure Python from two sources:
 
 - Preinstalled versions of Python in the tools cache on GitHub-hosted runners.
-    - For detailed information regarding the available versions of Python that are installed see [Supported software](https://docs.github.com/en/actions/reference/specifications-for-github-hosted-runners#supported-software).
+    - For detailed information regarding the available versions of Python that are installed, see [Supported software](https://docs.github.com/en/actions/reference/specifications-for-github-hosted-runners#supported-software).
     - For every minor version of Python, expect only the latest patch to be preinstalled.
     - If `3.8.1` is installed for example, and `3.8.2` is released, expect `3.8.1` to be removed and replaced by `3.8.2` in the tools cache.
     - If the exact patch version doesn't matter to you, specifying just the major and minor version will get you the latest preinstalled patch version. In the previous example, the version spec `3.8` will use the `3.8.2` Python version found in the cache.
 - Downloadable Python versions from GitHub Releases ([actions/python-versions](https://github.com/actions/python-versions/releases)).
     - All available versions are listed in the [version-manifest.json](https://github.com/actions/python-versions/blob/main/versions-manifest.json) file.
-    - If there is a specific version of Python that is not available, you can open an issue here.
+    - If there is a specific version of Python that is not available, you can open an issue here
+
+ # Available versions of PyPy
+
+ `setup-python` is able to configure PyPy from two sources:
+
+- Preinstalled versions of PyPy in the tools cache on GitHub-hosted runners
+  - For detailed information regarding the available versions of PyPy that are installed, see [Supported software](https://docs.github.com/en/actions/reference/specifications-for-github-hosted-runners#supported-software).
+  - For the latest PyPy release, all versions of Python are cached.
+  - Cache is updated with a 1-2 week delay. If you specify the PyPy version as `pypy-3.7`, the cached version will be used although a newer version is available. If you need to start using the recently released version right after release, you should specify the exact PyPy version using `pypy-3.7-v7.3.3`.
+
+- Downloadable PyPy versions from the [official PyPy site](https://downloads.python.org/pypy/).
+  - All available versions that we can download are listed in [versions.json](https://downloads.python.org/pypy/versions.json) file.
+  - PyPy < 7.3.3 are not available to install on-flight.
+  - If some versions are not available, you can open an issue in https://foss.heptapod.net/pypy/pypy/
 
 # Hosted Tool Cache
 
@@ -156,6 +193,86 @@ You should specify only a major and minor version if you are okay with the most
   - The patch version that will be preinstalled, will generally be the latest and every time there is a new patch released, the older version that is preinstalled will be replaced.
   - Using the most recent patch version will result in a very quick setup since no downloads will be required since a locally installed version Python on the runner will be used.
 
+# Specifying a PyPy version
+The version of PyPy should be specified in the format `pypy-<python_version>[-v<pypy_version>]`.
+The `<pypy_version>` parameter is optional and can be skipped. The latest version will be used in this case.
+
+```
+pypy-3.7 # the latest available version of PyPy that supports Python 3.7
+pypy-3.8 # the latest available version of PyPy that supports Python 3.8
+pypy-2.7 # the latest available version of PyPy that supports Python 2.7
+pypy-3.7-v7.3.3 # Python 3.7 and PyPy 7.3.3
+pypy-3.7-v7.x # Python 3.7 and the latest available PyPy 7.x
+pypy-3.7-v7.3.3rc1 # Python 3.7 and preview version of PyPy
+pypy-3.7-nightly # Python 3.7 and nightly PyPy
+```
+
+# Caching packages dependencies
+
+The action has built-in functionality for caching and restoring dependencies. It uses [actions/cache](https://github.com/actions/toolkit/tree/main/packages/cache) under the hood for caching dependencies but requires less configuration settings. Supported package managers are `pip` and `pipenv`. The `cache` input is optional, and caching is turned off by default.
+
+The action defaults to searching for a dependency file (`requirements.txt` for pip or `Pipfile.lock` for pipenv) in the repository, and uses its hash as a part of the cache key. Use `cache-dependency-path` for cases where multiple dependency files are used, they are located in different subdirectories or different files for the hash want to be used.
+
+ - For pip, the action will cache global cache directory
+ - For pipenv, the action will cache virtualenv directory
+
+**Please Note:** Restored cache will not be used if the requirements.txt file is not updated for a long time and a newer version of the dependency is available that can lead to an increase in total build time.
+
+The requirements file format allows to specify dependency versions using logical operators (for example chardet>=3.0.4) or specify dependencies without any versions. In this case the pip install -r requirements.txt command will always try to install the latest available package version. To be sure that the cache will be used, please stick to a specific dependency version and update it manually if necessary.
+
+**Caching pip dependencies:**  
+
+```yaml
+steps:
+- uses: actions/checkout@v2
+- uses: actions/setup-python@v2
+  with:
+    python-version: '3.9'
+    cache: 'pip'
+- run: pip install -r requirements.txt
+```
+
+**Caching pipenv dependencies:**
+```yaml
+steps:
+- uses: actions/checkout@v2
+- name: Install pipenv
+  run: pipx install pipenv
+- uses: actions/setup-python@v2
+  with:
+    python-version: '3.9'
+    cache: 'pipenv'
+- run: pipenv install
+```
+
+**Using wildcard patterns to cache dependencies**
+```yaml
+steps:
+- uses: actions/checkout@v2
+- uses: actions/setup-python@v2
+  with:
+    python-version: '3.9'
+    cache: 'pip'
+    cache-dependency-path: '**/requirements-dev.txt'
+- run: pip install -r subdirectory/requirements-dev.txt
+```
+
+**Using a list of file paths to cache dependencies**
+```yaml
+steps:
+- uses: actions/checkout@v2
+- name: Install pipenv
+  run: pipx install pipenv
+- uses: actions/setup-python@v2
+  with:
+    python-version: '3.9'
+    cache: 'pipenv'
+    cache-dependency-path: |
+      server/app/Pipfile.lock
+      __test__/app/Pipfile.lock
+- run: pipenv install
+```
+
 # Using `setup-python` with a self hosted runner
 
 Python distributions are only available for the same [environments](https://github.com/actions/virtual-environments#available-environments) that GitHub Actions hosted environments are available for. If you are using an unsupported version of Ubuntu such as `19.04` or another Linux distribution such as Fedora, `setup-python` will not work. If you have a supported self-hosted runner and you would like to use `setup-python`, there are a few extra things you need to make sure are set up so that new versions of Python can be downloaded and configured on your runner.
@@ -183,7 +300,7 @@ If you are experiencing problems while configuring Python on your self-hosted ru
   - The user starting the runner is in the owning group, and the owning group has write permission.
   - All users have write permission.
 - One quick way to grant access is to change the user and group of `/opt/hostedtoolcache` to be the same as the runners using `chown`.
-    - `sudo chown runner-user:runner-group opt/hostedtoolcache/`.
+    - `sudo chown runner-user:runner-group /opt/hostedtoolcache/`.
 - If your runner is configured as a service and you run into problems, make sure the user that the service is running as is correct. For more information, you can [check the status of your self-hosted runner](https://help.github.com/en/actions/hosting-your-own-runners/configuring-the-self-hosted-runner-application-as-a-service#checking-the-status-of-the-service).
 
 ### Mac
@@ -198,6 +315,12 @@ If you are experiencing problems while configuring Python on your self-hosted ru
 
 `setup-python` helps keep your dependencies explicit and ensures consistent behavior between different runners. If you use `python` in a shell on a GitHub hosted runner without `setup-python` it will default to whatever is in PATH. The default version of Python in PATH vary between runners and can change unexpectedly so we recommend you always use `setup-python`.
 
+# Using `setup-python` on GHES
+
+`setup-python` comes pre-installed on the appliance with GHES if Actions is enabled. When dynamically downloading Python distributions, `setup-python` downloads distributions from [`actions/python-versions`](https://github.com/actions/python-versions) on github.com (outside of the appliance). These calls to `actions/python-versions` are made via unauthenticated requests, which are limited to [60 requests per hour per IP](https://docs.github.com/en/rest/overview/resources-in-the-rest-api#rate-limiting). If more requests are made within the time frame, then you will start to see rate-limit errors during download that read `##[error]API rate limit exceeded for...`.
+
+To avoid hitting rate-limit problems, we recommend [setting up your own runner tool cache](https://docs.github.com/en/enterprise-server@2.22/admin/github-actions/managing-access-to-actions-from-githubcom/setting-up-the-tool-cache-on-self-hosted-runners-without-internet-access#about-the-included-setup-actions-and-the-runner-tool-cache).
+
 # License
 
 The scripts and documentation in this project are released under the [MIT License](LICENSE).

__tests__/cache-restore.test.ts

@@ -0,0 +1,172 @@
+import * as core from '@actions/core';
+import * as cache from '@actions/cache';
+import * as exec from '@actions/exec';
+import {getCacheDistributor} from '../src/cache-distributions/cache-factory';
+
+describe('restore-cache', () => {
+  const pipFileLockHash =
+    'a3bdcc71289e4979ca9e051810d81999cc99823109faf6912e17ff14c8e621a6';
+  const requirementsHash =
+    'd8110e0006d7fb5ee76365d565eef9d37df1d11598b912d3eb66d398d57a1121';
+  const requirementsLinuxHash =
+    '2d0ff7f46b0e120e3d3294db65768b474934242637b9899b873e6283dfd16d7c';
+
+  // core spy
+  let infoSpy: jest.SpyInstance;
+  let warningSpy: jest.SpyInstance;
+  let debugSpy: jest.SpyInstance;
+  let saveSatetSpy: jest.SpyInstance;
+  let getStateSpy: jest.SpyInstance;
+
+  // cache spy
+  let restoreCacheSpy: jest.SpyInstance;
+
+  // exec spy
+  let getExecOutputSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    process.env['RUNNER_OS'] = process.env['RUNNER_OS'] ?? 'linux';
+
+    infoSpy = jest.spyOn(core, 'info');
+    infoSpy.mockImplementation(input => undefined);
+
+    warningSpy = jest.spyOn(core, 'warning');
+    warningSpy.mockImplementation(input => undefined);
+
+    debugSpy = jest.spyOn(core, 'debug');
+    debugSpy.mockImplementation(input => undefined);
+
+    saveSatetSpy = jest.spyOn(core, 'saveState');
+    saveSatetSpy.mockImplementation(input => undefined);
+
+    getStateSpy = jest.spyOn(core, 'getState');
+    getStateSpy.mockImplementation(input => undefined);
+
+    getExecOutputSpy = jest.spyOn(exec, 'getExecOutput');
+    getExecOutputSpy.mockImplementation((input: string) => {
+      if (input.includes('pip')) {
+        return {stdout: 'pip', stderr: '', exitCode: 0};
+      }
+
+      return {stdout: '', stderr: 'Error occured', exitCode: 2};
+    });
+
+    restoreCacheSpy = jest.spyOn(cache, 'restoreCache');
+    restoreCacheSpy.mockImplementation(
+      (cachePaths: string[], primaryKey: string, restoreKey?: string) => {
+        return primaryKey;
+      }
+    );
+  });
+
+  describe('Validate provided package manager', () => {
+    it.each(['npm', 'pip2', 'pip21', 'pip21.3', 'pipenv32'])(
+      'Throw an error because %s is not supported',
+      async packageManager => {
+        expect(() =>
+          getCacheDistributor(packageManager, '3.8.12', undefined)
+        ).toThrowError(`Caching for '${packageManager}' is not supported`);
+      }
+    );
+  });
+
+  describe('Restore dependencies', () => {
+    it.each([
+      ['pip', '3.8.12', undefined, requirementsHash],
+      ['pip', '3.8.12', '**/requirements-linux.txt', requirementsLinuxHash],
+      [
+        'pip',
+        '3.8.12',
+        '__tests__/data/requirements-linux.txt',
+        requirementsLinuxHash
+      ],
+      ['pip', '3.8.12', '__tests__/data/requirements.txt', requirementsHash],
+      ['pipenv', '3.9.1', undefined, pipFileLockHash],
+      ['pipenv', '3.9.12', '__tests__/data/requirements.txt', requirementsHash]
+    ])(
+      'restored dependencies for %s by primaryKey',
+      async (packageManager, pythonVersion, dependencyFile, fileHash) => {
+        const cacheDistributor = await getCacheDistributor(
+          packageManager,
+          pythonVersion,
+          dependencyFile
+        );
+        await cacheDistributor.restoreCache();
+
+        expect(infoSpy).toHaveBeenCalledWith(
+          `Cache restored from key: setup-python-${process.env['RUNNER_OS']}-python-${pythonVersion}-${packageManager}-${fileHash}`
+        );
+      },
+      30000
+    );
+
+    it.each([
+      ['pip', '3.8.12', 'requirements-linux.txt', 'requirements-linux.txt'],
+      ['pip', '3.8.12', 'requirements.txt', 'requirements.txt'],
+      ['pipenv', '3.9.12', 'requirements.txt', 'requirements.txt']
+    ])(
+      'Should throw an error because dependency file is not found',
+      async (
+        packageManager,
+        pythonVersion,
+        dependencyFile,
+        cacheDependencyPath
+      ) => {
+        const cacheDistributor = await getCacheDistributor(
+          packageManager,
+          pythonVersion,
+          dependencyFile
+        );
+        await expect(cacheDistributor.restoreCache()).rejects.toThrowError(
+          `No file in ${process.cwd()} matched to [${cacheDependencyPath
+            .split('\n')
+            .join(',')}], make sure you have checked out the target repository`
+        );
+      }
+    );
+  });
+
+  describe('Dependencies changed', () => {
+    it.each([
+      ['pip', '3.8.12', undefined, pipFileLockHash],
+      ['pip', '3.8.12', '**/requirements-linux.txt', pipFileLockHash],
+      [
+        'pip',
+        '3.8.12',
+        '__tests__/data/requirements-linux.txt',
+        pipFileLockHash
+      ],
+      ['pip', '3.8.12', '__tests__/data/requirements.txt', pipFileLockHash],
+      ['pipenv', '3.9.1', undefined, requirementsHash],
+      ['pipenv', '3.9.12', '__tests__/data/requirements.txt', requirementsHash]
+    ])(
+      'restored dependencies for %s by primaryKey',
+      async (packageManager, pythonVersion, dependencyFile, fileHash) => {
+        restoreCacheSpy.mockImplementation(
+          (cachePaths: string[], primaryKey: string, restoreKey?: string) => {
+            return primaryKey !== fileHash && restoreKey ? pipFileLockHash : '';
+          }
+        );
+        const cacheDistributor = await getCacheDistributor(
+          packageManager,
+          pythonVersion,
+          dependencyFile
+        );
+        await cacheDistributor.restoreCache();
+        let result = '';
+        if (packageManager !== 'pipenv') {
+          result = `Cache restored from key: ${fileHash}`;
+        } else {
+          result = 'pipenv cache is not found';
+        }
+
+        expect(infoSpy).toHaveBeenCalledWith(result);
+      }
+    );
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+    jest.clearAllMocks();
+  });
+});

__tests__/cache-save.test.ts

@@ -0,0 +1,178 @@
+import * as core from '@actions/core';
+import * as cache from '@actions/cache';
+import * as exec from '@actions/exec';
+import {run} from '../src/cache-save';
+import {State} from '../src/cache-distributions/cache-distributor';
+
+describe('run', () => {
+  const pipFileLockHash =
+    '67d817abcde9c72da0ed5b8f235647cb14638b9ff9d742b42e4406d2eb16fe3c';
+  const requirementsHash =
+    'd8110e0006d7fb5ee76365d565eef9d37df1d11598b912d3eb66d398d57a1121';
+  const requirementsLinuxHash =
+    '2d0ff7f46b0e120e3d3294db65768b474934242637b9899b873e6283dfd16d7c';
+
+  // core spy
+  let infoSpy: jest.SpyInstance;
+  let warningSpy: jest.SpyInstance;
+  let debugSpy: jest.SpyInstance;
+  let saveSatetSpy: jest.SpyInstance;
+  let getStateSpy: jest.SpyInstance;
+  let getInputSpy: jest.SpyInstance;
+  let setFailedSpy: jest.SpyInstance;
+
+  // cache spy
+  let saveCacheSpy: jest.SpyInstance;
+
+  // exec spy
+  let getExecOutputSpy: jest.SpyInstance;
+
+  let inputs = {} as any;
+
+  beforeEach(() => {
+    process.env['RUNNER_OS'] = process.env['RUNNER_OS'] ?? 'linux';
+
+    infoSpy = jest.spyOn(core, 'info');
+    infoSpy.mockImplementation(input => undefined);
+
+    warningSpy = jest.spyOn(core, 'warning');
+    warningSpy.mockImplementation(input => undefined);
+
+    debugSpy = jest.spyOn(core, 'debug');
+    debugSpy.mockImplementation(input => undefined);
+
+    saveSatetSpy = jest.spyOn(core, 'saveState');
+    saveSatetSpy.mockImplementation(input => undefined);
+
+    getStateSpy = jest.spyOn(core, 'getState');
+    getStateSpy.mockImplementation(input => {
+      if (input === State.CACHE_PATHS) {
+        return JSON.stringify([__dirname]);
+      }
+      return requirementsHash;
+    });
+
+    setFailedSpy = jest.spyOn(core, 'setFailed');
+
+    getInputSpy = jest.spyOn(core, 'getInput');
+    getInputSpy.mockImplementation(input => inputs[input]);
+
+    getExecOutputSpy = jest.spyOn(exec, 'getExecOutput');
+    getExecOutputSpy.mockImplementation((input: string) => {
+      if (input.includes('pip')) {
+        return {stdout: 'pip', stderr: '', exitCode: 0};
+      }
+
+      return {stdout: '', stderr: 'Error occured', exitCode: 2};
+    });
+
+    saveCacheSpy = jest.spyOn(cache, 'saveCache');
+    saveCacheSpy.mockImplementation(() => undefined);
+  });
+
+  describe('Package manager validation', () => {
+    it('Package manager is not provided, skip caching', async () => {
+      inputs['cache'] = '';
+      await run();
+
+      expect(getInputSpy).toHaveBeenCalled();
+      expect(infoSpy).not.toHaveBeenCalled();
+      expect(saveCacheSpy).not.toHaveBeenCalled();
+      expect(setFailedSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Validate unchanged cache is not saved', () => {
+    it('should not save cache for pip', async () => {
+      inputs['cache'] = 'pip';
+
+      await run();
+
+      expect(getInputSpy).toHaveBeenCalled();
+      expect(debugSpy).toHaveBeenCalledWith(
+        `paths for caching are ${__dirname}`
+      );
+      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(infoSpy).toHaveBeenCalledWith(
+        `Cache hit occurred on the primary key ${requirementsHash}, not saving cache.`
+      );
+      expect(setFailedSpy).not.toHaveBeenCalled();
+    });
+
+    it('should not save cache for pipenv', async () => {
+      inputs['cache'] = 'pipenv';
+
+      await run();
+
+      expect(getInputSpy).toHaveBeenCalled();
+      expect(debugSpy).toHaveBeenCalledWith(
+        `paths for caching are ${__dirname}`
+      );
+      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(infoSpy).toHaveBeenCalledWith(
+        `Cache hit occurred on the primary key ${requirementsHash}, not saving cache.`
+      );
+      expect(setFailedSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('action saves the cache', () => {
+    it('saves cache from pip', async () => {
+      inputs['cache'] = 'pip';
+      getStateSpy.mockImplementation((name: string) => {
+        if (name === State.CACHE_MATCHED_KEY) {
+          return requirementsHash;
+        } else if (name === State.CACHE_PATHS) {
+          return JSON.stringify([__dirname]);
+        } else {
+          return pipFileLockHash;
+        }
+      });
+
+      await run();
+
+      expect(getInputSpy).toHaveBeenCalled();
+      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(infoSpy).not.toHaveBeenCalledWith(
+        `Cache hit occurred on the primary key ${requirementsHash}, not saving cache.`
+      );
+      expect(saveCacheSpy).toHaveBeenCalled();
+      expect(infoSpy).toHaveBeenLastCalledWith(
+        `Cache saved with the key: ${pipFileLockHash}`
+      );
+      expect(setFailedSpy).not.toHaveBeenCalled();
+    });
+
+    it('saves cache from pipenv', async () => {
+      inputs['cache'] = 'pipenv';
+      getStateSpy.mockImplementation((name: string) => {
+        if (name === State.CACHE_MATCHED_KEY) {
+          return pipFileLockHash;
+        } else if (name === State.CACHE_PATHS) {
+          return JSON.stringify([__dirname]);
+        } else {
+          return requirementsHash;
+        }
+      });
+
+      await run();
+
+      expect(getInputSpy).toHaveBeenCalled();
+      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(infoSpy).not.toHaveBeenCalledWith(
+        `Cache hit occurred on the primary key ${pipFileLockHash}, not saving cache.`
+      );
+      expect(saveCacheSpy).toHaveBeenCalled();
+      expect(infoSpy).toHaveBeenLastCalledWith(
+        `Cache saved with the key: ${requirementsHash}`
+      );
+      expect(setFailedSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+    jest.clearAllMocks();
+    inputs = {};
+  });
+});

__tests__/data/Pipfile

@@ -0,0 +1,13 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+flake8 = "==4.0.1"
+numpy = "==1.23.0"
+
+[dev-packages]
+
+[requires]
+python_version = "*"

__tests__/data/Pipfile.lock

@@ -0,0 +1,80 @@
+{
+    "_meta": {
+        "hash": {
+            "sha256": "e9c37110984955621040e2dc8548c026eb8466c23db1b8e69430289b10be8938"
+        },
+        "pipfile-spec": 6,
+        "requires": {
+            "python_version": "*"
+        },
+        "sources": [
+            {
+                "name": "pypi",
+                "url": "https://pypi.org/simple",
+                "verify_ssl": true
+            }
+        ]
+    },
+    "default": {
+        "flake8": {
+            "hashes": [
+                "sha256:479b1304f72536a55948cb40a32dce8bb0ffe3501e26eaf292c7e60eb5e0428d",
+                "sha256:806e034dda44114815e23c16ef92f95c91e4c71100ff52813adf7132a6ad870d"
+            ],
+            "index": "pypi",
+            "version": "==4.0.1"
+        },
+        "mccabe": {
+            "hashes": [
+                "sha256:ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42",
+                "sha256:dd8d182285a0fe56bace7f45b5e7d1a6ebcbf524e8f3bd87eb0f125271b8831f"
+            ],
+            "version": "==0.6.1"
+        },
+        "numpy": {
+            "hashes": [
+                "sha256:092f5e6025813e64ad6d1b52b519165d08c730d099c114a9247c9bb635a2a450",
+                "sha256:196cd074c3f97c4121601790955f915187736f9cf458d3ee1f1b46aff2b1ade0",
+                "sha256:1c29b44905af288b3919803aceb6ec7fec77406d8b08aaa2e8b9e63d0fe2f160",
+                "sha256:2b2da66582f3a69c8ce25ed7921dcd8010d05e59ac8d89d126a299be60421171",
+                "sha256:5043bcd71fcc458dfb8a0fc5509bbc979da0131b9d08e3d5f50fb0bbb36f169a",
+                "sha256:58bfd40eb478f54ff7a5710dd61c8097e169bc36cc68333d00a9bcd8def53b38",
+                "sha256:79a506cacf2be3a74ead5467aee97b81fca00c9c4c8b3ba16dbab488cd99ba10",
+                "sha256:94b170b4fa0168cd6be4becf37cb5b127bd12a795123984385b8cd4aca9857e5",
+                "sha256:97a76604d9b0e79f59baeca16593c711fddb44936e40310f78bfef79ee9a835f",
+                "sha256:98e8e0d8d69ff4d3fa63e6c61e8cfe2d03c29b16b58dbef1f9baa175bbed7860",
+                "sha256:ac86f407873b952679f5f9e6c0612687e51547af0e14ddea1eedfcb22466babd",
+                "sha256:ae8adff4172692ce56233db04b7ce5792186f179c415c37d539c25de7298d25d",
+                "sha256:bd3fa4fe2e38533d5336e1272fc4e765cabbbde144309ccee8675509d5cd7b05",
+                "sha256:d0d2094e8f4d760500394d77b383a1b06d3663e8892cdf5df3c592f55f3bff66",
+                "sha256:d54b3b828d618a19779a84c3ad952e96e2c2311b16384e973e671aa5be1f6187",
+                "sha256:d6ca8dabe696c2785d0c8c9b0d8a9b6e5fdbe4f922bde70d57fa1a2848134f95",
+                "sha256:d8cc87bed09de55477dba9da370c1679bd534df9baa171dd01accbb09687dac3",
+                "sha256:f0f18804df7370571fb65db9b98bf1378172bd4e962482b857e612d1fec0f53e",
+                "sha256:f1d88ef79e0a7fa631bb2c3dda1ea46b32b1fe614e10fedd611d3d5398447f2f",
+                "sha256:f9c3fc2adf67762c9fe1849c859942d23f8d3e0bee7b5ed3d4a9c3eeb50a2f07",
+                "sha256:fc431493df245f3c627c0c05c2bd134535e7929dbe2e602b80e42bf52ff760bc",
+                "sha256:fe8b9683eb26d2c4d5db32cd29b38fdcf8381324ab48313b5b69088e0e355379"
+            ],
+            "index": "pypi",
+            "version": "==1.23.0"
+        },
+        "pycodestyle": {
+            "hashes": [
+                "sha256:720f8b39dde8b293825e7ff02c475f3077124006db4f440dcbc9a20b76548a20",
+                "sha256:eddd5847ef438ea1c7870ca7eb78a9d47ce0cdb4851a5523949f2601d0cbbe7f"
+            ],
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4'",
+            "version": "==2.8.0"
+        },
+        "pyflakes": {
+            "hashes": [
+                "sha256:05a85c2872edf37a4ed30b0cce2f6093e1d0581f8c19d7393122da7e25b2b24c",
+                "sha256:3bb3a3f256f4b7968c9c788781e4ff07dce46bdf12339dcda61053375426ee2e"
+            ],
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "version": "==2.4.0"
+        }
+    },
+    "develop": {}
+}

__tests__/data/pipenv-requirements.txt

@@ -0,0 +1,2 @@
+numpy==1.22.3
+pandas==1.4.2

__tests__/data/pypy.json

@@ -0,0 +1,533 @@
+[
+  {
+    "pypy_version": "7.3.3",
+    "python_version": "3.6.12",
+    "stable": true,
+    "latest_pypy": true,
+    "date": "2020-11-21",
+    "files": [
+      {
+        "filename": "pypy3.6-v7.3.3-aarch64.tar.bz2",
+        "arch": "aarch64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.3-aarch64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.6-v7.3.3-linux32.tar.bz2",
+        "arch": "i686",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.3-linux32.tar.bz2"
+      },
+      {
+        "filename": "pypy3.6-v7.3.3-linux64.tar.bz2",
+        "arch": "x64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.3-linux64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.6-v7.3.3-darwin64.tar.bz2",
+        "arch": "x64",
+        "platform": "darwin",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.3-darwin64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.6-v7.3.3-win32.zip",
+        "arch": "x86",
+        "platform": "win32",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.3-win32.zip"
+      },
+      {
+        "filename": "pypy3.6-v7.3.3-s390x.tar.bz2",
+        "arch": "s390x",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.3-s390x.tar.bz2"
+      }
+    ]
+  },
+  {
+    "pypy_version": "7.3.3rc1",
+    "python_version": "3.6.12",
+    "stable": false,
+    "latest_pypy": false,
+    "date": "2020-11-11",
+    "files": [
+      {
+        "filename": "pypy3.6-v7.3.3rc1-aarch64.tar.bz2",
+        "arch": "aarch64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.3rc1-aarch64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.6-v7.3.3-linux32rc1.tar.bz2",
+        "arch": "i686",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.3rc1-linux32.tar.bz2"
+      },
+      {
+        "filename": "pypy3.6-v7.3.3rc1-linux64.tar.bz2",
+        "arch": "x64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.3rc1-linux64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.6-v7.3.3rc1-osx64.tar.bz2",
+        "arch": "x64",
+        "platform": "darwin",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.3rc1-osx64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.6-v7.3.3-win32rc1.zip",
+        "arch": "x86",
+        "platform": "win32",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.3rc1-win32.zip"
+      },
+      {
+        "filename": "pypy3.6-v7.3.3rc1-s390x.tar.bz2",
+        "arch": "s390x",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.3rc1-s390x.tar.bz2"
+      }
+    ]
+  },
+  {
+    "pypy_version": "7.3.4rc1",
+    "python_version": "2.7.18",
+    "stable": false,
+    "latest_pypy": false,
+    "date": "2021-03-19",
+    "files": [
+      {
+        "filename": "pypy2.7-v7.3.4rc1-aarch64.tar.bz2",
+        "arch": "aarch64",
+        "platform": "linux",
+        "download_url": "https://test.downloads.python.org/pypy/pypy2.7-v7.3.4rc1-aarch64.tar.bz2"
+      },
+      {
+        "filename": "pypy2.7-v7.3.4rc1-linux32.tar.bz2",
+        "arch": "i686",
+        "platform": "linux",
+        "download_url": "https://test.downloads.python.org/pypy/pypy2.7-v7.3.4rc1-linux32.tar.bz2"
+      },
+      {
+        "filename": "pypy2.7-v7.3.4rc1-linux64.tar.bz2",
+        "arch": "x64",
+        "platform": "linux",
+        "download_url": "https://test.downloads.python.org/pypy/pypy2.7-v7.3.4rc1-linux64.tar.bz2"
+      },
+      {
+        "filename": "pypy2.7-v7.3.4rc1-osx64.tar.bz2",
+        "arch": "x64",
+        "platform": "darwin",
+        "download_url": "https://test.downloads.python.org/pypy/pypy2.7-v7.3.4rc1-osx64.tar.bz2"
+      },
+      {
+        "filename": "pypy2.7-v7.3.4rc1-win64.zip",
+        "arch": "x64",
+        "platform": "win64",
+        "download_url": "https://test.downloads.python.org/pypy/pypy2.7-v7.3.4rc1-win64.zip"
+      }
+    ]
+  },
+  {
+    "pypy_version": "7.3.3rc2",
+    "python_version": "3.7.7",
+    "stable": false,
+    "latest_pypy": false,
+    "date": "2020-11-11",
+    "files": [
+      {
+        "filename": "test.tar.bz2",
+        "arch": "aarch64",
+        "platform": "linux",
+        "download_url": "test.tar.bz2"
+      },
+      {
+        "filename": "test.tar.bz2",
+        "arch": "i686",
+        "platform": "linux",
+        "download_url": "test.tar.bz2"
+      },
+      {
+        "filename": "test.tar.bz2",
+        "arch": "x64",
+        "platform": "linux",
+        "download_url": "test.tar.bz2"
+      },
+      {
+        "filename": "test.tar.bz2",
+        "arch": "x64",
+        "platform": "darwin",
+        "download_url": "test.tar.bz2"
+      },
+      {
+        "filename": "test.zip",
+        "arch": "x86",
+        "platform": "win32",
+        "download_url": "test.zip"
+      },
+      {
+        "filename": "test.tar.bz2",
+        "arch": "s390x",
+        "platform": "linux",
+        "download_url": "test.tar.bz2"
+      }
+    ]
+  },
+  {
+    "pypy_version": "7.3.3",
+    "python_version": "3.7.9",
+    "stable": true,
+    "latest_pypy": true,
+    "date": "2020-11-21",
+    "files": [
+      {
+        "filename": "pypy3.7-v7.3.3-aarch64.tar.bz2",
+        "arch": "aarch64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.7-v7.3.3-aarch64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.7-v7.3.3-linux32.tar.bz2",
+        "arch": "i686",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.7-v7.3.3-linux32.tar.bz2"
+      },
+      {
+        "filename": "pypy3.7-v7.3.3-linux64.tar.bz2",
+        "arch": "x64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.7-v7.3.3-linux64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.7-v7.3.3-osx64.tar.bz2",
+        "arch": "x64",
+        "platform": "darwin",
+        "download_url": "https://test.download.python.org/pypy/pypy3.7-v7.3.3-osx64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.7-v7.3.3-win32.zip",
+        "arch": "x86",
+        "platform": "win32",
+        "download_url": "https://test.download.python.org/pypy/pypy3.7-v7.3.3-win32.zip"
+      },
+      {
+        "filename": "pypy3.7-v7.3.3-s390x.tar.bz2",
+        "arch": "s390x",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.7-v7.3.3-s390x.tar.bz2"
+      }
+    ]
+  },
+  {
+    "pypy_version": "7.3.3",
+    "python_version": "2.7.18",
+    "stable": true,
+    "latest_pypy": true,
+    "date": "2020-11-21",
+    "files": [
+      {
+        "filename": "pypy2.7-v7.3.3-aarch64.tar.bz2",
+        "arch": "aarch64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy2.7-v7.3.3-aarch64.tar.bz2"
+      },
+      {
+        "filename": "pypy2.7-v7.3.3-linux32.tar.bz2",
+        "arch": "i686",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy2.7-v7.3.3-linux32.tar.bz2"
+      },
+      {
+        "filename": "pypy2.7-v7.3.3-linux64.tar.bz2",
+        "arch": "x64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy2.7-v7.3.3-linux64.tar.bz2"
+      },
+      {
+        "filename": "pypy2.7-v7.3.3-osx64.tar.bz2",
+        "arch": "x64",
+        "platform": "darwin",
+        "download_url": "https://test.download.python.org/pypy/pypy2.7-v7.3.3-osx64.tar.bz2"
+      },
+      {
+        "filename": "pypy2.7-v7.3.3-win32.zip",
+        "arch": "x86",
+        "platform": "win32",
+        "download_url": "https://test.download.python.org/pypy/pypy2.7-v7.3.3-win32.zip"
+      },
+      {
+        "filename": "pypy2.7-v7.3.3-s390x.tar.bz2",
+        "arch": "s390x",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy2.7-v7.3.3-s390x.tar.bz2"
+      }
+    ]
+  },
+  {
+    "pypy_version": "7.3.2",
+    "python_version": "3.6.9",
+    "stable": true,
+    "latest_pypy": true,
+    "date": "2020-09-25",
+    "files": [
+      {
+        "filename": "pypy3.6-v7.3.2-aarch64.tar.bz2",
+        "arch": "aarch64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.2-aarch64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.6-v7.3.2-linux32.tar.bz2",
+        "arch": "i686",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.2-linux32.tar.bz2"
+      },
+      {
+        "filename": "pypy3.6-v7.3.2-linux64.tar.bz2",
+        "arch": "x64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.2-linux64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.6-v7.3.2-osx64.tar.bz2",
+        "arch": "x64",
+        "platform": "darwin",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.2-osx64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.6-v7.3.2-win32.zip",
+        "arch": "x86",
+        "platform": "win32",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.2-win32.zip"
+      },
+      {
+        "filename": "pypy3.6-v7.3.2-s390x.tar.bz2",
+        "arch": "s390x",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.6-v7.3.2-s390x.tar.bz2"
+      }
+    ]
+  },
+  {
+    "pypy_version": "7.3.2",
+    "python_version": "3.7.9",
+    "stable": true,
+    "latest_pypy": false,
+    "date": "2020-09-25",
+    "files": [
+      {
+        "filename": "pypy3.7-v7.3.2-aarch64.tar.bz2",
+        "arch": "aarch64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.7-v7.3.2-aarch64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.7-v7.3.2-linux32.tar.bz2",
+        "arch": "i686",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.7-v7.3.2-linux32.tar.bz2"
+      },
+      {
+        "filename": "pypy3.7-v7.3.2-linux64.tar.bz2",
+        "arch": "x64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.7-v7.3.2-linux64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.7-v7.3.2-osx64.tar.bz2",
+        "arch": "x64",
+        "platform": "darwin",
+        "download_url": "https://test.download.python.org/pypy/pypy3.7-v7.3.2-osx64.tar.bz2"
+      },
+      {
+        "filename": "pypy3.7-v7.3.2-win32.zip",
+        "arch": "x86",
+        "platform": "win32",
+        "download_url": "https://test.download.python.org/pypy/pypy3.7-v7.3.2-win32.zip"
+      },
+      {
+        "filename": "pypy3.7-v7.3.2-s390x.tar.bz2",
+        "arch": "s390x",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy3.7-v7.3.2-s390x.tar.bz2"
+      }
+    ]
+  },
+  {
+    "pypy_version": "7.3.2",
+    "python_version": "2.7.13",
+    "stable": true,
+    "latest_pypy": true,
+    "date": "2020-09-25",
+    "files": [
+      {
+        "filename": "pypy2.7-v7.3.2-aarch64.tar.bz2",
+        "arch": "aarch64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy2.7-v7.3.2-aarch64.tar.bz2"
+      },
+      {
+        "filename": "pypy2.7-v7.3.2-linux32.tar.bz2",
+        "arch": "i686",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy2.7-v7.3.2-linux32.tar.bz2"
+      },
+      {
+        "filename": "pypy2.7-v7.3.2-linux64.tar.bz2",
+        "arch": "x64",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy2.7-v7.3.2-linux64.tar.bz2"
+      },
+      {
+        "filename": "pypy2.7-v7.3.2-osx64.tar.bz2",
+        "arch": "x64",
+        "platform": "darwin",
+        "download_url": "https://test.download.python.org/pypy/pypy2.7-v7.3.2-osx64.tar.bz2"
+      },
+      {
+        "filename": "pypy2.7-v7.3.2-win32.zip",
+        "arch": "x86",
+        "platform": "win32",
+        "download_url": "https://test.download.python.org/pypy/pypy2.7-v7.3.2-win32.zip"
+      },
+      {
+        "filename": "pypy2.7-v7.3.2-s390x.tar.bz2",
+        "arch": "s390x",
+        "platform": "linux",
+        "download_url": "https://test.download.python.org/pypy/pypy2.7-v7.3.2-s390x.tar.bz2"
+      }
+    ]
+  },
+  {
+    "pypy_version": "nightly",
+    "python_version": "2.7",
+    "stable": false,
+    "latest_pypy": false,
+    "files": [
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "aarch64",
+        "platform": "linux",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      },
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "i686",
+        "platform": "linux",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      },
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "x64",
+        "platform": "linux",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      },
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "x64",
+        "platform": "darwin",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      },
+      {
+        "filename": "filename.zip",
+        "arch": "x86",
+        "platform": "win32",
+        "download_url": "http://nightlyBuilds.org/filename.zip"
+      },
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "s390x",
+        "platform": "linux",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      }
+    ]
+  },
+  {
+    "pypy_version": "nightly",
+    "python_version": "3.7",
+    "stable": false,
+    "latest_pypy": false,
+    "files": [
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "aarch64",
+        "platform": "linux",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      },
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "i686",
+        "platform": "linux",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      },
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "x64",
+        "platform": "linux",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      },
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "x64",
+        "platform": "darwin",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      },
+      {
+        "filename": "filename.zip",
+        "arch": "x86",
+        "platform": "win32",
+        "download_url": "http://nightlyBuilds.org/filename.zip"
+      },
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "s390x",
+        "platform": "linux",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      }
+    ]
+  },
+  {
+    "pypy_version": "nightly",
+    "python_version": "3.6",
+    "stable": false,
+    "latest_pypy": false,
+    "files": [
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "aarch64",
+        "platform": "linux",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      },
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "i686",
+        "platform": "linux",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      },
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "x64",
+        "platform": "linux",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      },
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "x64",
+        "platform": "darwin",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      },
+      {
+        "filename": "filename.zip",
+        "arch": "x86",
+        "platform": "win32",
+        "download_url": "http://nightlyBuilds.org/filename.zip"
+      },
+      {
+        "filename": "filename.tar.bz2",
+        "arch": "s390x",
+        "platform": "linux",
+        "download_url": "http://nightlyBuilds.org/filename.tar.bz2"
+      }
+    ]
+  }
+]

__tests__/data/requirements-linux.txt

@@ -0,0 +1,12 @@
+certifi==2020.6.20
+chardet==3.0.4
+docutils==0.16
+idna==2.10
+Kivy==2.0.0rc3
+Kivy-Garden==0.1.4
+packaging==20.7
+pdf2image==1.12.1
+Pygments==2.6.1
+requests==2.24.0
+urllib3==1.25.10
+xlrd==1.2.0

__tests__/data/requirements.txt

@@ -0,0 +1,47 @@
+altgraph==0.17.2
+
+certifi==2020.6.20
+
+chardet==3.0.4
+
+docutils==0.16
+
+future==0.18.2; python_version >= '2.6' and python_version not in '3.0, 3.1, 3.2'
+
+idna==2.9
+
+itsdangerous==1.1.0
+
+kivy-deps-angle==0.3.0
+
+kivy-deps.glew==0.1.12
+
+kivy-deps.gstreamer==0.1.17
+
+kivy-deps.sdl2==0.1.22
+
+kivy-garden==0.1.4
+
+kivy==1.11.1
+
+packaging==21.0
+
+pdf2image==1.12.1
+
+pefile==2021.9.3; python_full_version >= '3.6.0'
+
+pillow==7.2
+
+pygments==2.6.1
+
+pyinstaller==3.6
+
+pyparsing==2.4.7; python_version >= '2.6' and python_version not in '3.0, 3.1, 3.2'
+
+pywin32-ctypes==0.2.0
+
+requests==2.24.0
+
+urllib3==1.25.9
+
+xlrd==1.2.0

__tests__/find-pypy.test.ts

@@ -0,0 +1,237 @@
+import fs from 'fs';
+
+import * as utils from '../src/utils';
+import {HttpClient} from '@actions/http-client';
+import * as ifm from '@actions/http-client/interfaces';
+import * as tc from '@actions/tool-cache';
+import * as exec from '@actions/exec';
+
+import * as path from 'path';
+import * as semver from 'semver';
+
+import * as finder from '../src/find-pypy';
+import {
+  IPyPyManifestRelease,
+  IS_WINDOWS,
+  validateVersion,
+  getPyPyVersionFromPath
+} from '../src/utils';
+
+const manifestData = require('./data/pypy.json');
+
+let architecture: string;
+
+if (IS_WINDOWS) {
+  architecture = 'x86';
+} else {
+  architecture = 'x64';
+}
+
+const toolDir = path.join(__dirname, 'runner', 'tools');
+const tempDir = path.join(__dirname, 'runner', 'temp');
+
+describe('parsePyPyVersion', () => {
+  it.each([
+    ['pypy-3.6-v7.3.3', {pythonVersion: '3.6', pypyVersion: 'v7.3.3'}],
+    ['pypy-3.6-v7.3.x', {pythonVersion: '3.6', pypyVersion: 'v7.3.x'}],
+    ['pypy-3.6-v7.x', {pythonVersion: '3.6', pypyVersion: 'v7.x'}],
+    ['pypy-3.6', {pythonVersion: '3.6', pypyVersion: 'x'}],
+    ['pypy-3.6-nightly', {pythonVersion: '3.6', pypyVersion: 'nightly'}],
+    ['pypy-3.6-v7.3.3rc1', {pythonVersion: '3.6', pypyVersion: 'v7.3.3-rc.1'}]
+  ])('%s -> %s', (input, expected) => {
+    expect(finder.parsePyPyVersion(input)).toEqual(expected);
+  });
+
+  it('throw on invalid input', () => {
+    expect(() => finder.parsePyPyVersion('pypy-')).toThrowError(
+      "Invalid 'version' property for PyPy. PyPy version should be specified as 'pypy-<python-version>'. See README for examples and documentation."
+    );
+  });
+});
+
+describe('getPyPyVersionFromPath', () => {
+  it('/fake/toolcache/PyPy/3.6.5/x64 -> 3.6.5', () => {
+    expect(getPyPyVersionFromPath('/fake/toolcache/PyPy/3.6.5/x64')).toEqual(
+      '3.6.5'
+    );
+  });
+});
+
+describe('findPyPyToolCache', () => {
+  const actualPythonVersion = '3.6.17';
+  const actualPyPyVersion = '7.5.4';
+  const pypyPath = path.join('PyPy', actualPythonVersion, architecture);
+  let tcFind: jest.SpyInstance;
+  let spyReadExactPyPyVersion: jest.SpyInstance;
+
+  beforeEach(() => {
+    tcFind = jest.spyOn(tc, 'find');
+    tcFind.mockImplementation((toolname: string, pythonVersion: string) => {
+      const semverVersion = new semver.Range(pythonVersion);
+      return semver.satisfies(actualPythonVersion, semverVersion)
+        ? pypyPath
+        : '';
+    });
+
+    spyReadExactPyPyVersion = jest.spyOn(utils, 'readExactPyPyVersionFile');
+    spyReadExactPyPyVersion.mockImplementation(() => actualPyPyVersion);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+  });
+
+  it('PyPy exists on the path and versions are satisfied', () => {
+    expect(finder.findPyPyToolCache('3.6.17', 'v7.5.4', architecture)).toEqual({
+      installDir: pypyPath,
+      resolvedPythonVersion: actualPythonVersion,
+      resolvedPyPyVersion: actualPyPyVersion
+    });
+  });
+
+  it('PyPy exists on the path and versions are satisfied with semver', () => {
+    expect(finder.findPyPyToolCache('3.6', 'v7.5.x', architecture)).toEqual({
+      installDir: pypyPath,
+      resolvedPythonVersion: actualPythonVersion,
+      resolvedPyPyVersion: actualPyPyVersion
+    });
+  });
+
+  it("PyPy exists on the path, but Python version doesn't match", () => {
+    expect(finder.findPyPyToolCache('3.7', 'v7.5.4', architecture)).toEqual({
+      installDir: '',
+      resolvedPythonVersion: '',
+      resolvedPyPyVersion: ''
+    });
+  });
+
+  it("PyPy exists on the path, but PyPy version doesn't match", () => {
+    expect(finder.findPyPyToolCache('3.6', 'v7.5.1', architecture)).toEqual({
+      installDir: null,
+      resolvedPythonVersion: '',
+      resolvedPyPyVersion: ''
+    });
+  });
+});
+
+describe('findPyPyVersion', () => {
+  let tcFind: jest.SpyInstance;
+  let spyExtractZip: jest.SpyInstance;
+  let spyExtractTar: jest.SpyInstance;
+  let spyHttpClient: jest.SpyInstance;
+  let spyExistsSync: jest.SpyInstance;
+  let spyExec: jest.SpyInstance;
+  let spySymlinkSync: jest.SpyInstance;
+  let spyDownloadTool: jest.SpyInstance;
+  let spyReadExactPyPyVersion: jest.SpyInstance;
+  let spyFsReadDir: jest.SpyInstance;
+  let spyWriteExactPyPyVersionFile: jest.SpyInstance;
+  let spyCacheDir: jest.SpyInstance;
+  let spyChmodSync: jest.SpyInstance;
+
+  beforeEach(() => {
+    tcFind = jest.spyOn(tc, 'find');
+    tcFind.mockImplementation((tool: string, version: string) => {
+      const semverRange = new semver.Range(version);
+      let pypyPath = '';
+      if (semver.satisfies('3.6.12', semverRange)) {
+        pypyPath = path.join(toolDir, 'PyPy', '3.6.12', architecture);
+      }
+      return pypyPath;
+    });
+
+    spyWriteExactPyPyVersionFile = jest.spyOn(
+      utils,
+      'writeExactPyPyVersionFile'
+    );
+    spyWriteExactPyPyVersionFile.mockImplementation(() => null);
+
+    spyReadExactPyPyVersion = jest.spyOn(utils, 'readExactPyPyVersionFile');
+    spyReadExactPyPyVersion.mockImplementation(() => '7.3.3');
+
+    spyDownloadTool = jest.spyOn(tc, 'downloadTool');
+    spyDownloadTool.mockImplementation(() => path.join(tempDir, 'PyPy'));
+
+    spyExtractZip = jest.spyOn(tc, 'extractZip');
+    spyExtractZip.mockImplementation(() => tempDir);
+
+    spyExtractTar = jest.spyOn(tc, 'extractTar');
+    spyExtractTar.mockImplementation(() => tempDir);
+
+    spyFsReadDir = jest.spyOn(fs, 'readdirSync');
+    spyFsReadDir.mockImplementation((directory: string) => ['PyPyTest']);
+
+    spyHttpClient = jest.spyOn(HttpClient.prototype, 'getJson');
+    spyHttpClient.mockImplementation(
+      async (): Promise<ifm.ITypedResponse<IPyPyManifestRelease[]>> => {
+        const result = JSON.stringify(manifestData);
+        return {
+          statusCode: 200,
+          headers: {},
+          result: JSON.parse(result) as IPyPyManifestRelease[]
+        };
+      }
+    );
+
+    spyExec = jest.spyOn(exec, 'exec');
+    spyExec.mockImplementation(() => undefined);
+
+    spySymlinkSync = jest.spyOn(fs, 'symlinkSync');
+    spySymlinkSync.mockImplementation(() => undefined);
+
+    spyExistsSync = jest.spyOn(fs, 'existsSync');
+    spyExistsSync.mockReturnValue(true);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+  });
+
+  it('found PyPy in toolcache', async () => {
+    await expect(
+      finder.findPyPyVersion('pypy-3.6-v7.3.x', architecture)
+    ).resolves.toEqual({
+      resolvedPythonVersion: '3.6.12',
+      resolvedPyPyVersion: '7.3.3'
+    });
+  });
+
+  it('throw on invalid input format', async () => {
+    await expect(
+      finder.findPyPyVersion('pypy3.7-v7.3.x', architecture)
+    ).rejects.toThrow();
+  });
+
+  it('throw on invalid input format pypy3.7-7.3.x', async () => {
+    await expect(
+      finder.findPyPyVersion('pypy3.7-v7.3.x', architecture)
+    ).rejects.toThrow();
+  });
+
+  it('found and install successfully', async () => {
+    spyCacheDir = jest.spyOn(tc, 'cacheDir');
+    spyCacheDir.mockImplementation(() =>
+      path.join(toolDir, 'PyPy', '3.7.7', architecture)
+    );
+    spyChmodSync = jest.spyOn(fs, 'chmodSync');
+    spyChmodSync.mockImplementation(() => undefined);
+    await expect(
+      finder.findPyPyVersion('pypy-3.7-v7.3.x', architecture)
+    ).resolves.toEqual({
+      resolvedPythonVersion: '3.7.9',
+      resolvedPyPyVersion: '7.3.3'
+    });
+  });
+
+  it('throw if release is not found', async () => {
+    await expect(
+      finder.findPyPyVersion('pypy-3.7-v7.5.x', architecture)
+    ).rejects.toThrowError(
+      `PyPy version 3.7 (v7.5.x) with arch ${architecture} not found`
+    );
+  });
+});

__tests__/install-pypy.test.ts

@@ -0,0 +1,230 @@
+import fs from 'fs';
+
+import {HttpClient} from '@actions/http-client';
+import * as ifm from '@actions/http-client/interfaces';
+import * as tc from '@actions/tool-cache';
+import * as exec from '@actions/exec';
+import * as path from 'path';
+
+import * as installer from '../src/install-pypy';
+import {
+  IPyPyManifestRelease,
+  IPyPyManifestAsset,
+  IS_WINDOWS
+} from '../src/utils';
+
+const manifestData = require('./data/pypy.json');
+
+let architecture: string;
+if (IS_WINDOWS) {
+  architecture = 'x86';
+} else {
+  architecture = 'x64';
+}
+
+const toolDir = path.join(__dirname, 'runner', 'tools');
+const tempDir = path.join(__dirname, 'runner', 'temp');
+
+describe('pypyVersionToSemantic', () => {
+  it.each([
+    ['7.3.3rc1', '7.3.3-rc.1'],
+    ['7.3.3', '7.3.3'],
+    ['7.3.x', '7.3.x'],
+    ['7.x', '7.x'],
+    ['nightly', 'nightly']
+  ])('%s -> %s', (input, expected) => {
+    expect(installer.pypyVersionToSemantic(input)).toEqual(expected);
+  });
+});
+
+describe('findRelease', () => {
+  const result = JSON.stringify(manifestData);
+  const releases = JSON.parse(result) as IPyPyManifestRelease[];
+  const extension = IS_WINDOWS ? '.zip' : '.tar.bz2';
+  const extensionName = IS_WINDOWS
+    ? `${process.platform}${extension}`
+    : `${process.platform}64${extension}`;
+  const files: IPyPyManifestAsset = {
+    filename: `pypy3.6-v7.3.3-${extensionName}`,
+    arch: architecture,
+    platform: process.platform,
+    download_url: `https://test.download.python.org/pypy/pypy3.6-v7.3.3-${extensionName}`
+  };
+
+  it("Python version is found, but PyPy version doesn't match", () => {
+    const pythonVersion = '3.6';
+    const pypyVersion = '7.3.7';
+    expect(
+      installer.findRelease(releases, pythonVersion, pypyVersion, architecture)
+    ).toEqual(null);
+  });
+
+  it('Python version is found and PyPy version matches', () => {
+    const pythonVersion = '3.6';
+    const pypyVersion = '7.3.3';
+    expect(
+      installer.findRelease(releases, pythonVersion, pypyVersion, architecture)
+    ).toEqual({
+      foundAsset: files,
+      resolvedPythonVersion: '3.6.12',
+      resolvedPyPyVersion: pypyVersion
+    });
+  });
+
+  it('Python version is found in toolcache and PyPy version matches semver', () => {
+    const pythonVersion = '3.6';
+    const pypyVersion = '7.x';
+    expect(
+      installer.findRelease(releases, pythonVersion, pypyVersion, architecture)
+    ).toEqual({
+      foundAsset: files,
+      resolvedPythonVersion: '3.6.12',
+      resolvedPyPyVersion: '7.3.3'
+    });
+  });
+
+  it('Python and preview version of PyPy are found', () => {
+    const pythonVersion = '3.7';
+    const pypyVersion = installer.pypyVersionToSemantic('7.3.3rc2');
+    expect(
+      installer.findRelease(releases, pythonVersion, pypyVersion, architecture)
+    ).toEqual({
+      foundAsset: {
+        filename: `test${extension}`,
+        arch: architecture,
+        platform: process.platform,
+        download_url: `test${extension}`
+      },
+      resolvedPythonVersion: '3.7.7',
+      resolvedPyPyVersion: '7.3.3rc2'
+    });
+  });
+
+  it('Python version with latest PyPy is found', () => {
+    const pythonVersion = '3.6';
+    const pypyVersion = 'x';
+    expect(
+      installer.findRelease(releases, pythonVersion, pypyVersion, architecture)
+    ).toEqual({
+      foundAsset: files,
+      resolvedPythonVersion: '3.6.12',
+      resolvedPyPyVersion: '7.3.3'
+    });
+  });
+
+  it('Nightly release is found', () => {
+    const pythonVersion = '3.6';
+    const pypyVersion = 'nightly';
+    const filename = IS_WINDOWS ? 'filename.zip' : 'filename.tar.bz2';
+    expect(
+      installer.findRelease(releases, pythonVersion, pypyVersion, architecture)
+    ).toEqual({
+      foundAsset: {
+        filename: filename,
+        arch: architecture,
+        platform: process.platform,
+        download_url: `http://nightlyBuilds.org/${filename}`
+      },
+      resolvedPythonVersion: '3.6',
+      resolvedPyPyVersion: pypyVersion
+    });
+  });
+});
+
+describe('installPyPy', () => {
+  let tcFind: jest.SpyInstance;
+  let spyExtractZip: jest.SpyInstance;
+  let spyExtractTar: jest.SpyInstance;
+  let spyFsReadDir: jest.SpyInstance;
+  let spyFsWriteFile: jest.SpyInstance;
+  let spyHttpClient: jest.SpyInstance;
+  let spyExistsSync: jest.SpyInstance;
+  let spyExec: jest.SpyInstance;
+  let spySymlinkSync: jest.SpyInstance;
+  let spyDownloadTool: jest.SpyInstance;
+  let spyCacheDir: jest.SpyInstance;
+  let spyChmodSync: jest.SpyInstance;
+
+  beforeEach(() => {
+    tcFind = jest.spyOn(tc, 'find');
+    tcFind.mockImplementation(() => path.join('PyPy', '3.6.12', architecture));
+
+    spyDownloadTool = jest.spyOn(tc, 'downloadTool');
+    spyDownloadTool.mockImplementation(() => path.join(tempDir, 'PyPy'));
+
+    spyExtractZip = jest.spyOn(tc, 'extractZip');
+    spyExtractZip.mockImplementation(() => tempDir);
+
+    spyExtractTar = jest.spyOn(tc, 'extractTar');
+    spyExtractTar.mockImplementation(() => tempDir);
+
+    spyFsReadDir = jest.spyOn(fs, 'readdirSync');
+    spyFsReadDir.mockImplementation(() => ['PyPyTest']);
+
+    spyFsWriteFile = jest.spyOn(fs, 'writeFileSync');
+    spyFsWriteFile.mockImplementation(() => undefined);
+
+    spyHttpClient = jest.spyOn(HttpClient.prototype, 'getJson');
+    spyHttpClient.mockImplementation(
+      async (): Promise<ifm.ITypedResponse<IPyPyManifestRelease[]>> => {
+        const result = JSON.stringify(manifestData);
+        return {
+          statusCode: 200,
+          headers: {},
+          result: JSON.parse(result) as IPyPyManifestRelease[]
+        };
+      }
+    );
+
+    spyExec = jest.spyOn(exec, 'exec');
+    spyExec.mockImplementation(() => undefined);
+
+    spySymlinkSync = jest.spyOn(fs, 'symlinkSync');
+    spySymlinkSync.mockImplementation(() => undefined);
+
+    spyExistsSync = jest.spyOn(fs, 'existsSync');
+    spyExistsSync.mockImplementation(() => false);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+  });
+
+  it('throw if release is not found', async () => {
+    await expect(
+      installer.installPyPy('7.3.3', '3.6.17', architecture)
+    ).rejects.toThrowError(
+      `PyPy version 3.6.17 (7.3.3) with arch ${architecture} not found`
+    );
+
+    expect(spyHttpClient).toHaveBeenCalled();
+    expect(spyDownloadTool).not.toHaveBeenCalled();
+    expect(spyExec).not.toHaveBeenCalled();
+  });
+
+  it('found and install PyPy', async () => {
+    spyCacheDir = jest.spyOn(tc, 'cacheDir');
+    spyCacheDir.mockImplementation(() =>
+      path.join(toolDir, 'PyPy', '3.6.12', architecture)
+    );
+
+    spyChmodSync = jest.spyOn(fs, 'chmodSync');
+    spyChmodSync.mockImplementation(() => undefined);
+
+    await expect(
+      installer.installPyPy('7.3.x', '3.6.12', architecture)
+    ).resolves.toEqual({
+      installDir: path.join(toolDir, 'PyPy', '3.6.12', architecture),
+      resolvedPythonVersion: '3.6.12',
+      resolvedPyPyVersion: '7.3.3'
+    });
+
+    expect(spyHttpClient).toHaveBeenCalled();
+    expect(spyDownloadTool).toHaveBeenCalled();
+    expect(spyExistsSync).toHaveBeenCalled();
+    expect(spyCacheDir).toHaveBeenCalled();
+    expect(spyExec).toHaveBeenCalled();
+  });
+});

__tests__/utils.test.ts

@@ -0,0 +1,34 @@
+import {
+  validateVersion,
+  validatePythonVersionFormatForPyPy
+} from '../src/utils';
+
+describe('validatePythonVersionFormatForPyPy', () => {
+  it.each([
+    ['3.6', true],
+    ['3.7', true],
+    ['3.6.x', false],
+    ['3.7.x', false],
+    ['3.x', false],
+    ['3', false]
+  ])('%s -> %s', (input, expected) => {
+    expect(validatePythonVersionFormatForPyPy(input)).toEqual(expected);
+  });
+});
+
+describe('validateVersion', () => {
+  it.each([
+    ['v7.3.3', true],
+    ['v7.3.x', true],
+    ['v7.x', true],
+    ['x', true],
+    ['v7.3.3-rc.1', true],
+    ['nightly', true],
+    ['v7.3.b', false],
+    ['3.6', true],
+    ['3.b', false],
+    ['3', true]
+  ])('%s -> %s', (input, expected) => {
+    expect(validateVersion(input)).toEqual(expected);
+  });
+});

action.yml

@@ -6,17 +6,24 @@ inputs:
   python-version:
     description: "Version range or exact version of a Python version to use, using SemVer's version range syntax."
     default: '3.x'
+  cache:
+    description: 'Used to specify a package manager for caching in the default directory. Supported values: pip, pipenv.'
+    required: false
   architecture:
     description: 'The target architecture (x86, x64) of the Python interpreter.'
   token:
     description: Used to pull python distributions from actions/python-versions. Since there's a default, this is typically not supplied by the user.
     default: ${{ github.token }}
+  cache-dependency-path:
+    description: 'Used to specify the path to dependency files. Supports wildcards or a list of file names for caching multiple dependencies.'
 outputs:
   python-version:
     description: "The installed python version. Useful when given a version range as input."
 runs:
   using: 'node12'
-  main: 'dist/index.js'
+  main: 'dist/setup/index.js'
+  post: 'dist/cache-save/index.js'
+  post-if: success()
 branding:
   icon: 'code'
   color: 'yellow'

docs/adrs/0000-caching-dependencies.md

@@ -0,0 +1,93 @@
+## 0. Caching dependencies
+
+Date: 2021-10-01
+
+Status: Accepted
+
+## Context
+
+`actions/setup-python` is one the most popular python's action in GitHub Actions. A lot of customers use it in conjunction with `actions/cache` to speed up dependencies installation.
+See more examples on proper usage in [actions/cache documentation](https://github.com/actions/cache/blob/main/examples.md#python---pip).
+
+## Goals & Anti-Goals
+
+Integration of caching functionality into `actions/setup-python` action will bring the following benefits for action users:
+ - Decrease the entry threshold for using the cache for Python dependencies and simplify initial configuration
+ - Simplify YAML pipelines by reducing the need for additional steps to enable caching
+ - More users will use caching for Python so users will have faster builds!
+
+We will add support for Pip and Pipenv dependency caching.
+
+We won't pursue the goal to provide wide customization of caching in the scope of `actions/setup-python` action. The purpose of this integration is to cover ~90% of basic use-cases. If users need flexible customization, we will advise them to use `actions/cache` directly.
+
+## Decision
+
+ - Add a `cache` input parameter to `actions/setup-python`. For now the input will accept the following values:
+    - pip - enable caching for pip dependencies
+    - pipenv - enable caching for pipenv dependencies
+    - '' - disable caching (default value)
+ - Cache feature will be disabled by default to make sure that we don't break existing customers.
+ - Action will try to search dependencies files (requirements.txt for pip and Pipfile.lock for pipenv) in the repository root (or relative to the repository root, if patterns are used) and throw error if no one is found.
+ - The hash of found file will be used as part of cache key (the same approach like actions/cache recommends)
+ - The following cache key will be used for pip: `setup-python-${{ runner.os }}-pip-${{ hashFiles('<package-file-path>') }}`
+ - The following cache key will be used for pipenv: `setup-python-${{ runner.os }}-python-${{ python-version }}-pipenv-${{ hashFiles('<package-file-path>') }}`. We add the python version to the cache key because the created virtualenv folder with the project name contains a copy of the python binary as a symlink to paths like `/opt/hostedtoolcache/Python/3.7.11`, so the cache can be fetched with a wrong python version. See details in the related [pull request](https://github.com/actions/cache/pull/607) in the actions/cache.
+ - Action will save the packages global cache:
+    - Pip (retrieved via pip cache dir). The command is available With pip 20.1 or later. We always update pip during installation, that is why this command should be available.
+    - Pipenv (default cache paths):
+        - ~/.local/share/virtualenvs (macOS)
+        - ~/.virtualenvs (Windows)
+        - ~/.local/share/virtualenvs (Ubuntu)
+ - Add a `cache-dependency-path` input parameter to `actions/setup-python`. The new input will accept an array or regex of dependency files. The field will accept a path (relative to the repository root) to dependency files. If the provided path contains wildcards, the action will search all matching files and calculate a common hash like the `${{ hashFiles('**/requirements-dev.txt') }}` YAML construction does
+
+## Example of real use-cases
+
+ - Pip package manager
+
+```
+steps:
+- uses: actions/checkout@v2
+- uses: actions/setup-python@v2
+  with:
+    python-version: 3.9
+    cache: pip
+```
+
+ - Pipenv package manager
+
+```
+steps:
+- uses: actions/checkout@v2
+- uses: actions/setup-python@v2
+  with:
+    python-version: 3.9
+    cache: pipenv
+```
+- With `cache-dependency-path`
+
+```
+steps:
+- uses: actions/checkout@v2
+- uses: actions/setup-python@v2
+  with:
+    python-version: 3.9
+    cache: pip
+    cache-dependency-path: |
+        **/requirements-dev.txt
+        **/requirements-test.txt
+        **/requirements.txt
+```
+
+
+```
+steps:
+- uses: actions/checkout@v2
+- uses: actions/setup-python@v2
+  with:
+    python-version: 3.9
+    cache: pip
+    cache-dependency-path: **/requirements-dev.txt
+```
+
+## Release process
+
+As soon as the functionality is implemented, we will release a minor update of the action. No need to bump the major version since there are no breaking changes for existing users. After that, we will update [starter-workflows](https://github.com/actions/starter-workflows/blob/main/ci/python-app.yml) and [GitHub Action documentation](https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#caching-dependencies).

package.json

@@ -1,14 +1,14 @@
 {
   "name": "setup-python",
-  "version": "2.0.1",
+  "version": "2.3.3",
   "private": true,
   "description": "Setup python action",
   "main": "dist/index.js",
   "scripts": {
-    "build": "tsc",
+    "build": "ncc build -o dist/setup src/setup-python.ts && ncc build -o dist/cache-save src/cache-save.ts",
-    "format": "prettier --write **/*.ts",
+    "format": "prettier --write \"{,!(node_modules)/**/}*.ts\"",
-    "format-check": "prettier --check **/*.ts",
+    "format-check": "prettier --check \"{,!(node_modules)/**/}*.ts\"",
-    "release": "ncc build src/setup-python.ts && git add -f dist/",
+    "release": "ncc build -o dist/setup src/setup-python.ts && ncc build -o dist/cache-save src/cache-save.ts && git add -f dist/",
     "test": "jest"
   },
   "repository": {
@@ -23,21 +23,24 @@
   "author": "GitHub",
   "license": "MIT",
   "dependencies": {
-    "@actions/core": "^1.2.3",
+    "@actions/cache": "^1.0.8",
+    "@actions/core": "^1.10.0",
+    "@actions/exec": "^1.1.0",
+    "@actions/glob": "^0.2.0",
     "@actions/io": "^1.0.2",
     "@actions/tool-cache": "^1.5.5",
     "semver": "^7.1.3"
   },
   "devDependencies": {
-    "@types/jest": "^25.1.4",
+    "@types/jest": "^27.0.2",
-    "@types/node": "^12.12.31",
+    "@types/node": "^12.20.36",
     "@types/semver": "^7.1.0",
     "@zeit/ncc": "^0.22.0",
-    "husky": "^4.2.3",
+    "husky": "^7.0.2",
-    "jest": "^25.1.0",
+    "jest": "^27.2.5",
-    "jest-circus": "^25.1.0",
+    "jest-circus": "^27.2.5",
     "prettier": "^2.0.2",
-    "ts-jest": "^25.2.1",
+    "ts-jest": "^27.0.5",
     "typescript": "^3.8.3"
   },
   "husky": {

src/cache-distributions/cache-distributor.ts

@@ -0,0 +1,53 @@
+import * as cache from '@actions/cache';
+import * as core from '@actions/core';
+
+export enum State {
+  STATE_CACHE_PRIMARY_KEY = 'cache-primary-key',
+  CACHE_MATCHED_KEY = 'cache-matched-key',
+  CACHE_PATHS = 'cache-paths'
+}
+
+abstract class CacheDistributor {
+  protected CACHE_KEY_PREFIX = 'setup-python';
+  constructor(
+    protected packageManager: string,
+    protected cacheDependencyPath: string
+  ) {}
+
+  protected abstract getCacheGlobalDirectories(): Promise<string[]>;
+  protected abstract computeKeys(): Promise<{
+    primaryKey: string;
+    restoreKey: string[] | undefined;
+  }>;
+
+  public async restoreCache() {
+    const {primaryKey, restoreKey} = await this.computeKeys();
+    if (primaryKey.endsWith('-')) {
+      throw new Error(
+        `No file in ${process.cwd()} matched to [${this.cacheDependencyPath
+          .split('\n')
+          .join(',')}], make sure you have checked out the target repository`
+      );
+    }
+
+    const cachePath = await this.getCacheGlobalDirectories();
+
+    core.saveState(State.CACHE_PATHS, cachePath);
+    core.saveState(State.STATE_CACHE_PRIMARY_KEY, primaryKey);
+
+    const matchedKey = await cache.restoreCache(
+      cachePath,
+      primaryKey,
+      restoreKey
+    );
+
+    if (matchedKey) {
+      core.saveState(State.CACHE_MATCHED_KEY, matchedKey);
+      core.info(`Cache restored from key: ${matchedKey}`);
+    } else {
+      core.info(`${this.packageManager} cache is not found`);
+    }
+  }
+}
+
+export default CacheDistributor;

src/cache-distributions/cache-factory.ts

@@ -0,0 +1,22 @@
+import PipCache from './pip-cache';
+import PipenvCache from './pipenv-cache';
+
+export enum PackageManagers {
+  Pip = 'pip',
+  Pipenv = 'pipenv'
+}
+
+export function getCacheDistributor(
+  packageManager: string,
+  pythonVersion: string,
+  cacheDependencyPath: string | undefined
+) {
+  switch (packageManager) {
+    case PackageManagers.Pip:
+      return new PipCache(pythonVersion, cacheDependencyPath);
+    case PackageManagers.Pipenv:
+      return new PipenvCache(pythonVersion, cacheDependencyPath);
+    default:
+      throw new Error(`Caching for '${packageManager}' is not supported`);
+  }
+}

src/cache-distributions/pip-cache.ts

@@ -0,0 +1,70 @@
+import * as glob from '@actions/glob';
+import * as core from '@actions/core';
+import * as exec from '@actions/exec';
+import * as child_process from 'child_process';
+import utils from 'util';
+import * as path from 'path';
+import os from 'os';
+
+import CacheDistributor from './cache-distributor';
+import {IS_WINDOWS} from '../utils';
+
+class PipCache extends CacheDistributor {
+  constructor(
+    private pythonVersion: string,
+    cacheDependencyPath: string = '**/requirements.txt'
+  ) {
+    super('pip', cacheDependencyPath);
+  }
+
+  protected async getCacheGlobalDirectories() {
+    let exitCode = 1;
+    let stdout = '';
+    let stderr = '';
+
+    // Add temporary fix for Windows
+    // On windows it is necessary to execute through an exec
+    // because the getExecOutput gives a non zero code or writes to stderr for pip 22.0.2,
+    // or spawn must be started with the shell option enabled for getExecOutput
+    // Related issue: https://github.com/actions/setup-python/issues/328
+    if (IS_WINDOWS) {
+      const execPromisify = utils.promisify(child_process.exec);
+      ({stdout: stdout, stderr: stderr} = await execPromisify('pip cache dir'));
+    } else {
+      ({
+        stdout: stdout,
+        stderr: stderr,
+        exitCode: exitCode
+      } = await exec.getExecOutput('pip cache dir'));
+    }
+
+    if (exitCode && stderr) {
+      throw new Error(
+        `Could not get cache folder path for pip package manager`
+      );
+    }
+
+    let resolvedPath = stdout.trim();
+
+    if (resolvedPath.includes('~')) {
+      resolvedPath = path.join(os.homedir(), resolvedPath.slice(1));
+    }
+
+    core.debug(`global cache directory path is ${resolvedPath}`);
+
+    return [resolvedPath];
+  }
+
+  protected async computeKeys() {
+    const hash = await glob.hashFiles(this.cacheDependencyPath);
+    const primaryKey = `${this.CACHE_KEY_PREFIX}-${process.env['RUNNER_OS']}-python-${this.pythonVersion}-${this.packageManager}-${hash}`;
+    const restoreKey = `${this.CACHE_KEY_PREFIX}-${process.env['RUNNER_OS']}-python-${this.pythonVersion}-${this.packageManager}`;
+
+    return {
+      primaryKey,
+      restoreKey: [restoreKey]
+    };
+  }
+}
+
+export default PipCache;

src/cache-distributions/pipenv-cache.ts

@@ -0,0 +1,44 @@
+import * as glob from '@actions/glob';
+import * as os from 'os';
+import * as path from 'path';
+import * as core from '@actions/core';
+
+import CacheDistributor from './cache-distributor';
+
+class PipenvCache extends CacheDistributor {
+  constructor(
+    private pythonVersion: string,
+    protected patterns: string = '**/Pipfile.lock'
+  ) {
+    super('pipenv', patterns);
+  }
+
+  protected async getCacheGlobalDirectories() {
+    let virtualEnvRelativePath;
+
+    // Default virtualenv directories are hardcoded,
+    // because pipenv is not preinstalled on hosted images and virtualenv is not created:
+    // https://github.com/pypa/pipenv/blob/1daaa0de9a0b00d386c6baeb809d8d4ee6795cfd/pipenv/utils.py#L1990-L2002
+    if (process.platform === 'win32') {
+      virtualEnvRelativePath = '.virtualenvs';
+    } else {
+      virtualEnvRelativePath = '.local/share/virtualenvs';
+    }
+    const resolvedPath = path.join(os.homedir(), virtualEnvRelativePath);
+    core.debug(`global cache directory path is ${resolvedPath}`);
+
+    return [resolvedPath];
+  }
+
+  protected async computeKeys() {
+    const hash = await glob.hashFiles(this.patterns);
+    const primaryKey = `${this.CACHE_KEY_PREFIX}-${process.env['RUNNER_OS']}-python-${this.pythonVersion}-${this.packageManager}-${hash}`;
+    const restoreKey = undefined;
+    return {
+      primaryKey,
+      restoreKey
+    };
+  }
+}
+
+export default PipenvCache;

src/cache-save.ts

@@ -0,0 +1,67 @@
+import * as core from '@actions/core';
+import * as cache from '@actions/cache';
+
+import fs from 'fs';
+import {State} from './cache-distributions/cache-distributor';
+
+export async function run() {
+  try {
+    const cache = core.getInput('cache');
+    if (cache) {
+      await saveCache(cache);
+    }
+  } catch (error) {
+    const err = error as Error;
+    core.setFailed(err.message);
+  }
+}
+
+async function saveCache(packageManager: string) {
+  const cachePaths = JSON.parse(core.getState(State.CACHE_PATHS)) as string[];
+
+  core.debug(`paths for caching are ${cachePaths.join(', ')}`);
+
+  if (!isCacheDirectoryExists(cachePaths)) {
+    throw new Error(
+      `Cache folder path is retrieved for ${packageManager} but doesn't exist on disk: ${cachePaths.join(
+        ', '
+      )}`
+    );
+  }
+
+  const primaryKey = core.getState(State.STATE_CACHE_PRIMARY_KEY);
+  const matchedKey = core.getState(State.CACHE_MATCHED_KEY);
+
+  if (!primaryKey) {
+    core.warning('Error retrieving key from state.');
+    return;
+  } else if (matchedKey === primaryKey) {
+    // no change in target directories
+    core.info(
+      `Cache hit occurred on the primary key ${primaryKey}, not saving cache.`
+    );
+    return;
+  }
+
+  try {
+    await cache.saveCache(cachePaths, primaryKey);
+    core.info(`Cache saved with the key: ${primaryKey}`);
+  } catch (error) {
+    const err = error as Error;
+    if (err.name === cache.ReserveCacheError.name) {
+      core.info(err.message);
+    } else {
+      throw error;
+    }
+  }
+}
+
+function isCacheDirectoryExists(cacheDirectory: string[]) {
+  const result = cacheDirectory.reduce((previousValue, currentValue) => {
+    return previousValue || fs.existsSync(currentValue);
+  }, false);
+
+  return result;
+}
+
+run();

src/find-pypy.ts

@@ -0,0 +1,140 @@
+import * as path from 'path';
+import * as pypyInstall from './install-pypy';
+import {
+  IS_WINDOWS,
+  WINDOWS_ARCHS,
+  validateVersion,
+  getPyPyVersionFromPath,
+  readExactPyPyVersionFile,
+  validatePythonVersionFormatForPyPy
+} from './utils';
+
+import * as semver from 'semver';
+import * as core from '@actions/core';
+import * as tc from '@actions/tool-cache';
+
+interface IPyPyVersionSpec {
+  pypyVersion: string;
+  pythonVersion: string;
+}
+
+export async function findPyPyVersion(
+  versionSpec: string,
+  architecture: string
+): Promise<{resolvedPyPyVersion: string; resolvedPythonVersion: string}> {
+  let resolvedPyPyVersion = '';
+  let resolvedPythonVersion = '';
+  let installDir: string | null;
+
+  const pypyVersionSpec = parsePyPyVersion(versionSpec);
+
+  ({installDir, resolvedPythonVersion, resolvedPyPyVersion} = findPyPyToolCache(
+    pypyVersionSpec.pythonVersion,
+    pypyVersionSpec.pypyVersion,
+    architecture
+  ));
+
+  if (!installDir) {
+    ({
+      installDir,
+      resolvedPythonVersion,
+      resolvedPyPyVersion
+    } = await pypyInstall.installPyPy(
+      pypyVersionSpec.pypyVersion,
+      pypyVersionSpec.pythonVersion,
+      architecture
+    ));
+  }
+
+  const pipDir = IS_WINDOWS ? 'Scripts' : 'bin';
+  const _binDir = path.join(installDir, pipDir);
+  const pythonLocation = pypyInstall.getPyPyBinaryPath(installDir);
+  core.exportVariable('pythonLocation', pythonLocation);
+  core.addPath(pythonLocation);
+  core.addPath(_binDir);
+
+  return {resolvedPyPyVersion, resolvedPythonVersion};
+}
+
+export function findPyPyToolCache(
+  pythonVersion: string,
+  pypyVersion: string,
+  architecture: string
+) {
+  let resolvedPyPyVersion = '';
+  let resolvedPythonVersion = '';
+  let installDir: string | null = IS_WINDOWS
+    ? findPyPyInstallDirForWindows(pythonVersion)
+    : tc.find('PyPy', pythonVersion, architecture);
+
+  if (installDir) {
+    // 'tc.find' finds tool based on Python version but we also need to check
+    // whether PyPy version satisfies requested version.
+    resolvedPythonVersion = getPyPyVersionFromPath(installDir);
+    resolvedPyPyVersion = readExactPyPyVersionFile(installDir);
+
+    const isPyPyVersionSatisfies = semver.satisfies(
+      resolvedPyPyVersion,
+      pypyVersion
+    );
+    if (!isPyPyVersionSatisfies) {
+      installDir = null;
+      resolvedPyPyVersion = '';
+      resolvedPythonVersion = '';
+    }
+  }
+
+  if (!installDir) {
+    core.info(
+      `PyPy version ${pythonVersion} (${pypyVersion}) was not found in the local cache`
+    );
+  }
+
+  return {installDir, resolvedPythonVersion, resolvedPyPyVersion};
+}
+
+export function parsePyPyVersion(versionSpec: string): IPyPyVersionSpec {
+  const versions = versionSpec.split('-').filter(item => !!item);
+
+  if (versions.length < 2 || versions[0] != 'pypy') {
+    throw new Error(
+      "Invalid 'version' property for PyPy. PyPy version should be specified as 'pypy-<python-version>'. See README for examples and documentation."
+    );
+  }
+
+  const pythonVersion = versions[1];
+  let pypyVersion: string;
+  if (versions.length > 2) {
+    pypyVersion = pypyInstall.pypyVersionToSemantic(versions[2]);
+  } else {
+    pypyVersion = 'x';
+  }
+
+  if (!validateVersion(pythonVersion) || !validateVersion(pypyVersion)) {
+    throw new Error(
+      "Invalid 'version' property for PyPy. Both Python version and PyPy versions should satisfy SemVer notation. See README for examples and documentation."
+    );
+  }
+
+  if (!validatePythonVersionFormatForPyPy(pythonVersion)) {
+    throw new Error(
+      "Invalid format of Python version for PyPy. Python version should be specified in format 'x.y'. See README for examples and documentation."
+    );
+  }
+
+  return {
+    pypyVersion: pypyVersion,
+    pythonVersion: pythonVersion
+  };
+}
+
+export function findPyPyInstallDirForWindows(pythonVersion: string): string {
+  let installDir = '';
+
+  WINDOWS_ARCHS.forEach(
+    architecture =>
+      (installDir = installDir || tc.find('PyPy', pythonVersion, architecture))
+  );
+
+  return installDir;
+}

src/find-python.ts

@@ -1,5 +1,6 @@
 import * as os from 'os';
 import * as path from 'path';
+import {IS_WINDOWS, IS_LINUX} from './utils';
 
 import * as semver from 'semver';
 
@@ -8,9 +9,6 @@ import * as installer from './install-python';
 import * as core from '@actions/core';
 import * as tc from '@actions/tool-cache';
 
-const IS_WINDOWS = process.platform === 'win32';
-const IS_LINUX = process.platform === 'linux';
-
 // Python has "scripts" or "bin" directories where command-line tools that come with packages are installed.
 // This is where pip is, along with anything that pip installs.
 // There is a seperate directory for `pip install --user`.
@@ -37,8 +35,11 @@ function binDir(installDir: string): string {
 // A particular version of PyPy may contain one or more versions of the Python interpreter.
 // For example, PyPy 7.0 contains Python 2.7, 3.5, and 3.6-alpha.
 // We only care about the Python version, so we don't use the PyPy version for the tool cache.
-function usePyPy(majorVersion: 2 | 3, architecture: string): InstalledVersion {
+function usePyPy(
-  const findPyPy = tc.find.bind(undefined, 'PyPy', majorVersion.toString());
+  majorVersion: '2' | '3.6',
+  architecture: string
+): InstalledVersion {
+  const findPyPy = tc.find.bind(undefined, 'PyPy', majorVersion);
   let installDir: string | null = findPyPy(architecture);
 
   if (!installDir && IS_WINDOWS) {
@@ -63,6 +64,10 @@ function usePyPy(majorVersion: 2 | 3, architecture: string): InstalledVersion {
 
   core.addPath(installDir);
   core.addPath(_binDir);
+  // Starting from PyPy 7.3.1, the folder that is used for pip and anything that pip installs should be "Scripts" on Windows.
+  if (IS_WINDOWS) {
+    core.addPath(path.join(installDir, 'Scripts'));
+  }
 
   const impl = 'pypy' + majorVersion.toString();
   core.setOutput('python-version', impl);
@@ -188,9 +193,10 @@ export async function findPythonVersion(
 ): Promise<InstalledVersion> {
   switch (version.toUpperCase()) {
     case 'PYPY2':
-      return usePyPy(2, architecture);
+      return usePyPy('2', architecture);
     case 'PYPY3':
-      return usePyPy(3, architecture);
+      // keep pypy3 pointing to 3.6 for backward compatibility
+      return usePyPy('3.6', architecture);
     default:
       return await useCpythonVersion(version, architecture);
   }

src/install-pypy.ts

@@ -0,0 +1,231 @@
+import * as path from 'path';
+import * as core from '@actions/core';
+import * as tc from '@actions/tool-cache';
+import * as semver from 'semver';
+import * as httpm from '@actions/http-client';
+import * as exec from '@actions/exec';
+import fs from 'fs';
+
+import {
+  IS_WINDOWS,
+  WINDOWS_ARCHS,
+  WINDOWS_PLATFORMS,
+  IPyPyManifestRelease,
+  createSymlinkInFolder,
+  isNightlyKeyword,
+  writeExactPyPyVersionFile
+} from './utils';
+
+export async function installPyPy(
+  pypyVersion: string,
+  pythonVersion: string,
+  architecture: string
+) {
+  let downloadDir;
+
+  const releases = await getAvailablePyPyVersions();
+  if (!releases || releases.length === 0) {
+    throw new Error('No release was found in PyPy version.json');
+  }
+
+  const releaseData = findRelease(
+    releases,
+    pythonVersion,
+    pypyVersion,
+    architecture
+  );
+
+  if (!releaseData || !releaseData.foundAsset) {
+    throw new Error(
+      `PyPy version ${pythonVersion} (${pypyVersion}) with arch ${architecture} not found`
+    );
+  }
+
+  const {foundAsset, resolvedPythonVersion, resolvedPyPyVersion} = releaseData;
+  let downloadUrl = `${foundAsset.download_url}`;
+
+  core.info(`Downloading PyPy from "${downloadUrl}" ...`);
+  const pypyPath = await tc.downloadTool(downloadUrl);
+
+  core.info('Extracting downloaded archive...');
+  if (IS_WINDOWS) {
+    downloadDir = await tc.extractZip(pypyPath);
+  } else {
+    downloadDir = await tc.extractTar(pypyPath, undefined, 'x');
+  }
+
+  // root folder in archive can have unpredictable name so just take the first folder
+  // downloadDir is unique folder under TEMP and can't contain any other folders
+  const archiveName = fs.readdirSync(downloadDir)[0];
+
+  const toolDir = path.join(downloadDir, archiveName);
+  let installDir = toolDir;
+  if (!isNightlyKeyword(resolvedPyPyVersion)) {
+    installDir = await tc.cacheDir(
+      toolDir,
+      'PyPy',
+      resolvedPythonVersion,
+      architecture
+    );
+  }
+
+  writeExactPyPyVersionFile(installDir, resolvedPyPyVersion);
+
+  const binaryPath = getPyPyBinaryPath(installDir);
+  await createPyPySymlink(binaryPath, resolvedPythonVersion);
+  await installPip(binaryPath);
+
+  return {installDir, resolvedPythonVersion, resolvedPyPyVersion};
+}
+
+async function getAvailablePyPyVersions() {
+  const url = 'https://downloads.python.org/pypy/versions.json';
+  const http: httpm.HttpClient = new httpm.HttpClient('tool-cache');
+
+  const response = await http.getJson<IPyPyManifestRelease[]>(url);
+  if (!response.result) {
+    throw new Error(
+      `Unable to retrieve the list of available PyPy versions from '${url}'`
+    );
+  }
+
+  return response.result;
+}
+
+async function createPyPySymlink(
+  pypyBinaryPath: string,
+  pythonVersion: string
+) {
+  const version = semver.coerce(pythonVersion)!;
+  const pythonBinaryPostfix = semver.major(version);
+  const pypyBinaryPostfix = pythonBinaryPostfix === 2 ? '' : '3';
+  let binaryExtension = IS_WINDOWS ? '.exe' : '';
+
+  core.info('Creating symlinks...');
+  createSymlinkInFolder(
+    pypyBinaryPath,
+    `pypy${pypyBinaryPostfix}${binaryExtension}`,
+    `python${pythonBinaryPostfix}${binaryExtension}`,
+    true
+  );
+
+  createSymlinkInFolder(
+    pypyBinaryPath,
+    `pypy${pypyBinaryPostfix}${binaryExtension}`,
+    `python${binaryExtension}`,
+    true
+  );
+}
+
+async function installPip(pythonLocation: string) {
+  core.info('Installing and updating pip');
+  const pythonBinary = path.join(pythonLocation, 'python');
+  await exec.exec(`${pythonBinary} -m ensurepip`);
+
+  await exec.exec(
+    `${pythonLocation}/python -m pip install --ignore-installed pip`
+  );
+}
+
+export function findRelease(
+  releases: IPyPyManifestRelease[],
+  pythonVersion: string,
+  pypyVersion: string,
+  architecture: string
+) {
+  const filterReleases = releases.filter(item => {
+    const isPythonVersionSatisfied = semver.satisfies(
+      semver.coerce(item.python_version)!,
+      pythonVersion
+    );
+    const isPyPyNightly =
+      isNightlyKeyword(pypyVersion) && isNightlyKeyword(item.pypy_version);
+    const isPyPyVersionSatisfied =
+      isPyPyNightly ||
+      semver.satisfies(pypyVersionToSemantic(item.pypy_version), pypyVersion);
+    const isArchPresent =
+      item.files &&
+      (IS_WINDOWS
+        ? isArchPresentForWindows(item)
+        : isArchPresentForMacOrLinux(item, architecture, process.platform));
+    return isPythonVersionSatisfied && isPyPyVersionSatisfied && isArchPresent;
+  });
+
+  if (filterReleases.length === 0) {
+    return null;
+  }
+
+  const sortedReleases = filterReleases.sort((previous, current) => {
+    return (
+      semver.compare(
+        semver.coerce(pypyVersionToSemantic(current.pypy_version))!,
+        semver.coerce(pypyVersionToSemantic(previous.pypy_version))!
+      ) ||
+      semver.compare(
+        semver.coerce(current.python_version)!,
+        semver.coerce(previous.python_version)!
+      )
+    );
+  });
+
+  const foundRelease = sortedReleases[0];
+  const foundAsset = IS_WINDOWS
+    ? findAssetForWindows(foundRelease)
+    : findAssetForMacOrLinux(foundRelease, architecture, process.platform);
+
+  return {
+    foundAsset,
+    resolvedPythonVersion: foundRelease.python_version,
+    resolvedPyPyVersion: foundRelease.pypy_version
+  };
+}
+
+/** Get PyPy binary location from the tool of installation directory
+ *  - On Linux and macOS, the Python interpreter is in 'bin'.
+ *  - On Windows, it is in the installation root.
+ */
+export function getPyPyBinaryPath(installDir: string) {
+  const _binDir = path.join(installDir, 'bin');
+  return IS_WINDOWS ? installDir : _binDir;
+}
+
+export function pypyVersionToSemantic(versionSpec: string) {
+  const prereleaseVersion = /(\d+\.\d+\.\d+)((?:a|b|rc))(\d*)/g;
+  return versionSpec.replace(prereleaseVersion, '$1-$2.$3');
+}
+
+export function isArchPresentForWindows(item: any) {
+  return item.files.some(
+    (file: any) =>
+      WINDOWS_ARCHS.includes(file.arch) &&
+      WINDOWS_PLATFORMS.includes(file.platform)
+  );
+}
+
+export function isArchPresentForMacOrLinux(
+  item: any,
+  architecture: string,
+  platform: string
+) {
+  return item.files.some(
+    (file: any) => file.arch === architecture && file.platform === platform
+  );
+}
+
+export function findAssetForWindows(releases: any) {
+  return releases.files.find(
+    (item: any) =>
+      WINDOWS_ARCHS.includes(item.arch) &&
+      WINDOWS_PLATFORMS.includes(item.platform)
+  );
+}
+
+export function findAssetForMacOrLinux(
+  releases: any,
+  architecture: string,
+  platform: string
+) {
+  return releases.files.find(
+    (item: any) => item.arch === architecture && item.platform === platform
+  );
+}

src/install-python.ts

@@ -3,7 +3,7 @@ import * as core from '@actions/core';
 import * as tc from '@actions/tool-cache';
 import * as exec from '@actions/exec';
 import {ExecOptions} from '@actions/exec/lib/interfaces';
-import {stderr} from 'process';
+import {IS_WINDOWS, IS_LINUX, isGhes} from './utils';
 
 const TOKEN = core.getInput('token');
 const AUTH = !TOKEN || isGhes() ? undefined : `token ${TOKEN}`;
@@ -12,9 +12,6 @@ const MANIFEST_REPO_NAME = 'python-versions';
 const MANIFEST_REPO_BRANCH = 'main';
 export const MANIFEST_URL = `https://raw.githubusercontent.com/${MANIFEST_REPO_OWNER}/${MANIFEST_REPO_NAME}/${MANIFEST_REPO_BRANCH}/versions-manifest.json`;
 
-const IS_WINDOWS = process.platform === 'win32';
-const IS_LINUX = process.platform === 'linux';
-
 export async function findReleaseFromManifest(
   semanticVersionSpec: string,
   architecture: string
@@ -74,10 +71,3 @@ export async function installCpythonFromRelease(release: tc.IToolRelease) {
   core.info('Execute installation script');
   await installPython(pythonExtractedFolder);
 }
-
-function isGhes(): boolean {
-  const ghUrl = new URL(
-    process.env['GITHUB_SERVER_URL'] || 'https://github.com'
-  );
-  return ghUrl.hostname.toUpperCase() !== 'GITHUB.COM';
-}

src/setup-python.ts

@@ -1,20 +1,61 @@
 import * as core from '@actions/core';
 import * as finder from './find-python';
+import * as finderPyPy from './find-pypy';
 import * as path from 'path';
 import * as os from 'os';
+import {getCacheDistributor} from './cache-distributions/cache-factory';
+import {isGhes} from './utils';
+
+function isPyPyVersion(versionSpec: string) {
+  return versionSpec.startsWith('pypy-');
+}
+
+async function cacheDependencies(cache: string, pythonVersion: string) {
+  if (isGhes()) {
+    throw new Error('Caching is not supported on GHES');
+  }
+  const cacheDependencyPath =
+    core.getInput('cache-dependency-path') || undefined;
+  const cacheDistributor = getCacheDistributor(
+    cache,
+    pythonVersion,
+    cacheDependencyPath
+  );
+  await cacheDistributor.restoreCache();
+}
 
 async function run() {
   try {
-    let version = core.getInput('python-version');
+    const version = core.getInput('python-version');
     if (version) {
+      if (version.trim().startsWith('2')) {
+        core.warning(
+          'The support for python 2.7 will be removed on June 19. Related issue: https://github.com/actions/setup-python/issues/672'
+        );
+      }
+      let pythonVersion: string;
       const arch: string = core.getInput('architecture') || os.arch();
-      const installed = await finder.findPythonVersion(version, arch);
+      if (isPyPyVersion(version)) {
-      core.info(`Successfully setup ${installed.impl} (${installed.version})`);
+        const installed = await finderPyPy.findPyPyVersion(version, arch);
+        pythonVersion = `${installed.resolvedPyPyVersion}-${installed.resolvedPythonVersion}`;
+        core.info(
+          `Successfully setup PyPy ${installed.resolvedPyPyVersion} with Python (${installed.resolvedPythonVersion})`
+        );
+      } else {
+        const installed = await finder.findPythonVersion(version, arch);
+        pythonVersion = installed.version;
+        core.info(`Successfully setup ${installed.impl} (${pythonVersion})`);
+      }
+
+      const cache = core.getInput('cache');
+      if (cache) {
+        await cacheDependencies(cache, pythonVersion);
+      }
     }
-    const matchersPath = path.join(__dirname, '..', '.github');
+    const matchersPath = path.join(__dirname, '../..', '.github');
     core.info(`##[add-matcher]${path.join(matchersPath, 'python.json')}`);
   } catch (err) {
-    core.setFailed(err.message);
+    core.setFailed((err as Error).message);
   }
 }
 

src/utils.ts

@@ -0,0 +1,101 @@
+import fs from 'fs';
+import * as path from 'path';
+import * as semver from 'semver';
+
+export const IS_WINDOWS = process.platform === 'win32';
+export const IS_LINUX = process.platform === 'linux';
+export const WINDOWS_ARCHS = ['x86', 'x64'];
+export const WINDOWS_PLATFORMS = ['win32', 'win64'];
+const PYPY_VERSION_FILE = 'PYPY_VERSION';
+
+export interface IPyPyManifestAsset {
+  filename: string;
+  arch: string;
+  platform: string;
+  download_url: string;
+}
+
+export interface IPyPyManifestRelease {
+  pypy_version: string;
+  python_version: string;
+  stable: boolean;
+  latest_pypy: boolean;
+  files: IPyPyManifestAsset[];
+}
+
+/** create Symlinks for downloaded PyPy
+ *  It should be executed only for downloaded versions in runtime, because
+ *  toolcache versions have this setup.
+ */
+export function createSymlinkInFolder(
+  folderPath: string,
+  sourceName: string,
+  targetName: string,
+  setExecutable = false
+) {
+  const sourcePath = path.join(folderPath, sourceName);
+  const targetPath = path.join(folderPath, targetName);
+  if (fs.existsSync(targetPath)) {
+    return;
+  }
+
+  fs.symlinkSync(sourcePath, targetPath);
+  if (!IS_WINDOWS && setExecutable) {
+    fs.chmodSync(targetPath, '755');
+  }
+}
+
+export function validateVersion(version: string) {
+  return isNightlyKeyword(version) || Boolean(semver.validRange(version));
+}
+
+export function isNightlyKeyword(pypyVersion: string) {
+  return pypyVersion === 'nightly';
+}
+
+export function getPyPyVersionFromPath(installDir: string) {
+  return path.basename(path.dirname(installDir));
+}
+
+/**
+ * In tool-cache, we put PyPy to '<toolcache_root>/PyPy/<python_version>/x64'
+ * There is no easy way to determine what PyPy version is located in specific folder
+ * 'pypy --version' is not reliable enough since it is not set properly for preview versions
+ * "7.3.3rc1" is marked as '7.3.3' in 'pypy --version'
+ * so we put PYPY_VERSION file to PyPy directory when install it to VM and read it when we need to know version
+ * PYPY_VERSION contains exact version from 'versions.json'
+ */
+export function readExactPyPyVersionFile(installDir: string) {
+  let pypyVersion = '';
+  let fileVersion = path.join(installDir, PYPY_VERSION_FILE);
+  if (fs.existsSync(fileVersion)) {
+    pypyVersion = fs.readFileSync(fileVersion).toString();
+  }
+
+  return pypyVersion;
+}
+
+export function writeExactPyPyVersionFile(
+  installDir: string,
+  resolvedPyPyVersion: string
+) {
+  const pypyFilePath = path.join(installDir, PYPY_VERSION_FILE);
+  fs.writeFileSync(pypyFilePath, resolvedPyPyVersion);
+}
+
+/**
+ * Python version should be specified explicitly like "x.y" (2.7, 3.6, 3.7)
+ * "3.x" or "3" are not supported
+ * because it could cause ambiguity when both PyPy version and Python version are not precise
+ */
+export function validatePythonVersionFormatForPyPy(version: string) {
+  const re = /^\d+\.\d+$/;
+  return re.test(version);
+}
+
+export function isGhes(): boolean {
+  const ghUrl = new URL(
+    process.env['GITHUB_SERVER_URL'] || 'https://github.com'
+  );
+  return ghUrl.hostname.toUpperCase() !== 'GITHUB.COM';
+}