A Python script to install a number of useful programs and packages on a fresh Linux-based device

Question

I work with Linux-based devices, and, both at work and in my personal life, it's necessary to wipe these devices every so often - sometimes as frequently as multiple times per week. In this context, it's obviously very useful to have some sort of script which reinstalls a suite of useful software.

For the past couple of years I've made do with a Shell script, but, since GitHib decided to encourage the use of access tokens ever more strongly, I switched to using Python. Setting up Git is one of the script's most crucial actions. Other responsibilities:

• Upgrading Python as required.
• Installing a number of useful packages via APT.
• Cloning and installing some of my own repositories.

I'm going to post the code for the script's core class below. If you want to run the script yourself, you can download the full repo - it's only a few files - here. But beware that it will start trying to install stuff!

The core class:

"""
This code defines a class which installs the various packages and repositories
required on this computer.
"""
# Standard imports.
import os
import pathlib
import shutil
import subprocess
import urllib.parse
# Local imports.
from git_credentials import set_up_git_credentials, \
 DEFAULT_PATH_TO_GIT_CREDENTIALS, DEFAULT_PATH_TO_PAT, \
 DEFAULT_USERNAME as DEFAULT_GIT_USERNAME, DEFAULT_EMAIL_ADDRESS
# Local constants.
DEFAULT_OS = "ubuntu"
DEFAULT_TARGET_DIR = str(pathlib.Path.home())
DEFAULT_PATH_TO_WALLPAPER_DIR = \
 os.path.join(DEFAULT_TARGET_DIR, "hmss/wallpaper/")
