Bash switch Java versions (my own little dumb jenv)

.zshrc

# Java List Utility - type jl or javalist at the command line to switch java versions
JAVALIST_FILE="/tmp/javalist.sh"
function loadjavalist {
  if [ -f "$JAVALIST_FILE" ]; then
    source ${JAVALIST_FILE}
    echo "Current Java set to ${JAVA_NAME}!"
  fi
}
function javalist {
  ~/OneDrive\ -\ Infomedia/tools/javalist.py "${JAVALIST_FILE}" "$(/usr/libexec/java_home -X)"
  loadjavalist
}
alias jl='javalist'

loadjavalist

javalist.py

#!/usr/bin/env python

from __future__ import print_function # Not needed in Python 3
import sys, tty, termios
import xml.etree.ElementTree as ET
import json
import os

class Menu:
    """Interactive select menu.
    Attributes:
        opts (list of str): Options for the user to choose from.
    """
    opts = []

    def __init__(self, java_version_names, java_versions, message=None):
        """Interactive select menu.
        Args:
            options (list of str): Options for the user to choose from.
            message (str, optional): Message to be displayed before showing options
        """
        self.opts = java_version_names
        self.java_versions = java_versions
        self.message = message

    def _getch(self):
        # Read single keypress from user
        fd = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd)
        try:
            tty.setcbreak(sys.stdin.fileno())
            ch = ""
            for _ in range(3): # Reading maximum 3 bytes
                ch += sys.stdin.read(1)
                if not ch.startswith('\x1b'):
                    # Exit if no escape sequence (used by arrow keys)
                    break
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        return ch

    def _get_input(self):
        # Convert keycode input into commands
        while(1):
            k = self._getch()
            if k!="":
                break
        keycodes = {'\x1b[A': "prev", '\x1b[B': "next", '\x1b[C': "next", '\x1b[D': "prev", "\n": "select"}
        if k in keycodes.keys():
            return keycodes[k]
        return None

    def __call__(self):
        """Creates an interactive select menu for the user. The user's choice is selected with up/down/left/right arrow keys and confirmed with the enter/return key.
        Returns:
            Option (from list) selected by user.
        """
        selected = 0
        while True:
            # Infinite loop broken by return
            # print("\r", end="")
            print("\033[2J\033[0;0H")
            if not self.message == None:
                print("\033[0;34m{}\033[0m".format(self.message))
            for ind, opt in enumerate(self.opts):
                if ind == selected:
                    print("\033[0;30;47m{}\033[0m".format(opt), end="\n")
                else:
                    print(opt, end="\n")

            print("\n")
            print(json.dumps(self.java_versions[self.opts[selected]], indent=2))

            sys.stdout.flush() # Forcing options to show (would be delayed until after keypress in Python 3)

            key_pressed = None
            while key_pressed == None:
                # Looping until valid key pressed
                key_pressed = self._get_input()
                if (key_pressed == "next") and selected < (len(self.opts) - 1):
                    selected += 1
                elif (key_pressed == "prev") and selected > 0:
                    selected -= 1
                elif key_pressed == "select":
                    print("")
                    return self.opts[selected]


def get_java_versions(version_xml):
    root = ET.fromstring(version_xml)
    java_versions = {

    }
    for jvm in root.findall("./array/dict"):
        data = jvm.iter()
        data.next()
        jvm_data = {}

        while True:
            try:
                key = data.next()
                value = data.next()
                # print(key.text, "=", value.text)

                if key.text == 'JVMName':
                    jvm_data["name"] = value.text
                if key.text == 'JVMHomePath':
                    jvm_data["home"] = value.text
                if key.text == 'JVMArch':
                    jvm_data["arch"] = value.text
                if key.text == 'JVMVersion':
                    jvm_data["version"] = value.text
                
            except:
                break
        
        # print(json.dumps(jvm_data))
        java_versions[jvm_data["name"]] = jvm_data

    java_versions["None"] = {}

    return java_versions


if len(sys.argv) < 3:
    print("Pass two parameters:\n (1) the path to write a shell script exporting JAVA_HOME e.g. \"/tmp/javalist.sh\"\n (2) the version XML output of \"$(/usr/libexec/java_home -X)\" as the parameter to the script.")
    sys.exit(-1)

temp_file_path=sys.argv[1]
java_versions_xml=sys.argv[2]

try:
    java_versions = get_java_versions(java_versions_xml)
    java_name = Menu(java_versions.keys(), java_versions, "Select a Java Version:")
    selected_java_name = java_name()
    if selected_java_name != 'None':
        f = open(temp_file_path, "w")
        try:
            selected_java = java_versions[selected_java_name]
            f.write("export JAVA_NAME=\"" + selected_java["name"] + "\"\n")
            f.write("export JAVA_HOME=\"" + selected_java["home"] + "\"\n")
            f.write("export PATH=\"$JAVA_HOME/bin:$PATH\"\n")
        finally:
            f.close()
    else:
        print("Exiting without changing Java")
except KeyboardInterrupt, ki:
    print("\nExiting without changing Java")
except Exception, e:
    print("Unexpected error: " + str(e))
    raise