all messages for Guix-related lists mirrored at yhetil.org
 help / color / mirror / code / Atom feed
blob a05fd5a7949572654f172bda9a4992b94e3194fe 10668 bytes (raw)
name: guix/build-system/python.scm 	 # note: path name is non-authoritative(*)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
 
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2013, 2014, 2015, 2016, 2017 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2013 Andreas Enge <andreas@enge.fr>
;;; Copyright © 2013 Nikita Karetnikov <nikita@karetnikov.org>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (guix build-system python)
  #:use-module (guix store)
  #:use-module (guix utils)
  #:use-module (guix memoization)
  #:use-module (guix packages)
  #:use-module (guix derivations)
  #:use-module (guix search-paths)
  #:use-module (guix build-system)
  #:use-module (guix build-system gnu)
  #:use-module (ice-9 match)
  #:use-module (srfi srfi-1)
  #:use-module (srfi srfi-26)
  #:export (%python-build-system-modules
            package-with-python2
            strip-python2-variant
            default-python
            default-python2
            python-build
            python-build-system
            pypi-uri))

;; Commentary:
;;
;; Standard build procedure for Python packages using 'setup.py'.  This is
;; implemented as an extension of 'gnu-build-system'.
;;
;; Code:

(define* (pypi-uri name version #:optional (extension ".tar.gz"))
  "Return a URI string for the Python package hosted on the Python Package
Index (PyPI) corresponding to NAME and VERSION.  EXTENSION is the file name
extension, such as '.tar.gz'."
  (string-append "https://pypi.io/packages/source/"
                 (string-take name 1) "/" name "/"
                 name "-" version extension))

(define %python-build-system-modules
  ;; Build-side modules imported by default.
  `((guix build python-build-system)
    ,@%gnu-build-system-modules))

(define (default-python)
  "Return the default Python package."
  ;; Lazily resolve the binding to avoid a circular dependency.
  (let ((python (resolve-interface '(gnu packages python))))
    (module-ref python 'python-wrapper)))

(define (default-python2)
  "Return the default Python 2 package."
  (let ((python (resolve-interface '(gnu packages python))))
    (module-ref python 'python-2)))

(define* (package-with-explicit-python python old-prefix new-prefix
                                       #:key variant-property)
  "Return a procedure of one argument, P.  The procedure creates a package with
the same fields as P, which is assumed to use PYTHON-BUILD-SYSTEM, such that
it is compiled with PYTHON instead.  The inputs are changed recursively
accordingly.  If the name of P starts with OLD-PREFIX, this is replaced by
NEW-PREFIX; otherwise, NEW-PREFIX is prepended to the name.

When VARIANT-PROPERTY is present, it is used as a key to search for
pre-defined variants of this transformation recorded in the 'properties' field
of packages.  The property value must be the promise of a package.  This is a
convenient way for package writers to force the transformation to use
pre-defined variants."
  (define transform
    ;; Memoize the transformations.  Failing to do that, we would build a huge
    ;; object graph with lots of duplicates, which in turns prevents us from
    ;; benefiting from memoization in 'package-derivation'.
    (mlambdaq (p)
      (let* ((rewrite-if-package
              (lambda (content)
                ;; CONTENT may be a file name, in which case it is returned,
                ;; or a package, which is rewritten with the new PYTHON and
                ;; NEW-PREFIX.
                (if (package? content)
                    (transform content)
                    content)))
             (rewrite
              (match-lambda
                ((name content . rest)
                 (append (list name (rewrite-if-package content)) rest)))))

        (cond
         ;; If VARIANT-PROPERTY is present, use that.
         ((and variant-property
               (assoc-ref (package-properties p) variant-property))
          => force)

         ;; Otherwise build the new package object graph.
         ((eq? (package-build-system p) python-build-system)
          (package
            (inherit p)
            (location (package-location p))
            (name (let ((name (package-name p)))
                    (string-append new-prefix
                                   (if (string-prefix? old-prefix name)
                                       (substring name
                                                  (string-length old-prefix))
                                       name))))
            (arguments
             (let ((python (if (promise? python)
                               (force python)
                               python)))
               (ensure-keyword-arguments (package-arguments p)
                                         `(#:python ,python))))
            (inputs (map rewrite (package-inputs p)))
            (propagated-inputs (map rewrite (package-propagated-inputs p)))
            (native-inputs (map rewrite (package-native-inputs p)))))
         (else
          p)))))

  transform)

