pw_build/python_dist.gni - pigweed/pigweed - Git at Google

 # Copyright 2021 The Pigweed Authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may not
 # use this file except in compliance with the License. You may obtain a copy of
 # the License at
 #
 #     https://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 # License for the specific language governing permissions and limitations under
 # the License.

 import("//build_overrides/pigweed.gni")

 import("$dir_pw_build/error.gni")
 import("$dir_pw_build/python.gni")
 import("$dir_pw_build/python_action.gni")
 import("$dir_pw_build/python_gn_args.gni")
 import("$dir_pw_build/zip.gni")

 # Builds a directory containing a collection of Python wheels.
 #
 # Given one or more pw_python_package targets, this target will build their
 # .wheel sub-targets along with the .wheel sub-targets of all dependencies,
 # direct and indirect, as understood by GN. The resulting .whl files will be
 # collected into a single directory called 'python_wheels'.
 #
 # Args:
 #   packages: A list of pw_python_package targets whose wheels should be
 #       included; their dependencies will be pulled in as wheels also.
 #   directory: output directory for the wheels; defaults to
 #       $target_out_dir/$target_name
 #   deps: additional dependencies
 #
 template("pw_python_wheels") {
   _wheel_paths_path = "${target_gen_dir}/${target_name}_wheel_paths.txt"

   _deps = []
   if (defined(invoker.deps)) {
     _deps = invoker.deps
   }

   if (defined(invoker.directory)) {
     _directory = invoker.directory
   } else {
     _directory = "$target_out_dir/$target_name"
   }

   _packages = []
   foreach(_pkg, invoker.packages) {
     _pkg_name = get_label_info(_pkg, "label_no_toolchain")
     _pkg_toolchain = get_label_info(_pkg, "toolchain")
     _packages += [ "${_pkg_name}.wheel(${_pkg_toolchain})" ]
   }

   # Build a list of relative paths containing all the wheels we depend on.
   generated_file("${target_name}._wheel_paths") {
     data_keys = [ "pw_python_package_wheels" ]
     rebase = root_build_dir
     deps = _packages
     outputs = [ _wheel_paths_path ]
   }

   pw_python_action(target_name) {
     forward_variables_from(invoker, [ "public_deps" ])
     deps = _deps + [ ":$target_name._wheel_paths" ]
     module = "pw_build.collect_wheels"
     python_deps = [ "$dir_pw_build/py" ]

     args = [
       "--prefix",
       rebase_path(root_build_dir, root_build_dir),
       "--suffix",
       rebase_path(_wheel_paths_path, root_build_dir),
       "--out_dir",
       rebase_path(_directory, root_build_dir),
     ]

     stamp = true
   }
 }

 # Builds a .zip containing Python wheels and setup scripts.
 #
 # The resulting .zip archive will contain a directory with Python wheels for
 # all pw_python_package targets listed in 'packages', plus wheels for any
 # pw_python_package targets those packages depend on, directly or indirectly,
 # as understood by GN.
 #
 # In addition to Python wheels, the resulting .zip will also contain simple
 # setup scripts for Linux, MacOS, and Windows that take care of creating a
 # Python venv and installing all the included wheels into it, and a README.md
 # file with setup and usage instructions.
 #
 # Args:
 #   packages: A list of pw_python_package targets whose wheels should be
 #       included; their dependencies will be pulled in as wheels also.
 #   inputs: An optional list of extra files to include in the generated .zip,
 #       formatted the same was as the 'inputs' argument to pw_zip targets.
 #   dirs: An optional list of directories to include in the generated .zip,
 #       formatted the same way as the 'dirs' argument to pw_zip targets.
 template("pw_python_zip_with_setup") {
   _outer_name = target_name
   _zip_path = "${target_out_dir}/${target_name}.zip"

   _inputs = []
   if (defined(invoker.inputs)) {
     _inputs = invoker.inputs
   }
   _dirs = []
   if (defined(invoker.dirs)) {
     _dirs = invoker.dirs
   }
   _public_deps = []
   if (defined(invoker.public_deps)) {
     _public_deps = invoker.public_deps
   }

   pw_python_wheels("$target_name.wheels") {
     packages = invoker.packages
     forward_variables_from(invoker, [ "deps" ])
   }

   pw_zip(target_name) {
     forward_variables_from(invoker, [ "deps" ])
     inputs = _inputs + [
                "$dir_pw_build/python_dist/setup.bat > /${target_name}/",
                "$dir_pw_build/python_dist/setup.sh > /${target_name}/",
              ]

     dirs = _dirs + [ "$target_out_dir/$target_name.wheels/ > /$target_name/python_wheels/" ]

     output = _zip_path

     # TODO(b/235245034): Remove the plumbing-through of invoker's public_deps.
     public_deps = _public_deps + [ ":${_outer_name}.wheels" ]
   }
 }

 # Generates a directory of Python packages from source files suitable for
 # deployment outside of the project developer environment.
 #
 # The resulting directory contains only files mentioned in each package's
 # setup.cfg file. This is useful for bundling multiple Python packages up
 # into a single package for distribution to other locations like
 # http://pypi.org.
 #
 # Args:
 #   packages: A list of pw_python_package targets to be installed into the build
 #     directory. Their dependencies will be pulled in as wheels also.
 #
 #   include_tests: If true, copy Python package tests to a `tests` subdir.
 #
 #   extra_files: A list of extra files that should be included in the output. The
 #     format of each item in this list follows this convention:
 #       //some/nested/source_file > nested/destination_file
 #
 #   generate_setup_cfg: A scope containing either common_config_file or 'name'
 #     and 'version' If included this creates a merged setup.cfg for all python
 #     Packages using either a common_config_file as a base or name and version
 #     strings. This scope can optionally include: 'append_git_sha_to_version' or
 #     'append_date_to_version' whic append the current git SHA or date to the
 #     package version string after a + sign.
 #
 template("pw_python_distribution") {
   _metadata_path_list_suffix = "_pw_python_distribution_metadata_path_list.txt"
   _output_dir = "${target_out_dir}/${target_name}/"
   _metadata_json_file_list =
       "${target_gen_dir}/${target_name}${_metadata_path_list_suffix}"

   # If generating a setup.cfg file a common base file must be provided.
   if (defined(invoker.generate_setup_cfg)) {
     generate_setup_cfg = invoker.generate_setup_cfg
     assert(
         defined(generate_setup_cfg.common_config_file) ||
             (defined(generate_setup_cfg.name) &&
                  defined(generate_setup_cfg.version)),
         "Either 'common_config_file' or ('name' + 'version') are required in generate_setup_cfg")
   }

   _extra_file_inputs = []
   _extra_file_args = []

   # Convert extra_file strings to input, outputs and create_python_tree.py args.
   if (defined(invoker.extra_files)) {
     _delimiter = ">"
     _extra_file_outputs = []
     foreach(input, invoker.extra_files) {
       # Remove spaces before and after the delimiter
       input = string_replace(input, " $_delimiter", _delimiter)
       input = string_replace(input, "$_delimiter ", _delimiter)

       input_list = []
       input_list = string_split(input, _delimiter)

       # Save the input file
       _extra_file_inputs += [ input_list[0] ]

       # Save the output file
       _this_output = _output_dir + "/" + input_list[1]
       _extra_file_outputs += [ _this_output ]

       # Compose an arg for passing to create_python_tree.py with properly
       # rebased paths.
       _extra_file_args +=
           [ string_join(" $_delimiter ",
                         [
                           rebase_path(input_list[0], root_build_dir),
                           rebase_path(_this_output, root_build_dir),
                         ]) ]
     }
   }

   _include_tests = defined(invoker.include_tests) && invoker.include_tests

   _public_deps = []
   if (defined(invoker.public_deps)) {
     _public_deps += invoker.public_deps
   }

   # Set source files for the Python package metadata json file.
   _sources = []
   _setup_sources = [
     "$_output_dir/pyproject.toml",
     "$_output_dir/setup.cfg",
   ]
   _test_sources = []

   # Create the Python package_metadata.json file so this can be used as a
   # Python dependency.
   _package_metadata_json_file =
       "$target_gen_dir/$target_name/package_metadata.json"

   # Get Python package metadata and write to disk as JSON.
   _package_metadata = {
     gn_target_name =
         get_label_info(":${invoker.target_name}", "label_no_toolchain")

     # Get package source files
     sources = rebase_path(_sources, root_build_dir)

     # Get setup.cfg, pyproject.toml, or setup.py file
     setup_sources = rebase_path(_setup_sources, root_build_dir)

     # Get test source files
     tests = rebase_path(_test_sources, root_build_dir)

     # Get package input files (package data)
     inputs = []
     if (defined(invoker.inputs)) {
       inputs = rebase_path(invoker.inputs, root_build_dir)
     }
     inputs += rebase_path(_extra_file_inputs, root_build_dir)
   }

   # Finally, write out the json
   write_file(_package_metadata_json_file, _package_metadata, "json")

   group("$target_name._package_metadata") {
     metadata = {
       pw_python_package_metadata_json = [ _package_metadata_json_file ]
     }
   }

   _package_metadata_targets = []
   foreach(pkg, invoker.packages) {
     _package_metadata_targets +=
         [ get_label_info(pkg, "label_no_toolchain") +
           "._package_metadata($pw_build_PYTHON_TOOLCHAIN)" ]
   }

   # Build a list of relative paths containing all the python
   # package_metadata.json files we depend on.
   generated_file("${target_name}.${_metadata_path_list_suffix}") {
     data_keys = [ "pw_python_package_metadata_json" ]
     rebase = root_build_dir
     deps = _package_metadata_targets
     outputs = [ _metadata_json_file_list ]
   }

   # Run the python action on the metadata_path_list.txt file
   pw_python_action(target_name) {
     # Save the Python package metadata so this can be installed using
     # pw_internal_pip_install.
     metadata = {
       pw_python_package_metadata_json = [ _package_metadata_json_file ]
     }

     deps = invoker.packages +
            [ ":${invoker.target_name}.${_metadata_path_list_suffix}" ]

     script = "$dir_pw_build/py/pw_build/create_python_tree.py"
     inputs = _extra_file_inputs
     public_deps = _public_deps
     _pw_internal_run_in_venv = false

     args = [
       "--tree-destination-dir",
       rebase_path(_output_dir, root_build_dir),
       "--input-list-files",
       rebase_path(_metadata_json_file_list, root_build_dir),
     ]

     # Add required setup.cfg args if we are generating a merged config.
     if (defined(generate_setup_cfg)) {
       if (defined(generate_setup_cfg.common_config_file)) {
         args += [
           "--setupcfg-common-file",
           rebase_path(generate_setup_cfg.common_config_file, root_build_dir),
         ]
       }
       if (defined(generate_setup_cfg.append_git_sha_to_version)) {
         args += [ "--setupcfg-version-append-git-sha" ]
       }
       if (defined(generate_setup_cfg.append_date_to_version)) {
         args += [ "--setupcfg-version-append-date" ]
       }
       if (defined(generate_setup_cfg.name)) {
         args += [
           "--setupcfg-override-name",
           generate_setup_cfg.name,
         ]
       }
       if (defined(generate_setup_cfg.version)) {
         args += [
           "--setupcfg-override-version",
           generate_setup_cfg.version,
         ]
       }
       if (defined(generate_setup_cfg.include_default_pyproject_file) &&
           generate_setup_cfg.include_default_pyproject_file == true) {
         args += [ "--create-default-pyproject-toml" ]
       }
     }

     if (_extra_file_args == []) {
       # No known output files - stamp instead.
       stamp = true
     } else {
       args += [ "--extra-files" ]
       args += _extra_file_args

       # Include extra_files as outputs
       outputs = _extra_file_outputs
     }

     if (_include_tests) {
       args += [ "--include-tests" ]
     }
   }

   # Template to build a bundled Python package wheel.
   pw_python_action("$target_name._build_wheel") {
     metadata = {
       pw_python_package_wheels = [ "$target_out_dir/$target_name" ]
     }
     module = "build"
     args = [
              rebase_path(_output_dir, root_build_dir),
              "--wheel",
              "--no-isolation",
              "--outdir",
            ] + rebase_path(metadata.pw_python_package_wheels, root_build_dir)

     public_deps = []
     if (defined(invoker.public_deps)) {
       public_deps += invoker.public_deps
     }
     public_deps += [ ":${invoker.target_name}" ]

     stamp = true
   }
   group("$target_name.wheel") {
     public_deps = [ ":${invoker.target_name}._build_wheel" ]
   }

   # Allow using pw_python_distribution targets as a python_dep in
   # pw_python_group. To do this, create a pw_python_group with the relevant
   # packages and create wrappers for each subtarget, except those that are
   # actually implemented by this template.
   #
   # This is an ugly workaround that will be removed when the Python build is
   # refactored (b/235278298).
   pw_python_group("$target_name._pw_python_group") {
     python_deps = invoker.packages
   }

   wrapped_subtargets = pw_python_package_subtargets - [
                          "wheel",
                          "_build_wheel",
                        ]

   foreach(subtarget, wrapped_subtargets) {
     group("$target_name.$subtarget") {
       public_deps = [ ":${invoker.target_name}._pw_python_group.$subtarget" ]
     }
   }
 }

 # TODO(b/232800695): Remove this template when all projects no longer use it.
 template("pw_create_python_source_tree") {
   pw_python_distribution("$target_name") {
     forward_variables_from(invoker, "*")
   }
 }

 # Runs pip install on a set of pw_python_packages. This will install
 # pw_python_packages into the user's developer environment.
 #
 # Args:
 #   packages: A list of pw_python_package targets to be pip installed.
 #     These will be installed one at a time.
 #
 #   editable: If true, --editable is passed to the pip install command.
 #
 #   force_reinstall: If true, --force-reinstall is passed to the pip install
 #     command.
 template("pw_python_pip_install") {
   if (current_toolchain == pw_build_PYTHON_TOOLCHAIN) {
     # Create a target group for the Python package metadata only.
     group("$target_name._package_metadata") {
       # Forward the package_metadata subtarget for all python_deps.
       public_deps = []
       if (defined(invoker.packages)) {
         foreach(dep, invoker.packages) {
           public_deps += [ get_label_info(dep, "label_no_toolchain") +
                            "._package_metadata($pw_build_PYTHON_TOOLCHAIN)" ]
         }
       }
     }

     pw_python_action("$target_name") {
       script = "$dir_pw_build/py/pw_build/pip_install_python_deps.py"

       assert(
           defined(invoker.packages),
           "packages = [ 'python_package' ] is required by pw_internal_pip_install")

       public_deps = []
       if (defined(invoker.public_deps)) {
         public_deps += invoker.public_deps
       }

       python_deps = []
       python_metadata_deps = []
       if (defined(invoker.packages)) {
         public_deps += invoker.packages
         python_deps += invoker.packages
         python_metadata_deps += invoker.packages
       }

       python_deps = []
       if (defined(invoker.python_deps)) {
         python_deps += invoker.python_deps
       }

       _pw_internal_run_in_venv = false
       _forward_python_metadata_deps = true

       _editable_install = false
       if (defined(invoker.editable)) {
         _editable_install = invoker.editable
       }

       _pkg_gn_labels = []
       foreach(pkg, invoker.packages) {
         _pkg_gn_labels += [ get_label_info(pkg, "label_no_toolchain") ]
       }

       args = [
         "--gn-packages",
         string_join(",", _pkg_gn_labels),
       ]

       if (_editable_install) {
         args += [ "--editable-pip-install" ]
       }

       args += [
         "install",
         "--no-build-isolation",
       ]

       _force_reinstall = false
       if (defined(invoker.force_reinstall)) {
         _force_reinstall = true
       }
       if (_force_reinstall) {
         args += [ "--force-reinstall" ]
       }

       inputs = pw_build_PIP_CONSTRAINTS
       foreach(_constraints_file, pw_build_PIP_CONSTRAINTS) {
         args += [
           "--constraint",
           rebase_path(_constraints_file, root_build_dir),
         ]
       }

       stamp = true

       # Parallel pip installations don't work, so serialize pip invocations.
       pool = "$dir_pw_build/pool:pip($default_toolchain)"
     }
   } else {
     group("$target_name") {
       deps = [ ":$target_name($pw_build_PYTHON_TOOLCHAIN)" ]
     }
     not_needed("*")
     not_needed(invoker, "*")
   }

   group("$target_name.install") {
     public_deps = [ ":${invoker.target_name}" ]
   }

   # Allow using pw_internal_pip_install targets as a python_dep in
   # pw_python_group. To do this, create a pw_python_group with the relevant
   # packages and create wrappers for each subtarget, except those that are
   # actually implemented by this template.
   #
   # This is an ugly workaround that will be removed when the Python build is
   # refactored (b/235278298).
   pw_python_group("$target_name._pw_python_group") {
     python_deps = invoker.packages
   }

   foreach(subtarget, pw_python_package_subtargets - [ "install" ]) {
     group("$target_name.$subtarget") {
       public_deps = [ ":${invoker.target_name}._pw_python_group.$subtarget" ]
     }
   }
 }

 # TODO(b/232800695): Remove this template when all projects no longer use it.
 template("pw_internal_pip_install") {
   pw_python_pip_install("$target_name") {
     forward_variables_from(invoker, "*")
   }
 }
	# Copyright 2021 The Pigweed Authors
	#
	# Licensed under the Apache License, Version 2.0 (the "License"); you may not
	# use this file except in compliance with the License. You may obtain a copy of
	# the License at
	#
	# https://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	# License for the specific language governing permissions and limitations under
	# the License.

	import("//build_overrides/pigweed.gni")

	import("$dir_pw_build/error.gni")
	import("$dir_pw_build/python.gni")
	import("$dir_pw_build/python_action.gni")
	import("$dir_pw_build/python_gn_args.gni")
	import("$dir_pw_build/zip.gni")

	# Builds a directory containing a collection of Python wheels.
	#
	# Given one or more pw_python_package targets, this target will build their
	# .wheel sub-targets along with the .wheel sub-targets of all dependencies,
	# direct and indirect, as understood by GN. The resulting .whl files will be
	# collected into a single directory called 'python_wheels'.
	#
	# Args:
	# packages: A list of pw_python_package targets whose wheels should be
	# included; their dependencies will be pulled in as wheels also.
	# directory: output directory for the wheels; defaults to
	# $target_out_dir/$target_name
	# deps: additional dependencies
	#
	template("pw_python_wheels") {
	_wheel_paths_path = "${target_gen_dir}/${target_name}_wheel_paths.txt"

	_deps = []
	if (defined(invoker.deps)) {
	_deps = invoker.deps
	}

	if (defined(invoker.directory)) {
	_directory = invoker.directory
	} else {
	_directory = "$target_out_dir/$target_name"
	}

	_packages = []
	foreach(_pkg, invoker.packages) {
	_pkg_name = get_label_info(_pkg, "label_no_toolchain")
	_pkg_toolchain = get_label_info(_pkg, "toolchain")
	_packages += [ "${_pkg_name}.wheel(${_pkg_toolchain})" ]
	}

	# Build a list of relative paths containing all the wheels we depend on.
	generated_file("${target_name}._wheel_paths") {
	data_keys = [ "pw_python_package_wheels" ]
	rebase = root_build_dir
	deps = _packages
	outputs = [ _wheel_paths_path ]
	}

	pw_python_action(target_name) {
	forward_variables_from(invoker, [ "public_deps" ])
	deps = _deps + [ ":$target_name._wheel_paths" ]
	module = "pw_build.collect_wheels"
	python_deps = [ "$dir_pw_build/py" ]

	args = [
	"--prefix",
	rebase_path(root_build_dir, root_build_dir),
	"--suffix",
	rebase_path(_wheel_paths_path, root_build_dir),
	"--out_dir",
	rebase_path(_directory, root_build_dir),
	]

	stamp = true
	}
	}

	# Builds a .zip containing Python wheels and setup scripts.
	#
	# The resulting .zip archive will contain a directory with Python wheels for
	# all pw_python_package targets listed in 'packages', plus wheels for any
	# pw_python_package targets those packages depend on, directly or indirectly,
	# as understood by GN.
	#
	# In addition to Python wheels, the resulting .zip will also contain simple
	# setup scripts for Linux, MacOS, and Windows that take care of creating a
	# Python venv and installing all the included wheels into it, and a README.md
	# file with setup and usage instructions.
	#
	# Args:
	# packages: A list of pw_python_package targets whose wheels should be
	# included; their dependencies will be pulled in as wheels also.
	# inputs: An optional list of extra files to include in the generated .zip,
	# formatted the same was as the 'inputs' argument to pw_zip targets.
	# dirs: An optional list of directories to include in the generated .zip,
	# formatted the same way as the 'dirs' argument to pw_zip targets.
	template("pw_python_zip_with_setup") {
	_outer_name = target_name
	_zip_path = "${target_out_dir}/${target_name}.zip"

	_inputs = []
	if (defined(invoker.inputs)) {
	_inputs = invoker.inputs
	}
	_dirs = []
	if (defined(invoker.dirs)) {
	_dirs = invoker.dirs
	}
	_public_deps = []
	if (defined(invoker.public_deps)) {
	_public_deps = invoker.public_deps
	}

	pw_python_wheels("$target_name.wheels") {
	packages = invoker.packages
	forward_variables_from(invoker, [ "deps" ])
	}

	pw_zip(target_name) {
	forward_variables_from(invoker, [ "deps" ])
	inputs = _inputs + [
	"$dir_pw_build/python_dist/setup.bat > /${target_name}/",
	"$dir_pw_build/python_dist/setup.sh > /${target_name}/",
	]

	dirs = _dirs + [ "$target_out_dir/$target_name.wheels/ > /$target_name/python_wheels/" ]

	output = _zip_path

	# TODO(b/235245034): Remove the plumbing-through of invoker's public_deps.
	public_deps = _public_deps + [ ":${_outer_name}.wheels" ]
	}
	}

	# Generates a directory of Python packages from source files suitable for
	# deployment outside of the project developer environment.
	#
	# The resulting directory contains only files mentioned in each package's
	# setup.cfg file. This is useful for bundling multiple Python packages up
	# into a single package for distribution to other locations like
	# http://pypi.org.
	#
	# Args:
	# packages: A list of pw_python_package targets to be installed into the build
	# directory. Their dependencies will be pulled in as wheels also.
	#
	# include_tests: If true, copy Python package tests to a `tests` subdir.
	#
	# extra_files: A list of extra files that should be included in the output. The
	# format of each item in this list follows this convention:
	# //some/nested/source_file > nested/destination_file
	#
	# generate_setup_cfg: A scope containing either common_config_file or 'name'
	# and 'version' If included this creates a merged setup.cfg for all python
	# Packages using either a common_config_file as a base or name and version
	# strings. This scope can optionally include: 'append_git_sha_to_version' or
	# 'append_date_to_version' whic append the current git SHA or date to the
	# package version string after a + sign.
	#
	template("pw_python_distribution") {
	_metadata_path_list_suffix = "_pw_python_distribution_metadata_path_list.txt"
	_output_dir = "${target_out_dir}/${target_name}/"
	_metadata_json_file_list =
	"${target_gen_dir}/${target_name}${_metadata_path_list_suffix}"

	# If generating a setup.cfg file a common base file must be provided.
	if (defined(invoker.generate_setup_cfg)) {
	generate_setup_cfg = invoker.generate_setup_cfg
	assert(
	defined(generate_setup_cfg.common_config_file) \|\|
	(defined(generate_setup_cfg.name) &&
	defined(generate_setup_cfg.version)),
	"Either 'common_config_file' or ('name' + 'version') are required in generate_setup_cfg")
	}

	_extra_file_inputs = []
	_extra_file_args = []

	# Convert extra_file strings to input, outputs and create_python_tree.py args.
	if (defined(invoker.extra_files)) {
	_delimiter = ">"
	_extra_file_outputs = []
	foreach(input, invoker.extra_files) {
	# Remove spaces before and after the delimiter
	input = string_replace(input, " $_delimiter", _delimiter)
	input = string_replace(input, "$_delimiter ", _delimiter)

	input_list = []
	input_list = string_split(input, _delimiter)

	# Save the input file
	_extra_file_inputs += [ input_list[0] ]

	# Save the output file
	_this_output = _output_dir + "/" + input_list[1]
	_extra_file_outputs += [ _this_output ]

	# Compose an arg for passing to create_python_tree.py with properly
	# rebased paths.
	_extra_file_args +=
	[ string_join(" $_delimiter ",
	[
	rebase_path(input_list[0], root_build_dir),
	rebase_path(_this_output, root_build_dir),
	]) ]
	}
	}

	_include_tests = defined(invoker.include_tests) && invoker.include_tests

	_public_deps = []
	if (defined(invoker.public_deps)) {
	_public_deps += invoker.public_deps
	}

	# Set source files for the Python package metadata json file.
	_sources = []
	_setup_sources = [
	"$_output_dir/pyproject.toml",
	"$_output_dir/setup.cfg",
	]
	_test_sources = []

	# Create the Python package_metadata.json file so this can be used as a
	# Python dependency.
	_package_metadata_json_file =
	"$target_gen_dir/$target_name/package_metadata.json"

	# Get Python package metadata and write to disk as JSON.
	_package_metadata = {
	gn_target_name =
	get_label_info(":${invoker.target_name}", "label_no_toolchain")

	# Get package source files
	sources = rebase_path(_sources, root_build_dir)

	# Get setup.cfg, pyproject.toml, or setup.py file
	setup_sources = rebase_path(_setup_sources, root_build_dir)

	# Get test source files
	tests = rebase_path(_test_sources, root_build_dir)

	# Get package input files (package data)
	inputs = []
	if (defined(invoker.inputs)) {
	inputs = rebase_path(invoker.inputs, root_build_dir)
	}
	inputs += rebase_path(_extra_file_inputs, root_build_dir)
	}

	# Finally, write out the json
	write_file(_package_metadata_json_file, _package_metadata, "json")

	group("$target_name._package_metadata") {
	metadata = {
	pw_python_package_metadata_json = [ _package_metadata_json_file ]
	}
	}

	_package_metadata_targets = []
	foreach(pkg, invoker.packages) {
	_package_metadata_targets +=
	[ get_label_info(pkg, "label_no_toolchain") +
	"._package_metadata($pw_build_PYTHON_TOOLCHAIN)" ]
	}

	# Build a list of relative paths containing all the python
	# package_metadata.json files we depend on.
	generated_file("${target_name}.${_metadata_path_list_suffix}") {
	data_keys = [ "pw_python_package_metadata_json" ]
	rebase = root_build_dir
	deps = _package_metadata_targets
	outputs = [ _metadata_json_file_list ]
	}

	# Run the python action on the metadata_path_list.txt file
	pw_python_action(target_name) {
	# Save the Python package metadata so this can be installed using
	# pw_internal_pip_install.
	metadata = {
	pw_python_package_metadata_json = [ _package_metadata_json_file ]
	}

	deps = invoker.packages +
	[ ":${invoker.target_name}.${_metadata_path_list_suffix}" ]

	script = "$dir_pw_build/py/pw_build/create_python_tree.py"
	inputs = _extra_file_inputs
	public_deps = _public_deps
	_pw_internal_run_in_venv = false

	args = [
	"--tree-destination-dir",
	rebase_path(_output_dir, root_build_dir),
	"--input-list-files",
	rebase_path(_metadata_json_file_list, root_build_dir),
	]

	# Add required setup.cfg args if we are generating a merged config.
	if (defined(generate_setup_cfg)) {
	if (defined(generate_setup_cfg.common_config_file)) {
	args += [
	"--setupcfg-common-file",
	rebase_path(generate_setup_cfg.common_config_file, root_build_dir),
	]
	}
	if (defined(generate_setup_cfg.append_git_sha_to_version)) {
	args += [ "--setupcfg-version-append-git-sha" ]
	}
	if (defined(generate_setup_cfg.append_date_to_version)) {
	args += [ "--setupcfg-version-append-date" ]
	}
	if (defined(generate_setup_cfg.name)) {
	args += [
	"--setupcfg-override-name",
	generate_setup_cfg.name,
	]
	}
	if (defined(generate_setup_cfg.version)) {
	args += [
	"--setupcfg-override-version",
	generate_setup_cfg.version,
	]
	}
	if (defined(generate_setup_cfg.include_default_pyproject_file) &&
	generate_setup_cfg.include_default_pyproject_file == true) {
	args += [ "--create-default-pyproject-toml" ]
	}
	}

	if (_extra_file_args == []) {
	# No known output files - stamp instead.
	stamp = true
	} else {
	args += [ "--extra-files" ]
	args += _extra_file_args

	# Include extra_files as outputs
	outputs = _extra_file_outputs
	}

	if (_include_tests) {
	args += [ "--include-tests" ]
	}
	}

	# Template to build a bundled Python package wheel.
	pw_python_action("$target_name._build_wheel") {
	metadata = {
	pw_python_package_wheels = [ "$target_out_dir/$target_name" ]
	}
	module = "build"
	args = [
	rebase_path(_output_dir, root_build_dir),
	"--wheel",
	"--no-isolation",
	"--outdir",
	] + rebase_path(metadata.pw_python_package_wheels, root_build_dir)

	public_deps = []
	if (defined(invoker.public_deps)) {
	public_deps += invoker.public_deps
	}
	public_deps += [ ":${invoker.target_name}" ]

	stamp = true
	}
	group("$target_name.wheel") {
	public_deps = [ ":${invoker.target_name}._build_wheel" ]
	}

	# Allow using pw_python_distribution targets as a python_dep in
	# pw_python_group. To do this, create a pw_python_group with the relevant
	# packages and create wrappers for each subtarget, except those that are
	# actually implemented by this template.
	#
	# This is an ugly workaround that will be removed when the Python build is
	# refactored (b/235278298).
	pw_python_group("$target_name._pw_python_group") {
	python_deps = invoker.packages
	}

	wrapped_subtargets = pw_python_package_subtargets - [
	"wheel",
	"_build_wheel",
	]

	foreach(subtarget, wrapped_subtargets) {
	group("$target_name.$subtarget") {
	public_deps = [ ":${invoker.target_name}._pw_python_group.$subtarget" ]
	}
	}
	}

	# TODO(b/232800695): Remove this template when all projects no longer use it.
	template("pw_create_python_source_tree") {
	pw_python_distribution("$target_name") {
	forward_variables_from(invoker, "*")
	}
	}

	# Runs pip install on a set of pw_python_packages. This will install
	# pw_python_packages into the user's developer environment.
	#
	# Args:
	# packages: A list of pw_python_package targets to be pip installed.
	# These will be installed one at a time.
	#
	# editable: If true, --editable is passed to the pip install command.
	#
	# force_reinstall: If true, --force-reinstall is passed to the pip install
	# command.
	template("pw_python_pip_install") {
	if (current_toolchain == pw_build_PYTHON_TOOLCHAIN) {
	# Create a target group for the Python package metadata only.
	group("$target_name._package_metadata") {
	# Forward the package_metadata subtarget for all python_deps.
	public_deps = []
	if (defined(invoker.packages)) {
	foreach(dep, invoker.packages) {
	public_deps += [ get_label_info(dep, "label_no_toolchain") +
	"._package_metadata($pw_build_PYTHON_TOOLCHAIN)" ]
	}
	}
	}

	pw_python_action("$target_name") {
	script = "$dir_pw_build/py/pw_build/pip_install_python_deps.py"

	assert(
	defined(invoker.packages),
	"packages = [ 'python_package' ] is required by pw_internal_pip_install")

	public_deps = []
	if (defined(invoker.public_deps)) {
	public_deps += invoker.public_deps
	}

	python_deps = []
	python_metadata_deps = []
	if (defined(invoker.packages)) {
	public_deps += invoker.packages
	python_deps += invoker.packages
	python_metadata_deps += invoker.packages
	}

	python_deps = []
	if (defined(invoker.python_deps)) {
	python_deps += invoker.python_deps
	}

	_pw_internal_run_in_venv = false
	_forward_python_metadata_deps = true

	_editable_install = false
	if (defined(invoker.editable)) {
	_editable_install = invoker.editable
	}

	_pkg_gn_labels = []
	foreach(pkg, invoker.packages) {
	_pkg_gn_labels += [ get_label_info(pkg, "label_no_toolchain") ]
	}

	args = [
	"--gn-packages",
	string_join(",", _pkg_gn_labels),
	]

	if (_editable_install) {
	args += [ "--editable-pip-install" ]
	}

	args += [
	"install",
	"--no-build-isolation",
	]

	_force_reinstall = false
	if (defined(invoker.force_reinstall)) {
	_force_reinstall = true
	}
	if (_force_reinstall) {
	args += [ "--force-reinstall" ]
	}

	inputs = pw_build_PIP_CONSTRAINTS
	foreach(_constraints_file, pw_build_PIP_CONSTRAINTS) {
	args += [
	"--constraint",
	rebase_path(_constraints_file, root_build_dir),
	]
	}

	stamp = true

	# Parallel pip installations don't work, so serialize pip invocations.
	pool = "$dir_pw_build/pool:pip($default_toolchain)"
	}
	} else {
	group("$target_name") {
	deps = [ ":$target_name($pw_build_PYTHON_TOOLCHAIN)" ]
	}
	not_needed("*")
	not_needed(invoker, "*")
	}

	group("$target_name.install") {
	public_deps = [ ":${invoker.target_name}" ]
	}

	# Allow using pw_internal_pip_install targets as a python_dep in
	# pw_python_group. To do this, create a pw_python_group with the relevant
	# packages and create wrappers for each subtarget, except those that are
	# actually implemented by this template.
	#
	# This is an ugly workaround that will be removed when the Python build is
	# refactored (b/235278298).
	pw_python_group("$target_name._pw_python_group") {
	python_deps = invoker.packages
	}

	foreach(subtarget, pw_python_package_subtargets - [ "install" ]) {
	group("$target_name.$subtarget") {
	public_deps = [ ":${invoker.target_name}._pw_python_group.$subtarget" ]
	}
	}
	}

	# TODO(b/232800695): Remove this template when all projects no longer use it.
	template("pw_internal_pip_install") {
	pw_python_pip_install("$target_name") {
	forward_variables_from(invoker, "*")
	}
	}