apply Black 25.11.0 style in fbcode (72/92)

Summary:
Formats the covered files with pyfmt.

paintitblack

Reviewed By: itamaro

Differential Revision: D90476322

fbshipit-source-id: e689aa40511799087010490a2ebe5260d41130c8

Author: bowiechen

.github/scripts/abtest.py

@@ -52,12 +52,12 @@ def run_commit(
 def validate_benchmark_output(bm_output: Path, bm_name: str):
     with open(bm_output, "r") as bmobj:
         output = json.load(bmobj)
-    assert (
-        output["name"] == bm_name
-    ), f"Expected benchmark name {bm_name}, getting {output['name']}."
-    assert (
-        "environ" in output and "pytorch_git_version" in output["environ"]
-    ), f"Missing pytorch git version in {bm_output}."
+    assert output["name"] == bm_name, (
+        f"Expected benchmark name {bm_name}, getting {output['name']}."
+    )
+    assert "environ" in output and "pytorch_git_version" in output["environ"], (
+        f"Missing pytorch git version in {bm_output}."
+    )
     assert "metrics" in output, f"Missing definition of metrics in {bm_output}."
 
 
@@ -138,17 +138,17 @@ def validate_results(a, b) -> bool:
         return sorted(metrics) == sorted(b["metrics"])
 
     # check two results are different files
-    assert (
-        not result_a == result_b
-    ), f"Path {result_a} and {result_b} are the same. Exit."
+    assert not result_a == result_b, (
+        f"Path {result_a} and {result_b} are the same. Exit."
+    )
     # validate results
     with open(result_a, "r") as fa:
         a = json.load(fa)
     with open(result_b, "r") as fb:
         b = json.load(fb)
-    assert validate_results(
-        a, b
-    ), f"Result validation failed for {result_a} and {result_b}."
+    assert validate_results(a, b), (
+        f"Result validation failed for {result_a} and {result_b}."
+    )
     # print result in csv format
     header = [
         "Metric",
@@ -195,11 +195,13 @@ def validate_results(a, b) -> bool:
         f"but you specified {args.userbenchmark}."
     )
     if not args.skip_build:
-        assert Path(
-            args.pytorch_repo
-        ).is_dir(), f"Specified PyTorch repo dir {args.pytorch_repo} doesn't exist."
+        assert Path(args.pytorch_repo).is_dir(), (
+            f"Specified PyTorch repo dir {args.pytorch_repo} doesn't exist."
+        )
         commits = gitutils.get_git_commits(args.pytorch_repo, args.base, args.head)
-        assert commits, f"Can't find git commit {args.base} or {args.head} in repo {args.pytorch_repo}"
+        assert commits, (
+            f"Can't find git commit {args.base} or {args.head} in repo {args.pytorch_repo}"
+        )
     # setup cuda environment
     cuda_env = prepare_cuda_env(cuda_version=DEFAULT_CUDA_VERSION)
     result_a = run_commit(

.github/scripts/bmutils/analyze-bisection-result.py

@@ -14,18 +14,18 @@ def check_env(bisection_root: str):
     # result.json exists
     bisection_path = Path(bisection_root)
     assert os.environ["GITHUB_ENV"], f"GITHUB_ENV environment variable doesn't exist."
-    assert (
-        bisection_path.is_dir()
-    ), f"Specified bisection root {bisection_path} is not a directory."
-    assert (
-        bisection_path.joinpath("gh-issue.md").exists()
-    ), f"Bisection directory {bisection_path} doesn't contain file gh-issue.md."
-    assert (
-        bisection_path.joinpath("result.json").exists()
-    ), f"Bisection directory {bisection_path} doesn't contain file result.json."
-    assert (
-        bisection_path.joinpath("config.yaml").exists()
-    ), f"Bisection directory {bisection_path} doesn't contain file config.yaml."
+    assert bisection_path.is_dir(), (
+        f"Specified bisection root {bisection_path} is not a directory."
+    )
+    assert bisection_path.joinpath("gh-issue.md").exists(), (
+        f"Bisection directory {bisection_path} doesn't contain file gh-issue.md."
+    )
+    assert bisection_path.joinpath("result.json").exists(), (
+        f"Bisection directory {bisection_path} doesn't contain file result.json."
+    )
+    assert bisection_path.joinpath("config.yaml").exists(), (
+        f"Bisection directory {bisection_path} doesn't contain file config.yaml."
+    )
 
 
 def setup_gh_issue(bisection_root: str, gh_workflow_id: str):

.github/scripts/bmutils/summarize.py

@@ -52,9 +52,9 @@ def generate_header(result, base_key):
     base_arg = None
     for t in result:
         assert t[1] == test, f"Both {t[1]} and {test} exist in result, can't analyze."
-        assert (
-            t[2] == device
-        ), f"Both {t[2]} and {device} exist in result, can't analyze."
+        assert t[2] == device, (
+            f"Both {t[2]} and {device} exist in result, can't analyze."
+        )
         result_keys = result[t].keys()
         for k in filter(lambda x: not x in ATTRIBUTES, result_keys):
             if k == base_key:
@@ -121,9 +121,9 @@ def analyze_result(result_dir: str, base_key: str) -> str:
     files = get_nonempty_json(result_dir)
     # make sure the baseline file exists
     file_keys = list(map(lambda x: Path(x).stem, files))
-    assert (
-        base_key in file_keys
-    ), f"Baseline key {base_key} is not found in all files: {file_keys}."
+    assert base_key in file_keys, (
+        f"Baseline key {base_key} is not found in all files: {file_keys}."
+    )
     result = {}
     for f in files:
         process_json(result, f, base_key)

.github/scripts/generate-abtest-config.py

@@ -189,9 +189,9 @@ def setup_gh_env(affected_pytorch_version):
     # input directory
     input_dir = Path(args.benchmark_dir)
     tip_json_file = find_latest_nonempty_json(input_dir)
-    assert (
-        tip_json_file
-    ), "The input benchmark directory must contain a non-empty json file!"
+    assert tip_json_file, (
+        "The input benchmark directory must contain a non-empty json file!"
+    )
     tip_version = get_pytorch_version(args.pytorch_dir, tip_json_file)
     parent_dir = input_dir.parent
     base_benchmark_dirs = list(

.github/scripts/run-config.py

@@ -15,7 +15,6 @@
 from typing import List, Optional
 
 import yaml
-
 from bmutils import add_path
 from bmutils.summarize import analyze_result
 
@@ -59,7 +58,9 @@ def get_models(config) -> Optional[str]:
         r = re.compile(model_pattern)
         matched_models = list(filter(lambda x: r.match(x), models))
         enabled_models.extend(matched_models)
-    assert enabled_models, f"The model patterns you specified {config['models']} does not match any model. Please double check."
+    assert enabled_models, (
+        f"The model patterns you specified {config['models']} does not match any model. Please double check."
+    )
     return enabled_models
 
 
@@ -185,9 +186,9 @@ def check_env(bmconfigs):
                 cuda_path = Path("/").joinpath(
                     "usr", "local", f"cuda-{bmconfig.cuda_version}"
                 )
-                assert (
-                    cuda_path.exists() and cuda_path.is_dir()
-                ), f"Expected CUDA path {str(cuda_path)} doesn't exist. Please report a bug."
+                assert cuda_path.exists() and cuda_path.is_dir(), (
+                    f"Expected CUDA path {str(cuda_path)} doesn't exist. Please report a bug."
+                )
 
 
 if __name__ == "__main__":

.github/scripts/userbenchmark/aicluster.py

@@ -175,9 +175,9 @@ def upload_metrics_to_scribe(s3, benchmark_name, index, work_dir):
     """
     try:
         for index_key in index:
-            assert (
-                "uploaded-scribe" in index[index_key]
-            ), f"Index key {index_key} missing field uploaded-scribe!"
+            assert "uploaded-scribe" in index[index_key], (
+                f"Index key {index_key} missing field uploaded-scribe!"
+            )
         index_file_path = work_dir.joinpath(INDEX_FILE_NAME)
         with open(index_file_path, "w") as index_file:
             yaml.safe_dump(index, index_file)
@@ -188,9 +188,9 @@ def upload_metrics_to_scribe(s3, benchmark_name, index, work_dir):
             # download the metrics file from S3 to work_dir
             print(f"Downloading metrics file {upload_metrics} to local.")
             metrics_key = s3.exists(prefix=None, file_name=upload_metrics)
-            assert (
-                metrics_key
-            ), f"Expected metrics file {upload_metrics} does not exist."
+            assert metrics_key, (
+                f"Expected metrics file {upload_metrics} does not exist."
+            )
             s3.download_file(metrics_key, work_dir)
             # upload it to scribe
             print(f"Uploading metrics file {upload_metrics} to scribe.")
@@ -236,7 +236,9 @@ def run_aicluster_benchmark(
     index = get_metrics_index(s3, benchmark_name, work_dir)
     # if the previous run is not successful, exit immediately
     if check_success and not determine_success_today(index):
-        assert False, f"Don't find the last successful run in index: { index }. Please report a bug."
+        assert False, (
+            f"Don't find the last successful run in index: {index}. Please report a bug."
+        )
     # upload to scribe by the index
     if upload_scribe:
         upload_metrics_to_scribe(s3, benchmark_name, index, work_dir)

bisection.py

@@ -23,7 +23,6 @@
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
 import yaml
-
 from userbenchmark.utils import (
     parse_abtest_result_from_regression_file_for_bisect,
     TorchBenchABTestResult,
@@ -125,9 +124,9 @@ def get_updated_clean_torch_repos(
     all_repos = {}
 
     def _gen_torch_repo(repo_name: str, repo_path: str):
-        assert (
-            repo_path.exists() and repo_path.is_dir()
-        ), f"{str(repo_path)} is not an existing directory."
+        assert repo_path.exists() and repo_path.is_dir(), (
+            f"{str(repo_path)} is not an existing directory."
+        )
         main_branch = (
             "main"
             if not "main_branch" in TORCHBENCH_BISECTION_TARGETS[repo_name]
@@ -216,9 +215,9 @@ def _checkout_non_target_repos(self, cdate: datetime):
             print(
                 f"Checking out {repo.name} commit {dep_commit} ...", end="", flush=True
             )
-            assert gitutils.checkout_git_commit(
-                repo.src_path.absolute(), dep_commit
-            ), f"Failed to checkout commit {dep_commit} of {repo.name}"
+            assert gitutils.checkout_git_commit(repo.src_path.absolute(), dep_commit), (
+                f"Failed to checkout commit {dep_commit} of {repo.name}"
+            )
             print("done.")
 
     def prep(self, interactive: bool = False) -> bool:
@@ -314,9 +313,9 @@ def _run_benchmark_for_commit(
         output_dir = os.path.join(self.workdir.absolute(), commit.sha)
         # If the directory already exists, clear its contents
         if os.path.exists(output_dir):
-            assert os.path.isdir(
-                output_dir
-            ), "Must specify output directory: {output_dir}"
+            assert os.path.isdir(output_dir), (
+                "Must specify output directory: {output_dir}"
+            )
             shutil.rmtree(output_dir)
         os.mkdir(output_dir)
         # If the first time to run benchmark, install the dependencies first
@@ -612,15 +611,15 @@ def main() -> None:
 
     bisect_config = parse_abtest_result_from_regression_file_for_bisect(args.config)
     # sanity checks
-    assert (
-        bisect_config.name
-    ), "Invalid bisection config, must specify userbenchmark name."
-    assert bisect_config.control_env[
-        "git_commit_hash"
-    ], "Invalid bisection config, must specify control group commit hash."
-    assert bisect_config.treatment_env[
-        "git_commit_hash"
-    ], "Invalid bisection config, must specify treatment group commit hash."
+    assert bisect_config.name, (
+        "Invalid bisection config, must specify userbenchmark name."
+    )
+    assert bisect_config.control_env["git_commit_hash"], (
+        "Invalid bisection config, must specify control group commit hash."
+    )
+    assert bisect_config.treatment_env["git_commit_hash"], (
+        "Invalid bisection config, must specify treatment group commit hash."
+    )
     assert bisect_config.bisection in TORCHBENCH_BISECTION_TARGETS.keys(), (
         f"Invalid bisection config, "
         f"get bisection target repo {bisect_config.bisection}, "
@@ -632,9 +631,9 @@ def main() -> None:
     if args.skip_update:
         skip_update_repos = list(map(lambda x: x.strip(), args.skip_update.split(",")))
         for repo in skip_update_repos:
-            assert (
-                repo in list(TORCHBENCH_BISECTION_TARGETS.keys())
-            ), f"User specified skip update repo {repo} not in list: {TORCHBENCH_BISECTION_TARGETS.keys()}"
+            assert repo in list(TORCHBENCH_BISECTION_TARGETS.keys()), (
+                f"User specified skip update repo {repo} not in list: {TORCHBENCH_BISECTION_TARGETS.keys()}"
+            )
     else:
         skip_update_repos = None
     if args.skip_install_torchbench:

regression_detector.py

@@ -72,10 +72,10 @@ def _call_userbenchmark_detector(
     ) -> TorchBenchABTestResult:
         return detector(control, treatment)
 
-    assert (
-        control["name"] == treatment["name"]
-    ), f'Expected the same userbenchmark name from metrics files, \
-                                                but getting {control["name"]} and {treatment["name"]}.'
+    assert control["name"] == treatment["name"], (
+        f"Expected the same userbenchmark name from metrics files, \
+                                                but getting {control['name']} and {treatment['name']}."
+    )
     bm_name = control["name"]
     try:
         detector = importlib.import_module(
@@ -257,7 +257,9 @@ def get_metrics_by_date(
         if metric_datetime.date() == pick_date.date():
             pick_metrics_json_key = metrics_json_key
             break
-    assert pick_metrics_json_key, f"Selected date {pick_date} is not found in the latest_metrics_jsons: {latest_metrics_jsons}"
+    assert pick_metrics_json_key, (
+        f"Selected date {pick_date} is not found in the latest_metrics_jsons: {latest_metrics_jsons}"
+    )
     s3 = S3Client(USERBENCHMARK_S3_BUCKET, USERBENCHMARK_S3_OBJECT)
     metrics_json = s3.get_file_as_json(pick_metrics_json_key)
     return (metrics_json, pick_metrics_json_key)
@@ -355,27 +357,27 @@ def get_metrics_by_date(
     control, treatment = None, None
     if not args.control and args.treatment:
         json_path = Path(args.treatment)
-        assert (
-            json_path.exists()
-        ), f"Specified result json path {args.treatment} does not exist."
+        assert json_path.exists(), (
+            f"Specified result json path {args.treatment} does not exist."
+        )
         end_date: datetime = datetime.strptime(
             get_date_from_metrics(json_path.stem), "%Y-%m-%d"
         )
         userbenchmark_name: str = get_ub_name(args.treatment)
         with open(json_path, "r") as cfptr:
             treatment = json.load(cfptr)
     else:
-        assert (
-            args.name
-        ), f"To detect regression with S3, you must specify a userbenchmark name."
+        assert args.name, (
+            f"To detect regression with S3, you must specify a userbenchmark name."
+        )
         userbenchmark_name = args.name
         end_date = datetime.strptime(args.end_date, "%Y-%m-%d")
 
     # Only download the existing regression YAML file from S3
     if args.download_from_s3:
-        assert (
-            args.output
-        ), f"You must specify a regression output file path for S3 download."
+        assert args.output, (
+            f"You must specify a regression output file path for S3 download."
+        )
         regression_yaml_cond = lambda x: x.endswith(".yaml") and "regression" in x
         available_regression_yamls = get_latest_files_in_s3_from_last_n_days(
             userbenchmark_name, args.platform, end_date, regression_yaml_cond, ndays=1

run.py

@@ -16,7 +16,6 @@
 import numpy as np
 import torch
 import torch.profiler as profiler
-
 from torchbenchmark.util.experiment.instantiator import (
     load_model,
     TorchBenchModelConfig,
@@ -547,9 +546,9 @@ def main() -> None:
         if "gpu_peak_mem" in metrics_needed or (
             "flops" in metrics_needed and metrics_gpu_backend == "dcgm"
         ):
-            assert (
-                args.device == "cuda"
-            ), "gpu_peak_mem and flops:dcgm are only available for cuda device."
+            assert args.device == "cuda", (
+                "gpu_peak_mem and flops:dcgm are only available for cuda device."
+            )
     if args.export_metrics:
         if not args.metrics:
             print("You have to specifiy at least one metrics to export.")

scripts/proper_bs.py

@@ -59,9 +59,9 @@ def _run_model_test_proper_bs(
     batch_size: Optional[int],
     extra_args: List[str],
 ) -> ModelTestResult:
-    assert (
-        test == "train" or test == "eval"
-    ), f"Test must be either 'train' or 'eval', but get {test}."
+    assert test == "train" or test == "eval", (
+        f"Test must be either 'train' or 'eval', but get {test}."
+    )
     result = ModelTestResult(
         name=model_path.name,
         test=test,