pypi importer outputs strange character series in optional dependency case.

+++ b/guix/import/pypi.scm

+                    (requires.txt (string-append dirname "/" pypi-name

+                                                 ".egg-info" "/requires.txt"))

+                    (exit-code (parameterize ((current-error-port (%make-void-port "rw+"))

+                                              (current-output-port (%make-void-port "rw+")))

+                                 (system* "tar" "xf" tarball "-C" dir requires.txt))))

+               (if (zero? exit-code)

+                   (read-requirements (string-append dir "/" requires.txt))

+                     (warning

+                      (G_ "Failed to extract file: ~a from source.~%")

+                      requires.txt)

+  ;; First, try to compute the requirements using the wheel, else, fallback to

+  ;; reading the "requires.txt" from the egg-info directory from the source

+  ;; tarball.

+++ b/tests/pypi.scm

+  #:use-module ((guix build utils) #:select (delete-file-recursively which mkdir-p))

+(define test-requires.txt "\

+baz > 13.37

+")

+                  (mkdir-p "foo-1.0.0/foo.egg-info/")

+                  (with-output-to-file "foo-1.0.0/foo.egg-info/requires.txt"

+                      (display test-requires.txt)))

+              (begin

+                (mkdir-p "foo-1.0.0/foo.egg-info/")

+                (with-output-to-file "foo-1.0.0/foo.egg-info/requires.txt"

+                     (display test-requires.txt)))

+++ b/guix/import/pypi.scm

+  #:export (parse-requires.txt

+            guix-package->pypi-name

+(define (clean-requirement s)

+  ;; Given a requirement LINE, as can be found in a setuptools requires.txt

+  ;; file, remove everything other than the actual name of the required

+  ;; package, and return it.

+  (string-take s (or (string-index s (lambda (chr)

+                                       (member chr '(#\space #\> #\= #\<))))

+                     (string-length s))))

+

+(define (parse-requires.txt requires.txt)

+  "Given REQUIRES.TXT, a Setuptools requires.txt file, return a list of

+requirement names."

+  ;; This is a very incomplete parser, which job is to select the non-optional

+  ;; dependencies and strip them out of any version information.

+  ;; Alternatively, we could implement a PEG parser with the (ice-9 peg)

+  ;; library and the requirements grammar defined by PEP-0508

+  ;; (https://www.python.org/dev/peps/pep-0508/).

+

+  (define (comment? line)

+    ;; Return #t if the given LINE is a comment, #f otherwise.

+    (eq? (string-ref (string-trim line) 0) #\#))

+

+  (define (section-header? line)

+    ;; Return #t if the given LINE is a section header, #f otherwise.

+    (let ((trimmed-line (string-trim line)))

+      (and (not (string-null? trimmed-line))

+           (eq? (string-ref trimmed-line 0) #\[))))

+

+  (call-with-input-file requires.txt

+    (lambda (port)

+      (let loop ((result '()))

+        (let ((line (read-line port)))

+          ;; Stop when a section is encountered, as sections contains optional

+          ;; (extra) requirements.  Non-optional requirements must appear

+          ;; before any section is defined.

+          (if (or (eof-object? line) (section-header? line))

+              (reverse result)

+              (cond

+               ((or (string-null? line) (comment? line))

+                (loop result))

+               (else

+                (loop (cons (clean-requirement line)

+                            result))))))))))

+

+                   (parse-requires.txt (string-append dir "/" requires.txt))

+++ b/tests/pypi.scm

+(define test-requires-with-sections "\

+# A comment

+foo ~= 3

+bar != 2

+

+[test]

+pytest (>=2.5.0)

+")

+

+(test-equal "parse-requires.txt, with sections"

+  '("foo" "bar")

+  (mock ((ice-9 ports) call-with-input-file

+         call-with-input-string)

+        (parse-requires.txt test-requires-with-sections)))

+

+                  (parameterize ((current-output-port (%make-void-port "rw+")))

+                    (system* "tar" "czvf" file-name "foo-1.0.0/"))

+                (parameterize ((current-output-port (%make-void-port "rw+")))

+                  (system* "tar" "czvf" file-name "foo-1.0.0/"))

+++ b/guix/import/pypi.scm

+            specification->requirement-name

+(define %requirement-name-regexp

+  ;; Regexp to match the requirement name in a requirement specification.

+

+  ;; Some grammar, taken from PEP-0508 (see:

+  ;; https://www.python.org/dev/peps/pep-0508/).

+

+  ;; The unified rule can be expressed as:

+  ;; specification = wsp* ( url_req | name_req ) wsp*

+

+  ;; where url_req is:

+  ;; url_req = name wsp* extras? wsp* urlspec wsp+ quoted_marker?

+

+  ;; and where name_req is:

+  ;; name_req = name wsp* extras? wsp* versionspec? wsp* quoted_marker?

+

+  ;; Thus, we need only matching NAME, which is expressed as:

+  ;; identifer_end = letterOrDigit | (('-' | '_' | '.' )* letterOrDigit)

+  ;; identifier    = letterOrDigit identifier_end*

+  ;; name          = identifier

+  (let* ((letter-or-digit "[A-Za-z0-9]")

+         (identifier-end (string-append "(" letter-or-digit "|"

+                                        "[-_.]*" letter-or-digit ")"))

+         (identifier (string-append "^" letter-or-digit identifier-end "*"))

+         (name identifier))

+    (make-regexp name)))

+

+(define (specification->requirement-name spec)

+  "Given a specification SPEC, return the requirement name."

+  (match:substring

+   (or (regexp-exec %requirement-name-regexp spec)

+       (error (G_ "Could not extract requirement name in spec:") spec))))

+                (loop (cons (specification->requirement-name line)

+                     (map specification->requirement-name requirements)))))

+++ b/tests/pypi.scm

+(define test-specifications

+  '("Fizzy [foo, bar]"

+    "PickyThing<1.6,>1.9,!=1.9.6,<2.0a0,==2.4c1"

+    "SomethingWithMarker[foo]>1.0;python_version<\"2.7\""

+    "requests [security,tests] >= 2.8.1, == 2.8.* ; python_version < \"2.7\""

+    "pip @ https://github.com/pypa/pip/archive/1.3.1.zip#\

+sha1=da9234ee9982d4bbb3c72346a6de940a148ea686"))

+

+(test-equal "specification->requirement-name"

+  '("Fizzy" "PickyThing" "SomethingWithMarker" "requests" "pip")

+  (map specification->requirement-name test-specifications))

+

+++ b/guix/import/pypi.scm

+              ;; Duplicates can occur, since the same requirement can be

+              ;; listed multiple times with different conditional markers, e.g.

+              ;; pytest >= 3 ; python_version >= "3.3"

+              ;; pytest < 3 ; python_version < "3.3"

+              (reverse (delete-duplicates result))

+++ b/guix/import/pypi.scm

+(define (guess-requirements source-url wheel-url archive)

+  "Given SOURCE-URL, WHEEL-URL and a ARCHIVE of the package, return a list

+of the required packages specified in the requirements.txt file.  ARCHIVE will

+  (define (archive-root-directory url)

+    ;; Given the URL of the package's archive, return the name of the directory

+    (if (compressed-file? url)

+        (let ((root-directory (file-sans-extension (basename url))))

+          (if (string=? "tar" (file-extension root-directory))

+              (file-sans-extension root-directory)

+              root-directory))

+          (warning (G_ "Unsupported archive format (~a): \

+cannot determine package dependencies") (file-extension url))

+          #f)))

+    (let ((dirname (archive-root-directory source-url))

+          (extension (file-extension source-url)))

+                    (exit-code

+                     (parameterize ((current-error-port (%make-void-port "rw+"))

+                                    (current-output-port (%make-void-port "rw+")))

+                       (if (string=? "zip" extension)

+                           (system* "unzip" archive "-d" dir requires.txt)

+                           (system* "tar" "xf" archive "-C" dir requires.txt)))))

+(define (compute-inputs source-url wheel-url archive)

+  "Given the SOURCE-URL of an already downloaded ARCHIVE, return a list of

+                 (guess-requirements source-url wheel-url archive))))

+++ b/guix/import/pypi.scm

+            parse-wheel-metadata

+(define (parse-wheel-metadata metadata)

+  "Given METADATA, a Wheel metadata file, return a list of requirement names."

+  ;; METADATA is a RFC-2822-like, header based file.

+

+  (define (requires-dist-header? line)

+    ;; Return #t if the given LINE is a Requires-Dist header.

+    (regexp-match? (string-match "^Requires-Dist: " line)))

+

+  (define (requires-dist-value line)

+    (string-drop line (string-length "Requires-Dist: ")))

+

+  (define (extra? line)

+    ;; Return #t if the given LINE is an "extra" requirement.

+    (regexp-match? (string-match "extra == " line)))

+

+  (call-with-input-file metadata

+    (lambda (port)

+      (let loop ((requirements '()))

+        (let ((line (read-line port)))

+          ;; Stop at the first 'Provides-Extra' section: the non-optional

+          ;; requirements appear before the optional ones.

+          (if (eof-object? line)

+              (reverse (delete-duplicates requirements))

+              (cond

+               ((and (requires-dist-header? line) (not (extra? line)))

+                (loop (cons (specification->requirement-name

+                             (requires-dist-value line))

+                            requirements)))

+               (else

+                (loop requirements)))))))))

+

+    ;; requirements, or #f if the metadata file contained therein couldn't be

+    ;; extracted.

+           (metadata (string-append dirname "/METADATA")))

+      (call-with-temporary-directory

+       (lambda (dir)

+         (if (zero? (system* "unzip" "-q" wheel-archive "-d" dir metadata))

+             (parse-wheel-metadata (string-append dir "/" metadata))

+             (begin

+               (warning

+                (G_ "Failed to extract file: ~a from wheel.~%") metadata)

+               #f))))))

+++ b/tests/pypi.scm

+  #:use-module (guix memoization)

+(define test-metadata "\

+Classifier: Programming Language :: Python :: 3.7

+Requires-Dist: baz ~= 3

+Requires-Dist: bar != 2

+Provides-Extra: test

+pytest (>=2.5.0)

+")

+

+(define test-metadata-with-extras "

+Classifier: Programming Language :: Python :: 3.7

+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*

+Requires-Dist: wrapt (<2,>=1)

+Requires-Dist: bar

+

+Provides-Extra: dev

+Requires-Dist: tox ; extra == 'dev'

+Requires-Dist: bumpversion (<1) ; extra == 'dev'

+")

+

+;;; Provides-Extra can appear before Requires-Dist.

+(define test-metadata-with-extras-jedi "\

+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*

+Provides-Extra: testing

+Requires-Dist: parso (>=0.3.0)

+Provides-Extra: testing

+Requires-Dist: pytest (>=3.1.0); extra == 'testing'

+")

+(test-equal "parse-wheel-metadata, with extras"

+  '("wrapt" "bar")

+  (mock ((ice-9 ports) call-with-input-file

+         call-with-input-string)

+        (parse-wheel-metadata test-metadata-with-extras)))

+

+(test-equal "parse-wheel-metadata, with extras - Jedi"

+  '("parso")

+  (mock ((ice-9 ports) call-with-input-file

+         call-with-input-string)

+        (parse-wheel-metadata test-metadata-with-extras-jedi)))

+

+                     (display "wrong data to make sure we're testing wheels ")))

+                 (with-output-to-file "foo-1.0.0.dist-info/METADATA"

+                   (system* "zip" zip-file "foo-1.0.0.dist-info/METADATA")

+              ;; Not clearing the memoization cache here would mean returning the value

+              ;; computed in the previous test.

+              (invalidate-memoization! pypi->guix-package)

+++ b/guix/import/pypi.scm

+;;; Copyright © 2019 Maxim Cournoyer <maxim.cournoyer@gmail.com>

+  #:use-module (srfi srfi-11)

+(define (maybe-inputs package-inputs input-type)

+package definition.  INPUT-TYPE, a symbol, is used to populate the name of

+the input field."

+     `((,input-type (,'quasiquote ,package-inputs))))))

+(define (test-section? name)

+  "Return #t if the section name contains 'test' or 'dev'."

+  (any (cut string-contains-ci name <>)

+       '("test" "dev")))

+

+  "Given REQUIRES.TXT, a Setuptools requires.txt file, return a pair of requirements.

+

+The first element of the pair contains the required dependencies while the

+second the optional test dependencies.  Note that currently, optional,

+non-test dependencies are omitted since these can be difficult or expensive to

+satisfy."

+

+  ;; This is a very incomplete parser, which job is to read in the requirement

+  ;; specification lines, and strip them out of any version information.

+      (let loop ((required-deps '())

+                 (test-deps '())

+                 (inside-test-section? #f)

+                 (optional? #f))

+          (if (eof-object? line)

+              (map (compose reverse delete-duplicates)

+                   (list required-deps test-deps))

+                (loop required-deps test-deps inside-test-section? optional?))

+               ((section-header? line)

+                ;; Encountering a section means that all the requirements

+                ;; listed below are optional. Since we want to pick only the

+                ;; test dependencies from the optional dependencies, we must

+                ;; track those separately.

+                (loop required-deps test-deps (test-section? line) #t))

+               (inside-test-section?

+                (loop required-deps

+                      (cons (specification->requirement-name line)

+                            test-deps)

+                      inside-test-section? optional?))

+               ((not optional?)

+                            required-deps)

+                      test-deps inside-test-section? optional?))

+               (optional?

+                ;; Skip optional items.

+                (loop required-deps test-deps inside-test-section? optional?))

+               (else

+                (warning (G_ "parse-requires.txt reached an unexpected \

+condition on line ~a~%") line)))))))))

+  "Given METADATA, a Wheel metadata file, return a pair of requirements.

+

+The first element of the pair contains the required dependencies while the second the optional

+test dependencies.  Note that currently, optional, non-test dependencies are

+omitted since these can be difficult or expensive to satisfy."

+    (string-match "^Requires-Dist: " line))

+    (string-match "extra == '(.*)'" line))

+

+  (define (test-requirement? line)

+    (let ((extra-label (match:substring (extra? line) 1)))

+      (and extra-label (test-section? extra-label))))

+      (let loop ((required-deps '())

+                 (test-deps '()))

+              (map (compose reverse delete-duplicates)

+                   (list required-deps test-deps))

+                            required-deps)

+                      test-deps))

+               ((and (requires-dist-header? line) (test-requirement? line))

+                (loop required-deps

+                      (cons (specification->requirement-name (requires-dist-value line))

+                            test-deps)))

+                (loop required-deps test-deps))))))))) ;skip line

+  "Given SOURCE-URL, WHEEL-URL and an ARCHIVE of the package, return a list

+         (if (zero?

+              (parameterize ((current-error-port (%make-void-port "rw+"))

+                             (current-output-port (%make-void-port "rw+")))

+                (system* "unzip" wheel-archive "-d" dir metadata)))

+                     (list '() '()))))))

+          (list '() '()))))

+  ;; archive.

+  "Given the SOURCE-URL and WHEEL-URL of an already downloaded ARCHIVE, return

+a pair of lists, each consisting of a list of name/variable pairs, for the

+propagated inputs and the native inputs, respectively."

+

+  (define (strip-argparse deps)

+    (remove (cut string=? "argparse" <>) deps))

+

+  (define (requirement->package-name/sort deps)

+    (sort

+     (map (lambda (input)

+            (let ((guix-name (python->package-name input)))

+              (list guix-name (list 'unquote (string->symbol guix-name)))))

+          deps)

+     (lambda args

+       (match args

+         (((a _ ...) (b _ ...))

+          (string-ci<? a b))))))

+

+  (define process-requirements

+    (compose requirement->package-name/sort strip-argparse))

+

+  (map process-requirements (guess-requirements source-url wheel-url archive)))

+          (match (compute-inputs source-url wheel-url temp)

+            ((required-inputs test-inputs)

+                ,@(maybe-inputs required-inputs 'propagated-inputs)

+                ,@(maybe-inputs test-inputs 'native-inputs)

+                (license ,(license->symbol license)))))))))

+++ b/tests/pypi.scm

+;;; Copyright © 2019 Maxim Cournoyer <maxim.cournoyer@gmail.com>

+;; Beaker contains only optional dependencies.

+(define test-requires.txt-beaker "\

+[crypto]

+pycryptopp>=0.5.12

+

+[cryptography]

+cryptography

+

+[testsuite]

+Mock

+coverage

+")

+

+Requires-Dist: pytest (>=2.5.0) ; extra == 'test'

+(test-equal "parse-requires.txt"

+  (list '("foo" "bar") '("pytest"))

+        (parse-requires.txt test-requires.txt)))

+

+(test-equal "parse-requires.txt - Beaker"

+  (list '() '("Mock" "coverage"))

+  (mock ((ice-9 ports) call-with-input-file

+         call-with-input-string)

+        (parse-requires.txt test-requires.txt-beaker)))

+  (list '("wrapt" "bar") '("tox" "bumpversion"))

+  (list '("parso") '("pytest"))

+(test-assert "pypi->guix-package, no wheel"

+                        ("python-foo" ('unquote 'python-foo)))))

+                     ('native-inputs

+                      ('quasiquote

+                       (("python-pytest" ('unquote 'python-pytest)))))

+                  (lambda ()

+                    (display "wrong data to make sure we're testing wheels ")))

+                (delete-file-recursively "foo-1.0.0")

+                (set! test-source-hash

+                  (call-with-input-file file-name port-sha256))))

+              (begin

+                (mkdir "foo-1.0.0.dist-info")

+                (with-output-to-file "foo-1.0.0.dist-info/METADATA"

+                  (lambda ()

+                    (display test-metadata)))

+                (let ((zip-file (string-append file-name ".zip")))

+                  ;; zip always adds a "zip" extension to the file it creates,

+                  ;; so we need to rename it.

+                  (system* "zip" "-q" zip-file "foo-1.0.0.dist-info/METADATA")

+                  (rename-file zip-file file-name))

+                (delete-file-recursively "foo-1.0.0.dist-info")))

+                   ('native-inputs

+                    ('quasiquote

+                     (("python-pytest" ('unquote 'python-pytest)))))

+(test-assert "pypi->guix-package, no usable requirement file."

+  ;; Replace network resources with sample data.

+  (mock ((guix import utils) url-fetch

+         (lambda (url file-name)

+           (match url

+             ("https://example.com/foo-1.0.0.tar.gz"

+              (set! test-source-hash

+                (call-with-input-file file-name port-sha256))

+              #t)

+             ("https://example.com/foo-1.0.0-py2.py3-none-any.whl" #t)

+             (_ (error "Unexpected URL: " url)))))

+        (mock ((guix http-client) http-fetch

+               (lambda (url . rest)

+                 (match url

+                   ("https://pypi.org/pypi/foo/json"

+                    (values (open-input-string test-json)

+                            (string-length test-json)))

+                   ("https://example.com/foo-1.0.0-py2.py3-none-any.whl" #f)

+                   (_ (error "Unexpected URL: " url)))))

+              ;; Not clearing the memoization cache here would mean returning the value

+              ;; computed in the previous test.

+              (invalidate-memoization! pypi->guix-package)

+              (match (pypi->guix-package "foo")

+                (('package

+                   ('name "python-foo")

+                   ('version "1.0.0")

+                   ('source ('origin

+                              ('method 'url-fetch)

+                              ('uri ('pypi-uri "foo" 'version))

+                              ('sha256

+                               ('base32

+                                (? string? hash)))))

+                   ('build-system 'python-build-system)

+                   ('home-page "http://example.com")

+                   ('synopsis "summary")

+                   ('description "summary")

+                   ('license 'license:lgpl2.0))

+                 (string=? (bytevector->nix-base32-string

+                            test-source-hash)

+                           hash))

+                (x

+                 (pk 'fail x #f)))

+              )))

+

+++ b/guix/import/pypi.scm

+;;; Copyright © 2019 Maxim Cournoyer <maxim.cournoyer@gmail.com>

+  #:use-module (srfi srfi-11)

+(define (maybe-inputs package-inputs input-type)

+package definition.  INPUT-TYPE, a symbol, is used to populate the name of

+the input field."

+     `((,input-type (,'quasiquote ,package-inputs))))))

+(define (test-section? name)

+  "Return #t if the section name contains 'test' or 'dev'."

+  (any (cut string-contains-ci name <>)

+       '("test" "dev")))

+

+  "Given REQUIRES.TXT, a Setuptools requires.txt file, return a pair of requirements.

+

+The first element of the pair contains the required dependencies while the

+second the optional test dependencies.  Note that currently, optional,

+non-test dependencies are omitted since these can be difficult or expensive to

+satisfy."

+

+  ;; This is a very incomplete parser, which job is to read in the requirement

+  ;; specification lines, and strip them out of any version information.

+      (let loop ((required-deps '())

+                 (test-deps '())

+                 (inside-test-section? #f)

+                 (optional? #f))

+          (if (eof-object? line)

+              (map (compose reverse delete-duplicates)

+                   (list required-deps test-deps))

+                (loop required-deps test-deps inside-test-section? optional?))

+               ((section-header? line)

+                ;; Encountering a section means that all the requirements

+                ;; listed below are optional. Since we want to pick only the

+                ;; test dependencies from the optional dependencies, we must

+                ;; track those separately.

+                (loop required-deps test-deps (test-section? line) #t))

+               (inside-test-section?

+                (loop required-deps

+                      (cons (specification->requirement-name line)

+                            test-deps)

+                      inside-test-section? optional?))

+               ((not optional?)

+                            required-deps)

+                      test-deps inside-test-section? optional?))

+               (optional?

+                ;; Skip optional items.

+                (loop required-deps test-deps inside-test-section? optional?))

+               (else

+                (warning (G_ "parse-requires.txt reached an unexpected \

+condition on line ~a~%") line)))))))))

+  "Given METADATA, a Wheel metadata file, return a pair of requirements.

+

+The first element of the pair contains the required dependencies while the second the optional

+test dependencies.  Note that currently, optional, non-test dependencies are

+omitted since these can be difficult or expensive to satisfy."

+    (string-match "^Requires-Dist: " line))

+    (string-match "extra == '(.*)'" line))

+

+  (define (test-requirement? line)

+    (let ((extra-label (match:substring (extra? line) 1)))

+      (and extra-label (test-section? extra-label))))

+      (let loop ((required-deps '())

+                 (test-deps '()))

+              (map (compose reverse delete-duplicates)

+                   (list required-deps test-deps))

+                            required-deps)

+                      test-deps))

+               ((and (requires-dist-header? line) (test-requirement? line))

+                (loop required-deps

+                      (cons (specification->requirement-name (requires-dist-value line))

+                            test-deps)))

+                (loop required-deps test-deps))))))))) ;skip line

+  "Given SOURCE-URL, WHEEL-URL and an ARCHIVE of the package, return a list

+         (if (zero?

+              (parameterize ((current-error-port (%make-void-port "rw+"))

+                             (current-output-port (%make-void-port "rw+")))

+                (system* "unzip" wheel-archive "-d" dir metadata)))

+                     (list '() '()))))))

+          (list '() '()))))

+  ;; archive.

+  "Given the SOURCE-URL and WHEEL-URL of an already downloaded ARCHIVE, return

+a pair of lists, each consisting of a list of name/variable pairs, for the

+propagated inputs and the native inputs, respectively.  Also

+

+  (define (strip-argparse deps)

+    (remove (cut string=? "argparse" <>) deps))

+

+  (define (requirement->package-name/sort deps)

+    (sort

+     (map (lambda (input)

+            (let ((guix-name (python->package-name input)))

+              (list guix-name (list 'unquote (string->symbol guix-name)))))

+          deps)

+     (lambda args

+       (match args

+         (((a _ ...) (b _ ...))

+          (string-ci<? a b))))))

+

+  (define process-requirements

+    (compose requirement->package-name/sort strip-argparse))

+

+  (let ((dependencies (guess-requirements source-url wheel-url archive)))

+    (values (map process-requirements dependencies)

+            (concatenate dependencies))))

+          (receive (guix-dependencies upstream-dependencies)

+            (match guix-dependencies

+              ((required-inputs test-inputs)

+               (values

+                `(package

+                   (name ,(python->package-name name))

+                   (version ,version)

+                   (source (origin

+                             (method url-fetch)

+                             ;; Sometimes 'pypi-uri' doesn't quite work due to mixed

+                             ;; cases in NAME, for instance, as is the case with

+                             ;; "uwsgi".  In that case, fall back to a full URL.

+                             (uri (pypi-uri ,(string-downcase name) version))

+                             (sha256

+                              (base32

+                               ,(guix-hash-url temp)))))

+                   (build-system python-build-system)

+                   ,@(maybe-inputs required-inputs 'propagated-inputs)

+                   ,@(maybe-inputs test-inputs 'native-inputs)

+                   (home-page ,home-page)

+                   (synopsis ,synopsis)

+                   (description ,description)

+                   (license ,(license->symbol license)))

+                ;; Flatten the nested lists and return the upstream

+                ;; dependencies.

+                upstream-dependencies))))))))

+++ b/tests/pypi.scm

+;;; Copyright © 2019 Maxim Cournoyer <maxim.cournoyer@gmail.com>

+;; Beaker contains only optional dependencies.

+(define test-requires.txt-beaker "\

+[crypto]

+pycryptopp>=0.5.12

+

+[cryptography]

+cryptography

+

+[testsuite]

+Mock

+coverage

+")

+

+Requires-Dist: pytest (>=2.5.0) ; extra == 'test'

+(test-equal "parse-requires.txt"

+  (list '("foo" "bar") '("pytest"))

+        (parse-requires.txt test-requires.txt)))

+

+(test-equal "parse-requires.txt - Beaker"

+  (list '() '("Mock" "coverage"))

+  (mock ((ice-9 ports) call-with-input-file

+         call-with-input-string)

+        (parse-requires.txt test-requires.txt-beaker)))

+  (list '("wrapt" "bar") '("tox" "bumpversion"))

+  (list '("parso") '("pytest"))

+(test-assert "pypi->guix-package, no wheel"

+                        ("python-foo" ('unquote 'python-foo)))))

+                     ('native-inputs

+                      ('quasiquote

+                       (("python-pytest" ('unquote 'python-pytest)))))

+                  (lambda ()

+                    (display "wrong data to make sure we're testing wheels ")))

+                (delete-file-recursively "foo-1.0.0")

+                (set! test-source-hash

+                  (call-with-input-file file-name port-sha256))))

+              (begin

+                (mkdir "foo-1.0.0.dist-info")

+                (with-output-to-file "foo-1.0.0.dist-info/METADATA"

+                  (lambda ()

+                    (display test-metadata)))

+                (let ((zip-file (string-append file-name ".zip")))

+                  ;; zip always adds a "zip" extension to the file it creates,

+                  ;; so we need to rename it.

+                  (system* "zip" "-q" zip-file "foo-1.0.0.dist-info/METADATA")

+                  (rename-file zip-file file-name))

+                (delete-file-recursively "foo-1.0.0.dist-info")))

+                   ('native-inputs

+                    ('quasiquote

+                     (("python-pytest" ('unquote 'python-pytest)))))

+(test-assert "pypi->guix-package, no usable requirement file."

+  ;; Replace network resources with sample data.

+  (mock ((guix import utils) url-fetch

+         (lambda (url file-name)

+           (match url

+             ("https://example.com/foo-1.0.0.tar.gz"

+              (set! test-source-hash

+                (call-with-input-file file-name port-sha256))

+              #t)

+             ("https://example.com/foo-1.0.0-py2.py3-none-any.whl" #t)

+             (_ (error "Unexpected URL: " url)))))

+        (mock ((guix http-client) http-fetch

+               (lambda (url . rest)

+                 (match url

+                   ("https://pypi.org/pypi/foo/json"

+                    (values (open-input-string test-json)

+                            (string-length test-json)))

+                   ("https://example.com/foo-1.0.0-py2.py3-none-any.whl" #f)

+                   (_ (error "Unexpected URL: " url)))))

+              ;; Not clearing the memoization cache here would mean returning the value

+              ;; computed in the previous test.

+              (invalidate-memoization! pypi->guix-package)

+              (match (pypi->guix-package "foo")

+                (('package

+                   ('name "python-foo")

+                   ('version "1.0.0")

+                   ('source ('origin

+                              ('method 'url-fetch)

+                              ('uri ('pypi-uri "foo" 'version))

+                              ('sha256

+                               ('base32

+                                (? string? hash)))))

+                   ('build-system 'python-build-system)

+                   ('home-page "http://example.com")

+                   ('synopsis "summary")

+                   ('description "summary")

+                   ('license 'license:lgpl2.0))

+                 (string=? (bytevector->nix-base32-string

+                            test-source-hash)

+                           hash))

+                (x

+                 (pk 'fail x #f)))

+              )))

+

+++ b/guix/import/pypi.scm

+                          find-files

+                          invoke))

+           (and (url-fetch wheel-url temp)

+                (read-wheel-metadata temp))

+           #f))))

+    (if (compressed-file? source-url)

+        (call-with-temporary-directory

+         (lambda (dir)

+           (parameterize ((current-error-port (%make-void-port "rw+"))

+                          (current-output-port (%make-void-port "rw+")))

+             (if (string=? "zip" (file-extension source-url))

+                 (invoke "unzip" archive "-d" dir)

+                 (invoke "tar" "xf" archive "-C" dir)))

+           (let ((requires.txt-files

+                  (find-files dir (lambda (abs-file-name _)

+		                    (string-match "\\.egg-info/requires.txt$"

+                                                  abs-file-name)))))

+             (if (> (length requires.txt-files) 0)

+                 (begin

+                   (parse-requires.txt (first requires.txt-files)))

+                 (begin (warning (G_ "Cannot guess requirements from source archive:\

+ no requires.txt file found.~%"))

+                        (list '() '()))))))

+        (begin

+          (warning (G_ "Unsupported archive format; \

+cannot determine package dependencies from source archive: ~a~%")

+                   (basename source-url))

+++ b/tests/pypi.scm

+                  ;; Unusual requires.txt location should still be found.

+                  (mkdir-p "foo-1.0.0/src/bizarre.egg-info")

+                  (with-output-to-file "foo-1.0.0/src/bizarre.egg-info/requires.txt"

+              (mkdir-p "foo-1.0.0/foo.egg-info/")

+              (parameterize ((current-output-port (%make-void-port "rw+")))

+                (system* "tar" "czvf" file-name "foo-1.0.0/"))

+              (delete-file-recursively "foo-1.0.0")

+                (call-with-input-file file-name port-sha256)))

+             ("https://example.com/foo-1.0.0-py2.py3-none-any.whl" #f)

+                 (pk 'fail x #f))))))