melpa-packages.hy

#!/usr/bin/env hy3

(import [requests [get :as fetch]])

(require [hy.extra.anaphoric [ap-each :as aeach
                              ap-map :as amap]]
         [hy.contrib.walk [let]])

(defmacro try* [&rest body]
  `(try ~@body
        (except [Exception])))

(defmacro get* [&rest args]
  "Like `get', but ignores e.g. KeyErrors."
  `(try*
     (get ~@args)))

(defmacro aprog1 [result &rest body]
  `(let [it ~result]
     ~@body
     it))

(defmacro/g! parse-args [&rest args]
  "Return arguments parsed from sys.argv with argparse according to ARGS.

ARGS should be a list of arguments passed to argparse.ArgumentParser.add_argument."
  `(do
     (import argparse)
     (setv g!parser (argparse.ArgumentParser))
     ~@(lfor arg args
             `(.add-argument g!parser ~@arg))
     (.parse_args g!parser)))

(defmacro atypecase [obj &rest forms]
  `(let [it ~obj]
     (cond ~@(lfor form forms
                   `[(is (type it) ~(first form))
                     ~@(rest form)]
                   ))))

(defn field-contains? [s field package]
  "Return non-nil if PACKAGE's FIELD contains string S."
  (atypecase (get* package "props" field)
             [str (in s it)]
             [list (some (fn [ls]
                           (in s ls))
                         it)]))

(defn print-type [field string-or-strings]
  "Print packages and totals for packages whose FIELD contains STRING-OR-STRINGS."
  (aeach string-or-strings
         (let [package-names (list (lfor package-name archive
                                         :if (field-contains? it field (get* archive package-name))
                                         package-name))
               package-downloads (aprog1 (dict)
                                         (lfor n package-names
                                               (assoc it n (get* downloads n))))]
           (.sort package-names
                  :key (fn [package-name]
                         (get* package-downloads package-name)))
           (print (+ field ": " it
                     "  Packages: " (str (len package-names))
                     (.format "  TOTAL: {}" (sum (amap (get package-downloads it)
                                                       package-names)))))
           (aeach package-names
                  (print (.format "{}: {}" it (get package-downloads it))))

           (print))))

(setv args (parse-args
             ["-a" "--author" :nargs "+"]
             ["-m" "--maintainer" :nargs "+"])
      archive-json-url "https://melpa.org/archive.json"
      download-count-json-url "https://melpa.org/download_counts.json"
      archive (.json (fetch archive-json-url))
      downloads (.json (fetch download-count-json-url)))

(when args.author
  ;; The authors field is plural
  (print-type "authors" args.author))
(when args.maintainer
  (print-type "maintainer" args.maintainer))