nixbot

1these 2 derivations will be built:2  /nix/store/8f5bcc9k9d2fh96d0hf87dqzi1f3h04h-python3-3.13.13-env.drv3  /nix/store/x7hglhwnlmjs8d467a6hkin10445ybwa-pytest-impure.drv4Failed to find a machine for remote build!5derivation: ghfwljvv218bclhvr7d6qg36f2xlj2x2-pytest-impure.drv6required (system, features): (aarch64-linux, [ca-derivations])73 available machines:8(systems, maxjobs, supportedFeatures, mandatoryFeatures)9([aarch64-darwin, x86_64-darwin], 8, [big-parallel, recursive-nix], [])10([i686-linux, x86_64-linux], 128, [big-parallel, kvm, nixos-test, recursive-nix, uid-range], [])11([aarch64-linux], 128, [big-parallel, kvm, nixos-test, recursive-nix, uid-range], [])12building '/nix/store/ghfwljvv218bclhvr7d6qg36f2xlj2x2-pytest-impure.drv'13pytest-impure> tribuchet: building on eliza14pytest-impure> ....FF...........FFFF.F                                                  [100%]15pytest-impure> =================================== FAILURES ===================================16pytest-impure> ___________________ TestFlakeService.test_update_flake_input ___________________17pytest-impure> 18pytest-impure> self = <update_flake_inputs.flake_service.FlakeService object at 0xfffff62223f0>19pytest-impure> input_name = 'flake-utils', flake_file = 'flake.nix'20pytest-impure> work_dir = '/build/tmp2cmlv0fq'21pytest-impure> 22pytest-impure>     def update_flake_input(23pytest-impure>         self,24pytest-impure>         input_name: str,25pytest-impure>         flake_file: str,26pytest-impure>         work_dir: str | None = None,27pytest-impure>     ) -> None:28pytest-impure>         """Update a specific flake input.29pytest-impure>     30pytest-impure>         Args:31pytest-impure>             input_name: Name of the input to update32pytest-impure>             flake_file: Path to the flake file33pytest-impure>             work_dir: Optional working directory to resolve flake file path from34pytest-impure>     35pytest-impure>         """36pytest-impure>         try:37pytest-impure>             logger.info("Updating flake input: %s in %s", input_name, flake_file)38pytest-impure>     39pytest-impure>             # If work_dir is provided, resolve the flake file relative to it40pytest-impure>             absolute_flake_path = Path(work_dir) / flake_file if work_dir else Path(flake_file)41pytest-impure>     42pytest-impure>             flake_dir = absolute_flake_path.parent or Path()43pytest-impure>             absolute_flake_dir = flake_dir.resolve()44pytest-impure>     45pytest-impure>             # Use a shallow URL because worktrees may not have the full history.46pytest-impure>             # For subflakes, nix needs the URL to point to the git root47pytest-impure>             # with a dir= parameter rather than the subdirectory directly.48pytest-impure>             if work_dir:49pytest-impure>                 git_root = Path(work_dir).resolve()50pytest-impure>                 relative_dir = absolute_flake_dir.relative_to(git_root)51pytest-impure>                 flake_url = f"git+file://{git_root}?shallow=1"52pytest-impure>                 if str(relative_dir) != ".":53pytest-impure>                     flake_url += f"&dir={relative_dir}"54pytest-impure>             else:55pytest-impure>                 flake_url = f"git+file://{absolute_flake_dir}?shallow=1"56pytest-impure>     57pytest-impure> >           result = subprocess.run(58pytest-impure>                 [59pytest-impure>                     "nix",60pytest-impure>                     "flake",61pytest-impure>                     "update",62pytest-impure>                     "--flake",63pytest-impure>                     flake_url,64pytest-impure>                     input_name,65pytest-impure>                 ],66pytest-impure>                 cwd=str(flake_dir),67pytest-impure>                 capture_output=True,68pytest-impure>                 text=True,69pytest-impure>                 check=True,70pytest-impure>             )71pytest-impure> 72pytest-impure> src/update_flake_inputs/flake_service.py:191: 73pytest-impure> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 74pytest-impure> 75pytest-impure> input = None, capture_output = True, timeout = None, check = True76pytest-impure> popenargs = (['nix', 'flake', 'update', '--flake', 'git+file:///build/tmp2cmlv0fq?shallow=1', 'flake-utils'],)77pytest-impure> kwargs = {'cwd': '/build/tmp2cmlv0fq', 'stderr': -1, 'stdout': -1, 'text': True}78pytest-impure> process = <Popen: returncode: 1 args: ['nix', 'flake', 'update', '--flake', 'git+file:...>79pytest-impure> stdout = ''80pytest-impure> stderr = "warning: you don't have Internet access; disabling some network-dependent features\nerror:\n       … while updating t...b.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com\n"81pytest-impure> retcode = 182pytest-impure> 83pytest-impure>     def run(*popenargs,84pytest-impure>             input=None, capture_output=False, timeout=None, check=False, **kwargs):85pytest-impure>         """Run command with arguments and return a CompletedProcess instance.86pytest-impure>     87pytest-impure>         The returned instance will have attributes args, returncode, stdout and88pytest-impure>         stderr. By default, stdout and stderr are not captured, and those attributes89pytest-impure>         will be None. Pass stdout=PIPE and/or stderr=PIPE in order to capture them,90pytest-impure>         or pass capture_output=True to capture both.91pytest-impure>     92pytest-impure>         If check is True and the exit code was non-zero, it raises a93pytest-impure>         CalledProcessError. The CalledProcessError object will have the return code94pytest-impure>         in the returncode attribute, and output & stderr attributes if those streams95pytest-impure>         were captured.96pytest-impure>     97pytest-impure>         If timeout (seconds) is given and the process takes too long,98pytest-impure>          a TimeoutExpired exception will be raised.99pytest-impure>     100pytest-impure>         There is an optional argument "input", allowing you to101pytest-impure>         pass bytes or a string to the subprocess's stdin.  If you use this argument102pytest-impure>         you may not also use the Popen constructor's "stdin" argument, as103pytest-impure>         it will be used internally.104pytest-impure>     105pytest-impure>         By default, all communication is in bytes, and therefore any "input" should106pytest-impure>         be bytes, and the stdout and stderr will be bytes. If in text mode, any107pytest-impure>         "input" should be a string, and stdout and stderr will be strings decoded108pytest-impure>         according to locale encoding, or by "encoding" if set. Text mode is109pytest-impure>         triggered by setting any of text, encoding, errors or universal_newlines.110pytest-impure>     111pytest-impure>         The other arguments are the same as for the Popen constructor.112pytest-impure>         """113pytest-impure>         if input is not None:114pytest-impure>             if kwargs.get('stdin') is not None:115pytest-impure>                 raise ValueError('stdin and input arguments may not both be used.')116pytest-impure>             kwargs['stdin'] = PIPE117pytest-impure>     118pytest-impure>         if capture_output:119pytest-impure>             if kwargs.get('stdout') is not None or kwargs.get('stderr') is not None:120pytest-impure>                 raise ValueError('stdout and stderr arguments may not be used '121pytest-impure>                                  'with capture_output.')122pytest-impure>             kwargs['stdout'] = PIPE123pytest-impure>             kwargs['stderr'] = PIPE124pytest-impure>     125pytest-impure>         with Popen(*popenargs, **kwargs) as process:126pytest-impure>             try:127pytest-impure>                 stdout, stderr = process.communicate(input, timeout=timeout)128pytest-impure>             except TimeoutExpired as exc:129pytest-impure>                 process.kill()130pytest-impure>                 if _mswindows:131pytest-impure>                     # Windows accumulates the output in a single blocking132pytest-impure>                     # read() call run on child threads, with the timeout133pytest-impure>                     # being done in a join() on those threads.  communicate()134pytest-impure>                     # _after_ kill() is required to collect that and add it135pytest-impure>                     # to the exception.136pytest-impure>                     exc.stdout, exc.stderr = process.communicate()137pytest-impure>                 else:138pytest-impure>                     # POSIX _communicate already populated the output so139pytest-impure>                     # far into the TimeoutExpired exception.140pytest-impure>                     process.wait()141pytest-impure>                 raise142pytest-impure>             except:  # Including KeyboardInterrupt, communicate handled that.143pytest-impure>                 process.kill()144pytest-impure>                 # We don't call process.wait() as .__exit__ does that for us.145pytest-impure>                 raise146pytest-impure>             retcode = process.poll()147pytest-impure>             if check and retcode:148pytest-impure> >               raise CalledProcessError(retcode, process.args,149pytest-impure>                                          output=stdout, stderr=stderr)150pytest-impure> E               subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/tmp2cmlv0fq?shallow=1', 'flake-utils']' returned non-zero exit status 1.151pytest-impure> 152pytest-impure> /nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py:577: CalledProcessError153pytest-impure> 154pytest-impure> The above exception was the direct cause of the following exception:155pytest-impure> 156pytest-impure> self = <tests.test_flake_service.TestFlakeService object at 0xfffff626ac30>157pytest-impure> flake_service = <update_flake_inputs.flake_service.FlakeService object at 0xfffff62223f0>158pytest-impure> fixtures_path = PosixPath('/build/src/tests/fixtures')159pytest-impure> 160pytest-impure>     @pytest.mark.impure161pytest-impure>     def test_update_flake_input(162pytest-impure>         self,163pytest-impure>         flake_service: FlakeService,164pytest-impure>         fixtures_path: Path,165pytest-impure>     ) -> None:166pytest-impure>         """Test updating a flake input and modifying the lock file."""167pytest-impure>         # Create a temporary directory for the test168pytest-impure>         with tempfile.TemporaryDirectory() as temp_dir:169pytest-impure>             temp_path = Path(temp_dir)170pytest-impure>     171pytest-impure>             # Copy minimal flake to temp directory172pytest-impure>             shutil.copy(173pytest-impure>                 fixtures_path / "minimal" / "flake.nix",174pytest-impure>                 temp_path / "flake.nix",175pytest-impure>             )176pytest-impure>             shutil.copy(177pytest-impure>                 fixtures_path / "minimal" / "flake.lock",178pytest-impure>                 temp_path / "flake.lock",179pytest-impure>             )180pytest-impure>     181pytest-impure>             # Initialize git repo in temp directory182pytest-impure>             subprocess.run(["git", "init"], cwd=temp_path, check=True)183pytest-impure>             subprocess.run(["git", "add", "."], cwd=temp_path, check=True)184pytest-impure>             subprocess.run(185pytest-impure>                 ["git", "commit", "-m", "Initial commit"],186pytest-impure>                 cwd=temp_path,187pytest-impure>                 check=True,188pytest-impure>                 env={189pytest-impure>                     **os.environ,190pytest-impure>                     "GIT_AUTHOR_NAME": "Test User",191pytest-impure>                     "GIT_AUTHOR_EMAIL": "test@example.com",192pytest-impure>                     "GIT_COMMITTER_NAME": "Test User",193pytest-impure>                     "GIT_COMMITTER_EMAIL": "test@example.com",194pytest-impure>                 },195pytest-impure>             )196pytest-impure>     197pytest-impure>             # Get the original lock file content198pytest-impure>             original_lock_content = (temp_path / "flake.lock").read_text()199pytest-impure>             original_lock = json.loads(original_lock_content)200pytest-impure>             original_flake_utils_rev = original_lock["nodes"]["flake-utils"]["locked"]["rev"]201pytest-impure>     202pytest-impure>             # Update flake-utils input203pytest-impure> >           flake_service.update_flake_input("flake-utils", "flake.nix", str(temp_path))204pytest-impure> 205pytest-impure> tests/test_flake_service.py:198: 206pytest-impure> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 207pytest-impure> 208pytest-impure> self = <update_flake_inputs.flake_service.FlakeService object at 0xfffff62223f0>209pytest-impure> input_name = 'flake-utils', flake_file = 'flake.nix'210pytest-impure> work_dir = '/build/tmp2cmlv0fq'211pytest-impure> 212pytest-impure>     def update_flake_input(213pytest-impure>         self,214pytest-impure>         input_name: str,215pytest-impure>         flake_file: str,216pytest-impure>         work_dir: str | None = None,217pytest-impure>     ) -> None:218pytest-impure>         """Update a specific flake input.219pytest-impure>     220pytest-impure>         Args:221pytest-impure>             input_name: Name of the input to update222pytest-impure>             flake_file: Path to the flake file223pytest-impure>             work_dir: Optional working directory to resolve flake file path from224pytest-impure>     225pytest-impure>         """226pytest-impure>         try:227pytest-impure>             logger.info("Updating flake input: %s in %s", input_name, flake_file)228pytest-impure>     229pytest-impure>             # If work_dir is provided, resolve the flake file relative to it230pytest-impure>             absolute_flake_path = Path(work_dir) / flake_file if work_dir else Path(flake_file)231pytest-impure>     232pytest-impure>             flake_dir = absolute_flake_path.parent or Path()233pytest-impure>             absolute_flake_dir = flake_dir.resolve()234pytest-impure>     235pytest-impure>             # Use a shallow URL because worktrees may not have the full history.236pytest-impure>             # For subflakes, nix needs the URL to point to the git root237pytest-impure>             # with a dir= parameter rather than the subdirectory directly.238pytest-impure>             if work_dir:239pytest-impure>                 git_root = Path(work_dir).resolve()240pytest-impure>                 relative_dir = absolute_flake_dir.relative_to(git_root)241pytest-impure>                 flake_url = f"git+file://{git_root}?shallow=1"242pytest-impure>                 if str(relative_dir) != ".":243pytest-impure>                     flake_url += f"&dir={relative_dir}"244pytest-impure>             else:245pytest-impure>                 flake_url = f"git+file://{absolute_flake_dir}?shallow=1"246pytest-impure>     247pytest-impure>             result = subprocess.run(248pytest-impure>                 [249pytest-impure>                     "nix",250pytest-impure>                     "flake",251pytest-impure>                     "update",252pytest-impure>                     "--flake",253pytest-impure>                     flake_url,254pytest-impure>                     input_name,255pytest-impure>                 ],256pytest-impure>                 cwd=str(flake_dir),257pytest-impure>                 capture_output=True,258pytest-impure>                 text=True,259pytest-impure>                 check=True,260pytest-impure>             )261pytest-impure>     262pytest-impure>             # Check if there was a warning about non-existent input263pytest-impure>             if result.stderr and "does not match any input" in result.stderr:264pytest-impure>                 logger.warning(265pytest-impure>                     "Failed to update input %s in %s: %s",266pytest-impure>                     input_name,267pytest-impure>                     flake_file,268pytest-impure>                     result.stderr.strip(),269pytest-impure>                 )270pytest-impure>     271pytest-impure>             logger.info(272pytest-impure>                 "Successfully updated flake input: %s in %s",273pytest-impure>                 input_name,274pytest-impure>                 flake_file,275pytest-impure>             )276pytest-impure>         except subprocess.CalledProcessError as e:277pytest-impure>             stderr_output = e.stderr.strip() if e.stderr else "No stderr output"278pytest-impure>             stdout_output = e.stdout.strip() if e.stdout else "No stdout output"279pytest-impure>             logger.exception(280pytest-impure>                 "Failed to update flake input %s in %s. Exit code: %d\nStdout: %s\nStderr: %s",281pytest-impure>                 input_name,282pytest-impure>                 flake_file,283pytest-impure>                 e.returncode,284pytest-impure>                 stdout_output,285pytest-impure>                 stderr_output,286pytest-impure>             )287pytest-impure>             msg = (288pytest-impure>                 f"Failed to update flake input {input_name} in {flake_file}: {e}\n"289pytest-impure>                 f"Stderr: {stderr_output}"290pytest-impure>             )291pytest-impure> >           raise FlakeServiceError(msg) from e292pytest-impure> E           update_flake_inputs.exceptions.FlakeServiceError: Failed to update flake input flake-utils in flake.nix: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/tmp2cmlv0fq?shallow=1', 'flake-utils']' returned non-zero exit status 1.293pytest-impure> E           Stderr: warning: you don't have Internet access; disabling some network-dependent features294pytest-impure> E           error:295pytest-impure> E                  … while updating the lock file of flake 'git+file:///build/tmp2cmlv0fq?ref=refs/heads/master&rev=c612154fdd8ea6da984559356ee0f13da2faa699&shallow=1'296pytest-impure> E           297pytest-impure> E                  … while updating the flake input 'flake-utils'298pytest-impure> E           299pytest-impure> E                  … while fetching the input 'github:numtide/flake-utils'300pytest-impure> E           301pytest-impure> E                  error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com302pytest-impure> 303pytest-impure> src/update_flake_inputs/flake_service.py:235: FlakeServiceError304pytest-impure> ----------------------------- Captured stdout call -----------------------------305pytest-impure> Initialized empty Git repository in /build/tmp2cmlv0fq/.git/306pytest-impure> [master (root-commit) c612154] Initial commit307pytest-impure>  2 files changed, 55 insertions(+)308pytest-impure>  create mode 100644 flake.lock309pytest-impure>  create mode 100644 flake.nix310pytest-impure> ----------------------------- Captured stderr call -----------------------------311pytest-impure> hint: Using 'master' as the name for the initial branch. This default branch name312pytest-impure> hint: will change to "main" in Git 3.0. To configure the initial branch name313pytest-impure> hint: to use in all of your new repositories, which will suppress this warning,314pytest-impure> hint: call:315pytest-impure> hint:316pytest-impure> hint: 	git config --global init.defaultBranch <name>317pytest-impure> hint:318pytest-impure> hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and319pytest-impure> hint: 'development'. The just-created branch can be renamed via this command:320pytest-impure> hint:321pytest-impure> hint: 	git branch -m <name>322pytest-impure> hint:323pytest-impure> hint: Disable this message with "git config set advice.defaultBranchName false"324pytest-impure> ------------------------------ Captured log call -------------------------------325pytest-impure> ERROR    update_flake_inputs.flake_service:flake_service.py:223 Failed to update flake input flake-utils in flake.nix. Exit code: 1326pytest-impure> Stdout: No stdout output327pytest-impure> Stderr: warning: you don't have Internet access; disabling some network-dependent features328pytest-impure> error:329pytest-impure>        … while updating the lock file of flake 'git+file:///build/tmp2cmlv0fq?ref=refs/heads/master&rev=c612154fdd8ea6da984559356ee0f13da2faa699&shallow=1'330pytest-impure> 331pytest-impure>        … while updating the flake input 'flake-utils'332pytest-impure> 333pytest-impure>        … while fetching the input 'github:numtide/flake-utils'334pytest-impure> 335pytest-impure>        error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com336pytest-impure> Traceback (most recent call last):337pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 191, in update_flake_input338pytest-impure>     result = subprocess.run(339pytest-impure>         [340pytest-impure>     ...<10 lines>...341pytest-impure>         check=True,342pytest-impure>     )343pytest-impure>   File "/nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py", line 577, in run344pytest-impure>     raise CalledProcessError(retcode, process.args,345pytest-impure>                              output=stdout, stderr=stderr)346pytest-impure> subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/tmp2cmlv0fq?shallow=1', 'flake-utils']' returned non-zero exit status 1.347pytest-impure> _________________ TestFlakeService.test_update_subflake_input __________________348pytest-impure> 349pytest-impure> self = <update_flake_inputs.flake_service.FlakeService object at 0xfffff5edbbf0>350pytest-impure> input_name = 'flake-utils', flake_file = 'flake.nix'351pytest-impure> work_dir = '/build/tmprfllca7h'352pytest-impure> 353pytest-impure>     def update_flake_input(354pytest-impure>         self,355pytest-impure>         input_name: str,356pytest-impure>         flake_file: str,357pytest-impure>         work_dir: str | None = None,358pytest-impure>     ) -> None:359pytest-impure>         """Update a specific flake input.360pytest-impure>     361pytest-impure>         Args:362pytest-impure>             input_name: Name of the input to update363pytest-impure>             flake_file: Path to the flake file364pytest-impure>             work_dir: Optional working directory to resolve flake file path from365pytest-impure>     366pytest-impure>         """367pytest-impure>         try:368pytest-impure>             logger.info("Updating flake input: %s in %s", input_name, flake_file)369pytest-impure>     370pytest-impure>             # If work_dir is provided, resolve the flake file relative to it371pytest-impure>             absolute_flake_path = Path(work_dir) / flake_file if work_dir else Path(flake_file)372pytest-impure>     373pytest-impure>             flake_dir = absolute_flake_path.parent or Path()374pytest-impure>             absolute_flake_dir = flake_dir.resolve()375pytest-impure>     376pytest-impure>             # Use a shallow URL because worktrees may not have the full history.377pytest-impure>             # For subflakes, nix needs the URL to point to the git root378pytest-impure>             # with a dir= parameter rather than the subdirectory directly.379pytest-impure>             if work_dir:380pytest-impure>                 git_root = Path(work_dir).resolve()381pytest-impure>                 relative_dir = absolute_flake_dir.relative_to(git_root)382pytest-impure>                 flake_url = f"git+file://{git_root}?shallow=1"383pytest-impure>                 if str(relative_dir) != ".":384pytest-impure>                     flake_url += f"&dir={relative_dir}"385pytest-impure>             else:386pytest-impure>                 flake_url = f"git+file://{absolute_flake_dir}?shallow=1"387pytest-impure>     388pytest-impure> >           result = subprocess.run(389pytest-impure>                 [390pytest-impure>                     "nix",391pytest-impure>                     "flake",392pytest-impure>                     "update",393pytest-impure>                     "--flake",394pytest-impure>                     flake_url,395pytest-impure>                     input_name,396pytest-impure>                 ],397pytest-impure>                 cwd=str(flake_dir),398pytest-impure>                 capture_output=True,399pytest-impure>                 text=True,400pytest-impure>                 check=True,401pytest-impure>             )402pytest-impure> 403pytest-impure> src/update_flake_inputs/flake_service.py:191: 404pytest-impure> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 405pytest-impure> 406pytest-impure> input = None, capture_output = True, timeout = None, check = True407pytest-impure> popenargs = (['nix', 'flake', 'update', '--flake', 'git+file:///build/tmprfllca7h?shallow=1', 'flake-utils'],)408pytest-impure> kwargs = {'cwd': '/build/tmprfllca7h', 'stderr': -1, 'stdout': -1, 'text': True}409pytest-impure> process = <Popen: returncode: 1 args: ['nix', 'flake', 'update', '--flake', 'git+file:...>410pytest-impure> stdout = ''411pytest-impure> stderr = "warning: you don't have Internet access; disabling some network-dependent features\nerror:\n       … while updating t...b.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com\n"412pytest-impure> retcode = 1413pytest-impure> 414pytest-impure>     def run(*popenargs,415pytest-impure>             input=None, capture_output=False, timeout=None, check=False, **kwargs):416pytest-impure>         """Run command with arguments and return a CompletedProcess instance.417pytest-impure>     418pytest-impure>         The returned instance will have attributes args, returncode, stdout and419pytest-impure>         stderr. By default, stdout and stderr are not captured, and those attributes420pytest-impure>         will be None. Pass stdout=PIPE and/or stderr=PIPE in order to capture them,421pytest-impure>         or pass capture_output=True to capture both.422pytest-impure>     423pytest-impure>         If check is True and the exit code was non-zero, it raises a424pytest-impure>         CalledProcessError. The CalledProcessError object will have the return code425pytest-impure>         in the returncode attribute, and output & stderr attributes if those streams426pytest-impure>         were captured.427pytest-impure>     428pytest-impure>         If timeout (seconds) is given and the process takes too long,429pytest-impure>          a TimeoutExpired exception will be raised.430pytest-impure>     431pytest-impure>         There is an optional argument "input", allowing you to432pytest-impure>         pass bytes or a string to the subprocess's stdin.  If you use this argument433pytest-impure>         you may not also use the Popen constructor's "stdin" argument, as434pytest-impure>         it will be used internally.435pytest-impure>     436pytest-impure>         By default, all communication is in bytes, and therefore any "input" should437pytest-impure>         be bytes, and the stdout and stderr will be bytes. If in text mode, any438pytest-impure>         "input" should be a string, and stdout and stderr will be strings decoded439pytest-impure>         according to locale encoding, or by "encoding" if set. Text mode is440pytest-impure>         triggered by setting any of text, encoding, errors or universal_newlines.441pytest-impure>     442pytest-impure>         The other arguments are the same as for the Popen constructor.443pytest-impure>         """444pytest-impure>         if input is not None:445pytest-impure>             if kwargs.get('stdin') is not None:446pytest-impure>                 raise ValueError('stdin and input arguments may not both be used.')447pytest-impure>             kwargs['stdin'] = PIPE448pytest-impure>     449pytest-impure>         if capture_output:450pytest-impure>             if kwargs.get('stdout') is not None or kwargs.get('stderr') is not None:451pytest-impure>                 raise ValueError('stdout and stderr arguments may not be used '452pytest-impure>                                  'with capture_output.')453pytest-impure>             kwargs['stdout'] = PIPE454pytest-impure>             kwargs['stderr'] = PIPE455pytest-impure>     456pytest-impure>         with Popen(*popenargs, **kwargs) as process:457pytest-impure>             try:458pytest-impure>                 stdout, stderr = process.communicate(input, timeout=timeout)459pytest-impure>             except TimeoutExpired as exc:460pytest-impure>                 process.kill()461pytest-impure>                 if _mswindows:462pytest-impure>                     # Windows accumulates the output in a single blocking463pytest-impure>                     # read() call run on child threads, with the timeout464pytest-impure>                     # being done in a join() on those threads.  communicate()465pytest-impure>                     # _after_ kill() is required to collect that and add it466pytest-impure>                     # to the exception.467pytest-impure>                     exc.stdout, exc.stderr = process.communicate()468pytest-impure>                 else:469pytest-impure>                     # POSIX _communicate already populated the output so470pytest-impure>                     # far into the TimeoutExpired exception.471pytest-impure>                     process.wait()472pytest-impure>                 raise473pytest-impure>             except:  # Including KeyboardInterrupt, communicate handled that.474pytest-impure>                 process.kill()475pytest-impure>                 # We don't call process.wait() as .__exit__ does that for us.476pytest-impure>                 raise477pytest-impure>             retcode = process.poll()478pytest-impure>             if check and retcode:479pytest-impure> >               raise CalledProcessError(retcode, process.args,480pytest-impure>                                          output=stdout, stderr=stderr)481pytest-impure> E               subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/tmprfllca7h?shallow=1', 'flake-utils']' returned non-zero exit status 1.482pytest-impure> 483pytest-impure> /nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py:577: CalledProcessError484pytest-impure> 485pytest-impure> The above exception was the direct cause of the following exception:486pytest-impure> 487pytest-impure> self = <tests.test_flake_service.TestFlakeService object at 0xfffff62818c0>488pytest-impure> flake_service = <update_flake_inputs.flake_service.FlakeService object at 0xfffff5edbbf0>489pytest-impure> fixtures_path = PosixPath('/build/src/tests/fixtures')490pytest-impure> 491pytest-impure>     @pytest.mark.impure492pytest-impure>     def test_update_subflake_input(493pytest-impure>         self,494pytest-impure>         flake_service: FlakeService,495pytest-impure>         fixtures_path: Path,496pytest-impure>     ) -> None:497pytest-impure>         """Test updating a flake input in a subdirectory (subflake)."""498pytest-impure>         with tempfile.TemporaryDirectory() as temp_dir:499pytest-impure>             temp_path = Path(temp_dir)500pytest-impure>     501pytest-impure>             # Copy minimal flake to a subdirectory502pytest-impure>             sub_dir = temp_path / "sub"503pytest-impure>             sub_dir.mkdir()504pytest-impure>             shutil.copy(505pytest-impure>                 fixtures_path / "minimal" / "flake.nix",506pytest-impure>                 sub_dir / "flake.nix",507pytest-impure>             )508pytest-impure>             shutil.copy(509pytest-impure>                 fixtures_path / "minimal" / "flake.lock",510pytest-impure>                 sub_dir / "flake.lock",511pytest-impure>             )512pytest-impure>     513pytest-impure>             # Copy minimal flake to root514pytest-impure>             shutil.copy(515pytest-impure>                 fixtures_path / "minimal" / "flake.nix",516pytest-impure>                 temp_path / "flake.nix",517pytest-impure>             )518pytest-impure>             shutil.copy(519pytest-impure>                 fixtures_path / "minimal" / "flake.lock",520pytest-impure>                 temp_path / "flake.lock",521pytest-impure>             )522pytest-impure>     523pytest-impure>             # Initialize git repo in temp directory524pytest-impure>             subprocess.run(["git", "init"], cwd=temp_path, check=True)525pytest-impure>             subprocess.run(["git", "add", "."], cwd=temp_path, check=True)526pytest-impure>             subprocess.run(527pytest-impure>                 ["git", "commit", "-m", "Initial commit"],528pytest-impure>                 cwd=temp_path,529pytest-impure>                 check=True,530pytest-impure>                 env={531pytest-impure>                     **os.environ,532pytest-impure>                     "GIT_AUTHOR_NAME": "Test User",533pytest-impure>                     "GIT_AUTHOR_EMAIL": "test@example.com",534pytest-impure>                     "GIT_COMMITTER_NAME": "Test User",535pytest-impure>                     "GIT_COMMITTER_EMAIL": "test@example.com",536pytest-impure>                 },537pytest-impure>             )538pytest-impure>     539pytest-impure>             original_root_lock = json.loads((temp_path / "flake.lock").read_text())540pytest-impure>             original_root_rev = original_root_lock["nodes"]["flake-utils"]["locked"]["rev"]541pytest-impure>     542pytest-impure>             original_sub_lock = json.loads((sub_dir / "flake.lock").read_text())543pytest-impure>             original_sub_rev = original_sub_lock["nodes"]["flake-utils"]["locked"]["rev"]544pytest-impure>     545pytest-impure>             # Update flake-utils in the root flake546pytest-impure> >           flake_service.update_flake_input("flake-utils", "flake.nix", str(temp_path))547pytest-impure> 548pytest-impure> tests/test_flake_service.py:272: 549pytest-impure> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 550pytest-impure> 551pytest-impure> self = <update_flake_inputs.flake_service.FlakeService object at 0xfffff5edbbf0>552pytest-impure> input_name = 'flake-utils', flake_file = 'flake.nix'553pytest-impure> work_dir = '/build/tmprfllca7h'554pytest-impure> 555pytest-impure>     def update_flake_input(556pytest-impure>         self,557pytest-impure>         input_name: str,558pytest-impure>         flake_file: str,559pytest-impure>         work_dir: str | None = None,560pytest-impure>     ) -> None:561pytest-impure>         """Update a specific flake input.562pytest-impure>     563pytest-impure>         Args:564pytest-impure>             input_name: Name of the input to update565pytest-impure>             flake_file: Path to the flake file566pytest-impure>             work_dir: Optional working directory to resolve flake file path from567pytest-impure>     568pytest-impure>         """569pytest-impure>         try:570pytest-impure>             logger.info("Updating flake input: %s in %s", input_name, flake_file)571pytest-impure>     572pytest-impure>             # If work_dir is provided, resolve the flake file relative to it573pytest-impure>             absolute_flake_path = Path(work_dir) / flake_file if work_dir else Path(flake_file)574pytest-impure>     575pytest-impure>             flake_dir = absolute_flake_path.parent or Path()576pytest-impure>             absolute_flake_dir = flake_dir.resolve()577pytest-impure>     578pytest-impure>             # Use a shallow URL because worktrees may not have the full history.579pytest-impure>             # For subflakes, nix needs the URL to point to the git root580pytest-impure>             # with a dir= parameter rather than the subdirectory directly.581pytest-impure>             if work_dir:582pytest-impure>                 git_root = Path(work_dir).resolve()583pytest-impure>                 relative_dir = absolute_flake_dir.relative_to(git_root)584pytest-impure>                 flake_url = f"git+file://{git_root}?shallow=1"585pytest-impure>                 if str(relative_dir) != ".":586pytest-impure>                     flake_url += f"&dir={relative_dir}"587pytest-impure>             else:588pytest-impure>                 flake_url = f"git+file://{absolute_flake_dir}?shallow=1"589pytest-impure>     590pytest-impure>             result = subprocess.run(591pytest-impure>                 [592pytest-impure>                     "nix",593pytest-impure>                     "flake",594pytest-impure>                     "update",595pytest-impure>                     "--flake",596pytest-impure>                     flake_url,597pytest-impure>                     input_name,598pytest-impure>                 ],599pytest-impure>                 cwd=str(flake_dir),600pytest-impure>                 capture_output=True,601pytest-impure>                 text=True,602pytest-impure>                 check=True,603pytest-impure>             )604pytest-impure>     605pytest-impure>             # Check if there was a warning about non-existent input606pytest-impure>             if result.stderr and "does not match any input" in result.stderr:607pytest-impure>                 logger.warning(608pytest-impure>                     "Failed to update input %s in %s: %s",609pytest-impure>                     input_name,610pytest-impure>                     flake_file,611pytest-impure>                     result.stderr.strip(),612pytest-impure>                 )613pytest-impure>     614pytest-impure>             logger.info(615pytest-impure>                 "Successfully updated flake input: %s in %s",616pytest-impure>                 input_name,617pytest-impure>                 flake_file,618pytest-impure>             )619pytest-impure>         except subprocess.CalledProcessError as e:620pytest-impure>             stderr_output = e.stderr.strip() if e.stderr else "No stderr output"621pytest-impure>             stdout_output = e.stdout.strip() if e.stdout else "No stdout output"622pytest-impure>             logger.exception(623pytest-impure>                 "Failed to update flake input %s in %s. Exit code: %d\nStdout: %s\nStderr: %s",624pytest-impure>                 input_name,625pytest-impure>                 flake_file,626pytest-impure>                 e.returncode,627pytest-impure>                 stdout_output,628pytest-impure>                 stderr_output,629pytest-impure>             )630pytest-impure>             msg = (631pytest-impure>                 f"Failed to update flake input {input_name} in {flake_file}: {e}\n"632pytest-impure>                 f"Stderr: {stderr_output}"633pytest-impure>             )634pytest-impure> >           raise FlakeServiceError(msg) from e635pytest-impure> E           update_flake_inputs.exceptions.FlakeServiceError: Failed to update flake input flake-utils in flake.nix: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/tmprfllca7h?shallow=1', 'flake-utils']' returned non-zero exit status 1.636pytest-impure> E           Stderr: warning: you don't have Internet access; disabling some network-dependent features637pytest-impure> E           error:638pytest-impure> E                  … while updating the lock file of flake 'git+file:///build/tmprfllca7h?ref=refs/heads/master&rev=d2cdb1d9198fb7a86ced6dfb30bc1fa04fce58a8&shallow=1'639pytest-impure> E           640pytest-impure> E                  … while updating the flake input 'flake-utils'641pytest-impure> E           642pytest-impure> E                  … while fetching the input 'github:numtide/flake-utils'643pytest-impure> E           644pytest-impure> E                  error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com645pytest-impure> 646pytest-impure> src/update_flake_inputs/flake_service.py:235: FlakeServiceError647pytest-impure> ----------------------------- Captured stdout call -----------------------------648pytest-impure> Initialized empty Git repository in /build/tmprfllca7h/.git/649pytest-impure> [master (root-commit) d2cdb1d] Initial commit650pytest-impure>  4 files changed, 110 insertions(+)651pytest-impure>  create mode 100644 flake.lock652pytest-impure>  create mode 100644 flake.nix653pytest-impure>  create mode 100644 sub/flake.lock654pytest-impure>  create mode 100644 sub/flake.nix655pytest-impure> ----------------------------- Captured stderr call -----------------------------656pytest-impure> hint: Using 'master' as the name for the initial branch. This default branch name657pytest-impure> hint: will change to "main" in Git 3.0. To configure the initial branch name658pytest-impure> hint: to use in all of your new repositories, which will suppress this warning,659pytest-impure> hint: call:660pytest-impure> hint:661pytest-impure> hint: 	git config --global init.defaultBranch <name>662pytest-impure> hint:663pytest-impure> hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and664pytest-impure> hint: 'development'. The just-created branch can be renamed via this command:665pytest-impure> hint:666pytest-impure> hint: 	git branch -m <name>667pytest-impure> hint:668pytest-impure> hint: Disable this message with "git config set advice.defaultBranchName false"669pytest-impure> ------------------------------ Captured log call -------------------------------670pytest-impure> ERROR    update_flake_inputs.flake_service:flake_service.py:223 Failed to update flake input flake-utils in flake.nix. Exit code: 1671pytest-impure> Stdout: No stdout output672pytest-impure> Stderr: warning: you don't have Internet access; disabling some network-dependent features673pytest-impure> error:674pytest-impure>        … while updating the lock file of flake 'git+file:///build/tmprfllca7h?ref=refs/heads/master&rev=d2cdb1d9198fb7a86ced6dfb30bc1fa04fce58a8&shallow=1'675pytest-impure> 676pytest-impure>        … while updating the flake input 'flake-utils'677pytest-impure> 678pytest-impure>        … while fetching the input 'github:numtide/flake-utils'679pytest-impure> 680pytest-impure>        error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com681pytest-impure> Traceback (most recent call last):682pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 191, in update_flake_input683pytest-impure>     result = subprocess.run(684pytest-impure>         [685pytest-impure>     ...<10 lines>...686pytest-impure>         check=True,687pytest-impure>     )688pytest-impure>   File "/nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py", line 577, in run689pytest-impure>     raise CalledProcessError(retcode, process.args,690pytest-impure>                              output=stdout, stderr=stderr)691pytest-impure> subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/tmprfllca7h?shallow=1', 'flake-utils']' returned non-zero exit status 1.692pytest-impure> ___________ TestProcessFlakeUpdates.test_with_updatable_flake_input ____________693pytest-impure> 694pytest-impure> self = <tests.test_process_flake_updates.TestProcessFlakeUpdates object at 0xfffff5eb11d0>695pytest-impure> tmp_path = PosixPath('/build/pytest-of-nixbld/pytest-0/test_with_updatable_flake_inpu0')696pytest-impure> fixtures_path = PosixPath('/build/src/tests/fixtures')697pytest-impure> 698pytest-impure>         @pytest.mark.impure699pytest-impure>         def test_with_updatable_flake_input(700pytest-impure>             self,701pytest-impure>             tmp_path: Path,702pytest-impure>             fixtures_path: Path,703pytest-impure>         ) -> None:704pytest-impure>             """Test PR creation when flake input has available updates."""705pytest-impure>             # Create a flake with flake-utils that can be updated706pytest-impure>             flake_content = """{707pytest-impure>       inputs = {708pytest-impure>         flake-utils.url = "github:numtide/flake-utils";709pytest-impure>       };710pytest-impure>     711pytest-impure>       outputs = { self, flake-utils }: {712pytest-impure>         # Test flake with updatable input713pytest-impure>       };714pytest-impure>     }"""715pytest-impure>     716pytest-impure>             (tmp_path / "flake.nix").write_text(flake_content)717pytest-impure>     718pytest-impure>             # Copy old lock file from minimal fixture719pytest-impure>             shutil.copy(720pytest-impure>                 fixtures_path / "minimal" / "flake.lock",721pytest-impure>                 tmp_path / "flake.lock",722pytest-impure>             )723pytest-impure>     724pytest-impure>             _setup_git_repo(tmp_path)725pytest-impure>     726pytest-impure>             # Change to test directory727pytest-impure>             original_cwd = Path.cwd()728pytest-impure>             os.chdir(tmp_path)729pytest-impure>     730pytest-impure>             try:731pytest-impure>                 # Create test services732pytest-impure>                 flake_service = FlakeService()733pytest-impure>                 test_gitea_service = MockGiteaService()734pytest-impure>     735pytest-impure>                 # Process updates736pytest-impure> >               process_flake_updates(737pytest-impure>                     flake_service,738pytest-impure>                     test_gitea_service,739pytest-impure>                     "",740pytest-impure>                     "main",741pytest-impure>                     "",742pytest-impure>                     auto_merge=False,743pytest-impure>                 )744pytest-impure> 745pytest-impure> tests/test_process_flake_updates.py:222: 746pytest-impure> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 747pytest-impure> 748pytest-impure> flake_service = <update_flake_inputs.flake_service.FlakeService object at 0xfffff5e3a850>749pytest-impure> gitea_service = MockGiteaService(api_url='https://gitea.example.com', token='test-token', owner='test-owner', repo='test-repo', git_au...tions[bot]', git_committer_email='gitea-actions[bot]@noreply.gitea.io', merge_style='default', pr_creation_attempts=[])750pytest-impure> exclude_patterns = '', base_branch = 'main', branch_suffix = ''751pytest-impure> 752pytest-impure>     def process_flake_updates(  # noqa: PLR0913753pytest-impure>         flake_service: FlakeService,754pytest-impure>         gitea_service: GiteaService,755pytest-impure>         exclude_patterns: str,756pytest-impure>         base_branch: str,757pytest-impure>         branch_suffix: str,758pytest-impure>         *,759pytest-impure>         auto_merge: bool,760pytest-impure>     ) -> None:761pytest-impure>         """Process all flake updates.762pytest-impure>     763pytest-impure>         Args:764pytest-impure>             flake_service: Flake service instance765pytest-impure>             gitea_service: Gitea service instance766pytest-impure>             exclude_patterns: Patterns to exclude767pytest-impure>             base_branch: Base branch for PRs768pytest-impure>             branch_suffix: Optional suffix to append to branch names769pytest-impure>             auto_merge: Whether to automatically merge PRs770pytest-impure>     771pytest-impure>         """772pytest-impure>         # Discover flake files773pytest-impure>         flakes = flake_service.discover_flake_files(exclude_patterns)774pytest-impure>         if not flakes:775pytest-impure>             logger.info("No flake files found")776pytest-impure>             return777pytest-impure>     778pytest-impure>         logger.info("Found %d flake files to process", len(flakes))779pytest-impure>     780pytest-impure>         failed_inputs: list[str] = []781pytest-impure>     782pytest-impure>         # Process each flake783pytest-impure>         for flake in flakes:784pytest-impure>             logger.info("Processing flake: %s", flake.file_path)785pytest-impure>             logger.info("Inputs to update: %s", ", ".join(flake.inputs))786pytest-impure>     787pytest-impure>             # Don't include '.' for root directory788pytest-impure>             parent_path = Path(flake.file_path).parent789pytest-impure>             parent_suffix = "" if parent_path == Path() else f" in {parent_path}"790pytest-impure>             parent_branch = "" if parent_path == Path() else f"-{parent_path}"791pytest-impure>             suffix = branch_suffix.strip().replace("/", "-").strip("-")792pytest-impure>     793pytest-impure>             # Update each input794pytest-impure>             for input_name in flake.inputs:795pytest-impure>                 try:796pytest-impure>                     branch_name = f"update{parent_branch}-{input_name}"797pytest-impure>                     branch_name = branch_name.replace("/", "-").strip("-")798pytest-impure>                     if suffix:799pytest-impure>                         branch_name = f"{branch_name}-{suffix}"800pytest-impure>     801pytest-impure>                     logger.info(802pytest-impure>                         "Updating input %s in %s (branch: %s)",803pytest-impure>                         input_name,804pytest-impure>                         flake.file_path,805pytest-impure>                         branch_name,806pytest-impure>                     )807pytest-impure>     808pytest-impure>                     # Create worktree and update input809pytest-impure>                     with gitea_service.worktree(branch_name, base_branch) as worktree_path:810pytest-impure>                         # Update the input811pytest-impure>                         flake_service.update_flake_input(812pytest-impure>                             input_name,813pytest-impure>                             flake.file_path,814pytest-impure>                             str(worktree_path),815pytest-impure>                         )816pytest-impure>     817pytest-impure>                         # Commit changes818pytest-impure>                         commit_message = f"Update {input_name}{parent_suffix}"819pytest-impure>                         if gitea_service.commit_changes(820pytest-impure>                             branch_name,821pytest-impure>                             commit_message,822pytest-impure>                             worktree_path,823pytest-impure>                         ):824pytest-impure>                             # Create pull request825pytest-impure>                             pr_title = commit_message826pytest-impure>                             pr_body = (827pytest-impure>                                 f"This PR updates the `{input_name}` input "828pytest-impure>                                 f"in `{flake.file_path}`.\n\n"829pytest-impure>                                 "Generated by update-flake-inputs action."830pytest-impure>                             )831pytest-impure>                             gitea_service.create_pull_request(832pytest-impure>                                 branch_name,833pytest-impure>                                 base_branch,834pytest-impure>                                 pr_title,835pytest-impure>                                 pr_body,836pytest-impure>                                 auto_merge=auto_merge,837pytest-impure>                             )838pytest-impure>                         else:839pytest-impure>                             logger.info(840pytest-impure>                                 "No changes for input %s in %s",841pytest-impure>                                 input_name,842pytest-impure>                                 flake.file_path,843pytest-impure>                             )844pytest-impure>                             gitea_service.delete_branch(branch_name)845pytest-impure>     846pytest-impure>                 except Exception:847pytest-impure>                     logger.exception(848pytest-impure>                         "Failed to update input %s in %s",849pytest-impure>                         input_name,850pytest-impure>                         flake.file_path,851pytest-impure>                     )852pytest-impure>                     failed_inputs.append(f"{input_name} in {flake.file_path}")853pytest-impure>     854pytest-impure>         if failed_inputs:855pytest-impure>             msg = f"Failed to process {len(failed_inputs)} input(s): {', '.join(failed_inputs)}"856pytest-impure> >           raise UpdateFlakeInputsError(msg)857pytest-impure> E           update_flake_inputs.exceptions.UpdateFlakeInputsError: Failed to process 1 input(s): flake-utils in flake.nix858pytest-impure> 859pytest-impure> src/update_flake_inputs/cli.py:268: UpdateFlakeInputsError860pytest-impure> ----------------------------- Captured stdout call -----------------------------861pytest-impure> Initialized empty Git repository in /build/pytest-of-nixbld/pytest-0/test_with_updatable_flake_inpu0/.git/862pytest-impure> [main (root-commit) 6a74b3a] Initial commit863pytest-impure>  2 files changed, 53 insertions(+)864pytest-impure>  create mode 100644 flake.lock865pytest-impure>  create mode 100644 flake.nix866pytest-impure> Initialized empty Git repository in /build/pytest-of-nixbld/pytest-0/remote-test_with_updatable_flake_inpu0.git/867pytest-impure> branch 'main' set up to track 'origin/main'.868pytest-impure> branch 'update-flake-utils' set up to track 'origin/main'.869pytest-impure> HEAD is now at 6a74b3a Initial commit870pytest-impure> ----------------------------- Captured stderr call -----------------------------871pytest-impure> hint: Using 'master' as the name for the initial branch. This default branch name872pytest-impure> hint: will change to "main" in Git 3.0. To configure the initial branch name873pytest-impure> hint: to use in all of your new repositories, which will suppress this warning,874pytest-impure> hint: call:875pytest-impure> hint:876pytest-impure> hint: 	git config --global init.defaultBranch <name>877pytest-impure> hint:878pytest-impure> hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and879pytest-impure> hint: 'development'. The just-created branch can be renamed via this command:880pytest-impure> hint:881pytest-impure> hint: 	git branch -m <name>882pytest-impure> hint:883pytest-impure> hint: Disable this message with "git config set advice.defaultBranchName false"884pytest-impure> To /build/pytest-of-nixbld/pytest-0/remote-test_with_updatable_flake_inpu0.git885pytest-impure>  * [new branch]      main -> main886pytest-impure> From /build/pytest-of-nixbld/pytest-0/remote-test_with_updatable_flake_inpu0887pytest-impure>  * branch            main       -> FETCH_HEAD888pytest-impure> Preparing worktree (new branch 'update-flake-utils')889pytest-impure> ------------------------------ Captured log call -------------------------------890pytest-impure> ERROR    update_flake_inputs.flake_service:flake_service.py:223 Failed to update flake input flake-utils in flake.nix. Exit code: 1891pytest-impure> Stdout: No stdout output892pytest-impure> Stderr: warning: you don't have Internet access; disabling some network-dependent features893pytest-impure> error:894pytest-impure>        … while updating the lock file of flake 'git+file:///build/flake-update-0je849kf/update-flake-utils?ref=refs/heads/update-flake-utils&rev=6a74b3a71186db3178663c227e447cc32eaf4080&shallow=1'895pytest-impure> 896pytest-impure>        … while updating the flake input 'flake-utils'897pytest-impure> 898pytest-impure>        … while fetching the input 'github:numtide/flake-utils'899pytest-impure> 900pytest-impure>        error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com901pytest-impure> Traceback (most recent call last):902pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 191, in update_flake_input903pytest-impure>     result = subprocess.run(904pytest-impure>         [905pytest-impure>     ...<10 lines>...906pytest-impure>         check=True,907pytest-impure>     )908pytest-impure>   File "/nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py", line 577, in run909pytest-impure>     raise CalledProcessError(retcode, process.args,910pytest-impure>                              output=stdout, stderr=stderr)911pytest-impure> subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-0je849kf/update-flake-utils?shallow=1', 'flake-utils']' returned non-zero exit status 1.912pytest-impure> ERROR    update_flake_inputs.cli:cli.py:259 Failed to update input flake-utils in flake.nix913pytest-impure> Traceback (most recent call last):914pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 191, in update_flake_input915pytest-impure>     result = subprocess.run(916pytest-impure>         [917pytest-impure>     ...<10 lines>...918pytest-impure>         check=True,919pytest-impure>     )920pytest-impure>   File "/nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py", line 577, in run921pytest-impure>     raise CalledProcessError(retcode, process.args,922pytest-impure>                              output=stdout, stderr=stderr)923pytest-impure> subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-0je849kf/update-flake-utils?shallow=1', 'flake-utils']' returned non-zero exit status 1.924pytest-impure> 925pytest-impure> The above exception was the direct cause of the following exception:926pytest-impure> 927pytest-impure> Traceback (most recent call last):928pytest-impure>   File "/build/src/src/update_flake_inputs/cli.py", line 223, in process_flake_updates929pytest-impure>     flake_service.update_flake_input(930pytest-impure>     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^931pytest-impure>         input_name,932pytest-impure>         ^^^^^^^^^^^933pytest-impure>         flake.file_path,934pytest-impure>         ^^^^^^^^^^^^^^^^935pytest-impure>         str(worktree_path),936pytest-impure>         ^^^^^^^^^^^^^^^^^^^937pytest-impure>     )938pytest-impure>     ^939pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 235, in update_flake_input940pytest-impure>     raise FlakeServiceError(msg) from e941pytest-impure> update_flake_inputs.exceptions.FlakeServiceError: Failed to update flake input flake-utils in flake.nix: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-0je849kf/update-flake-utils?shallow=1', 'flake-utils']' returned non-zero exit status 1.942pytest-impure> Stderr: warning: you don't have Internet access; disabling some network-dependent features943pytest-impure> error:944pytest-impure>        … while updating the lock file of flake 'git+file:///build/flake-update-0je849kf/update-flake-utils?ref=refs/heads/update-flake-utils&rev=6a74b3a71186db3178663c227e447cc32eaf4080&shallow=1'945pytest-impure> 946pytest-impure>        … while updating the flake input 'flake-utils'947pytest-impure> 948pytest-impure>        … while fetching the input 'github:numtide/flake-utils'949pytest-impure> 950pytest-impure>        error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com951pytest-impure> _____ TestProcessFlakeUpdates.test_worktree_based_on_base_branch_not_head ______952pytest-impure> 953pytest-impure> self = <tests.test_process_flake_updates.TestProcessFlakeUpdates object at 0xfffff5e2dba0>954pytest-impure> tmp_path = PosixPath('/build/pytest-of-nixbld/pytest-0/test_worktree_based_on_base_br0')955pytest-impure> fixtures_path = PosixPath('/build/src/tests/fixtures')956pytest-impure> 957pytest-impure>         @pytest.mark.impure958pytest-impure>         def test_worktree_based_on_base_branch_not_head(959pytest-impure>             self,960pytest-impure>             tmp_path: Path,961pytest-impure>             fixtures_path: Path,962pytest-impure>         ) -> None:963pytest-impure>             """Test that update branches are based on base_branch, not current HEAD.964pytest-impure>     965pytest-impure>             When the action is triggered from a non-main branch, the worktree966pytest-impure>             should still be based on origin/<base_branch> so that commits from967pytest-impure>             the triggering branch don't leak into the update branch.968pytest-impure>             """969pytest-impure>             flake_content = """{970pytest-impure>       inputs = {971pytest-impure>         flake-utils.url = "github:numtide/flake-utils";972pytest-impure>       };973pytest-impure>     974pytest-impure>       outputs = { self, flake-utils }: {975pytest-impure>         # Test flake with updatable input976pytest-impure>       };977pytest-impure>     }"""978pytest-impure>     979pytest-impure>             (tmp_path / "flake.nix").write_text(flake_content)980pytest-impure>     981pytest-impure>             shutil.copy(982pytest-impure>                 fixtures_path / "minimal" / "flake.lock",983pytest-impure>                 tmp_path / "flake.lock",984pytest-impure>             )985pytest-impure>     986pytest-impure>             _setup_git_repo(tmp_path)987pytest-impure>     988pytest-impure>             # Create a feature branch with an extra commit989pytest-impure>             git_env = {990pytest-impure>                 **os.environ,991pytest-impure>                 "GIT_AUTHOR_NAME": "Test User",992pytest-impure>                 "GIT_AUTHOR_EMAIL": "test@example.com",993pytest-impure>                 "GIT_COMMITTER_NAME": "Test User",994pytest-impure>                 "GIT_COMMITTER_EMAIL": "test@example.com",995pytest-impure>             }996pytest-impure>             subprocess.run(997pytest-impure>                 ["git", "checkout", "-b", "feature-branch"],998pytest-impure>                 cwd=tmp_path,999pytest-impure>                 check=True,1000pytest-impure>             )1001pytest-impure>             (tmp_path / "extra-file.txt").write_text("feature branch content")1002pytest-impure>             subprocess.run(["git", "add", "."], cwd=tmp_path, check=True)1003pytest-impure>             subprocess.run(1004pytest-impure>                 ["git", "commit", "-m", "Feature branch commit"],1005pytest-impure>                 cwd=tmp_path,1006pytest-impure>                 check=True,1007pytest-impure>                 env=git_env,1008pytest-impure>             )1009pytest-impure>     1010pytest-impure>             # Stay on feature-branch (simulating action triggered from non-main branch)1011pytest-impure>             original_cwd = Path.cwd()1012pytest-impure>             os.chdir(tmp_path)1013pytest-impure>     1014pytest-impure>             try:1015pytest-impure>                 flake_service = FlakeService()1016pytest-impure>                 test_gitea_service = MockGiteaService()1017pytest-impure>     1018pytest-impure> >               process_flake_updates(1019pytest-impure>                     flake_service,1020pytest-impure>                     test_gitea_service,1021pytest-impure>                     "",1022pytest-impure>                     "main",1023pytest-impure>                     "",1024pytest-impure>                     auto_merge=False,1025pytest-impure>                 )1026pytest-impure> 1027pytest-impure> tests/test_process_flake_updates.py:328: 1028pytest-impure> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 1029pytest-impure> 1030pytest-impure> flake_service = <update_flake_inputs.flake_service.FlakeService object at 0xfffff5ead450>1031pytest-impure> gitea_service = MockGiteaService(api_url='https://gitea.example.com', token='test-token', owner='test-owner', repo='test-repo', git_au...tions[bot]', git_committer_email='gitea-actions[bot]@noreply.gitea.io', merge_style='default', pr_creation_attempts=[])1032pytest-impure> exclude_patterns = '', base_branch = 'main', branch_suffix = ''1033pytest-impure> 1034pytest-impure>     def process_flake_updates(  # noqa: PLR09131035pytest-impure>         flake_service: FlakeService,1036pytest-impure>         gitea_service: GiteaService,1037pytest-impure>         exclude_patterns: str,1038pytest-impure>         base_branch: str,1039pytest-impure>         branch_suffix: str,1040pytest-impure>         *,1041pytest-impure>         auto_merge: bool,1042pytest-impure>     ) -> None:1043pytest-impure>         """Process all flake updates.1044pytest-impure>     1045pytest-impure>         Args:1046pytest-impure>             flake_service: Flake service instance1047pytest-impure>             gitea_service: Gitea service instance1048pytest-impure>             exclude_patterns: Patterns to exclude1049pytest-impure>             base_branch: Base branch for PRs1050pytest-impure>             branch_suffix: Optional suffix to append to branch names1051pytest-impure>             auto_merge: Whether to automatically merge PRs1052pytest-impure>     1053pytest-impure>         """1054pytest-impure>         # Discover flake files1055pytest-impure>         flakes = flake_service.discover_flake_files(exclude_patterns)1056pytest-impure>         if not flakes:1057pytest-impure>             logger.info("No flake files found")1058pytest-impure>             return1059pytest-impure>     1060pytest-impure>         logger.info("Found %d flake files to process", len(flakes))1061pytest-impure>     1062pytest-impure>         failed_inputs: list[str] = []1063pytest-impure>     1064pytest-impure>         # Process each flake1065pytest-impure>         for flake in flakes:1066pytest-impure>             logger.info("Processing flake: %s", flake.file_path)1067pytest-impure>             logger.info("Inputs to update: %s", ", ".join(flake.inputs))1068pytest-impure>     1069pytest-impure>             # Don't include '.' for root directory1070pytest-impure>             parent_path = Path(flake.file_path).parent1071pytest-impure>             parent_suffix = "" if parent_path == Path() else f" in {parent_path}"1072pytest-impure>             parent_branch = "" if parent_path == Path() else f"-{parent_path}"1073pytest-impure>             suffix = branch_suffix.strip().replace("/", "-").strip("-")1074pytest-impure>     1075pytest-impure>             # Update each input1076pytest-impure>             for input_name in flake.inputs:1077pytest-impure>                 try:1078pytest-impure>                     branch_name = f"update{parent_branch}-{input_name}"1079pytest-impure>                     branch_name = branch_name.replace("/", "-").strip("-")1080pytest-impure>                     if suffix:1081pytest-impure>                         branch_name = f"{branch_name}-{suffix}"1082pytest-impure>     1083pytest-impure>                     logger.info(1084pytest-impure>                         "Updating input %s in %s (branch: %s)",1085pytest-impure>                         input_name,1086pytest-impure>                         flake.file_path,1087pytest-impure>                         branch_name,1088pytest-impure>                     )1089pytest-impure>     1090pytest-impure>                     # Create worktree and update input1091pytest-impure>                     with gitea_service.worktree(branch_name, base_branch) as worktree_path:1092pytest-impure>                         # Update the input1093pytest-impure>                         flake_service.update_flake_input(1094pytest-impure>                             input_name,1095pytest-impure>                             flake.file_path,1096pytest-impure>                             str(worktree_path),1097pytest-impure>                         )1098pytest-impure>     1099pytest-impure>                         # Commit changes1100pytest-impure>                         commit_message = f"Update {input_name}{parent_suffix}"1101pytest-impure>                         if gitea_service.commit_changes(1102pytest-impure>                             branch_name,1103pytest-impure>                             commit_message,1104pytest-impure>                             worktree_path,1105pytest-impure>                         ):1106pytest-impure>                             # Create pull request1107pytest-impure>                             pr_title = commit_message1108pytest-impure>                             pr_body = (1109pytest-impure>                                 f"This PR updates the `{input_name}` input "1110pytest-impure>                                 f"in `{flake.file_path}`.\n\n"1111pytest-impure>                                 "Generated by update-flake-inputs action."1112pytest-impure>                             )1113pytest-impure>                             gitea_service.create_pull_request(1114pytest-impure>                                 branch_name,1115pytest-impure>                                 base_branch,1116pytest-impure>                                 pr_title,1117pytest-impure>                                 pr_body,1118pytest-impure>                                 auto_merge=auto_merge,1119pytest-impure>                             )1120pytest-impure>                         else:1121pytest-impure>                             logger.info(1122pytest-impure>                                 "No changes for input %s in %s",1123pytest-impure>                                 input_name,1124pytest-impure>                                 flake.file_path,1125pytest-impure>                             )1126pytest-impure>                             gitea_service.delete_branch(branch_name)1127pytest-impure>     1128pytest-impure>                 except Exception:1129pytest-impure>                     logger.exception(1130pytest-impure>                         "Failed to update input %s in %s",1131pytest-impure>                         input_name,1132pytest-impure>                         flake.file_path,1133pytest-impure>                     )1134pytest-impure>                     failed_inputs.append(f"{input_name} in {flake.file_path}")1135pytest-impure>     1136pytest-impure>         if failed_inputs:1137pytest-impure>             msg = f"Failed to process {len(failed_inputs)} input(s): {', '.join(failed_inputs)}"1138pytest-impure> >           raise UpdateFlakeInputsError(msg)1139pytest-impure> E           update_flake_inputs.exceptions.UpdateFlakeInputsError: Failed to process 1 input(s): flake-utils in flake.nix1140pytest-impure> 1141pytest-impure> src/update_flake_inputs/cli.py:268: UpdateFlakeInputsError1142pytest-impure> ----------------------------- Captured stdout call -----------------------------1143pytest-impure> Initialized empty Git repository in /build/pytest-of-nixbld/pytest-0/test_worktree_based_on_base_br0/.git/1144pytest-impure> [main (root-commit) 24a32f8] Initial commit1145pytest-impure>  2 files changed, 53 insertions(+)1146pytest-impure>  create mode 100644 flake.lock1147pytest-impure>  create mode 100644 flake.nix1148pytest-impure> Initialized empty Git repository in /build/pytest-of-nixbld/pytest-0/remote-test_worktree_based_on_base_br0.git/1149pytest-impure> branch 'main' set up to track 'origin/main'.1150pytest-impure> [feature-branch e2c54de] Feature branch commit1151pytest-impure>  1 file changed, 1 insertion(+)1152pytest-impure>  create mode 100644 extra-file.txt1153pytest-impure> branch 'update-flake-utils' set up to track 'origin/main'.1154pytest-impure> HEAD is now at 24a32f8 Initial commit1155pytest-impure> ----------------------------- Captured stderr call -----------------------------1156pytest-impure> hint: Using 'master' as the name for the initial branch. This default branch name1157pytest-impure> hint: will change to "main" in Git 3.0. To configure the initial branch name1158pytest-impure> hint: to use in all of your new repositories, which will suppress this warning,1159pytest-impure> hint: call:1160pytest-impure> hint:1161pytest-impure> hint: 	git config --global init.defaultBranch <name>1162pytest-impure> hint:1163pytest-impure> hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and1164pytest-impure> hint: 'development'. The just-created branch can be renamed via this command:1165pytest-impure> hint:1166pytest-impure> hint: 	git branch -m <name>1167pytest-impure> hint:1168pytest-impure> hint: Disable this message with "git config set advice.defaultBranchName false"1169pytest-impure> To /build/pytest-of-nixbld/pytest-0/remote-test_worktree_based_on_base_br0.git1170pytest-impure>  * [new branch]      main -> main1171pytest-impure> Switched to a new branch 'feature-branch'1172pytest-impure> From /build/pytest-of-nixbld/pytest-0/remote-test_worktree_based_on_base_br01173pytest-impure>  * branch            main       -> FETCH_HEAD1174pytest-impure> Preparing worktree (new branch 'update-flake-utils')1175pytest-impure> ------------------------------ Captured log call -------------------------------1176pytest-impure> ERROR    update_flake_inputs.flake_service:flake_service.py:223 Failed to update flake input flake-utils in flake.nix. Exit code: 11177pytest-impure> Stdout: No stdout output1178pytest-impure> Stderr: warning: you don't have Internet access; disabling some network-dependent features1179pytest-impure> error:1180pytest-impure>        … while updating the lock file of flake 'git+file:///build/flake-update-leiezfl2/update-flake-utils?ref=refs/heads/update-flake-utils&rev=24a32f86a6a9b6f68581808d1d5e51c81e9ea430&shallow=1'1181pytest-impure> 1182pytest-impure>        … while updating the flake input 'flake-utils'1183pytest-impure> 1184pytest-impure>        … while fetching the input 'github:numtide/flake-utils'1185pytest-impure> 1186pytest-impure>        error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com1187pytest-impure> Traceback (most recent call last):1188pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 191, in update_flake_input1189pytest-impure>     result = subprocess.run(1190pytest-impure>         [1191pytest-impure>     ...<10 lines>...1192pytest-impure>         check=True,1193pytest-impure>     )1194pytest-impure>   File "/nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py", line 577, in run1195pytest-impure>     raise CalledProcessError(retcode, process.args,1196pytest-impure>                              output=stdout, stderr=stderr)1197pytest-impure> subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-leiezfl2/update-flake-utils?shallow=1', 'flake-utils']' returned non-zero exit status 1.1198pytest-impure> ERROR    update_flake_inputs.cli:cli.py:259 Failed to update input flake-utils in flake.nix1199pytest-impure> Traceback (most recent call last):1200pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 191, in update_flake_input1201pytest-impure>     result = subprocess.run(1202pytest-impure>         [1203pytest-impure>     ...<10 lines>...1204pytest-impure>         check=True,1205pytest-impure>     )1206pytest-impure>   File "/nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py", line 577, in run1207pytest-impure>     raise CalledProcessError(retcode, process.args,1208pytest-impure>                              output=stdout, stderr=stderr)1209pytest-impure> subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-leiezfl2/update-flake-utils?shallow=1', 'flake-utils']' returned non-zero exit status 1.1210pytest-impure> 1211pytest-impure> The above exception was the direct cause of the following exception:1212pytest-impure> 1213pytest-impure> Traceback (most recent call last):1214pytest-impure>   File "/build/src/src/update_flake_inputs/cli.py", line 223, in process_flake_updates1215pytest-impure>     flake_service.update_flake_input(1216pytest-impure>     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^1217pytest-impure>         input_name,1218pytest-impure>         ^^^^^^^^^^^1219pytest-impure>         flake.file_path,1220pytest-impure>         ^^^^^^^^^^^^^^^^1221pytest-impure>         str(worktree_path),1222pytest-impure>         ^^^^^^^^^^^^^^^^^^^1223pytest-impure>     )1224pytest-impure>     ^1225pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 235, in update_flake_input1226pytest-impure>     raise FlakeServiceError(msg) from e1227pytest-impure> update_flake_inputs.exceptions.FlakeServiceError: Failed to update flake input flake-utils in flake.nix: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-leiezfl2/update-flake-utils?shallow=1', 'flake-utils']' returned non-zero exit status 1.1228pytest-impure> Stderr: warning: you don't have Internet access; disabling some network-dependent features1229pytest-impure> error:1230pytest-impure>        … while updating the lock file of flake 'git+file:///build/flake-update-leiezfl2/update-flake-utils?ref=refs/heads/update-flake-utils&rev=24a32f86a6a9b6f68581808d1d5e51c81e9ea430&shallow=1'1231pytest-impure> 1232pytest-impure>        … while updating the flake input 'flake-utils'1233pytest-impure> 1234pytest-impure>        … while fetching the input 'github:numtide/flake-utils'1235pytest-impure> 1236pytest-impure>        error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com1237pytest-impure> ___________ TestProcessFlakeUpdates.test_custom_git_author_committer ___________1238pytest-impure> 1239pytest-impure> self = <tests.test_process_flake_updates.TestProcessFlakeUpdates object at 0xfffff5e2df30>1240pytest-impure> tmp_path = PosixPath('/build/pytest-of-nixbld/pytest-0/test_custom_git_author_committ0')1241pytest-impure> fixtures_path = PosixPath('/build/src/tests/fixtures')1242pytest-impure> 1243pytest-impure>         @pytest.mark.impure1244pytest-impure>         def test_custom_git_author_committer(1245pytest-impure>             self,1246pytest-impure>             tmp_path: Path,1247pytest-impure>             fixtures_path: Path,1248pytest-impure>         ) -> None:1249pytest-impure>             """Test that custom git author/committer configuration is used."""1250pytest-impure>             # Create a flake with flake-utils1251pytest-impure>             flake_content = """{1252pytest-impure>       inputs = {1253pytest-impure>         flake-utils.url = "github:numtide/flake-utils";1254pytest-impure>       };1255pytest-impure>     1256pytest-impure>       outputs = { self, flake-utils }: {1257pytest-impure>         # Test flake1258pytest-impure>       };1259pytest-impure>     }"""1260pytest-impure>     1261pytest-impure>             (tmp_path / "flake.nix").write_text(flake_content)1262pytest-impure>     1263pytest-impure>             # Copy old lock file from minimal fixture1264pytest-impure>             shutil.copy(1265pytest-impure>                 fixtures_path / "minimal" / "flake.lock",1266pytest-impure>                 tmp_path / "flake.lock",1267pytest-impure>             )1268pytest-impure>     1269pytest-impure>             _setup_git_repo(tmp_path)1270pytest-impure>     1271pytest-impure>             # Change to test directory1272pytest-impure>             original_cwd = Path.cwd()1273pytest-impure>             os.chdir(tmp_path)1274pytest-impure>     1275pytest-impure>             try:1276pytest-impure>                 # Create test services with custom git author/committer1277pytest-impure>                 flake_service = FlakeService()1278pytest-impure>                 test_gitea_service = MockGiteaService()1279pytest-impure>                 test_gitea_service.git_author_name = "Custom Bot"1280pytest-impure>                 test_gitea_service.git_author_email = "custom@bot.com"1281pytest-impure>                 test_gitea_service.git_committer_name = "Custom Committer"1282pytest-impure>                 test_gitea_service.git_committer_email = "committer@bot.com"1283pytest-impure>     1284pytest-impure>                 # Process updates1285pytest-impure> >               process_flake_updates(1286pytest-impure>                     flake_service,1287pytest-impure>                     test_gitea_service,1288pytest-impure>                     "",1289pytest-impure>                     "main",1290pytest-impure>                     "",1291pytest-impure>                     auto_merge=False,1292pytest-impure>                 )1293pytest-impure> 1294pytest-impure> tests/test_process_flake_updates.py:398: 1295pytest-impure> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 1296pytest-impure> 1297pytest-impure> flake_service = <update_flake_inputs.flake_service.FlakeService object at 0xfffff61cbe30>1298pytest-impure> gitea_service = MockGiteaService(api_url='https://gitea.example.com', token='test-token', owner='test-owner', repo='test-repo', git_au...itter_name='Custom Committer', git_committer_email='committer@bot.com', merge_style='default', pr_creation_attempts=[])1299pytest-impure> exclude_patterns = '', base_branch = 'main', branch_suffix = ''1300pytest-impure> 1301pytest-impure>     def process_flake_updates(  # noqa: PLR09131302pytest-impure>         flake_service: FlakeService,1303pytest-impure>         gitea_service: GiteaService,1304pytest-impure>         exclude_patterns: str,1305pytest-impure>         base_branch: str,1306pytest-impure>         branch_suffix: str,1307pytest-impure>         *,1308pytest-impure>         auto_merge: bool,1309pytest-impure>     ) -> None:1310pytest-impure>         """Process all flake updates.1311pytest-impure>     1312pytest-impure>         Args:1313pytest-impure>             flake_service: Flake service instance1314pytest-impure>             gitea_service: Gitea service instance1315pytest-impure>             exclude_patterns: Patterns to exclude1316pytest-impure>             base_branch: Base branch for PRs1317pytest-impure>             branch_suffix: Optional suffix to append to branch names1318pytest-impure>             auto_merge: Whether to automatically merge PRs1319pytest-impure>     1320pytest-impure>         """1321pytest-impure>         # Discover flake files1322pytest-impure>         flakes = flake_service.discover_flake_files(exclude_patterns)1323pytest-impure>         if not flakes:1324pytest-impure>             logger.info("No flake files found")1325pytest-impure>             return1326pytest-impure>     1327pytest-impure>         logger.info("Found %d flake files to process", len(flakes))1328pytest-impure>     1329pytest-impure>         failed_inputs: list[str] = []1330pytest-impure>     1331pytest-impure>         # Process each flake1332pytest-impure>         for flake in flakes:1333pytest-impure>             logger.info("Processing flake: %s", flake.file_path)1334pytest-impure>             logger.info("Inputs to update: %s", ", ".join(flake.inputs))1335pytest-impure>     1336pytest-impure>             # Don't include '.' for root directory1337pytest-impure>             parent_path = Path(flake.file_path).parent1338pytest-impure>             parent_suffix = "" if parent_path == Path() else f" in {parent_path}"1339pytest-impure>             parent_branch = "" if parent_path == Path() else f"-{parent_path}"1340pytest-impure>             suffix = branch_suffix.strip().replace("/", "-").strip("-")1341pytest-impure>     1342pytest-impure>             # Update each input1343pytest-impure>             for input_name in flake.inputs:1344pytest-impure>                 try:1345pytest-impure>                     branch_name = f"update{parent_branch}-{input_name}"1346pytest-impure>                     branch_name = branch_name.replace("/", "-").strip("-")1347pytest-impure>                     if suffix:1348pytest-impure>                         branch_name = f"{branch_name}-{suffix}"1349pytest-impure>     1350pytest-impure>                     logger.info(1351pytest-impure>                         "Updating input %s in %s (branch: %s)",1352pytest-impure>                         input_name,1353pytest-impure>                         flake.file_path,1354pytest-impure>                         branch_name,1355pytest-impure>                     )1356pytest-impure>     1357pytest-impure>                     # Create worktree and update input1358pytest-impure>                     with gitea_service.worktree(branch_name, base_branch) as worktree_path:1359pytest-impure>                         # Update the input1360pytest-impure>                         flake_service.update_flake_input(1361pytest-impure>                             input_name,1362pytest-impure>                             flake.file_path,1363pytest-impure>                             str(worktree_path),1364pytest-impure>                         )1365pytest-impure>     1366pytest-impure>                         # Commit changes1367pytest-impure>                         commit_message = f"Update {input_name}{parent_suffix}"1368pytest-impure>                         if gitea_service.commit_changes(1369pytest-impure>                             branch_name,1370pytest-impure>                             commit_message,1371pytest-impure>                             worktree_path,1372pytest-impure>                         ):1373pytest-impure>                             # Create pull request1374pytest-impure>                             pr_title = commit_message1375pytest-impure>                             pr_body = (1376pytest-impure>                                 f"This PR updates the `{input_name}` input "1377pytest-impure>                                 f"in `{flake.file_path}`.\n\n"1378pytest-impure>                                 "Generated by update-flake-inputs action."1379pytest-impure>                             )1380pytest-impure>                             gitea_service.create_pull_request(1381pytest-impure>                                 branch_name,1382pytest-impure>                                 base_branch,1383pytest-impure>                                 pr_title,1384pytest-impure>                                 pr_body,1385pytest-impure>                                 auto_merge=auto_merge,1386pytest-impure>                             )1387pytest-impure>                         else:1388pytest-impure>                             logger.info(1389pytest-impure>                                 "No changes for input %s in %s",1390pytest-impure>                                 input_name,1391pytest-impure>                                 flake.file_path,1392pytest-impure>                             )1393pytest-impure>                             gitea_service.delete_branch(branch_name)1394pytest-impure>     1395pytest-impure>                 except Exception:1396pytest-impure>                     logger.exception(1397pytest-impure>                         "Failed to update input %s in %s",1398pytest-impure>                         input_name,1399pytest-impure>                         flake.file_path,1400pytest-impure>                     )1401pytest-impure>                     failed_inputs.append(f"{input_name} in {flake.file_path}")1402pytest-impure>     1403pytest-impure>         if failed_inputs:1404pytest-impure>             msg = f"Failed to process {len(failed_inputs)} input(s): {', '.join(failed_inputs)}"1405pytest-impure> >           raise UpdateFlakeInputsError(msg)1406pytest-impure> E           update_flake_inputs.exceptions.UpdateFlakeInputsError: Failed to process 1 input(s): flake-utils in flake.nix1407pytest-impure> 1408pytest-impure> src/update_flake_inputs/cli.py:268: UpdateFlakeInputsError1409pytest-impure> ----------------------------- Captured stdout call -----------------------------1410pytest-impure> Initialized empty Git repository in /build/pytest-of-nixbld/pytest-0/test_custom_git_author_committ0/.git/1411pytest-impure> [main (root-commit) e76969a] Initial commit1412pytest-impure>  2 files changed, 53 insertions(+)1413pytest-impure>  create mode 100644 flake.lock1414pytest-impure>  create mode 100644 flake.nix1415pytest-impure> Initialized empty Git repository in /build/pytest-of-nixbld/pytest-0/remote-test_custom_git_author_committ0.git/1416pytest-impure> branch 'main' set up to track 'origin/main'.1417pytest-impure> branch 'update-flake-utils' set up to track 'origin/main'.1418pytest-impure> HEAD is now at e76969a Initial commit1419pytest-impure> ----------------------------- Captured stderr call -----------------------------1420pytest-impure> hint: Using 'master' as the name for the initial branch. This default branch name1421pytest-impure> hint: will change to "main" in Git 3.0. To configure the initial branch name1422pytest-impure> hint: to use in all of your new repositories, which will suppress this warning,1423pytest-impure> hint: call:1424pytest-impure> hint:1425pytest-impure> hint: 	git config --global init.defaultBranch <name>1426pytest-impure> hint:1427pytest-impure> hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and1428pytest-impure> hint: 'development'. The just-created branch can be renamed via this command:1429pytest-impure> hint:1430pytest-impure> hint: 	git branch -m <name>1431pytest-impure> hint:1432pytest-impure> hint: Disable this message with "git config set advice.defaultBranchName false"1433pytest-impure> To /build/pytest-of-nixbld/pytest-0/remote-test_custom_git_author_committ0.git1434pytest-impure>  * [new branch]      main -> main1435pytest-impure> From /build/pytest-of-nixbld/pytest-0/remote-test_custom_git_author_committ01436pytest-impure>  * branch            main       -> FETCH_HEAD1437pytest-impure> Preparing worktree (new branch 'update-flake-utils')1438pytest-impure> ------------------------------ Captured log call -------------------------------1439pytest-impure> ERROR    update_flake_inputs.flake_service:flake_service.py:223 Failed to update flake input flake-utils in flake.nix. Exit code: 11440pytest-impure> Stdout: No stdout output1441pytest-impure> Stderr: warning: you don't have Internet access; disabling some network-dependent features1442pytest-impure> error:1443pytest-impure>        … while updating the lock file of flake 'git+file:///build/flake-update-9y8bctw4/update-flake-utils?ref=refs/heads/update-flake-utils&rev=e76969a56e490f9164deef4862231976d2b6a18c&shallow=1'1444pytest-impure> 1445pytest-impure>        … while updating the flake input 'flake-utils'1446pytest-impure> 1447pytest-impure>        … while fetching the input 'github:numtide/flake-utils'1448pytest-impure> 1449pytest-impure>        error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com1450pytest-impure> Traceback (most recent call last):1451pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 191, in update_flake_input1452pytest-impure>     result = subprocess.run(1453pytest-impure>         [1454pytest-impure>     ...<10 lines>...1455pytest-impure>         check=True,1456pytest-impure>     )1457pytest-impure>   File "/nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py", line 577, in run1458pytest-impure>     raise CalledProcessError(retcode, process.args,1459pytest-impure>                              output=stdout, stderr=stderr)1460pytest-impure> subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-9y8bctw4/update-flake-utils?shallow=1', 'flake-utils']' returned non-zero exit status 1.1461pytest-impure> ERROR    update_flake_inputs.cli:cli.py:259 Failed to update input flake-utils in flake.nix1462pytest-impure> Traceback (most recent call last):1463pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 191, in update_flake_input1464pytest-impure>     result = subprocess.run(1465pytest-impure>         [1466pytest-impure>     ...<10 lines>...1467pytest-impure>         check=True,1468pytest-impure>     )1469pytest-impure>   File "/nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py", line 577, in run1470pytest-impure>     raise CalledProcessError(retcode, process.args,1471pytest-impure>                              output=stdout, stderr=stderr)1472pytest-impure> subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-9y8bctw4/update-flake-utils?shallow=1', 'flake-utils']' returned non-zero exit status 1.1473pytest-impure> 1474pytest-impure> The above exception was the direct cause of the following exception:1475pytest-impure> 1476pytest-impure> Traceback (most recent call last):1477pytest-impure>   File "/build/src/src/update_flake_inputs/cli.py", line 223, in process_flake_updates1478pytest-impure>     flake_service.update_flake_input(1479pytest-impure>     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^1480pytest-impure>         input_name,1481pytest-impure>         ^^^^^^^^^^^1482pytest-impure>         flake.file_path,1483pytest-impure>         ^^^^^^^^^^^^^^^^1484pytest-impure>         str(worktree_path),1485pytest-impure>         ^^^^^^^^^^^^^^^^^^^1486pytest-impure>     )1487pytest-impure>     ^1488pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 235, in update_flake_input1489pytest-impure>     raise FlakeServiceError(msg) from e1490pytest-impure> update_flake_inputs.exceptions.FlakeServiceError: Failed to update flake input flake-utils in flake.nix: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-9y8bctw4/update-flake-utils?shallow=1', 'flake-utils']' returned non-zero exit status 1.1491pytest-impure> Stderr: warning: you don't have Internet access; disabling some network-dependent features1492pytest-impure> error:1493pytest-impure>        … while updating the lock file of flake 'git+file:///build/flake-update-9y8bctw4/update-flake-utils?ref=refs/heads/update-flake-utils&rev=e76969a56e490f9164deef4862231976d2b6a18c&shallow=1'1494pytest-impure> 1495pytest-impure>        … while updating the flake input 'flake-utils'1496pytest-impure> 1497pytest-impure>        … while fetching the input 'github:numtide/flake-utils'1498pytest-impure> 1499pytest-impure>        error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com1500pytest-impure> __________________ TestProcessFlakeUpdates.test_branch_suffix __________________1501pytest-impure> 1502pytest-impure> self = <tests.test_process_flake_updates.TestProcessFlakeUpdates object at 0xfffff54dc170>1503pytest-impure> tmp_path = PosixPath('/build/pytest-of-nixbld/pytest-0/test_branch_suffix0')1504pytest-impure> fixtures_path = PosixPath('/build/src/tests/fixtures')1505pytest-impure> 1506pytest-impure>         @pytest.mark.impure1507pytest-impure>         def test_branch_suffix(1508pytest-impure>             self,1509pytest-impure>             tmp_path: Path,1510pytest-impure>             fixtures_path: Path,1511pytest-impure>         ) -> None:1512pytest-impure>             """Test that branch suffix is properly appended to branch names."""1513pytest-impure>             # Create a flake with flake-utils1514pytest-impure>             flake_content = """{1515pytest-impure>       inputs = {1516pytest-impure>         flake-utils.url = "github:numtide/flake-utils";1517pytest-impure>       };1518pytest-impure>     1519pytest-impure>       outputs = { self, flake-utils }: {1520pytest-impure>         # Test flake1521pytest-impure>       };1522pytest-impure>     }"""1523pytest-impure>     1524pytest-impure>             (tmp_path / "flake.nix").write_text(flake_content)1525pytest-impure>     1526pytest-impure>             # Copy old lock file from minimal fixture1527pytest-impure>             shutil.copy(1528pytest-impure>                 fixtures_path / "minimal" / "flake.lock",1529pytest-impure>                 tmp_path / "flake.lock",1530pytest-impure>             )1531pytest-impure>     1532pytest-impure>             _setup_git_repo(tmp_path)1533pytest-impure>     1534pytest-impure>             # Change to test directory1535pytest-impure>             original_cwd = Path.cwd()1536pytest-impure>             os.chdir(tmp_path)1537pytest-impure>     1538pytest-impure>             try:1539pytest-impure>                 # Create test services1540pytest-impure>                 flake_service = FlakeService()1541pytest-impure>                 test_gitea_service = MockGiteaService()1542pytest-impure>     1543pytest-impure>                 # Process updates with branch suffix1544pytest-impure> >               process_flake_updates(1545pytest-impure>                     flake_service,1546pytest-impure>                     test_gitea_service,1547pytest-impure>                     "",1548pytest-impure>                     "main",1549pytest-impure>                     "my-suffix",1550pytest-impure>                     auto_merge=False,1551pytest-impure>                 )1552pytest-impure> 1553pytest-impure> tests/test_process_flake_updates.py:465: 1554pytest-impure> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 1555pytest-impure> 1556pytest-impure> flake_service = <update_flake_inputs.flake_service.FlakeService object at 0xfffff5ea89b0>1557pytest-impure> gitea_service = MockGiteaService(api_url='https://gitea.example.com', token='test-token', owner='test-owner', repo='test-repo', git_au...tions[bot]', git_committer_email='gitea-actions[bot]@noreply.gitea.io', merge_style='default', pr_creation_attempts=[])1558pytest-impure> exclude_patterns = '', base_branch = 'main', branch_suffix = 'my-suffix'1559pytest-impure> 1560pytest-impure>     def process_flake_updates(  # noqa: PLR09131561pytest-impure>         flake_service: FlakeService,1562pytest-impure>         gitea_service: GiteaService,1563pytest-impure>         exclude_patterns: str,1564pytest-impure>         base_branch: str,1565pytest-impure>         branch_suffix: str,1566pytest-impure>         *,1567pytest-impure>         auto_merge: bool,1568pytest-impure>     ) -> None:1569pytest-impure>         """Process all flake updates.1570pytest-impure>     1571pytest-impure>         Args:1572pytest-impure>             flake_service: Flake service instance1573pytest-impure>             gitea_service: Gitea service instance1574pytest-impure>             exclude_patterns: Patterns to exclude1575pytest-impure>             base_branch: Base branch for PRs1576pytest-impure>             branch_suffix: Optional suffix to append to branch names1577pytest-impure>             auto_merge: Whether to automatically merge PRs1578pytest-impure>     1579pytest-impure>         """1580pytest-impure>         # Discover flake files1581pytest-impure>         flakes = flake_service.discover_flake_files(exclude_patterns)1582pytest-impure>         if not flakes:1583pytest-impure>             logger.info("No flake files found")1584pytest-impure>             return1585pytest-impure>     1586pytest-impure>         logger.info("Found %d flake files to process", len(flakes))1587pytest-impure>     1588pytest-impure>         failed_inputs: list[str] = []1589pytest-impure>     1590pytest-impure>         # Process each flake1591pytest-impure>         for flake in flakes:1592pytest-impure>             logger.info("Processing flake: %s", flake.file_path)1593pytest-impure>             logger.info("Inputs to update: %s", ", ".join(flake.inputs))1594pytest-impure>     1595pytest-impure>             # Don't include '.' for root directory1596pytest-impure>             parent_path = Path(flake.file_path).parent1597pytest-impure>             parent_suffix = "" if parent_path == Path() else f" in {parent_path}"1598pytest-impure>             parent_branch = "" if parent_path == Path() else f"-{parent_path}"1599pytest-impure>             suffix = branch_suffix.strip().replace("/", "-").strip("-")1600pytest-impure>     1601pytest-impure>             # Update each input1602pytest-impure>             for input_name in flake.inputs:1603pytest-impure>                 try:1604pytest-impure>                     branch_name = f"update{parent_branch}-{input_name}"1605pytest-impure>                     branch_name = branch_name.replace("/", "-").strip("-")1606pytest-impure>                     if suffix:1607pytest-impure>                         branch_name = f"{branch_name}-{suffix}"1608pytest-impure>     1609pytest-impure>                     logger.info(1610pytest-impure>                         "Updating input %s in %s (branch: %s)",1611pytest-impure>                         input_name,1612pytest-impure>                         flake.file_path,1613pytest-impure>                         branch_name,1614pytest-impure>                     )1615pytest-impure>     1616pytest-impure>                     # Create worktree and update input1617pytest-impure>                     with gitea_service.worktree(branch_name, base_branch) as worktree_path:1618pytest-impure>                         # Update the input1619pytest-impure>                         flake_service.update_flake_input(1620pytest-impure>                             input_name,1621pytest-impure>                             flake.file_path,1622pytest-impure>                             str(worktree_path),1623pytest-impure>                         )1624pytest-impure>     1625pytest-impure>                         # Commit changes1626pytest-impure>                         commit_message = f"Update {input_name}{parent_suffix}"1627pytest-impure>                         if gitea_service.commit_changes(1628pytest-impure>                             branch_name,1629pytest-impure>                             commit_message,1630pytest-impure>                             worktree_path,1631pytest-impure>                         ):1632pytest-impure>                             # Create pull request1633pytest-impure>                             pr_title = commit_message1634pytest-impure>                             pr_body = (1635pytest-impure>                                 f"This PR updates the `{input_name}` input "1636pytest-impure>                                 f"in `{flake.file_path}`.\n\n"1637pytest-impure>                                 "Generated by update-flake-inputs action."1638pytest-impure>                             )1639pytest-impure>                             gitea_service.create_pull_request(1640pytest-impure>                                 branch_name,1641pytest-impure>                                 base_branch,1642pytest-impure>                                 pr_title,1643pytest-impure>                                 pr_body,1644pytest-impure>                                 auto_merge=auto_merge,1645pytest-impure>                             )1646pytest-impure>                         else:1647pytest-impure>                             logger.info(1648pytest-impure>                                 "No changes for input %s in %s",1649pytest-impure>                                 input_name,1650pytest-impure>                                 flake.file_path,1651pytest-impure>                             )1652pytest-impure>                             gitea_service.delete_branch(branch_name)1653pytest-impure>     1654pytest-impure>                 except Exception:1655pytest-impure>                     logger.exception(1656pytest-impure>                         "Failed to update input %s in %s",1657pytest-impure>                         input_name,1658pytest-impure>                         flake.file_path,1659pytest-impure>                     )1660pytest-impure>                     failed_inputs.append(f"{input_name} in {flake.file_path}")1661pytest-impure>     1662pytest-impure>         if failed_inputs:1663pytest-impure>             msg = f"Failed to process {len(failed_inputs)} input(s): {', '.join(failed_inputs)}"1664pytest-impure> >           raise UpdateFlakeInputsError(msg)1665pytest-impure> E           update_flake_inputs.exceptions.UpdateFlakeInputsError: Failed to process 1 input(s): flake-utils in flake.nix1666pytest-impure> 1667pytest-impure> src/update_flake_inputs/cli.py:268: UpdateFlakeInputsError1668pytest-impure> ----------------------------- Captured stdout call -----------------------------1669pytest-impure> Initialized empty Git repository in /build/pytest-of-nixbld/pytest-0/test_branch_suffix0/.git/1670pytest-impure> [main (root-commit) 9bb82d8] Initial commit1671pytest-impure>  2 files changed, 53 insertions(+)1672pytest-impure>  create mode 100644 flake.lock1673pytest-impure>  create mode 100644 flake.nix1674pytest-impure> Initialized empty Git repository in /build/pytest-of-nixbld/pytest-0/remote-test_branch_suffix0.git/1675pytest-impure> branch 'main' set up to track 'origin/main'.1676pytest-impure> branch 'update-flake-utils-my-suffix' set up to track 'origin/main'.1677pytest-impure> HEAD is now at 9bb82d8 Initial commit1678pytest-impure> ----------------------------- Captured stderr call -----------------------------1679pytest-impure> hint: Using 'master' as the name for the initial branch. This default branch name1680pytest-impure> hint: will change to "main" in Git 3.0. To configure the initial branch name1681pytest-impure> hint: to use in all of your new repositories, which will suppress this warning,1682pytest-impure> hint: call:1683pytest-impure> hint:1684pytest-impure> hint: 	git config --global init.defaultBranch <name>1685pytest-impure> hint:1686pytest-impure> hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and1687pytest-impure> hint: 'development'. The just-created branch can be renamed via this command:1688pytest-impure> hint:1689pytest-impure> hint: 	git branch -m <name>1690pytest-impure> hint:1691pytest-impure> hint: Disable this message with "git config set advice.defaultBranchName false"1692pytest-impure> To /build/pytest-of-nixbld/pytest-0/remote-test_branch_suffix0.git1693pytest-impure>  * [new branch]      main -> main1694pytest-impure> From /build/pytest-of-nixbld/pytest-0/remote-test_branch_suffix01695pytest-impure>  * branch            main       -> FETCH_HEAD1696pytest-impure> Preparing worktree (new branch 'update-flake-utils-my-suffix')1697pytest-impure> ------------------------------ Captured log call -------------------------------1698pytest-impure> ERROR    update_flake_inputs.flake_service:flake_service.py:223 Failed to update flake input flake-utils in flake.nix. Exit code: 11699pytest-impure> Stdout: No stdout output1700pytest-impure> Stderr: warning: you don't have Internet access; disabling some network-dependent features1701pytest-impure> error:1702pytest-impure>        … while updating the lock file of flake 'git+file:///build/flake-update-86qfcb6g/update-flake-utils-my-suffix?ref=refs/heads/update-flake-utils-my-suffix&rev=9bb82d891bb38b360c0c2b9f2a1a396a258e9dd8&shallow=1'1703pytest-impure> 1704pytest-impure>        … while updating the flake input 'flake-utils'1705pytest-impure> 1706pytest-impure>        … while fetching the input 'github:numtide/flake-utils'1707pytest-impure> 1708pytest-impure>        error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com1709pytest-impure> Traceback (most recent call last):1710pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 191, in update_flake_input1711pytest-impure>     result = subprocess.run(1712pytest-impure>         [1713pytest-impure>     ...<10 lines>...1714pytest-impure>         check=True,1715pytest-impure>     )1716pytest-impure>   File "/nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py", line 577, in run1717pytest-impure>     raise CalledProcessError(retcode, process.args,1718pytest-impure>                              output=stdout, stderr=stderr)1719pytest-impure> subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-86qfcb6g/update-flake-utils-my-suffix?shallow=1', 'flake-utils']' returned non-zero exit status 1.1720pytest-impure> ERROR    update_flake_inputs.cli:cli.py:259 Failed to update input flake-utils in flake.nix1721pytest-impure> Traceback (most recent call last):1722pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 191, in update_flake_input1723pytest-impure>     result = subprocess.run(1724pytest-impure>         [1725pytest-impure>     ...<10 lines>...1726pytest-impure>         check=True,1727pytest-impure>     )1728pytest-impure>   File "/nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py", line 577, in run1729pytest-impure>     raise CalledProcessError(retcode, process.args,1730pytest-impure>                              output=stdout, stderr=stderr)1731pytest-impure> subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-86qfcb6g/update-flake-utils-my-suffix?shallow=1', 'flake-utils']' returned non-zero exit status 1.1732pytest-impure> 1733pytest-impure> The above exception was the direct cause of the following exception:1734pytest-impure> 1735pytest-impure> Traceback (most recent call last):1736pytest-impure>   File "/build/src/src/update_flake_inputs/cli.py", line 223, in process_flake_updates1737pytest-impure>     flake_service.update_flake_input(1738pytest-impure>     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^1739pytest-impure>         input_name,1740pytest-impure>         ^^^^^^^^^^^1741pytest-impure>         flake.file_path,1742pytest-impure>         ^^^^^^^^^^^^^^^^1743pytest-impure>         str(worktree_path),1744pytest-impure>         ^^^^^^^^^^^^^^^^^^^1745pytest-impure>     )1746pytest-impure>     ^1747pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 235, in update_flake_input1748pytest-impure>     raise FlakeServiceError(msg) from e1749pytest-impure> update_flake_inputs.exceptions.FlakeServiceError: Failed to update flake input flake-utils in flake.nix: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-86qfcb6g/update-flake-utils-my-suffix?shallow=1', 'flake-utils']' returned non-zero exit status 1.1750pytest-impure> Stderr: warning: you don't have Internet access; disabling some network-dependent features1751pytest-impure> error:1752pytest-impure>        … while updating the lock file of flake 'git+file:///build/flake-update-86qfcb6g/update-flake-utils-my-suffix?ref=refs/heads/update-flake-utils-my-suffix&rev=9bb82d891bb38b360c0c2b9f2a1a396a258e9dd8&shallow=1'1753pytest-impure> 1754pytest-impure>        … while updating the flake input 'flake-utils'1755pytest-impure> 1756pytest-impure>        … while fetching the input 'github:numtide/flake-utils'1757pytest-impure> 1758pytest-impure>        error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com1759pytest-impure> ____ TestProcessFlakeUpdates.test_fails_at_end_when_individual_input_fails _____1760pytest-impure> 1761pytest-impure> self = <tests.test_process_flake_updates.TestProcessFlakeUpdates object at 0xfffff5e4a8b0>1762pytest-impure> tmp_path = PosixPath('/build/pytest-of-nixbld/pytest-0/test_fails_at_end_when_individ0')1763pytest-impure> fixtures_path = PosixPath('/build/src/tests/fixtures')1764pytest-impure> 1765pytest-impure>         @pytest.mark.impure1766pytest-impure>         def test_fails_at_end_when_individual_input_fails(1767pytest-impure>             self,1768pytest-impure>             tmp_path: Path,1769pytest-impure>             fixtures_path: Path,1770pytest-impure>         ) -> None:1771pytest-impure>             """Test that the action continues updating other inputs but fails at the end."""1772pytest-impure>             flake_content = """{1773pytest-impure>       inputs = {1774pytest-impure>         flake-utils.url = "github:numtide/flake-utils";1775pytest-impure>       };1776pytest-impure>     1777pytest-impure>       outputs = { self, flake-utils }: {1778pytest-impure>         # Test flake with updatable input1779pytest-impure>       };1780pytest-impure>     }"""1781pytest-impure>     1782pytest-impure>             (tmp_path / "flake.nix").write_text(flake_content)1783pytest-impure>     1784pytest-impure>             shutil.copy(1785pytest-impure>                 fixtures_path / "minimal" / "flake.lock",1786pytest-impure>                 tmp_path / "flake.lock",1787pytest-impure>             )1788pytest-impure>     1789pytest-impure>             _setup_git_repo(tmp_path)1790pytest-impure>     1791pytest-impure>             original_cwd = Path.cwd()1792pytest-impure>             os.chdir(tmp_path)1793pytest-impure>     1794pytest-impure>             try:1795pytest-impure>                 # FailingFlakeService injects "bad-input" during discovery and1796pytest-impure>                 # raises when asked to update it, simulating a 403 or dead ref1797pytest-impure>                 flake_service = FailingFlakeService(fail_inputs=["bad-input"])1798pytest-impure>                 test_gitea_service = MockGiteaService()1799pytest-impure>     1800pytest-impure>                 with pytest.raises(UpdateFlakeInputsError, match="Failed to process 1 input"):1801pytest-impure> >                   process_flake_updates(1802pytest-impure>                         flake_service,1803pytest-impure>                         test_gitea_service,1804pytest-impure>                         "",1805pytest-impure>                         "main",1806pytest-impure>                         "",1807pytest-impure>                         auto_merge=False,1808pytest-impure>                     )1809pytest-impure> 1810pytest-impure> tests/test_process_flake_updates.py:597: 1811pytest-impure> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 1812pytest-impure> 1813pytest-impure> flake_service = <tests.test_process_flake_updates.FailingFlakeService object at 0xfffff624ecf0>1814pytest-impure> gitea_service = MockGiteaService(api_url='https://gitea.example.com', token='test-token', owner='test-owner', repo='test-repo', git_au...tions[bot]', git_committer_email='gitea-actions[bot]@noreply.gitea.io', merge_style='default', pr_creation_attempts=[])1815pytest-impure> exclude_patterns = '', base_branch = 'main', branch_suffix = ''1816pytest-impure> 1817pytest-impure>     def process_flake_updates(  # noqa: PLR09131818pytest-impure>         flake_service: FlakeService,1819pytest-impure>         gitea_service: GiteaService,1820pytest-impure>         exclude_patterns: str,1821pytest-impure>         base_branch: str,1822pytest-impure>         branch_suffix: str,1823pytest-impure>         *,1824pytest-impure>         auto_merge: bool,1825pytest-impure>     ) -> None:1826pytest-impure>         """Process all flake updates.1827pytest-impure>     1828pytest-impure>         Args:1829pytest-impure>             flake_service: Flake service instance1830pytest-impure>             gitea_service: Gitea service instance1831pytest-impure>             exclude_patterns: Patterns to exclude1832pytest-impure>             base_branch: Base branch for PRs1833pytest-impure>             branch_suffix: Optional suffix to append to branch names1834pytest-impure>             auto_merge: Whether to automatically merge PRs1835pytest-impure>     1836pytest-impure>         """1837pytest-impure>         # Discover flake files1838pytest-impure>         flakes = flake_service.discover_flake_files(exclude_patterns)1839pytest-impure>         if not flakes:1840pytest-impure>             logger.info("No flake files found")1841pytest-impure>             return1842pytest-impure>     1843pytest-impure>         logger.info("Found %d flake files to process", len(flakes))1844pytest-impure>     1845pytest-impure>         failed_inputs: list[str] = []1846pytest-impure>     1847pytest-impure>         # Process each flake1848pytest-impure>         for flake in flakes:1849pytest-impure>             logger.info("Processing flake: %s", flake.file_path)1850pytest-impure>             logger.info("Inputs to update: %s", ", ".join(flake.inputs))1851pytest-impure>     1852pytest-impure>             # Don't include '.' for root directory1853pytest-impure>             parent_path = Path(flake.file_path).parent1854pytest-impure>             parent_suffix = "" if parent_path == Path() else f" in {parent_path}"1855pytest-impure>             parent_branch = "" if parent_path == Path() else f"-{parent_path}"1856pytest-impure>             suffix = branch_suffix.strip().replace("/", "-").strip("-")1857pytest-impure>     1858pytest-impure>             # Update each input1859pytest-impure>             for input_name in flake.inputs:1860pytest-impure>                 try:1861pytest-impure>                     branch_name = f"update{parent_branch}-{input_name}"1862pytest-impure>                     branch_name = branch_name.replace("/", "-").strip("-")1863pytest-impure>                     if suffix:1864pytest-impure>                         branch_name = f"{branch_name}-{suffix}"1865pytest-impure>     1866pytest-impure>                     logger.info(1867pytest-impure>                         "Updating input %s in %s (branch: %s)",1868pytest-impure>                         input_name,1869pytest-impure>                         flake.file_path,1870pytest-impure>                         branch_name,1871pytest-impure>                     )1872pytest-impure>     1873pytest-impure>                     # Create worktree and update input1874pytest-impure>                     with gitea_service.worktree(branch_name, base_branch) as worktree_path:1875pytest-impure>                         # Update the input1876pytest-impure>                         flake_service.update_flake_input(1877pytest-impure>                             input_name,1878pytest-impure>                             flake.file_path,1879pytest-impure>                             str(worktree_path),1880pytest-impure>                         )1881pytest-impure>     1882pytest-impure>                         # Commit changes1883pytest-impure>                         commit_message = f"Update {input_name}{parent_suffix}"1884pytest-impure>                         if gitea_service.commit_changes(1885pytest-impure>                             branch_name,1886pytest-impure>                             commit_message,1887pytest-impure>                             worktree_path,1888pytest-impure>                         ):1889pytest-impure>                             # Create pull request1890pytest-impure>                             pr_title = commit_message1891pytest-impure>                             pr_body = (1892pytest-impure>                                 f"This PR updates the `{input_name}` input "1893pytest-impure>                                 f"in `{flake.file_path}`.\n\n"1894pytest-impure>                                 "Generated by update-flake-inputs action."1895pytest-impure>                             )1896pytest-impure>                             gitea_service.create_pull_request(1897pytest-impure>                                 branch_name,1898pytest-impure>                                 base_branch,1899pytest-impure>                                 pr_title,1900pytest-impure>                                 pr_body,1901pytest-impure>                                 auto_merge=auto_merge,1902pytest-impure>                             )1903pytest-impure>                         else:1904pytest-impure>                             logger.info(1905pytest-impure>                                 "No changes for input %s in %s",1906pytest-impure>                                 input_name,1907pytest-impure>                                 flake.file_path,1908pytest-impure>                             )1909pytest-impure>                             gitea_service.delete_branch(branch_name)1910pytest-impure>     1911pytest-impure>                 except Exception:1912pytest-impure>                     logger.exception(1913pytest-impure>                         "Failed to update input %s in %s",1914pytest-impure>                         input_name,1915pytest-impure>                         flake.file_path,1916pytest-impure>                     )1917pytest-impure>                     failed_inputs.append(f"{input_name} in {flake.file_path}")1918pytest-impure>     1919pytest-impure>         if failed_inputs:1920pytest-impure>             msg = f"Failed to process {len(failed_inputs)} input(s): {', '.join(failed_inputs)}"1921pytest-impure> >           raise UpdateFlakeInputsError(msg)1922pytest-impure> E           update_flake_inputs.exceptions.UpdateFlakeInputsError: Failed to process 2 input(s): bad-input in flake.nix, flake-utils in flake.nix1923pytest-impure> 1924pytest-impure> src/update_flake_inputs/cli.py:268: UpdateFlakeInputsError1925pytest-impure> 1926pytest-impure> During handling of the above exception, another exception occurred:1927pytest-impure> 1928pytest-impure> self = <tests.test_process_flake_updates.TestProcessFlakeUpdates object at 0xfffff5e4a8b0>1929pytest-impure> tmp_path = PosixPath('/build/pytest-of-nixbld/pytest-0/test_fails_at_end_when_individ0')1930pytest-impure> fixtures_path = PosixPath('/build/src/tests/fixtures')1931pytest-impure> 1932pytest-impure>         @pytest.mark.impure1933pytest-impure>         def test_fails_at_end_when_individual_input_fails(1934pytest-impure>             self,1935pytest-impure>             tmp_path: Path,1936pytest-impure>             fixtures_path: Path,1937pytest-impure>         ) -> None:1938pytest-impure>             """Test that the action continues updating other inputs but fails at the end."""1939pytest-impure>             flake_content = """{1940pytest-impure>       inputs = {1941pytest-impure>         flake-utils.url = "github:numtide/flake-utils";1942pytest-impure>       };1943pytest-impure>     1944pytest-impure>       outputs = { self, flake-utils }: {1945pytest-impure>         # Test flake with updatable input1946pytest-impure>       };1947pytest-impure>     }"""1948pytest-impure>     1949pytest-impure>             (tmp_path / "flake.nix").write_text(flake_content)1950pytest-impure>     1951pytest-impure>             shutil.copy(1952pytest-impure>                 fixtures_path / "minimal" / "flake.lock",1953pytest-impure>                 tmp_path / "flake.lock",1954pytest-impure>             )1955pytest-impure>     1956pytest-impure>             _setup_git_repo(tmp_path)1957pytest-impure>     1958pytest-impure>             original_cwd = Path.cwd()1959pytest-impure>             os.chdir(tmp_path)1960pytest-impure>     1961pytest-impure>             try:1962pytest-impure>                 # FailingFlakeService injects "bad-input" during discovery and1963pytest-impure>                 # raises when asked to update it, simulating a 403 or dead ref1964pytest-impure>                 flake_service = FailingFlakeService(fail_inputs=["bad-input"])1965pytest-impure>                 test_gitea_service = MockGiteaService()1966pytest-impure>     1967pytest-impure> >               with pytest.raises(UpdateFlakeInputsError, match="Failed to process 1 input"):1968pytest-impure>                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^1969pytest-impure> E               AssertionError: Regex pattern did not match.1970pytest-impure> E                 Expected regex: 'Failed to process 1 input'1971pytest-impure> E                 Actual message: 'Failed to process 2 input(s): bad-input in flake.nix, flake-utils in flake.nix'1972pytest-impure> 1973pytest-impure> tests/test_process_flake_updates.py:596: AssertionError1974pytest-impure> ----------------------------- Captured stdout call -----------------------------1975pytest-impure> Initialized empty Git repository in /build/pytest-of-nixbld/pytest-0/test_fails_at_end_when_individ0/.git/1976pytest-impure> [main (root-commit) ab6bc56] Initial commit1977pytest-impure>  2 files changed, 53 insertions(+)1978pytest-impure>  create mode 100644 flake.lock1979pytest-impure>  create mode 100644 flake.nix1980pytest-impure> Initialized empty Git repository in /build/pytest-of-nixbld/pytest-0/remote-test_fails_at_end_when_individ0.git/1981pytest-impure> branch 'main' set up to track 'origin/main'.1982pytest-impure> branch 'update-bad-input' set up to track 'origin/main'.1983pytest-impure> HEAD is now at ab6bc56 Initial commit1984pytest-impure> branch 'update-flake-utils' set up to track 'origin/main'.1985pytest-impure> HEAD is now at ab6bc56 Initial commit1986pytest-impure> ----------------------------- Captured stderr call -----------------------------1987pytest-impure> hint: Using 'master' as the name for the initial branch. This default branch name1988pytest-impure> hint: will change to "main" in Git 3.0. To configure the initial branch name1989pytest-impure> hint: to use in all of your new repositories, which will suppress this warning,1990pytest-impure> hint: call:1991pytest-impure> hint:1992pytest-impure> hint: 	git config --global init.defaultBranch <name>1993pytest-impure> hint:1994pytest-impure> hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and1995pytest-impure> hint: 'development'. The just-created branch can be renamed via this command:1996pytest-impure> hint:1997pytest-impure> hint: 	git branch -m <name>1998pytest-impure> hint:1999pytest-impure> hint: Disable this message with "git config set advice.defaultBranchName false"2000pytest-impure> To /build/pytest-of-nixbld/pytest-0/remote-test_fails_at_end_when_individ0.git2001pytest-impure>  * [new branch]      main -> main2002pytest-impure> From /build/pytest-of-nixbld/pytest-0/remote-test_fails_at_end_when_individ02003pytest-impure>  * branch            main       -> FETCH_HEAD2004pytest-impure> Preparing worktree (new branch 'update-bad-input')2005pytest-impure> From /build/pytest-of-nixbld/pytest-0/remote-test_fails_at_end_when_individ02006pytest-impure>  * branch            main       -> FETCH_HEAD2007pytest-impure> Preparing worktree (new branch 'update-flake-utils')2008pytest-impure> ------------------------------ Captured log call -------------------------------2009pytest-impure> ERROR    update_flake_inputs.cli:cli.py:259 Failed to update input bad-input in flake.nix2010pytest-impure> Traceback (most recent call last):2011pytest-impure>   File "/build/src/src/update_flake_inputs/cli.py", line 223, in process_flake_updates2012pytest-impure>     flake_service.update_flake_input(2013pytest-impure>     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^2014pytest-impure>         input_name,2015pytest-impure>         ^^^^^^^^^^^2016pytest-impure>         flake.file_path,2017pytest-impure>         ^^^^^^^^^^^^^^^^2018pytest-impure>         str(worktree_path),2019pytest-impure>         ^^^^^^^^^^^^^^^^^^^2020pytest-impure>     )2021pytest-impure>     ^2022pytest-impure>   File "/build/src/tests/test_process_flake_updates.py", line 635, in update_flake_input2023pytest-impure>     raise FlakeServiceError(msg)2024pytest-impure> update_flake_inputs.exceptions.FlakeServiceError: Simulated failure updating bad-input2025pytest-impure> ERROR    update_flake_inputs.flake_service:flake_service.py:223 Failed to update flake input flake-utils in flake.nix. Exit code: 12026pytest-impure> Stdout: No stdout output2027pytest-impure> Stderr: warning: you don't have Internet access; disabling some network-dependent features2028pytest-impure> error:2029pytest-impure>        … while updating the lock file of flake 'git+file:///build/flake-update-glyc96v6/update-flake-utils?ref=refs/heads/update-flake-utils&rev=ab6bc5674366df97d871a1832ebbc1e7ffabe138&shallow=1'2030pytest-impure> 2031pytest-impure>        … while updating the flake input 'flake-utils'2032pytest-impure> 2033pytest-impure>        … while fetching the input 'github:numtide/flake-utils'2034pytest-impure> 2035pytest-impure>        error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com2036pytest-impure> Traceback (most recent call last):2037pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 191, in update_flake_input2038pytest-impure>     result = subprocess.run(2039pytest-impure>         [2040pytest-impure>     ...<10 lines>...2041pytest-impure>         check=True,2042pytest-impure>     )2043pytest-impure>   File "/nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py", line 577, in run2044pytest-impure>     raise CalledProcessError(retcode, process.args,2045pytest-impure>                              output=stdout, stderr=stderr)2046pytest-impure> subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-glyc96v6/update-flake-utils?shallow=1', 'flake-utils']' returned non-zero exit status 1.2047pytest-impure> ERROR    update_flake_inputs.cli:cli.py:259 Failed to update input flake-utils in flake.nix2048pytest-impure> Traceback (most recent call last):2049pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 191, in update_flake_input2050pytest-impure>     result = subprocess.run(2051pytest-impure>         [2052pytest-impure>     ...<10 lines>...2053pytest-impure>         check=True,2054pytest-impure>     )2055pytest-impure>   File "/nix/store/xvl4pzq8il9wbdspslib7hs5wlhz73cf-python3-3.13.13-env/lib/python3.13/subprocess.py", line 577, in run2056pytest-impure>     raise CalledProcessError(retcode, process.args,2057pytest-impure>                              output=stdout, stderr=stderr)2058pytest-impure> subprocess.CalledProcessError: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-glyc96v6/update-flake-utils?shallow=1', 'flake-utils']' returned non-zero exit status 1.2059pytest-impure> 2060pytest-impure> The above exception was the direct cause of the following exception:2061pytest-impure> 2062pytest-impure> Traceback (most recent call last):2063pytest-impure>   File "/build/src/src/update_flake_inputs/cli.py", line 223, in process_flake_updates2064pytest-impure>     flake_service.update_flake_input(2065pytest-impure>     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^2066pytest-impure>         input_name,2067pytest-impure>         ^^^^^^^^^^^2068pytest-impure>         flake.file_path,2069pytest-impure>         ^^^^^^^^^^^^^^^^2070pytest-impure>         str(worktree_path),2071pytest-impure>         ^^^^^^^^^^^^^^^^^^^2072pytest-impure>     )2073pytest-impure>     ^2074pytest-impure>   File "/build/src/tests/test_process_flake_updates.py", line 636, in update_flake_input2075pytest-impure>     super().update_flake_input(input_name, flake_file, work_dir)2076pytest-impure>     ~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^2077pytest-impure>   File "/build/src/src/update_flake_inputs/flake_service.py", line 235, in update_flake_input2078pytest-impure>     raise FlakeServiceError(msg) from e2079pytest-impure> update_flake_inputs.exceptions.FlakeServiceError: Failed to update flake input flake-utils in flake.nix: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-glyc96v6/update-flake-utils?shallow=1', 'flake-utils']' returned non-zero exit status 1.2080pytest-impure> Stderr: warning: you don't have Internet access; disabling some network-dependent features2081pytest-impure> error:2082pytest-impure>        … while updating the lock file of flake 'git+file:///build/flake-update-glyc96v6/update-flake-utils?ref=refs/heads/update-flake-utils&rev=ab6bc5674366df97d871a1832ebbc1e7ffabe138&shallow=1'2083pytest-impure> 2084pytest-impure>        … while updating the flake input 'flake-utils'2085pytest-impure> 2086pytest-impure>        … while fetching the input 'github:numtide/flake-utils'2087pytest-impure> 2088pytest-impure>        error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com2089pytest-impure> =========================== short test summary info ============================2090pytest-impure> FAILED tests/test_flake_service.py::TestFlakeService::test_update_flake_input2091pytest-impure> FAILED tests/test_flake_service.py::TestFlakeService::test_update_subflake_input2092pytest-impure> FAILED tests/test_process_flake_updates.py::TestProcessFlakeUpdates::test_with_updatable_flake_input2093pytest-impure> FAILED tests/test_process_flake_updates.py::TestProcessFlakeUpdates::test_worktree_based_on_base_branch_not_head2094pytest-impure> FAILED tests/test_process_flake_updates.py::TestProcessFlakeUpdates::test_custom_git_author_committer2095pytest-impure> FAILED tests/test_process_flake_updates.py::TestProcessFlakeUpdates::test_branch_suffix2096pytest-impure> FAILED tests/test_process_flake_updates.py::TestProcessFlakeUpdates::test_fails_at_end_when_individual_input_fails2097pytest-impure> 7 failed, 16 passed in 74.17s (0:01:14)2098error: Cannot build '/nix/store/ghfwljvv218bclhvr7d6qg36f2xlj2x2-pytest-impure.drv'.2099       Reason: builder failed with exit code 1.2100       Last 25 log lines:2101       >     ^2102       >   File "/build/src/tests/test_process_flake_updates.py", line 636, in update_flake_input2103       >     super().update_flake_input(input_name, flake_file, work_dir)2104       >     ~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^2105       >   File "/build/src/src/update_flake_inputs/flake_service.py", line 235, in update_flake_input2106       >     raise FlakeServiceError(msg) from e2107       > update_flake_inputs.exceptions.FlakeServiceError: Failed to update flake input flake-utils in flake.nix: Command '['nix', 'flake', 'update', '--flake', 'git+file:///build/flake-update-glyc96v6/update-flake-utils?shallow=1', 'flake-utils']' returned non-zero exit status 1.2108       > Stderr: warning: you don't have Internet access; disabling some network-dependent features2109       > error:2110       >        … while updating the lock file of flake 'git+file:///build/flake-update-glyc96v6/update-flake-utils?ref=refs/heads/update-flake-utils&rev=ab6bc5674366df97d871a1832ebbc1e7ffabe138&shallow=1'2111       >2112       >        … while updating the flake input 'flake-utils'2113       >2114       >        … while fetching the input 'github:numtide/flake-utils'2115       >2116       >        error: unable to download 'https://api.github.com/repos/numtide/flake-utils/commits/HEAD': Could not resolve hostname (6) Could not resolve host: api.github.com2117       > =========================== short test summary info ============================2118       > FAILED tests/test_flake_service.py::TestFlakeService::test_update_flake_input2119       > FAILED tests/test_flake_service.py::TestFlakeService::test_update_subflake_input2120       > FAILED tests/test_process_flake_updates.py::TestProcessFlakeUpdates::test_with_updatable_flake_input2121       > FAILED tests/test_process_flake_updates.py::TestProcessFlakeUpdates::test_worktree_based_on_base_branch_not_head2122       > FAILED tests/test_process_flake_updates.py::TestProcessFlakeUpdates::test_custom_git_author_committer2123       > FAILED tests/test_process_flake_updates.py::TestProcessFlakeUpdates::test_branch_suffix2124       > FAILED tests/test_process_flake_updates.py::TestProcessFlakeUpdates::test_fails_at_end_when_individual_input_fails2125       > 7 failed, 16 passed in 74.17s (0:01:14)2126       For full logs, run:2127         nix log /nix/store/ghfwljvv218bclhvr7d6qg36f2xlj2x2-pytest-impure.drv2128error: build of resolved derivation '/nix/store/ghfwljvv218bclhvr7d6qg36f2xlj2x2-pytest-impure.drv' failed212921302131nixbot: transient error detected, retrying once21322133this derivation will be built:2134  /nix/store/x7hglhwnlmjs8d467a6hkin10445ybwa-pytest-impure.drv2135Failed to find a machine for remote build!2136derivation: ghfwljvv218bclhvr7d6qg36f2xlj2x2-pytest-impure.drv2137required (system, features): (aarch64-linux, [ca-derivations])21383 available machines:2139(systems, maxjobs, supportedFeatures, mandatoryFeatures)2140([aarch64-darwin, x86_64-darwin], 8, [big-parallel, recursive-nix], [])2141([i686-linux, x86_64-linux], 128, [big-parallel, kvm, nixos-test, recursive-nix, uid-range], [])2142([aarch64-linux], 128, [big-parallel, kvm, nixos-test, recursive-nix, uid-range], [])2143building '/nix/store/ghfwljvv218bclhvr7d6qg36f2xlj2x2-pytest-impure.drv'2144pytest-impure> tribuchet: building on eliza