##############
# MAIN CLASS #
##############
class HMSoftwareInstaller:
 """ The class in question. """
 # Class constants.
 CHROME_DEB = "google-chrome-stable_current_amd64.deb"
 CHROME_STEM = "https://dl.google.com/linux/direct/"
 EXPECTED_PATH_TO_GOOGLE_CHROME_COMMAND = "/usr/bin/google-chrome"
 GIT_URL_STEM = "https://github.com/"
 MISSING_FROM_CHROME = ("eog", "nautilus")
 OTHER_THIRD_PARTY = ("gedit-plugins", "inkscape")
 SUPPORTED_OSS = set(("ubuntu", "chrome-os", "raspian", "linux-based"))
 WALLPAPER_STEM = "wallpaper_t"
 WALLPAPER_EXT = ".png"
 def __init__(
 self,
 this_os=DEFAULT_OS,
 target_dir=DEFAULT_TARGET_DIR,
 thunderbird_num=None,
 path_to_git_credentials=DEFAULT_PATH_TO_GIT_CREDENTIALS,
 path_to_pat=DEFAULT_PATH_TO_PAT,
 git_username=DEFAULT_GIT_USERNAME,
 email_address=DEFAULT_EMAIL_ADDRESS,
 path_to_wallpaper_dir=DEFAULT_PATH_TO_WALLPAPER_DIR
 ):
 self.this_os = this_os
 self.target_dir = target_dir
 self.thunderbird_num = thunderbird_num
 self.path_to_git_credentials = path_to_git_credentials
 self.path_to_pat = path_to_pat
 self.git_username = git_username
 self.email_address = email_address
 self.path_to_wallpaper_dir = path_to_wallpaper_dir
 self.failure_log = []
 def check_os(self):
 """ Test whether the OS we're using is supported. """
 if self.this_os in self.SUPPORTED_OSS:
 return True
 return False
 def move_to_target_dir(self):
 """ Change into the directory where we want to install stuff. """
 os.chdir(self.target_dir)
 def set_up_git(self):
 """ Install Git and set up a personal access token. """
 install_result = install_via_apt("git")
 if not install_result:
 return False
 pat_result = \
 set_up_git_credentials(
 username=self.git_username,
 email_address=self.email_address,
 path_to_git_credentials=self.path_to_git_credentials,
 path_to_pat=self.path_to_pat
 )
 if not pat_result:
 return False
 return True
 def install_google_chrome(self):
 """ Ronseal. """
 if (
 check_command_exists("google-chrome") or
 self.this_os == "chrome-os"
 ):
 return True
 chrome_url = urllib.parse.urljoin(self.CHROME_STEM, self.CHROME_DEB)
 chrome_deb_path = "./"+self.CHROME_DEB
 download_process = subprocess.run(["wget", chrome_url])
 if download_process.returncode != 0:
 return False
 if not install_via_apt(chrome_deb_path):
 return False
 os.remove(chrome_deb_path)
 return True
 def change_wallpaper(self):
 """ Change the wallpaper on the desktop of this computer. """
 if not os.path.exists(self.path_to_wallpaper_dir):
 return False
 if self.thunderbird_num:
 wallpaper_filename = (
 self.WALLPAPER_STEM+
 str(self.thunderbird_num)+
 self.WALLPAPER_EXT
 )
 else:
 wallpaper_filename = "default.jpg"
 wallpaper_path = \
 os.path.join(self.path_to_wallpaper_dir, wallpaper_filename)
 if self.this_os == "ubuntu":
 arguments = [
 "gsettings",
 "set",
 "org.gnome.desktop.background",
 "picture-uri",
 "file:///"+wallpaper_path
 ]
 elif self.this_os == "raspbian":
 arguments = ["pcmanfm", "--set-wallpaper", wallpaper_path]
 else:
 return False
 result = run_with_indulgence(arguments)
 return result
 def make_git_url(self, repo_name):
 """ Make the URL pointing to a given repo. """
 suffix = self.git_username+"/"+repo_name+".git"
 result = urllib.parse.urljoin(self.GIT_URL_STEM, suffix)
 return result
 def install_own_repo(
 self,
 repo_name,
 dependent_packages=None,
 installation_arguments=None
 ):
 """ Install a custom repo. """
 if os.path.exists(repo_name):
 print("Looks like "+repo_name+" already exists...")
 return True
 if dependent_packages:
 for package_name in dependent_packages:
 if not install_via_apt(package_name):
 return False
 arguments = ["git", "clone", self.make_git_url(repo_name)]
 if not run_with_indulgence(arguments):
 return False
 os.chdir(repo_name)
 if installation_arguments:
 if not run_with_indulgence(arguments):
 os.chdir(self.target_dir)
 return False
 os.chdir(self.target_dir)
 return True
 def install_kingdom_of_cyprus(self):
 """ Install the Kingdom of Cyprus repo. """
 repo_name = "kingdom-of-cyprus"
 dependent_packages = ("sqlite", "sqlitebrowser", "nodejs", "npm")
 result = \
 self.install_own_repo(
 repo_name,
 dependent_packages=dependent_packages
 )
 return result
 def install_chancery(self):
 """ Install the Chancery repos. """
 repo_name = "chancery"
 if not self.install_own_repo(repo_name):
 return False
 repo_name_b = "chancery-b"
 installation_arguments_b = ("sh", "install_3rd_party")
 result = \
 self.install_own_repo(
 repo_name_b,
 installation_arguments=installation_arguments_b
 )
 return result
 def install_hmss(self):
 """ Install the HMSS repo. """
 result = self.install_own_repo("hmss")
 return result
 def install_hgmj(self):
 """ Install the HGMJ repo. """
 repo_name = "hgmj"
 installation_arguments = ("sh", "install_3rd_party")
 result = \
 self.install_own_repo(
 repo_name,
 installation_arguments=installation_arguments
 )
 return result
 def install_other_third_party(self):
 """ Install some other useful packages. """
 result = True
 for package in self.OTHER_THIRD_PARTY:
 if not install_via_apt(package):
 result = False
 if self.this_os == "chrome-os":
 for package in self.MISSING_FROM_CHROME:
 if not install_via_apt(package):
 result = False
 return result
 def run_essentials(self):
 """ Run those processes which, if they fail, we will have to stop
 the entire program there. """
 print("Checking OS...")
 if not self.check_os():
 self.failure_log.append("Check OS")
 return False
 print("Updating and upgrading...")
 if not update_and_upgrade():
 self.failure_log.append("Update and upgrade")
 return False
 print("Upgrading Python...")
 if not upgrade_python():
 self.failure_log.append("Upgrade Python")
 return False
 print("Setting up Git...")
 if not self.set_up_git():
 self.failure_log.append("Set up Git")
 return False
 return True
 def run_non_essentials(self):
 """ Run the installation processes. """
 result = True
 print("Installing Google Chrome...")
 if not self.install_google_chrome():
 self.failure_log.append("Install Google Chrome")
 result = False
 print("Installing HMSS...")
 if not self.install_hmss():
 self.failure_log.append("Install HMSS")
 print("Installing Kingdom of Cyprus...")
 if not self.install_kingdom_of_cyprus():
 self.failure_log.append("Install Kingdom of Cyprus")
 result = False
 print("Installing Chancery repos...")
 if not self.install_chancery():
 self.failure_log.append("Install Chancery repos")
 result = False
 print("Installing HGMJ...")
 if not self.install_hgmj():
 self.failure_log.append("Install HGMJ")
 result = False
 print("Installing other third party...")
 if not self.install_other_third_party():
 self.failure_log.append("Install other third party")
 result = False
 print("Changing wallpaper...")
 if not self.change_wallpaper():
 self.failure_log.append("Change wallpaper")
 # It doesn't matter too much if this fails.
 return result
 def print_outcome(self, passed, with_flying_colours):
 """ Print a list of what failed to the screen. """
 if passed and with_flying_colours:
 print("Installation PASSED with flying colours!")
 return
 if passed:
 print("Installation PASSED but with non-essential failures.")
 else:
 print("Installation FAILED.")
 print("\nThe following items failed:\n")
 for item in self.failure_log:
 print(" * "+item)
 print(" ")
 def run(self):
 """ Run the software installer. """
 print("Running His Majesty's Software Installer...")
 get_sudo()
 self.move_to_target_dir()
 if not self.run_essentials():
 print("\nFinished.\n\n")
 self.print_outcome(False, False)
 return False
 with_flying_colours = self.run_non_essentials()
 print("\nComplete!\n")
 self.print_outcome(True, with_flying_colours)
 return True
