blob: 1a129737a8035ee2bdb8b829918f4ad329713f64 [file] [log] [blame]
Nan Zhangdb0b9a32017-02-27 10:12:13 -08001// Copyright 2017 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package python
16
17// This file contains the "Base" module type for building Python program.
18
19import (
20 "fmt"
21 "path/filepath"
22 "regexp"
Nan Zhangdb0b9a32017-02-27 10:12:13 -080023 "strings"
24
25 "github.com/google/blueprint"
Nan Zhangd4e641b2017-07-12 12:55:28 -070026 "github.com/google/blueprint/proptools"
Nan Zhangdb0b9a32017-02-27 10:12:13 -080027
28 "android/soong/android"
29)
30
31func init() {
Paul Duffind0890452021-03-17 21:57:08 +000032 registerPythonMutators(android.InitRegistrationContext)
33}
34
35func registerPythonMutators(ctx android.RegistrationContext) {
36 ctx.PreDepsMutators(RegisterPythonPreDepsMutators)
Liz Kammerdd849a82020-06-12 16:38:45 -070037}
38
Liz Kammerd737d022020-11-16 15:42:51 -080039// Exported to support other packages using Python modules in tests.
Liz Kammerdd849a82020-06-12 16:38:45 -070040func RegisterPythonPreDepsMutators(ctx android.RegisterMutatorsContext) {
Colin Crosse20113d2020-11-22 19:37:44 -080041 ctx.BottomUp("python_version", versionSplitMutator()).Parallel()
Nan Zhangdb0b9a32017-02-27 10:12:13 -080042}
43
Liz Kammerd737d022020-11-16 15:42:51 -080044// the version-specific properties that apply to python modules.
Nan Zhangd4e641b2017-07-12 12:55:28 -070045type VersionProperties struct {
Liz Kammerd737d022020-11-16 15:42:51 -080046 // whether the module is required to be built with this version.
47 // Defaults to true for Python 3, and false otherwise.
Liz Kammer59c0eae2021-09-17 17:48:05 -040048 Enabled *bool
Nan Zhangdb0b9a32017-02-27 10:12:13 -080049
Liz Kammerd737d022020-11-16 15:42:51 -080050 // list of source files specific to this Python version.
51 // Using the syntax ":module", srcs may reference the outputs of other modules that produce source files,
52 // e.g. genrule or filegroup.
Colin Cross27b922f2019-03-04 22:35:41 -080053 Srcs []string `android:"path,arch_variant"`
Nan Zhangd4e641b2017-07-12 12:55:28 -070054
Liz Kammerd737d022020-11-16 15:42:51 -080055 // list of source files that should not be used to build the Python module for this version.
56 // This is most useful to remove files that are not common to all Python versions.
Colin Cross27b922f2019-03-04 22:35:41 -080057 Exclude_srcs []string `android:"path,arch_variant"`
Nan Zhangdb0b9a32017-02-27 10:12:13 -080058
Liz Kammerd737d022020-11-16 15:42:51 -080059 // list of the Python libraries used only for this Python version.
Nan Zhangd4e641b2017-07-12 12:55:28 -070060 Libs []string `android:"arch_variant"`
61
Liz Kammerd737d022020-11-16 15:42:51 -080062 // whether the binary is required to be built with embedded launcher for this version, defaults to false.
Liz Kammer59c0eae2021-09-17 17:48:05 -040063 Embedded_launcher *bool // TODO(b/174041232): Remove this property
Nan Zhangdb0b9a32017-02-27 10:12:13 -080064}
65
Liz Kammerd737d022020-11-16 15:42:51 -080066// properties that apply to all python modules
Nan Zhangd4e641b2017-07-12 12:55:28 -070067type BaseProperties struct {
Nan Zhangdb0b9a32017-02-27 10:12:13 -080068 // the package path prefix within the output artifact at which to place the source/data
69 // files of the current module.
70 // eg. Pkg_path = "a/b/c"; Other packages can reference this module by using
71 // (from a.b.c import ...) statement.
Nan Zhangbea09752018-05-31 12:49:33 -070072 // if left unspecified, all the source/data files path is unchanged within zip file.
Liz Kammer59c0eae2021-09-17 17:48:05 -040073 Pkg_path *string
Nan Zhangd4e641b2017-07-12 12:55:28 -070074
75 // true, if the Python module is used internally, eg, Python std libs.
Liz Kammer59c0eae2021-09-17 17:48:05 -040076 Is_internal *bool
Nan Zhangdb0b9a32017-02-27 10:12:13 -080077
78 // list of source (.py) files compatible both with Python2 and Python3 used to compile the
79 // Python module.
80 // srcs may reference the outputs of other modules that produce source files like genrule
81 // or filegroup using the syntax ":module".
82 // Srcs has to be non-empty.
Colin Cross27b922f2019-03-04 22:35:41 -080083 Srcs []string `android:"path,arch_variant"`
Nan Zhangd4e641b2017-07-12 12:55:28 -070084
85 // list of source files that should not be used to build the C/C++ module.
86 // This is most useful in the arch/multilib variants to remove non-common files
Colin Cross27b922f2019-03-04 22:35:41 -080087 Exclude_srcs []string `android:"path,arch_variant"`
Nan Zhangdb0b9a32017-02-27 10:12:13 -080088
89 // list of files or filegroup modules that provide data that should be installed alongside
90 // the test. the file extension can be arbitrary except for (.py).
Colin Cross27b922f2019-03-04 22:35:41 -080091 Data []string `android:"path,arch_variant"`
Nan Zhangdb0b9a32017-02-27 10:12:13 -080092
Colin Cross1bc63932020-11-22 20:12:45 -080093 // list of java modules that provide data that should be installed alongside the test.
94 Java_data []string
95
Nan Zhangdb0b9a32017-02-27 10:12:13 -080096 // list of the Python libraries compatible both with Python2 and Python3.
Nan Zhangd4e641b2017-07-12 12:55:28 -070097 Libs []string `android:"arch_variant"`
Nan Zhangdb0b9a32017-02-27 10:12:13 -080098
99 Version struct {
Liz Kammerd737d022020-11-16 15:42:51 -0800100 // Python2-specific properties, including whether Python2 is supported for this module
101 // and version-specific sources, exclusions and dependencies.
Nan Zhangd4e641b2017-07-12 12:55:28 -0700102 Py2 VersionProperties `android:"arch_variant"`
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800103
Liz Kammerd737d022020-11-16 15:42:51 -0800104 // Python3-specific properties, including whether Python3 is supported for this module
105 // and version-specific sources, exclusions and dependencies.
Nan Zhangd4e641b2017-07-12 12:55:28 -0700106 Py3 VersionProperties `android:"arch_variant"`
107 } `android:"arch_variant"`
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800108
109 // the actual version each module uses after variations created.
110 // this property name is hidden from users' perspectives, and soong will populate it during
111 // runtime.
Nan Zhangd4e641b2017-07-12 12:55:28 -0700112 Actual_version string `blueprint:"mutated"`
Liz Kammer7e93e5b2020-10-30 15:44:09 -0700113
Liz Kammerd737d022020-11-16 15:42:51 -0800114 // whether the module is required to be built with actual_version.
115 // this is set by the python version mutator based on version-specific properties
Liz Kammer7e93e5b2020-10-30 15:44:09 -0700116 Enabled *bool `blueprint:"mutated"`
117
Liz Kammerd737d022020-11-16 15:42:51 -0800118 // whether the binary is required to be built with embedded launcher for this actual_version.
119 // this is set by the python version mutator based on version-specific properties
Liz Kammer7e93e5b2020-10-30 15:44:09 -0700120 Embedded_launcher *bool `blueprint:"mutated"`
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800121}
122
Liz Kammerd737d022020-11-16 15:42:51 -0800123// Used to store files of current module after expanding dependencies
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800124type pathMapping struct {
125 dest string
126 src android.Path
127}
128
Cole Faust4d247e62023-01-23 10:14:58 -0800129type PythonLibraryModule struct {
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800130 android.ModuleBase
Nan Zhanga3fc4ba2017-07-20 17:43:37 -0700131 android.DefaultableModuleBase
Jingwen Chen13b9b422021-03-08 07:32:28 -0500132 android.BazelModuleBase
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800133
Nan Zhangb8fa1972017-12-22 16:12:00 -0800134 properties BaseProperties
135 protoProperties android.ProtoProperties
Nan Zhangd4e641b2017-07-12 12:55:28 -0700136
137 // initialize before calling Init
138 hod android.HostOrDeviceSupported
139 multilib android.Multilib
140
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800141 // the Python files of current module after expanding source dependencies.
142 // pathMapping: <dest: runfile_path, src: source_path>
143 srcsPathMappings []pathMapping
144
145 // the data files of current module after expanding source dependencies.
146 // pathMapping: <dest: runfile_path, src: source_path>
147 dataPathMappings []pathMapping
148
Cole Faust5c503d12023-01-24 11:48:08 -0800149 // The zip file containing the current module's source/data files.
Nan Zhang1db85402017-12-18 13:20:23 -0800150 srcsZip android.Path
Cole Faust5c503d12023-01-24 11:48:08 -0800151
152 // The zip file containing the current module's source/data files, with the
153 // source files precompiled.
154 precompiledSrcsZip android.Path
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800155}
156
Liz Kammerd737d022020-11-16 15:42:51 -0800157// newModule generates new Python base module
Cole Faust4d247e62023-01-23 10:14:58 -0800158func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *PythonLibraryModule {
159 return &PythonLibraryModule{
Nan Zhangd4e641b2017-07-12 12:55:28 -0700160 hod: hod,
161 multilib: multilib,
162 }
163}
164
Liz Kammerd737d022020-11-16 15:42:51 -0800165// interface implemented by Python modules to provide source and data mappings and zip to python
166// modules that depend on it
167type pythonDependency interface {
168 getSrcsPathMappings() []pathMapping
169 getDataPathMappings() []pathMapping
170 getSrcsZip() android.Path
Cole Faust5c503d12023-01-24 11:48:08 -0800171 getPrecompiledSrcsZip() android.Path
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800172}
173
Liz Kammerd737d022020-11-16 15:42:51 -0800174// getSrcsPathMappings gets this module's path mapping of src source path : runfiles destination
Cole Faust4d247e62023-01-23 10:14:58 -0800175func (p *PythonLibraryModule) getSrcsPathMappings() []pathMapping {
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800176 return p.srcsPathMappings
177}
178
Liz Kammerd737d022020-11-16 15:42:51 -0800179// getSrcsPathMappings gets this module's path mapping of data source path : runfiles destination
Cole Faust4d247e62023-01-23 10:14:58 -0800180func (p *PythonLibraryModule) getDataPathMappings() []pathMapping {
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800181 return p.dataPathMappings
182}
183
Liz Kammerd737d022020-11-16 15:42:51 -0800184// getSrcsZip returns the filepath where the current module's source/data files are zipped.
Cole Faust4d247e62023-01-23 10:14:58 -0800185func (p *PythonLibraryModule) getSrcsZip() android.Path {
Nan Zhang1db85402017-12-18 13:20:23 -0800186 return p.srcsZip
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800187}
188
Cole Faust5c503d12023-01-24 11:48:08 -0800189// getSrcsZip returns the filepath where the current module's source/data files are zipped.
190func (p *PythonLibraryModule) getPrecompiledSrcsZip() android.Path {
191 return p.precompiledSrcsZip
192}
193
Cole Faust4d247e62023-01-23 10:14:58 -0800194func (p *PythonLibraryModule) getBaseProperties() *BaseProperties {
195 return &p.properties
196}
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800197
Cole Faust4d247e62023-01-23 10:14:58 -0800198var _ pythonDependency = (*PythonLibraryModule)(nil)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800199
Cole Faust4d247e62023-01-23 10:14:58 -0800200func (p *PythonLibraryModule) init() android.Module {
Nan Zhangb8fa1972017-12-22 16:12:00 -0800201 p.AddProperties(&p.properties, &p.protoProperties)
Nan Zhangd4e641b2017-07-12 12:55:28 -0700202 android.InitAndroidArchModule(p, p.hod, p.multilib)
Nan Zhanga3fc4ba2017-07-20 17:43:37 -0700203 android.InitDefaultableModule(p)
Cole Faust4d247e62023-01-23 10:14:58 -0800204 android.InitBazelModule(p)
Nan Zhangd4e641b2017-07-12 12:55:28 -0700205 return p
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800206}
207
Liz Kammerd737d022020-11-16 15:42:51 -0800208// Python-specific tag to transfer information on the purpose of a dependency.
209// This is used when adding a dependency on a module, which can later be accessed when visiting
210// dependencies.
Nan Zhangd4e641b2017-07-12 12:55:28 -0700211type dependencyTag struct {
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800212 blueprint.BaseDependencyTag
Nan Zhangd4e641b2017-07-12 12:55:28 -0700213 name string
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800214}
215
Liz Kammerd737d022020-11-16 15:42:51 -0800216// Python-specific tag that indicates that installed files of this module should depend on installed
217// files of the dependency
Colin Crosse9fe2942020-11-10 18:12:15 -0800218type installDependencyTag struct {
219 blueprint.BaseDependencyTag
Liz Kammerd737d022020-11-16 15:42:51 -0800220 // embedding this struct provides the installation dependency requirement
Colin Crosse9fe2942020-11-10 18:12:15 -0800221 android.InstallAlwaysNeededDependencyTag
222 name string
223}
224
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800225var (
Cole Faust5c503d12023-01-24 11:48:08 -0800226 pythonLibTag = dependencyTag{name: "pythonLib"}
227 javaDataTag = dependencyTag{name: "javaData"}
228 // The python interpreter, with soong module name "py3-launcher" or "py3-launcher-autorun".
Cole Faust909d2372023-02-13 23:17:40 +0000229 launcherTag = dependencyTag{name: "launcher"}
230 launcherSharedLibTag = installDependencyTag{name: "launcherSharedLib"}
Cole Faust5c503d12023-01-24 11:48:08 -0800231 // The python interpreter built for host so that we can precompile python sources.
232 // This only works because the precompiled sources don't vary by architecture.
233 // The soong module name is "py3-launcher".
Cole Faust909d2372023-02-13 23:17:40 +0000234 hostLauncherTag = dependencyTag{name: "hostLauncher"}
235 hostlauncherSharedLibTag = dependencyTag{name: "hostlauncherSharedLib"}
236 hostStdLibTag = dependencyTag{name: "hostStdLib"}
237 pathComponentRegexp = regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_-]*$`)
238 pyExt = ".py"
239 protoExt = ".proto"
240 pyVersion2 = "PY2"
241 pyVersion3 = "PY3"
Cole Faustd82f0362023-04-12 17:32:19 -0700242 pyVersion2And3 = "PY2ANDPY3"
Cole Faust909d2372023-02-13 23:17:40 +0000243 internalPath = "internal"
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800244)
245
Cole Faust4d247e62023-01-23 10:14:58 -0800246type basePropertiesProvider interface {
247 getBaseProperties() *BaseProperties
248}
249
Liz Kammerd737d022020-11-16 15:42:51 -0800250// versionSplitMutator creates version variants for modules and appends the version-specific
251// properties for a given variant to the properties in the variant module
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800252func versionSplitMutator() func(android.BottomUpMutatorContext) {
253 return func(mctx android.BottomUpMutatorContext) {
Cole Faust4d247e62023-01-23 10:14:58 -0800254 if base, ok := mctx.Module().(basePropertiesProvider); ok {
255 props := base.getBaseProperties()
256 var versionNames []string
Liz Kammerd737d022020-11-16 15:42:51 -0800257 // collect version specific properties, so that we can merge version-specific properties
258 // into the module's overall properties
Cole Faust4d247e62023-01-23 10:14:58 -0800259 var versionProps []VersionProperties
Liz Kammerdd849a82020-06-12 16:38:45 -0700260 // PY3 is first so that we alias the PY3 variant rather than PY2 if both
261 // are available
Cole Faust4d247e62023-01-23 10:14:58 -0800262 if proptools.BoolDefault(props.Version.Py3.Enabled, true) {
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800263 versionNames = append(versionNames, pyVersion3)
Cole Faust4d247e62023-01-23 10:14:58 -0800264 versionProps = append(versionProps, props.Version.Py3)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800265 }
Cole Faust4d247e62023-01-23 10:14:58 -0800266 if proptools.BoolDefault(props.Version.Py2.Enabled, false) {
Cole Faustedc4c502022-09-09 19:39:25 -0700267 if !mctx.DeviceConfig().BuildBrokenUsesSoongPython2Modules() &&
268 mctx.ModuleName() != "par_test" &&
269 mctx.ModuleName() != "py2-cmd" &&
270 mctx.ModuleName() != "py2-stdlib" {
271 mctx.PropertyErrorf("version.py2.enabled", "Python 2 is no longer supported, please convert to python 3. This error can be temporarily overridden by setting BUILD_BROKEN_USES_SOONG_PYTHON2_MODULES := true in the product configuration")
272 }
Liz Kammerdd849a82020-06-12 16:38:45 -0700273 versionNames = append(versionNames, pyVersion2)
Cole Faust4d247e62023-01-23 10:14:58 -0800274 versionProps = append(versionProps, props.Version.Py2)
Liz Kammerdd849a82020-06-12 16:38:45 -0700275 }
Colin Crosse20113d2020-11-22 19:37:44 -0800276 modules := mctx.CreateLocalVariations(versionNames...)
Liz Kammerd737d022020-11-16 15:42:51 -0800277 // Alias module to the first variant
Liz Kammerdd849a82020-06-12 16:38:45 -0700278 if len(versionNames) > 0 {
279 mctx.AliasVariation(versionNames[0])
280 }
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800281 for i, v := range versionNames {
282 // set the actual version for Python module.
Cole Faust4d247e62023-01-23 10:14:58 -0800283 newProps := modules[i].(basePropertiesProvider).getBaseProperties()
284 newProps.Actual_version = v
Liz Kammerd737d022020-11-16 15:42:51 -0800285 // append versioned properties for the Python module to the overall properties
Cole Faust4d247e62023-01-23 10:14:58 -0800286 err := proptools.AppendMatchingProperties([]interface{}{newProps}, &versionProps[i], nil)
Liz Kammer7e93e5b2020-10-30 15:44:09 -0700287 if err != nil {
288 panic(err)
289 }
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800290 }
291 }
292 }
293}
294
Liz Kammerd737d022020-11-16 15:42:51 -0800295func anyHasExt(paths []string, ext string) bool {
296 for _, p := range paths {
297 if filepath.Ext(p) == ext {
Nan Zhangb8fa1972017-12-22 16:12:00 -0800298 return true
299 }
300 }
301
302 return false
303}
304
Cole Faust4d247e62023-01-23 10:14:58 -0800305func (p *PythonLibraryModule) anySrcHasExt(ctx android.BottomUpMutatorContext, ext string) bool {
Liz Kammerd737d022020-11-16 15:42:51 -0800306 return anyHasExt(p.properties.Srcs, ext)
Nan Zhangb8fa1972017-12-22 16:12:00 -0800307}
308
Liz Kammerd737d022020-11-16 15:42:51 -0800309// DepsMutator mutates dependencies for this module:
Colin Crossd079e0b2022-08-16 10:27:33 -0700310// - handles proto dependencies,
311// - if required, specifies launcher and adds launcher dependencies,
312// - applies python version mutations to Python dependencies
Cole Faust4d247e62023-01-23 10:14:58 -0800313func (p *PythonLibraryModule) DepsMutator(ctx android.BottomUpMutatorContext) {
Colin Crossfe17f6f2019-03-28 19:30:56 -0700314 android.ProtoDeps(ctx, &p.protoProperties)
315
Colin Crosse20113d2020-11-22 19:37:44 -0800316 versionVariation := []blueprint.Variation{
317 {"python_version", p.properties.Actual_version},
Nan Zhangb8fa1972017-12-22 16:12:00 -0800318 }
Colin Crosse20113d2020-11-22 19:37:44 -0800319
Liz Kammerd737d022020-11-16 15:42:51 -0800320 // If sources contain a proto file, add dependency on libprotobuf-python
321 if p.anySrcHasExt(ctx, protoExt) && p.Name() != "libprotobuf-python" {
Colin Crosse20113d2020-11-22 19:37:44 -0800322 ctx.AddVariationDependencies(versionVariation, pythonLibTag, "libprotobuf-python")
323 }
Liz Kammerd737d022020-11-16 15:42:51 -0800324
325 // Add python library dependencies for this python version variation
Colin Crosse20113d2020-11-22 19:37:44 -0800326 ctx.AddVariationDependencies(versionVariation, pythonLibTag, android.LastUniqueStrings(p.properties.Libs)...)
Liz Kammer7e93e5b2020-10-30 15:44:09 -0700327
Colin Cross1bc63932020-11-22 20:12:45 -0800328 // Emulate the data property for java_data but with the arch variation overridden to "common"
329 // so that it can point to java modules.
330 javaDataVariation := []blueprint.Variation{{"arch", android.Common.String()}}
331 ctx.AddVariationDependencies(javaDataVariation, javaDataTag, p.properties.Java_data...)
Cole Faust5c503d12023-01-24 11:48:08 -0800332
Cole Faust909d2372023-02-13 23:17:40 +0000333 p.AddDepsOnPythonLauncherAndStdlib(ctx, hostStdLibTag, hostLauncherTag, hostlauncherSharedLibTag, false, ctx.Config().BuildOSTarget)
Cole Faust5c503d12023-01-24 11:48:08 -0800334}
335
Cole Faust909d2372023-02-13 23:17:40 +0000336// AddDepsOnPythonLauncherAndStdlib will make the current module depend on the python stdlib,
337// launcher (interpreter), and the launcher's shared libraries. If autorun is true, it will use
338// the autorun launcher instead of the regular one. This function acceps a targetForDeps argument
339// as the target to use for these dependencies. For embedded launcher python binaries, the launcher
340// that will be embedded will be under the same target as the python module itself. But when
341// precompiling python code, we need to get the python launcher built for host, even if we're
342// compiling the python module for device, so we pass a different target to this function.
Cole Faust5c503d12023-01-24 11:48:08 -0800343func (p *PythonLibraryModule) AddDepsOnPythonLauncherAndStdlib(ctx android.BottomUpMutatorContext,
Cole Faust909d2372023-02-13 23:17:40 +0000344 stdLibTag, launcherTag, launcherSharedLibTag blueprint.DependencyTag,
Cole Faust5c503d12023-01-24 11:48:08 -0800345 autorun bool, targetForDeps android.Target) {
346 var stdLib string
347 var launcherModule string
Cole Faust909d2372023-02-13 23:17:40 +0000348 // Add launcher shared lib dependencies. Ideally, these should be
349 // derived from the `shared_libs` property of the launcher. TODO: read these from
350 // the python launcher itself using ctx.OtherModuleProvider() or similar on the result
351 // of ctx.AddFarVariationDependencies()
352 launcherSharedLibDeps := []string{
353 "libsqlite",
354 }
355 // Add launcher-specific dependencies for bionic
356 if targetForDeps.Os.Bionic() {
357 launcherSharedLibDeps = append(launcherSharedLibDeps, "libc", "libdl", "libm")
358 }
359 if targetForDeps.Os == android.LinuxMusl && !ctx.Config().HostStaticBinaries() {
360 launcherSharedLibDeps = append(launcherSharedLibDeps, "libc_musl")
361 }
Cole Faust5c503d12023-01-24 11:48:08 -0800362
363 switch p.properties.Actual_version {
364 case pyVersion2:
365 stdLib = "py2-stdlib"
366
367 launcherModule = "py2-launcher"
368 if autorun {
369 launcherModule = "py2-launcher-autorun"
370 }
371
Cole Faust909d2372023-02-13 23:17:40 +0000372 launcherSharedLibDeps = append(launcherSharedLibDeps, "libc++")
Cole Faust5c503d12023-01-24 11:48:08 -0800373 case pyVersion3:
374 stdLib = "py3-stdlib"
375
376 launcherModule = "py3-launcher"
377 if autorun {
378 launcherModule = "py3-launcher-autorun"
379 }
380 if ctx.Config().HostStaticBinaries() && targetForDeps.Os == android.LinuxMusl {
381 launcherModule += "-static"
382 }
Cole Faust909d2372023-02-13 23:17:40 +0000383 if ctx.Device() {
384 launcherSharedLibDeps = append(launcherSharedLibDeps, "liblog")
385 }
Cole Faust5c503d12023-01-24 11:48:08 -0800386 default:
387 panic(fmt.Errorf("unknown Python Actual_version: %q for module: %q.",
388 p.properties.Actual_version, ctx.ModuleName()))
389 }
390 targetVariations := targetForDeps.Variations()
391 if ctx.ModuleName() != stdLib {
392 stdLibVariations := make([]blueprint.Variation, 0, len(targetVariations)+1)
393 stdLibVariations = append(stdLibVariations, blueprint.Variation{Mutator: "python_version", Variation: p.properties.Actual_version})
394 stdLibVariations = append(stdLibVariations, targetVariations...)
395 // Using AddFarVariationDependencies for all of these because they can be for a different
396 // platform, like if the python module itself was being compiled for device, we may want
397 // the python interpreter built for host so that we can precompile python sources.
398 ctx.AddFarVariationDependencies(stdLibVariations, stdLibTag, stdLib)
399 }
400 ctx.AddFarVariationDependencies(targetVariations, launcherTag, launcherModule)
Cole Faust909d2372023-02-13 23:17:40 +0000401 ctx.AddFarVariationDependencies(targetVariations, launcherSharedLibTag, launcherSharedLibDeps...)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800402}
403
Cole Faust4d247e62023-01-23 10:14:58 -0800404// GenerateAndroidBuildActions performs build actions common to all Python modules
405func (p *PythonLibraryModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Liz Kammerd737d022020-11-16 15:42:51 -0800406 expandedSrcs := android.PathsForModuleSrcExcludes(ctx, p.properties.Srcs, p.properties.Exclude_srcs)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800407
408 // expand data files from "data" property.
Colin Cross8a497952019-03-05 22:25:09 -0800409 expandedData := android.PathsForModuleSrc(ctx, p.properties.Data)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800410
Colin Cross1bc63932020-11-22 20:12:45 -0800411 // Emulate the data property for java_data dependencies.
412 for _, javaData := range ctx.GetDirectDepsWithTag(javaDataTag) {
413 expandedData = append(expandedData, android.OutputFilesForModule(ctx, javaData, "")...)
414 }
415
Liz Kammerd737d022020-11-16 15:42:51 -0800416 // Validate pkg_path property
Nan Zhang1db85402017-12-18 13:20:23 -0800417 pkgPath := String(p.properties.Pkg_path)
418 if pkgPath != "" {
Liz Kammerd737d022020-11-16 15:42:51 -0800419 // TODO: export validation from android/paths.go handling to replace this duplicated functionality
Nan Zhang1db85402017-12-18 13:20:23 -0800420 pkgPath = filepath.Clean(String(p.properties.Pkg_path))
421 if pkgPath == ".." || strings.HasPrefix(pkgPath, "../") ||
422 strings.HasPrefix(pkgPath, "/") {
Nan Zhangd4e641b2017-07-12 12:55:28 -0700423 ctx.PropertyErrorf("pkg_path",
424 "%q must be a relative path contained in par file.",
Nan Zhangea568a42017-11-08 21:20:04 -0800425 String(p.properties.Pkg_path))
Nan Zhangd4e641b2017-07-12 12:55:28 -0700426 return
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800427 }
Liz Kammerd737d022020-11-16 15:42:51 -0800428 }
429 // If property Is_internal is set, prepend pkgPath with internalPath
430 if proptools.BoolDefault(p.properties.Is_internal, false) {
431 pkgPath = filepath.Join(internalPath, pkgPath)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800432 }
433
Liz Kammerd737d022020-11-16 15:42:51 -0800434 // generate src:destination path mappings for this module
Nan Zhang1db85402017-12-18 13:20:23 -0800435 p.genModulePathMappings(ctx, pkgPath, expandedSrcs, expandedData)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800436
Liz Kammerd737d022020-11-16 15:42:51 -0800437 // generate the zipfile of all source and data files
Nan Zhang1db85402017-12-18 13:20:23 -0800438 p.srcsZip = p.createSrcsZip(ctx, pkgPath)
Cole Faust5c503d12023-01-24 11:48:08 -0800439 p.precompiledSrcsZip = p.precompileSrcs(ctx)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800440}
441
Liz Kammerd737d022020-11-16 15:42:51 -0800442func isValidPythonPath(path string) error {
443 identifiers := strings.Split(strings.TrimSuffix(path, filepath.Ext(path)), "/")
444 for _, token := range identifiers {
445 if !pathComponentRegexp.MatchString(token) {
446 return fmt.Errorf("the path %q contains invalid subpath %q. "+
447 "Subpaths must be at least one character long. "+
448 "The first character must an underscore or letter. "+
449 "Following characters may be any of: letter, digit, underscore, hyphen.",
450 path, token)
451 }
452 }
453 return nil
454}
455
456// For this module, generate unique pathMappings: <dest: runfiles_path, src: source_path>
457// for python/data files expanded from properties.
Cole Faust4d247e62023-01-23 10:14:58 -0800458func (p *PythonLibraryModule) genModulePathMappings(ctx android.ModuleContext, pkgPath string,
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800459 expandedSrcs, expandedData android.Paths) {
460 // fetch <runfiles_path, source_path> pairs from "src" and "data" properties to
Nan Zhangb8fa1972017-12-22 16:12:00 -0800461 // check current module duplicates.
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800462 destToPySrcs := make(map[string]string)
463 destToPyData := make(map[string]string)
464
465 for _, s := range expandedSrcs {
Nan Zhangb8fa1972017-12-22 16:12:00 -0800466 if s.Ext() != pyExt && s.Ext() != protoExt {
467 ctx.PropertyErrorf("srcs", "found non (.py|.proto) file: %q!", s.String())
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800468 continue
469 }
Nan Zhang1db85402017-12-18 13:20:23 -0800470 runfilesPath := filepath.Join(pkgPath, s.Rel())
Liz Kammerd737d022020-11-16 15:42:51 -0800471 if err := isValidPythonPath(runfilesPath); err != nil {
472 ctx.PropertyErrorf("srcs", err.Error())
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800473 }
Liz Kammerd737d022020-11-16 15:42:51 -0800474 if !checkForDuplicateOutputPath(ctx, destToPySrcs, runfilesPath, s.String(), p.Name(), p.Name()) {
475 p.srcsPathMappings = append(p.srcsPathMappings, pathMapping{dest: runfilesPath, src: s})
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800476 }
477 }
478
479 for _, d := range expandedData {
Nan Zhangb8fa1972017-12-22 16:12:00 -0800480 if d.Ext() == pyExt || d.Ext() == protoExt {
481 ctx.PropertyErrorf("data", "found (.py|.proto) file: %q!", d.String())
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800482 continue
483 }
Nan Zhang1db85402017-12-18 13:20:23 -0800484 runfilesPath := filepath.Join(pkgPath, d.Rel())
Liz Kammerd737d022020-11-16 15:42:51 -0800485 if !checkForDuplicateOutputPath(ctx, destToPyData, runfilesPath, d.String(), p.Name(), p.Name()) {
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800486 p.dataPathMappings = append(p.dataPathMappings,
487 pathMapping{dest: runfilesPath, src: d})
488 }
489 }
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800490}
491
Liz Kammerd737d022020-11-16 15:42:51 -0800492// createSrcsZip registers build actions to zip current module's sources and data.
Cole Faust4d247e62023-01-23 10:14:58 -0800493func (p *PythonLibraryModule) createSrcsZip(ctx android.ModuleContext, pkgPath string) android.Path {
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800494 relativeRootMap := make(map[string]android.Paths)
Nan Zhangb8fa1972017-12-22 16:12:00 -0800495 var protoSrcs android.Paths
Cole Faust5c503d12023-01-24 11:48:08 -0800496 addPathMapping := func(path pathMapping) {
Liz Kammerd737d022020-11-16 15:42:51 -0800497 // handle proto sources separately
Nan Zhangb8fa1972017-12-22 16:12:00 -0800498 if path.src.Ext() == protoExt {
499 protoSrcs = append(protoSrcs, path.src)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800500 } else {
Cole Faust4d247e62023-01-23 10:14:58 -0800501 relativeRoot := strings.TrimSuffix(path.src.String(), path.src.Rel())
502 relativeRootMap[relativeRoot] = append(relativeRootMap[relativeRoot], path.src)
Nan Zhangb8fa1972017-12-22 16:12:00 -0800503 }
504 }
Cole Faust5c503d12023-01-24 11:48:08 -0800505
506 // "srcs" or "data" properties may contain filegroups so it might happen that
507 // the root directory for each source path is different.
508 for _, path := range p.srcsPathMappings {
509 addPathMapping(path)
510 }
511 for _, path := range p.dataPathMappings {
512 addPathMapping(path)
513 }
514
Nan Zhangb8fa1972017-12-22 16:12:00 -0800515 var zips android.Paths
516 if len(protoSrcs) > 0 {
Colin Cross19878da2019-03-28 14:45:07 -0700517 protoFlags := android.GetProtoFlags(ctx, &p.protoProperties)
518 protoFlags.OutTypeFlag = "--python_out"
519
Cole Faustcaf766b2022-10-21 16:07:56 -0700520 if pkgPath != "" {
Cole Faust43ac21f2022-09-19 11:19:52 -0700521 pkgPathStagingDir := android.PathForModuleGen(ctx, "protos_staged_for_pkg_path")
522 rule := android.NewRuleBuilder(pctx, ctx)
523 var stagedProtoSrcs android.Paths
524 for _, srcFile := range protoSrcs {
525 stagedProtoSrc := pkgPathStagingDir.Join(ctx, pkgPath, srcFile.Rel())
526 rule.Command().Text("mkdir -p").Flag(filepath.Base(stagedProtoSrc.String()))
527 rule.Command().Text("cp -f").Input(srcFile).Output(stagedProtoSrc)
528 stagedProtoSrcs = append(stagedProtoSrcs, stagedProtoSrc)
529 }
530 rule.Build("stage_protos_for_pkg_path", "Stage protos for pkg_path")
531 protoSrcs = stagedProtoSrcs
Cole Faust43ac21f2022-09-19 11:19:52 -0700532 }
533
Nan Zhangb8fa1972017-12-22 16:12:00 -0800534 for _, srcFile := range protoSrcs {
Cole Faustcaf766b2022-10-21 16:07:56 -0700535 zip := genProto(ctx, srcFile, protoFlags)
Nan Zhangb8fa1972017-12-22 16:12:00 -0800536 zips = append(zips, zip)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800537 }
538 }
539
Nan Zhangb8fa1972017-12-22 16:12:00 -0800540 if len(relativeRootMap) > 0 {
Nan Zhangb8fa1972017-12-22 16:12:00 -0800541 // in order to keep stable order of soong_zip params, we sort the keys here.
Cole Faust18994c72023-02-28 16:02:16 -0800542 roots := android.SortedKeys(relativeRootMap)
Nan Zhangb8fa1972017-12-22 16:12:00 -0800543
Cole Faust01243362022-06-02 12:11:12 -0700544 // Use -symlinks=false so that the symlinks in the bazel output directory are followed
545 parArgs := []string{"-symlinks=false"}
Nan Zhangf0c4e432018-05-22 14:50:18 -0700546 if pkgPath != "" {
Liz Kammerd737d022020-11-16 15:42:51 -0800547 // use package path as path prefix
Nan Zhangf0c4e432018-05-22 14:50:18 -0700548 parArgs = append(parArgs, `-P `+pkgPath)
549 }
Liz Kammerd737d022020-11-16 15:42:51 -0800550 paths := android.Paths{}
551 for _, root := range roots {
552 // specify relative root of file in following -f arguments
553 parArgs = append(parArgs, `-C `+root)
554 for _, path := range relativeRootMap[root] {
Nan Zhangb8fa1972017-12-22 16:12:00 -0800555 parArgs = append(parArgs, `-f `+path.String())
Liz Kammerd737d022020-11-16 15:42:51 -0800556 paths = append(paths, path)
Nan Zhangb8fa1972017-12-22 16:12:00 -0800557 }
558 }
559
560 origSrcsZip := android.PathForModuleOut(ctx, ctx.ModuleName()+".py.srcszip")
561 ctx.Build(pctx, android.BuildParams{
562 Rule: zip,
563 Description: "python library archive",
564 Output: origSrcsZip,
Liz Kammerd737d022020-11-16 15:42:51 -0800565 // as zip rule does not use $in, there is no real need to distinguish between Inputs and Implicits
566 Implicits: paths,
Nan Zhangb8fa1972017-12-22 16:12:00 -0800567 Args: map[string]string{
568 "args": strings.Join(parArgs, " "),
569 },
570 })
571 zips = append(zips, origSrcsZip)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800572 }
Liz Kammerd737d022020-11-16 15:42:51 -0800573 // we may have multiple zips due to separate handling of proto source files
Nan Zhangb8fa1972017-12-22 16:12:00 -0800574 if len(zips) == 1 {
575 return zips[0]
576 } else {
577 combinedSrcsZip := android.PathForModuleOut(ctx, ctx.ModuleName()+".srcszip")
578 ctx.Build(pctx, android.BuildParams{
579 Rule: combineZip,
580 Description: "combine python library archive",
581 Output: combinedSrcsZip,
582 Inputs: zips,
583 })
584 return combinedSrcsZip
585 }
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800586}
587
Cole Faust5c503d12023-01-24 11:48:08 -0800588func (p *PythonLibraryModule) precompileSrcs(ctx android.ModuleContext) android.Path {
589 // To precompile the python sources, we need a python interpreter and stdlib built
590 // for host. We then use those to compile the python sources, which may be used on either
591 // host of device. Python bytecode is architecture agnostic, so we're essentially
592 // "cross compiling" for device here purely by virtue of host and device python bytecode
593 // being the same.
594 var stdLib android.Path
595 var launcher android.Path
596 if ctx.ModuleName() == "py3-stdlib" || ctx.ModuleName() == "py2-stdlib" {
597 stdLib = p.srcsZip
598 } else {
599 ctx.VisitDirectDepsWithTag(hostStdLibTag, func(module android.Module) {
600 if dep, ok := module.(pythonDependency); ok {
601 stdLib = dep.getPrecompiledSrcsZip()
602 }
603 })
604 }
605 ctx.VisitDirectDepsWithTag(hostLauncherTag, func(module android.Module) {
606 if dep, ok := module.(IntermPathProvider); ok {
607 optionalLauncher := dep.IntermPathForModuleOut()
608 if optionalLauncher.Valid() {
609 launcher = optionalLauncher.Path()
610 }
Cole Faust909d2372023-02-13 23:17:40 +0000611 }
612 })
613 var launcherSharedLibs android.Paths
614 var ldLibraryPath []string
615 ctx.VisitDirectDepsWithTag(hostlauncherSharedLibTag, func(module android.Module) {
616 if dep, ok := module.(IntermPathProvider); ok {
617 optionalPath := dep.IntermPathForModuleOut()
618 if optionalPath.Valid() {
619 launcherSharedLibs = append(launcherSharedLibs, optionalPath.Path())
620 ldLibraryPath = append(ldLibraryPath, filepath.Dir(optionalPath.Path().String()))
Cole Faust5c503d12023-01-24 11:48:08 -0800621 }
622 }
623 })
624
625 out := android.PathForModuleOut(ctx, ctx.ModuleName()+".srcszipprecompiled")
626 if stdLib == nil || launcher == nil {
627 // This shouldn't happen in a real build because we'll error out when adding dependencies
628 // on the stdlib and launcher if they don't exist. But some tests set
629 // AllowMissingDependencies.
630 return out
631 }
632 ctx.Build(pctx, android.BuildParams{
633 Rule: precompile,
634 Input: p.srcsZip,
635 Output: out,
636 Implicits: launcherSharedLibs,
637 Description: "Precompile the python sources of " + ctx.ModuleName(),
638 Args: map[string]string{
639 "stdlibZip": stdLib.String(),
640 "launcher": launcher.String(),
641 "ldLibraryPath": strings.Join(ldLibraryPath, ":"),
642 },
643 })
644 return out
645}
646
Cole Faust4d247e62023-01-23 10:14:58 -0800647// isPythonLibModule returns whether the given module is a Python library PythonLibraryModule or not
Nan Zhangd4e641b2017-07-12 12:55:28 -0700648func isPythonLibModule(module blueprint.Module) bool {
Cole Faust4d247e62023-01-23 10:14:58 -0800649 if _, ok := module.(*PythonLibraryModule); ok {
650 if _, ok := module.(*PythonBinaryModule); !ok {
651 return true
652 }
Nan Zhangd4e641b2017-07-12 12:55:28 -0700653 }
654 return false
655}
656
Liz Kammerd737d022020-11-16 15:42:51 -0800657// collectPathsFromTransitiveDeps checks for source/data files for duplicate paths
658// for module and its transitive dependencies and collects list of data/source file
659// zips for transitive dependencies.
Cole Faust5c503d12023-01-24 11:48:08 -0800660func (p *PythonLibraryModule) collectPathsFromTransitiveDeps(ctx android.ModuleContext, precompiled bool) android.Paths {
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800661 // fetch <runfiles_path, source_path> pairs from "src" and "data" properties to
662 // check duplicates.
663 destToPySrcs := make(map[string]string)
664 destToPyData := make(map[string]string)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800665 for _, path := range p.srcsPathMappings {
666 destToPySrcs[path.dest] = path.src.String()
667 }
668 for _, path := range p.dataPathMappings {
669 destToPyData[path.dest] = path.src.String()
670 }
671
Colin Cross6b753602018-06-21 13:03:07 -0700672 seen := make(map[android.Module]bool)
673
Cole Faust4d247e62023-01-23 10:14:58 -0800674 var result android.Paths
675
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800676 // visit all its dependencies in depth first.
Colin Cross6b753602018-06-21 13:03:07 -0700677 ctx.WalkDeps(func(child, parent android.Module) bool {
Liz Kammerd737d022020-11-16 15:42:51 -0800678 // we only collect dependencies tagged as python library deps
Colin Cross6b753602018-06-21 13:03:07 -0700679 if ctx.OtherModuleDependencyTag(child) != pythonLibTag {
680 return false
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800681 }
Colin Cross6b753602018-06-21 13:03:07 -0700682 if seen[child] {
683 return false
684 }
685 seen[child] = true
Nan Zhangb8fa1972017-12-22 16:12:00 -0800686 // Python modules only can depend on Python libraries.
Colin Cross6b753602018-06-21 13:03:07 -0700687 if !isPythonLibModule(child) {
Liz Kammerd737d022020-11-16 15:42:51 -0800688 ctx.PropertyErrorf("libs",
Nan Zhangd4e641b2017-07-12 12:55:28 -0700689 "the dependency %q of module %q is not Python library!",
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxd75507f2021-08-20 21:02:43 +0000690 ctx.OtherModuleName(child), ctx.ModuleName())
Nan Zhangd4e641b2017-07-12 12:55:28 -0700691 }
Liz Kammerd737d022020-11-16 15:42:51 -0800692 // collect source and data paths, checking that there are no duplicate output file conflicts
693 if dep, ok := child.(pythonDependency); ok {
694 srcs := dep.getSrcsPathMappings()
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800695 for _, path := range srcs {
Liz Kammerd737d022020-11-16 15:42:51 -0800696 checkForDuplicateOutputPath(ctx, destToPySrcs,
Colin Cross6b753602018-06-21 13:03:07 -0700697 path.dest, path.src.String(), ctx.ModuleName(), ctx.OtherModuleName(child))
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800698 }
Liz Kammerd737d022020-11-16 15:42:51 -0800699 data := dep.getDataPathMappings()
700 for _, path := range data {
701 checkForDuplicateOutputPath(ctx, destToPyData,
702 path.dest, path.src.String(), ctx.ModuleName(), ctx.OtherModuleName(child))
703 }
Cole Faust5c503d12023-01-24 11:48:08 -0800704 if precompiled {
705 result = append(result, dep.getPrecompiledSrcsZip())
706 } else {
707 result = append(result, dep.getSrcsZip())
708 }
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800709 }
Colin Cross6b753602018-06-21 13:03:07 -0700710 return true
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800711 })
Cole Faust4d247e62023-01-23 10:14:58 -0800712 return result
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800713}
714
Liz Kammerd737d022020-11-16 15:42:51 -0800715// chckForDuplicateOutputPath checks whether outputPath has already been included in map m, which
716// would result in two files being placed in the same location.
717// If there is a duplicate path, an error is thrown and true is returned
718// Otherwise, outputPath: srcPath is added to m and returns false
719func checkForDuplicateOutputPath(ctx android.ModuleContext, m map[string]string, outputPath, srcPath, curModule, otherModule string) bool {
720 if oldSrcPath, found := m[outputPath]; found {
Nan Zhangbea09752018-05-31 12:49:33 -0700721 ctx.ModuleErrorf("found two files to be placed at the same location within zip %q."+
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800722 " First file: in module %s at path %q."+
723 " Second file: in module %s at path %q.",
Liz Kammerd737d022020-11-16 15:42:51 -0800724 outputPath, curModule, oldSrcPath, otherModule, srcPath)
725 return true
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800726 }
Liz Kammerd737d022020-11-16 15:42:51 -0800727 m[outputPath] = srcPath
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800728
Liz Kammerd737d022020-11-16 15:42:51 -0800729 return false
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800730}
Nan Zhangea568a42017-11-08 21:20:04 -0800731
Liz Kammerd737d022020-11-16 15:42:51 -0800732// InstallInData returns true as Python is not supported in the system partition
Cole Faust4d247e62023-01-23 10:14:58 -0800733func (p *PythonLibraryModule) InstallInData() bool {
Nan Zhangd9ec5e72017-12-01 20:00:31 +0000734 return true
735}
736
Nan Zhangea568a42017-11-08 21:20:04 -0800737var Bool = proptools.Bool
Dan Willemsen6ca390f2019-02-14 23:17:08 -0800738var BoolDefault = proptools.BoolDefault
Nan Zhangea568a42017-11-08 21:20:04 -0800739var String = proptools.String