diff --git a/nixos/modules/tasks/filesystems/bcachefs.nix b/nixos/modules/tasks/filesystems/bcachefs.nix
index 5fda24adb97..897ddf03927 100644
--- a/nixos/modules/tasks/filesystems/bcachefs.nix
+++ b/nixos/modules/tasks/filesystems/bcachefs.nix
@@ -45,7 +45,7 @@ in
       system.fsPackages = [ pkgs.bcachefs-tools ];
 
       # use kernel package with bcachefs support until it's in mainline
-      boot.kernelPackages = pkgs.linuxPackages_testing_bcachefs;
+      # boot.kernelPackages = pkgs.linuxPackages_testing_bcachefs;
     }
 
     (mkIf ((elem "bcachefs" config.boot.initrd.supportedFilesystems) || (bootFs != {})) {

diff --git a/lib/licenses.nix b/lib/licenses.nix
index 4fa6d6abc7a..198b570e0ae 100644
--- a/lib/licenses.nix
+++ b/lib/licenses.nix
@@ -690,6 +690,11 @@ in mkLicense lset) ({
     fullName = "OpenSSL License";
   };
 
+  oreo = {
+    fullName = "Oreo Public License";
+    free = true;
+  };
+
   osl2 = {
     spdxId = "OSL-2.0";
     fullName = "Open Software License 2.0";

diff --git a/pkgs/top-level/aliases.nix b/pkgs/top-level/aliases.nix
index 7b9c55ee702..4c86533cad5 100644
--- a/pkgs/top-level/aliases.nix
+++ b/pkgs/top-level/aliases.nix
@@ -1154,10 +1154,10 @@ mapAliases ({
   pyrex095 = throw "pyrex has been removed from nixpkgs as the project is still stuck on python2"; # Added 2022-01-12
   pyrex096 = throw "pyrex has been removed from nixpkgs as the project is still stuck on python2"; # Added 2022-01-12
   pyrit = throw "pyrit has been removed from nixpkgs as the project is still stuck on python2"; # Added 2022-01-01
-  python = python2; # Added 2022-01-11
+  python = python3; # Added 2022-01-11
   python-swiftclient = swiftclient; # Added 2021-09-09
   python2nix = throw "python2nix has been removed as it is outdated. Use e.g. nixpkgs-pytools instead"; # Added 2021-03-08
-  pythonFull = python2Full; # Added 2022-01-11
+  pythonFull = python3Full; # Added 2022-01-11
   pythonPackages = python.pkgs; # Added 2022-01-11
 
   ### Q ###
diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix
index 1803508bdd4..da416ccaea6 100644
--- a/pkgs/top-level/all-packages.nix
+++ b/pkgs/top-level/all-packages.nix
@@ -14502,7 +14502,7 @@ with pkgs;
   # available as `pythonPackages.tkinter` and can be used as any other Python package.
   # When switching these sets, please update docs at ../../doc/languages-frameworks/python.md
   python2 = python27;
-  python3 = python39;
+  python3 = python310;
 
   # pythonPackages further below, but assigned here because they need to be in sync
   python2Packages = dontRecurseIntoAttrs python27Packages;

diff --git a/pkgs/development/python-modules/hy/default.nix b/pkgs/development/python-modules/hy/default.nix
index a962f868..a84a95ac 100644
--- a/pkgs/development/python-modules/hy/default.nix
+++ b/pkgs/development/python-modules/hy/default.nix
@@ -16,18 +16,22 @@
 
 buildPythonPackage rec {
   pname = "hy";
-  version = "1.0a4";
+  version = "0.24.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
 
   src = fetchFromGitHub {
-    owner = "hylang";
-    repo = pname;
-    rev = version;
-    sha256 = "sha256-MBzp3jqBg/kH233wcgYYHc+Yg9GuOaBsXIfjFDihD1E=";
+      owner = "hylang";
+      repo = pname;
+      rev = version;
+      sha256 = "1s458ymd9g3s8k2ccc300jr4w66c7q3vhmhs9z3d3a4qg0xdhs9y";
   };
 
+  postPatch = ''substituteInPlace setup.py --replace "\"funcparserlib ~= 1.0\"," ""'';
+
+  disabledTestPaths = [ "tests/test_bin.py" ];
+
   # https://github.com/hylang/hy/blob/1.0a4/get_version.py#L9-L10
   HY_VERSION = version;

":"; exec emacs --quick --script "$0" -- "$@" # -*- mode: emacs-lisp; lexical-binding: t; -*-
;;; bin/org-export

;; Exports blocks from org files. Debug/info messages are directed to stderr and
;; can be ignored.
;;
;;   -a/--all
;;     Export all blocks by default (unless it has :exports none set or a
;;     :noexport: tag)
;;   -t/--tag TAG
;;      --and TAG
;;      --or TAG
;;     Only include blocks in trees that have these tags. Combine multiple --and
;;     and --or's, or just use --tag (implicit --and).
;;   -p/--print
;;     Prints exported code to stdout instead of to files
;;
;; Usage: org-export some-file.org another.org
;; Examples:
;;   org-export -l sh modules/some/module/README.org > install_module.sh
;;   org-export -l sh modules/lang/go/README.org | sh
;;   org-export --and tagA --and tagB my/literate/config.org

(require 'cl-lib)
(require 'ox)
(require 'ox-html)
(load-file (concat (file-name-directory (or load-file-name buffer-file-name)) "org-export-functions.el"))

(setq debug-on-error t)

(defun usage ()
  (with-temp-buffer
    (insert (format "%s %s [OPTIONS] [TARGETS...]\n"
                    "Usage:"
                    (file-name-nondirectory load-file-name))
            "\n"
            "A command line interface for tangling org-mode files. TARGETS can be\n"
            "files or folders (which are searched for org files recursively).\n"
            "\n"
            "This is useful for literate configs that rely on command line\n"
            "workflows to build it.\n"
            "\n"
            "Example:\n"
            "  org-export some-file.org\n"
            "  org-export literate/config/\n"
            "  org-export -p -l sh scripts.org > do_something.sh\n"
            "  org-export -p -l python -t tagA -t tagB file.org | python\n"
            "\n"
            "Options:\n"
            "  -a --all\t\tExport all blocks by default\n"
            "  -p --print\t\tPrint exported output to stdout than to files\n"
            "  -t --tag TAG\n"
            "     --and TAG\n"
            "     --or TAG\n"
            "    Lets you export org blocks by tag. You may have more than one\n"
            "    of these options.\n")
    (princ (buffer-string))))

(defun *org-babel-export (fn &rest args)
  "Don't write exported blocks to files, print them to stdout."
  (cl-letf (((symbol-function 'write-region)
             (lambda (start end filename &optional append visit lockname mustbenew)
               (princ (buffer-string)))))
    (apply fn args)))

(defvar all-blocks nil)
(defvar and-tags nil)
(defvar or-tags nil)
(defvar initial-args argv)
(defvar expanded-args (mapcar #'f-expand argv))
(defvar debug (or (member "-d" initial-args) (member "--debug" initial-args)))
(defvar force (or (member "-f" initial-args) (member "--force" initial-args)))
(defvar bundle-path nil)
(defvar use-nix-path nil)
(let (srcs and-tags or-tags)
  (pop argv)
  (while argv
    (let ((arg (pop argv)))
      (pcase arg
        ((or "-h" "--help")
         (usage)
         (error ""))
        ((or "-f" "--force")
         nil)
        ((or "-b" "--bundle-path")
         (setq bundle-path (pop argv)))
        ((or "-n" "--use-nix-path")
         (setq use-nix-path t))
        ((or "-d" "--debug")
         nil)
        ((or "-a" "--all")
         (setq all-blocks t))
        ((or "-p" "--print")
         (advice-add #'org-html-export-to-html :around #'*org-babel-export))
        ((or "-t" "--tag" "--and")
         (push (pop argv) and-tags))
        ("--or"
         (push (pop argv) or-tags))
        ((guard (file-directory-p arg))
         (setq srcs
               (append (directory-files-recursively arg "\\.org$")
                       srcs)))
        ((guard (file-exists-p arg))
         (push arg srcs))
        (_ (if force
              (message "Skipping unknown option or file: %s" arg)
              (error "Unknown option or file: %s" arg))))))

  (dolist (file srcs)
    (let* ((file (f-expand (substitute-in-file-name file)))
           (backup (make-temp-file (file-name-base file) nil ".backup.org"))
           (post (eval `(lambda nil (ignore-errors (copy-file ,backup ,file t))
                                    (ignore-errors (delete-file ,backup))))))
      (add-hook 'kill-emacs-hook post)
      (message (format "\n\nNow exporting %s:\n" file))
      (unwind-protect
          ;; Prevent slow hooks from interfering
          (let (org-mode-hook org-confirm-babel-evaluate make-backup-files)
               (copy-file file backup t)
               (with-current-buffer (find-file-noselect file)
               (org-html-export-to-html)))
        (funcall post))))
  (kill-emacs 0))

(setq org-functions-directory (file-name-directory (or load-file-name buffer-file-name))
      windows (member system-type '(windows-nt ms-dos)))
(defun meq/oefd (&rest args) (apply #'concat org-functions-directory (mapcar #'(lambda (arg) (concat (if windows "\\" "/") arg)) args)))

(load-file (meq/oefd "org-tangle-functions.el"))
(unless (require 'htmlize nil t)
    (add-to-list 'load-path (meq/oefd "htmlize"))
    (require 'htmlize))

(defun meq/org-html-src-block (src-block _contents info)
  "Transcode a SRC-BLOCK element from Org to HTML.
CONTENTS holds the contents of the item.  INFO is a plist holding
contextual information."
  (if (org-export-read-attribute :attr_html src-block :textarea)
      (org-html--textarea-block src-block)
    (let* ((lang (org-element-property :language src-block))
           (lang (cond ((member lang '("emacs-lisp")) "lisp")
                       ((member lang '("shell" "zsh" "bash")) "sh")
                       ((member lang '("text")) "plaintext")
                       (t lang)))
           (code (org-html-format-code src-block info))
           (label (let ((lbl (org-html--reference src-block info t)))
                    (if lbl (format " id=\"%s\"" lbl) "")))
           (klipsify  (and  (plist-get info :html-klipsify-src)
                            (member lang '("javascript" "js"
                                           "ruby" "scheme" "clojure" "php" "html")))))
      (if (not lang) (format "<pre class=\"example\"%s>\n%s</pre>" label code)
        (format "<div class=\"org-src-container\">\n%s%s\n</div>"
                ;; Build caption.
                (let ((caption (org-export-get-caption src-block)))
                  (if (not caption) ""
                    (let ((listing-number
                           (format
                            "<span class=\"listing-number\">%s </span>"
                            (format
                             (org-html--translate "Listing %d:" info)
                             (org-export-get-ordinal
                              src-block info nil #'org-html--has-caption-p)))))
                      (format "<label class=\"org-src-name\">%s%s</label>"
                              listing-number
                              (org-trim (org-export-data caption info))))))
                ;; Contents.
                (if klipsify
                    (format "<pre><code class=\"src src-%s\"%s%s>%s</code></pre>"
                            lang
                            label
                            (if (string= lang "html")
                                " data-editor-type=\"html\""
                              "")
                            code)
                  (format "<pre><code class=\"language-%s match-braces rainbow-braces\"%s>%s</code></pre>"
                          lang label code)))))))
        (advice-add #'org-html-src-block :override #'meq/org-html-src-block)

(defun meq/org-html-inline-src-block (inline-src-block _contents info)
  "Transcode an INLINE-SRC-BLOCK element from Org to HTML.
CONTENTS holds the contents of the item.  INFO is a plist holding
contextual information."
  (let* ((lang (org-element-property :language inline-src-block))
         (code (org-html-fontify-code
                (org-element-property :value inline-src-block)
                lang))
         (label
          (let ((lbl (org-html--reference inline-src-block info t)))
            (if (not lbl) "" (format " id=\"%s\"" lbl)))))
    (format "<code class=\"language-%s match-braces rainbow-braces\"%s>%s</code>" lang label code)))
(advice-add #'org-html-inline-src-block :override #'meq/org-html-inline-src-block)

(defun meq/org-html-format-headline-default-function
    (todo _todo-type priority text tags info)
  "Default format function for a headline.
See `org-html-format-headline-function' for details."
  (let ((todo (org-html--todo todo info))
        (priority (org-html--priority priority info))
        (tags (org-html--tags tags info)))
    (concat todo (and todo " ")
            priority (and priority " ")
            text
            (and tags " ") tags)))
(advice-add #'org-html-format-headline-default-function :override #'meq/org-html-format-headline-default-function)

":"; exec emacs --quick --script "$0" -- "$@" # -*- mode: emacs-lisp; lexical-binding: t; -*-
;;; bin/org-tangle

;; Tangles source blocks from org files. Also expands #+INCLUDE directives,
;; unlike vanilla `ob-tangle'. Debug/info messages are directed to stderr and
;; can be ignored.
;;
;;   -l/--lang LANG
;;     Only include blocks in the specified language (e.g. emacs-lisp).
;;   -a/--all
;;     Tangle all blocks by default (unless it has :tangle nil set or a
;;     :notangle: tag)
;;   -t/--tag TAG
;;      --and TAG
;;      --or TAG
;;     Only include blocks in trees that have these tags. Combine multiple --and
;;     and --or's, or just use --tag (implicit --and).
;;   -p/--print
;;     Prints tangled code to stdout instead of to files
;;
;; Usage: org-tangle [[-l|--lang] LANG] some-file.org another.org
;; Examples:
;;   org-tangle -l sh modules/some/module/README.org > install_module.sh
;;   org-tangle -l sh modules/lang/go/README.org | sh
;;   org-tangle --and tagA --and tagB my/literate/config.org

(require 'cl-lib)
(require 'ox)
(require 'ob-tangle)
(load-file (concat (file-name-directory (or load-file-name buffer-file-name)) "org-tangle-functions.el"))

(defun usage ()
  (with-temp-buffer
    (insert (format "%s %s [OPTIONS] [TARGETS...]\n"
                    "Usage:"
                    (file-name-nondirectory load-file-name))
            "\n"
            "A command line interface for tangling org-mode files. TARGETS can be\n"
            "files or folders (which are searched for org files recursively).\n"
            "\n"
            "This is useful for literate configs that rely on command line\n"
            "workflows to build it.\n"
            "\n"
            "Example:\n"
            "  org-tangle some-file.org\n"
            "  org-tangle literate/config/\n"
            "  org-tangle -p -l sh scripts.org > do_something.sh\n"
            "  org-tangle -p -l python -t tagA -t tagB file.org | python\n"
            "\n"
            "Options:\n"
            "  -a --all\t\tTangle all blocks by default\n"
            "  -l --lang LANG\tOnly tangle blocks written in LANG\n"
            "  -p --print\t\tPrint tangled output to stdout than to files\n"
            "  -t --tag TAG\n"
            "     --and TAG\n"
            "     --or TAG\n"
            "    Lets you tangle org blocks by tag. You may have more than one\n"
            "    of these options.\n")
    (princ (buffer-string))))

(defun *org-babel-tangle (fn &rest args)
  "Don't write tangled blocks to files, print them to stdout."
  (cl-letf (((symbol-function 'write-region)
             (lambda (start end filename &optional append visit lockname mustbenew)
               (princ (buffer-string)))))
    (apply fn args)))

(defun *org-babel-tangle-collect-blocks (&optional language tangle-file)
  "Like `org-babel-tangle-collect-blocks', but will ignore blocks that are in
trees with the :notangle: tag."
  (let ((counter 0) last-heading-pos blocks)
    (org-babel-map-src-blocks (buffer-file-name)
      (let ((current-heading-pos
             (org-with-wide-buffer
              (org-with-limited-levels (outline-previous-heading)))))
        (if (eq last-heading-pos current-heading-pos) (cl-incf counter)
          (setq counter 1)
          (setq last-heading-pos current-heading-pos)))
      (unless (org-in-commented-heading-p)
        (require 'org)
        (let* ((tags (org-get-tags-at))
               (info (org-babel-get-src-block-info 'light))
               (src-lang (nth 0 info))
               (src-tfile (cdr (assq :tangle (nth 2 info)))))
          (cond ((member "notangle" tags))

                ((and (or or-tags and-tags)
                      (or (not and-tags)
                          (let ((a (cl-intersection and-tags tags :test #'string=))
                                (b and-tags))
                            (not (or (cl-set-difference a b :test #'equal)
                                     (cl-set-difference b a :test #'equal)))))
                      (or (not or-tags)
                          (cl-intersection or-tags tags :test #'string=))
                      t))

                ((or (not (or all-blocks src-tfile))
                     (string= src-tfile "no")  ; tangle blocks by default
                     (and tangle-file (not (equal tangle-file src-tfile)))
                     (and language (not (string= language src-lang)))))

                ;; Add the spec for this block to blocks under its language.
                ((let ((by-lang (assoc src-lang blocks))
                       (block (org-babel-tangle-single-block counter)))
                   (if by-lang
                       (setcdr by-lang (cons block (cdr by-lang)))
                     (push (cons src-lang (list block)) blocks))))))))
    ;; Ensure blocks are in the correct order.
    (mapcar (lambda (b) (cons (car b) (nreverse (cdr b)))) blocks)))
;; (advice-add #'org-babel-tangle-collect-blocks
;;             :override #'*org-babel-tangle-collect-blocks)

(defvar all-blocks nil)
(defvar and-tags nil)
(defvar or-tags nil)
(defvar initial-args argv)
(defvar expanded-args (mapcar #'f-expand argv))
(defvar debug (or (member "-d" initial-args) (member "--debug" initial-args)))
(defvar force (or (member "-f" initial-args) (member "--force" initial-args)))
(defvar bundle-path nil)
(defvar use-nix-path nil)
(let (lang srcs and-tags or-tags)
  (pop argv)
  (while argv
    (let ((arg (pop argv)))
      (pcase arg
        ((or "-h" "--help")
         (usage)
         (error ""))
        ((or "-f" "--force")
         nil)
        ((or "-b" "--bundle-path")
         (setq bundle-path (pop argv)))
        ((or "-n" "--use-nix-path")
         (setq use-nix-path t))
        ((or "-d" "--debug")
         nil)
        ((or "-a" "--all")
         (setq all-blocks t))
        ((or "-l" "--lang")
         (setq lang (pop argv)))
        ((or "-p" "--print")
         (advice-add #'org-babel-tangle :around #'*org-babel-tangle))
        ((or "-t" "--tag" "--and")
         (push (pop argv) and-tags))
        ("--or"
         (push (pop argv) or-tags))
        ((guard (string-match-p "^--lang=" arg))
         (setq lang (cadr (split-string arg "=" t t))))
        ((guard (file-directory-p arg))
         (setq srcs
               (append (directory-files-recursively arg "\\.org$")
                       srcs)))
        ((guard (file-exists-p arg))
         (push arg srcs))
        (_ (if force
              (message "Skipping unknown option or file: %s" arg)
              (error "Unknown option or file: %s" arg))))))

  (dolist (file srcs)
    (let* ((file (f-expand (substitute-in-file-name file)))
           (backup (make-temp-file (file-name-base file) nil ".backup.org"))
           (post (eval `(lambda nil (ignore-errors (copy-file ,backup ,file t))
                                    (ignore-errors (delete-file ,backup))))))
      (add-hook 'kill-emacs-hook post)
      (message (format "\n\nNow tangling %s:\n" file))
      (unwind-protect
          ;; Prevent slow hooks from interfering
          (let (org-mode-hook org-confirm-babel-evaluate make-backup-files)
            ;; We do the ol' switcheroo because `org-babel-tangle' writes
            ;; changes to the current file, which would be imposing on the user.
            (copy-file file backup t)
            (with-current-buffer (find-file-noselect file)
              ;; Tangling doesn't expand #+INCLUDE directives, so we do it
              ;; ourselves, since includes are so useful for literate configs!
              (org-export-expand-include-keyword)
              (org-babel-tangle nil nil lang)))
        (funcall post))))

  (kill-emacs 0))

(setq org-functions-directory (file-name-directory (or load-file-name buffer-file-name))
      windows (member system-type '(windows-nt ms-dos)))
(defun meq/oefd (&rest args) (apply #'concat org-functions-directory (mapcar #'(lambda (arg) (concat (if windows "\\" "/") arg)) args)))
(mapc (lambda (file) (unless (require file nil t) (load-file (meq/oefd (symbol-name file) (concat (symbol-name file) ".el"))))) '(
    uuidgen
    a
    dash
    s
))

(mapc (lambda (file) (unless (require file nil t) (load-file (meq/oefd "f" (concat (symbol-name file) ".el"))))) '(
    f-shortdoc
    f
))

(defun meq/org-babel-expand-src-block (&optional light datum info params)
  "Expand the current source code block. Expand according to the source code block's header arguments."
  (let* ((info (or info (org-babel-get-src-block-info t datum)))
         (lang (nth 0 info))
         (params (setf (nth 2 info)
                    (sort (org-babel-merge-params (nth 2 info) params) (lambda (el1 el2) (string< (symbol-name (car el1)) (symbol-name (car el2)))))))
         (params (setf (nth 2 info)
                    (if light params (mapcar (lambda (param) (cons (car param) (org-babel-read (cdr param))))
                                        (-remove (lambda (param) (member (car param) '(:tangle))) params)))))
         (body (setf (nth 1 info) (if (org-babel-noweb-p params :eval) (org-babel-expand-noweb-references info) (nth 1 info))))
         (expand-cmd (intern (concat "org-babel-expand-body:" lang)))
         (assignments-cmd (intern (concat "org-babel-variable-assignments:" lang)))
         (expanded (if (fboundp expand-cmd)
                    (funcall expand-cmd body params)
                    (org-babel-expand-body:generic body params (and (fboundp assignments-cmd) (funcall assignments-cmd params)))))
         (expanded (if (a-has-key? params :shebang)
                    (concat (a-get params :shebang) "\n" expanded)
                    expanded)))
    expanded))

(defun meq/org-babel-expand (path &optional return-path light no-check body info parent-buffer datum params)
    (let* ((exists (and path (f-exists? path)))
            (body (if exists (s-trim (f-read path)) body))
            (args (list light datum info params))
            (path-or-body (if return-path path (apply #'meq/org-babel-expand-src-block args))))
        (if (and (not no-check) body)
            (if exists

                (if (string= body (if return-path (apply #'meq/org-babel-expand-src-block args) path-or-body))

                    (if return-path "no")
                    path-or-body)
                path-or-body)
            path-or-body)))

(defun meq/get-block (name &optional light parent-buffer datum params)
    (let* (path return-path no-check body)
        (meq/org-babel-expand path return-path light no-check body (org-babel-lob--src-info name) parent-buffer datum params)))

(defun meq/get-header nil (nth 4 (org-heading-components)))
(defun meq/get-theme-from-header nil (s-chop-suffix "-theme.el" (meq/get-header)))

(defun meq/tangle-multi-inner (light dont-check-car &rest paths)
    (let* ((paths (remove "no" paths)))
      (mapc (lambda (path) (let* ((path (f-expand (substitute-in-file-name path)))
                                  (parent (f-parent path))
                                  (body (meq/org-babel-expand path nil light)))
                              (when body
                                    (unless (f-exists? parent) (f-mkdir-full-path parent))
                                    (f-write (if (string-suffix-p "\n" body) body (concat body "\n")) 'utf-8 path)))) (cdr paths))
      (meq/org-babel-expand (f-expand (substitute-in-file-name (car paths))) t light dont-check-car)))

(defun meq/tangle-path (&optional light)
    (meq/org-babel-expand (s-chop-prefix "/" (f-join (org-format-outline-path (org-get-outline-path)) (meq/get-header))) t light))
(defun meq/tangle-multipath (&rest paths) (apply #'meq/tangle-multi-inner nil 'dont-check-car (add-to-list 'paths (meq/tangle-path))))
(defun meq/tangle-multipath-light (&rest paths) (apply #'meq/tangle-multi-inner 'light 'dont-check-car (add-to-list 'paths (meq/tangle-path t))))
(defun meq/tangle-multi (&rest paths) (apply #'meq/tangle-multi-inner nil nil paths))
(defun meq/tangle-multi-light (&rest paths) (apply #'meq/tangle-multi-inner 'light nil paths))

(defun link-or-file (lf return-link &optional substitute is-link) (interactive)
    (when (and lf (not (s-blank? lf)))

        ;; TODO: Is `return-link' is causing this to happen?
        ;;       Or maybe `is-link'?

        ;; ========================================
        ;; Current Setup File: ../bundle/README.org
        ;; ========================================

        (if (and (not is-link) (f-exists? (setq expanded-lf (f-expand (if substitute (substitute-in-file-name lf) lf)))))
            expanded-lf
            (if return-link
                lf
                (let* ((curl-README (shell-command-to-string (format "curl -fsSL %s 2> /dev/null" lf))))
                    (unless (s-blank? curl-README)
                        (let* ((temp (make-temp-file (uuidgen-5 (uuidgen-4) (uuidgen-4)))))
                            (f-write curl-README 'utf-8 temp)
                            temp)))))))
(defvar bundle-path nil)
(defvar use-nix-path nil)
(defvar nix-path nil)
(defun join-and-expand (&rest paths) (f-expand (apply #'f-join paths)))
(defun get-README (&optional return-link setupfile lobfile) (interactive)
    (let* ((README (f-join "bundle" "README.org"))
            ;; This gets the directory of the file being tangled or exported,
            ;; so that the `bundle-README' condition can check if it's a bundle README.
            (tangled-fd (f-expand (s-chop-prefix "/" (org-format-outline-path (org-get-outline-path)))))

            (userrepo (f-expand "/home/shadowrylander/aiern"))
            (user-README (join-and-expand userrepo README))
            (usernamerepo (f-expand "/home/shadowrylander/shadowrylander"))
            (username-README (join-and-expand usernamerepo README)))
        (or (link-or-file bundle-path return-link)
            (link-or-file (getenv "BUNDLE_README") return-link t)
            (link-or-file setupfile return-link)
            (link-or-file lobfile return-link)
            (let* ((bundle-README (join-and-expand tangled-fd "README.org")))
                (cond
                  ((f-exists? README) (concat "./" README))
                  ((and (f-exists? bundle-README) (equal (last (f-split bundle-README) 2) '("bundle" "README.org"))) bundle-README)
                  ((and (f-ancestor-of? userrepo tangled-fd) (f-exists? user-README)) user-README)
                  ((and (f-ancestor-of? usernamerepo tangled-fd) (f-exists? username-README)) username-README)))
            (when use-nix-path (link-or-file nix-path return-link))
            (let* ((flake-bundle (s-trim (shell-command-to-string "nix eval --impure --expr \"((builtins.getFlake or import) (toString ./.)).inputs.bundle.outPath\" | tr -d '\"' 2> /dev/null"))))
                (cond
                  (f-present? (unless (s-blank? flake-bundle) (join-and-expand flake-bundle "README.org")))
                  (f-present? (f-expand README))
                  (f-present? (join-and-expand "~" README))
                  (f-present? user-README)
                  (f-present? username-README)
                  (f-present? (join-and-expand "/" README))))
            (link-or-file nix-path return-link)
            (link-or-file "https://raw.githubusercontent.com/sylvorg/bundle/main/README.org" return-link t))))

(defvar current-lob-file nil)
(defvar current-setup-file nil)

(defun org-babel-pre-tangle-hooks (&optional html) (interactive)
    (setq org-elements (let* (

            (headlines (org-element-map
                        (org-element-parse-buffer 'headline)
                        'headline
                        (lambda (headline) (downcase (org-element-property :title headline)))))

            (keywords (org-element-map
                        (org-element-parse-buffer 'element)
                        'keyword
                        (lambda (keyword) (cons (downcase (org-element-property :key keyword)) (org-element-property :value keyword))))))

        (unless (or (a-has-key? keywords "nosetupfile") (a-has-key? keywords "nosetuplobfile") (member "no setupfile" headlines))
              (setq current-setup-file (get-README 'return-link (when (a-has-key? keywords "setuplobfile") (a-get keywords "setuplobfile"))))
              (when debug (let* ((m (format "Current Setup File: %s" current-setup-file))
                                  (l (length m))
                                  (b (make-string l ?=)))
                            (message "\n\n%s\n%s\n%s\n\n" b m b)))

              (when (member current-setup-file expanded-args) (global-auto-revert-mode 1))

              (goto-char 0)
              (insert (format "#+setupfile: %s\n\n" current-setup-file))
              (goto-char 0)
              (org-ctrl-c-ctrl-c))
        (a-list :keywords keywords :headlines headlines)))

    (require 'org-id)
    (setq org-id-locations-file (meq/oefd ".org-id-locations")
          org-id-files (list load-file-name
                             buffer-file-name
                             (meq/oefd "README.org"))
          org-id-link-to-org-use-id t)
    (org-id-update-id-locations)

    (setq org-src-preserve-indentation t)
    (let* ((headlines (a-get org-elements :headlines))
            (keywords (a-get org-elements :keywords)))
        (unless (or (a-has-key? keywords "nolobfile") (a-has-key? keywords "nosetuplobfile") (member "no lobfile" headlines))
          (let* ((file (get-README nil nil (cond ((a-has-key? keywords "setuplobfile") (a-get keywords "setuplobfile"))
                                            ((a-has-key? keywords "lobfile") (a-get keywords "lobfile"))))))
            (when file
              (setq current-lob-file file)
              (when debug (let* ((m (format "Current LOB File: %s" current-lob-file))
                                  (l (length m))
                                  (b (make-string l ?=)))
                            (message "\n\n%s\n%s\n%s\n\n" b m b)))

              (when (member current-lob-file expanded-args) (global-auto-revert-mode 1))

              (org-babel-lob-ingest current-lob-file))))))

(defun org-babel-post-tangle-hooks nil (interactive)

  (when (or (member current-setup-file expanded-args) (member current-lob-file expanded-args)) (global-auto-revert-mode -1))

)

(mapc (lambda (hook) (interactive) (add-hook hook 'org-babel-pre-tangle-hooks)) '(org-babel-pre-tangle-hook org-export-before-processing-hook))
(mapc (lambda (hook) (interactive) (add-hook hook 'org-babel-post-tangle-hooks)) '(org-babel-post-tangle-hook org-export-after-processing-hook))

(print "Hello, world!")

(import sys)
(.write sys.stdout "Hello, world!")

":"; exec emacs --quick --script "$0" -- "$@" # -*- mode: emacs-lisp; lexical-binding: t; -*-
(pop argv)

(require 'org-element)

(defun require-lang (lang)
    (defvar bootstrap-version)
    (let ((bootstrap-file
        (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory))
        (bootstrap-version 5))
    (unless (file-exists-p bootstrap-file)
        (with-current-buffer
            (url-retrieve-synchronously
            "https://raw.githubusercontent.com/raxod502/straight.el/develop/install.el"
            'silent 'inhibit-cookies)
        (goto-char (point-max))
        (eval-print-last-sexp)))
    (load bootstrap-file nil 'nomessage))
    (straight-use-package 'use-package)
    (setq straight-use-package-by-default t)
    (pcase (downcase lang)
        ((or "hy" "hylang") (use-package ob-hy :demand t :straight '(ob-hy :type git :host github :repo "allison-casey/ob-hy") :init (setq org-babel-hy-command "/usr/bin/env hy")))))

(defun message-advice (func &rest args) (interactive)
    (let* ((*message (apply #'format args)))
        (unless (or (string-prefix-p "executing" *message)
                    (string-prefix-p "Code block" *message))
            (apply func args))))
(advice-add #'message :around #'message-advice)

(defun org-babel-eval-error-notify-advice (exit-code stderr)
  "Open a buffer to display STDERR and a message with the value of EXIT-CODE."
  (let ((buf (get-buffer-create org-babel-error-buffer-name)))
    (with-current-buffer buf
      (goto-char (point-max))
      (save-excursion (insert stderr))
      (message (buffer-string)))
    (display-buffer buf))
  (message "Babel evaluation exited with code %S" exit-code))
(advice-add #'org-babel-eval-error-notify :override #'org-babel-eval-error-notify-advice)

(let ((org-confirm-babel-evaluate)
        (lang-list '()))
    (with-temp-buffer
        (while argv
            (let ((arg (pop argv)))
                (pcase arg
                    ((or "-l" "--languages")
                        (while (and (> (length argv) 1) (not (string-prefix-p "-" (car argv))))
                            (add-to-list 'lang-list (pop argv) t)))
                    (_ (setq file arg)))))
        (insert-file-contents file)
        (mapc 'require-lang lang-list)

        (org-babel-execute-buffer)))