Merge staging-next into staging

nixos/modules/services/monitoring/grafana-image-renderer.nix

···
     systemd.services.grafana-image-renderer = {
       wantedBy = [ "multi-user.target" ];
       after = [ "network.target" ];
-      description = " A Grafana backend plugin that handles rendering of panels & dashboards to PNGs using headless browser (Chromium/Chrome)";
+      description = "Grafana backend plugin that handles rendering of panels & dashboards to PNGs using headless browser (Chromium/Chrome)";
 
       environment = {
         PUPPETEER_SKIP_CHROMIUM_DOWNLOAD = "true";

nixos/modules/services/networking/flannel.nix

···
     };
 
     network = lib.mkOption {
-      description = " IPv4 network in CIDR format to use for the entire flannel network.";
+      description = "IPv4 network in CIDR format to use for the entire flannel network";
       type = lib.types.str;
     };
 

nixos/modules/services/networking/quicktun.nix

···
                 type = types.port;
                 default = qtcfg.localPort;
                 defaultText = lib.literalExpression "config.services.quicktun.<name>.localPort";
-                description = " remote UDP port";
+                description = "Remote UDP port";
               };
 
               remoteFloat = mkOption {

nixos/modules/services/web-apps/nextcloud.nix

···
   ]);
 
   meta.doc = ./nextcloud.md;
-  meta.maintainers = teams.nextcloud;
+  meta.maintainers = teams.nextcloud.members;
 }

pkgs/applications/editors/vscode/extensions/default.nix

