FilesExpand file tree

main

/

find-python.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

203 lines (171 loc) · 6.61 KB

main

/

find-python.ts

Copy path

Top

File metadata and controls

• Code
• Blame

203 lines (171 loc) · 6.61 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

import * as os from 'os';

import * as path from 'path';

import {IS_WINDOWS, IS_LINUX} from './utils';

import * as semver from 'semver';

import * as installer from './install-python';

import * as core from '@actions/core';

import * as tc from '@actions/tool-cache';

// 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`.

//

// For reference, these directories are as follows:

// macOS / Linux:

// <sys.prefix>/bin (by default /usr/local/bin, but not on hosted agents -- see the `else`)

// (--user) ~/.local/bin

// Windows:

// <Python installation dir>\Scripts

// (--user) %APPDATA%\Python\PythonXY\Scripts

// See https://docs.python.org/3/library/sysconfig.html

function binDir(installDir: string): string {

if (IS_WINDOWS) {

return path.join(installDir, 'Scripts');

} else {

return path.join(installDir, 'bin');

}

}

// Note on the tool cache layout for PyPy:

// PyPy has its own versioning scheme that doesn't follow the Python versioning scheme.

// 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.6',

architecture: string

): InstalledVersion {

const findPyPy = tc.find.bind(undefined, 'PyPy', majorVersion);

let installDir: string | null = findPyPy(architecture);

if (!installDir && IS_WINDOWS) {

// PyPy only precompiles binaries for x86, but the architecture parameter defaults to x64.

// On our Windows virtual environments, we only install an x86 version.

// Fall back to x86.

installDir = findPyPy('x86');

}

if (!installDir) {

// PyPy not installed in $(Agent.ToolsDirectory)

throw new Error(`PyPy ${majorVersion} not found`);

}

// For PyPy, Windows uses 'bin', not 'Scripts'.

const _binDir = path.join(installDir, 'bin');

// On Linux and macOS, the Python interpreter is in 'bin'.

// On Windows, it is in the installation root.

const pythonLocation = IS_WINDOWS ? installDir : _binDir;

core.exportVariable('pythonLocation', pythonLocation);

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);

return {impl: impl, version: versionFromPath(installDir)};

}

async function useCpythonVersion(

version: string,

architecture: string

): Promise<InstalledVersion> {

const desugaredVersionSpec = desugarDevVersion(version);

const semanticVersionSpec = pythonVersionToSemantic(desugaredVersionSpec);

core.debug(`Semantic version spec of ${version} is ${semanticVersionSpec}`);

let installDir: string | null = tc.find(

'Python',

semanticVersionSpec,

architecture

);

if (!installDir) {

core.info(

`Version ${semanticVersionSpec} was not found in the local cache`

);

const foundRelease = await installer.findReleaseFromManifest(

semanticVersionSpec,

architecture

);

if (foundRelease && foundRelease.files && foundRelease.files.length > 0) {

core.info(`Version ${semanticVersionSpec} is available for downloading`);

await installer.installCpythonFromRelease(foundRelease);

installDir = tc.find('Python', semanticVersionSpec, architecture);

}

}

if (!installDir) {

throw new Error(

[

`Version ${version} with arch ${architecture} not found`,

`The list of all available versions can be found here: ${installer.MANIFEST_URL}`

].join(os.EOL)

);

}

core.exportVariable('pythonLocation', installDir);

if (IS_LINUX) {

const libPath = process.env.LD_LIBRARY_PATH

? `:${process.env.LD_LIBRARY_PATH}`

: '';

const pyLibPath = path.join(installDir, 'lib');

if (!libPath.split(':').includes(pyLibPath)) {

core.exportVariable('LD_LIBRARY_PATH', pyLibPath + libPath);

}

}

core.addPath(installDir);

core.addPath(binDir(installDir));

if (IS_WINDOWS) {

// Add --user directory

// `installDir` from tool cache should look like $RUNNER_TOOL_CACHE/Python/<semantic version>/x64/

// So if `findLocalTool` succeeded above, we must have a conformant `installDir`

const version = path.basename(path.dirname(installDir));

const major = semver.major(version);

const minor = semver.minor(version);

const userScriptsDir = path.join(

process.env['APPDATA'] || '',

'Python',

`Python${major}${minor}`,

'Scripts'

);

core.addPath(userScriptsDir);

}

// On Linux and macOS, pip will create the --user directory and add it to PATH as needed.

const installed = versionFromPath(installDir);

core.setOutput('python-version', installed);

return {impl: 'CPython', version: installed};

}

/** Convert versions like `3.8-dev` to a version like `>= 3.8.0-a0`. */

function desugarDevVersion(versionSpec: string) {

if (versionSpec.endsWith('-dev')) {

const versionRoot = versionSpec.slice(0, -'-dev'.length);

return `>= ${versionRoot}.0-a0`;

} else {

return versionSpec;

}

}

/** Extracts python version from install path from hosted tool cache as described in README.md */

function versionFromPath(installDir: string) {

const parts = installDir.split(path.sep);

const idx = parts.findIndex(part => part === 'PyPy' || part === 'Python');

return parts[idx + 1] || '';

}

interface InstalledVersion {

impl: string;

version: string;

}

/**

* Python's prelease versions look like `3.7.0b2`.

* This is the one part of Python versioning that does not look like semantic versioning, which specifies `3.7.0-b2`.

* If the version spec contains prerelease versions, we need to convert them to the semantic version equivalent.

*/

export function pythonVersionToSemantic(versionSpec: string) {

const prereleaseVersion = /(\d+\.\d+\.\d+)((?:a|b|rc)\d*)/g;

return versionSpec.replace(prereleaseVersion, '$1-$2');

}

export async function findPythonVersion(

version: string,

architecture: string

): Promise<InstalledVersion> {

switch (version.toUpperCase()) {

case 'PYPY2':

return usePyPy('2', architecture);

case 'PYPY3':

// keep pypy3 pointing to 3.6 for backward compatibility

return usePyPy('3.6', architecture);

default:

return await useCpythonVersion(version, architecture);

}

}