####################
# HELPER FUNCTIONS #
####################
def get_sudo():
 """ Get superuser privileges. """
 print("I'm going to need superuser privileges for this...")
 subprocess.run(
 ["sudo", "echo", "Superuser privileges: activate!"],
 check=True
 )
def run_with_indulgence(arguments, show_output=False):
 """ Run a command, and don't panic immediately if we get a non-zero
 return code. """
 if show_output:
 print("Running subprocess.run() with arguments:")
 print(arguments)
 process = subprocess.run(arguments)
 else:
 process = subprocess.run(arguments, stdout=subprocess.DEVNULL)
 if process.returncode == 0:
 return True
 return False
def run_apt_with_argument(argument):
 """ Run APT with an argument, and tell me how it went. """
 arguments = ["sudo", "apt-get", argument]
 result = run_with_indulgence(arguments)
 return result
def check_against_dpkg(package_name):
 """ Check whether a given package is on the books with DPKG. """
 result = run_with_indulgence(["dpkg", "--status", package_name])
 return result
def check_command_exists(command):
 """ Check whether a given command exists on this computer. """
 if shutil.which(command):
 return True
 return False
def install_via_apt(package_name, command=None):
 """ Attempt to install a package, and tell me how it went. """
 if not command:
 command = package_name
 if check_command_exists(command):
 return True
 arguments = ["sudo", "apt-get", "--yes", "install", package_name]
 result = run_with_indulgence(arguments)
 return result
def update_and_upgrade():
 """ Update and upgrade the existing software. """
 if not run_apt_with_argument("update"):
 return False
 if not run_apt_with_argument("upgrade"):
 return False
 if not install_via_apt("software-properties-common"):
 return False
 return True
def pip3_install(package):
 """ Run `pip3 install [package]`. """
 if run_with_indulgence(["pip3", "install", package]):
 return True
 return False
def upgrade_python():
 """ Install PIP3 and other useful Python hangers-on. """
 result = True
 if not install_via_apt("python3-pip"):
 result = False
 if not pip3_install("pylint"):
 result = False
 if not pip3_install("pytest"):
 result = False
 return result

• Richard Neumann: Your code is not for Linux-based devices, it is for Debian-based devices. It is entirely useless on any Linux distribution, not using apt or the dpkg format.
• Reinderien: @RichardNeumann I mean... the OP's statement is true, it's just non-specific. Ubuntu is a Debian-based OS; Debian is a Linux-based OS. I see no problem here.

Answer 1

The nuclear option

it's necessary to wipe these devices every so often - sometimes as frequently as multiple times per week

Having a script like this is useful, because reproducible environments are useful; so long as you're not relying on it to cover over other problems. Your two scenarios:

At work: we were manufacturing embedded Linux devices, and we needed to be absolutely sure that each new software release would work install properly on untouched hardware.

That's a great application of a setup script like this.

At home: my laptop's a Chromebook with a Linux VM; every few months, I run into a problem in which it's quicker just to delete the VM and start again.