···
           hash = "sha256-vVbaHSaBX6QzpnYMQlpPsJU1TQYJEBe8jq95muzwN0o=";
         };
         meta = {
-          description = " A solarized-palenight theme for vscode";
+          description = "Solarized-palenight theme for vscode";
           downloadPage = "https://marketplace.visualstudio.com/items?itemName=BrandonKirbyson.solarized-palenight";
           homepage = "https://github.com/BrandonKirbyson/Solarized-Palenight";
           license = lib.licenses.mit;

pkgs/applications/networking/browsers/chromium/info.json

···
 {
   "chromium": {
-    "version": "138.0.7204.157",
+    "version": "138.0.7204.168",
     "chromedriver": {
-      "version": "138.0.7204.158",
-      "hash_darwin": "sha256-rNd7glDAVNkd4CNn4k3rdpb//yD/ccpebnGhDv1EGb8=",
-      "hash_darwin_aarch64": "sha256-oUMFW09mp2aUgplboMHaKvTVbKtqAy5C0KsA7DXbElc="
+      "version": "138.0.7204.169",
+      "hash_darwin": "sha256-I87LWl+F8nmxpIUXUT+InLFf2nZ1Sh1nAtYVLCq9r5M=",
+      "hash_darwin_aarch64": "sha256-6DoMi5gy68tuauNGvFl0QKPZnh5lY9S73+S+FNltDow="
     },
     "deps": {
       "depot_tools": {
···
     "DEPS": {
       "src": {
         "url": "https://chromium.googlesource.com/chromium/src.git",
-        "rev": "e533e98b1267baa1f1c46d666b120e64e5146aa9",
-        "hash": "sha256-LbZ8/6Lvz1p3ydRL4fXtd7RL426PU3jU01Hx+DP5QYQ=",
+        "rev": "3e8d82e86e9f508e88ed406c2a24657a6c691d30",
+        "hash": "sha256-6s9mkfckhibpb+L74oPZsgvOZZT58BeSo362t/s92UI=",
         "recompress": true
       },
       "src/third_party/clang-format/script": {
···
       },
       "src/third_party/devtools-frontend/src": {
         "url": "https://chromium.googlesource.com/devtools/devtools-frontend",
-        "rev": "4cca0aa00c4915947f1081014d5cfa2e83d357fa",
-        "hash": "sha256-pVNr8NB5U/Uf688oOvPLpu81isCn/WmjJky01A000a4="
+        "rev": "a718e86b3dc6f1ba3c8cc8092cd79b401d428cfc",
+        "hash": "sha256-50KQk54JwwRS3ENUjB0QedQYFuwmkv9oxytfuNDTVPo="
       },
       "src/third_party/dom_distiller_js/dist": {
         "url": "https://chromium.googlesource.com/chromium/dom-distiller/dist.git",
···
       },
       "src/v8": {
         "url": "https://chromium.googlesource.com/v8/v8.git",
-        "rev": "de9d0f8b56ae61896e4d2ac577fc589efb14f87d",
-        "hash": "sha256-/T5fisjmN80bs3PtQrCRfH3Bo9dRSd3f+xpPLDh1RTY="
+        "rev": "f5036f509b5e147cccb298a069c40827f3d5edd6",
+        "hash": "sha256-n4/Lf5ZawqUY0QHF2jYl3JPPx9Br/wzVmtqnMvq3Vzk="
       }
     }
   },

pkgs/applications/networking/instant-messengers/ferdium/default.nix

···
     ."${stdenv.hostPlatform.system}" or (throw "Unsupported system: ${stdenv.hostPlatform.system}");
   hash =
     {
-      amd64-linux_hash = "sha256-e5O8cvQqvymHQiu7kY1AhKfoVOsDLYK8hDX+PKgZPFs=";
-      arm64-linux_hash = "sha256-UskXFGxAFOrAK8bIXRHSwN0G1lakGyuRGXTYYRFKHaw=";
+      amd64-linux_hash = "sha256-84W40++U+5/kTI84vGEqAVb93TCgFPduBkhMQG0yDRo=";
+      arm64-linux_hash = "sha256-lOQW559aXXBIDuindVj8YBB8pzNAJPoTSJ70y1YnZQ4=";
     }
     ."${arch}-linux_hash";
 in
 mkFranzDerivation rec {
   pname = "ferdium";
   name = "Ferdium";
-  version = "7.0.1";
+  version = "7.1.0";
   src = fetchurl {
     url = "https://github.com/ferdium/ferdium-app/releases/download/v${version}/Ferdium-linux-${version}-${arch}.deb";
     inherit hash;

pkgs/by-name/ca/cargonode/package.nix

···
-{
-  lib,
-  rustPlatform,
-  fetchFromGitHub,
-  pkg-config,
-}:
-
-rustPlatform.buildRustPackage rec {
-  pname = "cargonode";
-  version = "0.1.3";
-
-  src = fetchFromGitHub {
-    owner = "xosnrdev";
-    repo = "cargonode";
-    tag = version;
-    hash = "sha256-O5+wAM99m1rgQpwz36mkHEU/FvGnY6hBCKPMIGXCeCU=";
-  };
-
-  useFetchCargoVendor = true;
-  cargoHash = "sha256-dYOdnyKdzL93kuSTUb+1vRqfDgkZLymaEZo9FUrR1JI=";
-
-  checkFlags = [
-    # Skip test that requires network access
-    "--skip test_download_file"
-    "--skip test_extract_zip"
-    "--skip test_invalid_download_url"
-    "--skip test_create_package"
-    "--skip test_init_package"
-  ];
-
-  nativeBuildInputs = [
-    pkg-config
-  ];
-
-  meta = {
-    description = "Unified tooling for Node.js";
-    mainProgram = "cargonode";
-    homepage = "https://github.com/xosnrdev/cargonode?tab=readme-ov-file#readme";
-    changelog = "https://github.com/xosnrdev/cargonode/blob/${version}/CHANGELOG.md";
-    license = with lib.licenses; [
-      asl20 # or
-      mit
-    ];
-    maintainers = with lib.maintainers; [ xosnrdev ];
-  };
-}

pkgs/by-name/ca/caroline/package.nix

···
   ];
 
   meta = with lib; {
-    description = " A simple Cairo Chart Library for GTK and Vala";
+    description = "Simple Cairo Chart Library for GTK and Vala";
     homepage = "https://github.com/dcharles525/Caroline";
     maintainers = with maintainers; [ grindhold ];
     license = licenses.mit;

pkgs/by-name/cb/cbftp/package.nix

···
 
   meta = with lib; {
     homepage = "https://cbftp.eu/";
-    description = " An advanced multi-purpose FTP/FXP client";
+    description = "Advanced multi-purpose FTP/FXP client";
     longDescription = ''
       Cbftp is an advanced multi-purpose FTP/FXP client that focuses on
       efficient large-scale data spreading, while also supporting most regular

pkgs/by-name/cl/clash-verge-rev/package.nix

···
 }:
 let
   pname = "clash-verge-rev";
-  version = "2.3.1";
+  version = "2.3.2";
 
   src = fetchFromGitHub {
     owner = "clash-verge-rev";
     repo = "clash-verge-rev";
     tag = "v${version}";
-    hash = "sha256-NNP/NDC/Y4oBQftM6Z+pOFMEtdtvcIMYyY3sGwkpmrc=";
+    hash = "sha256-Wdd1iZspVcCxifCYvST4vlatQJXnyeZkm3Ifc8Q2xtM=";
   };
 
   src-service = fetchFromGitHub {
···
   };
 
   service-cargo-hash = "sha256-HET7/Lyc0Ip1f9WMVzUWr0QFuL8YN3dgZdK0adl/rYc=";
-  pnpm-hash = "sha256-bhWaDP0gHJC6Mx9QFl4Ltk7y5jozt0eLtsPOWg821Yw=";
-  vendor-hash = "sha256-UkiPJNr5leKuffrrh8n2uhCe/QVjIb4S9heZXP7oKqw=";
+  pnpm-hash = "sha256-yizUju+AswVkbfPMxNhHkrkKsFIe7yedEUqS15uy+V0=";
+  vendor-hash = "sha256-u2y0fSx15Kbe3auL7c4enW0y6z4gjvTg4WIGkmXpMmI=";
 
   service = callPackage ./service.nix {
     inherit

pkgs/by-name/ea/each/package.nix

···
   cargoHash = "sha256-TfAT36/JeBjBxymnX1gIyCEPZcxTW4fPVIOhHF3z9wA=";
 
   meta = with lib; {
-    description = " A better way of working with structured data on the command line";
+    description = "A better way of working with structured data on the command line";
     mainProgram = "each";
     homepage = "https://github.com/arraypad/each";
     license = with licenses; [ mit ];

pkgs/by-name/fi/firefly-iii-data-importer/package.nix

···
 
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "firefly-iii-data-importer";
-  version = "1.7.6";
+  version = "1.7.8";
 
   src = fetchFromGitHub {
     owner = "firefly-iii";
     repo = "data-importer";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-2QjflXnusdqg63S1RgSbDsYHk9U4Xjf59wkvvo9n+Zo=";
+    hash = "sha256-ZsrzB9jO9huMb7N6J+LPAKOGisIjuXaXAGhyewWC+cA=";
   };
 
   buildInputs = [ php84 ];
···
   composerStrictValidation = true;
   strictDeps = true;
 
-  vendorHash = "sha256-j0KjjmaDyFBFWnz6e4Bkrb3gkitfSKsj9UB2j/G19do=";
+  vendorHash = "sha256-mgliWS/PrGGGc0we8/TH/7xitbXtZFCrFBF+ElNYXBA=";
 
   npmDeps = fetchNpmDeps {
     inherit (finalAttrs) src;
     name = "${finalAttrs.pname}-npm-deps";
-    hash = "sha256-4bDSEGg5vGoam1PLRfaxJK0aQ+MLBTF+GP0AZQjHvVw=";
+    hash = "sha256-28Y8fM88Z83VVZMm3ZanP9CskUWCE3043lgoP7WhW/I=";
   };
 
   composerRepository = php84.mkComposerRepository {

pkgs/by-name/ga/galerio/package.nix

···
   cargoHash = "sha256-jXUAjK/fqBaXaehcbFZU02w9/MTHluqKjtWGoAJa7ks=";
 
   meta = with lib; {
-    description = " A simple generator for self-contained HTML flexbox galleries";
+    description = "Simple generator for self-contained HTML flexbox galleries";
     homepage = "https://github.com/dbrgn/galerio";
     maintainers = with maintainers; [ dbrgn ];
     license = with licenses; [

pkgs/by-name/gi/gitlab-ci-ls/package.nix

···
     owner = "alesbrelih";
     repo = "gitlab-ci-ls";
     rev = "${version}";
-    hash = "sha256-yJA6xdeLJVPbHI2VdRAmsYvuULCJk40ntIJ0JIWsZds=";
+    hash = "sha256-0AVi/DyaWh+dCXm/jUf3M63KjobJWCCKHDvm1xGUzCw=";
   };
 
   useFetchCargoVendor = true;

pkgs/by-name/gi/gitlab-timelogs/package.nix

···
   cargoHash = "sha256-qSIRcf0HpRg1Eu12L6UcJajHBgjJgfhsHmF1oV1h8HM=";
 
   meta = {
-    description = " CLI utility to support you with your time logs in GitLab";
+    description = "CLI utility to support you with your time logs in GitLab";
     mainProgram = "gitlab-timelogs";
     longDescription = ''
       CLI utility to support you with your time logs in GitLab.

pkgs/by-name/go/go-i18n/package.nix

···
+{
+  lib,
+  buildGoModule,
+  fetchFromGitHub,
+}:
+buildGoModule (finalAttrs: {
+  pname = "go-i18n";
+  version = "2.6.0";
+
+  src = fetchFromGitHub {
+    owner = "nicksnyder";
+    repo = "go-i18n";
+    tag = "v${finalAttrs.version}";
+    hash = "sha256-UrSECFbpCIg5avJ+f3LkJy/ncZFHa4q8sDqDIQ3YZJM=";
+  };
+
+  vendorHash = "sha256-4Kbdj2D6eJTjZtdsFMNES3AEZ0PEi01HS73uFNZsFMA=";
+
+  subPackages = [
+    "goi18n"
+  ];
+
+  env.CGO_ENABLED = 0;
+
+  doCheck = true;
+
+  meta = {
+    changelog = "https://github.com/nicksnyder/go-i18n/releases/tag/${finalAttrs.src.tag}";
+    description = "Translate your Go program into multiple languages";
+    longDescription = ''
+      goi18n is a tool that lets you extract messages from all your Go source files,
+      generates new language files.
+    '';
+    homepage = "https://github.com/nicksnyder/go-i18n";
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ videl ];
+    mainProgram = "goi18n";
+  };
+})

pkgs/by-name/go/go-protobuf/package.nix

···
 
   meta = with lib; {
     homepage = "https://github.com/golang/protobuf";
-    description = " Go bindings for protocol buffer";
+    description = "Go bindings for protocol buffer";
     maintainers = with maintainers; [ lewo ];
     license = licenses.bsd3;
   };

pkgs/by-name/go/google-chrome/package.nix

···
 
   linux = stdenvNoCC.mkDerivation (finalAttrs: {
     inherit pname meta passthru;
-    version = "138.0.7204.157";
+    version = "138.0.7204.168";
 
     src = fetchurl {
       url = "https://dl.google.com/linux/chrome/deb/pool/main/g/google-chrome-stable/google-chrome-stable_${finalAttrs.version}-1_amd64.deb";
-      hash = "sha256-QmWevU4cYmUc6lUbFG4bQ1aKFuUyIUorJjMMF14bzZ4=";
+      hash = "sha256-vfMEQOh9VZsLElld8qfeLY9B53z1AqyRTQ/7p2cxHYg=";
     };
 
     # With strictDeps on, some shebangs were not being patched correctly
···
 
   darwin = stdenvNoCC.mkDerivation (finalAttrs: {
     inherit pname meta passthru;
-    version = "138.0.7204.158";
+    version = "138.0.7204.169";
 
     src = fetchurl {
-      url = "http://dl.google.com/release2/chrome/adskeulizkrq3h2yvus65pybna6a_138.0.7204.158/GoogleChrome-138.0.7204.158.dmg";
-      hash = "sha256-D7Iik+R9PIfvL1QEASfip5M2pE+nco90dKet4Fehq/8=";
+      url = "http://dl.google.com/release2/chrome/acwjggvog6ot2icovazewas35mgq_138.0.7204.169/GoogleChrome-138.0.7204.169.dmg";
+      hash = "sha256-58/hSldBZ3gtzjY0GCt6GkxUX97GORwTh5uEfEjxM3A=";
     };
 
     dontPatch = true;

pkgs/by-name/gt/gtg/package.nix

···
   checkPhase = "xvfb-run pytest ../tests/";
 
   meta = with lib; {
-    description = " A personal tasks and TODO-list items organizer";
+    description = "Personal tasks and TODO-list items organizer";
     mainProgram = "gtg";
     longDescription = ''
       "Getting Things GNOME" (GTG) is a personal tasks and ToDo list organizer inspired by the "Getting Things Done" (GTD) methodology.

pkgs/by-name/jw/jwx/package.nix

···
   sourceRoot = "${finalAttrs.src.name}/cmd/jwx";
 
   meta = {
-    description = " Implementation of various JWx (Javascript Object Signing and Encryption/JOSE) technologies";
+    description = "Implementation of various JWx (Javascript Object Signing and Encryption/JOSE) technologies";
     mainProgram = "jwx";
     homepage = "https://github.com/lestrrat-go/jwx";
     changelog = "https://github.com/lestrrat-go/jwx/blob/v${finalAttrs.version}/Changes";

pkgs/by-name/kn/knewave/package.nix

···
   '';
 
   meta = {
-    description = " A bold, painted face for the rocker within";
+    description = "Bold, painted face for the rocker within";
     longDescription = ''
       Knewave is bold, painted face. Get it? Git it.
     '';

pkgs/by-name/le/lessc/plugins/clean-css/default.nix

···
 
   meta = {
     homepage = "https://github.com/less/less-plugin-clean-css";
-    description = " Post-process and compress CSS using clean-css";
+    description = "Post-process and compress CSS using clean-css";
     license = lib.licenses.asl20;
     maintainers = with lib.maintainers; [ lelgenio ];
   };

pkgs/by-name/li/libmsym/package.nix

···
   nativeBuildInputs = [ cmake ];
 
   meta = with lib; {
-    description = " molecular point group symmetry lib";
+    description = "Molecular point group symmetry lib";
     homepage = "https://github.com/mcodev31/libmsym";
     license = licenses.mit;
     platforms = platforms.linux;

pkgs/by-name/lv/lv_font_conv/package.nix

···
   meta = {
     description = "Converts TTF/WOFF fonts to compact bitmap format";
     mainProgram = "lv_font_conv";
-    homepage = " https://lvgl.io/tools/fontconverter";
+    homepage = "https://lvgl.io/tools/fontconverter";
     license = lib.licenses.mit;
     maintainers = with lib.maintainers; [ pyrox0 ];
   };

pkgs/by-name/mb/mbake/package.nix

···
 {
+  stdenv,
   lib,
   fetchFromGitHub,
+  installShellFiles,
   python3Packages,
   versionCheckHook,
 }:
 
 python3Packages.buildPythonApplication rec {
   pname = "mbake";
-  version = "1.2.4";
+  version = "1.3.1";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "EbodShojaei";
     repo = "bake";
     tag = "v${version}";
-    hash = "sha256-RzM3HC3lYq93mngpqNCohcPMISWQ4+Lwa1V88S0O0To=";
+    hash = "sha256-gQsie4/iUIe4g6ZH8bL33xW6CNxSg/sh429P4Xv0GjQ=";
   };
 
   build-system = [
+    installShellFiles
     python3Packages.hatchling
   ];
 
···
     typer
   ];
 
+  postInstall = lib.optionalString (stdenv.buildPlatform.canExecute stdenv.hostPlatform) ''
+    installShellCompletion --cmd mbake \
+      --bash <($out/bin/mbake completions bash) \
+      --fish <($out/bin/mbake completions fish) \
+      --zsh <($out/bin/mbake completions zsh)
+  '';
+
   nativeCheckInputs = [
     python3Packages.pytestCheckHook
     versionCheckHook
   ];
   versionCheckProgramArg = "--version";
 
-  pythonImportsCheck = [ "bake" ];
+  pythonImportsCheck = [ "mbake" ];
 
   meta = {
     description = "Makefile formatter and linter";

pkgs/by-name/op/openswitcher/package.nix

···
     homepage = "https://openswitcher.org/";
     license = licenses.gpl3Only;
     maintainers = with maintainers; [ hexa ];
+    mainProgram = "switcher-control";
   };
 }

pkgs/by-name/os/oss-rebuild/package.nix

···
+{
+  lib,
+  buildGoModule,
+  fetchFromGitHub,
+}:
+
+buildGoModule (finalAttrs: {
+  pname = "oss-rebuild";
+  version = "0-unstable-2025-07-22";
+
+  src = fetchFromGitHub {
+    owner = "google";
+    repo = "oss-rebuild";
+    rev = "6f57c474a8faf3012204792af8ef5d8b6fae2fd1";
+    hash = "sha256-H8HkhQcRt6C+lxoMVLzRfhv60Mq8TAf83ctOBRbx4p0=";
+  };
+
+  proxyVendor = true;
+  vendorHash = "sha256-H6ZMop3tXwpzvjoLWAaovP8UHSYLLFxvSz2jhz8tj/g=";
+
+  subPackages = [
+    "cmd/oss-rebuild"
+    "cmd/proxy"
+    "cmd/stabilize"
+    "cmd/timewarp"
+    # There are other tools in available, but without documentation.
+  ];
+
+  ldflags = [ "-s" ];
+
+  env.CGO_ENABLED = 0;
+
+  meta = {
+    description = "Securing open-source package ecosystems by originating, validating, and augmenting build attestations";
+    longDescription = ''
+      OSS Rebuild aims to apply reproducible build concepts at low-cost and high-scale for open-source package ecosystems.
+
+      Rebuilds are derived by analyzing the published metadata and artifacts and are evaluated against the upstream package
+      versions. When successful, build attestations are published for the upstream artifacts, verifying the integrity of
+      the upstream artifact and eliminating many possible sources of compromise.
+
+      [`oss-rebuild`](https://github.com/google/oss-rebuild?tab=readme-ov-file#usage) CLI tool provides access to OSS Rebuild
+      data.
+
+      [`proxy`](https://github.com/google/oss-rebuild/blob/main/cmd/proxy/README.md) is a transparent HTTP(S) proxy that
+      intercepts and records network activity. It's primarily used within OSS Rebuild to monitor network interactions during
+      the build process, helping to passively enumerate remote dependencies and to identify suspect build behavior.
+
+      [`stabilize`](https://github.com/google/oss-rebuild/blob/main/cmd/stabilize/README.md) is a command-line tool that
+      removes non-deterministic metadata from software packages to facilitate functional comparison of artifacts.
+
+      [`timewarp`](https://github.com/google/oss-rebuild/blob/main/cmd/timewarp/README.md) is a registry-fronting HTTP
+      service that filters returned content by time. This tool allows you to transparently adjust the data returned to
+      package manager clients to reflect the state of a registry at a given point in time (especially useful for reproducing
+      prior builds).
+    '';
+    homepage = "https://github.com/google/oss-rebuild";
+    license = lib.licenses.asl20;
+    maintainers = with lib.maintainers; [ katexochen ];
+    mainProgram = "oss-rebuild";
+  };
+})

pkgs/by-name/pl/plutovg/package.nix

···
 }:
 stdenv.mkDerivation (finalAttrs: {
   pname = "plutovg";
-  version = "1.2.0";
+  version = "1.3.0";
 
   src = fetchFromGitHub {
     owner = "sammycage";
     repo = "plutovg";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-+LJhQb8uZ7iPNcdhL40LLk/6mR97VCgDtYgnj2R8vno=";
+    hash = "sha256-9h7UvUSJLBRs4jD0/qTs3nzMBZKyyZg2T9eVEIpSYMg=";
   };
 
   cmakeFlags = [

pkgs/by-name/pm/pmix/package.nix

···
   hwloc,
   munge,
   zlib,
-  pandoc,
   gitMinimal,
 }:
 
···
   '';
 
   nativeBuildInputs = [
-    pandoc
     perl
     autoconf
     automake

pkgs/by-name/pr/prometheus-klipper-exporter/package.nix

···
   };
 
   meta = with lib; {
-    description = " Prometheus Exporter for Klipper ";
+    description = "Prometheus Exporter for Klipper";
     homepage = "https://github.com/scross01/prometheus-klipper-exporter";
     license = licenses.mit;
     maintainers = with maintainers; [ wulfsta ];

pkgs/by-name/pu/pulsarctl/package.nix

···
   };
 
   meta = with lib; {
-    description = " a CLI for Apache Pulsar written in Go";
+    description = "CLI for Apache Pulsar written in Go";
     homepage = "https://github.com/streamnative/pulsarctl";
     license = with licenses; [ asl20 ];
     platforms = platforms.unix;

pkgs/by-name/ri/rime-wanxiang/package.nix

···
 
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "rime-wanxiang";
-  version = "8.7.7";
+  version = "9.1.3";
 
   src = fetchFromGitHub {
     owner = "amzxyz";
     repo = "rime_wanxiang";
     tag = "v" + finalAttrs.version;
-    hash = "sha256-X64kxr93V0ilAefmQcJgMCegdzpoNoI0TuMdkYRG66I=";
+    hash = "sha256-jcYvDktk1zj32i92LQKYu35Br2uPRcoNtoyPKo3hP/Y=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/ro/roxterm/package.nix

···
 
   meta = {
     homepage = "https://github.com/realh/roxterm";
-    description = " A highly configurable terminal emulator";
+    description = "Highly configurable terminal emulator";
     longDescription = ''
       ROXTerm is a terminal emulator intended to provide similar features to
       gnome-terminal, based on the same VTE library. It was originally designed

pkgs/by-name/sn/snphost/package.nix

···
   nix-update-script,
   findutils,
   installShellFiles,
+  versionCheckHook,
 }:
 
 rustPlatform.buildRustPackage rec {
   pname = "snphost";
-  version = "0.6.0";
+  version = "0.6.1";
 
   src = fetchFromGitHub {
     owner = "virtee";
     repo = "snphost";
     tag = "v${version}";
-    hash = "sha256-sBEIQQ0vfwQh5eqsC6x37VDlbXuBUybRh4LNUjfEJ5A=";
+    hash = "sha256-FvHawwoIqCiZ+Jm1itDWspaI+vDN6xDfeI11KoiO/DU=";
   };
 
   useFetchCargoVendor = true;
-  cargoHash = "sha256-aNXv6Av3JvnTqTbxX70FmwEF4jJaQmD6FHjvh7om9iE=";
+  cargoHash = "sha256-ZOXOfFYingTBq5LfJqHRf6ZdvrdY1Zve/ZMnAE25kPM=";
 
   nativeBuildInputs = [
     asciidoctor
···
     zlib
   ];
 
+  env.OPENSSL_NO_VENDOR = true;
+
   # man page is placed in cargo's $OUT_DIR, which is randomized.
   # Contacted upstream about it, for now use find to locate it.
   postInstall = ''
     installManPage $(find target/x86_64-unknown-linux-gnu/release/build -name "snphost.1")
   '';
+
+  nativeInstallCheckInputs = [ versionCheckHook ];
+  doInstallCheck = true;
 
   passthru.updateScript = nix-update-script { };
 

pkgs/by-name/to/tomato-c/package.nix

···
 
   meta = {
     homepage = "https://github.com/gabrielzschmitz/Tomato.C";
-    description = " A pomodoro timer written in pure C";
+    description = "Pomodoro timer written in pure C";
     license = with lib.licenses; [ gpl3Plus ];
     maintainers = with lib.maintainers; [ ];
     mainProgram = "tomato";

pkgs/by-name/tr/treedome/package.nix

···
 
   meta = {
     description = "Local-first, encrypted, note taking application organized in tree-like structures";
-    homepage = " https://codeberg.org/solver-orgz/treedome";
+    homepage = "https://codeberg.org/solver-orgz/treedome";
     license = lib.licenses.agpl3Plus;
     platforms = [ "x86_64-linux" ];
     mainProgram = "treedome";

pkgs/by-name/va/valeronoi/package.nix

···
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  boost,
+  cgal,
+  cmake,
+  gpp,
+  mpfr,
+  qt6Packages,
+}:
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "valeronoi";
+  version = "0.2.2";
+
+  src = fetchFromGitHub {
+    owner = "ccoors";
+    repo = "valeronoi";
+    tag = "v${finalAttrs.version}";
+    hash = "sha256-5KXVSIqWDkXnpO+qgBzFtbJb444RW8dIVXp8Y/aAOrk=";
+  };
+
+  buildInputs =
+    [
+      boost
+      cgal
+      gpp
+      mpfr
+    ]
+    ++ (with qt6Packages; [
+      qtbase
+      qtimageformats
+      qtsvg
+    ]);
+
+  nativeBuildInputs = [
+    cmake
+    qt6Packages.wrapQtAppsHook
+  ];
+
+  doCheck = true;
+
+  meta = {
+    homepage = "https://github.com/ccoors/Valeronoi/";
+    description = "WiFi mapping companion app for Valetudo";
+    license = lib.licenses.gpl3Only;
+    platforms = [ "x86_64-linux" ];
+    maintainers = with lib.maintainers; [
+      nova-madeline
+      maeve
+    ];
+    mainProgram = "valeronoi";
+  };
+})

pkgs/by-name/vu/vulkan-volk/package.nix

···
   cmakeFlags = [ "-DVOLK_INSTALL=1" ];
 
   meta = with lib; {
-    description = " Meta loader for Vulkan API";
+    description = "Meta loader for Vulkan API";
     homepage = "https://github.com/zeux/volk";
     platforms = platforms.all;
     license = licenses.mit;

pkgs/by-name/xb/xbyak/package.nix

···
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  cmake,
+}:
+stdenv.mkDerivation (finalAttrs: {
+  pname = "xbyak";
+  version = "7.28";
+
+  src = fetchFromGitHub {
+    owner = "herumi";
+    repo = "xbyak";
+    tag = "v${finalAttrs.version}";
+    hash = "sha256-jBxpNeA2Ed13zpJ++ODsjKgSC14z/RTFX3px4SapeS0=";
+  };
+
+  nativeBuildInputs = [ cmake ];
+
+  meta = {
+    description = "JIT assembler for x86/x64 architectures supporting advanced instruction sets up to AVX10.2";
+    homepage = "https://github.com/herumi/xbyak";
+    changelog = "https://github.com/herumi/xbyak/blob/v${finalAttrs.version}/doc/changelog.md";
+    license = lib.licenses.bsd3;
+    platforms = lib.platforms.all;
+    maintainers = [ lib.maintainers.ryand56 ];
+  };
+})

pkgs/development/compilers/elm/packages/node/default.nix

···
       with lib;
       nodePkgs."@dillonkearns/elm-graphql".meta
       // {
-        description = " Autogenerate type-safe GraphQL queries in Elm";
+        description = "Autogenerate type-safe GraphQL queries in Elm";
         license = licenses.bsd3;
         maintainers = [ maintainers.pedrohlc ];
       };

pkgs/development/compilers/flutter/update/update.py

···
 #! /usr/bin/env nix-shell
 #! nix-shell -i python3 -p python3Packages.pyyaml
 
-import shutil
+import argparse
 import json
-import urllib.request
-import tempfile
-from sys import exit
 import os
-import subprocess
 import re
-import json
-import argparse
+import subprocess
+import sys
+import tempfile
+import urllib.request
+from pathlib import Path
+
 import yaml
-import json
 
-FAKE_HASH = 'sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA='
+FAKE_HASH = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
 
-NIXPKGS_ROOT = subprocess.Popen(['git',
-                                 'rev-parse',
-                                 '--show-toplevel'],
-                                stdout=subprocess.PIPE,
-                                text=True).communicate()[0].strip()
+NIXPKGS_ROOT = (
+    subprocess.Popen(
+        ["git", "rev-parse", "--show-toplevel"], stdout=subprocess.PIPE, text=True
+    )
+    .communicate()[0]
+    .strip()
+)
 
 
 def load_code(name, **kwargs):
-    with open(f"{NIXPKGS_ROOT}/pkgs/development/compilers/flutter/update/{name}.in", 'r') as f:
+    with Path(
+        f"{NIXPKGS_ROOT}/pkgs/development/compilers/flutter/update/{name}.in"
+    ).open("r", encoding="utf-8") as f:
         code = f.read()
 
-    for (key, value) in kwargs.items():
+    for key, value in kwargs.items():
         code = code.replace(f"@{key}@", value)
 
     return code
···
 
 # Return out paths
 def nix_build(code):
-    temp = tempfile.NamedTemporaryFile(mode='w')
-    temp.write(code)
-    temp.flush()
-    os.fsync(temp.fileno())
+    with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", delete=False) as temp:
+        temp.write(code)
+        temp.flush()
+        os.fsync(temp.fileno())
+    temp_name = temp.name
 
     process = subprocess.Popen(
         [
···
             "--impure",
             "--no-out-link",
             "--expr",
-            f"with import {NIXPKGS_ROOT} {{}}; callPackage {temp.name} {{}}"],
+            f"with import {NIXPKGS_ROOT} {{}}; callPackage {temp_name} {{}}",
+        ],
         stdout=subprocess.PIPE,
-        text=True)
+        text=True,
+    )
 
     process.wait()
-    temp.close()
+    Path(temp_name).unlink()  # Clean up the temporary file
     return process.stdout.read().strip().splitlines()[0]
 
 
 # Return errors
 def nix_build_to_fail(code):
-    temp = tempfile.NamedTemporaryFile(mode='w')
-    temp.write(code)
-    temp.flush()
-    os.fsync(temp.fileno())
+    with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", delete=False) as temp:
+        temp.write(code)
+        temp.flush()
+        os.fsync(temp.fileno())
+    temp_name = temp.name
 
     process = subprocess.Popen(
         [
···
             "--keep-going",
             "--no-link",
             "--expr",
-            f"with import {NIXPKGS_ROOT} {{}}; callPackage {temp.name} {{}}"],
+            f"with import {NIXPKGS_ROOT} {{}}; callPackage {temp_name} {{}}",
+        ],
         stderr=subprocess.PIPE,
-        text=True)
+        text=True,
+    )
 
     stderr = ""
     while True:
···
         print(line.strip())
 
     process.wait()
-    temp.close()
+    Path(temp_name).unlink()  # Clean up the temporary file
     return stderr
 
 
 def get_engine_hashes(engine_version, flutter_version):
-    code = load_code("get-engine-hashes.nix",
-                     nixpkgs_root=NIXPKGS_ROOT,
-                     flutter_version=flutter_version,
-                     engine_version=engine_version)
+    code = load_code(
+        "get-engine-hashes.nix",
+        nixpkgs_root=NIXPKGS_ROOT,
+        flutter_version=flutter_version,
+        engine_version=engine_version,
+    )
 
     stderr = nix_build_to_fail(code)
 
     pattern = re.compile(
-        rf"/nix/store/.*-flutter-engine-source-{engine_version}-(.+?-.+?)-(.+?-.+?).drv':\n\s+specified: .*\n\s+got:\s+(.+?)\n")
+        rf"/nix/store/.*-flutter-engine-source-{engine_version}-(.+?-.+?)-(.+?-.+?).drv':\n\s+specified: .*\n\s+got:\s+(.+?)\n"
+    )
     matches = pattern.findall(stderr)
     result_dict = {}
 
···
 
     def sort_dict_recursive(d):
         return {
-            k: sort_dict_recursive(v) if isinstance(
-                v, dict) else v for k, v in sorted(
-                d.items())}
-    result_dict = sort_dict_recursive(result_dict)
+            k: sort_dict_recursive(v) if isinstance(v, dict) else v
+            for k, v in sorted(d.items())
+        }
 
-    return result_dict
+    return sort_dict_recursive(result_dict)
 
 
 def get_artifact_hashes(flutter_compact_version):
-    code = load_code("get-artifact-hashes.nix",
-                     nixpkgs_root=NIXPKGS_ROOT,
-                     flutter_compact_version=flutter_compact_version)
+    code = load_code(
+        "get-artifact-hashes.nix",
+        nixpkgs_root=NIXPKGS_ROOT,
+        flutter_compact_version=flutter_compact_version,
+    )
 
     stderr = nix_build_to_fail(code)
 
     pattern = re.compile(
-        r"/nix/store/.*-flutter-artifacts-(.+?)-(.+?).drv':\n\s+specified: .*\n\s+got:\s+(.+?)\n")
+        r"/nix/store/.*-flutter-artifacts-(.+?)-(.+?).drv':\n\s+specified: .*\n\s+got:\s+(.+?)\n"
+    )
     matches = pattern.findall(stderr)
     result_dict = {}
 
···
 
     def sort_dict_recursive(d):
         return {
-            k: sort_dict_recursive(v) if isinstance(
-                v, dict) else v for k, v in sorted(
-                d.items())}
-    result_dict = sort_dict_recursive(result_dict)
+            k: sort_dict_recursive(v) if isinstance(v, dict) else v
+            for k, v in sorted(d.items())
+        }
 
-    return result_dict
+    return sort_dict_recursive(result_dict)
 
 
 def get_dart_hashes(dart_version, channel):
-    platforms = [
-        "x86_64-linux",
-        "aarch64-linux",
-        "x86_64-darwin",
-        "aarch64-darwin"]
+    platforms = ["x86_64-linux", "aarch64-linux", "x86_64-darwin", "aarch64-darwin"]
     result_dict = {}
     for platform in platforms:
         code = load_code(
             "get-dart-hashes.nix",
             dart_version=dart_version,
             channel=channel,
-            platform=platform)
+            platform=platform,
+        )
         stderr = nix_build_to_fail(code)
 
         pattern = re.compile(r"got:\s+(.+?)\n")
···
 
 
 def get_flutter_hash_and_src(flutter_version):
-    code = load_code(
-        "get-flutter.nix",
-        flutter_version=flutter_version,
-        hash="")
+    code = load_code("get-flutter.nix", flutter_version=flutter_version, hash="")
 
     stderr = nix_build_to_fail(code)
     pattern = re.compile(r"got:\s+(.+?)\n")
-    hash = pattern.findall(stderr)[0]
+    flutter_hash_value = pattern.findall(stderr)[0]
 
     code = load_code(
-        "get-flutter.nix",
-        flutter_version=flutter_version,
-        hash=hash)
+        "get-flutter.nix", flutter_version=flutter_version, hash=flutter_hash_value
+    )
 
-    return (hash, nix_build(code))
+    return (flutter_hash_value, nix_build(code))
 
 
 def get_pubspec_lock(flutter_compact_version, flutter_src):
···
         "get-pubspec-lock.nix",
         flutter_compact_version=flutter_compact_version,
         flutter_src=flutter_src,
-        hash="")
+        hash="",
+    )
 
     stderr = nix_build_to_fail(code)
     pattern = re.compile(r"got:\s+(.+?)\n")
-    hash = pattern.findall(stderr)[0]
+    pubspec_lock_hash = pattern.findall(stderr)[0]
 
     code = load_code(
         "get-pubspec-lock.nix",
         flutter_compact_version=flutter_compact_version,
         flutter_src=flutter_src,
-        hash=hash)
+        hash=pubspec_lock_hash,
+    )
 
     pubspec_lock_file = nix_build(code)
 
-    with open(pubspec_lock_file, 'r') as f:
+    with Path(pubspec_lock_file).open("r", encoding="utf-8") as f:
         pubspec_lock_yaml = f.read()
 
     return yaml.safe_load(pubspec_lock_yaml)
 
+
 def get_engine_swiftshader_rev(engine_version):
-    with urllib.request.urlopen(f"https://github.com/flutter/flutter/raw/{engine_version}/DEPS") as f:
-        deps = f.read().decode('utf-8')
-        pattern = re.compile(r"Var\('swiftshader_git'\) \+ '\/SwiftShader\.git' \+ '@' \+ \'([0-9a-fA-F]{40})\'\,")
-        rev = pattern.findall(deps)[0]
-        return rev
+    with urllib.request.urlopen(
+        f"https://github.com/flutter/flutter/raw/{engine_version}/DEPS"
+    ) as f:
+        deps = f.read().decode("utf-8")
+        pattern = re.compile(
+            r"Var\('swiftshader_git'\) \+ '\/SwiftShader\.git' \+ '@' \+ \'([0-9a-fA-F]{40})\'\,"
+        )
+        return pattern.findall(deps)[0]
+
 
 def get_engine_swiftshader_hash(engine_swiftshader_rev):
     code = load_code(
         "get-engine-swiftshader.nix",
         engine_swiftshader_rev=engine_swiftshader_rev,
-        hash="")
+        hash="",
+    )
 
     stderr = nix_build_to_fail(code)
     pattern = re.compile(r"got:\s+(.+?)\n")
     return pattern.findall(stderr)[0]
 
+
 def write_data(
-        nixpkgs_flutter_version_directory,
-        flutter_version,
-        channel,
-        engine_hash,
-        engine_hashes,
-        engine_swiftshader_hash,
-        engine_swiftshader_rev,
-        dart_version,
-        dart_hash,
-        flutter_hash,
-        artifact_hashes,
-        pubspec_lock):
-    with open(f"{nixpkgs_flutter_version_directory}/data.json", "w") as f:
-        f.write(json.dumps({
-            "version": flutter_version,
-            "engineVersion": engine_hash,
-            "engineSwiftShaderHash": engine_swiftshader_hash,
-            "engineSwiftShaderRev": engine_swiftshader_rev,
-            "channel": channel,
-            "engineHashes": engine_hashes,
-            "dartVersion": dart_version,
-            "dartHash": dart_hash,
-            "flutterHash": flutter_hash,
-            "artifactHashes": artifact_hashes,
-            "pubspecLock": pubspec_lock,
-        }, indent=2).strip() + "\n")
+    nixpkgs_flutter_version_directory,
+    flutter_version,
+    channel,
+    engine_hash,
+    engine_hashes,
+    engine_swiftshader_hash,
+    engine_swiftshader_rev,
+    dart_version,
+    dart_hash,
+    flutter_hash,
+    artifact_hashes,
+    pubspec_lock,
+):
+    with Path(f"{nixpkgs_flutter_version_directory}/data.json").open(
+        "w", encoding="utf-8"
+    ) as f:
+        f.write(
+            json.dumps(
+                {
+                    "version": flutter_version,
+                    "engineVersion": engine_hash,
+                    "engineSwiftShaderHash": engine_swiftshader_hash,
+                    "engineSwiftShaderRev": engine_swiftshader_rev,
+                    "channel": channel,
+                    "engineHashes": engine_hashes,
+                    "dartVersion": dart_version,
+                    "dartHash": dart_hash,
+                    "flutterHash": flutter_hash,
+                    "artifactHashes": artifact_hashes,
+                    "pubspecLock": pubspec_lock,
+                },
+                indent=2,
+            ).strip()
+            + "\n"
+        )
 
 
 def update_all_packages():
     versions_directory = f"{NIXPKGS_ROOT}/pkgs/development/compilers/flutter/versions"
-    versions = [directory for directory in os.listdir(versions_directory)]
-    versions = sorted(versions, key=lambda x: (
-        int(x.split('_')[0]), int(x.split('_')[1])), reverse=True)
+    versions = [d.name for d in Path(versions_directory).iterdir()]
+    versions = sorted(
+        versions,
+        key=lambda x: (int(x.split("_")[0]), int(x.split("_")[1])),
+        reverse=True,
+    )
 
     new_content = [
         "flutterPackages-bin = recurseIntoAttrs (callPackage ../development/compilers/flutter { });",
-        "flutterPackages-source = recurseIntoAttrs (callPackage ../development/compilers/flutter { useNixpkgsEngine = true; });",
+        "flutterPackages-source = recurseIntoAttrs (",
+        "  callPackage ../development/compilers/flutter { useNixpkgsEngine = true; }",
+        ");",
         "flutterPackages = flutterPackages-bin;",
         "flutter = flutterPackages.stable;",
-    ] + [f"flutter{version.replace('_', '')} = flutterPackages.v{version};" for version in versions]
+    ] + [
+        f"flutter{version.replace('_', '')} = flutterPackages.v{version};"
+        for version in versions
+    ]
 
-    with open(f"{NIXPKGS_ROOT}/pkgs/top-level/all-packages.nix", 'r') as file:
+    with Path(f"{NIXPKGS_ROOT}/pkgs/top-level/all-packages.nix").open(
+        "r", encoding="utf-8"
+    ) as file:
         lines = file.read().splitlines(keepends=True)
 
     start = -1
     end = -1
     for i, line in enumerate(lines):
-        if "flutterPackages-bin = recurseIntoAttrs (callPackage ../development/compilers/flutter { });" in line:
+        if (
+            "flutterPackages-bin = recurseIntoAttrs (callPackage ../development/compilers/flutter { });"
+            in line
+        ):
             start = i
         if start != -1 and len(line.strip()) == 0:
             end = i
···
 
     if start != -1 and end != -1:
         del lines[start:end]
-        lines[start:start] = [f"  {l}\n" for l in new_content]
+        lines[start:start] = [f"  {line}\n" for line in new_content]
 
-    with open(f"{NIXPKGS_ROOT}/pkgs/top-level/all-packages.nix", 'w') as file:
+    with Path(f"{NIXPKGS_ROOT}/pkgs/top-level/all-packages.nix").open(
+        "w", encoding="utf-8"
+    ) as file:
         file.write("".join(lines))
 
 
···
     engine_hash = None
     dart_version = None
 
-    releases = json.load(urllib.request.urlopen(
-        "https://storage.googleapis.com/flutter_infra_release/releases/releases_linux.json"))
+    releases = json.load(
+        urllib.request.urlopen(
+            "https://storage.googleapis.com/flutter_infra_release/releases/releases_linux.json"
+        )
+    )
 
     if not channel:
-        channel = 'stable'
+        channel = "stable"
 
     if not flutter_version:
-        hash = releases['current_release'][channel]
+        release_hash = releases["current_release"][channel]
         release = next(
             filter(
-                lambda release: release['hash'] == hash,
-                releases['releases']))
-        flutter_version = release['version']
+                lambda release: release["hash"] == release_hash, releases["releases"]
+            )
+        )
+        flutter_version = release["version"]
 
-    tags = subprocess.Popen(['git',
-                             'ls-remote',
-                             '--tags',
-                             'https://github.com/flutter/flutter.git'],
-                            stdout=subprocess.PIPE,
-                            text=True).communicate()[0].strip()
+    tags = (
+        subprocess.Popen(
+            ["git", "ls-remote", "--tags", "https://github.com/flutter/flutter.git"],
+            stdout=subprocess.PIPE,
+            text=True,
+        )
+        .communicate()[0]
+        .strip()
+    )
 
     try:
-        flutter_hash = next(
-            filter(
-                lambda line: line.endswith(f'refs/tags/{flutter_version}'),
-                tags.splitlines())).split('refs')[0].strip()
+        flutter_hash = (
+            next(
+                filter(
+                    lambda line: line.endswith(f"refs/tags/{flutter_version}"),
+                    tags.splitlines(),
+                )
+            )
+            .split("refs")[0]
+            .strip()
+        )
 
-        engine_hash = urllib.request.urlopen(f'https://github.com/flutter/flutter/raw/{flutter_hash}/bin/internal/engine.version').read().decode('utf-8').strip()
+        engine_hash = (
+            urllib.request.urlopen(
+                f"https://github.com/flutter/flutter/raw/{flutter_hash}/bin/internal/engine.version"
+            )
+            .read()
+            .decode("utf-8")
+            .strip()
+        )
     except StopIteration:
-        exit(
-            f"Couldn't find Engine hash for Flutter version: {flutter_version}")
+        sys.exit(f"Couldn't find Engine hash for Flutter version: {flutter_version}")
 
     try:
         dart_version = next(
             filter(
-                lambda release: release['version'] == flutter_version,
-                releases['releases']))['dart_sdk_version']
+                lambda release: release["version"] == flutter_version,
+                releases["releases"],
+            )
+        )["dart_sdk_version"]
 
         if " " in dart_version:
-            dart_version = dart_version.split(' ')[2][:-1]
+            dart_version = dart_version.split(" ")[2][:-1]
     except StopIteration:
-        exit(
-            f"Couldn't find Dart version for Flutter version: {flutter_version}")
+        sys.exit(f"Couldn't find Dart version for Flutter version: {flutter_version}")
 
     return (flutter_version, engine_hash, dart_version, channel)
 
 
 def main():
-    parser = argparse.ArgumentParser(description='Update Flutter in Nixpkgs')
-    parser.add_argument('--version', type=str, help='Specify Flutter version')
-    parser.add_argument('--channel', type=str, help='Specify Flutter release channel')
-    parser.add_argument('--artifact-hashes', action='store_true',
-                        help='Whether to get artifact hashes')
+    parser = argparse.ArgumentParser(description="Update Flutter in Nixpkgs")
+    parser.add_argument("--version", type=str, help="Specify Flutter version")
+    parser.add_argument("--channel", type=str, help="Specify Flutter release channel")
+    parser.add_argument(
+        "--artifact-hashes", action="store_true", help="Whether to get artifact hashes"
+    )
     args = parser.parse_args()
 
-    (flutter_version, engine_hash, dart_version, channel) = find_versions(args.version, args.channel)
+    (flutter_version, engine_hash, dart_version, channel) = find_versions(
+        args.version, args.channel
+    )
 
-    flutter_compact_version = '_'.join(flutter_version.split('.')[:2])
+    flutter_compact_version = "_".join(flutter_version.split(".")[:2])
 
     if args.artifact_hashes:
         print(
-            json.dumps(
-                get_artifact_hashes(flutter_compact_version),
-                indent=2).strip() +
-            "\n")
+            json.dumps(get_artifact_hashes(flutter_compact_version), indent=2).strip()
+            + "\n"
+        )
         return
 
-    print(f"Flutter version: {flutter_version} ({flutter_compact_version}) on ({channel})")
+    print(
+        f"Flutter version: {flutter_version} ({flutter_compact_version}) on ({channel})"
+    )
     print(f"Engine hash: {engine_hash}")
     print(f"Dart version: {dart_version}")
 
···
 
     nixpkgs_flutter_version_directory = f"{NIXPKGS_ROOT}/pkgs/development/compilers/flutter/versions/{flutter_compact_version}"
 
-    if os.path.exists(f"{nixpkgs_flutter_version_directory}/data.json"):
-        os.remove(f"{nixpkgs_flutter_version_directory}/data.json")
-    os.makedirs(nixpkgs_flutter_version_directory, exist_ok=True)
+    if Path(f"{nixpkgs_flutter_version_directory}/data.json").exists():
+        Path(f"{nixpkgs_flutter_version_directory}/data.json").unlink()
+    Path(nixpkgs_flutter_version_directory).mkdir(parents=True, exist_ok=True)
 
     update_all_packages()
 
···
         artifact_hashes={},
         engine_hashes={},
         engine_swiftshader_hash=FAKE_HASH,
-        engine_swiftshader_rev='0',
-        **common_data_args)
+        engine_swiftshader_rev="0",
+        **common_data_args,
+    )
 
     pubspec_lock = get_pubspec_lock(flutter_compact_version, flutter_src)
 
