commit ae61a14242cdc2ee37910ee20b750d1adef1bc66 · pyrox.dev/nixpkgs

+84

nixos/doc/manual/from_md/release-notes/rl-2111.section.xml

···

       188
       188
        
           <itemizedlist>

     

       189
       189
        
             <listitem>

     

       190
       190
        
               <para>

     

       191
       191
       +
                 The <literal>paperless</literal> module and package have been

     

       192
       192
       +
                 removed. All users should migrate to the successor

     

       193
       193
       +
                 <literal>paperless-ng</literal> instead. The Paperless project

     

       194
       194
       +
                 <link xlink:href="https://github.com/the-paperless-project/paperless/commit/9b0063c9731f7c5f65b1852cb8caff97f5e40ba4">has

     

       195
       195
       +
                 been archived</link> and advises all users to use

     

       196
       196
       +
                 <literal>paperless-ng</literal> instead.

     

       197
       197
       +
               </para>

     

       198
       198
       +
               <para>

     

       199
       199
       +
                 Users can use the <literal>services.paperless-ng</literal>

     

       200
       200
       +
                 module as a replacement while noting the following

     

       201
       201
       +
                 incompatibilities:

     

       202
       202
       +
               </para>

     

       203
       203
       +
               <itemizedlist spacing="compact">

     

       204
       204
       +
                 <listitem>

     

       205
       205
       +
                   <para>

     

       206
       206
       +
                     <literal>services.paperless.ocrLanguages</literal> has no

     

       207
       207
       +
                     replacement. Users should migrate to

     

       208
       208
       +
                     <link xlink:href="options.html#opt-services.paperless-ng.extraConfig"><literal>services.paperless-ng.extraConfig</literal></link>

     

       209
       209
       +
                     instead:

     

       210
       210
       +
                   </para>

     

       211
       211
       +
                 </listitem>

     

       212
       212
       +
               </itemizedlist>

     

       213
       213
       +
               <programlisting language="bash">

     

       214
       214
       +
       {

     

       215
       215
       +
         services.paperless-ng.extraConfig = {

     

       216
       216
       +
           # Provide languages as ISO 639-2 codes

     

       217
       217
       +
           # separated by a plus (+) sign.

     

       218
       218
       +
           # https://en.wikipedia.org/wiki/List_of_ISO_639-2_codes

     

       219
       219
       +
           PAPERLESS_OCR_LANGUAGE = &quot;deu+eng+jpn&quot;; # German &amp; English &amp; Japanse

     

       220
       220
       +
         };

     

       221
       221
       +
       }

     

       222
       222
       +
       </programlisting>

     

       223
       223
       +
               <itemizedlist>

     

       224
       224
       +
                 <listitem>

     

       225
       225
       +
                   <para>

     

       226
       226
       +
                     If you previously specified

     

       227
       227
       +
                     <literal>PAPERLESS_CONSUME_MAIL_*</literal> settings in

     

       228
       228
       +
                     <literal>services.paperless.extraConfig</literal> you

     

       229
       229
       +
                     should remove those options now. You now

     

       230
       230
       +
                     <emphasis>must</emphasis> define those settings in the

     

       231
       231
       +
                     admin interface of paperless-ng.

     

       232
       232
       +
                   </para>

     

       233
       233
       +
                 </listitem>

     

       234
       234
       +
                 <listitem>

     

       235
       235
       +
                   <para>

     

       236
       236
       +
                     Option <literal>services.paperless.manage</literal> no

     

       237
       237
       +
                     longer exists. Use the script at

     

       238
       238
       +
                     <literal>${services.paperless-ng.dataDir}/paperless-ng-manage</literal>

     

       239
       239
       +
                     instead. Note that this script only exists after the

     

       240
       240
       +
                     <literal>paperless-ng</literal> service has been started

     

       241
       241
       +
                     at least once.

     

       242
       242
       +
                   </para>

     

       243
       243
       +
                 </listitem>

     

       244
       244
       +
                 <listitem>

     

       245
       245
       +
                   <para>

     

       246
       246
       +
                     After switching to the new system configuration you should

     

       247
       247
       +
                     run the Django management command to reindex your

     

       248
       248
       +
                     documents and optionally create a user, if you don’t have

     

       249
       249
       +
                     one already.

     

       250
       250
       +
                   </para>

     

       251
       251
       +
                   <para>

     

       252
       252
       +
                     To do so, enter the data directory (the value of

     

       253
       253
       +
                     <literal>services.paperless-ng.dataDir</literal>,

     

       254
       254
       +
                     <literal>/var/lib/paperless</literal> by default), switch

     

       255
       255
       +
                     to the paperless user and execute the management command

     

       256
       256
       +
                     like below:

     

       257
       257
       +
                   </para>

     

       258
       258
       +
                   <programlisting>

     

       259
       259
       +
       $ cd /var/lib/paperless

     

       260
       260
       +
       $ su paperless -s /bin/sh

     

       261
       261
       +
       $ ./paperless-ng-manage document_index reindex

     

       262
       262
       +
       # if not already done create a user account, paperless-ng requires a login

     

       263
       263
       +
       $ ./paperless-ng-manage createsuperuser

     

       264
       264
       +
       Username (leave blank to use 'paperless'): my-user-name

     

       265
       265
       +
       Email address: me@example.com

     

       266
       266
       +
       Password: **********

     

       267
       267
       +
       Password (again): **********

     

       268
       268
       +
       Superuser created successfully.

     

       269
       269
       +
       </programlisting>

     

       270
       270
       +
                 </listitem>

     

       271
       271
       +
               </itemizedlist>

     

       272
       272
       +
             </listitem>

     

       273
       273
       +
             <listitem>

     

       274
       274
       +
               <para>

     

       191
       275
        
                 The <literal>staticjinja</literal> package has been upgraded

     

       192
       276
        
                 from 1.0.4 to 3.0.1

     

       193
       277
        
               </para>

+47

nixos/doc/manual/release-notes/rl-2111.section.md

