commit 738ff237df998813cafaeade0368fb1ee722ddad · pyrox.dev/nixpkgs

+6 -3

pkgs/by-name/ni/nixos-rebuild-ng/package.nix

···

       134
       134
        
               # NOTE: this is a passthru test rather than a build-time test because we

     

       135
       135
        
               # want to keep the build closures small

     

       136
       136
        
               linters = runCommand "${pname}-linters" { nativeBuildInputs = [ python-with-pkgs ]; } ''

     

       137
       137
       +
                 export MYPY_CACHE_DIR="$(mktemp -d)"

     

       137
       138
        
                 export RUFF_CACHE_DIR="$(mktemp -d)"

     

       138
       139
        
       

     

       140
       140
       +
                 pushd ${src}

     

       139
       141
        
                 echo -e "\x1b[32m## run mypy\x1b[0m"

     

       140
       140
       -
                 mypy ${src}

     

       142
       142
       +
                 mypy .

     

       141
       143
        
                 echo -e "\x1b[32m## run ruff\x1b[0m"

     

       142
       142
       -
                 ruff check ${src}

     

       144
       144
       +
                 ruff check .

     

       143
       145
        
                 echo -e "\x1b[32m## run ruff format\x1b[0m"

     

       144
       144
       -
                 ruff format --check ${src}

     

       146
       146
       +
                 ruff format --check .

     

       147
       147
       +
                 popd

     

       145
       148
        
       

     

       146
       149
        
                 touch $out

     

       147
       150
        
               '';

pkgs/by-name/ni/nixos-rebuild-ng/src/nixos_rebuild/constants.py

···

       1
       1
       +
       # mypy: disable-error-code=comparison-overlap

     

       1
       2
        
       from typing import Final

     

       2
       3
        
       

     

       3
       4
        
       # Build-time flags

+10 -11

pkgs/by-name/ni/nixos-rebuild-ng/src/nixos_rebuild/models.py

···

       8
       8
        
       

     

       9
       9
        
       from .process import Remote, run_wrapper

     

       10
       10
        
       

     

       11
       11
       -
       type ImageVariants = list[str]

     

       11
       11
       +
       type ImageVariants = dict[str, str]

     

       12
       12
        
       

     

       13
       13
        
       

     

       14
       14
        
       class NixOSRebuildError(Exception):

     
···

       77
       77
        
       

     

       78
       78
        
       @dataclass(frozen=True)

     

       79
       79
        
       class Flake:

     

       80
       80
       -
           path: Path | str

     

       80
       80
       +
           path: str

     

       81
       81
        
           attr: str

     

       82
       82
        
           _re: ClassVar = re.compile(r"^(?P<path>[^\#]*)\#?(?P<attr>[^\#\"]*)$")

     

       83
       83
        
       

     
···

       86
       86
        
       

     

       87
       87
        
           @override

     

       88
       88
        
           def __str__(self) -> str:

     

       89
       89
       -
               if isinstance(self.path, Path):

     

       90
       90
       -
                   # https://github.com/NixOS/nixpkgs/issues/433726

     

       91
       91
       -
                   return f"{self.path.absolute()}#{self.attr}"

     

       92
       92
       -
               else:

     

       93
       93
       -
                   return f"{self.path}#{self.attr}"

     

       89
       89
       +
               return f"{self.path}#{self.attr}"

     

       94
       90
        
       

     

       95
       91
        
           @classmethod

     

       96
       92
        
           def parse(cls, flake_str: str, target_host: Remote | None = None) -> Self:

     
···

       101
       97
        
                   f'nixosConfigurations."{attr or _get_hostname(target_host) or "default"}"'

     

       102
       98
        
               )

     

       103
       99
        
               path = m.group("path")

     

       104
       104
       -
               if ":" in path:

     

       105
       105
       -
                   return cls(path, nixos_attr)

     

       106
       106
       -
               else:

     

       107
       107
       -
                   return cls(Path(path), nixos_attr)

     

       100
       100
       +
               return cls(path, nixos_attr)

     

       108
       101
        
       

     

       109
       102
        
           @classmethod

     

       110
       103
        
           def from_arg(cls, flake_arg: Any, target_host: Remote | None) -> Self | None:  # noqa: ANN401

     
