FilesExpand file tree

 main

/

find-python.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

180 lines (156 loc) · 5.95 KB

 main

/

find-python.ts

Copy path

Top

File metadata and controls

• Code
• Blame

180 lines (156 loc) · 5.95 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

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

}

}

export async function useCpythonVersion(

version: string,

architecture: string,

updateEnvironment: boolean,

checkLatest: boolean

): Promise<InstalledVersion> {

let manifest: tc.IToolRelease[] | null = null;

const desugaredVersionSpec = desugarDevVersion(version);

let semanticVersionSpec = pythonVersionToSemantic(desugaredVersionSpec);

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

if (checkLatest) {

manifest = await installer.getManifest();

const resolvedVersion = (

await installer.findReleaseFromManifest(

semanticVersionSpec,

architecture,

manifest

)

)?.version;

if (resolvedVersion) {

semanticVersionSpec = resolvedVersion;

core.info(`Resolved as '${semanticVersionSpec}'`);

} else {

core.info(

`Failed to resolve version ${semanticVersionSpec} from manifest`

);

}

}

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,

manifest

);

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)

);

}

const _binDir = binDir(installDir);

const binaryExtension = IS_WINDOWS ? '.exe' : '';

const pythonPath = path.join(

IS_WINDOWS ? installDir : _binDir,

`python${binaryExtension}`

);

if (updateEnvironment) {

core.exportVariable('pythonLocation', installDir);

core.exportVariable('PKG_CONFIG_PATH', installDir + '/lib/pkgconfig');

core.exportVariable('pythonLocation', installDir);

// https://cmake.org/cmake/help/latest/module/FindPython.html#module:FindPython

core.exportVariable('Python_ROOT_DIR', installDir);

// https://cmake.org/cmake/help/latest/module/FindPython2.html#module:FindPython2

core.exportVariable('Python2_ROOT_DIR', installDir);

// https://cmake.org/cmake/help/latest/module/FindPython3.html#module:FindPython3

core.exportVariable('Python3_ROOT_DIR', installDir);

core.exportVariable('PKG_CONFIG_PATH', installDir + '/lib/pkgconfig');

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

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

core.setOutput('python-path', pythonPath);

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

}

/** Convert versions like `3.8-dev` to a version like `~3.8.0-0`. */

function desugarDevVersion(versionSpec: string) {

const devVersion = /^(\d+)\.(\d+)-dev$/;

return versionSpec.replace(devVersion, '~$1.$2.0-0');

}

/** 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');

}