···
         artifact_hashes={},
         engine_hashes={},
         engine_swiftshader_hash=FAKE_HASH,
-        engine_swiftshader_rev='0',
-        **common_data_args)
+        engine_swiftshader_rev="0",
+        **common_data_args,
+    )
 
     artifact_hashes = get_artifact_hashes(flutter_compact_version)
 
···
         artifact_hashes=artifact_hashes,
         engine_hashes={},
         engine_swiftshader_hash=FAKE_HASH,
-        engine_swiftshader_rev='0',
-        **common_data_args)
+        engine_swiftshader_rev="0",
+        **common_data_args,
+    )
 
     engine_hashes = get_engine_hashes(engine_hash, flutter_version)
 
···
         artifact_hashes=artifact_hashes,
         engine_hashes=engine_hashes,
         engine_swiftshader_hash=FAKE_HASH,
-        engine_swiftshader_rev='0',
-        **common_data_args)
+        engine_swiftshader_rev="0",
+        **common_data_args,
+    )
 
     engine_swiftshader_rev = get_engine_swiftshader_rev(engine_hash)
     engine_swiftshader_hash = get_engine_swiftshader_hash(engine_swiftshader_rev)
···
         engine_hashes=engine_hashes,
         engine_swiftshader_hash=engine_swiftshader_hash,
         engine_swiftshader_rev=engine_swiftshader_rev,