···

       58
       58
        
       

     

       59
       59
        
       ## Backward Incompatibilities {#sec-release-21.11-incompatibilities}

     

       60
       60
        
       

     

       61
       61
       +
       - The `paperless` module and package have been removed. All users should migrate to the

     

       62
       62
       +
         successor `paperless-ng` instead. The Paperless project [has been

     

       63
       63
       +
         archived](https://github.com/the-paperless-project/paperless/commit/9b0063c9731f7c5f65b1852cb8caff97f5e40ba4)

     

       64
       64
       +
         and advises all users to use `paperless-ng` instead.

     

       65
       65
       +
       

     

       66
       66
       +
         Users can use the `services.paperless-ng` module as a replacement while noting the following incompatibilities:

     

       67
       67
       +
           - `services.paperless.ocrLanguages` has no replacement. Users should migrate to [`services.paperless-ng.extraConfig`](options.html#opt-services.paperless-ng.extraConfig) instead:

     

       68
       68
       +
            ```nix

     

       69
       69
       +
            {

     

       70
       70
       +
              services.paperless-ng.extraConfig = {

     

       71
       71
       +
                # Provide languages as ISO 639-2 codes

     

       72
       72
       +
                # separated by a plus (+) sign.

     

       73
       73
       +
                # https://en.wikipedia.org/wiki/List_of_ISO_639-2_codes

     

       74
       74
       +
                PAPERLESS_OCR_LANGUAGE = "deu+eng+jpn"; # German & English & Japanse

     

       75
       75
       +
              };

     

       76
       76
       +
            }

     

       77
       77
       +
            ```

     

       78
       78
       +
       

     

       79
       79
       +
           - If you previously specified `PAPERLESS_CONSUME_MAIL_*` settings in

     

       80
       80
       +
             `services.paperless.extraConfig` you should remove those options now. You

     

       81
       81
       +
             now *must* define those settings in the admin interface of paperless-ng.

     

       82
       82
       +
       

     

       83
       83
       +
           - Option `services.paperless.manage` no longer exists.

     

       84
       84
       +
             Use the script at `${services.paperless-ng.dataDir}/paperless-ng-manage` instead.

     

       85
       85
       +
             Note that this script only exists after the `paperless-ng` service has been

     

       86
       86
       +
             started at least once.

     

       87
       87
       +
       

     

       88
       88
       +
           - After switching to the new system configuration you should run the Django

     

       89
       89
       +
             management command to reindex your documents and optionally create a user,

     

       90
       90
       +
             if you don't have one already.

     

       91
       91
       +
       

     

       92
       92
       +
             To do so, enter the data directory (the value of

     

       93
       93
       +
             `services.paperless-ng.dataDir`, `/var/lib/paperless` by default), switch

     

       94
       94
       +
             to the paperless user and execute the management command like below:

     

       95
       95
       +
             ```

     

       96
       96
       +
             $ cd /var/lib/paperless

     

       97
       97
       +
             $ su paperless -s /bin/sh

     

       98
       98
       +
             $ ./paperless-ng-manage document_index reindex

     

       99
       99
       +
             # if not already done create a user account, paperless-ng requires a login

     

       100
       100
       +
             $ ./paperless-ng-manage createsuperuser

     

       101
       101
       +
             Username (leave blank to use 'paperless'): my-user-name

     

       102
       102
       +
             Email address: me@example.com

     

       103
       103
       +
             Password: **********

     

       104
       104
       +
             Password (again): **********

     

       105
       105
       +
             Superuser created successfully.

     

       106
       106
       +
             ```

     

       107
       107
       +
       

     

       61
       108
        
       - The `staticjinja` package has been upgraded from 1.0.4 to 3.0.1

     

       62
       109
        
       

     

       63
       110
        
       - The `erigon` ethereum node has moved to a new database format in `2021-05-04`, and requires a full resync

+1 -1

nixos/modules/module-list.nix

···

       551
       551
        
         ./services/misc/ombi.nix

     

       552
       552
        
         ./services/misc/osrm.nix

     

       553
       553
        
         ./services/misc/packagekit.nix

     

       554
       554
       -
         ./services/misc/paperless.nix

     

       554
       554
       +
         ./services/misc/paperless-ng.nix

     

       555
       555
        
         ./services/misc/parsoid.nix

     

       556
       556
        
         ./services/misc/plex.nix

     

       557
       557
        
         ./services/misc/plikd.nix

+304

nixos/modules/services/misc/paperless-ng.nix

···

       1
       1
       +
       { config, pkgs, lib, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       let

     

       5
       5
       +
         cfg = config.services.paperless-ng;

     

       6
       6
       +
       

     

       7
       7
       +
         defaultUser = "paperless";

     

       8
       8
       +
       

     

       9
       9
       +
         env = {

     

       10
       10
       +
           PAPERLESS_DATA_DIR = cfg.dataDir;

     

       11
       11
       +
           PAPERLESS_MEDIA_ROOT = cfg.mediaDir;

     

       12
       12
       +
           PAPERLESS_CONSUMPTION_DIR = cfg.consumptionDir;

     

       13
       13
       +
           GUNICORN_CMD_ARGS = "--bind=${cfg.address}:${toString cfg.port}";

     

       14
       14
       +
         } // lib.mapAttrs (_: toString) cfg.extraConfig;

     

       15
       15
       +
       

     

       16
       16
       +
         manage = let

     

       17
       17
       +
           setupEnv = lib.concatStringsSep "\n" (mapAttrsToList (name: val: "export ${name}=\"${val}\"") env);

     

       18
       18
       +
         in pkgs.writeShellScript "manage" ''

     

       19
       19
       +
           ${setupEnv}

     

       20
       20
       +
           exec ${cfg.package}/bin/paperless-ng "$@"

     

       21
       21
       +
         '';

     

       22
       22
       +
       

     

       23
       23
       +
         # Secure the services

     

       24
       24
       +
         defaultServiceConfig = {

     

       25
       25
       +
           TemporaryFileSystem = "/:ro";

     

       26
       26
       +
           BindReadOnlyPaths = [

     

       27
       27
       +
             "/nix/store"

     

       28
       28
       +
             "-/etc/resolv.conf"

     

       29
       29
       +
             "-/etc/nsswitch.conf"

     

       30
       30
       +
             "-/etc/hosts"

     

       31
       31
       +
             "-/etc/localtime"

     

       32
       32
       +
           ];

     

       33
       33
       +
           BindPaths = [

     

       34
       34
       +
             cfg.consumptionDir

     

       35
       35
       +
             cfg.dataDir

     

       36
       36
       +
             cfg.mediaDir

     

       37
       37
       +
           ];

     

       38
       38
       +
           CapabilityBoundingSet = "";

     

       39
       39
       +
           # ProtectClock adds DeviceAllow=char-rtc r

     

       40
       40
       +
           DeviceAllow = "";

     

       41
       41
       +
           LockPersonality = true;

     

       42
       42
       +
           MemoryDenyWriteExecute = true;

     

       43
       43
       +
           NoNewPrivileges = true;

     

       44
       44
       +
           PrivateDevices = true;

     

       45
       45
       +
           PrivateMounts = true;

     

       46
       46
       +
           # Needs to connect to redis

     

       47
       47
       +
           # PrivateNetwork = true;

     

       48
       48
       +
           PrivateTmp = true;

     

       49
       49
       +
           PrivateUsers = true;

     

       50
       50
       +
           ProcSubset = "pid";

     

       51
       51
       +
           ProtectClock = true;

     

       52
       52
       +
           # Breaks if the home dir of the user is in /home

     

       53
       53
       +
           # Also does not add much value in combination with the TemporaryFileSystem.

     

       54
       54
       +
           # ProtectHome = true;

     

       55
       55
       +
           ProtectHostname = true;

     

       56
       56
       +
           # Would re-mount paths ignored by temporary root

     

       57
       57
       +
           #ProtectSystem = "strict";

     

       58
       58
       +
           ProtectControlGroups = true;

     

       59
       59
       +
           ProtectKernelLogs = true;

     

       60
       60
       +
           ProtectKernelModules = true;

     

       61
       61
       +
           ProtectKernelTunables = true;

     

       62
       62
       +
           ProtectProc = "invisible";

     

       63
       63
       +
           RestrictAddressFamilies = [ "AF_INET" "AF_INET6" ];

     

       64
       64
       +
           RestrictNamespaces = true;

     

       65
       65
       +
           RestrictRealtime = true;

     

       66
       66
       +
           RestrictSUIDSGID = true;

     

       67
       67
       +
           SystemCallArchitectures = "native";

     

       68
       68
       +
           SystemCallFilter = [ "@system-service" "~@privileged @resources @setuid @keyring" ];

     

       69
       69
       +
           # Does not work well with the temporary root

     

       70
       70
       +
           #UMask = "0066";

     

       71
       71
       +
         };

     

       72
       72
       +
       in

     

       73
       73
       +
       {

     

       74
       74
       +
         meta.maintainers = with maintainers; [ earvstedt Flakebi ];

     

       75
       75
       +
       

     

       76
       76
       +
         imports = [

     

       77
       77
       +
           (mkRemovedOptionModule [ "services" "paperless"] ''

     

       78
       78
       +
             The paperless module has been removed as the upstream project died.

     

       79
       79
       +
             Users should migrate to the paperless-ng module (services.paperless-ng).

     

       80
       80
       +
             More information can be found in the NixOS 21.11 release notes.

     

       81
       81
       +
           '')

     

       82
       82
       +
         ];

     

       83
       83
       +
       

     

       84
       84
       +
         options.services.paperless-ng = {

     

       85
       85
       +
           enable = mkOption {

     

       86
       86
       +
             type = lib.types.bool;

     

       87
       87
       +
             default = false;

     

       88
       88
       +
             description = ''

     

       89
       89
       +
               Enable Paperless-ng.

     

       90
       90
       +
       

     

       91
       91
       +
               When started, the Paperless database is automatically created if it doesn't

     

       92
       92
       +
               exist and updated if the Paperless package has changed.

     

       93
       93
       +
               Both tasks are achieved by running a Django migration.

     

       94
       94
       +
       

     

       95
       95
       +
               A script to manage the Paperless instance (by wrapping Django's manage.py) is linked to

     

       96
       96
       +
               <literal>''${dataDir}/paperless-ng-manage</literal>.

     

       97
       97
       +
             '';

     

       98
       98
       +
           };

     

       99
       99
       +
       

     

       100
       100
       +
           dataDir = mkOption {

     

       101
       101
       +
             type = types.str;

     

       102
       102
       +
             default = "/var/lib/paperless";

     

       103
       103
       +
             description = "Directory to store the Paperless data.";

     

       104
       104
       +
           };

     

       105
       105
       +
       

     

       106
       106
       +
           mediaDir = mkOption {

     

       107
       107
       +
             type = types.str;

     

       108
       108
       +
             default = "${cfg.dataDir}/media";

     

       109
       109
       +
             defaultText = "\${dataDir}/consume";

     

       110
       110
       +
             description = "Directory to store the Paperless documents.";

     

       111
       111
       +
           };

     

       112
       112
       +
       

     

       113
       113
       +
           consumptionDir = mkOption {

     

       114
       114
       +
             type = types.str;

     

       115
       115
       +
             default = "${cfg.dataDir}/consume";

     

       116
       116
       +
             defaultText = "\${dataDir}/consume";

     

       117
       117
       +
             description = "Directory from which new documents are imported.";

     

       118
       118
       +
           };

     

       119
       119
       +
       

     

       120
       120
       +
           consumptionDirIsPublic = mkOption {

     

       121
       121
       +
             type = types.bool;

     

       122
       122
       +
             default = false;

     

       123
       123
       +
             description = "Whether all users can write to the consumption dir.";

     

       124
       124
       +
           };

     

       125
       125
       +
       

     

       126
       126
       +
           passwordFile = mkOption {

     

       127
       127
       +
             type = types.nullOr types.path;

     

       128
       128
       +
             default = null;

     

       129
       129
       +
             example = "/run/keys/paperless-ng-password";

     

       130
       130
       +
             description = ''

     

       131
       131
       +
               A file containing the superuser password.

     

       132
       132
       +
       

     

       133
       133
       +
               A superuser is required to access the web interface.

     

       134
       134
       +
               If unset, you can create a superuser manually by running

     

       135
       135
       +
               <literal>''${dataDir}/paperless-ng-manage createsuperuser</literal>.

     

       136
       136
       +
       

     

       137
       137
       +
               The default superuser name is <literal>admin</literal>. To change it, set

     

       138
       138
       +
               option <option>extraConfig.PAPERLESS_ADMIN_USER</option>.

     

       139
       139
       +
               WARNING: When changing the superuser name after the initial setup, the old superuser

     

       140
       140
       +
               will continue to exist.

     

       141
       141
       +
       

     

       142
       142
       +
               To disable login for the web interface, set the following:

     

       143
       143
       +
               <literal>extraConfig.PAPERLESS_AUTO_LOGIN_USERNAME = "admin";</literal>.

     

       144
       144
       +
               WARNING: Only use this on a trusted system without internet access to Paperless.

     

       145
       145
       +
             '';

     

       146
       146
       +
           };

     

       147
       147
       +
       

     

       148
       148
       +
           address = mkOption {

     

       149
       149
       +
             type = types.str;

     

       150
       150
       +
             default = "localhost";

     

       151
       151
       +
             description = "Web interface address.";

     

       152
       152
       +
           };

     

       153
       153
       +
       

     

       154
       154
       +
           port = mkOption {

     

       155
       155
       +
             type = types.port;

     

       156
       156
       +
             default = 28981;

     

       157
       157
       +
             description = "Web interface port.";

     

       158
       158
       +
           };

     

       159
       159
       +
       

     

       160
       160
       +
           extraConfig = mkOption {

     

       161
       161
       +
             type = types.attrs;

     

       162
       162
       +
             default = {};

     

       163
       163
       +
             description = ''

     

       164
       164
       +
               Extra paperless-ng config options.

     

       165
       165
       +
       

     

       166
       166
       +
               See <link xlink:href="https://paperless-ng.readthedocs.io/en/latest/configuration.html">the documentation</link>

     

       167
       167
       +
               for available options.

     

       168
       168
       +
             '';

     

       169
       169
       +
             example = literalExample ''

     

       170
       170
       +
               {

     

       171
       171
       +
                 PAPERLESS_OCR_LANGUAGE = "deu+eng";

     

       172
       172
       +
               }

     

       173
       173
       +
             '';

     

       174
       174
       +
           };

     

       175
       175
       +
       

     

       176
       176
       +
           user = mkOption {

     

       177
       177
       +
             type = types.str;

     

       178
       178
       +
             default = defaultUser;

     

       179
       179
       +
             description = "User under which Paperless runs.";

     

       180
       180
       +
           };

     

       181
       181
       +
       

     

       182
       182
       +
           package = mkOption {

     

       183
       183
       +
             type = types.package;

     

       184
       184
       +
             default = pkgs.paperless-ng;

     

       185
       185
       +
             defaultText = "pkgs.paperless-ng";

     

       186
       186
       +
             description = "The Paperless package to use.";

     

       187
       187
       +
           };

     

       188
       188
       +
         };

     

       189
       189
       +
       

     

       190
       190
       +
         config = mkIf cfg.enable {

     

       191
       191
       +
           # Enable redis if no special url is set

     

       192
       192
       +
           services.redis.enable = mkIf (!hasAttr "PAPERLESS_REDIS" env) true;

     

       193
       193
       +
       

     

       194
       194
       +
           systemd.tmpfiles.rules = [

     

       195
       195
       +
             "d '${cfg.dataDir}' - ${cfg.user} ${config.users.users.${cfg.user}.group} - -"

     

       196
       196
       +
             "d '${cfg.mediaDir}' - ${cfg.user} ${config.users.users.${cfg.user}.group} - -"

     

       197
       197
       +
             (if cfg.consumptionDirIsPublic then

     

       198
       198
       +
               "d '${cfg.consumptionDir}' 777 - - - -"

     

       199
       199
       +
             else

     

       200
       200
       +
               "d '${cfg.consumptionDir}' - ${cfg.user} ${config.users.users.${cfg.user}.group} - -"

     

       201
       201
       +
             )

     

       202
       202
       +
           ];

     

       203
       203
       +
       

     

       204
       204
       +
           systemd.services.paperless-ng-server = {

     

       205
       205
       +
             description = "Paperless document server";

     

       206
       206
       +
             serviceConfig = defaultServiceConfig // {

     

       207
       207
       +
               User = cfg.user;

     

       208
       208
       +
               ExecStart = "${cfg.package}/bin/paperless-ng qcluster";

     

       209
       209
       +
               Restart = "on-failure";

     

       210
       210
       +
             };

     

       211
       211
       +
             environment = env;

     

       212
       212
       +
             wantedBy = [ "multi-user.target" ];

     

       213
       213
       +
             wants = [ "paperless-ng-consumer.service" "paperless-ng-web.service" ];

     

       214
       214
       +
       

     

       215
       215
       +
             preStart = ''

     

       216
       216
       +
               ln -sf ${manage} ${cfg.dataDir}/paperless-ng-manage

     

       217
       217
       +
       

     

       218
       218
       +
               # Auto-migrate on first run or if the package has changed

     

       219
       219
       +
               versionFile="${cfg.dataDir}/src-version"

     

       220
       220
       +
               if [[ $(cat "$versionFile" 2>/dev/null) != ${cfg.package} ]]; then

     

       221
       221
       +
                 ${cfg.package}/bin/paperless-ng migrate

     

       222
       222
       +
                 echo ${cfg.package} > "$versionFile"

     

       223
       223
       +
               fi

     

       224
       224
       +
             ''

     

       225
       225
       +
             + optionalString (cfg.passwordFile != null) ''

     

       226
       226
       +
               export PAPERLESS_ADMIN_USER="''${PAPERLESS_ADMIN_USER:-admin}"

     

       227
       227
       +
               export PAPERLESS_ADMIN_PASSWORD=$(cat "${cfg.dataDir}/superuser-password")

     

       228
       228
       +
               superuserState="$PAPERLESS_ADMIN_USER:$PAPERLESS_ADMIN_PASSWORD"

     

       229
       229
       +
               superuserStateFile="${cfg.dataDir}/superuser-state"

     

       230
       230
       +
       

     

       231
       231
       +
               if [[ $(cat "$superuserStateFile" 2>/dev/null) != $superuserState ]]; then

     

       232
       232
       +
                 ${cfg.package}/bin/paperless-ng manage_superuser

     

       233
       233
       +
                 echo "$superuserState" > "$superuserStateFile"

     

       234
       234
       +
               fi

     

       235
       235
       +
             '';

     

       236
       236
       +
           };

     

       237
       237
       +
       

     

       238
       238
       +
           # Password copying can't be implemented as a privileged preStart script

     

       239
       239
       +
           # in 'paperless-ng-server' because 'defaultServiceConfig' limits the filesystem

     

       240
       240
       +
           # paths accessible by the service.

     

       241
       241
       +
           systemd.services.paperless-ng-copy-password = mkIf (cfg.passwordFile != null) {

     

       242
       242
       +
             requiredBy = [ "paperless-ng-server.service" ];

     

       243
       243
       +
             before = [ "paperless-ng-server.service" ];

     

       244
       244
       +
             serviceConfig = {

     

       245
       245
       +
               ExecStart = ''

     

       246
       246
       +
                 ${pkgs.coreutils}/bin/install --mode 600 --owner '${cfg.user}' --compare \

     

       247
       247
       +
                   '${cfg.passwordFile}' '${cfg.dataDir}/superuser-password'

     

       248
       248
       +
               '';

     

       249
       249
       +
               Type = "oneshot";

     

       250
       250
       +
             };

     

       251
       251
       +
           };

     

       252
       252
       +
       

     

       253
       253
       +
           systemd.services.paperless-ng-consumer = {

     

       254
       254
       +
             description = "Paperless document consumer";

     

       255
       255
       +
             serviceConfig = defaultServiceConfig // {

     

       256
       256
       +
               User = cfg.user;

     

       257
       257
       +
               ExecStart = "${cfg.package}/bin/paperless-ng document_consumer";

     

       258
       258
       +
               Restart = "on-failure";

     

       259
       259
       +
             };

     

       260
       260
       +
             environment = env;

     

       261
       261
       +
             # Bind to `paperless-ng-server` so that the consumer never runs

     

       262
       262
       +
             # during migrations

     

       263
       263
       +
             bindsTo = [ "paperless-ng-server.service" ];

     

       264
       264
       +
             after = [ "paperless-ng-server.service" ];

     

       265
       265
       +
           };

     

       266
       266
       +
       

     

       267
       267
       +
           systemd.services.paperless-ng-web = {

     

       268
       268
       +
             description = "Paperless web server";

     

       269
       269
       +
             serviceConfig = defaultServiceConfig // {

     

       270
       270
       +
               User = cfg.user;

     

       271
       271
       +
               ExecStart = ''

     

       272
       272
       +
                 ${pkgs.python3Packages.gunicorn}/bin/gunicorn \

     

       273
       273
       +
                   -c ${cfg.package}/lib/paperless-ng/gunicorn.conf.py paperless.asgi:application

     

       274
       274
       +
               '';

     

       275
       275
       +
               Restart = "on-failure";

     

       276
       276
       +
       

     

       277
       277
       +
               AmbientCapabilities = "CAP_NET_BIND_SERVICE";

     

       278
       278
       +
               CapabilityBoundingSet = "CAP_NET_BIND_SERVICE";

     

       279
       279
       +
               # gunicorn needs setuid

     

       280
       280
       +
               SystemCallFilter = defaultServiceConfig.SystemCallFilter ++ [ "@setuid" ];

     

       281
       281
       +
             };

     

       282
       282
       +
             environment = env // {

     

       283
       283
       +
               PATH = mkForce cfg.package.path;

     

       284
       284
       +
               PYTHONPATH = "${cfg.package.pythonPath}:${cfg.package}/lib/paperless-ng/src";

     

       285
       285
       +
             };

     

       286
       286
       +
             # Bind to `paperless-ng-server` so that the web server never runs

     

       287
       287
       +
             # during migrations

     

       288
       288
       +
             bindsTo = [ "paperless-ng-server.service" ];

     

       289
       289
       +
             after = [ "paperless-ng-server.service" ];

     

       290
       290
       +
           };

     

       291
       291
       +
       

     

       292
       292
       +
           users = optionalAttrs (cfg.user == defaultUser) {

     

       293
       293
       +
             users.${defaultUser} = {

     

       294
       294
       +
               group = defaultUser;

     

       295
       295
       +
               uid = config.ids.uids.paperless;

     

       296
       296
       +
               home = cfg.dataDir;

     

       297
       297
       +
             };

     

       298
       298
       +
       

     

       299
       299
       +
             groups.${defaultUser} = {

     

       300
       300
       +
               gid = config.ids.gids.paperless;

     

       301
       301
       +
             };

     

       302
       302
       +
           };

     

       303
       303
       +
         };

     

       304
       304
       +
       }