(define package-with-python2
  ;; Note: delay call to 'default-python2' until after the 'arguments' field
  ;; of packages is accessed to avoid a circular dependency when evaluating
  ;; the top-level of (gnu packages python).
  (package-with-explicit-python (delay (default-python2))
                                "python-" "python2-"
                                #:variant-property 'python2-variant))

(define (strip-python2-variant p)
  "Remove the 'python2-variant' property from P."
  (package
    (inherit p)
    (properties (alist-delete 'python2-variant (package-properties p)))))

(define* (lower name
                #:key source inputs native-inputs outputs system target
                (python (default-python))
                #:allow-other-keys
                #:rest arguments)
  "Return a bag for NAME."
  (define private-keywords
    '(#:source #:target #:python #:inputs))

  (and (not target)                               ;XXX: no cross-compilation
       (bag
         (name name)
         (system system)
         (host-inputs `(,@(if source
                              `(("source" ,source))
                              '())
                        ,@inputs

                        ;; Keep the standard inputs of 'gnu-build-system'.
                        ,@(standard-packages)))
         (build-inputs `(("python" ,python)
                         ,@native-inputs))
         (outputs outputs)
         (build python-build)
         (arguments (strip-keyword-arguments private-keywords arguments)))))

(define* (python-build store name inputs
                       #:key
                       (native-inputs '())
                       ;; TODO: Something like this:
                       ;; (disallowed-references native-inputs)
                       (tests? #t)
                       (test-target "test")
                       (use-setuptools? #t)
                       (configure-flags ''())
                       (phases '(@ (guix build python-build-system)
                                   %standard-phases))
                       (outputs '("out"))
                       (search-paths '())
                       (system (%current-system))
                       (guile #f)
                       (imported-modules %python-build-system-modules)
                       (modules '((guix build python-build-system)
                                  (guix build utils))))
  "Build SOURCE using PYTHON, and with INPUTS.  This assumes that SOURCE
provides a 'setup.py' file as its build system."
  (define canonicalize-reference
    (match-lambda
      (((? derivation? source))
       (derivation->output-path source))
      (((? package? package))
       (derivation->output-path
        (package-derivation store package system)))
      ((source)
       source)
      (source
       source)))

  (define builder
    `(begin
       (use-modules ,@modules)
       (python-build #:name ,name
                     #:source ,(canonicalize-reference
                                (assoc-ref inputs "source"))
                     #:configure-flags ,configure-flags
                     #:system ,system
                     #:test-target ,test-target
                     #:tests? ,tests?
                     #:use-setuptools? ,use-setuptools?
                     #:phases ,phases
                     #:outputs %outputs
                     #:search-paths ',(map search-path-specification->sexp
                                           search-paths)
                     #:inputs %build-inputs

                     ;; We call them "native inputs" but there's no
                     ;; cross-compilation here, so that really means
                     ;; "build-time-only" inputs, things should not be
                     ;; run-time dependencies.
                     #:native-inputs ',(map (match-lambda
                                              ((name . rest)
                                               `(,name
                                                 . ,(canonicalize-reference rest))))
                                            native-inputs))))

  (define guile-for-build
    (match guile
      ((? package?)
       (package-derivation store guile system #:graft? #f))
      (#f                                         ; the default
       (let* ((distro (resolve-interface '(gnu packages commencement)))
              (guile  (module-ref distro 'guile-final)))
         (package-derivation store guile system #:graft? #f)))))

  (build-expression->derivation store name builder
                                #:inputs inputs
                                ;; TODO:
                                ;; #:disallowed-references disallowed-references
                                #:system system
                                #:modules imported-modules
                                #:outputs outputs
                                #:guile-for-build guile-for-build))

(define python-build-system
  (build-system
    (name 'python)
    (description "The standard Python build system")
    (lower lower)))

;;; python.scm ends here

debug log:

solving a05fd5a79 ...
found a05fd5a79 in https://yhetil.org/guix/87o9wiwzn2.fsf@gnu.org/
found 17173f121 in https://git.savannah.gnu.org/cgit/guix.git
preparing index
index prepared:
100644 17173f121ec06a79f8212a9eebdde6cc6a66e553	guix/build-system/python.scm

applying [1/1] https://yhetil.org/guix/87o9wiwzn2.fsf@gnu.org/
diff --git a/guix/build-system/python.scm b/guix/build-system/python.scm
index 17173f121..a05fd5a79 100644

Checking patch guix/build-system/python.scm...
Applied patch guix/build-system/python.scm cleanly.

index at:
100644 a05fd5a7949572654f172bda9a4992b94e3194fe	guix/build-system/python.scm

(*) Git path names are given by the tree(s) the blob belongs to.
    Blobs themselves have no identifier aside from the hash of its contents.^

Code repositories for project(s) associated with this external index

	https://git.savannah.gnu.org/cgit/guix.git

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.