def main(args: argparse.Namespace) -> None: check_path() rel = version.StrictVersion(args.release) platforms = [ "win_amd64", "manylinux2010_x86_64", "manylinux2014_aarch64", "macosx_10_14_x86_64.macosx_10_15_x86_64.macosx_11_0_x86_64", ] print("Release:", rel) major, minor, patch = rel.version branch = "release_" + str(major) + "." + str(minor) + ".0" git.clean("-xdf") git.checkout(branch) git.pull("origin", branch) git.submodule("update") commit_hash = lastest_hash() dir_URL = PREFIX + str(major) + "." + str(minor) + ".0" + "/" src_filename_prefix = "xgboost-" + args.release + "%2B" + commit_hash + "-py3-none-" target_filename_prefix = "xgboost-" + args.release + "-py3-none-" if not os.path.exists(DIST): os.mkdir(DIST) filenames = download_wheels(platforms, dir_URL, src_filename_prefix, target_filename_prefix) print("List of downloaded wheels:", filenames) print(""" Following steps should be done manually: - Generate source package by running `python setup.py sdist`. - Upload pypi package by `python3 -m twine upload dist/<Package Name>` for all wheels. - Check the uploaded files on `https://pypi.org/project/xgboost/<VERSION>/#files` and `pip install xgboost==<VERSION>` """)
def main(args: argparse.Namespace) -> None: check_path() rel = version.LooseVersion(args.release) print("Release:", rel) if len(rel.version) == 3: # Major release major, minor, patch = version.StrictVersion(args.release).version rc = None rc_ver = None else: # RC release major, minor, patch, rc, rc_ver = cast(Tuple[int, int, int, str, int], rel.version) assert rc == "rc" release = str(major) + "." + str(minor) + "." + str(patch) branch = "release_" + release git.clean("-xdf") git.checkout(branch) git.pull("origin", branch) git.submodule("update") commit_hash = latest_hash() download_r_packages(release, "" if rc is None else rc + str(rc_ver), commit_hash) download_py_packages(major, minor, commit_hash)
def clone_commit(cirpy_dir, commit): """ Clones the `circuitpython` repository, fetches the commit, then checks out the repo at that ref. """ working_dir = pathlib.Path() rosiepi_logger.info("Cloning repository at reference: %s", commit) try: git.clone("--depth", "1", "-n", "https://github.com/sommersoft/circuitpython.git", cirpy_dir) os.chdir(cirpy_dir) git.fetch("origin", commit) git.checkout(commit) git.submodule("sync") git.submodule("update", "--init") except sh.ErrorReturnCode as git_err: git_stderr = str(git_err.stderr, encoding="utf-8").strip("\n") err_msg = [ f"Failed to retrive repository at {commit}:", f" - {git_stderr}", ] rosiepi_logger.warning("%s", "\n".join(err_msg)) raise RuntimeError(git_stderr) from None finally: os.chdir(working_dir)
def update_bundle(bundle_path): working_directory = os.path.abspath(os.getcwd()) os.chdir(bundle_path) git.submodule("foreach", "git", "fetch") # sh fails to find the subcommand so we use subprocess. subprocess.run(shlex.split( "git submodule foreach 'git checkout -q `git rev-list --tags --max-count=1`'" ), stdout=subprocess.DEVNULL) status = StringIO() result = git.status("--short", _out=status) updates = [] status = status.getvalue().strip() if status: for status_line in status.split("\n"): action, directory = status_line.split() if action != "M" or not directory.startswith("libraries"): raise RuntimeError("Unsupported updates") # Compute the tag difference. diff = StringIO() result = git.diff("--submodule=log", directory, _out=diff) diff_lines = diff.getvalue().split("\n") commit_range = diff_lines[0].split()[2] commit_range = commit_range.strip(":").split(".") old_commit = commit_to_tag(directory, commit_range[0]) new_commit = commit_to_tag(directory, commit_range[-1]) url = repo_remote_url(directory) summary = "\n".join(diff_lines[1:-1]) updates.append((url[:-4], old_commit, new_commit, summary)) os.chdir(working_directory) return updates
def fetch_bundle(bundle, bundle_path): if not os.path.isdir(bundle_path): os.makedirs(bundle_path, exist_ok=True) git.clone("-o", "adafruit", "https://github.com/adafruit/" + bundle + ".git", bundle_path) working_directory = os.getcwd() os.chdir(bundle_path) git.pull() git.submodule("init") git.submodule("update") os.chdir(working_directory)
def fetch_bundle(bundle, bundle_path): if not os.path.isdir(bundle_path): os.makedirs(bundle_path, exist_ok=True) if "GITHUB_WORKSPACE" in os.environ: git_url = "https://" + os.environ["ADABOT_GITHUB_ACCESS_TOKEN"] + "@github.com/adafruit/" git.clone("-o", "adafruit", git_url + bundle + ".git", bundle_path) else: git.clone("-o", "adafruit", "https://github.com/adafruit/" + bundle + ".git", bundle_path) working_directory = os.getcwd() os.chdir(bundle_path) git.pull() git.submodule("init") git.submodule("update") os.chdir(working_directory)
def update_bundle(bundle_path): working_directory = os.path.abspath(os.getcwd()) os.chdir(bundle_path) git.submodule("foreach", "git", "fetch") # Regular release tags are 'x.x.x'. Exclude tags that are alpha or beta releases. # They will contain a '-' in the tag, such as '3.0.0-beta.5'. # --exclude must be before --tags. # sh fails to find the subcommand so we use subprocess. subprocess.run(shlex.split( "git submodule foreach 'git checkout -q `git rev-list --exclude='*-*' --tags --max-count=1`'" ), stdout=subprocess.DEVNULL) status = StringIO() result = git.status("--short", _out=status) updates = [] status = status.getvalue().strip() if status: for status_line in status.split("\n"): action, directory = status_line.split() if directory.endswith("library_list.md"): continue if action != "M" or not directory.startswith("libraries"): raise RuntimeError("Unsupported updates") # Compute the tag difference. diff = StringIO() result = git.diff("--submodule=log", directory, _out=diff) diff_lines = diff.getvalue().split("\n") commit_range = diff_lines[0].split()[2] commit_range = commit_range.strip(":").split(".") old_commit = commit_to_tag(directory, commit_range[0]) new_commit = commit_to_tag(directory, commit_range[-1]) url = repo_remote_url(directory) summary = "\n".join(diff_lines[1:-1]) updates.append((url[:-4], old_commit, new_commit, summary)) os.chdir(working_directory) lib_list_updates = check_lib_links_md(bundle_path) if lib_list_updates: updates.append(( "https://github.com/adafruit/Adafruit_CircuitPython_Bundle/circuitpython_library_list.md", "NA", "NA", " > Added the following libraries: {}".format( ", ".join(lib_list_updates)))) return updates
def main(args: argparse.Namespace) -> None: check_path() rel = version.parse(args.release) assert isinstance(rel, version.Version) major = rel.major minor = rel.minor patch = rel.micro print("Release:", rel) if not rel.is_prerelease: # Major release rc: Optional[str] = None rc_ver: Optional[int] = None else: # RC release major = rel.major minor = rel.minor patch = rel.micro assert rel.pre is not None rc, rc_ver = rel.pre assert rc == "rc" release = str(major) + "." + str(minor) + "." + str(patch) branch = "release_" + release git.clean("-xdf") git.checkout(branch) git.pull("origin", branch) git.submodule("update") commit_hash = latest_hash() download_r_packages( release, "" if rc is None else rc + str(rc_ver), commit_hash ) download_py_packages(major, minor, commit_hash)
def update_json_file(working_directory, cp_org_dir, output_filename, json_string): """ Clone the circuitpython-org repo, update libraries.json, and push the updates in a commit. """ if "TRAIVS" in os.environ: if not os.path.isdir(cp_org_dir): os.makedirs(cp_org_dir, exist_ok=True) git_url = "https://" + os.environ[ "ADABOT_GITHUB_ACCESS_TOKEN"] + "@github.com/adafruit/circuitpython-org.git" git.clone("-o", "adafruit", git_url, cp_org_dir) os.chdir(cp_org_dir) git.pull() git.submodule("update", "--init", "--recursive") with open(output_filename, "w") as json_file: json.dump(json_string, json_file, indent=2) commit_day = date.date.strftime(datetime.datetime.today(), "%Y-%m-%d") commit_msg = "adabot: auto-update of libraries.json ({})".format( commit_day) git.commit("-a", "-m", commit_msg) git_push = git.push("adafruit", "master") print(git_push)
def build_fw(board, build_ref, test_log): # pylint: disable=too-many-locals,too-many-statements """ Builds the firware at `build_ref` for `board`. Firmware will be output to `.fw_builds/<build_ref>/<board>/`. :param: str board: Name of the board to build firmware for. :param: str build_ref: The tag/commit to build firmware for. :param: test_log: The TestController.log used for output. """ working_dir = os.getcwd() cirpy_ports_dir = pathlib.Path(cirpy_dir(), "ports") board_port_dir = None for port in _AVAILABLE_PORTS: port_dir = cirpy_ports_dir / port / "boards" / board if port_dir.exists(): board_port_dir = (cirpy_ports_dir / port).resolve() rosiepi_logger.info("Board source found: %s", board_port_dir) break if board_port_dir is None: err_msg = [ f"'{board}' board not available to test. Can't build firmware.", #"="*60, #"Closing RosiePi" ] raise RuntimeError("\n".join(err_msg)) build_dir = pathlib.Path.home() / ".fw_builds" / build_ref[:5] / board os.chdir(cirpy_dir()) try: test_log.write("Fetching {}...".format(build_ref)) git.fetch("--depth", "1", "origin", build_ref) test_log.write("Checking out {}...".format(build_ref)) git.checkout(build_ref) test_log.write("Syncing submodules...") git.submodule("sync") test_log.write("Updating submodules...") git.submodule("update", "--init", "--depth", "1") except sh.ErrorReturnCode as git_err: # TODO: change to 'master' git.checkout("-f", "rosiepi_test") os.chdir(working_dir) err_msg = [ "Building firmware failed:", " - {}".format(str(git_err.stderr, encoding="utf-8").strip("\n")), #"="*60, #"Closing RosiePi" ] raise RuntimeError("\n".join(err_msg)) from None os.chdir(board_port_dir) board_cmd = (f"make clean BOARD={board} BUILD={build_dir}", f"make BOARD={board} BUILD={build_dir}") test_log.write("Building firmware...") try: rosiepi_logger.info("Running make recipe: %s", '; '.join(board_cmd)) run_envs = { "BASH_ENV": "/etc/profile", } rosiepi_logger.info("Running build clean...") # pylint: disable=subprocess-run-check subprocess.run( board_cmd[0], shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, executable="/usr/bin/bash", start_new_session=True, env=run_envs, ) build_dir.mkdir(mode=0o0774, parents=True) # pylint: enable=subprocess-run-check rosiepi_logger.info("Running firmware build...") fw_build = subprocess.run( board_cmd[1], check=True, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, executable="/usr/bin/bash", start_new_session=True, env=run_envs, ) result = str(fw_build.stdout, encoding="utf-8").split("\n") success_msg = [line for line in result if "bytes" in line] test_log.write(" - " + "\n - ".join(success_msg)) rosiepi_logger.info("Firmware built...") except subprocess.CalledProcessError as cmd_err: # TODO: change to 'master' git.checkout("-f", "rosiepi_test") os.chdir(working_dir) err_msg = [ "Building firmware failed:", " - {}".format(str(cmd_err.stdout, encoding="utf-8").strip("\n")), #"="*60, #"Closing RosiePi" ] rosiepi_logger.warning("Firmware build failed...") raise RuntimeError("\n".join(err_msg)) from None finally: # TODO: change to 'master' git.checkout("-f", "rosiepi_test") os.chdir(working_dir) return build_dir