lol

flutter.updateScript: fix some ruff warning

authored by

mivorasu and committed by
mivorasu
be500d94 9027305b

+223 -157
+223 -157
pkgs/development/compilers/flutter/update/update.py
··· 1 1 #! /usr/bin/env nix-shell 2 2 #! nix-shell -i python3 -p python3Packages.pyyaml 3 3 4 - import shutil 4 + import argparse 5 5 import json 6 - import urllib.request 7 - import tempfile 8 - from sys import exit 9 6 import os 10 - import subprocess 11 7 import re 12 - import json 13 - import argparse 8 + import subprocess 9 + import sys 10 + import tempfile 11 + import urllib.request 12 + from pathlib import Path 13 + 14 14 import yaml 15 - import json 16 15 17 - FAKE_HASH = 'sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=' 16 + FAKE_HASH = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=" 18 17 19 - NIXPKGS_ROOT = subprocess.Popen(['git', 20 - 'rev-parse', 21 - '--show-toplevel'], 22 - stdout=subprocess.PIPE, 23 - text=True).communicate()[0].strip() 18 + NIXPKGS_ROOT = ( 19 + subprocess.Popen( 20 + ["git", "rev-parse", "--show-toplevel"], stdout=subprocess.PIPE, text=True 21 + ) 22 + .communicate()[0] 23 + .strip() 24 + ) 24 25 25 26 26 27 def load_code(name, **kwargs): 27 - with open(f"{NIXPKGS_ROOT}/pkgs/development/compilers/flutter/update/{name}.in", 'r') as f: 28 + with Path( 29 + f"{NIXPKGS_ROOT}/pkgs/development/compilers/flutter/update/{name}.in" 30 + ).open("r", encoding="utf-8") as f: 28 31 code = f.read() 29 32 30 - for (key, value) in kwargs.items(): 33 + for key, value in kwargs.items(): 31 34 code = code.replace(f"@{key}@", value) 32 35 33 36 return code ··· 35 38 36 39 # Return out paths 37 40 def nix_build(code): 38 - temp = tempfile.NamedTemporaryFile(mode='w') 39 - temp.write(code) 40 - temp.flush() 41 - os.fsync(temp.fileno()) 41 + with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", delete=False) as temp: 42 + temp.write(code) 43 + temp.flush() 44 + os.fsync(temp.fileno()) 45 + temp_name = temp.name 42 46 43 47 process = subprocess.Popen( 44 48 [ ··· 46 50 "--impure", 47 51 "--no-out-link", 48 52 "--expr", 49 - f"with import {NIXPKGS_ROOT} {{}}; callPackage {temp.name} {{}}"], 53 + f"with import {NIXPKGS_ROOT} {{}}; callPackage {temp_name} {{}}", 54 + ], 50 55 stdout=subprocess.PIPE, 51 - text=True) 56 + text=True, 57 + ) 52 58 53 59 process.wait() 54 - temp.close() 60 + Path(temp_name).unlink() # Clean up the temporary file 55 61 return process.stdout.read().strip().splitlines()[0] 56 62 57 63 58 64 # Return errors 59 65 def nix_build_to_fail(code): 60 - temp = tempfile.NamedTemporaryFile(mode='w') 61 - temp.write(code) 62 - temp.flush() 63 - os.fsync(temp.fileno()) 66 + with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", delete=False) as temp: 67 + temp.write(code) 68 + temp.flush() 69 + os.fsync(temp.fileno()) 70 + temp_name = temp.name 64 71 65 72 process = subprocess.Popen( 66 73 [ ··· 69 76 "--keep-going", 70 77 "--no-link", 71 78 "--expr", 72 - f"with import {NIXPKGS_ROOT} {{}}; callPackage {temp.name} {{}}"], 79 + f"with import {NIXPKGS_ROOT} {{}}; callPackage {temp_name} {{}}", 80 + ], 73 81 stderr=subprocess.PIPE, 74 - text=True) 82 + text=True, 83 + ) 75 84 76 85 stderr = "" 77 86 while True: ··· 82 91 print(line.strip()) 83 92 84 93 process.wait() 85 - temp.close() 94 + Path(temp_name).unlink() # Clean up the temporary file 86 95 return stderr 87 96 88 97 89 98 def get_engine_hashes(engine_version, flutter_version): 90 - code = load_code("get-engine-hashes.nix", 91 - nixpkgs_root=NIXPKGS_ROOT, 92 - flutter_version=flutter_version, 93 - engine_version=engine_version) 99 + code = load_code( 100 + "get-engine-hashes.nix", 101 + nixpkgs_root=NIXPKGS_ROOT, 102 + flutter_version=flutter_version, 103 + engine_version=engine_version, 104 + ) 94 105 95 106 stderr = nix_build_to_fail(code) 96 107 97 108 pattern = re.compile( 98 - rf"/nix/store/.*-flutter-engine-source-{engine_version}-(.+?-.+?)-(.+?-.+?).drv':\n\s+specified: .*\n\s+got:\s+(.+?)\n") 109 + rf"/nix/store/.*-flutter-engine-source-{engine_version}-(.+?-.+?)-(.+?-.+?).drv':\n\s+specified: .*\n\s+got:\s+(.+?)\n" 110 + ) 99 111 matches = pattern.findall(stderr) 100 112 result_dict = {} 101 113 ··· 105 117 106 118 def sort_dict_recursive(d): 107 119 return { 108 - k: sort_dict_recursive(v) if isinstance( 109 - v, dict) else v for k, v in sorted( 110 - d.items())} 111 - result_dict = sort_dict_recursive(result_dict) 120 + k: sort_dict_recursive(v) if isinstance(v, dict) else v 121 + for k, v in sorted(d.items()) 122 + } 112 123 113 - return result_dict 124 + return sort_dict_recursive(result_dict) 114 125 115 126 116 127 def get_artifact_hashes(flutter_compact_version): 117 - code = load_code("get-artifact-hashes.nix", 118 - nixpkgs_root=NIXPKGS_ROOT, 119 - flutter_compact_version=flutter_compact_version) 128 + code = load_code( 129 + "get-artifact-hashes.nix", 130 + nixpkgs_root=NIXPKGS_ROOT, 131 + flutter_compact_version=flutter_compact_version, 132 + ) 120 133 121 134 stderr = nix_build_to_fail(code) 122 135 123 136 pattern = re.compile( 124 - r"/nix/store/.*-flutter-artifacts-(.+?)-(.+?).drv':\n\s+specified: .*\n\s+got:\s+(.+?)\n") 137 + r"/nix/store/.*-flutter-artifacts-(.+?)-(.+?).drv':\n\s+specified: .*\n\s+got:\s+(.+?)\n" 138 + ) 125 139 matches = pattern.findall(stderr) 126 140 result_dict = {} 127 141 ··· 131 145 132 146 def sort_dict_recursive(d): 133 147 return { 134 - k: sort_dict_recursive(v) if isinstance( 135 - v, dict) else v for k, v in sorted( 136 - d.items())} 137 - result_dict = sort_dict_recursive(result_dict) 148 + k: sort_dict_recursive(v) if isinstance(v, dict) else v 149 + for k, v in sorted(d.items()) 150 + } 138 151 139 - return result_dict 152 + return sort_dict_recursive(result_dict) 140 153 141 154 142 155 def get_dart_hashes(dart_version, channel): 143 - platforms = [ 144 - "x86_64-linux", 145 - "aarch64-linux", 146 - "x86_64-darwin", 147 - "aarch64-darwin"] 156 + platforms = ["x86_64-linux", "aarch64-linux", "x86_64-darwin", "aarch64-darwin"] 148 157 result_dict = {} 149 158 for platform in platforms: 150 159 code = load_code( 151 160 "get-dart-hashes.nix", 152 161 dart_version=dart_version, 153 162 channel=channel, 154 - platform=platform) 163 + platform=platform, 164 + ) 155 165 stderr = nix_build_to_fail(code) 156 166 157 167 pattern = re.compile(r"got:\s+(.+?)\n") ··· 161 171 162 172 163 173 def get_flutter_hash_and_src(flutter_version): 164 - code = load_code( 165 - "get-flutter.nix", 166 - flutter_version=flutter_version, 167 - hash="") 174 + code = load_code("get-flutter.nix", flutter_version=flutter_version, hash="") 168 175 169 176 stderr = nix_build_to_fail(code) 170 177 pattern = re.compile(r"got:\s+(.+?)\n") 171 - hash = pattern.findall(stderr)[0] 178 + flutter_hash_value = pattern.findall(stderr)[0] 172 179 173 180 code = load_code( 174 - "get-flutter.nix", 175 - flutter_version=flutter_version, 176 - hash=hash) 181 + "get-flutter.nix", flutter_version=flutter_version, hash=flutter_hash_value 182 + ) 177 183 178 - return (hash, nix_build(code)) 184 + return (flutter_hash_value, nix_build(code)) 179 185 180 186 181 187 def get_pubspec_lock(flutter_compact_version, flutter_src): ··· 183 189 "get-pubspec-lock.nix", 184 190 flutter_compact_version=flutter_compact_version, 185 191 flutter_src=flutter_src, 186 - hash="") 192 + hash="", 193 + ) 187 194 188 195 stderr = nix_build_to_fail(code) 189 196 pattern = re.compile(r"got:\s+(.+?)\n") 190 - hash = pattern.findall(stderr)[0] 197 + pubspec_lock_hash = pattern.findall(stderr)[0] 191 198 192 199 code = load_code( 193 200 "get-pubspec-lock.nix", 194 201 flutter_compact_version=flutter_compact_version, 195 202 flutter_src=flutter_src, 196 - hash=hash) 203 + hash=pubspec_lock_hash, 204 + ) 197 205 198 206 pubspec_lock_file = nix_build(code) 199 207 200 - with open(pubspec_lock_file, 'r') as f: 208 + with Path(pubspec_lock_file).open("r", encoding="utf-8") as f: 201 209 pubspec_lock_yaml = f.read() 202 210 203 211 return yaml.safe_load(pubspec_lock_yaml) 204 212 213 + 205 214 def get_engine_swiftshader_rev(engine_version): 206 - with urllib.request.urlopen(f"https://github.com/flutter/flutter/raw/{engine_version}/DEPS") as f: 207 - deps = f.read().decode('utf-8') 208 - pattern = re.compile(r"Var\('swiftshader_git'\) \+ '\/SwiftShader\.git' \+ '@' \+ \'([0-9a-fA-F]{40})\'\,") 209 - rev = pattern.findall(deps)[0] 210 - return rev 215 + with urllib.request.urlopen( 216 + f"https://github.com/flutter/flutter/raw/{engine_version}/DEPS" 217 + ) as f: 218 + deps = f.read().decode("utf-8") 219 + pattern = re.compile( 220 + r"Var\('swiftshader_git'\) \+ '\/SwiftShader\.git' \+ '@' \+ \'([0-9a-fA-F]{40})\'\," 221 + ) 222 + return pattern.findall(deps)[0] 223 + 211 224 212 225 def get_engine_swiftshader_hash(engine_swiftshader_rev): 213 226 code = load_code( 214 227 "get-engine-swiftshader.nix", 215 228 engine_swiftshader_rev=engine_swiftshader_rev, 216 - hash="") 229 + hash="", 230 + ) 217 231 218 232 stderr = nix_build_to_fail(code) 219 233 pattern = re.compile(r"got:\s+(.+?)\n") 220 234 return pattern.findall(stderr)[0] 221 235 236 + 222 237 def write_data( 223 - nixpkgs_flutter_version_directory, 224 - flutter_version, 225 - channel, 226 - engine_hash, 227 - engine_hashes, 228 - engine_swiftshader_hash, 229 - engine_swiftshader_rev, 230 - dart_version, 231 - dart_hash, 232 - flutter_hash, 233 - artifact_hashes, 234 - pubspec_lock): 235 - with open(f"{nixpkgs_flutter_version_directory}/data.json", "w") as f: 236 - f.write(json.dumps({ 237 - "version": flutter_version, 238 - "engineVersion": engine_hash, 239 - "engineSwiftShaderHash": engine_swiftshader_hash, 240 - "engineSwiftShaderRev": engine_swiftshader_rev, 241 - "channel": channel, 242 - "engineHashes": engine_hashes, 243 - "dartVersion": dart_version, 244 - "dartHash": dart_hash, 245 - "flutterHash": flutter_hash, 246 - "artifactHashes": artifact_hashes, 247 - "pubspecLock": pubspec_lock, 248 - }, indent=2).strip() + "\n") 238 + nixpkgs_flutter_version_directory, 239 + flutter_version, 240 + channel, 241 + engine_hash, 242 + engine_hashes, 243 + engine_swiftshader_hash, 244 + engine_swiftshader_rev, 245 + dart_version, 246 + dart_hash, 247 + flutter_hash, 248 + artifact_hashes, 249 + pubspec_lock, 250 + ): 251 + with Path(f"{nixpkgs_flutter_version_directory}/data.json").open( 252 + "w", encoding="utf-8" 253 + ) as f: 254 + f.write( 255 + json.dumps( 256 + { 257 + "version": flutter_version, 258 + "engineVersion": engine_hash, 259 + "engineSwiftShaderHash": engine_swiftshader_hash, 260 + "engineSwiftShaderRev": engine_swiftshader_rev, 261 + "channel": channel, 262 + "engineHashes": engine_hashes, 263 + "dartVersion": dart_version, 264 + "dartHash": dart_hash, 265 + "flutterHash": flutter_hash, 266 + "artifactHashes": artifact_hashes, 267 + "pubspecLock": pubspec_lock, 268 + }, 269 + indent=2, 270 + ).strip() 271 + + "\n" 272 + ) 249 273 250 274 251 275 def update_all_packages(): 252 276 versions_directory = f"{NIXPKGS_ROOT}/pkgs/development/compilers/flutter/versions" 253 - versions = [directory for directory in os.listdir(versions_directory)] 254 - versions = sorted(versions, key=lambda x: ( 255 - int(x.split('_')[0]), int(x.split('_')[1])), reverse=True) 277 + versions = [d.name for d in Path(versions_directory).iterdir()] 278 + versions = sorted( 279 + versions, 280 + key=lambda x: (int(x.split("_")[0]), int(x.split("_")[1])), 281 + reverse=True, 282 + ) 256 283 257 284 new_content = [ 258 285 "flutterPackages-bin = recurseIntoAttrs (callPackage ../development/compilers/flutter { });", 259 286 "flutterPackages-source = recurseIntoAttrs (callPackage ../development/compilers/flutter { useNixpkgsEngine = true; });", 260 287 "flutterPackages = flutterPackages-bin;", 261 288 "flutter = flutterPackages.stable;", 262 - ] + [f"flutter{version.replace('_', '')} = flutterPackages.v{version};" for version in versions] 289 + ] + [ 290 + f"flutter{version.replace('_', '')} = flutterPackages.v{version};" 291 + for version in versions 292 + ] 263 293 264 - with open(f"{NIXPKGS_ROOT}/pkgs/top-level/all-packages.nix", 'r') as file: 294 + with Path(f"{NIXPKGS_ROOT}/pkgs/top-level/all-packages.nix").open( 295 + "r", encoding="utf-8" 296 + ) as file: 265 297 lines = file.read().splitlines(keepends=True) 266 298 267 299 start = -1 268 300 end = -1 269 301 for i, line in enumerate(lines): 270 - if "flutterPackages-bin = recurseIntoAttrs (callPackage ../development/compilers/flutter { });" in line: 302 + if ( 303 + "flutterPackages-bin = recurseIntoAttrs (callPackage ../development/compilers/flutter { });" 304 + in line 305 + ): 271 306 start = i 272 307 if start != -1 and len(line.strip()) == 0: 273 308 end = i ··· 275 310 276 311 if start != -1 and end != -1: 277 312 del lines[start:end] 278 - lines[start:start] = [f" {l}\n" for l in new_content] 313 + lines[start:start] = [f" {line}\n" for line in new_content] 279 314 280 - with open(f"{NIXPKGS_ROOT}/pkgs/top-level/all-packages.nix", 'w') as file: 315 + with Path(f"{NIXPKGS_ROOT}/pkgs/top-level/all-packages.nix").open( 316 + "w", encoding="utf-8" 317 + ) as file: 281 318 file.write("".join(lines)) 282 319 283 320 ··· 288 325 engine_hash = None 289 326 dart_version = None 290 327 291 - releases = json.load(urllib.request.urlopen( 292 - "https://storage.googleapis.com/flutter_infra_release/releases/releases_linux.json")) 328 + releases = json.load( 329 + urllib.request.urlopen( 330 + "https://storage.googleapis.com/flutter_infra_release/releases/releases_linux.json" 331 + ) 332 + ) 293 333 294 334 if not channel: 295 - channel = 'stable' 335 + channel = "stable" 296 336 297 337 if not flutter_version: 298 - hash = releases['current_release'][channel] 338 + release_hash = releases["current_release"][channel] 299 339 release = next( 300 340 filter( 301 - lambda release: release['hash'] == hash, 302 - releases['releases'])) 303 - flutter_version = release['version'] 341 + lambda release: release["hash"] == release_hash, releases["releases"] 342 + ) 343 + ) 344 + flutter_version = release["version"] 304 345 305 - tags = subprocess.Popen(['git', 306 - 'ls-remote', 307 - '--tags', 308 - 'https://github.com/flutter/flutter.git'], 309 - stdout=subprocess.PIPE, 310 - text=True).communicate()[0].strip() 346 + tags = ( 347 + subprocess.Popen( 348 + ["git", "ls-remote", "--tags", "https://github.com/flutter/flutter.git"], 349 + stdout=subprocess.PIPE, 350 + text=True, 351 + ) 352 + .communicate()[0] 353 + .strip() 354 + ) 311 355 312 356 try: 313 - flutter_hash = next( 314 - filter( 315 - lambda line: line.endswith(f'refs/tags/{flutter_version}'), 316 - tags.splitlines())).split('refs')[0].strip() 357 + flutter_hash = ( 358 + next( 359 + filter( 360 + lambda line: line.endswith(f"refs/tags/{flutter_version}"), 361 + tags.splitlines(), 362 + ) 363 + ) 364 + .split("refs")[0] 365 + .strip() 366 + ) 317 367 318 - engine_hash = urllib.request.urlopen(f'https://github.com/flutter/flutter/raw/{flutter_hash}/bin/internal/engine.version').read().decode('utf-8').strip() 368 + engine_hash = ( 369 + urllib.request.urlopen( 370 + f"https://github.com/flutter/flutter/raw/{flutter_hash}/bin/internal/engine.version" 371 + ) 372 + .read() 373 + .decode("utf-8") 374 + .strip() 375 + ) 319 376 except StopIteration: 320 - exit( 321 - f"Couldn't find Engine hash for Flutter version: {flutter_version}") 377 + sys.exit(f"Couldn't find Engine hash for Flutter version: {flutter_version}") 322 378 323 379 try: 324 380 dart_version = next( 325 381 filter( 326 - lambda release: release['version'] == flutter_version, 327 - releases['releases']))['dart_sdk_version'] 382 + lambda release: release["version"] == flutter_version, 383 + releases["releases"], 384 + ) 385 + )["dart_sdk_version"] 328 386 329 387 if " " in dart_version: 330 - dart_version = dart_version.split(' ')[2][:-1] 388 + dart_version = dart_version.split(" ")[2][:-1] 331 389 except StopIteration: 332 - exit( 333 - f"Couldn't find Dart version for Flutter version: {flutter_version}") 390 + sys.exit(f"Couldn't find Dart version for Flutter version: {flutter_version}") 334 391 335 392 return (flutter_version, engine_hash, dart_version, channel) 336 393 337 394 338 395 def main(): 339 - parser = argparse.ArgumentParser(description='Update Flutter in Nixpkgs') 340 - parser.add_argument('--version', type=str, help='Specify Flutter version') 341 - parser.add_argument('--channel', type=str, help='Specify Flutter release channel') 342 - parser.add_argument('--artifact-hashes', action='store_true', 343 - help='Whether to get artifact hashes') 396 + parser = argparse.ArgumentParser(description="Update Flutter in Nixpkgs") 397 + parser.add_argument("--version", type=str, help="Specify Flutter version") 398 + parser.add_argument("--channel", type=str, help="Specify Flutter release channel") 399 + parser.add_argument( 400 + "--artifact-hashes", action="store_true", help="Whether to get artifact hashes" 401 + ) 344 402 args = parser.parse_args() 345 403 346 - (flutter_version, engine_hash, dart_version, channel) = find_versions(args.version, args.channel) 404 + (flutter_version, engine_hash, dart_version, channel) = find_versions( 405 + args.version, args.channel 406 + ) 347 407 348 - flutter_compact_version = '_'.join(flutter_version.split('.')[:2]) 408 + flutter_compact_version = "_".join(flutter_version.split(".")[:2]) 349 409 350 410 if args.artifact_hashes: 351 411 print( 352 - json.dumps( 353 - get_artifact_hashes(flutter_compact_version), 354 - indent=2).strip() + 355 - "\n") 412 + json.dumps(get_artifact_hashes(flutter_compact_version), indent=2).strip() 413 + + "\n" 414 + ) 356 415 return 357 416 358 - print(f"Flutter version: {flutter_version} ({flutter_compact_version}) on ({channel})") 417 + print( 418 + f"Flutter version: {flutter_version} ({flutter_compact_version}) on ({channel})" 419 + ) 359 420 print(f"Engine hash: {engine_hash}") 360 421 print(f"Dart version: {dart_version}") 361 422 ··· 364 425 365 426 nixpkgs_flutter_version_directory = f"{NIXPKGS_ROOT}/pkgs/development/compilers/flutter/versions/{flutter_compact_version}" 366 427 367 - if os.path.exists(f"{nixpkgs_flutter_version_directory}/data.json"): 368 - os.remove(f"{nixpkgs_flutter_version_directory}/data.json") 369 - os.makedirs(nixpkgs_flutter_version_directory, exist_ok=True) 428 + if Path(f"{nixpkgs_flutter_version_directory}/data.json").exists(): 429 + Path(f"{nixpkgs_flutter_version_directory}/data.json").unlink() 430 + Path(nixpkgs_flutter_version_directory).mkdir(parents=True, exist_ok=True) 370 431 371 432 update_all_packages() 372 433 ··· 385 446 artifact_hashes={}, 386 447 engine_hashes={}, 387 448 engine_swiftshader_hash=FAKE_HASH, 388 - engine_swiftshader_rev='0', 389 - **common_data_args) 449 + engine_swiftshader_rev="0", 450 + **common_data_args, 451 + ) 390 452 391 453 pubspec_lock = get_pubspec_lock(flutter_compact_version, flutter_src) 392 454 ··· 395 457 artifact_hashes={}, 396 458 engine_hashes={}, 397 459 engine_swiftshader_hash=FAKE_HASH, 398 - engine_swiftshader_rev='0', 399 - **common_data_args) 460 + engine_swiftshader_rev="0", 461 + **common_data_args, 462 + ) 400 463 401 464 artifact_hashes = get_artifact_hashes(flutter_compact_version) 402 465 ··· 405 468 artifact_hashes=artifact_hashes, 406 469 engine_hashes={}, 407 470 engine_swiftshader_hash=FAKE_HASH, 408 - engine_swiftshader_rev='0', 409 - **common_data_args) 471 + engine_swiftshader_rev="0", 472 + **common_data_args, 473 + ) 410 474 411 475 engine_hashes = get_engine_hashes(engine_hash, flutter_version) 412 476 ··· 415 479 artifact_hashes=artifact_hashes, 416 480 engine_hashes=engine_hashes, 417 481 engine_swiftshader_hash=FAKE_HASH, 418 - engine_swiftshader_rev='0', 419 - **common_data_args) 482 + engine_swiftshader_rev="0", 483 + **common_data_args, 484 + ) 420 485 421 486 engine_swiftshader_rev = get_engine_swiftshader_rev(engine_hash) 422 487 engine_swiftshader_hash = get_engine_swiftshader_hash(engine_swiftshader_rev) ··· 427 492 engine_hashes=engine_hashes, 428 493 engine_swiftshader_hash=engine_swiftshader_hash, 429 494 engine_swiftshader_rev=engine_swiftshader_rev, 430 - **common_data_args) 495 + **common_data_args, 496 + ) 431 497 432 498 433 499 if __name__ == "__main__":