Fine-ish, so long as you understand what went wrong and were able to learn from it before nuking your OS.

Code

CHROME_DEB seems like a strange choice. You're on Ubuntu, so why not just install it from the repo?

You should be able to infer most of EXPECTED_PATH_TO_GOOGLE_CHROME_COMMAND from the result of a which.

set(("ubuntu", "chrome-os", "raspian", "linux-based")) should just be {"ubuntu", "chrome-os", "raspian", "linux-based"}.

The kind of rote repetition for member initialisation seen in your __init__ can be mostly eliminated by use of a @dataclass.

self.failure_log = [] implies that you're logging to memory. This is risky: if your process crashes, won't you lose your logs? Consider instead using the standard logging module and logging to a file.

This:

 if self.this_os in self.SUPPORTED_OSS:
 return True
 return False

should just be

return self.this_os in self.SUPPORTED_OSS

Avoid newline-escapes like in pat_result = \, which can just be

 pat_result = set_up_git_credentials(
 username=self.git_username,
 email_address=self.email_address,
 path_to_git_credentials=self.path_to_git_credentials,
 path_to_pat=self.path_to_pat
 )

This:

 if not pat_result:
 return False
 return True

can just be

return bool(pat_result)

This use of subprocess:

 download_process = subprocess.run(["wget", chrome_url])
 if download_process.returncode != 0:
 return False

should be replaced with subprocess.check_call. This will, rather than a boolean failure indicator, raise an exception - which you should also be doing. Use exceptions for failure states instead of boolean returns. Your "essential failures" should be represented by exceptions allowed to unwind the stack, and your "non-essential failures" should be logged in an except.

Replace calls to os.path.exists etc. with calls to the pathlib alternatives.

Your install_own_repo is curious. You accept a list of dependent packages required before installation of repo_name. This betrays a lack of proper packaging. Your own repos, when written properly, should build debs that express their own dependencies, so that you can just install the top-level package and the dependencies will be pulled in automatically. The alternative to making your own debs is to express dependencies in a distutils setup.py, which is preferable if all of the dependencies are pure Python.

• Reinderien: Let us continue this discussion in chat.

Answer 2

Don't repeat yourself

 def run_non_essentials(self):
 """ Run the installation processes. """
 result = True
 print("Installing Google Chrome...")
 if not self.install_google_chrome():
 self.failure_log.append("Install Google Chrome")
 result = False
 print("Installing HMSS...")
 if not self.install_hmss():
 self.failure_log.append("Install HMSS")
 print("Installing Kingdom of Cyprus...")
 if not self.install_kingdom_of_cyprus():
 self.failure_log.append("Install Kingdom of Cyprus")
 result = False
 print("Installing Chancery repos...")
 if not self.install_chancery():
 self.failure_log.append("Install Chancery repos")
 result = False
 print("Installing HGMJ...")
 if not self.install_hgmj():
 self.failure_log.append("Install HGMJ")
 result = False
 print("Installing other third party...")
 if not self.install_other_third_party():
 self.failure_log.append("Install other third party")
 result = False
 print("Changing wallpaper...")
 if not self.change_wallpaper():
 self.failure_log.append("Change wallpaper")
 # It doesn't matter too much if this fails.
 return result

Can be generalized into:

OPTIONAL_PROGRAMS = {
 "Google Chrome": install_google_chrome,
 "HMSS": install_hmss,
 "Kingdom of Cyprus": install_kingdom_of_cyprus,
 ...
}
[...]
class HMSoftwareInstaller:
 [...]
 
 def install(name: str, function: Callable[[], bool]) -> bool:
 print(f"Installing {name}...")
 
 if not (result := function()):
 self.failure_log.append(f"Install {name}")
 
 return result
 def run_non_essentials(self) -> bool:
 """ Run the installation processes. """
 
 return all([self.install(*program) for program in OPTIONAL_PROGRAMS.items()])

The same applies to run_essentials().

The functions invoked do not use self anyway, so they should be redefined as free functions.

Consider using pathlib.Path

...to manage paths, rather than the os.* functions.

Use built-ins where possible

The function upgrade_python() does unnecessarily store state. You can rewrite it as:

def upgrade_python():
 """ Install PIP3 and other useful Python hangers-on. """
 return all([
 install_via_apt("python3-pip"),
 pip3_install("pylint"),
 pip3_install("pytest")
 ])