commit 53dd1a6edb97724994c8d95995d0a2da41a4d61b · pyrox.dev/nixpkgs

+68 -18

doc/languages-frameworks/python.section.md

···

       101
       101
        
       buildPythonPackage rec {

     

       102
       102
        
         pname = "pytest";

     

       103
       103
        
         version = "3.3.1";

     

       104
       104
       -
         format = "setuptools";

     

       104
       104
       +
         pyproject = true;

     

       105
       105
        
       

     

       106
       106
        
         src = fetchPypi {

     

       107
       107
        
           inherit pname version;

     
···

       167
       167
        
       * `dontWrapPythonPrograms ? false`: Skip wrapping of Python programs.

     

       168
       168
        
       * `permitUserSite ? false`: Skip setting the `PYTHONNOUSERSITE` environment

     

       169
       169
        
         variable in wrapped programs.

     

       170
       170
       -
       * `format ? "setuptools"`: Format of the source. Valid options are

     

       171
       171
       -
         `"setuptools"`, `"pyproject"`, `"flit"`, `"wheel"`, and `"other"`.

     

       172
       172
       -
         `"setuptools"` is for when the source has a `setup.py` and `setuptools` is

     

       173
       173
       -
         used to build a wheel, `flit`, in case `flit` should be used to build a wheel,

     

       174
       174
       -
         and `wheel` in case a wheel is provided. Use `other` when a custom

     

       175
       175
       -
         `buildPhase` and/or `installPhase` is needed.

     

       170
       170
       +
       * `pyproject`: Whether the pyproject format should be used. When set to `true`,

     

       171
       171
       +
         `pypaBuildHook` will be used, and you can add the required build dependencies

     

       172
       172
       +
         from `build-system.requires` to `nativeBuildInputs`. Note that the pyproject

     

       173
       173
       +
         format falls back to using `setuptools`, so you can use `pyproject = true`

     

       174
       174
       +
         even if the package only has a `setup.py`. When set to `false`, you can

     

       175
       175
       +
         use the existing [hooks](#setup-hooks0 or provide your own logic to build the

     

       176
       176
       +
         package. This can be useful for packages that don't support the pyproject

     

       177
       177
       +
         format. When unset, the legacy `setuptools` hooks are used for backwards

     

       178
       178
       +
         compatibility.

     

       176
       179
        
       * `makeWrapperArgs ? []`: A list of strings. Arguments to be passed to

     

       177
       180
        
         `makeWrapper`, which wraps generated binaries. By default, the arguments to

     

       178
       181
        
         `makeWrapper` set `PATH` and `PYTHONPATH` environment variables before calling

     
···

       286
       289
        
       python3.pkgs.buildPythonApplication rec {

     

       287
       290
        
         pname = "luigi";

     

       288
       291
        
         version = "2.7.9";

     

       289
       289
       -
         format = "setuptools";

     

       292
       292
       +
         pyproject = true;

     

       290
       293
        
       

     

       291
       294
        
         src = fetchPypi {

     

       292
       295
        
           inherit pname version;

     

       293
       296
        
           hash  = "sha256-Pe229rT0aHwA98s+nTHQMEFKZPo/yw6sot8MivFDvAw=";

     

       294
       297
        
         };

     

       295
       298
        
       

     

       299
       299
       +
         nativeBuildInputs = [

     

       300
       300
       +
           python3.pkgs.setuptools

     

       301
       301
       +
           python3.pkgs.wheel

     

       302
       302
       +
         ];

     

       303
       303
       +
       

     

       296
       304
        
         propagatedBuildInputs = with python3.pkgs; [

     

       297
       305
        
           tornado

     

       298
       306
        
           python-daemon

     

       299
       307
        
         ];

     

       300
       308
        
       

     

       301
       309
        
         meta = with lib; {

     

       302
       302
       -
           ...

     

       310
       310
       +
           # ...

     

       303
       311
        
         };

     

       304
       312
        
       }

     

       305
       313
        
       ```

     
···

       858
       866
        
       { lib

     

       859
       867
        
       , buildPythonPackage

     

       860
       868
        
       , fetchPypi

     

       869
       869
       +
       , setuptools

     

       870
       870
       +
       , wheel

     

       861
       871
        
       }:

     

       862
       872
        
       

     

       863
       873
        
       buildPythonPackage rec {

     

       864
       874
        
         pname = "toolz";

     

       865
       875
        
         version = "0.10.0";

     

       866
       866
       -
         format = "setuptools";

     

       876
       876
       +
         pyproject = true;

     

       867
       877
        
       

     

       868
       878
        
         src = fetchPypi {

     

       869
       879
        
           inherit pname version;

     

       870
       880
        
           hash = "sha256-CP3V73yWSArRHBLUct4hrNMjWZlvaaUlkpm1QP66RWA=";

     

       871
       881
        
         };

     

       882
       882
       +
       

     

       883
       883
       +
         nativeBuildInputs = [

     

       884
       884
       +
           setuptools

     

       885
       885
       +
           wheel

     

       886
       886
       +
         ];

     

       872
       887
        
       

     

       873
       888
        
         # has no tests

     

       874
       889
        
         doCheck = false;

     
···

       918
       933
        
           my_toolz = python311.pkgs.buildPythonPackage rec {

     

       919
       934
        
             pname = "toolz";

     

       920
       935
        
             version = "0.10.0";

     

       921
       921
       -
             format = "setuptools";

     

       936
       936
       +
             pyproject = true;

     

       922
       937
        
       

     

       923
       938
        
             src = fetchPypi {

     

       924
       939
        
               inherit pname version;

     

       925
       940
        
               hash = "sha256-CP3V73yWSArRHBLUct4hrNMjWZlvaaUlkpm1QP66RWA=";

     

       926
       941
        
             };

     

       942
       942
       +
       

     

       943
       943
       +
             nativeBuildInputs = [

     

       944
       944
       +
               python311.pkgs.setuptools

     

       945
       945
       +
               python311.pkgs.wheel

     

       946
       946
       +
             ];

     

       927
       947
        
       

     

       928
       948
        
             # has no tests

     

       929
       949
        
             doCheck = false;

     
···

       972
       992
        
       , buildPythonPackage

     

       973
       993
        
       , fetchPypi

     

       974
       994
        
       

     

       995
       995
       +
       # build dependencies

     

       996
       996
       +
       , setuptools, wheel

     

       997
       997
       +
       

     

       975
       998
        
       # dependencies

     

       976
       999
        
       , numpy, multipledispatch, python-dateutil

     

       977
       1000
        
       

     
···

       982
       1005
        
       buildPythonPackage rec {

     

       983
       1006
        
         pname = "datashape";

     

       984
       1007
        
         version = "0.4.7";

     

       985
       985
       -
         format = "setuptools";

     

       1008
       1008
       +
         pyproject = true;

     

       986
       1009
        
       

     

       987
       1010
        
         src = fetchPypi {

     

       988
       1011
        
           inherit pname version;

     

       989
       1012
        
           hash = "sha256-FLLvdm1MllKrgTGC6Gb0k0deZeVYvtCCLji/B7uhong=";

     

       990
       1013
        
         };

     

       1014
       1014
       +
       

     

       1015
       1015
       +
         nativeBuildInputs = [

     

       1016
       1016
       +
           setuptools

     

       1017
       1017
       +
           wheel

     

       1018
       1018
       +
         ];

     

       991
       1019
        
       

     

       992
       1020
        
         propagatedBuildInputs = [

     

       993
       1021
        
           multipledispatch

     
···

       1023
       1051
        
       { lib

     

       1024
       1052
        
       , buildPythonPackage

     

       1025
       1053
        
       , fetchPypi

     

       1054
       1054
       +
       , setuptools

     

       1055
       1055
       +
       , wheel

     

       1026
       1056
        
       , libxml2

     

       1027
       1057
        
       , libxslt

     

       1028
       1058
        
       }:

     
···

       1030
       1060
        
       buildPythonPackage rec {

     

       1031
       1061
        
         pname = "lxml";

     

       1032
       1062
        
         version = "3.4.4";

     

       1033
       1033
       -
         format = "setuptools";

     

       1063
       1063
       +
         pyproject = true;

     

       1034
       1064
        
       

     

       1035
       1065
        
         src = fetchPypi {

     

       1036
       1066
        
           inherit pname version;

     

       1037
       1067
        
           hash = "sha256-s9NiusRxFydHzaNRMjjxFcvWxfi45jGb9ql6eJJyQJk=";

     

       1038
       1068
        
         };

     

       1069
       1069
       +
       

     

       1070
       1070
       +
         nativeBuildInputs = [

     

       1071
       1071
       +
           setuptools

     

       1072
       1072
       +
           wheel

     

       1073
       1073
       +
         ];

     

       1039
       1074
        
       

     

       1040
       1075
        
         buildInputs = [

     

       1041
       1076
        
           libxml2

     
···

       1066
       1101
        
       { lib

     

       1067
       1102
        
       , buildPythonPackage

     

       1068
       1103
        
       , fetchPypi

     

       1104
       1104
       +
       

     

       1105
       1105
       +
       # build dependencies

     

       1106
       1106
       +
       , setuptools

     

       1107
       1107
       +
       , wheel

     

       1069
       1108
        
       

     

       1070
       1109
        
       # dependencies

     

       1071
       1110
        
       , fftw

     
···

       1078
       1117
        
       buildPythonPackage rec {

     

       1079
       1118
        
         pname = "pyFFTW";

     

       1080
       1119
        
         version = "0.9.2";

     

       1081
       1081
       -
         format = "setuptools";

     

       1120
       1120
       +
         pyproject = true;

     

       1082
       1121
        
       

     

       1083
       1122
        
         src = fetchPypi {

     

       1084
       1123
        
           inherit pname version;

     

       1085
       1124
        
           hash = "sha256-9ru2r6kwhUCaskiFoaPNuJCfCVoUL01J40byvRt4kHQ=";

     

       1086
       1125
        
         };

     

       1126
       1126
       +
       

     

       1127
       1127
       +
         nativeBuildInputs = [

     

       1128
       1128
       +
           setuptools

     

       1129
       1129
       +
           wheel

     

       1130
       1130
       +
         ];

     

       1087
       1131
        
       

     

       1088
       1132
        
         buildInputs = [

     

       1089
       1133
        
           fftw

     
···

       1334
       1378
        
       

     

       1335
       1379
        
       Keep in mind that while the examples above are done with `requirements.txt`,

     

       1336
       1380
        
       `pythonRelaxDepsHook` works by modifying the resulting wheel file, so it should

     

       1337
       1337
       -
       work in any of the formats supported by `buildPythonPackage` currently,

     

       1338
       1338
       -
       with the exception of `other` (see `format` in

     

       1339
       1339
       -
       [`buildPythonPackage` parameters](#buildpythonpackage-parameters) for more details).

     

       1381
       1381
       +
       work with any of the existing [hooks](#setup-hooks).

     

       1340
       1382
        
       

     

       1341
       1383
        
       #### Using unittestCheckHook {#using-unittestcheckhook}

     

       1342
       1384
        
       

     
···

       1461
       1503
        
       ```nix

     

       1462
       1504
        
       { lib

     

       1463
       1505
        
       , buildPythonPackage

     

       1506
       1506
       +
       , fetchPypi

     

       1507
       1507
       +
       , setuptools

     

       1508
       1508
       +
       , wheel

     

       1464
       1509
        
       }:

     

       1465
       1510
        
       

     

       1466
       1511
        
       buildPythonPackage rec {

     

       1467
       1512
        
         pname = "toolz";

     

       1468
       1513
        
         version = "0.10.0";

     

       1469
       1469
       -
         format = "setuptools";

     

       1514
       1514
       +
         pyproject = true;

     

       1470
       1515
        
       

     

       1471
       1516
        
         src = fetchPypi {

     

       1472
       1517
        
           inherit pname version;

     

       1473
       1518
        
           hash = "sha256-CP3V73yWSArRHBLUct4hrNMjWZlvaaUlkpm1QP66RWA=";

     

       1474
       1519
        
         };

     

       1520
       1520
       +
       

     

       1521
       1521
       +
         nativeBuildInputs = [

     

       1522
       1522
       +
           setuptools

     

       1523
       1523
       +
           wheel

     

       1524
       1524
       +
         ];

     

       1475
       1525
        
       

     

       1476
       1526
        
         meta = with lib; {

     

       1477
       1527
        
           changelog = "https://github.com/pytoolz/toolz/releases/tag/${version}";

+1 -1

pkgs/applications/networking/seahub/default.nix

···

       22
       22
        
       python.pkgs.buildPythonApplication rec {

     

       23
       23
        
         pname = "seahub";

     

       24
       24
        
         version = "9.0.10";

     

       25
       25
       -
         format = "other";

     

       25
       25
       +
         pyproject = false;

     

       26
       26
        
       

     

       27
       27
        
         src = fetchFromGitHub {

     

       28
       28
        
           owner = "haiwen";

+28 -10

pkgs/development/interpreters/python/mk-python-derivation.nix

···

       82
       82
        
       # However, some packages do provide executables with extensions, and thus bytecode is generated.

     

       83
       83
        
       , removeBinBytecode ? true

     

       84
       84
        
       

     

       85
       85
       +
       # pyproject = true <-> format = "pyproject"

     

       86
       86
       +
       # pyproject = false <-> format = "other"

     

       87
       87
       +
       # https://github.com/NixOS/nixpkgs/issues/253154

     

       88
       88
       +
       , pyproject ? null

     

       89
       89
       +
       

     

       85
       90
        
       # Several package formats are supported.

     

       86
       91
        
       # "setuptools" : Install a common setuptools/distutils based package. This builds a wheel.

     

       87
       92
        
       # "wheel" : Install from a pre-compiled wheel.

     
···

       89
       94
        
       # "pyproject": Install a package using a ``pyproject.toml`` file (PEP517). This builds a wheel.

     

       90
       95
        
       # "egg": Install a package from an egg.

     

       91
       96
        
       # "other" : Provide your own buildPhase and installPhase.

     

       92
       92
       -
       , format ? "setuptools"

     

       97
       97
       +
       , format ? null

     

       93
       98
        
       

     

       94
       99
        
       , meta ? {}

     

       95
       100
        
       

     
···

       101
       106
        
       

     

       102
       107
        
       , ... } @ attrs:

     

       103
       108
        
       

     

       109
       109
       +
       assert (pyproject != null) -> (format == null);

     

       110
       110
       +
       

     

       104
       111
        
       let

     

       105
       112
        
         inherit (python) stdenv;

     

       106
       113
        
       

     

       107
       107
       -
         withDistOutput = lib.elem format ["pyproject" "setuptools" "flit" "wheel"];

     

       114
       114
       +
         format' =

     

       115
       115
       +
           if pyproject != null then

     

       116
       116
       +
             if pyproject then

     

       117
       117
       +
               "pyproject"

     

       118
       118
       +
             else

     

       119
       119
       +
               "other"

     

       120
       120
       +
           else if format != null then

     

       121
       121
       +
             format

     

       122
       122
       +
           else

     

       123
       123
       +
             "setuptools";

     

       124
       124
       +
       

     

       125
       125
       +
         withDistOutput = lib.elem format' ["pyproject" "setuptools" "flit" "wheel"];

     

       108
       126
        
       

     

       109
       127
        
         name_ = name;

     

       110
       128
        
       

     
···

       177
       195
        
       

     

       178
       196
        
         # Keep extra attributes from `attrs`, e.g., `patchPhase', etc.

     

       179
       197
        
         self = toPythonModule (stdenv.mkDerivation ((builtins.removeAttrs attrs [

     

       180
       180
       -
           "disabled" "checkPhase" "checkInputs" "nativeCheckInputs" "doCheck" "doInstallCheck" "dontWrapPythonPrograms" "catchConflicts" "format"

     

       198
       198
       +
           "disabled" "checkPhase" "checkInputs" "nativeCheckInputs" "doCheck" "doInstallCheck" "dontWrapPythonPrograms" "catchConflicts" "pyproject" "format"

     

       181
       199
        
           "disabledTestPaths" "outputs"

     

       182
       200
        
         ]) // {

     

       183
       201
        
       

     
···

       202
       220
        
             pythonRemoveBinBytecodeHook

     

       203
       221
        
           ] ++ lib.optionals (lib.hasSuffix "zip" (attrs.src.name or "")) [

     

       204
       222
        
             unzip

     

       205
       205
       -
           ] ++ lib.optionals (format == "setuptools") [

     

       223
       223
       +
           ] ++ lib.optionals (format' == "setuptools") [

     

       206
       224
        
             setuptoolsBuildHook

     

       207
       207
       -
           ] ++ lib.optionals (format == "flit") [

     

       225
       225
       +
           ] ++ lib.optionals (format' == "flit") [

     

       208
       226
        
             flitBuildHook

     

       209
       209
       -
           ] ++ lib.optionals (format == "pyproject") [(

     

       227
       227
       +
           ] ++ lib.optionals (format' == "pyproject") [(

     

       210
       228
        
             if isBootstrapPackage then

     

       211
       229
        
               pypaBuildHook.override {

     

       212
       230
        
                 inherit (python.pythonForBuild.pkgs.bootstrap) build;

     
···

       214
       232
        
               }

     

       215
       233
        
             else

     

       216
       234
        
               pypaBuildHook

     

       217
       217
       -
           )] ++ lib.optionals (format == "wheel") [

     

       235
       235
       +
           )] ++ lib.optionals (format' == "wheel") [

     

       218
       236
        
             wheelUnpackHook

     

       219
       219
       -
           ] ++ lib.optionals (format == "egg") [

     

       237
       237
       +
           ] ++ lib.optionals (format' == "egg") [

     

       220
       238
        
             eggUnpackHook eggBuildHook eggInstallHook

     

       221
       221
       -
           ] ++ lib.optionals (format != "other") [(

     

       239
       239
       +
           ] ++ lib.optionals (format' != "other") [(

     

       222
       240
        
             if isBootstrapInstallPackage then

     

       223
       241
        
               pypaInstallHook.override {

     

       224
       242
        
                 inherit (python.pythonForBuild.pkgs.bootstrap) installer;

     
···

       252
       270
        
           doCheck = false;

     

       253
       271
        
           doInstallCheck = attrs.doCheck or true;

     

       254
       272
        
           nativeInstallCheckInputs = [

     

       255
       255
       -
           ] ++ lib.optionals (format == "setuptools") [

     

       273
       273
       +
           ] ++ lib.optionals (format' == "setuptools") [

     

       256
       274
        
             # Longer-term we should get rid of this and require

     

       257
       275
        
             # users of this function to set the `installCheckPhase` or

     

       258
       276
        
             # pass in a hook that sets it.

+1 -1

pkgs/development/tools/language-servers/ruff-lsp/default.nix

···

       16
       16
        
       buildPythonPackage rec {

     

       17
       17
        
         pname = "ruff-lsp";

     

       18
       18
        
         version = "0.0.39";

     

       19
       19
       -
         format = "pyproject";

     

       19
       19
       +
         pyproject = true;

     

       20
       20
        
         disabled = pythonOlder "3.7";

     

       21
       21
        
       

     

       22
       22
        
         src = fetchFromGitHub {

+5 -1

pkgs/tools/package-management/nix-update/default.nix

···

       10
       10
        
       python3.pkgs.buildPythonApplication rec {

     

       11
       11
        
         pname = "nix-update";

     

       12
       12
        
         version = "0.19.3";

     

       13
       13
       -
         format = "setuptools";

     

       13
       13
       +
         pyproject = true;

     

       14
       14
        
       

     

       15
       15
        
         src = fetchFromGitHub {

     

       16
       16
        
           owner = "Mic92";

     
···

       18
       18
        
           rev = version;

     

       19
       19
        
           hash = "sha256-+WD+SV/L3TvksWBIg6jk+T0dUTNdp4VKONzdzVT+pac=";

     

       20
       20
        
         };

     

       21
       21
       +
       

     

       22
       22
       +
         nativeBuildInputs = [

     

       23
       23
       +
           python3.pkgs.setuptools

     

       24
       24
       +
         ];

     

       21
       25
        
       

     

       22
       26
        
         makeWrapperArgs = [

     

       23
       27
        
           "--prefix" "PATH" ":" (lib.makeBinPath [ nix nix-prefetch-git nixpkgs-fmt nixpkgs-review ])