linux/ohmyzsh
0
0
Fork 0
mirror of https://github.com/ohmyzsh/ohmyzsh.git synced 2024-09-12 04:01:14 +02:00
Code Issues Projects Releases Wiki Activity

style(dependencies): run ruff formatter

Browse source
This commit is contained in:
Carlo Sala 2024-05-09 17:20:09 +02:00
parent 83110e8ce1
commit 13c8a10e39
2 changed files with 378 additions and 329 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.editorconfig
View file

@ -6,3 +6,6 @@ insert_final_newline = true
charset = utf-8 charset = utf-8
indent_size = 2 indent_size = 2
indent_style = space indent_style = space
[*.py]
indent_size = 4

704
.github/workflows/dependencies/updater.py vendored
View file

@ -1,12 +1,14 @@
import os import os
import shutil
import subprocess import subprocess
import sys import sys
import requests import timeit
import shutil
import yaml
from copy import deepcopy from copy import deepcopy
from typing import Optional, TypedDict from typing import Optional, TypedDict
import requests
import yaml
# Get TMP_DIR variable from environment # Get TMP_DIR variable from environment
TMP_DIR = os.path.join(os.environ.get("TMP_DIR", "/tmp"), "ohmyzsh") TMP_DIR = os.path.join(os.environ.get("TMP_DIR", "/tmp"), "ohmyzsh")
# Relative path to dependencies.yml file # Relative path to dependencies.yml file
@ -14,28 +16,29 @@ DEPS_YAML_FILE = ".github/dependencies.yml"
# Dry run flag # Dry run flag
DRY_RUN = os.environ.get("DRY_RUN", "0") == "1" DRY_RUN = os.environ.get("DRY_RUN", "0") == "1"
import timeit
class CodeTimer: class CodeTimer:
def __init__(self, name=None): def __init__(self, name=None):
self.name = " '" + name + "'" if name else '' self.name = " '" + name + "'" if name else ""
def __enter__(self): def __enter__(self):
self.start = timeit.default_timer() self.start = timeit.default_timer()
def __exit__(self, exc_type, exc_value, traceback): def __exit__(self, exc_type, exc_value, traceback):
self.took = (timeit.default_timer() - self.start) * 1000.0 self.took = (timeit.default_timer() - self.start) * 1000.0
print('Code block' + self.name + ' took: ' + str(self.took) + ' ms') print("Code block" + self.name + " took: " + str(self.took) + " ms")
### YAML representation ### YAML representation
def str_presenter(dumper, data): def str_presenter(dumper, data):
""" """
Configures yaml for dumping multiline strings Configures yaml for dumping multiline strings
Ref: https://stackoverflow.com/a/33300001 Ref: https://stackoverflow.com/a/33300001
""" """
if len(data.splitlines()) > 1: # check for multiline string if len(data.splitlines()) > 1: # check for multiline string
return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|') return dumper.represent_scalar("tag:yaml.org,2002:str", data, style="|")
return dumper.represent_scalar('tag:yaml.org,2002:str', data) return dumper.represent_scalar("tag:yaml.org,2002:str", data)
yaml.add_representer(str, str_presenter) yaml.add_representer(str, str_presenter)
yaml.representer.SafeRepresenter.add_representer(str, str_presenter) yaml.representer.SafeRepresenter.add_representer(str, str_presenter)
@ -43,408 +46,451 @@ yaml.representer.SafeRepresenter.add_representer(str, str_presenter)
# Types # Types
class DependencyDict(TypedDict): class DependencyDict(TypedDict):
repo: str repo: str
branch: str branch: str
version: str version: str
precopy: Optional[str] precopy: Optional[str]
postcopy: Optional[str] postcopy: Optional[str]
class DependencyYAML(TypedDict): class DependencyYAML(TypedDict):
dependencies: dict[str, DependencyDict] dependencies: dict[str, DependencyDict]
class UpdateStatus(TypedDict): class UpdateStatus(TypedDict):
has_updates: bool has_updates: bool
version: Optional[str] version: Optional[str]
compare_url: Optional[str] compare_url: Optional[str]
head_ref: Optional[str] head_ref: Optional[str]
head_url: Optional[str] head_url: Optional[str]
class CommandRunner: class CommandRunner:
class Exception(Exception): class Exception(Exception):
def __init__(self, message, returncode, stage, stdout, stderr): def __init__(self, message, returncode, stage, stdout, stderr):
super().__init__(message) super().__init__(message)
self.returncode = returncode self.returncode = returncode
self.stage = stage self.stage = stage
self.stdout = stdout self.stdout = stdout
self.stderr = stderr self.stderr = stderr
@staticmethod @staticmethod
def run_or_fail(command: list[str], stage: str, *args, **kwargs): def run_or_fail(command: list[str], stage: str, *args, **kwargs):
if DRY_RUN and command[0] == "gh": if DRY_RUN and command[0] == "gh":
command.insert(0, "echo") command.insert(0, "echo")
result = subprocess.run(command, *args, capture_output=True, **kwargs) result = subprocess.run(command, *args, capture_output=True, **kwargs)
if result.returncode != 0: if result.returncode != 0:
raise CommandRunner.Exception( raise CommandRunner.Exception(
f"{stage} command failed with exit code {result.returncode}", returncode=result.returncode, f"{stage} command failed with exit code {result.returncode}",
stage=stage, returncode=result.returncode,
stdout=result.stdout.decode("utf-8"), stage=stage,
stderr=result.stderr.decode("utf-8") stdout=result.stdout.decode("utf-8"),
) stderr=result.stderr.decode("utf-8"),
)
return result return result
class DependencyStore: class DependencyStore:
store: DependencyYAML = { store: DependencyYAML = {"dependencies": {}}
"dependencies": {}
}
@staticmethod @staticmethod
def set(data: DependencyYAML): def set(data: DependencyYAML):
DependencyStore.store = data DependencyStore.store = data
@staticmethod @staticmethod
def update_dependency_version(path: str, version: str) -> DependencyYAML: def update_dependency_version(path: str, version: str) -> DependencyYAML:
with CodeTimer(f"store deepcopy: {path}"): with CodeTimer(f"store deepcopy: {path}"):
store_copy = deepcopy(DependencyStore.store) store_copy = deepcopy(DependencyStore.store)
dependency = store_copy["dependencies"].get(path, {}) dependency = store_copy["dependencies"].get(path, {})
dependency["version"] = version dependency["version"] = version
store_copy["dependencies"][path] = dependency store_copy["dependencies"][path] = dependency
return store_copy return store_copy
@staticmethod @staticmethod
def write_store(file: str, data: DependencyYAML): def write_store(file: str, data: DependencyYAML):
with open(file, "w") as yaml_file: with open(file, "w") as yaml_file:
yaml.safe_dump(data, yaml_file, sort_keys=False) yaml.safe_dump(data, yaml_file, sort_keys=False)
class Dependency: class Dependency:
def __init__(self, path: str, values: DependencyDict): def __init__(self, path: str, values: DependencyDict):
self.path = path self.path = path
self.values = values self.values = values
self.name: str = "" self.name: str = ""
self.desc: str = "" self.desc: str = ""
self.kind: str = "" self.kind: str = ""
match path.split("/"): match path.split("/"):
case ["plugins", name]: case ["plugins", name]:
self.name = name self.name = name
self.kind = "plugin" self.kind = "plugin"
self.desc = f"{name} plugin" self.desc = f"{name} plugin"
case ["themes", name]: case ["themes", name]:
self.name = name.replace(".zsh-theme", "") self.name = name.replace(".zsh-theme", "")
self.kind = "theme" self.kind = "theme"
self.desc = f"{self.name} theme" self.desc = f"{self.name} theme"
case _: case _:
self.name = self.desc = path self.name = self.desc = path
def __str__(self): def __str__(self):
output: str = "" output: str = ""
for key in DependencyDict.__dict__['__annotations__'].keys(): for key in DependencyDict.__dict__["__annotations__"].keys():
if key not in self.values: if key not in self.values:
output += f"{key}: None\n" output += f"{key}: None\n"
continue continue
value = self.values[key] value = self.values[key]
if "\n" not in value: if "\n" not in value:
output += f"{key}: {value}\n" output += f"{key}: {value}\n"
else: else:
output += f"{key}:\n " output += f"{key}:\n "
output += value.replace("\n", "\n ", value.count("\n") - 1) output += value.replace("\n", "\n ", value.count("\n") - 1)
return output return output
def update_or_notify(self): def update_or_notify(self):
# Print dependency settings # Print dependency settings
print(f"Processing {self.desc}...", file=sys.stderr) print(f"Processing {self.desc}...", file=sys.stderr)
print(self, file=sys.stderr) print(self, file=sys.stderr)
# Check for updates # Check for updates
repo = self.values["repo"] repo = self.values["repo"]
remote_branch = self.values["branch"] remote_branch = self.values["branch"]
version = self.values["version"] version = self.values["version"]
is_tag = version.startswith("tag:") is_tag = version.startswith("tag:")
try:
with CodeTimer(f"update check: {repo}"):
if is_tag:
status = GitHub.check_newer_tag(repo, version.replace("tag:", ""))
else:
status = GitHub.check_updates(repo, remote_branch, version)
if status["has_updates"]:
short_sha = status["head_ref"][:8]
new_version = status["version"] if is_tag else short_sha
try: try:
# Create new branch with CodeTimer(f"update check: {repo}"):
branch = Git.create_branch(self.path, new_version) if is_tag:
status = GitHub.check_newer_tag(repo, version.replace("tag:", ""))
else:
status = GitHub.check_updates(repo, remote_branch, version)
# Update dependencies.yml file if status["has_updates"]:
self.__update_yaml(f"tag:{new_version}" if is_tag else status["version"]) short_sha = status["head_ref"][:8]
new_version = status["version"] if is_tag else short_sha
# Update dependency files try:
self.__apply_upstream_changes() # Create new branch
branch = Git.create_branch(self.path, new_version)
# Add all changes and commit # Update dependencies.yml file
Git.add_and_commit(self.name, short_sha) self.__update_yaml(
f"tag:{new_version}" if is_tag else status["version"]
)
# Push changes to remote # Update dependency files
Git.push(branch) self.__apply_upstream_changes()
# Create GitHub PR # Add all changes and commit
GitHub.create_pr( Git.add_and_commit(self.name, short_sha)
branch,
f"feat({self.name}): update to version {new_version}", # Push changes to remote
f"""## Description Git.push(branch)
# Create GitHub PR
GitHub.create_pr(
branch,
f"feat({self.name}): update to version {new_version}",
f"""## Description
Update for **{self.desc}**: update to version [{new_version}]({status['head_url']}). Update for **{self.desc}**: update to version [{new_version}]({status['head_url']}).
Check out the [list of changes]({status['compare_url']}). Check out the [list of changes]({status['compare_url']}).
""" """,
) )
# Clean up repository # Clean up repository
Git.clean_repo() Git.clean_repo()
except (CommandRunner.Exception, shutil.Error) as e: except (CommandRunner.Exception, shutil.Error) as e:
# Handle exception on automatic update # Handle exception on automatic update
match type(e): match type(e):
case CommandRunner.Exception: case CommandRunner.Exception:
# Print error message # Print error message
print(f"Error running {e.stage} command: {e.returncode}", file=sys.stderr) print(
print(e.stderr, file=sys.stderr) f"Error running {e.stage} command: {e.returncode}",
case shutil.Error: file=sys.stderr,
print(f"Error copying files: {e}", file=sys.stderr) )
print(e.stderr, file=sys.stderr)
case shutil.Error:
print(f"Error copying files: {e}", file=sys.stderr)
try: try:
Git.clean_repo() Git.clean_repo()
except CommandRunner.Exception as e: except CommandRunner.Exception as e:
print(f"Error reverting repository to clean state: {e}", file=sys.stderr) print(
sys.exit(1) f"Error reverting repository to clean state: {e}",
file=sys.stderr,
)
sys.exit(1)
# Create a GitHub issue to notify maintainer # Create a GitHub issue to notify maintainer
title = f"{self.path}: update to {new_version}" title = f"{self.path}: update to {new_version}"
body = ( body = f"""## Description
f"""## Description
There is a new version of `{self.name}` {self.kind} available. There is a new version of `{self.name}` {self.kind} available.
New version: [{new_version}]({status['head_url']}) New version: [{new_version}]({status['head_url']})
Check out the [list of changes]({status['compare_url']}). Check out the [list of changes]({status['compare_url']}).
""" """
)
print(f"Creating GitHub issue", file=sys.stderr) print("Creating GitHub issue", file=sys.stderr)
print(f"{title}\n\n{body}", file=sys.stderr) print(f"{title}\n\n{body}", file=sys.stderr)
GitHub.create_issue(title, body) GitHub.create_issue(title, body)
except Exception as e: except Exception as e:
print(e, file=sys.stderr) print(e, file=sys.stderr)
def __update_yaml(self, new_version: str) -> None: def __update_yaml(self, new_version: str) -> None:
dep_yaml = DependencyStore.update_dependency_version(self.path, new_version) dep_yaml = DependencyStore.update_dependency_version(self.path, new_version)
DependencyStore.write_store(DEPS_YAML_FILE, dep_yaml) DependencyStore.write_store(DEPS_YAML_FILE, dep_yaml)
def __apply_upstream_changes(self) -> None: def __apply_upstream_changes(self) -> None:
# Patterns to ignore in copying files from upstream repo # Patterns to ignore in copying files from upstream repo
GLOBAL_IGNORE = [ GLOBAL_IGNORE = [".git", ".github", ".gitignore"]
".git",
".github",
".gitignore"
]
path = os.path.abspath(self.path) path = os.path.abspath(self.path)
precopy = self.values.get("precopy") precopy = self.values.get("precopy")
postcopy = self.values.get("postcopy") postcopy = self.values.get("postcopy")
repo = self.values["repo"] repo = self.values["repo"]
branch = self.values["branch"] branch = self.values["branch"]
remote_url = f"https://github.com/{repo}.git" remote_url = f"https://github.com/{repo}.git"
repo_dir = os.path.join(TMP_DIR, repo) repo_dir = os.path.join(TMP_DIR, repo)
# Clone repository # Clone repository
Git.clone(remote_url, branch, repo_dir, reclone=True) Git.clone(remote_url, branch, repo_dir, reclone=True)
# Run precopy on tmp repo # Run precopy on tmp repo
if precopy is not None: if precopy is not None:
print("Running precopy script:", end="\n ", file=sys.stderr) print("Running precopy script:", end="\n ", file=sys.stderr)
print(precopy.replace("\n", "\n ", precopy.count("\n") - 1), file=sys.stderr) print(
CommandRunner.run_or_fail(["bash", "-c", precopy], cwd=repo_dir, stage="Precopy") precopy.replace("\n", "\n ", precopy.count("\n") - 1), file=sys.stderr
)
CommandRunner.run_or_fail(
["bash", "-c", precopy], cwd=repo_dir, stage="Precopy"
)
# Copy files from upstream repo # Copy files from upstream repo
print(f"Copying files from {repo_dir} to {path}", file=sys.stderr) print(f"Copying files from {repo_dir} to {path}", file=sys.stderr)
shutil.copytree(repo_dir, path, dirs_exist_ok=True, ignore=shutil.ignore_patterns(*GLOBAL_IGNORE)) shutil.copytree(
repo_dir,
path,
dirs_exist_ok=True,
ignore=shutil.ignore_patterns(*GLOBAL_IGNORE),
)
# Run postcopy on our repository # Run postcopy on our repository
if postcopy is not None: if postcopy is not None:
print("Running postcopy script:", end="\n ", file=sys.stderr) print("Running postcopy script:", end="\n ", file=sys.stderr)
print(postcopy.replace("\n", "\n ", postcopy.count("\n") - 1), file=sys.stderr) print(
CommandRunner.run_or_fail(["bash", "-c", postcopy], cwd=path, stage="Postcopy") postcopy.replace("\n", "\n ", postcopy.count("\n") - 1),
file=sys.stderr,
)
CommandRunner.run_or_fail(
["bash", "-c", postcopy], cwd=path, stage="Postcopy"
)
class Git: class Git:
default_branch = "master" default_branch = "master"
@staticmethod @staticmethod
def clone(remote_url: str, branch: str, repo_dir: str, reclone=False): def clone(remote_url: str, branch: str, repo_dir: str, reclone=False):
# If repo needs to be fresh # If repo needs to be fresh
if reclone and os.path.exists(repo_dir): if reclone and os.path.exists(repo_dir):
shutil.rmtree(repo_dir) shutil.rmtree(repo_dir)
# Clone repo in tmp directory and checkout branch # Clone repo in tmp directory and checkout branch
if not os.path.exists(repo_dir): if not os.path.exists(repo_dir):
print(f"Cloning {remote_url} to {repo_dir} and checking out {branch}", file=sys.stderr) print(
CommandRunner.run_or_fail(["git", "clone", "--depth=1", "-b", branch, remote_url, repo_dir], stage="Clone") f"Cloning {remote_url} to {repo_dir} and checking out {branch}",
file=sys.stderr,
)
CommandRunner.run_or_fail(
["git", "clone", "--depth=1", "-b", branch, remote_url, repo_dir],
stage="Clone",
)
@staticmethod @staticmethod
def create_branch(path: str, version: str): def create_branch(path: str, version: str):
# Get current branch name # Get current branch name
result = CommandRunner.run_or_fail(["git", "rev-parse", "--abbrev-ref", "HEAD"], stage="GetDefaultBranch") result = CommandRunner.run_or_fail(
Git.default_branch = result.stdout.decode("utf-8").strip() ["git", "rev-parse", "--abbrev-ref", "HEAD"], stage="GetDefaultBranch"
)
Git.default_branch = result.stdout.decode("utf-8").strip()
# Create new branch and return created branch name # Create new branch and return created branch name
branch_name = f"update/{path}/{version}" branch_name = f"update/{path}/{version}"
CommandRunner.run_or_fail(["git", "checkout", "-b", branch_name], stage="CreateBranch") CommandRunner.run_or_fail(
return branch_name ["git", "checkout", "-b", branch_name], stage="CreateBranch"
)
return branch_name
@staticmethod @staticmethod
def add_and_commit(scope: str, version: str): def add_and_commit(scope: str, version: str):
user_name = os.environ.get("GIT_APP_NAME") user_name = os.environ.get("GIT_APP_NAME")
user_email = os.environ.get("GIT_APP_EMAIL") user_email = os.environ.get("GIT_APP_EMAIL")
# Add all files to git staging # Add all files to git staging
CommandRunner.run_or_fail(["git", "add", "-A", "-v"], stage="AddFiles") CommandRunner.run_or_fail(["git", "add", "-A", "-v"], stage="AddFiles")
# Reset environment and git config # Reset environment and git config
clean_env = os.environ.copy() clean_env = os.environ.copy()
clean_env["LANG"]="C.UTF-8" clean_env["LANG"] = "C.UTF-8"
clean_env["GIT_CONFIG_GLOBAL"]="/dev/null" clean_env["GIT_CONFIG_GLOBAL"] = "/dev/null"
clean_env["GIT_CONFIG_NOSYSTEM"]="1" clean_env["GIT_CONFIG_NOSYSTEM"] = "1"
# Commit with settings above # Commit with settings above
CommandRunner.run_or_fail([ CommandRunner.run_or_fail(
"git", [
"-c", f"user.name={user_name}", "git",
"-c", f"user.email={user_email}", "-c",
"commit", f"user.name={user_name}",
"-m", f"feat({scope}): update to {version}" "-c",
], stage="CreateCommit", env=clean_env) f"user.email={user_email}",
"commit",
"-m",
f"feat({scope}): update to {version}",
],
stage="CreateCommit",
env=clean_env,
)
@staticmethod @staticmethod
def push(branch: str): def push(branch: str):
CommandRunner.run_or_fail(["git", "push", "-u", "origin", branch], stage="PushBranch") CommandRunner.run_or_fail(
["git", "push", "-u", "origin", branch], stage="PushBranch"
)
@staticmethod @staticmethod
def clean_repo(): def clean_repo():
CommandRunner.run_or_fail(["git", "reset", "--hard", "HEAD"], stage="ResetRepository") CommandRunner.run_or_fail(
CommandRunner.run_or_fail(["git", "checkout", Git.default_branch], stage="CheckoutDefaultBranch") ["git", "reset", "--hard", "HEAD"], stage="ResetRepository"
)
CommandRunner.run_or_fail(
["git", "checkout", Git.default_branch], stage="CheckoutDefaultBranch"
)
class GitHub: class GitHub:
@staticmethod @staticmethod
def check_newer_tag(repo, current_tag) -> UpdateStatus: def check_newer_tag(repo, current_tag) -> UpdateStatus:
# GET /repos/:owner/:repo/git/refs/tags # GET /repos/:owner/:repo/git/refs/tags
url = f"https://api.github.com/repos/{repo}/git/refs/tags" url = f"https://api.github.com/repos/{repo}/git/refs/tags"
# Send a GET request to the GitHub API # Send a GET request to the GitHub API
response = requests.get(url) response = requests.get(url)
# If the request was successful # If the request was successful
if response.status_code == 200: if response.status_code == 200:
# Parse the JSON response # Parse the JSON response
data = response.json() data = response.json()
if len(data) == 0: if len(data) == 0:
return { return {
"has_updates": False, "has_updates": False,
} }
latest_ref = data[-1] latest_ref = data[-1]
latest_tag = latest_ref["ref"].replace("refs/tags/", "") latest_tag = latest_ref["ref"].replace("refs/tags/", "")
if latest_tag == current_tag: if latest_tag == current_tag:
return { return {
"has_updates": False, "has_updates": False,
} }
return { return {
"has_updates": True, "has_updates": True,
"version": latest_tag, "version": latest_tag,
"compare_url": f"https://github.com/{repo}/compare/{current_tag}...{latest_tag}", "compare_url": f"https://github.com/{repo}/compare/{current_tag}...{latest_tag}",
"head_ref": latest_ref["object"]["sha"], "head_ref": latest_ref["object"]["sha"],
"head_url": f"https://github.com/{repo}/releases/tag/{latest_tag}", "head_url": f"https://github.com/{repo}/releases/tag/{latest_tag}",
} }
else: else:
# If the request was not successful, raise an exception # If the request was not successful, raise an exception
raise Exception(f"GitHub API request failed with status code {response.status_code}: {response.json()}") raise Exception(
f"GitHub API request failed with status code {response.status_code}: {response.json()}"
)
@staticmethod @staticmethod
def check_updates(repo, branch, version) -> UpdateStatus: def check_updates(repo, branch, version) -> UpdateStatus:
# TODO: add support for semver updating (based on tags) # TODO: add support for semver updating (based on tags)
# Check if upstream github repo has a new version # Check if upstream github repo has a new version
# GitHub API URL for comparing two commits # GitHub API URL for comparing two commits
url = f"https://api.github.com/repos/{repo}/compare/{version}...{branch}" url = f"https://api.github.com/repos/{repo}/compare/{version}...{branch}"
# Send a GET request to the GitHub API # Send a GET request to the GitHub API
response = requests.get(url) response = requests.get(url)
# If the request was successful # If the request was successful
if response.status_code == 200: if response.status_code == 200:
# Parse the JSON response # Parse the JSON response
data = response.json() data = response.json()
# If the base is behind the head, there is a newer version # If the base is behind the head, there is a newer version
has_updates = data["status"] != "identical" has_updates = data["status"] != "identical"
if not has_updates: if not has_updates:
return { return {
"has_updates": False, "has_updates": False,
} }
return { return {
"has_updates": data["status"] != "identical", "has_updates": data["status"] != "identical",
"version": data["commits"][-1]["sha"], "version": data["commits"][-1]["sha"],
"compare_url": data["permalink_url"], "compare_url": data["permalink_url"],
"head_ref": data["commits"][-1]["sha"], "head_ref": data["commits"][-1]["sha"],
"head_url": data["commits"][-1]["html_url"] "head_url": data["commits"][-1]["html_url"],
} }
else: else:
# If the request was not successful, raise an exception # If the request was not successful, raise an exception
raise Exception(f"GitHub API request failed with status code {response.status_code}: {response.json()}") raise Exception(
f"GitHub API request failed with status code {response.status_code}: {response.json()}"
)
@staticmethod @staticmethod
def create_issue(title: str, body: str) -> None: def create_issue(title: str, body: str) -> None:
cmd = [ cmd = ["gh", "issue", "create", "-t", title, "-b", body]
"gh", CommandRunner.run_or_fail(cmd, stage="CreateIssue")
"issue",
"create",
"-t", title,
"-b", body
]
CommandRunner.run_or_fail(cmd, stage="CreateIssue")
@staticmethod @staticmethod
def create_pr(branch: str, title: str, body: str) -> None: def create_pr(branch: str, title: str, body: str) -> None:
cmd = [ cmd = [
"gh", "gh",
"pr", "pr",
"create", "create",
"-B", Git.default_branch, "-B",
"-H", branch, Git.default_branch,
"-t", title, "-H",
"-b", body branch,
] "-t",
CommandRunner.run_or_fail(cmd, stage="CreatePullRequest") title,
"-b",
body,
]
CommandRunner.run_or_fail(cmd, stage="CreatePullRequest")
def main(): def main():
# Load the YAML file # Load the YAML file
with open(DEPS_YAML_FILE, "r") as yaml_file: with open(DEPS_YAML_FILE, "r") as yaml_file:
data: DependencyYAML = yaml.safe_load(yaml_file) data: DependencyYAML = yaml.safe_load(yaml_file)
if "dependencies" not in data: if "dependencies" not in data:
raise Exception(f"dependencies.yml not properly formatted") raise Exception("dependencies.yml not properly formatted")
# Cache YAML version # Cache YAML version
DependencyStore.set(data) DependencyStore.set(data)
dependencies = data["dependencies"]
for path in dependencies:
dependency = Dependency(path, dependencies[path])
dependency.update_or_notify()
dependencies = data["dependencies"]
for path in dependencies:
dependency = Dependency(path, dependencies[path])
dependency.update_or_notify()
if __name__ == "__main__": if __name__ == "__main__":
main() main()