···

       124
       117
        
                           return cls.parse(str(default_path.parent), target_host)

     

       125
       118
        
                       else:

     

       126
       119
        
                           return None

     

       120
       120
       +
       

     

       121
       121
       +
           def resolve_path_if_exists(self) -> str:

     

       122
       122
       +
               try:

     

       123
       123
       +
                   return str(Path(self.path).resolve(strict=True))

     

       124
       124
       +
               except FileNotFoundError:

     

       125
       125
       +
                   return self.path

     

       127
       126
        
       

     

       128
       127
        
       

     

       129
       128
        
       @dataclass(frozen=True)

+1 -1

pkgs/by-name/ni/nixos-rebuild-ng/src/nixos_rebuild/nix.py

···

       545
       545
        
               files(__package__).joinpath(FLAKE_REPL_TEMPLATE).read_text()

     

       546
       546
        
           ).substitute(

     

       547
       547
        
               flake=flake,

     

       548
       548
       -
               flake_path=flake.path.resolve() if isinstance(flake.path, Path) else flake.path,

     

       548
       548
       +
               flake_path=flake.resolve_path_if_exists(),

     

       549
       549
        
               flake_attr=flake.attr,

     

       550
       550
        
               bold="\033[1m",

     

       551
       551
        
               blue="\033[34;1m",

+1 -1

pkgs/by-name/ni/nixos-rebuild-ng/src/nixos_rebuild/utils.py

···

       14
       14
        
           }

     

       15
       15
        
       

     

       16
       16
        
           @override

     

       17
       17
       -
           def format(self, record: logging.LogRecord) -> str:

     

       17
       17
       +
           def format(self, record: logging.LogRecord) -> Any:

     

       18
       18
        
               record.levelname = record.levelname.lower()

     

       19
       19
        
               formatter = self.formatters.get(record.levelno, self.formatters["DEFAULT"])

     

       20
       20
        
               return formatter.format(record)

+29 -15

pkgs/by-name/ni/nixos-rebuild-ng/src/tests/test_models.py

···

       33
       33
        
       @patch("platform.node", autospec=True, return_value=None)

     

       34
       34
        
       def test_flake_parse(mock_node: Mock, tmpdir: Path, monkeypatch: MonkeyPatch) -> None:

     

       35
       35
        
           assert m.Flake.parse("/path/to/flake#attr") == m.Flake(

     

       36
       36
       -
               Path("/path/to/flake"), 'nixosConfigurations."attr"'

     

       36
       36
       +
               "/path/to/flake", 'nixosConfigurations."attr"'

     

       37
       37
        
           )

     

       38
       38
        
           assert m.Flake.parse("/path/ to /flake") == m.Flake(

     

       39
       39
       -
               Path("/path/ to /flake"), 'nixosConfigurations."default"'

     

       39
       39
       +
               "/path/ to /flake", 'nixosConfigurations."default"'

     

       40
       40
        
           )

     

       41
       41
        
           with patch(

     

       42
       42
        
               get_qualified_name(m.run_wrapper, m),

     
···

       45
       45
        
           ):

     

       46
       46
        
               target_host = m.Remote("target@remote", [], None)

     

       47
       47
        
               assert m.Flake.parse("/path/to/flake", target_host) == m.Flake(

     

       48
       48
       -
                   Path("/path/to/flake"), 'nixosConfigurations."remote"'

     

       48
       48
       +
                   "/path/to/flake", 'nixosConfigurations."remote"'

     

       49
       49
        
               )

     

       50
       50
       -
           assert m.Flake.parse(".#attr") == m.Flake(Path("."), 'nixosConfigurations."attr"')

     

       51
       51
       -
           assert m.Flake.parse("#attr") == m.Flake(Path("."), 'nixosConfigurations."attr"')

     

       52
       52
       -
           assert m.Flake.parse(".") == m.Flake(Path("."), 'nixosConfigurations."default"')

     

       50
       50
       +
           assert m.Flake.parse(".#attr") == m.Flake(".", 'nixosConfigurations."attr"')

     

       51
       51
       +
           assert m.Flake.parse("#attr") == m.Flake("", 'nixosConfigurations."attr"')

     

       52
       52
       +
           assert m.Flake.parse(".") == m.Flake(".", 'nixosConfigurations."default"')

     

       53
       53
        
           assert m.Flake.parse("path:/to/flake#attr") == m.Flake(

     

       54
       54
        
               "path:/to/flake", 'nixosConfigurations."attr"'

     

       55
       55
        
           )

     
