archlinux/archinstall

Arch Linux installer - guided, templates etc.

Arch Installer

Just another guided/automated Arch Linux installer with a twist. The installer also doubles as a python library to install Arch Linux and manage services, packages, and other things inside the installed system (Usually from a live medium).

• archinstall discord server
• archinstall matrix.org channel
• archinstall #[email protected]
• archinstall documentation

Installation & Usage

sudo pacman -S archinstall

Alternative ways to install are git clone the repository or pip install --upgrade archinstall.

Running the guided installer

Assuming you are on an Arch Linux live-ISO or installed via pip:

archinstall

Running the guided installer using git

    # cd archinstall-git
    # python -m archinstall

Advanced

Some additional options that most users do not need are hidden behind the --advanced flag.

Running from a declarative configuration file or URL

archinstall can be run with a JSON configuration file. There are 2 different configuration files to consider, the user_configuration.json contains all general installation configuration, whereas the user_credentials.json contains the sensitive user configuration such as user password, root password, and encryption password.

An example of the user configuration file can be found here configuration file and an example of the credentials configuration here credentials file.

HINT: The configuration files can be auto-generated by starting archinstall, configuring all desired menu points and then going to Save configuration.

To load the configuration file into archinstall run the following command

archinstall --config <path to user config file or URL> --creds <path to user credentials config file or URL>

Help or Issues

If you come across any issues, kindly submit your issue here on Github or post your query in the discord help channel.

When submitting an issue, please:

• Provide the stacktrace of the output if applicable
• Attach the /var/log/archinstall/install.log to the issue ticket. This helps us help you!
  • To extract the log from the ISO image, one way is to use
    

    curl -F'file=@/var/log/archinstall/install.log' https://0x0.st

Available Languages

Archinstall is available in different languages which have been contributed and are maintained by the community. The language can be switched inside the installer (first menu entry). Bear in mind that not all languages provide full translations as we rely on contributors to do the translations. Each language has an indicator that shows how much has been translated.

Any contributions to the translations are more than welcome, to get started please follow the guide

Fonts

The ISO does not ship with all fonts needed for different languages. Fonts that use a different character set than Latin will not be displayed correctly. If those languages want to be selected then a proper font has to be set manually in the console.

All available console fonts can be found in /usr/share/kbd/consolefonts and set with setfont LatGrkCyr-8x16.

Scripting your own installation

Scripting interactive installation

There are some examples in the examples/ directory that should serve as a starting point.

The following is a small example of how to script your own interactive installation:

from pathlib import Path

from archinstall import Installer, ProfileConfiguration, profile_handler, User
from archinstall.default_profiles.minimal import MinimalProfile
from archinstall.lib.disk.device_model import FilesystemType
from archinstall.lib.disk.encryption_menu import DiskEncryptionMenu
from archinstall.lib.disk.filesystem import FilesystemHandler
from archinstall.lib.interactions.disk_conf import select_disk_config

fs_type = FilesystemType('ext4')

# Select a device to use for the installation
disk_config = select_disk_config()

# Optional: ask for disk encryption configuration
data_store = {}
disk_encryption = DiskEncryptionMenu(disk_config.device_modifications, data_store).run()

# initiate file handler with the disk config and the optional disk encryption config
fs_handler = FilesystemHandler(disk_config, disk_encryption)

# perform all file operations
# WARNING: this will potentially format the filesystem and delete all data
fs_handler.perform_filesystem_operations()

mountpoint = Path('/tmp')

with Installer(
        mountpoint,
        disk_config,
        disk_encryption=disk_encryption,
        kernels=['linux']
) as installation:
    installation.mount_ordered_layout()
    installation.minimal_installation(hostname='minimal-arch')
    installation.add_additional_packages(['nano', 'wget', 'git'])

    # Optionally, install a profile of choice.
    # In this case, we install a minimal profile that is empty
    profile_config = ProfileConfiguration(MinimalProfile())
    profile_handler.install_profile_config(installation, profile_config)

    user = User('archinstall', 'password', True)
    installation.create_users(user)

This installer will perform the following actions:

• Prompt the user to configure the disk partitioning
• Prompt the user to setup disk encryption
• Create a file handler instance for the configured disk and the optional disk encryption
• Perform the disk operations (WARNING: this will potentially format the disks and erase all data)
• Install a basic instance of Arch Linux (base base-devel linux linux-firmware btrfs-progs efibootmgr)
• Install and configures a bootloader to partition 0 on UEFI. On BIOS, it sets the root to partition 0.
• Install additional packages (nano, wget, git)
• Create a new user