-        **common_data_args)
+        **common_data_args,
+    )
 
 
 if __name__ == "__main__":

pkgs/development/compilers/flutter/versions/3_32/data.json

···
 {
-  "version": "3.32.6",
-  "engineVersion": "72f2b18bb094f92f62a3113a8075240ebb59affa",
+  "version": "3.32.7",
+  "engineVersion": "39d6d6e699e51b2874210e14cddf1a22fb9524b2",
   "engineSwiftShaderHash": "sha256-ATVcuxqPHqHOWYyO7DoX9LdgUiO3INUi7m9Mc6ccc1M=",
   "engineSwiftShaderRev": "d040a5bab638bf7c226235c95787ba6288bb6416",
   "channel": "stable",
   "engineHashes": {
     "aarch64-linux": {
-      "aarch64-linux": "sha256-MjWz+aveIDXygAejZiNGFZluR0gjpS62h16UcFGz7FA=",
-      "x86_64-linux": "sha256-MjWz+aveIDXygAejZiNGFZluR0gjpS62h16UcFGz7FA="
+      "aarch64-linux": "sha256-3cqYwwQlnHPMRoeRLsru+Xk9rMiAaLZ6rBxdJttJSW0=",
+      "x86_64-linux": "sha256-3cqYwwQlnHPMRoeRLsru+Xk9rMiAaLZ6rBxdJttJSW0="
     },
     "x86_64-linux": {
-      "aarch64-linux": "sha256-jWM+egf2tZVR8bnBXSHiXOG0CbkEjxEqxwPnaR7tJKk=",
-      "x86_64-linux": "sha256-jWM+egf2tZVR8bnBXSHiXOG0CbkEjxEqxwPnaR7tJKk="
+      "aarch64-linux": "sha256-8jXbz7gQZhaoU2Cs6uAbR5xF22HzBxMghA4edm/7oa4=",
+      "x86_64-linux": "sha256-8jXbz7gQZhaoU2Cs6uAbR5xF22HzBxMghA4edm/7oa4="
     }
   },
   "dartVersion": "3.8.1",
···
     "x86_64-darwin": "sha256-S3iGDVLollApke2SnXAcV919qsDTVmz5Gf9fTletr00=",
     "aarch64-darwin": "sha256-haHQks9N1mBIqRsYg9sOLw7ra7gC708gsTWfKxvIK1c="
   },