-183

nixos/modules/services/misc/paperless.nix

···

       1
       1
       -
       { config, pkgs, lib, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       let

     

       5
       5
       -
         cfg = config.services.paperless;

     

       6
       6
       -
       

     

       7
       7
       -
         defaultUser = "paperless";

     

       8
       8
       -
       

     

       9
       9
       -
         manage = cfg.package.withConfig {

     

       10
       10
       -
           config = {

     

       11
       11
       -
             PAPERLESS_CONSUMPTION_DIR = cfg.consumptionDir;

     

       12
       12
       -
             PAPERLESS_INLINE_DOC = "true";

     

       13
       13
       -
             PAPERLESS_DISABLE_LOGIN = "true";

     

       14
       14
       -
           } // cfg.extraConfig;

     

       15
       15
       -
           inherit (cfg) dataDir ocrLanguages;

     

       16
       16
       -
           paperlessPkg = cfg.package;

     

       17
       17
       -
         };

     

       18
       18
       -
       in

     

       19
       19
       -
       {

     

       20
       20
       -
         options.services.paperless = {

     

       21
       21
       -
           enable = mkOption {

     

       22
       22
       -
             type = lib.types.bool;

     

       23
       23
       -
             default = false;

     

       24
       24
       -
             description = ''

     

       25
       25
       -
               Enable Paperless.

     

       26
       26
       -
       

     

       27
       27
       -
               When started, the Paperless database is automatically created if it doesn't

     

       28
       28
       -
               exist and updated if the Paperless package has changed.

     

       29
       29
       -
               Both tasks are achieved by running a Django migration.

     

       30
       30
       -
             '';

     

       31
       31
       -
           };

     

       32
       32
       -
       

     

       33
       33
       -
           dataDir = mkOption {

     

       34
       34
       -
             type = types.str;

     

       35
       35
       -
             default = "/var/lib/paperless";

     

       36
       36
       -
             description = "Directory to store the Paperless data.";

     

       37
       37
       -
           };

     

       38
       38
       -
       

     

       39
       39
       -
           consumptionDir = mkOption {

     

       40
       40
       -
             type = types.str;

     

       41
       41
       -
             default = "${cfg.dataDir}/consume";

     

       42
       42
       -
             defaultText = "\${dataDir}/consume";

     

       43
       43
       -
             description = "Directory from which new documents are imported.";

     

       44
       44
       -
           };

     

       45
       45
       -
       

     

       46
       46
       -
           consumptionDirIsPublic = mkOption {

     

       47
       47
       -
             type = types.bool;

     

       48
       48
       -
             default = false;

     

       49
       49
       -
             description = "Whether all users can write to the consumption dir.";

     

       50
       50
       -
           };

     

       51
       51
       -
       

     

       52
       52
       -
           ocrLanguages = mkOption {

     

       53
       53
       -
             type = with types; nullOr (listOf str);

     

       54
       54
       -
             default = null;

     

       55
       55
       -
             description = ''

     

       56
       56
       -
               Languages available for OCR via Tesseract, specified as

     

       57
       57
       -
               <literal>ISO 639-2/T</literal> language codes.

     

       58
       58
       -
               If unset, defaults to all available languages.

     

       59
       59
       -
             '';

     

       60
       60
       -
             example = [ "eng" "spa" "jpn" ];

     

       61
       61
       -
           };

     

       62
       62
       -
       

     

       63
       63
       -
           address = mkOption {

     

       64
       64
       -
             type = types.str;

     

       65
       65
       -
             default = "localhost";

     

       66
       66
       -
             description = "Server listening address.";

     

       67
       67
       -
           };

     

       68
       68
       -
       

     

       69
       69
       -
           port = mkOption {

     

       70
       70
       -
             type = types.port;

     

       71
       71
       -
             default = 28981;

     

       72
       72
       -
             description = "Server port to listen on.";

     

       73
       73
       -
           };

     

       74
       74
       -
       

     

       75
       75
       -
           extraConfig = mkOption {

     

       76
       76
       -
             type = types.attrs;

     

       77
       77
       -
             default = {};

     

       78
       78
       -
             description = ''

     

       79
       79
       -
               Extra paperless config options.

     

       80
       80
       -
       

     

       81
       81
       -
               The config values are evaluated as double-quoted Bash string literals.

     

       82
       82
       -
       

     

       83
       83
       -
               See <literal>paperless-src/paperless.conf.example</literal> for available options.

     

       84
       84
       -
       

     

       85
       85
       -
               To enable user authentication, set <literal>PAPERLESS_DISABLE_LOGIN = "false"</literal>

     

       86
       86
       -
               and run the shell command <literal>$dataDir/paperless-manage createsuperuser</literal>.

     

       87
       87
       -
       

     

       88
       88
       -
               To define secret options without storing them in /nix/store, use the following pattern:

     

       89
       89
       -
               <literal>PAPERLESS_PASSPHRASE = "$(&lt; /etc/my_passphrase_file)"</literal>

     

       90
       90
       -
             '';

     

       91
       91
       -
             example = literalExample ''

     

       92
       92
       -
               {

     

       93
       93
       -
                 PAPERLESS_OCR_LANGUAGE = "deu";

     

       94
       94
       -
               }

     

       95
       95
       -
             '';

     

       96
       96
       -
           };

     

       97
       97
       -
       

     

       98
       98
       -
           user = mkOption {

     

       99
       99
       -
             type = types.str;

     

       100
       100
       -
             default = defaultUser;

     

       101
       101
       -
             description = "User under which Paperless runs.";

     

       102
       102
       -
           };

     

       103
       103
       -
       

     

       104
       104
       -
           package = mkOption {

     

       105
       105
       -
             type = types.package;

     

       106
       106
       -
             default = pkgs.paperless;

     

       107
       107
       -
             defaultText = "pkgs.paperless";

     

       108
       108
       -
             description = "The Paperless package to use.";

     

       109
       109
       -
           };

     

       110
       110
       -
       

     

       111
       111
       -
           manage = mkOption {

     

       112
       112
       -
             type = types.package;

     

       113
       113
       -
             readOnly = true;

     

       114
       114
       -
             default = manage;

     

       115
       115
       -
             description = ''

     

       116
       116
       -
               A script to manage the Paperless instance.

     

       117
       117
       -
               It wraps Django's manage.py and is also available at

     

       118
       118
       -
               <literal>$dataDir/manage-paperless</literal>

     

       119
       119
       -
             '';

     

       120
       120
       -
           };

     

       121
       121
       -
         };

     

       122
       122
       -
       

     

       123
       123
       -
         config = mkIf cfg.enable {

     

       124
       124
       -
       

     

       125
       125
       -
           systemd.tmpfiles.rules = [

     

       126
       126
       -
             "d '${cfg.dataDir}' - ${cfg.user} ${config.users.users.${cfg.user}.group} - -"

     

       127
       127
       -
           ] ++ (optional cfg.consumptionDirIsPublic

     

       128
       128
       -
             "d '${cfg.consumptionDir}' 777 - - - -"

     

       129
       129
       -
             # If the consumption dir is not created here, it's automatically created by

     

       130
       130
       -
             # 'manage' with the default permissions.

     

       131
       131
       -
           );

     

       132
       132
       -
       

     

       133
       133
       -
           systemd.services.paperless-consumer = {

     

       134
       134
       -
             description = "Paperless document consumer";

     

       135
       135
       -
             serviceConfig = {

     

       136
       136
       -
               User = cfg.user;

     

       137
       137
       -
               ExecStart = "${manage} document_consumer";

     

       138
       138
       -
               Restart = "always";

     

       139
       139
       -
             };

     

       140
       140
       -
             after = [ "systemd-tmpfiles-setup.service" ];

     

       141
       141
       -
             wantedBy = [ "multi-user.target" ];

     

       142
       142
       -
             preStart = ''

     

       143
       143
       -
               if [[ $(readlink ${cfg.dataDir}/paperless-manage) != ${manage} ]]; then

     

       144
       144
       -
                 ln -sf ${manage} ${cfg.dataDir}/paperless-manage

     

       145
       145
       -
               fi

     

       146
       146
       -
       

     

       147
       147
       -
               ${manage.setupEnv}

     

       148
       148
       -
               # Auto-migrate on first run or if the package has changed

     

       149
       149
       -
               versionFile="$PAPERLESS_DBDIR/src-version"

     

       150
       150
       -
               if [[ $(cat "$versionFile" 2>/dev/null) != ${cfg.package} ]]; then

     

       151
       151
       -
                 python $paperlessSrc/manage.py migrate

     

       152
       152
       -
                 echo ${cfg.package} > "$versionFile"

     

       153
       153
       -
               fi

     

       154
       154
       -
             '';

     

       155
       155
       -
           };

     

       156
       156
       -
       

     

       157
       157
       -
           systemd.services.paperless-server = {

     

       158
       158
       -
             description = "Paperless document server";

     

       159
       159
       -
             serviceConfig = {

     

       160
       160
       -
               User = cfg.user;

     

       161
       161
       -
               ExecStart = "${manage} runserver --noreload ${cfg.address}:${toString cfg.port}";

     

       162
       162
       -
               Restart = "always";

     

       163
       163
       -
             };

     

       164
       164
       -
             # Bind to `paperless-consumer` so that the server never runs

     

       165
       165
       -
             # during migrations

     

       166
       166
       -
             bindsTo = [ "paperless-consumer.service" ];

     

       167
       167
       -
             after = [ "paperless-consumer.service" ];

     

       168
       168
       -
             wantedBy = [ "multi-user.target" ];

     

       169
       169
       -
           };

     

       170
       170
       -
       

     

       171
       171
       -
           users = optionalAttrs (cfg.user == defaultUser) {

     

       172
       172
       -
             users.${defaultUser} = {

     

       173
       173
       -
               group = defaultUser;

     

       174
       174
       -
               uid = config.ids.uids.paperless;

     

       175
       175
       -
               home = cfg.dataDir;

     

       176
       176
       -
             };

     

       177
       177
       -
       

     

       178
       178
       -
             groups.${defaultUser} = {

     

       179
       179
       -
               gid = config.ids.gids.paperless;

     

       180
       180
       -
             };

     

       181
       181
       -
           };

     

       182
       182
       -
         };

     

       183
       183
       -
       }

+1 -1

nixos/tests/all-tests.nix

···

       336
       336
        
         pam-oath-login = handleTest ./pam-oath-login.nix {};

     

       337
       337
        
         pam-u2f = handleTest ./pam-u2f.nix {};

     

       338
       338
        
         pantheon = handleTest ./pantheon.nix {};

     

       339
       339
       -
         paperless = handleTest ./paperless.nix {};

     

       339
       339
       +
         paperless-ng = handleTest ./paperless-ng.nix {};

     

       340
       340
        
         pdns-recursor = handleTest ./pdns-recursor.nix {};

     

       341
       341
        
         peerflix = handleTest ./peerflix.nix {};

     

       342
       342
        
         pgjwt = handleTest ./pgjwt.nix {};

+36

nixos/tests/paperless-ng.nix

···

       1
       1
       +
       import ./make-test-python.nix ({ lib, ... }: {

     

       2
       2
       +
         name = "paperless-ng";

     

       3
       3
       +
         meta.maintainers = with lib.maintainers; [ earvstedt Flakebi ];

     

       4
       4
       +
       

     

       5
       5
       +
         nodes.machine = { pkgs, ... }: {

     

       6
       6
       +
           environment.systemPackages = with pkgs; [ imagemagick jq ];

     

       7
       7
       +
           services.paperless-ng = {

     

       8
       8
       +
             enable = true;

     

       9
       9
       +
             passwordFile = builtins.toFile "password" "admin";

     

       10
       10
       +
           };

     

       11
       11
       +
           virtualisation.memorySize = 1024;

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         testScript = ''

     

       15
       15
       +
           machine.wait_for_unit("paperless-ng-consumer.service")

     

       16
       16
       +
       

     

       17
       17
       +
           with subtest("Create test doc"):

     

       18
       18
       +
               machine.succeed(

     

       19
       19
       +
                   "convert -size 400x40 xc:white -font 'DejaVu-Sans' -pointsize 20 -fill black "

     

       20
       20
       +
                   "-annotate +5+20 'hello world 16-10-2005' /var/lib/paperless/consume/doc.png"

     

       21
       21
       +
               )

     

       22
       22
       +
       

     

       23
       23
       +
           with subtest("Web interface gets ready"):

     

       24
       24
       +
               machine.wait_for_unit("paperless-ng-web.service")

     

       25
       25
       +
               # Wait until server accepts connections

     

       26
       26
       +
               machine.wait_until_succeeds("curl -fs localhost:28981")

     

       27
       27
       +
       

     

       28
       28
       +
           with subtest("Document is consumed"):

     

       29
       29
       +
               machine.wait_until_succeeds(

     

       30
       30
       +
                   "(($(curl -u admin:admin -fs localhost:28981/api/documents/ | jq .count) == 1))"

     

       31
       31
       +
               )

     

       32
       32
       +
               assert "2005-10-16" in machine.succeed(

     

       33
       33
       +
                   "curl -u admin:admin -fs localhost:28981/api/documents/ | jq '.results | .[0] | .created'"

     

       34
       34
       +
               )

     

       35
       35
       +
         '';

     

       36
       36
       +
       })

-36

nixos/tests/paperless.nix

···

       1
       1
       -
       import ./make-test-python.nix ({ lib, ... } : {

     

       2
       2
       -
         name = "paperless";

     

       3
       3
       -
         meta = with lib.maintainers; {

     

       4
       4
       -
           maintainers = [ earvstedt ];

     

       5
       5
       -
         };

     

       6
       6
       -
       

     

       7
       7
       -
         machine = { pkgs, ... }: {

     

       8
       8
       -
           environment.systemPackages = with pkgs; [ imagemagick jq ];

     

       9
       9
       -
           services.paperless = {

     

       10
       10
       -
             enable = true;

     

       11
       11
       -
             ocrLanguages = [ "eng" ];

     

       12
       12
       -
           };

     

       13
       13
       -
         };

     

       14
       14
       -
       

     

       15
       15
       -
         testScript = ''

     

       16
       16
       -
           machine.wait_for_unit("paperless-consumer.service")

     

       17
       17
       -
       

     

       18
       18
       -
           # Create test doc

     

       19
       19
       -
           machine.succeed(

     

       20
       20
       -
               "convert -size 400x40 xc:white -font 'DejaVu-Sans' -pointsize 20 -fill black -annotate +5+20 'hello world 16-10-2005' /var/lib/paperless/consume/doc.png"

     

       21
       21
       -
           )

     

       22
       22
       -
       

     

       23
       23
       -
           with subtest("Service gets ready"):

     

       24
       24
       -
               machine.wait_for_unit("paperless-server.service")

     

       25
       25
       -
               # Wait until server accepts connections

     

       26
       26
       -
               machine.wait_until_succeeds("curl -fs localhost:28981")

     

       27
       27
       -
       

     

       28
       28
       -
           with subtest("Test document is consumed"):

     

       29
       29
       -
               machine.wait_until_succeeds(

     

       30
       30
       -
                   "(($(curl -fs localhost:28981/api/documents/ | jq .count) == 1))"

     

       31
       31
       -
               )

     

       32
       32
       -
               assert "2005-10-16" in machine.succeed(

     

       33
       33
       -
                   "curl -fs localhost:28981/api/documents/ | jq '.results | .[0] | .created'"

     

       34
       34
       -
               )

     

       35
       35
       -
         '';

     

       36
       36
       -
       })

+197

pkgs/applications/office/paperless-ng/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , fetchurl

     

       3
       3
       +
       , nixosTests

     

       4
       4
       +
       , python3

     

       5
       5
       +
       , ghostscript

     

       6
       6
       +
       , imagemagick

     

       7
       7
       +
       , jbig2enc

     

       8
       8
       +
       , ocrmypdf

     

       9
       9
       +
       , optipng

     

       10
       10
       +
       , pngquant

     

       11
       11
       +
       , qpdf

     

       12
       12
       +
       , tesseract4

     

       13
       13
       +
       , unpaper

     

       14
       14
       +
       , liberation_ttf

     

       15
       15
       +
       }:

     

       16
       16
       +
       

     

       17
       17
       +
       let

     

       18
       18
       +
         py = python3.override {

     

       19
       19
       +
           packageOverrides = self: super: {

     

       20
       20
       +
             django = super.django_3;

     

       21
       21
       +
             django-picklefield = super.django-picklefield.overrideAttrs (oldAttrs: {

     

       22
       22
       +
               # Checks do not pass with django 3

     

       23
       23
       +
               doInstallCheck = false;

     

       24
       24
       +
             });

     

       25
       25
       +
             # Avoid warning in django-q versions > 1.3.4

     

       26
       26
       +
             # https://github.com/jonaswinkler/paperless-ng/issues/857

     

       27
       27
       +
             # https://github.com/Koed00/django-q/issues/526

     

       28
       28
       +
             django-q = super.django-q.overridePythonAttrs (oldAttrs: rec {

     

       29
       29
       +
               version = "1.3.4";

     

       30
       30
       +
               src = super.fetchPypi {

     

       31
       31
       +
                 inherit (oldAttrs) pname;

     

       32
       32
       +
                 inherit version;

     

       33
       33
       +
                 sha256 = "Uj1U3PG2YVLBtlj5FPAO07UYo0MqnezUiYc4yo274Q8=";

     

       34
       34
       +
               };

     

       35
       35
       +
             });

     

       36
       36
       +
           };

     

       37
       37
       +
         };

     

       38
       38
       +
       

     

       39
       39
       +
         path = lib.makeBinPath [ ghostscript imagemagick jbig2enc optipng pngquant qpdf tesseract4 unpaper ];

     

       40
       40
       +
       in

     

       41
       41
       +
       py.pkgs.pythonPackages.buildPythonApplication rec {

     

       42
       42
       +
         pname = "paperless-ng";

     

       43
       43
       +
         version = "1.4.5";

     

       44
       44
       +
       

     

       45
       45
       +
         src = fetchurl {

     

       46
       46
       +
           url = "https://github.com/jonaswinkler/paperless-ng/releases/download/ng-${version}/${pname}-${version}.tar.xz";

     

       47
       47
       +
           sha256 = "2PJb8j3oimlfiJ3gqjK6uTemzFdtAP2Mlm5RH09bx/E=";

     

       48
       48
       +
         };

     

       49
       49
       +
       

     

       50
       50
       +
         format = "other";

     

       51
       51
       +
       

     

       52
       52
       +
         # Make bind address configurable

     

       53
       53
       +
         # Fix tests with Pillow 8.3.1: https://github.com/jonaswinkler/paperless-ng/pull/1183

     

       54
       54
       +
         prePatch = ''

     

       55
       55
       +
           substituteInPlace gunicorn.conf.py --replace "bind = '0.0.0.0:8000'" ""

     

       56
       56
       +
           substituteInPlace src/paperless_tesseract/parsers.py --replace "return x" "return round(x)"

     

       57
       57
       +
         '';

     

       58
       58
       +
       

     

       59
       59
       +
         propagatedBuildInputs = with py.pkgs.pythonPackages; [

     

       60
       60
       +
           aioredis

     

       61
       61
       +
           arrow

     

       62
       62
       +
           asgiref

     

       63
       63
       +
           async-timeout

     

       64
       64
       +
           attrs

     

       65
       65
       +
           autobahn

     

       66
       66
       +
           automat

     

       67
       67
       +
           blessed

     

       68
       68
       +
           certifi

     

       69
       69
       +
           cffi

     

       70
       70
       +
           channels-redis

     

       71
       71
       +
           channels

     

       72
       72
       +
           chardet

     

       73
       73
       +
           click

     

       74
       74
       +
           coloredlogs

     

       75
       75
       +
           concurrent-log-handler

     

       76
       76
       +
           constantly

     

       77
       77
       +
           cryptography

     

       78
       78
       +
           daphne

     

       79
       79
       +
           dateparser

     

       80
       80
       +
           django-cors-headers

     

       81
       81
       +
           django_extensions

     

       82
       82
       +
           django-filter

     

       83
       83
       +
           django-picklefield

     

       84
       84
       +
           django-q

     

       85
       85
       +
           django

     

       86
       86
       +
           djangorestframework

     

       87
       87
       +
           filelock

     

       88
       88
       +
           fuzzywuzzy

     

       89
       89
       +
           gunicorn

     

       90
       90
       +
           h11

     

       91
       91
       +
           hiredis

     

       92
       92
       +
           httptools

     

       93
       93
       +
           humanfriendly

     

       94
       94
       +
           hyperlink

     

       95
       95
       +
           idna

     

       96
       96
       +
           imap-tools

     

       97
       97
       +
           img2pdf

     

       98
       98
       +
           incremental

     

       99
       99
       +
           inotify-simple

     

       100
       100
       +
           inotifyrecursive

     

       101
       101
       +
           joblib

     

       102
       102
       +
           langdetect

     

       103
       103
       +
           lxml

     

       104
       104
       +
           msgpack

     

       105
       105
       +
           numpy

     

       106
       106
       +
           ocrmypdf

     

       107
       107
       +
           pathvalidate

     

       108
       108
       +
           pdfminer

     

       109
       109
       +
           pikepdf

     

       110
       110
       +
           pillow

     

       111
       111
       +
           pluggy

     

       112
       112
       +
           portalocker

     

       113
       113
       +
           psycopg2

     

       114
       114
       +
           pyasn1-modules

     

       115
       115
       +
           pyasn1

     

       116
       116
       +
           pycparser

     

       117
       117
       +
           pyopenssl

     

       118
       118
       +
           python-dateutil

     

       119
       119
       +
           python-dotenv

     

       120
       120
       +
           python-gnupg

     

       121
       121
       +
           python-Levenshtein

     

       122
       122
       +
           python_magic

     

       123
       123
       +
           pytz

     

       124
       124
       +
           pyyaml

     

       125
       125
       +
           redis

     

       126
       126
       +
           regex

     

       127
       127
       +
           reportlab

     

       128
       128
       +
           requests

     

       129
       129
       +
           scikit-learn

     

       130
       130
       +
           scipy

     

       131
       131
       +
           service-identity

     

       132
       132
       +
           six

     

       133
       133
       +
           sortedcontainers

     

       134
       134
       +
           sqlparse

     

       135
       135
       +
           threadpoolctl

     

       136
       136
       +
           tika

     

       137
       137
       +
           tqdm

     

       138
       138
       +
           twisted.extras.tls

     

       139
       139
       +
           txaio

     

       140
       140
       +
           tzlocal

     

       141
       141
       +
           urllib3

     

       142
       142
       +
           uvicorn

     

       143
       143
       +
           uvloop

     

       144
       144
       +
           watchdog

     

       145
       145
       +
           watchgod

     

       146
       146
       +
           wcwidth

     

       147
       147
       +
           websockets

     

       148
       148
       +
           whitenoise

     

       149
       149
       +
           whoosh

     

       150
       150
       +
           zope_interface

     

       151
       151
       +
         ];

     

       152
       152
       +
       

     

       153
       153
       +
         doCheck = true;

     

       154
       154
       +
         checkInputs = with py.pkgs.pythonPackages; [

     

       155
       155
       +
           pytest

     

       156
       156
       +
           pytest-cov

     

       157
       157
       +
           pytest-django

     

       158
       158
       +
           pytest-env

     

       159
       159
       +
           pytest-sugar

     

       160
       160
       +
           pytest-xdist

     

       161
       161
       +
           factory_boy

     

       162
       162
       +
         ];

     

       163
       163
       +
       

     

       164
       164
       +
         # The tests require:

     

       165
       165
       +
         # - PATH with runtime binaries

     

       166
       166
       +
         # - A temporary HOME directory for gnupg

     

       167
       167
       +
         # - XDG_DATA_DIRS with test-specific fonts

     

       168
       168
       +
         checkPhase = ''

     

       169
       169
       +
           pushd src

     

       170
       170
       +
           PATH="${path}:$PATH" HOME=$(mktemp -d) XDG_DATA_DIRS="${liberation_ttf}/share:$XDG_DATA_DIRS" pytest

     

       171
       171
       +
           popd

     

       172
       172
       +
         '';

     

       173
       173
       +
       

     

       174
       174
       +
         installPhase = ''

     

       175
       175
       +
           mkdir -p $out/lib

     

       176
       176
       +
           cp -r . $out/lib/paperless-ng

     

       177
       177
       +
           chmod +x $out/lib/paperless-ng/src/manage.py

     

       178
       178
       +
           makeWrapper $out/lib/paperless-ng/src/manage.py $out/bin/paperless-ng \

     

       179
       179
       +
             --prefix PYTHONPATH : "$PYTHONPATH" \

     

       180
       180
       +
             --prefix PATH : "${path}"

     

       181
       181
       +
         '';

     

       182
       182
       +
       

     

       183
       183
       +
         passthru = {

     

       184
       184
       +
           # PYTHONPATH of all dependencies used by the package

     

       185
       185
       +
           pythonPath = python3.pkgs.makePythonPath propagatedBuildInputs;

     

       186
       186
       +
           inherit path;

     

       187
       187
       +
       

     

       188
       188
       +
           tests = { inherit (nixosTests) paperless-ng; };

     

       189
       189
       +
         };

     

       190
       190
       +
       

     

       191
       191
       +
         meta = with lib; {

     

       192
       192
       +
           description = "A supercharged version of paperless: scan, index, and archive all of your physical documents";

     

       193
       193
       +
           homepage = "https://paperless-ng.readthedocs.io/en/latest/";

     

       194
       194
       +
           license = licenses.gpl3Only;

     

       195
       195
       +
           maintainers = with maintainers; [ earvstedt Flakebi ];

     

       196
       196
       +
         };

     

       197
       197
       +
       }

-168

pkgs/applications/office/paperless/default.nix

···

       1
       1
       -
       { stdenv

     

       2
       2
       -
       , lib

     

       3
       3
       -
       , fetchFromGitHub

     

       4
       4
       -
       , makeWrapper

     

       5
       5
       -
       , callPackage

     

       6
       6
       -
       

     

       7
       7
       -
       , python3

     

       8
       8
       -
       , imagemagick

     

       9
       9
       -
       , ghostscript

     

       10
       10
       -
       , optipng

     

       11
       11
       -
       , tesseract

     

       12
       12
       -
       , unpaper

     

       13
       13
       -
       }:

     

       14
       14
       -
       

     

       15
       15
       -
       ## Usage

     

       16
       16
       -
       

     

       17
       17
       -
       # ${paperless}/bin/paperless wraps manage.py

     

       18
       18
       -
       

     

       19
       19
       -
       # ${paperless}/share/paperless/setup-env.sh can be sourced from a

     

       20
       20
       -
       # shell script to setup a Paperless environment

     

       21
       21
       -
       

     

       22
       22
       -
       # paperless.withConfig is a convenience function to setup a

     

       23
       23
       -
       # configured Paperless instance. (See ./withConfig.nix)

     

       24
       24
       -
       

     

       25
       25
       -
       # For WSGI with gunicorn, use a shell script like this:

     

       26
       26
       -
       # let

     

       27
       27
       -
       #   pythonEnv = paperless.python.withPackages (ps: paperless.runtimePackages ++ [ ps.gunicorn ]);

     

       28
       28
       -
       # in

     

       29
       29
       -
       #   writers.writeBash "run-gunicorn" ''

     

       30
       30
       -
       #     source ${paperless}/share/paperless/setup-env.sh

     

       31
       31
       -
       #     PYTHONPATH=$paperlessSrc ${pythonEnv}/bin/gunicorn paperless.wsgi

     

       32
       32
       -
       #   ''

     

       33
       33
       -
       

     

       34
       34
       -
       let

     

       35
       35
       -
         paperless = stdenv.mkDerivation rec {

     

       36
       36
       -
           pname = "paperless";

     

       37
       37
       -
           version = "2.7.0";

     

       38
       38
       -
       

     

       39
       39
       -
           src = fetchFromGitHub {

     

       40
       40
       -
             owner = "the-paperless-project";

     

       41
       41
       -
             repo = "paperless";

     

       42
       42
       -
             rev = version;

     

       43
       43
       -
             sha256 = "0pkmyky1crjnsg7r0gfk0fadisfsgzlsq6afpz16wx4hp6yvkkf7";

     

       44
       44
       -
           };

     

       45
       45
       -
       

     

       46
       46
       -
           nativeBuildInputs = [ makeWrapper ];

     

       47
       47
       -
       

     

       48
       48
       -
           doCheck = true;

     

       49
       49
       -
           dontInstall = true;

     

       50
       50
       -
       

     

       51
       51
       -
           pythonEnv      = python.withPackages (_: runtimePackages);

     

       52
       52
       -
           pythonCheckEnv = python.withPackages (_: (runtimePackages ++ checkPackages));

     

       53
       53
       -
       

     

       54
       54
       -
           unpackPhase = ''

     

       55
       55
       -
             srcDir=$out/share/paperless

     

       56
       56
       -
             mkdir -p $srcDir

     

       57
       57
       -
             cp -r --no-preserve=mode $src/src/* $src/LICENSE $srcDir

     

       58
       58
       -
           '';

     

       59
       59
       -
       

     

       60
       60
       -
           postPatch = ''

     

       61
       61
       -
             # django-cors-headers 3.x requires a scheme for allowed hosts

     

       62
       62
       -
             substituteInPlace $out/share/paperless/paperless/settings.py \

     

       63
       63
       -
               --replace "localhost:8080" "http://localhost:8080"

     

       64
       64
       -
           '';

     

       65
       65
       -
       

     

       66
       66
       -
           buildPhase = let

     

       67
       67
       -
             # Paperless has explicit runtime checks that expect these binaries to be in PATH

     

       68
       68
       -
             extraBin = lib.makeBinPath [ imagemagick ghostscript optipng tesseract unpaper ];

     

       69
       69
       -
           in ''

     

       70
       70
       -
             ${python.interpreter} -m compileall $srcDir

     

       71
       71
       -
       

     

       72
       72
       -
             makeWrapper $pythonEnv/bin/python $out/bin/paperless \

     

       73
       73
       -
               --set PATH ${extraBin} --add-flags $out/share/paperless/manage.py

     

       74
       74
       -
       

     

       75
       75
       -
             # A shell snippet that can be sourced to setup a paperless env

     

       76
       76
       -
             cat > $out/share/paperless/setup-env.sh <<EOF

     

       77
       77
       -
             export PATH="$pythonEnv/bin:${extraBin}''${PATH:+:}$PATH"

     

       78
       78
       -
             export paperlessSrc=$out/share/paperless

     

       79
       79
       -
             EOF

     

       80
       80
       -
           '';

     

       81
       81
       -
       

     

       82
       82
       -
           checkPhase = ''

     

       83
       83
       -
             source $out/share/paperless/setup-env.sh

     

       84
       84
       -
             tmpDir=$(realpath testsTmp)

     

       85
       85
       -
             mkdir $tmpDir

     

       86
       86
       -
             export HOME=$tmpDir

     

       87
       87
       -
             export PAPERLESS_MEDIADIR=$tmpDir

     

       88
       88
       -
             cd $paperlessSrc

     

       89
       89
       -
             # Prevent tests from writing to the derivation output

     

       90
       90
       -
             chmod -R -w $out

     

       91
       91
       -
             # Disable cache to silence a pytest warning ("could not create cache")

     

       92
       92
       -
             $pythonCheckEnv/bin/pytest -p no:cacheprovider

     

       93
       93
       -
           '';

     

       94
       94
       -
       

     

       95
       95
       -
           passthru = {

     

       96
       96
       -
             withConfig = callPackage ./withConfig.nix {};

     

       97
       97
       -
             inherit python runtimePackages checkPackages tesseract;

     

       98
       98
       -
           };

     

       99
       99
       -
       

     

       100
       100
       -
           meta = with lib; {

     

       101
       101
       -
             description = "Scan, index, and archive all of your paper documents";

     

       102
       102
       -
             homepage = "https://github.com/the-paperless-project/paperless";

     

       103
       103
       -
             license = licenses.gpl3;

     

       104
       104
       -
             maintainers = [ maintainers.earvstedt ];

     

       105
       105
       -
           };

     

       106
       106
       -
         };

     

       107
       107
       -
       

     

       108
       108
       -
         python = python3.override {

     

       109
       109
       -
           packageOverrides = self: super: let

     

       110
       110
       -
             customPkgs = import ./python-modules super fetchFromGitHub; in

     

       111
       111
       -
           {

     

       112
       112
       -
             pyocr = pyocrWithUserTesseract super;

     

       113
       113
       -
       

     

       114
       114
       -
             # Paperless is incompatible with factory_boy >= 3

     

       115
       115
       -
             factory_boy = customPkgs.factory_boy_2_12_0;

     

       116
       116
       -
       

     

       117
       117
       -
             # These are pre-release versions, hence they are private to this pkg

     

       118
       118
       -
             django-filter = self.callPackage ./python-modules/django-filter.nix {};

     

       119
       119
       -
             django-crispy-forms = self.callPackage ./python-modules/django-crispy-forms.nix {};

     

       120
       120
       -
           };

     

       121
       121
       -
         };

     

       122
       122
       -
       

     

       123
       123
       -
         runtimePackages = with python.pkgs; [

     

       124
       124
       -
           dateparser

     

       125
       125
       -
           python-dateutil

     

       126
       126
       -
           django

     

       127
       127
       -
           django-cors-headers

     

       128
       128
       -
           django-crispy-forms

     

       129
       129
       -
           django-filter

     

       130
       130
       -
           django_extensions

     

       131
       131
       -
           djangoql

     

       132
       132
       -
           djangorestframework

     

       133
       133
       -
           factory_boy

     

       134
       134
       -
           filemagic

     

       135
       135
       -
           fuzzywuzzy

     

       136
       136
       -
           langdetect

     

       137
       137
       -
           pdftotext

     

       138
       138
       -
           pillow

     

       139
       139
       -
           psycopg2

     

       140
       140
       -
           pyocr

     

       141
       141
       -
           python-dotenv

     

       142
       142
       -
           python-gnupg

     

       143
       143
       -
           pytz

     

       144
       144
       -
           termcolor

     

       145
       145
       -
         ] ++ (lib.optional stdenv.isLinux inotify-simple);

     

       146
       146
       -
       

     

       147
       147
       -
         checkPackages = with python.pkgs; [

     

       148
       148
       -
           pytest

     

       149
       149
       -
           pytest-django

     

       150
       150
       -
           pytest-env

     

       151
       151
       -
           pytest-xdist

     

       152
       152
       -
         ];

     

       153
       153
       -
       

     

       154
       154
       -
         pyocrWithUserTesseract = pyPkgs:

     

       155
       155
       -
           let

     

       156
       156
       -
             pyocr = pyPkgs.pyocr.override { inherit tesseract; };

     

       157
       157
       -
           in

     

       158
       158
       -
             if pyocr.outPath == pyPkgs.pyocr.outPath then

     

       159
       159
       -
               pyocr

     

       160
       160
       -
             else

     

       161
       161
       -
               # The user has provided a custom tesseract derivation that might be

     

       162
       162
       -
               # missing some languages that are required for PyOCR's tests. Disable them to

     

       163
       163
       -
               # avoid build errors.

     

       164
       164
       -
               pyocr.overridePythonAttrs (attrs: {

     

       165
       165
       -
                 doCheck = false;

     

       166
       166
       -
               });

     

       167
       167
       -
       in

     

       168
       168
       -
         paperless

-11

pkgs/applications/office/paperless/python-modules/default.nix

···

       1
       1
       -
       pyPkgs: fetchFromGitHub:

     

       2
       2
       -
       {

     

       3
       3
       -
         factory_boy_2_12_0 = pyPkgs.factory_boy.overridePythonAttrs (old: rec {

     

       4
       4
       -
           version = "2.12.0";

     

       5
       5
       -
           src = pyPkgs.fetchPypi {

     

       6
       6
       -
             inherit (old) pname;

     

       7
       7
       -
             inherit version;

     

       8
       8
       -
             sha256 = "0w53hjgag6ad5i2vmrys8ysk54agsqvgbjy9lg8g0d8pi9h8vx7s";

     

       9
       9
       -
           };

     

       10
       10
       -
         });

     

       11
       11
       -
       }

-39

pkgs/applications/office/paperless/python-modules/django-crispy-forms.nix

···

       1
       1
       -
       { lib

     

       2
       2
       -
       , buildPythonPackage

     

       3
       3
       -
       , fetchFromGitHub

     

       4
       4
       -
       , pytestCheckHook

     

       5
       5
       -
       , pytest-django

     

       6
       6
       -
       , django

     

       7
       7
       -
       }:

     

       8
       8
       -
       

     

       9
       9
       -
       buildPythonPackage rec {

     

       10
       10
       -
         pname = "django-crispy-forms";

     

       11
       11
       -
         version = "1.10.0";

     

       12
       12
       -
       

     

       13
       13
       -
         src = fetchFromGitHub {

     

       14
       14
       -
           owner = "django-crispy-forms";

     

       15
       15
       -
           repo = "django-crispy-forms";

     

       16
       16
       -
           rev = version;

     

       17
       17
       -
           sha256 = "0y6kskfxgckb9npcgwx4zrs5n9px159zh9zhinhxi3i7wlriqpf5";

     

       18
       18
       -
         };

     

       19
       19
       -
       

     

       20
       20
       -
         # For reasons unknown, the source dir must contain a dash

     

       21
       21
       -
         # for the tests to run successfully

     

       22
       22
       -
         postUnpack = ''

     

       23
       23
       -
           mv $sourceRoot source-

     

       24
       24
       -
           export sourceRoot=source-

     

       25
       25
       -
         '';

     

       26
       26
       -
       

     

       27
       27
       -
         checkInputs = [ django pytest-django pytestCheckHook ];

     

       28
       28
       -
       

     

       29
       29
       -
         preCheck = ''

     

       30
       30
       -
           export DJANGO_SETTINGS_MODULE=crispy_forms.tests.test_settings

     

       31
       31
       -
         '';

     

       32
       32
       -
       

     

       33
       33
       -
         meta = with lib; {

     

       34
       34
       -
           description = "The best way to have DRY Django forms";

     

       35
       35
       -
           homepage = "https://github.com/maraujop/django-crispy-forms";

     

       36
       36
       -
           license = licenses.mit;

     

       37
       37
       -
           maintainers = with maintainers; [ earvstedt ];

     

       38
       38
       -
         };

     

       39
       39
       -
       }

-26

pkgs/applications/office/paperless/python-modules/django-filter.nix

···

       1
       1
       -
       { lib, buildPythonPackage, python, pythonOlder, fetchFromGitHub

     

       2
       2
       -
       , django, django-crispy-forms, djangorestframework, mock, pytz }:

     

       3
       3
       -
       

     

       4
       4
       -
       buildPythonPackage rec {

     

       5
       5
       -
         pname = "django-filter";

     

       6
       6
       -
         version = "2.1.0-pre";

     

       7
       7
       -
         disabled = pythonOlder "3.4";

     

       8
       8
       -
       

     

       9
       9
       -
         src = fetchFromGitHub {

     

       10
       10
       -
           owner = "carltongibson";

     

       11
       11
       -
           repo = pname;

     

       12
       12
       -
           rev = "24adad8c48bc9e7c7539b6510ffde4ce4effdc29";

     

       13
       13
       -
           sha256 = "0hv4w95jnlzp9vdximl6bb27fyi75001jhvsbs0ikkd8amq8iaj7";

     

       14
       14
       -
         };

     

       15
       15
       -
       

     

       16
       16
       -
         checkInputs = [ django django-crispy-forms djangorestframework mock pytz ];

     

       17
       17
       -
       

     

       18
       18
       -
         checkPhase = "${python.interpreter} runtests.py";

     

       19
       19
       -
       

     

       20
       20
       -
         meta = with lib; {

     

       21
       21
       -
           description = "A reusable Django application for allowing users to filter querysets dynamically.";

     

       22
       22
       -
           homepage = "https://github.com/carltongibson/django-filter";

     

       23
       23
       -
           license = licenses.bsd3;

     

       24
       24
       -
           maintainers = with maintainers; [ earvstedt ];

     

       25
       25
       -
         };

     

       26
       26
       -
       }

-68

pkgs/applications/office/paperless/withConfig.nix

···

       1
       1
       -
       { paperless, lib, writers }:

     

       2
       2
       -
       

     

       3
       3
       -
       ## Usage

     

       4
       4
       -
       #

     

       5
       5
       -
       # nix-build --out-link ./paperless -E '

     

       6
       6
       -
       # (import <nixpkgs> {}).paperless.withConfig {

     

       7
       7
       -
       #   dataDir = /tmp/paperless-data;

     

       8
       8
       -
       #   config = {

     

       9
       9
       -
       #     PAPERLESS_DISABLE_LOGIN = "true";

     

       10
       10
       -
       #   };

     

       11
       11
       -
       # }'

     

       12
       12
       -
       #

     

       13
       13
       -
       # Setup DB

     

       14
       14
       -
       # ./paperless migrate

     

       15
       15
       -
       #

     

       16
       16
       -
       # Consume documents in ${dataDir}/consume

     

       17
       17
       -
       # ./paperless document_consumer --oneshot

     

       18
       18
       -
       #

     

       19
       19
       -
       # Start web interface

     

       20
       20
       -
       # ./paperless runserver --noreload localhost:8000

     

       21
       21
       -
       

     

       22
       22
       -
       { config ? {}, dataDir ? null, ocrLanguages ? null

     

       23
       23
       -
       , paperlessPkg ? paperless, extraCmds ? "" }:

     

       24
       24
       -
       with lib;

     

       25
       25
       -
       let

     

       26
       26
       -
         paperless = if ocrLanguages == null then

     

       27
       27
       -
           paperlessPkg

     

       28
       28
       -
         else

     

       29
       29
       -
           (paperlessPkg.override {

     

       30
       30
       -
             tesseract = paperlessPkg.tesseract.override {

     

       31
       31
       -
               enableLanguages = ocrLanguages;

     

       32
       32
       -
             };

     

       33
       33
       -
           }).overrideDerivation (_: {

     

       34
       34
       -
             # `ocrLanguages` might be missing some languages required by the tests.

     

       35
       35
       -
             doCheck = false;

     

       36
       36
       -
           });

     

       37
       37
       -
       

     

       38
       38
       -
         envVars = (optionalAttrs (dataDir != null) {

     

       39
       39
       -
           PAPERLESS_CONSUMPTION_DIR = "${dataDir}/consume";

     

       40
       40
       -
           PAPERLESS_MEDIADIR = "${dataDir}/media";

     

       41
       41
       -
           PAPERLESS_STATICDIR = "${dataDir}/static";

     

       42
       42
       -
           PAPERLESS_DBDIR = dataDir;

     

       43
       43
       -
         }) // config;

     

       44
       44
       -
       

     

       45
       45
       -
         envVarDefs = mapAttrsToList (n: v: ''export ${n}="${toString v}"'') envVars;

     

       46
       46
       -
         setupEnvVars = builtins.concatStringsSep "\n" envVarDefs;

     

       47
       47
       -
       

     

       48
       48
       -
         setupEnv = ''

     

       49
       49
       -
           source ${paperless}/share/paperless/setup-env.sh

     

       50
       50
       -
           ${setupEnvVars}

     

       51
       51
       -
           ${optionalString (dataDir != null) ''

     

       52
       52
       -
             mkdir -p "$PAPERLESS_CONSUMPTION_DIR" \

     

       53
       53
       -
                      "$PAPERLESS_MEDIADIR" \

     

       54
       54
       -
                      "$PAPERLESS_STATICDIR" \

     

       55
       55
       -
                      "$PAPERLESS_DBDIR"

     

       56
       56
       -
           ''}

     

       57
       57
       -
         '';

     

       58
       58
       -
       

     

       59
       59
       -
         runPaperless = writers.writeBash "paperless" ''

     

       60
       60
       -
           set -e

     

       61
       61
       -
           ${setupEnv}

     

       62
       62
       -
           ${extraCmds}

     

       63
       63
       -
           exec python $paperlessSrc/manage.py "$@"

     

       64
       64
       -
         '';

     

       65
       65
       -
       in

     

       66
       66
       -
         runPaperless // {

     

       67
       67
       -
           inherit paperless setupEnv;

     

       68
       68
       -
         }

+28

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

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , fetchPypi

     

       4
       4
       +
       , inotify-simple

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildPythonPackage rec {

     

       8
       8
       +
         pname = "inotifyrecursive";

     

       9
       9
       +
         version = "0.3.5";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchPypi {

     

       12
       12
       +
           inherit pname version;

     

       13
       13
       +
           sha256 = "osRQsxdpPkU4QW+Q6x14WFBtr+a4uIUDe9LdmuLa+h4=";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         propagatedBuildInputs = [ inotify-simple ];

     

       17
       17
       +
       

     

       18
       18
       +
         # No tests included

     

       19
       19
       +
         doCheck = false;

     

       20
       20
       +
         pythonImportsCheck = [ pname ];

     

       21
       21
       +
       

     

       22
       22
       +
         meta = with lib; {

     

       23
       23
       +
           description = "Simple recursive inotify watches for Python";

     

       24
       24
       +
           homepage = "https://github.com/letorbi/inotifyrecursive";

     

       25
       25
       +
           license = licenses.lgpl3Plus;

     

       26
       26
       +
           maintainers = with maintainers; [ Flakebi ];

     

       27
       27
       +
         };

     

       28
       28
       +
       }

+29

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

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , fetchPypi

     

       4
       4
       +
       , pyyaml

     

       5
       5
       +
       , requests

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildPythonPackage rec {

     

       9
       9
       +
         pname = "tika";

     

       10
       10
       +
         version = "1.24";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchPypi {

     

       13
       13
       +
           inherit pname version;

     

       14
       14
       +
           sha256 = "wsUPQFYi90UxhBEE+ehcF1Ea7eEd6OU4XqsaKaMfGRs=";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         propagatedBuildInputs = [ pyyaml requests ];

     

       18
       18
       +
       

     

       19
       19
       +
         # Requires network

     

       20
       20
       +
         doCheck = false;

     

       21
       21
       +
         pythonImportsCheck = [ pname ];

     

       22
       22
       +
       

     

       23
       23
       +
         meta = with lib; {

     

       24
       24
       +
           description = "A Python binding to the Apache Tika™ REST services";

     

       25
       25
       +
           homepage = "https://github.com/chrismattmann/tika-python";

     

       26
       26
       +
           license = licenses.asl20;

     

       27
       27
       +
           maintainers = with maintainers; [ Flakebi ];

     

       28
       28
       +
         };

     

       29
       29
       +
       }

pkgs/top-level/aliases.nix

···

       567
       567
        
         owncloudclient = owncloud-client;  # added 2016-08

     

       568
       568
        
         ocz-ssd-guru = throw "ocz-ssd-guru has been removed due to there being no source available"; # added 2021-07-12

     

       569
       569
        
         p11_kit = p11-kit; # added 2018-02-25

     

       570
       570
       +
         paperless = paperless-ng; # added 2021-06-06

     

       570
       571
        
         parity = openethereum; # added 2020-08-01

     

       571
       572
        
         parquet-cpp = arrow-cpp; # added 2018-09-08

     

       572
       573
        
         pass-otp = pass.withExtensions (ext: [ext.pass-otp]); # added 2018-05-04

+1 -1

pkgs/top-level/all-packages.nix

···

       7893
       7893
        
       

     

       7894
       7894
        
         pamtester = callPackage ../tools/security/pamtester { };

     

       7895
       7895
        
       

     

       7896
       7896
       -
         paperless = callPackage ../applications/office/paperless { };

     

       7896
       7896
       +
         paperless-ng = callPackage ../applications/office/paperless-ng { };

     

       7897
       7897
        
       

     

       7898
       7898
        
         paperwork = callPackage ../applications/office/paperwork/paperwork-gtk.nix { };

     

       7899
       7899

pkgs/top-level/python-packages.nix

···

       3585
       3585
        
       

     

       3586
       3586
        
         inotify-simple = callPackage ../development/python-modules/inotify-simple { };

     

       3587
       3587
        
       

     

       3588
       3588
       +
         inotifyrecursive = callPackage ../development/python-modules/inotifyrecursive { };

     

       3589
       3589
       +
       

     

       3588
       3590
        
         inquirer = callPackage ../development/python-modules/inquirer { };

     

       3589
       3591
        
       

     

       3590
       3592
        
         intake = callPackage ../development/python-modules/intake { };

     
···

       8745
       8747
        
         tidylib = callPackage ../development/python-modules/pytidylib { };

     

       8746
       8748
        
       

     

       8747
       8749
        
         tifffile = callPackage ../development/python-modules/tifffile { };

     

       8750
       8750
       +
       

     

       8751
       8751
       +
         tika = callPackage ../development/python-modules/tika { };

     

       8748
       8752
        
       

     

       8749
       8753
        
         tiledb = callPackage ../development/python-modules/tiledb {

     

       8750
       8754
        
           inherit (pkgs) tiledb;