To create your own ISO with this script in it: Follow ArchISO's guide on creating your own ISO.

Script non-interactive automated installation

For an example of a fully scripted, automated installation please refer to the example full_automated_installation.py

Unattended installation based on MAC address

Archinstall comes with an unattended example which will look for a matching profile for the machine it is being run on, based on any local MAC address. For instance, if the machine the code is executed on has the MAC address 52:54:00:12:34:56 it will look for a profile called 52-54-00-12-34-56.py. If it's found, the unattended installation will begin and source that profile as its installation procedure.

Profiles

archinstall comes with a set of pre-configured profiles available for selection during the installation process.

• Desktop
• Server

The profiles' definitions and the packages they will install can be directly viewed in the menu, or default profiles

Testing

Using a Live ISO Image

If you want to test a commit, branch, or bleeding edge release from the repository using the standard Arch Linux Live ISO image, replace the archinstall version with a newer one and execute the subsequent steps defined below.

*Note: When booting from a live USB, the space on the ramdisk is limited and may not be sufficient to allow running a re-installation or upgrade of the installer. In case one runs into this issue, any of the following can be used

• Resize the root partition https://wiki.archlinux.org/title/Archiso#Adjusting_the_size_of_the_root_file_system
• The boot parameter copytoram=y (https://gitlab.archlinux.org/archlinux/mkinitcpio/mkinitcpio-archiso/-/blob/master/docs/README.bootparams#L26) can be specified which will copy the root filesystem to tmpfs.*

1. You need a working network connection
2. Install the build requirements with pacman -Sy; pacman -S git python-pip gcc pkgconf (note that this may or may not work depending on your RAM and current state of the squashfs maximum filesystem free space)
3. Uninstall the previous version of archinstall with pip uninstall --break-system-packages archinstall
4. Now clone the latest repository with git clone https://github.com/archlinux/archinstall
5. Enter the repository with cd archinstall At this stage, you can choose to check out a feature branch for instance with git checkout v2.3.1-rc1
6. To run the source code, there are 2 different options:
   • Run a specific branch version from source directly using python -m archinstall, in most cases this will work just fine, the rare case it will not work is if the source has introduced any new dependencies that are not installed yet
   • Installing the branch version with pip install --break-system-packages . and archinstall

Without a Live ISO Image

To test this without a live ISO, the simplest approach is to use a local image and create a loop device.
This can be done by installing pacman -S arch-install-scripts util-linux locally and doing the following:

# truncate -s 20G testimage.img
# losetup --partscan --show --find ./testimage.img
# pip install --upgrade archinstall
# python -m archinstall --script guided
# qemu-system-x86_64 -enable-kvm -machine q35,accel=kvm -device intel-iommu -cpu host -m 4096 -boot order=d -drive file=./testimage.img,format=raw -drive if=pflash,format=raw,readonly,file=/usr/share/ovmf/x64/OVMF_CODE.fd -drive if=pflash,format=raw,readonly,file=/usr/share/ovmf/x64/OVMF_VARS.fd

This will create a 20 GB testimage.img and create a loop device which we can use to format and install to.
archinstall is installed and executed in guided mode. Once the installation is complete, you can use qemu/kvm to boot the test media.
(You'd actually need to do some EFI magic in order to point the EFI vars to the partition 0 in the test medium, so this won't work entirely out of the box, but that gives you a general idea of what we're going for here)

There's also a Building and Testing guide.
It will go through everything from packaging, building and running (with qemu) the installer against a dev branch.

FAQ

How to dual boot with Windows

To install Arch Linux alongside an existing Windows installation using archinstall, follow these steps:

1. Ensure some unallocated space is available for the Linux installation after the Windows installation.
2. Boot into the ISO and run archinstall.
3. Choose Disk configuration -> Manual partitioning.
4. Select the disk on which Windows resides.
5. Select Create a new partition.
6. Choose a filesystem type.
7. Determine the start and end sectors for the new partition location (values can be suffixed with various units).
8. Assign the mountpoint / to the new partition.
9. Assign the Boot/ESP partition the mountpoint /boot from the partitioning menu.
10. Confirm your settings and exit to the main menu by choosing Confirm and exit.
11. Modify any additional settings for your installation as necessary.
12. Start the installation upon completion of setup.

Mission Statement

Archinstall promises to ship a guided installer that follows the Arch Linux Principles as well as a library to manage services, packages, and other Arch Linux aspects.

The guided installer ensures a user-friendly experience, offering optional selections throughout the process. Emphasizing its flexible nature, these options are never obligatory. In addition, the decision to use the guided installer remains entirely with the user, reflecting the Linux philosophy of providing full freedom and flexibility.

---

Archinstall primarily functions as a flexible library for managing services, packages, and other elements within an Arch Linux system. This core library is the backbone for the guided installer that Archinstall provides. It is also designed to be used by those who wish to script their own custom installations.

Therefore, Archinstall will try its best to not introduce any breaking changes except for major releases which may break backward compatibility after notifying about such changes.

Contributing

Please see CONTRIBUTING.md

archinstall's Issues

change the descriptoin of profiles

all most all of the profiles use A desktop environemtn using "Awesome" window manager. even though the should be separate descriptions pertaining to the specific environment.

Add support for wifi in the network configuration

Based off #65, it would be nice with a wifi option.
Since laptop users and other devices more or less defaults to using wifi rather than ethernet, this would be a welcome addition I think.

Ignore errors

Some template steps might deliberately cause a error.
Forcing he installer to crash. Having a "ignore-errors" : True makes sense.

Awesome menu not configured

Need to configure the awesome-menu in the workstation template.

Show file format when showing disks/partitions.

When showing "Select one of the above disks (by number):", in the list above, show the file format on those disks. And a human readable filesize perhaps. Would make it a lot easier to understand which disk is which (even tho you can ctrl+alt+f2 to run fdisk -l yourself).

Guess locale based off IP if present

If a gateway is detected, use a geoip library to determain to the best of our ability where the user is coming from. This in order to determain the keyboard layout and suggest mirrors etc.

archlinux.life is down

https://downforeveryoneorjustme.com/archlinux.life?proto=https

Can't reach archlinux.life.

Add --silent

Add a silent parameter, making the script as less noisy as possible on the network.
The name of the parameter might be discussable, but should be added at least.

When running in --offline mode, turn every online feature off.
When in --online mode so to speak, mute only automated features like country guessing and stuff. But leave the online-template fetching active.

Remove AUR support from guided installer

Since AUR isn't officially supported, we need to remove it before it can be offered to a wider public.

Profiles are not working with "No such file or directory"

Imported profiles doesn't work with URL's.
Root cause is Profile.load_instructions() which gives the URL as a file name.

The reason for this bug is when run in module-mode, the working path is wonky (will look at it) and there for it resorts back to HTTP-lookup.

Legacy support: MBR with Grub

Currently, one of the bigger limitations are that the installer/guided templates only support UEFI with Systemd-boot as the default bootloader.

We'll need to add archinstall.MBR as an alternative to:

with archinstall.Filesystem(harddrive, archinstall.GPT) as fs:
    ...

And installation.add_bootloader() should probably take a parameter for which bootloader to install. Currently it doesn't take any arguments, so adding one won't brake anything. Suggestion: installation.add_bootloader("grub")

Create PGP signed releases

Hi,

I'm creating a package of this on Arch and I would like to ask for PGP signed releases to be created. If possible, also add the keys to the release artifacts. Also, it would be a bonus if all commits and tags were signed. I've noticed a few of the previous tags were signed, but not the most recent ones.

Another thing that would be nice to have, is if we could build a chain of trust for all the keys that could make releasesl, not sure if one already exists.

Thanks

Change --default to --unattended

Makes more sense, it's a evolutionary naming decision which is BS for "I didn't know what to call it" at the beginning.

Rename make_offline -> aur

As of now, the intention of make_offline took a slightly different turn.
It's need came up when we tried to incorporate AUR packages into a ISO/Offline environment.

However, it does the job of building AUR packages and putting them into the ISO pretty neatly.
What it doesn't do, is make a offline-installable version of Arch Linux from the ISO (much like the other Linux distro's got, a CD jamed with all the packages).

So rename this script to ./AUR, and create a new ./make_offline that actually creates a local-hosted mirror on the ISO, that the ISO can use to install itself from. Including others who point their mirror to the ISO. (this is tested and works, that commit is here https://raw.githubusercontent.com/Torxed/Scripts/a7119ecb29b6e9b65936875a051b35d46de57c7f/systemd/offline_arch_mirror/make_mirror)

AUR builder doesn't revert /etc/sudoers

When prompted (using the guided.py examples) for AUR support.
The AUR support needs to temporarily grant itself password-less sudo permissions. This because we don't want to accidentally set a root password and something goes wrong. And cleaning up a text file should be easier.

But in all haste of 2.0, the AUR process was simply lifted from the v1.0 branch, which may have the same issue.

Add `lib/hardware.py` for detecting different hardware setups

Add hardware helpers, preferably in lib/hardware.py to detect certain hardware features.
Such as ssd/nvme detection, which should be the basis for opting in for btrfs for instance, and default to ext4 or something similar if anything else (as a very generalized example).

Thanks to @grazzolni for this idea.

Issue installing package groups (kde-applications for instance)

As mentioned in #61, support for package groups doesn't work.
The idea here is that it should be supported, we simply never verified that the archinstall.find_package() function can verify those, and apparently it can't. So we have to use another API endpoint or multiple to support this.

The backplane supports it already, as the packages are sent as a unfiltered string to pacman -S more or less.

Unecessary splitting and rejoining of sys_command output

I'm seeing a lot of splitting the output of sys_command using it's iterable, only to immediately rejoin it via b''.join(sys_command(...)). Is there a reason you've used this pattern so widely, since it seems to serve no purpose.

Add a delay between settings and wiping

Just add a little 5-10 sec timer between the settings being shown and the wiping+deploy actually starts.

STDIN parsing for any argument. Not just password.

Instead of STDIN being available only for the password prompt, make it so it parses through any argument to fill it in.

ála traditional guided installations I presume.

Issues installing no profile during guided installation.

Latest master branch have an issues in guided.py#59 that incorrectly assumes 'profile' exists when in fact no profile was selected.

This is partially a dummy issue to test signed PGP releases. #74

Support an already installed system

Assuming the following, that someone runs the scripts/library on a docker installation or re-running it after already performing an installation. It would be nice if the installer could run again and run different profiles scenarios. But that requires the mount points to be pointed towards the correct place.

Which, perhaps the archinstall.Installer() should take care of.

Make lukscrypt optionally disable-able

Fuzzy title..
Make it so LUKS is default on, but add an option some where to turn it off.
There are rare edge cases where disk encryption won't work for unattended stuff and we can accept the risk of not having disk encryption. But default should be to always have it enabled!

Encryption issues with NVME (to quick to encrypt)

Some NVME drives are to quick to respond to parted and mkfs, which makes them unavailable when cryptsetup execution attempts to encrypt the drive. The underlying issue is that the disk haven't entered "ready state" in kernel in between sys calls.

A simple time.sleep(5) at luks() proved to solve the issue. A better approach would be to assert and evaluate the state of the drive and release a lock whenever the devices becomes ready.

Temporary solution: Re-run the installation as it's more of a race condition or skip encryption and manually encrypt.

Correction: This has to do with the formatting, not encryption. The disk formatting is to quick on some drives. Fix is on it's way although this happens rarely on most systems.

Make it easier to gather log data

Currently, all the log data is stored in ~/.cache/archinstall/workers/<id>.
That's a little bit to technical for each and everyone most likely, especially considering the targeted users.

This goes hand in hand with #45 (Create a installer.help extension).
But this issue revolves around how to gather the logs for sending.

It's also not very well documented, both in terms of how to find the logs, but also how to submit them or even what to submit. So that needs a big overhaul.

Update KDE profile to use a display manager rather than xorg-xinit

As pointed out over at reddit, the preferred method of launching KDE appears to be not via xorg-xinit, but a displaymanager (much like Gnome which is launched via gdm).

The thing we need to change is profiles/applications/kde.py among other things. And investigate the most supported method in the KDE community.

SDDM appears to be the recommended for Plasma.

Confirm disk choice when multiple disks are found...

Novice "Desktop" profile/template

A novice mode/template.

Quote

aur helper, a gui, essential fonts, internet stuff, etc

Add optional support for network configuration (and/or network managers)

A quote from #61:

A simple option to configure networking would also be useful, e.g., enabling DHCP via systemd-networkd.

We should support at least two network managers in this case, systemd-networkd for sure but perhaps also NetworkManager. Both as optional additions. Either way, supporting configuring network (at a very basic level) would be invaluable for almost any installation.

inherited templates should not replace keys

If two templates have the same "step name" or key, the inherited template should not replace the step of the current template.

"ubuntu" inherits "workstation"
"ubuntu" should replace whatever "desktop"-environment step "workstation" has for isntance. And not the other way around(?).

Incorrect filesystem indicator in Partition() when creating ext4 partitions

According to a harmless and rather fun joke on reddit mentioned by u/parkerlreed:

So FATT32 is the new hotness for rootfs? :D

Adding partition to BlockDevice(/dev/sda)
Adding partition to BlockDevice(/dev/sda)
Formatting Partition(path=/dev/sda1, fs=None, mounted=None) -> fat32
Formatting Partition(path=/dev/sda2, fs=None, mounted=None) -> ext4
Mounting Partition(path=/dev/sda2, fs=fat32, mounted=None) to /mnt
Mounting Partition(path=/dev/sda1, fs=fat32, mounted=None) to /mnt/boot
A new package mirror-list has been created: /etc/pacman.d/mirrorlist
Installing packages: ['base', 'base-devel', 'linux', 'linux-firmware', 'efibootmgr', 'nano']

It actually mounted EXT4 just found that funny

/dev/sda2 on /mnt type ext4 (rw,relatime,stripe=8191)

At first glance /dev/sda2 which should be ext4 in a unencrypted configuration, should actually have the status fs=ext4.
The issue is disk.py #L133-L136 which sets:

elif filesystem == 'ext4':
	if (handle := sys_command(f'/usr/bin/mkfs.ext4 -F {self.path}')).exit_code != 0:
		raise DiskError(f'Could not format {self.path} with {filesystem} because: {b"".join(handle)}')
	self.filesystem = 'fat32'     <-----------

And if we check the partition.filesystem at any given point after this, it will give wrong indications.
It does get mounted correctly, it's just the soft login ontop that will break after this point if ever used.

Crashes upon trying to skip picking an environment after desktop

When prompted by the installer script to select a pre-programmed profile, selecting option 1 (desktop) and then trying to skip by pressing enter crashes the installer.

`guided` should show a brief overview of the config before formatting

Bring back the configuration summary shown just prior to starting the formatting.
It was removed during the great .json purge, previously print(conf) was shown containing the selected config.

archinstall.Installer.show_configuration() perhaps?

change --no-default as the default option, and add --default in case you want default.

see title (I'm one of those people)

Changing sys_command to take named keyword arguments.

Just getting back into this project, have been busy wrapping up some things for work.

One of the things I noticed the last time I was diving into this project, is that the sys_command class has a huge implict set of dependencies on things passed in via kwargs. Is there a reason for this?

It seems like it only ever looks at a few keys within kwargs

• debug
• emulate
• events
• ignore_errors
• on_output
• suppress_errors
• worker
• worker_id

Having those be explict arguments should make things easier to document. I also worry a bit about kwargs being passed through. For example right now the all_disks function passes through kwargs, but it's not clear that the kwargs for all_disks should be passed to sys_command, and most likely the extra partitions key should not be passed along.

if you're amenable to this I can fix this and send over a PR.

Create man pages

Now that archinstall is packaged on the official repos, it would be nice to have man pages for it as well. I think that, with some adaptation, they could be created from the docutils documentation.

Multi boot support

Would you be interested/open to contributions that allow for installations that need to co-exist with other installations of operating systems?

Guided installation fails during package installation

Hi,

I was testing the guided installer in a virtual machine, but it seems that the installation fails during package installation. I used pip install archinstall==2.0.6rc11 and python -m archinstall guided on the current Arch Linux installation image.

Installing packages: ['vim', 'gdb', 'radare2', 'pwndbg', 'tmux']
Error in profile guided: 'list' object has no attribute 'items'
Traceback (most recent call last):
  File "/usr/lib/python3.8/site-packages/archinstall/__main__.py", line 65, in run_as_a_module
    exec(profile)  # Is this is very safe?
  File "<string>", line 240, in <module>
  File "/usr/lib/python3.8/site-packages/archinstall/lib/disk.py", line 192, in __exit__
    raise args[1]
  File "<string>", line 240, in <module>
  File "<string>", line 66, in perform_installation
  File "/usr/lib/python3.8/site-packages/archinstall/lib/installer.py", line 78, in __exit__
    raise args[1]
  File "<string>", line 58, in perform_installation
AttributeError: 'list' object has no attribute 'items'
python -m archinstall guided  41.04s user 18.26s system 25% cpu 3:51.50 total

Full output here.

Edit: When do not select any additional packages, I get the following error:

Error in profile guided: 'packages'
Traceback (most recent call last):
  File "/usr/lib/python3.8/site-packages/archinstall/__main__.py", line 65, in run_as_a_module
    exec(profile)  # Is this is very safe?
  File "<string>", line 240, in <module>
  File "/usr/lib/python3.8/site-packages/archinstall/lib/disk.py", line 192, in __exit__
    raise args[1]
  File "<string>", line 240, in <module>
  File "<string>", line 66, in perform_installation
  File "/usr/lib/python3.8/site-packages/archinstall/lib/installer.py", line 78, in __exit__
    raise args[1]
  File "<string>", line 52, in perform_installation
KeyError: 'packages'

Add --profile parameter

Create a `installer.help` extension

Something along the lines of archinstall.Installer.help() which would print all the debug statistics needed.
And potentially a very optional archinstall.Installer.submit_debug(), but not until thoroughly thought out with better masking of passwords and stuff. The default archinstall.log function should probably have a filter=True for credential sensitive log data.

Instruction to change git-branch

Would be neat, if the instruction set could influence which git branch to run from.
If the instruction arguments have "git" : "experimental" it would save me a bunch of time having to re-create ISO's and/or abort the installation quickly to re-run with the correct branch.

Ability to get instructions from local git structure.

So far, the instruction set has only come from the online github repo.
Adding support for the local files would greatly help.

Add option to support time zones

As mentioned in #61:

An option to select the timezone / enable NTP would be nice.

The feature is pretty straight forward and not a bad idea.
It's mainly been put on hold because it's an easy thing to configure while inside the machine, but it makes sense to put it in now.

• Guess time-zone in examples/guided.py based on the locale selected would be nice, but not a requirement
• Listing time-zones would be nice and almost a requirement.

Improve selecting from large lists

The search feature by entering ?<enter> is a bit unclear.
And the scrollback history via Shift+PageUp is not always available (in most tty's).

It would there for be nice to break up larger lists into columns over the width of the terminal, as well as make the input text more descriptive.

Create `archinstall.packages` for helping to find/search for packages.

During installation, if a wrongly inputted package name is given.
It will take time for any error messages to pop up, and the installation will even continue up to the stage of strapping in additional packages.

It might be worth creating a package helper (crude, simple, nothing fancy) to search for package names and verify that they do exist in the upstream package database - prior to continuing the installation.

reflector give incorrect mirrors? causing corrupt packages?

During installation, the guided template lack the option to select local mirrors.
rankmirrors doesn't do a good enough job of selecting a appropriate mirror, causing:

Selecting profiles require a least one profile to be given as an option

I got this error after following the install instructions from the readme:

pip install archinstall
python -m archinstall guided

I also accidentally booted into BIOS mode, but retrying in EFI gives me the same error.

Multiple triggers via templates (merge templates into static triggers)

Currectly, there's only one trigger supported. And that's per-command-trigger set up by archinstall.py when it detects a chroot request.

However, it would be neat if the trigger-list became a normal list, and triggers from the template got merged into said list so that the template creator can choose multiple steps if need be.

Example: Say a command requires two inputs, "name" and "password". Currently, there's no way of supplying multiple triggers. Fix!

arch-chroot breaks name resolves for normal users (but not for root)

There's a issue over at Unix Stackexchange on the topic.

Essentially it boils down to when /run is mounted into the chroot, and you chroot /mnt /bin/bash. Something with /run breaks name resolves if you're not root.

Partitions should have more flexible file system options

Currently, encrypted drives default to using btrfs inside.
Un-encrypted drives default to ext4.

There's no real reason why these has to be forced upon the users.
But for development purposes (and test support of different FS's), this was chosen as a starting point.

Anyone can use the library to format whatever they want, but this is the default of minimal_installation() and the guided.py template currently. All we have to do is expand on guided.py and add another question, and test the support in the lib to support other formats.

The current design goal is to support:

• Format the entire drive
• Format entire drive but keep "unsupported" partitions (windows, mac etc)
• Use the current setup as-is
  • Autodetects pre-mounted partitions and uses them, or
  • Asks which partition to mount where