-  "flutterHash": "sha256-YxApWMp6Ax1ZNOH/7kgeXgiaBcXN7Ves4TFUImFtd3s=",
+  "flutterHash": "sha256-fPCa9JHvQGP47uo6LHbGC2aMMwdX+AOEZfvIyZ3M2/U=",
   "artifactHashes": {
     "android": {
-      "aarch64-darwin": "sha256-thfXrVn6nWlQg23yDHiNAx6XebQkV80tkckONwmfjaU=",
-      "aarch64-linux": "sha256-fM90NqMpD4SkrjZfDXvHjMNdGiaDqX2T+A4cNNZkplk=",
-      "x86_64-darwin": "sha256-thfXrVn6nWlQg23yDHiNAx6XebQkV80tkckONwmfjaU=",
-      "x86_64-linux": "sha256-fM90NqMpD4SkrjZfDXvHjMNdGiaDqX2T+A4cNNZkplk="
+      "aarch64-darwin": "sha256-Gs4SLCLh/6e/n8lu6pTujksW/MqIieWymF151N5dDnw=",
+      "aarch64-linux": "sha256-aTVHfbG6V4T2/SDbxdCEYo3+7EryjK6sAUL4FF4AmUM=",
+      "x86_64-darwin": "sha256-Gs4SLCLh/6e/n8lu6pTujksW/MqIieWymF151N5dDnw=",
+      "x86_64-linux": "sha256-aTVHfbG6V4T2/SDbxdCEYo3+7EryjK6sAUL4FF4AmUM="
     },
     "fuchsia": {
-      "aarch64-darwin": "sha256-Lh6z51v14kZIGxriaKDdOn5fAKyANm8FAzIozoOiAZg=",
-      "aarch64-linux": "sha256-Lh6z51v14kZIGxriaKDdOn5fAKyANm8FAzIozoOiAZg=",
-      "x86_64-darwin": "sha256-Lh6z51v14kZIGxriaKDdOn5fAKyANm8FAzIozoOiAZg=",
-      "x86_64-linux": "sha256-Lh6z51v14kZIGxriaKDdOn5fAKyANm8FAzIozoOiAZg="
+      "aarch64-darwin": "sha256-cKUp9CQq10Ls3dOcB3wPdnnwVK26RG0JWn0n4TsWigc=",
+      "aarch64-linux": "sha256-cKUp9CQq10Ls3dOcB3wPdnnwVK26RG0JWn0n4TsWigc=",
+      "x86_64-darwin": "sha256-cKUp9CQq10Ls3dOcB3wPdnnwVK26RG0JWn0n4TsWigc=",
+      "x86_64-linux": "sha256-cKUp9CQq10Ls3dOcB3wPdnnwVK26RG0JWn0n4TsWigc="
     },
     "ios": {
-      "aarch64-darwin": "sha256-zCR8wt7QZHl9UFOhkU8KFkyRbaUitXJHTiMLOe+M5/g=",
-      "aarch64-linux": "sha256-zCR8wt7QZHl9UFOhkU8KFkyRbaUitXJHTiMLOe+M5/g=",
-      "x86_64-darwin": "sha256-zCR8wt7QZHl9UFOhkU8KFkyRbaUitXJHTiMLOe+M5/g=",
-      "x86_64-linux": "sha256-zCR8wt7QZHl9UFOhkU8KFkyRbaUitXJHTiMLOe+M5/g="
+      "aarch64-darwin": "sha256-EvzvRyR2aRomFPiz7WfGyhg0JiOHzCIi6xEDbLeIGAQ=",
+      "aarch64-linux": "sha256-EvzvRyR2aRomFPiz7WfGyhg0JiOHzCIi6xEDbLeIGAQ=",
+      "x86_64-darwin": "sha256-EvzvRyR2aRomFPiz7WfGyhg0JiOHzCIi6xEDbLeIGAQ=",
+      "x86_64-linux": "sha256-EvzvRyR2aRomFPiz7WfGyhg0JiOHzCIi6xEDbLeIGAQ="
     },
     "linux": {
-      "aarch64-darwin": "sha256-dSXB6GFQZjHoyiDStAnohYtzFIrVWmD3DfQ0b+cGwcU=",
-      "aarch64-linux": "sha256-dSXB6GFQZjHoyiDStAnohYtzFIrVWmD3DfQ0b+cGwcU=",
-      "x86_64-darwin": "sha256-9ds2C7XBIvnzbgwcBPwJhaF/l/t+uZQEiuwQg2WIVkE=",
-      "x86_64-linux": "sha256-9ds2C7XBIvnzbgwcBPwJhaF/l/t+uZQEiuwQg2WIVkE="
+      "aarch64-darwin": "sha256-eLGFwZxd4P9NSnHhOssAvjWea+ahuPUtIi4BrsOxZDE=",
+      "aarch64-linux": "sha256-eLGFwZxd4P9NSnHhOssAvjWea+ahuPUtIi4BrsOxZDE=",
+      "x86_64-darwin": "sha256-WhDM+gxvSWsQ0RyaInKH3obabboMfBtfBPZPx6379kc=",
+      "x86_64-linux": "sha256-WhDM+gxvSWsQ0RyaInKH3obabboMfBtfBPZPx6379kc="
     },
     "macos": {
-      "aarch64-darwin": "sha256-Qybdtwy8MfPEsCJUHxlV62fZyEAClOHM4thsEw4nmvg=",
-      "aarch64-linux": "sha256-Qybdtwy8MfPEsCJUHxlV62fZyEAClOHM4thsEw4nmvg=",
-      "x86_64-darwin": "sha256-Qybdtwy8MfPEsCJUHxlV62fZyEAClOHM4thsEw4nmvg=",
-      "x86_64-linux": "sha256-Qybdtwy8MfPEsCJUHxlV62fZyEAClOHM4thsEw4nmvg="
+      "aarch64-darwin": "sha256-3QXe7KTjh9noCdZnCRbo6bXuif7dhQ75mk6/lyydSck=",
+      "aarch64-linux": "sha256-3QXe7KTjh9noCdZnCRbo6bXuif7dhQ75mk6/lyydSck=",
+      "x86_64-darwin": "sha256-3QXe7KTjh9noCdZnCRbo6bXuif7dhQ75mk6/lyydSck=",
+      "x86_64-linux": "sha256-3QXe7KTjh9noCdZnCRbo6bXuif7dhQ75mk6/lyydSck="
     },
     "universal": {
-      "aarch64-darwin": "sha256-37CxKej4SB4Qm3aJVkf3SK0uiimLYSGJBAOwqWStmEY=",
-      "aarch64-linux": "sha256-7p4CTx///0ND5xUpb9uGbBgaLeClt/aGoSm6mE56ySk=",
-      "x86_64-darwin": "sha256-sjrzv4jJ28RViNaC7jG4utnerBj3521kXfT8CAgGOLI=",
-      "x86_64-linux": "sha256-B9gqS5lfLy8pYjP7N52jLqZmroukuAS/ed0xP5xspeg="
+      "aarch64-darwin": "sha256-Z7UTqCTESwcpv0yxzTEMThkQMNfisOCnhC7sltY0dUA=",
+      "aarch64-linux": "sha256-VIMu52o7BIEkxt4h0u4sILcrgKg85TY+3ieQl290icM=",
+      "x86_64-darwin": "sha256-/jOrwEy6EWCx8cS9MyIEI4NqO2H8Rs/VV7N6RmCyPWM=",
+      "x86_64-linux": "sha256-mcQYpXo8E/j4j4OYIwlcx6xpiyYbnKXrwfT+rl6W4Zw="
     },
     "web": {
-      "aarch64-darwin": "sha256-iLAX0UCh+ZTsSggKj29cUm+8CIEJfXj+iWiTV1ndfrU=",
-      "aarch64-linux": "sha256-iLAX0UCh+ZTsSggKj29cUm+8CIEJfXj+iWiTV1ndfrU=",
-      "x86_64-darwin": "sha256-iLAX0UCh+ZTsSggKj29cUm+8CIEJfXj+iWiTV1ndfrU=",
-      "x86_64-linux": "sha256-iLAX0UCh+ZTsSggKj29cUm+8CIEJfXj+iWiTV1ndfrU="
+      "aarch64-darwin": "sha256-2nnM91LPjdxuU2uWCdE2tFoZ75N0L5DWlJa75KCulY8=",
+      "aarch64-linux": "sha256-2nnM91LPjdxuU2uWCdE2tFoZ75N0L5DWlJa75KCulY8=",
+      "x86_64-darwin": "sha256-2nnM91LPjdxuU2uWCdE2tFoZ75N0L5DWlJa75KCulY8=",
+      "x86_64-linux": "sha256-2nnM91LPjdxuU2uWCdE2tFoZ75N0L5DWlJa75KCulY8="
     },
     "windows": {
-      "x86_64-darwin": "sha256-7M6lLznB1FwQi4e4O6r5IWRxYFaXhfdkSx3rN2GZr5c=",
-      "x86_64-linux": "sha256-7M6lLznB1FwQi4e4O6r5IWRxYFaXhfdkSx3rN2GZr5c="
+      "x86_64-darwin": "sha256-boajU3GH29bhgDT+emE3gIQjAtuon1OUi1gGBH6iq/4=",
+      "x86_64-linux": "sha256-boajU3GH29bhgDT+emE3gIQjAtuon1OUi1gGBH6iq/4="
     }
   },
   "pubspecLock": {

pkgs/development/lua-modules/generated-packages.nix

···
 
       meta = {
         homepage = "https://github.com/mrcjkb/haskell-tools.nvim";
-        description = " 🦥 Supercharge your Haskell experience in neovim!";
+        description = "🦥 Supercharge your Haskell experience in neovim!";
         maintainers = with lib.maintainers; [ mrcjkb ];
         license.fullName = "GPL-2.0";
       };

pkgs/development/ocaml-modules/bls12-381/default.nix

···
   doCheck = true;
 
   meta = {
-    homepage = "	https://nomadic-labs.gitlab.io/cryptography/ocaml-bls12-381/bls12-381/";
+    homepage = "https://nomadic-labs.gitlab.io/cryptography/ocaml-bls12-381/bls12-381/";
     description = "Implementation of BLS12-381 and some cryptographic primitives built on top of it";
     license = lib.licenses.mit;
     maintainers = [ lib.maintainers.ulrikstrid ];

pkgs/development/ocaml-modules/janestreet/0.17.nix

···
   ocaml_openapi_generator = janePackage {
     pname = "ocaml_openapi_generator";
     hash = "sha256-HCq9fylcVjBMs8L6E860nw+EonWEQadlyEKpQI6mynU=";
-    meta.description = " An OpenAPI 3 to OCaml client generator";
+    meta.description = "OpenAPI 3 to OCaml client generator";
     buildInputs = [
       async
       core

pkgs/development/ocaml-modules/ocsigen-toolkit/default.nix

···
 
   meta = {
     homepage = "http://ocsigen.org/ocsigen-toolkit/";
-    description = " User interface widgets for Ocsigen applications";
+    description = "User interface widgets for Ocsigen applications";
     license = lib.licenses.lgpl21;
     maintainers = [ lib.maintainers.gal_bolle ];
     inherit (ocaml.meta) platforms;

pkgs/development/octave-modules/communications/default.nix

···
     homepage = "https://gnu-octave.github.io/packages/communications/";
     license = lib.licenses.gpl3Plus;
     maintainers = with lib.maintainers; [ KarlJoad ];
-    description = " Digital Communications, Error Correcting Codes (Channel Code), Source Code functions, Modulation and Galois Fields";
+    description = "Digital Communications, Error Correcting Codes (Channel Code), Source Code functions, Modulation and Galois Fields";
   };
 }

pkgs/development/python-modules/ahocorapy/default.nix

···
 {
   buildPythonPackage,
   fetchFromGitHub,
-  future,
   lib,
   pytestCheckHook,
   setuptools,
···
 
   build-system = [ setuptools ];
 
-  dependencies = [
-    future
-  ];
+  pythonRemoveDeps = [ "future" ];
 
   pythonImportsCheck = [ "ahocorapy" ];
 

pkgs/development/python-modules/aioamazondevices/default.nix

···
 
 buildPythonPackage rec {
   pname = "aioamazondevices";
-  version = "3.3.0";
+  version = "3.5.0";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "chemelli74";
     repo = "aioamazondevices";
     tag = "v${version}";
-    hash = "sha256-MXVQ/VtsT/ppeQsSnf+LiddlZFKylQxL48vPRKj932w=";
+    hash = "sha256-gFO0E5tphInHOTAgaifp+jNQQvs+HfLDhvErmLwwrPU=";
   };
 
   build-system = [ poetry-core ];

pkgs/development/python-modules/aioguardian/default.nix

···
   pythonImportsCheck = [ "aioguardian" ];
 
   meta = with lib; {
-    description = " Python library to interact with Elexa Guardian devices";
+    description = "Python library to interact with Elexa Guardian devices";
     longDescription = ''
       aioguardian is an asyncio-focused library for interacting with the
       Guardian line of water valves and sensors from Elexa.

pkgs/development/python-modules/aurorapy/default.nix

···
   lib,
   buildPythonPackage,
   fetchFromGitLab,
-  future,
   pyserial,
   pytestCheckHook,
-  pythonOlder,
   setuptools,
   six,
 }:
···
 buildPythonPackage rec {
   pname = "aurorapy";
   version = "0.2.7";
-  format = "pyproject";
-
-  disabled = pythonOlder "3.7";
+  pyproject = true;
 
   src = fetchFromGitLab {
     owner = "energievalsabbia";
···
     hash = "sha256-rGwfGq3zdoG9NCGqVN29Q4bWApk5B6CRdsW9ctWgOec=";
   };
 
-  nativeBuildInputs = [ setuptools ];
+  postPatch = ''
+    sed -i "/from past.builtins import map/d" aurorapy/client.py
+  '';
+
+  build-system = [ setuptools ];
+
+  pythonRemoveDeps = [ "future" ];
 
-  propagatedBuildInputs = [
-    future
-    pyserial
-  ];
+  dependencies = [ pyserial ];
 
   nativeCheckInputs = [
     pytestCheckHook

pkgs/development/python-modules/djangorestframework-recursive/default.nix

···
   pythonImportsCheck = [ "rest_framework_recursive" ];
 
   meta = with lib; {
-    description = " Recursive Serialization for Django REST framework";
+    description = "Recursive Serialization for Django REST framework";
     homepage = "https://github.com/heywbj/django-rest-framework-recursive";
     license = licenses.isc;
     maintainers = [ ];

pkgs/development/python-modules/gios/default.nix

···
 
 buildPythonPackage rec {
   pname = "gios";
-  version = "6.1.1";
+  version = "6.1.2";
   pyproject = true;
 
   disabled = pythonOlder "3.12";
···
     owner = "bieniu";
     repo = "gios";
     tag = version;
-    hash = "sha256-BjyeWg75JQd+VAIQmtFIwEdByMPdGG+nIOgKCavjF0c=";
+    hash = "sha256-z0MFXlim0YJ2ifAU94IjDOsIgaRzQk6YRqy64+LNehQ=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/manuf/default.nix

···
 
   meta = with lib; {
     homepage = "https://github.com/coolbho3k/manuf";
-    description = " Parser library for Wireshark's OUI database";
+    description = "Parser library for Wireshark's OUI database";
     mainProgram = "manuf";
     platforms = platforms.linux;
     license = with licenses; [

pkgs/development/python-modules/midea-local/default.nix

···
   ];
 
   meta = with lib; {
-    description = " Control your Midea M-Smart appliances via local area network";
+    description = "Control your Midea M-Smart appliances via local area network";
     homepage = "https://github.com/midea-lan/midea-local";
     changelog = "https://github.com/midea-lan/midea-local/releases/tag/${src.tag}";
     maintainers = with maintainers; [ k900 ];

pkgs/development/python-modules/migen/default.nix

···
   passthru.updateScript = unstableGitUpdater { };
 
   meta = {
-    description = " A Python toolbox for building complex digital hardware";
+    description = "Python toolbox for building complex digital hardware";
     homepage = "https://m-labs.hk/migen";
     license = lib.licenses.bsd2;
     maintainers = with lib.maintainers; [ l-as ];

pkgs/development/python-modules/plumbum/default.nix

···
   meta = with lib; {
     description = "Module Shell Combinators";
     changelog = "https://github.com/tomerfiliba/plumbum/releases/tag/v${version}";
-    homepage = " https://github.com/tomerfiliba/plumbum";
+    homepage = "https://github.com/tomerfiliba/plumbum";
     license = licenses.mit;
     maintainers = [ ];
   };

pkgs/development/python-modules/pyenphase/default.nix

···
 
 buildPythonPackage rec {
   pname = "pyenphase";
-  version = "2.2.1";
+  version = "2.2.2";
   pyproject = true;
 
   disabled = pythonOlder "3.11";
···
     owner = "pyenphase";
     repo = "pyenphase";
     tag = "v${version}";
-    hash = "sha256-rIGPkeEh36Au2F+zx/4vR79212BWMdnG5yz+vJ2sxfU=";
+    hash = "sha256-1RF1U4hMsGRa2OJJY2Plvuow3P+R7wbwd4ouo7QQ4n0=";
   };
 
   pythonRelaxDeps = [ "tenacity" ];

pkgs/development/python-modules/pytile/default.nix

···
   __darwinAllowLocalNetworking = true;
 
   meta = with lib; {
-    description = " Python API for Tile Bluetooth trackers";
+    description = "Python API for Tile Bluetooth trackers";
     longDescription = ''
       pytile is a simple Python library for retrieving information on Tile
       Bluetooth trackers (including last location and more).

pkgs/development/python-modules/tesla-fleet-api/default.nix

···
 
 buildPythonPackage rec {
   pname = "tesla-fleet-api";
-  version = "1.2.0";
+  version = "1.2.2";
   pyproject = true;
 
   disabled = pythonOlder "3.10";
···
     owner = "Teslemetry";
     repo = "python-tesla-fleet-api";
     tag = "v${version}";
-    hash = "sha256-z7oniC58MpWlz/IGd2oRWgoj5yAL/gaDHGotLKK2CVc=";
+    hash = "sha256-FWOAjNjzpImDWSFxbVVdBFuM1gUJUYyLN694B24kD9U=";
   };
 
   build-system = [ setuptools ];

pkgs/os-specific/linux/rtw89/default.nix

···
   '';
 
   meta = with lib; {
-    description = " Driver for Realtek 8852AE, 8852BE, and 8853CE, 802.11ax devices";
+    description = "Driver for Realtek 8852AE, 8852BE, and 8853CE, 802.11ax devices";
     homepage = "https://github.com/lwfinger/rtw89";
     license = with licenses; [ gpl2Only ];
     maintainers = with maintainers; [ tvorog ];

pkgs/servers/home-assistant/component-packages.nix

···
 # Do not edit!
 
 {
-  version = "2025.7.2";
+  version = "2025.7.3";
   components = {
     "3_day_blinds" =
       ps: with ps; [

pkgs/servers/home-assistant/default.nix

···
   extraBuildInputs = extraPackages python.pkgs;
 
   # Don't forget to run update-component-packages.py after updating
-  hassVersion = "2025.7.2";
+  hassVersion = "2025.7.3";
 
 in
 python.pkgs.buildPythonApplication rec {
···
     owner = "home-assistant";
     repo = "core";
     tag = version;
-    hash = "sha256-aBIG4dxCdj1dQP5wMd5ySXggUvspGlnh7btxmMr/51Y=";
+    hash = "sha256-FT77obtb081QOgw+nqbQvvW+3x/L2WUr3DLT8X1Wpwg=";
   };
 
   # Secondary source is pypi sdist for translations
   sdist = fetchPypi {
     inherit pname version;
-    hash = "sha256-J8KH9y8dNsKW+jc5Wkqnw9VreKoUQH0dEBbne/6xiMw=";
+    hash = "sha256-jO+rNIzEvtQ1vhSD1Xbq/SKV5XvBOb4MmkkczoeD1Kc=";
   };
 
   build-system = with python.pkgs; [

pkgs/servers/home-assistant/frontend.nix

···
   # the frontend version corresponding to a specific home-assistant version can be found here
   # https://github.com/home-assistant/home-assistant/blob/master/homeassistant/components/frontend/manifest.json
   pname = "home-assistant-frontend";
-  version = "20250702.2";
+  version = "20250702.3";
   format = "wheel";
 
   src = fetchPypi {
···
     pname = "home_assistant_frontend";
     dist = "py3";
     python = "py3";
-    hash = "sha256-3/m2T2yUpjczHEIywdwL+fqr9juiN2Mtd1iT+X+lTxo=";
+    hash = "sha256-Uj7auy5emdP8l9vUxLbAL28UNoAi1OQ/8qIhmJMmA8Q=";
   };
 
   # there is nothing to strip in this package

pkgs/servers/home-assistant/pytest-homeassistant-custom-component.nix

···
 
 buildPythonPackage rec {
   pname = "pytest-homeassistant-custom-component";
-  version = "0.13.261";
+  version = "0.13.262";
   pyproject = true;
 
   disabled = pythonOlder "3.13";
···
     owner = "MatthewFlamm";
     repo = "pytest-homeassistant-custom-component";
     rev = "refs/tags/${version}";
-    hash = "sha256-23qNOWz04uEPg2SHsdERVcFuYoVK16lznWYm8R1fJXc=";
+    hash = "sha256-dlGZD9JNEMGaDpH4RiX1LJtx2owdRJvJX+V2b5QzD7U=";
   };
 
   build-system = [ setuptools ];

pkgs/servers/home-assistant/stubs.nix

···
 
 buildPythonPackage rec {
   pname = "homeassistant-stubs";
-  version = "2025.7.2";
+  version = "2025.7.3";
   pyproject = true;
 
   disabled = python.version != home-assistant.python.version;
···
     owner = "KapJI";
     repo = "homeassistant-stubs";
     tag = version;
-    hash = "sha256-qpNDeJHnGmjxgFOfNDl1jyK+t/BFzC+VtkTu+zL8NaQ=";
+    hash = "sha256-iHNBFtdIQMAKiQGJ35xCBqDbYYphoAJPXjhmgIEEE5E=";
   };
 
   build-system = [

pkgs/servers/home-assistant/update-component-packages.py

···
         with urlopen(
             f"https://github.com/home-assistant/home-assistant/archive/{version}.tar.gz"
         ) as response:
-            tarfile.open(fileobj=BytesIO(response.read())).extractall(tmp)
+            tarfile.open(fileobj=BytesIO(response.read())).extractall(tmp, filter="data")
         # Use part of a script from the Home Assistant codebase
         core_path = os.path.join(tmp, f"core-{version}")
 

pkgs/servers/http/nginx/modules.nix

···
       };
 
       meta = with lib; {
-        description = " Fancy indexes module";
+        description = "Fancy indexes module";
         homepage = "https://github.com/aperezdc/ngx-fancyindex";
         license = with licenses; [ bsd2 ];
         maintainers = with maintainers; [ aneeshusa ];
···
       inputs = [ libbsd ];
 
       meta = with lib; {
-        description = " IP address anonymizer";
+        description = "IP address anonymizer";
         homepage = "https://github.com/masonicboom/ipscrub";
         license = with licenses; [ bsd3 ];
         maintainers = [ ];

pkgs/servers/nextcloud/packages/apps/hmr_enabler.nix

···
   '';
 
   meta = {
-    description = " Development Nextcloud app to enable apps to use hot module reloading";
+    description = "Development Nextcloud app to enable apps to use hot module reloading";
     homepage = "https://github.com/nextcloud/hmr_enabler";
     changelog = "https://github.com/nextcloud/hmr_enabler/blob/master/CHANGELOG.md";
     license = lib.licenses.agpl3Only;

pkgs/servers/web-apps/plausible/default.nix

···
     license = licenses.agpl3Plus;
     homepage = "https://plausible.io/";
     changelog = "https://github.com/plausible/analytics/blob/${src.rev}/CHANGELOG.md";
-    description = " Simple, open-source, lightweight (< 1 KB) and privacy-friendly web analytics alternative to Google Analytics";
+    description = "Simple, open-source, lightweight (< 1 KB) and privacy-friendly web analytics alternative to Google Analytics";
     mainProgram = "plausible";
     teams = [ teams.cyberus ];
     platforms = platforms.unix;

pkgs/tools/misc/valeronoi/default.nix

···
-{
-  lib,
-  stdenv,
-  fetchFromGitHub,
-  boost,
-  cgal,
-  cmake,
-  gpp,
-  mpfr,
-  qtbase,
-  qtimageformats,
-  qtsvg,
-  wrapQtAppsHook,
-}:
-
-stdenv.mkDerivation rec {
-  pname = "valeronoi";
-  version = "0.2.2";
-
-  src = fetchFromGitHub {
-    owner = "ccoors";
-    repo = pname;
-    tag = "v${version}";
-    sha256 = "sha256-5KXVSIqWDkXnpO+qgBzFtbJb444RW8dIVXp8Y/aAOrk=";
-  };
-
-  buildInputs = [
-    boost
-    cgal
-    gpp
-    mpfr
-    qtbase
-    qtimageformats
-    qtsvg
-  ];
-
-  nativeBuildInputs = [
-    cmake
-    wrapQtAppsHook
-  ];
-
-  doCheck = true;
-
-  meta = with lib; {
-    homepage = "https://github.com/ccoors/Valeronoi/";
-    description = "WiFi mapping companion app for Valetudo";
-    license = licenses.gpl3Only;
-    platforms = [ "x86_64-linux" ];
-    maintainers = with maintainers; [
-      nova-madeline
-      maeve
-    ];
-    mainProgram = "valeronoi";
-  };
-}

pkgs/tools/security/fwbuilder/default.nix pkgs/by-name/fw/fwbuilder/package.nix

···
   fetchFromGitHub,
   cmake,
   ninja,
-  wrapQtAppsHook,
   wayland,
   wayland-protocols,
-  qtwayland,
+  libsForQt5,
 }:
 
-stdenv.mkDerivation rec {
+stdenv.mkDerivation (finalAttrs: {
   pname = "fwbuilder";
   version = "6.0.0-rc1";
 
   src = fetchFromGitHub {
     owner = "fwbuilder";
     repo = "fwbuilder";
-    rev = "v${version}";
+    tag = "v${finalAttrs.version}";
     hash = "sha256-j5HjGcIqq93Ca9OBqEgSotoSXyw+q6Fqxa3hKk1ctwQ=";
   };
 
···
   nativeBuildInputs = [
     cmake
     ninja
-    wrapQtAppsHook
+    libsForQt5.wrapQtAppsHook
   ];
 
   buildInputs = [
     wayland
     wayland-protocols
-    qtwayland
+    libsForQt5.qtwayland
   ];
 
-  meta = with lib; {
+  meta = {
     description = "GUI Firewall Management Application";
     longDescription = ''
       Firewall Builder is a GUI firewall management application for iptables,
···
       managed from a single UI.
     '';
     homepage = "https://github.com/fwbuilder/fwbuilder";
-    license = licenses.gpl2Only;
-    platforms = platforms.linux;
-    maintainers = [ maintainers.elatov ];
+    license = lib.licenses.gpl2Only;
+    platforms = lib.platforms.linux;
+    maintainers = with lib.maintainers; [ elatov ];
   };
-}
+})

pkgs/top-level/aliases.nix

···
   cargo-information = throw "'cargo-information' has been removed due to being merged upstream into 'cargo'"; # Added 2025-03-09
   cargo-inspect = throw "'cargo-inspect' has been removed due to lack of upstream maintenance. Upstream recommends cargo-expand."; # Added 2025-01-26
   cargo-web = throw "'cargo-web' has been removed due to lack of upstream maintenance"; # Added 2025-01-26
+  cargonode = throw "'cargonode' has been removed due to lack of upstream maintenance"; # Added 2025-06-18
   cassandra_3_0 = throw "'cassandra_3_0' has been removed has it reached end-of-life"; # Added 2025-03-23
   cassandra_3_11 = throw "'cassandra_3_11' has been removed has it reached end-of-life"; # Added 2025-03-23
   cawbird = throw "cawbird has been abandoned upstream and is broken anyways due to Twitter closing its API";

pkgs/top-level/all-packages.nix

···
 
   gp-saml-gui = python3Packages.callPackage ../tools/networking/gp-saml-gui { };
 
-  fwbuilder = libsForQt5.callPackage ../tools/security/fwbuilder { };
-
   inherit (callPackages ../tools/networking/ivpn/default.nix { })
     ivpn
     ivpn-service
···
   };
 
   ufolint = with python3Packages; toPythonApplication ufolint;
-
-  valeronoi = qt6Packages.callPackage ../tools/misc/valeronoi { };
 
   veikk-linux-driver-gui = libsForQt5.callPackage ../tools/misc/veikk-linux-driver-gui { };