Dataset preprocessing with Guix scripts

(define-public hello
  (package
    (name "hello")
    (version "2.12.1")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://gnu/hello/hello-" version
                                  ".tar.gz"))
              (sha256
               (base32
                "086vqwk2wl8zfs47sq2xpjc9k066ilmb8z6dn0q6ymwjzlm196cd"))))
    (build-system gnu-build-system)
    (synopsis "Hello, GNU world: An example GNU package")
    (description
     "GNU Hello prints the message \"Hello, world!\" and then exits.  It
serves as an example of standard GNU coding practices.  As such, it supports
command-line arguments, multiple languages, and so on.")
    (home-page "https://www.gnu.org/software/hello/")
    (license gpl3+)))

stdenv.mkDerivation (finalAttrs: {
  pname = "hello";
  version = "2.12.1";

  src = fetchurl {
    url = "mirror://gnu/hello/hello-${finalAttrs.version}.tar.gz";
    sha256 = "sha256-jZkUKv2SV28wsM18tCqNxoCZmLxdYH2Idh9RLibH2yA=";
  };

  doCheck = true;

  passthru.tests = {
    version = testers.testVersion { package = hello; };

    invariant-under-noXlibs =
      testers.testEqualDerivation
        "hello must not be rebuilt when environment.noXlibs is set."
        hello
        (nixos { environment.noXlibs = true; }).pkgs.hello;
  };

  passthru.tests.run = callPackage ./test.nix { hello = finalAttrs.finalPackage; };

  meta = with lib; {
    description = "A program that produces a familiar, friendly greeting";
    longDescription = ''
      GNU Hello is a program that prints "Hello, world!" when you run it.
      It is fully customizable.
    '';
    homepage = "https://www.gnu.org/software/hello/manual/";
    changelog = "https://git.savannah.gnu.org/cgit/hello.git/plain/NEWS?h=v${finalAttrs.version}";
    license = licenses.gpl3Plus;
    maintainers = [ maintainers.eelco ];
    mainProgram = "hello";
    platforms = platforms.all;
  };
})

(define filename "/gnu/store...")
(define version "12.3.4")

(write
 (quasiquote
  (begin
    (copy-file (unquote filename) "./")
    (display (unquote version)) (newline))))

(use-modules (guix gexp)
             (gnu packages base))

(define some-constant "12345...")

(define exp
  (gexp
   (begin
     (system* (string-append (ungexp hello) "/bin/hello"))
     (with-output-to-file (ungexp output)
       (lambda ()
         (display "contents") (newline)
         (display (ungexp some-constant)) (newline))))))

(write exp)

#!/usr/bin/env -S guix build -f
!#
;; The shebang lets us execute it after having `chmod +x`-ed it.

(use-modules
 (srfi srfi-1)                          ; List utilities
 (guix gexp)                            ; For `gexp`, `local-file` and more.
 (guix build utils)                     ; find-files
 (terramorpha packages energyplus))     ; For the energyplus package itself

;; The whole chain of updates we need to go through
(define versions
  '("9.5.0"
    "9.6.0"
    "22.1.0"
    "22.2.0"
    "23.1.0"
    "23.2.0"
    "24.1.0"))

;; A single update step. 
(define* (update-version file #:key from to)
  ;; Turns a version name in 1.2.3 format into its 1-2-3 format.
  (define (turn-version v)
    (string-map (lambda (c) (if (eq? c #\.)
                           #\-
                           c))
                v))
  ;; The idd file that describes the source version format
  (define fromidd (string-append "V" (turn-version from) "-Energy+.idd"))
  ;; The idd file that describes the source version format
  (define toidd (string-append "V" (turn-version to) "-Energy+.idd"))
  #~(begin
      ;; On the build side, we first have to copy the format
      ;; specifiers for both versions in the working directory.
      (copy-file (string-append #$energyplus "/PreProcess/IDFVersionUpdater/" #$fromidd)
                 #$fromidd)
      (copy-file (string-append #$energyplus "/PreProcess/IDFVersionUpdater/" #$toidd)
                 #$toidd)
      ;; We also have to copy the file to convert in the working
      ;; directory.
      (copy-file #$file "./file.idf")
      ;; Then, we run the appropriate binary (named like
      ;; Transition-V1.2.3-to-V1.2.4) on the input file
      (system* (string-append
                #$energyplus
                "/PreProcess/IDFVersionUpdater/Transition-V"
                #$(turn-version from)
                "-to-V"
                #$(turn-version to))
               "./file.idf")
      ;; Finally, we copy the output file to the output path. Here,
      ;; #$output is a special variable pointing to the output path of
      ;; the current build procedure. It is similar to the $@ variable
      ;; in makefiles.
      (copy-file "./file.idfnew"
                 #$output)))

;; update-all-the-way takes a file name (from the client side) and
;; returns a file like object that, when built, will give the fully
;; updated idf file.
(define (update-all-the-way filename)
  (define name (basename filename))
  ;; if we had version 1, 2, and 3, transitions would contain
  ;; transition procedures of the form (1 -> 2, 2 -> 3) where each
  ;; arrow takes a file like object pointing to an idf file from a
  ;; version and returns a file like object pointing to an idf file
  ;; from the next version.
  (define transitions (map (lambda (from to)
                             (lambda (file)
                               (computed-file (string-append (car (string-split name #\.)) "-" to ".idf")
                                              (update-version file
                                                              #:from from
                                                              #:to to)
                                              ;; This argument is
                                              ;; important to allow
                                              ;; guix to execute it on
                                              ;; remote machines.
                                              #:local-build? #f)))

                           (list-head versions (1- (length versions)))
                           (cdr versions)))

  ;; We apply each transition procedure one after the other.
  (fold (lambda (updater file) (updater file))
        ;; local-file is important to take a file on the client
        ;; file-system and turn it into a file-like object that will
        ;; be accessible on the build side.
        (local-file filename) transitions))

(define prof
  (getenv "GUIX_LOAD_PROFILE"))

;; We list every idf file in our dataset.
(define all-idf-files
  (find-files (string-append prof "/share/energyplus/buildings/") ".*\\.idf"))

;; For each of these files, we create a file-like object for their
;; upgraded version.
(define all-the-updated-files
  (map update-all-the-way all-idf-files))

;; In the last file-like object, we assemble every artifact into a
;; common directory.
(define new-dataset
  (computed-file
   "energyplus-dataset-family-1a-24.1.0"
   ;; with-imported-modules lets us add scheme libraries to be made
   ;; available on the build side. (guix build utils) provides the
   ;; `install-file` procedure.
   (with-imported-modules
    '((guix build utils))
    #~(begin
        (use-modules (guix build utils))
        (for-each
         (lambda (filename)
           (install-file filename (string-append #$output "/share/energyplus/buildings/"))))
        '#$all-the-updated-files))
   #:local-build? #f))

;; We end the program with an expression so that the file can be executed with `guix build -f`
new-dataset