···

       64
       64
        
       

     

       65
       65
        
       def test_flake_to_attr() -> None:

     

       66
       66
        
           assert (

     

       67
       67
       -
               m.Flake(Path("/path/to/flake"), "nixosConfigurations.preAttr").to_attr(

     

       67
       67
       +
               m.Flake("/path/to/flake", "nixosConfigurations.preAttr").to_attr(

     

       68
       68
        
                   "attr1", "attr2"

     

       69
       69
        
               )

     

       70
       70
        
               == "/path/to/flake#nixosConfigurations.preAttr.attr1.attr2"

     

       71
       71
        
           )

     

       72
       72
        
       

     

       73
       73
        
       

     

       74
       74
       -
       def test_flake__str__(monkeypatch: MonkeyPatch, tmpdir: Path) -> None:

     

       74
       74
       +
       def test_flake__str__() -> None:

     

       75
       75
        
           assert str(m.Flake("github:nixos/nixpkgs", "attr")) == "github:nixos/nixpkgs#attr"

     

       76
       76
       -
           assert str(m.Flake(Path("/etc/nixos"), "attr")) == "/etc/nixos#attr"

     

       76
       76
       +
           assert str(m.Flake("/etc/nixos", "attr")) == "/etc/nixos#attr"

     

       77
       77
       +
           assert str(m.Flake(".", "attr")) == ".#attr"

     

       78
       78
       +
           assert str(m.Flake("", "attr")) == "#attr"

     

       79
       79
       +
       

     

       80
       80
       +
       

     

       81
       81
       +
       def test_flake_resolve_path_if_exists(monkeypatch: MonkeyPatch, tmpdir: Path) -> None:

     

       82
       82
       +
           assert (

     

       83
       83
       +
               m.Flake("github:nixos/nixpkgs", "attr").resolve_path_if_exists()

     

       84
       84
       +
               == "github:nixos/nixpkgs"

     

       85
       85
       +
           )

     

       86
       86
       +
           assert (

     

       87
       87
       +
               m.Flake("/an/inexistent/path", "attr").resolve_path_if_exists()

     

       88
       88
       +
               == "/an/inexistent/path"

     

       89
       89
       +
           )

     

       77
       90
        
           with monkeypatch.context() as patch_context:

     

       78
       91
        
               patch_context.chdir(tmpdir)

     

       79
       79
       -
               assert str(m.Flake(Path("."), "attr")) == f"{tmpdir}#attr"

     

       92
       92
       +
               assert m.Flake(str(tmpdir), "attr").resolve_path_if_exists() == str(tmpdir)

     

       93
       93
       +
               assert m.Flake(".", "attr").resolve_path_if_exists() == str(tmpdir)

     

       80
       94
        
       

     

       81
       95
        
       

     

       82
       96
        
       @patch("platform.node", autospec=True)

     
···

       87
       101
        
       

     

       88
       102
        
           # Flake string

     

       89
       103
        
           assert m.Flake.from_arg("/path/to/flake#attr", None) == m.Flake(

     

       90
       90
       -
               Path("/path/to/flake"), 'nixosConfigurations."attr"'

     

       104
       104
       +
               "/path/to/flake", 'nixosConfigurations."attr"'

     

       91
       105
        
           )

     

       92
       106
        
       

     

       93
       107
        
           # False

     
···

       97
       111
        
           with monkeypatch.context() as patch_context:

     

       98
       112
        
               patch_context.chdir(tmpdir)

     

       99
       113
        
               assert m.Flake.from_arg(True, None) == m.Flake(

     

       100
       100
       -
                   Path("."), 'nixosConfigurations."hostname"'

     

       114
       114
       +
                   ".", 'nixosConfigurations."hostname"'

     

       101
       115
        
               )

     

       102
       116
        
       

     

       103
       117
        
           # None when we do not have /etc/nixos/flake.nix

     
···

       122
       136
        
               ),

     

       123
       137
        
           ):

     

       124
       138
        
               assert m.Flake.from_arg(None, None) == m.Flake(

     

       125
       125
       -
                   Path("/etc/nixos"), 'nixosConfigurations."hostname"'

     

       139
       139
       +
                   "/etc/nixos", 'nixosConfigurations."hostname"'

     

       126
       140
        
               )

     

       127
       141
        
       

     

       128
       142
        
           with (

     
···

       138
       152
        
               ),

     

       139
       153
        
           ):

     

       140
       154
        
               assert m.Flake.from_arg(None, None) == m.Flake(

     

       141
       141
       -
                   Path("/path/to"), 'nixosConfigurations."hostname"'

     

       155
       155
       +
                   "/path/to", 'nixosConfigurations."hostname"'

     

       142
       156
        
               )

     

       143
       157
        
       

     

       144
       158
        
           with (

     
···

       149
       163
        
               ),

     

       150
       164
        
           ):

     

       151
       165
        
               assert m.Flake.from_arg("/path/to", m.Remote("user@host", [], None)) == m.Flake(

     

       152
       152
       -
                   Path("/path/to"), 'nixosConfigurations."remote-hostname"'

     

       166
       166
       +
                   "/path/to", 'nixosConfigurations."remote-hostname"'

     

       153
       167
        
               )

     

       154
       168
        
       

     

       155
       169

+2 -2

pkgs/by-name/ni/nixos-rebuild-ng/src/tests/test_nix.py

···

       385
       385
        
           ),

     

       386
       386
        
       )

     

       387
       387
        
       def test_get_build_image_variants_flake(mock_run: Mock) -> None:

     

       388
       388
       -
           flake = m.Flake(Path("/flake.nix"), "myAttr")

     

       388
       388
       +
           flake = m.Flake("/flake.nix", "myAttr")

     

       389
       389
        
           assert n.get_build_image_variants_flake(flake, {"eval_flag": True}) == {

     

       390
       390
        
               "azure": "nixos-image-azure-25.05.20250102.6df2492-x86_64-linux.vhd",

     

       391
       391
        
               "vmware": "nixos-image-vmware-25.05.20250102.6df2492-x86_64-linux.vmdk",

     
···

       574
       574
        
       

     

       575
       575
        
       @patch(get_qualified_name(n.run_wrapper, n), autospec=True)

     

       576
       576
        
       def test_repl_flake(mock_run: Mock) -> None:

     

       577
       577
       -
           n.repl_flake(m.Flake(Path("flake.nix"), "myAttr"), {"nix_flag": True})

     

       577
       577
       +
           n.repl_flake(m.Flake("flake.nix", "myAttr"), {"nix_flag": True})

     

       578
       578
        
           # See nixos-rebuild-ng.tests.repl for a better test,

     

       579
       579
        
           # this is mostly for sanity check

     

       580
       580
        
           assert mock_run.call_count == 1