Replace WMIC sections

Addresses issue #227

.gitignore

@@ -1,5 +1,6 @@
 **/__pycache__
 **/*.7z
+**/*.DS_Store
 **/*.bak
 **/*.exe
 **/*.swp

.pre-commit-config.yaml

@@ -0,0 +1,6 @@
+repos:
+- repo: https://github.com/charliermarsh/ruff-pre-commit
+  # Ruff version.
+  rev: 'v0.0.257'
+  hooks:
+    - id: ruff

LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2020 Alan Mason
+Copyright (c) 2023 Alan Mason
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

README.md

@@ -1,135 +1,39 @@
-# Wizard Kit #
+# WizardKit #
-
+
-A collection of scripts to help technicians service Windows systems.
+A collection of tools to help technicians service computers.
-
+
-## Main Kit ##
+## Overview ##
-
+
-### Build Requirements ###
+There are a few main parts to this project and their uses:
-
+
-* PowerShell 3.0 or newer<sup>1</sup>
+* Live Linux image
-* 10 Gb disk space
+  * Hardware diagnostics
-
+    * CPU stress tests with temperature monitoring
-### Initial Setup ###
+    * Health checks/tests for storage drives
-
+    * Misc other diagnostics
-* Replace artwork as desired
+  * Data recovery
-* Run `Build Kit.cmd` which will do the following:
+    * General data transfers from many possible filesystems
-  * Download 7-Zip, ConEmu, Notepad++, and Python (including wheel packages)
+    * Bit-level drive duplication based on ddrescue
-  * Open `main.py` in Notepad++ for configuration
+* Live macOS image
-  * Update the rest of the tools with the `.bin\Scripts\update_kit.py` script
+  * Hardware diagnostics
-
+    * CPU stress tests with temperature monitoring
-### Layout ###
+    * Health checks/tests for storage drives
-
+  * Data recovery
-* Root
+    * _(Currently under development)_
-  * Main script launchers:
+* Live WinPE image
-* `.bin`
+  * _(Currently under development)_
-  * Extracted programs: As compressed tools are run they will be extracted here.
+* Windows Kit _(intended for UFDs)_
-  * `Scripts`
+  * Automated repairs
-    * "Real" scripts live here and are run via their respective launchers.
+    * AV scans
-* `.cbin`
+    * Windows health checks
-  * This folder holds the compressed and encrypted tool archives.
+  * Automated setup
-  * They are extracted at runtime as needed.
+    * Install software
-* `Data Recovery`
+    * System configuration
-  * This folder is not copied by `Copy WizardKit.cmd` to help discourage
+
-  * recovering data to the same drive.
+## Combined UFD ##
-* `Data Transfers`
+
-* `Diagnostics`
+All parts can be combined onto a single UFD!
-* `Drivers`
+
-* `Installers`
+* Compatible with most legacy and UEFI bootloaders
-* `Misc`
+* Custom boot menus
-* `Repairs`
+* To get started run `build-ufd` under the live Linux image
-* `Uninstallers`
-
-## Live Linux ##
-
-### Build Requirements ###
-
-* Arch Linux
-* 6 Gb disk space
-
-### Initial Setup ###
-
-* Replace artwork as desired
-* Install Arch Linux in a virtual machine ([VirtualBox](https://www.virtualbox.org/) is a good option for Windows systems).
-  * See the [installation guide](https://wiki.archlinux.org/index.php/Installation_guide) for details.
-* Add a standard user to the Arch Linux installation.
-  * See the [wiki page](https://wiki.archlinux.org/index.php/Users_and_groups#User_management) for details.
-* Install git # `pacman -Syu git`
-* _(Recommended)_ Install and configure `sudo`
-  * See the [wiki page](https://wiki.archlinux.org/index.php/Sudo) for details.
-* Login to the user added above
-* Download the Github repo $ `git clone https://github.com/2Shirt/WizardKit.git`
-* Run the build script
-  * $ `cd WizardKit`
-  * $ `./Build\ Linux -b`
-  * The build script does the following:
-    * Installs missing dependencies via `pacman`
-    * Opens `main.py` in `nano` for configuration
-    * Downloads, builds, and adds AUR packages to a local repo
-    * Builds the Live Linux ISO
-
-### Notes ###
-
-* The WinPE boot options require files to be copied from a completed WinPE build.
-  * This is done below for the Combined UFD
-
-## Windows PE ##
-
-### Build Requirements ###
-
-* Windows Assessment and Deployment Kit for Windows 10
-  * Deployment Tools
-  * Windows Preinstallation Environment (Windows PE)
-  * _All other features are not required_
-* PowerShell 3.0 or newer
-* 8 Gb disk space
-
-### Initial Setup ###
-
-* Replace artwork as desired
-* Run `Build PE.cmd` which will do the following:
-  * Load the WADK environment
-  * Open `main.py` in notepad for configuration
-  * Download all tools
-  * Build both 32-bit & 64-bit PE images (exported as ISO files)
-
-## Combined Wizard Kit ##
-
-### Build Requirements ###
-
-* 64-bit system or virtual machine
-* 4 Gb RAM
-* 8 Gb USB flash drive _(16 Gb or larger recommended)_
-
-### Overview ###
-
-There's a `build-ufd` script which does the following:
-
-* Checks for the presence if the Linux ISO and the (64-bit) WinPE ISO.
-* Formats the selected UFD using FAT32.
-  * All data will be deleted from the UFD resulting in **DATA LOSS**.
-* Copies the required files from the Linux ISO, WinPE ISO, and Main Kit folder to the UFD.
-* Installs Syslinux to the UFD making it bootable on legacy systems.
-* Sets the boot files/folders to be hidden under Windows.
-
-### Setup ###
-
-* Boot to a Live Linux ISO built following the instructions above.
-  * You can apply it to a UFD using [rufus](https://rufus.akeo.ie/) for physical systems.
-  * Virtual machines should be able to use the Linux ISO directly.
-* Mount the device(s) or network share(s) that contain the Linux ISO, WinPE ISO, and Main Kit folder.
-* Connect the UFD but don't mount it.
-* Get the device name of the UFD.
-  * You can use $ `hw-drive-info` to help.
-* $ `sudo build-ufd --ufd-device [device] --linux-iso [path] --main-kit [path] --winpe-iso [path]`
-  * **2nd Warning**: All data will be erased from the UFD resulting in **DATA LOSS**.
-  * NOTE: The Main Kit folder will be renamed on the UFD using `$KIT_NAME_FULL`
-    * `$KIT_NAME_FULL` defaults to "Wizard Kit" but can be changed in `main.py`
-  * You can include extra items by using the `--extra-dir` option
-    * _(e.g. $ `sudo build-ufd --ufd-device [device] --linux-iso [path] --main-kit [path] --winpe-iso [path] --extra-dir [path]`)_
-  * To include images for the WinPE Setup section, put the files in "Extras/images".
-    * WinPE Setup will recognize ESD, WIM, and SWM<sup>2</sup> images.
-    * The filenames should be "Win7", "Win8", or "Win10"
-
-## Notes ##
-1. PowerShell 6.0 on Windows 7 is not supported by the build script.
-2. See [wimlib-imagex](https://wimlib.net/) for details about split WIM images.

scripts/Copy WizardKit.cmd

@@ -1,152 +0,0 @@
-:: Wizard Kit: Copy Kit ::
-@echo off
-
-:Init
-setlocal EnableDelayedExpansion
-title Wizard Kit: Tools Copier
-color 1b
-echo Initializing...
-call :CheckFlags %*
-call :FindBin
-call :SetTitle Tools Copier
-
-:SetVariables
-rem Set variables using settings\main.py file
-set "SETTINGS=%bin%\Scripts\settings\main.py"
-for %%v in (ARCHIVE_PASSWORD KIT_NAME_FULL) do (
-  set "var=%%v"
-  for /f "tokens=* usebackq" %%f in (`findstr "!var!=" "%SETTINGS%"`) do (
-    set "_v=%%f"
-    set "_v=!_v:*'=!"
-    set "%%v=!_v:~0,-1!"
-  )
-)
-rem Set ARCH to 32 as a gross assumption and check for x86_64 status
-set ARCH=32
-if /i "%PROCESSOR_ARCHITECTURE%" == "AMD64" set "ARCH=64"
-set "SEVEN_ZIP=%bin%\7-Zip\7za.exe"
-set "CON=%bin%\ConEmu\ConEmu.exe"
-set "FASTCOPY=%bin%\FastCopy\FastCopy.exe"
-if %ARCH% equ 64 (
-  set "SEVEN_ZIP=%bin%\7-Zip\7za64.exe"
-  set "CON=%bin%\ConEmu\ConEmu64.exe"
-  set "FASTCOPY=%bin%\FastCopy\FastCopy64.exe"
-)
-set "fastcopy_args=/cmd=diff /no_ui /auto_close"
-rem Set %client_dir%
-call "%bin%\Scripts\init_client_dir.cmd"
-pushd "%bin%\.."
-set "source=%cd%"
-popd
-set "dest=%client_dir%\Tools"
-
-:RelaunchInConEmu
-if not defined IN_CONEMU (
-  if not defined L_NCMD (
-    set "con_args=-new_console:n"
-    rem If in DEBUG state then force ConEmu to stay open
-    if defined DEBUG (set "con_args=!con_args! -new_console:c")
-    set IN_CONEMU=True
-    start "" "%CON%" -run ""%~0" %*" !con_args! || goto ErrorUnknown
-    exit /b 0
-  )
-)
-:CopyBin
-echo Copying .bin...
-mkdir "%dest%\.bin" >nul 2>&1
-attrib +h "%dest%\.bin"
-set _sources="%bin%\7-Zip"
-set _sources=%_sources% "%bin%\ConEmu"
-set _sources=%_sources% "%bin%\FastCopy"
-set _sources=%_sources% "%bin%\HWiNFO"
-set _sources=%_sources% "%bin%\Python"
-set _sources=%_sources% "%bin%\Scripts"
-start "" /wait "%fastcopy%" %fastcopy_args% %_sources% /to="%dest%\.bin\"
-
-:CopyCBin
-echo Copying .cbin...
-mkdir "%dest%\.cbin" >nul 2>&1
-attrib +h "%dest%\.cbin"
-start "" /wait "%fastcopy%" %fastcopy_args% "%cbin%"\* /to="%dest%\.cbin\"
-
-:CopyMainData
-echo Copying Main Kit...
-set _sources="%source%\Data Transfers"
-set _sources=%_sources% "%source%\Diagnostics"
-set _sources=%_sources% "%source%\Drivers"
-set _sources=%_sources% "%source%\Installers"
-set _sources=%_sources% "%source%\Misc"
-set _sources=%_sources% "%source%\Repairs"
-set _sources=%_sources% "%source%\Uninstallers"
-set _sources=%_sources% "%source%\Activate Windows.cmd"
-set _sources=%_sources% "%source%\Enter SafeMode.cmd"
-set _sources=%_sources% "%source%\Exit SafeMode.cmd"
-set _sources=%_sources% "%source%\LICENSE.txt"
-set _sources=%_sources% "%source%\README.md"
-set _sources=%_sources% "%source%\System Checklist.cmd"
-set _sources=%_sources% "%source%\System Diagnostics.cmd"
-set _sources=%_sources% "%source%\User Checklist.cmd"
-start "" /wait "%fastcopy%" %fastcopy_args% /exclude="Snappy Driver Installer*;Update Kit*;*.exe" %_sources% /to="%dest%\"
-start "" /wait "%fastcopy%" %fastcopy_args% "%source%\Installers\Extras\Office\Adobe Reader DC.exe" /to="%dest%\Installers\Extras\Office\"
-
-:Ninite
-echo Extracting Ninite installers...
-"%SEVEN_ZIP%" x "%cbin%\_Ninite.7z" -aos -bso0 -bse0 -bsp0 -p%ARCHIVE_PASSWORD% -o"%dest%\Installers\Extras" || goto Abort
-
-:OpenFolder
-start "" explorer "%dest%"
-goto Exit
-
-:: Functions ::
-:CheckFlags
-rem Loops through all arguments to check for accepted flags
-set DEBUG=
-for %%f in (%*) do (
-  if /i "%%f" == "/DEBUG" (@echo on & set "DEBUG=/DEBUG")
-)
-@exit /b 0
-
-:FindBin
-rem Checks the current directory and all parents for the ".bin" folder
-rem NOTE: Has not been tested for UNC paths
-set bin=
-pushd "%~dp0"
-:FindBinInner
-if exist ".bin" (goto FindBinDone)
-if "%~d0\" == "%cd%" (popd & @exit /b 1)
-cd ..
-goto FindBinInner
-:FindBinDone
-set "bin=%cd%\.bin"
-set "cbin=%cd%\.cbin"
-popd
-@exit /b 0
-
-:SetTitle
-rem Sets title using KIT_NAME_FULL from settings\main.py
-set "window_title=%*"
-if not defined window_title set "window_title=Launcher"
-set "window_title=%KIT_NAME_FULL%: %window_title%"
-title %window_title%
-@exit /b 0
-
-:: Errors ::
-:ErrorNoBin
-echo.
-echo ERROR: ".bin" folder not found.
-goto Abort
-
-:Abort
-color 4e
-echo Aborted.
-echo Press any key to exit...
-pause>nul
-color
-rem Set errorlevel to 1 by calling color incorrectly
-color 00
-goto Exit
-
-:: Cleanup and exit ::
-:Exit
-endlocal
-exit /b %errorlevel%

scripts/Launch.cmd

@@ -1,4 +1,4 @@
-:: Wizard Kit: Wrapper for launching programs and scripts.
+:: WizardKit: Wrapper for launching programs and scripts.
 ::
 :: Some features:
 ::   * If the OS is 64-bit then the WorkingDir is scanned for a 64-bit version of the programs
@@ -10,7 +10,7 @@ if defined DEBUG (@echo on)
 
 :Init
 setlocal EnableDelayedExpansion
-title Wizard Kit: Launcher
+title WizardKit: Launcher
 pushd "%~dp0"
 call :FindBin
 call :DeQuote L_ITEM
@@ -19,7 +19,7 @@ call :DeQuote L_TYPE
 
 :SetVariables
 rem Set variables using settings\main.py file
-set "SETTINGS=%bin%\Scripts\settings\main.py"
+set "SETTINGS=%bin%\Scripts\wk\cfg\main.py"
 for %%v in (ARCHIVE_PASSWORD KIT_NAME_FULL OFFICE_SERVER_IP QUICKBOOKS_SERVER_IP) do (
   set "var=%%v"
   for /f "tokens=* usebackq" %%f in (`findstr "!var!=" "%SETTINGS%"`) do (
@@ -31,13 +31,12 @@ for %%v in (ARCHIVE_PASSWORD KIT_NAME_FULL OFFICE_SERVER_IP QUICKBOOKS_SERVER_IP
 rem Set ARCH to 32 as a gross assumption and check for x86_64 status
 set ARCH=32
 if /i "%PROCESSOR_ARCHITECTURE%" == "AMD64" set "ARCH=64"
-set "SEVEN_ZIP=%bin%\7-Zip\7za.exe"
+set "SEVEN_ZIP=%bin%\7-Zip\7z.exe"
 set "CON=%bin%\ConEmu\ConEmu.exe"
 set "FASTCOPY=%bin%\FastCopy\FastCopy.exe"
 set "POWERSHELL=%systemroot%\system32\WindowsPowerShell\v1.0\powershell.exe"
 set "PYTHON=%bin%\Python\x32\python.exe"
 if %ARCH% equ 64 (
-  set "SEVEN_ZIP=%bin%\7-Zip\7za64.exe"
   set "CON=%bin%\ConEmu\ConEmu64.exe"
   set "FASTCOPY=%bin%\FastCopy\FastCopy64.exe"
   set "PYTHON=%bin%\Python\x64\python.exe"
@@ -98,6 +97,8 @@ rem Check for 64-bit prog (if running on 64-bit system)
 set "prog=%_path%\%L_ITEM%"
 if %ARCH% equ 64 (
   if exist "%_path%\%L_ITEM:.=64.%" set "prog=%_path%\%L_ITEM:.=64.%"
+) else (
+  if exist "%_path%\%L_ITEM:.=32.%" set "prog=%_path%\%L_ITEM:.=32.%"
 )
 if not exist "%prog%" goto ErrorProgramNotFound
 
@@ -241,7 +242,7 @@ if defined L_NCMD (
   rem use Powershell's window instead of %CON%
   echo UAC.ShellExecute "%POWERSHELL%", "%ps_args% -File "%script%"", "", "runas", 3 >> "%bin%\tmp\Elevate.vbs"
 ) else (
-  echo UAC.ShellExecute "%CON%", "-run %POWERSHELL% %ps_args% -File "%script%" -new_console:n", "", "runas", 1 >> "%bin%\tmp\Elevate.vbs"
+  echo UAC.ShellExecute "%CON%", "-run %POWERSHELL% %ps_args% -File "^"%script%^"" -new_console:n", "", "runas", 1 >> "%bin%\tmp\Elevate.vbs"
 )
 
 rem Run

scripts/Launcher_Template.cmd

@@ -1,4 +1,4 @@
-:: Wizard Kit: Launcher Script ::
+:: WizardKit: Launcher Script ::
 ::
 :: This script works by setting env variables and then calling Launch.cmd
 :: which inherits the variables. This bypasses batch file argument parsing
@@ -7,7 +7,7 @@
 
 :Init
 setlocal EnableDelayedExpansion
-title Wizard Kit: Launcher
+title WizardKit: Launcher
 call :CheckFlags %*
 call :FindBin
 call :SetTitle Launcher
@@ -67,8 +67,8 @@ popd
 @exit /b 0
 
 :SetTitle
-rem Sets title using KIT_NAME_FULL from settings\main.py
+rem Sets title using KIT_NAME_FULL from wk\cfg\main.py
-set "SETTINGS=%bin%\Scripts\settings\main.py"
+set "SETTINGS=%bin%\Scripts\wk\cfg\main.py"
 for /f "tokens=* usebackq" %%f in (`findstr KIT_NAME_FULL "%SETTINGS%"`) do (
   set "_v=%%f"
   set "_v=!_v:*'=!"

scripts/README.md

@@ -1,6 +1,2 @@
-## pylint ##
+# WizardKit: Scripts #
-
-These scripts use two spaces per indent instead of the default four. As such you will need to update your pylintrc file or run like this:
-
-`pylint --indent-after-paren=2 --indent-string='  ' wk`
 

scripts/activate.py

@@ -1,31 +0,0 @@
-"""Wizard Kit: Activate Windows using a BIOS key"""
-# vim: sts=2 sw=2 ts=2
-
-import wk
-
-
-def main():
-  """Attempt to activate Windows and show result."""
-  title = f'{wk.cfg.main.KIT_NAME_FULL}: Activation Tool'
-  try_print = wk.std.TryAndPrint()
-  wk.std.clear_screen()
-  wk.std.set_title(title)
-  wk.std.print_info(title)
-  print('')
-
-  # Attempt activation
-  try_print.run('Attempting activation...', wk.os.win.activate_with_bios)
-
-  # Done
-  print('')
-  print('Done.')
-  wk.std.pause('Press Enter to exit...')
-
-
-if __name__ == '__main__':
-  try:
-    main()
-  except SystemExit:
-    raise
-  except: #pylint: disable=bare-except
-    wk.std.major_exception()

scripts/add-known-networks

@@ -1,81 +0,0 @@
-#!/bin/env python3
-#
-## Convert saved WiFi connections for NetworkManager
-
-import os
-import re
-import sys
-import uuid
-
-KNOWN_NETWORKS = '/root/known_networks'
-TEMPLATE = '''[connection]
-id={ssid}
-uuid={uuid}
-type=wifi
-permissions=user:{user}:;
-
-[wifi]
-mac-address-blacklist=
-mode=infrastructure
-ssid={ssid}
-
-[wifi-security]
-auth-alg=open
-key-mgmt=wpa-psk
-psk={password}
-
-[ipv4]
-dns-search=
-method=auto
-
-[ipv6]
-addr-gen-mode=stable-privacy
-dns-search=
-method=auto
-'''
-
-def get_user_name():
-  """Get user name, returns str."""
-  user = None
-
-  # Get running user
-  if 'SUDO_USER' in os.environ:
-    user = os.environ.get('SUDO_USER')
-  else:
-    user = os.environ.get('USER')
-
-  # Check if user manually specified
-  for a in sys.argv:
-    a = a.strip().lower()
-    if a.startswith('--user='):
-      user = a.replace('--user=', '')
-
-  return user
-
-if __name__ == '__main__':
-  known_networks = {}
-  #try:
-  with open('/root/known_networks', 'r') as f:
-    for line in f.readlines():
-      r = re.search(r"^'(.*)':\s+'(.*)'", line.strip())
-      if r:
-        known_networks[r.group(1)] = r.group(2)
-  for ssid, password in known_networks.items():
-    out_path = '{}/{}.nmconnection'.format(
-      '/etc/NetworkManager/system-connections',
-      ssid,
-      )
-    if not os.path.exists(out_path):
-      with open(out_path, 'w') as f:
-        f.write(TEMPLATE.format(
-          user=get_user_name(),
-          ssid=ssid,
-          password=password,
-          uuid=uuid.uuid4(),
-          ))
-    os.chmod(out_path, 0o600)
-  #except:
-  #  # Meh
-  #  pass
-
-# vim: sts=2 sw=2 ts=2

scripts/apple-fans

@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-## Wizard Kit: Apple fan speed tool
+## WizardKit: Apple fan speed tool
 
 SMCPATH="/sys/devices/platform/applesmc.768"
 SET_MAX="True"

scripts/auto_repairs.py

@@ -0,0 +1,100 @@
+"""WizardKit: Auto Repair Tool"""
+# vim: sts=2 sw=2 ts=2
+
+from typing import Any
+
+import wk
+
+
+# Classes
+REBOOT_STR = wk.ui.ansi.color_string('Reboot', 'YELLOW')
+class MenuEntry():
+  """Simple class to allow cleaner code below."""
+  def __init__(
+      self,
+      name: str,
+      function: str | None = None,
+      selected: bool = True,
+      **kwargs):
+    self.name: str = name
+    self.details: dict[str, Any] = {
+      'Function': function,
+      'Selected': selected,
+      **kwargs,
+      }
+
+
+# STATIC VARIABLES
+BASE_MENUS = {
+  'Groups': {
+    'Backup Settings': (
+      MenuEntry('Enable RegBack',           'auto_enable_regback'),
+      MenuEntry('Enable System Restore',    'auto_system_restore_enable'),
+      MenuEntry('Set System Restore Size',  'auto_system_restore_set_size'),
+      MenuEntry('Create System Restore',    'auto_system_restore_create'),
+      MenuEntry('Backup Browsers',          'auto_backup_browser_profiles'),
+      MenuEntry('Backup Power Plans',       'auto_backup_power_plans'),
+      MenuEntry('Reset Power Plans',        'auto_reset_power_plans'),
+      MenuEntry('Set Custom Power Plan',    'auto_set_custom_power_plan'),
+      MenuEntry('Backup Registry',          'auto_backup_registry'),
+      ),
+    'Windows Repairs': (
+      MenuEntry('Disable Windows Updates',  'auto_windows_updates_disable'),
+      MenuEntry('Reset Windows Updates',    'auto_windows_updates_reset'),
+      MenuEntry(REBOOT_STR,                 'auto_reboot'),
+      MenuEntry('CHKDSK',                   'auto_chkdsk'),
+      MenuEntry('DISM RestoreHealth',       'auto_dism'),
+      MenuEntry('SFC Scan',                 'auto_sfc'),
+      MenuEntry('Clear Proxy Settings',     'auto_reset_proxy'),
+      MenuEntry('Disable Pending Renames',  'auto_disable_pending_renames'),
+      MenuEntry('Registry Repairs',         'auto_repair_registry'),
+      MenuEntry('Reset UAC',                'auto_restore_uac_defaults'),
+      MenuEntry('Reset Windows Policies',   'auto_reset_windows_policies'),
+      ),
+    'Malware Cleanup': (
+      MenuEntry('BleachBit',                'auto_bleachbit'),
+      MenuEntry('HitmanPro',                'auto_hitmanpro'),
+      MenuEntry('KVRT',                     'auto_kvrt'),
+      MenuEntry('Windows Defender',         'auto_microsoft_defender'),
+      MenuEntry('Remove Custom Power Plan', 'auto_remove_power_plan'),
+      MenuEntry(REBOOT_STR,                 'auto_reboot'),
+      ),
+    'Manual Steps': (
+      MenuEntry('AdwCleaner',               'auto_adwcleaner'),
+      MenuEntry('Bulk Crap Uninstaller',    'auto_bcuninstaller'),
+      MenuEntry('Enable Windows Updates',   'auto_windows_updates_enable'),
+      ),
+    },
+  'Options': (
+    MenuEntry('Kill Explorer', selected=False),
+    MenuEntry('Run AVRemover (once)'),
+    MenuEntry('Run RKill'),
+    MenuEntry('Sync Clock'),
+    MenuEntry('Use Autologon', selected=False),
+    ),
+  'Actions': (
+    MenuEntry('Load Preset'),
+    MenuEntry('Options'),
+    MenuEntry('Start', Separator=True),
+    MenuEntry('Quit'),
+    ),
+  }
+PRESETS = {
+  'Default': { # Will be expanded at runtime using BASE_MENUS
+    'Options': (
+      'Run RKill',
+      'Sync Clock',
+      ),
+    },
+  'Custom': {}, # Will remain empty at runtime
+  }
+
+if __name__ == '__main__':
+  try:
+    wk.repairs.win.run_auto_repairs(BASE_MENUS, PRESETS)
+  except KeyboardInterrupt:
+    wk.ui.cli.abort()
+  except SystemExit:
+    raise
+  except: # noqa: E722
+    wk.ui.cli.major_exception()

scripts/auto_setup.py

@@ -0,0 +1,175 @@
+"""WizardKit: Auto System Setup Tool"""
+# vim: sts=2 sw=2 ts=2
+
+from typing import Any
+
+import wk
+
+
+# Classes
+class MenuEntry():
+  """Simple class to allow cleaner code below."""
+  def __init__(
+      self,
+      name: str,
+      function: str | None = None,
+      selected: bool = True,
+      **kwargs):
+    self.name: str = name
+    self.details: dict[str, Any] = {
+      'Function': function,
+      'Selected': selected,
+      **kwargs,
+      }
+
+
+# STATIC VARIABLES
+BASE_MENUS = {
+  'Groups': {
+    'Backup Settings': (
+      MenuEntry('Backup Browsers',          'auto_backup_browser_profiles'),
+      MenuEntry('Backup Power Plans',       'auto_backup_power_plans'),
+      MenuEntry('Reset Power Plans',        'auto_reset_power_plans'),
+      MenuEntry('Set Custom Power Plan',    'auto_set_custom_power_plan'),
+      ),
+    'Install Software': (
+      MenuEntry('Winget',                   'auto_install_winget'),
+      MenuEntry('Firefox',                  'auto_install_firefox'),
+      MenuEntry('LibreOffice',              'auto_install_libreoffice', selected=False),
+      MenuEntry('Open Shell',               'auto_install_open_shell'),
+      MenuEntry('Software Bundle',          'auto_install_software_bundle'),
+      MenuEntry('Software Upgrades',        'auto_install_software_upgrades'),
+      MenuEntry('Visual C++ Runtimes',      'auto_install_vcredists'),
+      ),
+    'Configure System': (
+      MenuEntry('Open Shell',               'auto_config_open_shell'),
+      MenuEntry('Disable Password Expiration', 'auto_disable_password_expiration'),
+      MenuEntry('Enable BSoD MiniDumps',    'auto_enable_bsod_minidumps'),
+      MenuEntry('Enable RegBack',           'auto_enable_regback'),
+      MenuEntry('Enable System Restore',    'auto_system_restore_enable'),
+      MenuEntry('Set System Restore Size',  'auto_system_restore_set_size'),
+      MenuEntry('Enable Windows Updates',   'auto_windows_updates_enable'),
+      MenuEntry('Windows Activation',       'auto_activate_windows'),
+      MenuEntry('Windows Explorer',         'auto_config_explorer'),
+      MenuEntry(r'Windows\Temp Fix',        'auto_windows_temp_fix'),
+      MenuEntry('Configure Browsers',       'auto_config_browsers'),
+      MenuEntry('Create System Restore',    'auto_system_restore_create'),
+      ),
+    'System Information': (
+      MenuEntry('AIDA64 Report',            'auto_export_aida64_report'),
+      MenuEntry('Backup Registry',          'auto_backup_registry'),
+      ),
+    'System Summary': (
+      MenuEntry('Operating System',         'auto_show_os_name'),
+      MenuEntry('Windows Activation',       'auto_show_os_activation'),
+      MenuEntry('Secure Boot',              'auto_show_secure_boot_status'),
+      MenuEntry('Installed RAM',            'auto_show_installed_ram'),
+      MenuEntry('Storage Status',           'auto_show_storage_status'),
+      MenuEntry('Virus Protection',         'auto_show_installed_antivirus'),
+      MenuEntry('Partitions 4K Aligned',    'auto_show_4k_alignment_check'),
+      ),
+    'Run Programs': (
+      MenuEntry('Device Manager',           'auto_open_device_manager'),
+      MenuEntry('HWiNFO Sensors',           'auto_open_hwinfo_sensors'),
+      MenuEntry('Microsoft Store Updates',  'auto_open_microsoft_store_updates'),
+      MenuEntry('Snappy Driver Installer',  'auto_open_snappy_driver_installer_origin'),
+      MenuEntry('Windows Activation',       'auto_open_windows_activation'),
+      MenuEntry('Windows Updates',          'auto_open_windows_updates'),
+      MenuEntry('XMPlay',                   'auto_open_xmplay'),
+      ),
+    },
+  'Actions': (
+    MenuEntry('Load Preset'),
+    MenuEntry('Start', Separator=True),
+    MenuEntry('Quit'),
+    ),
+  }
+PRESETS = {
+  'Default': {}, # Will be built at runtime using BASE_MENUS
+  'Additional User': {
+    'Configure System': (
+      'Configure Browsers',
+      'Open Shell',
+      'uBlock Origin',
+      'Enable BSoD MiniDumps',
+      'Enable RegBack',
+      'Enable System Restore',
+      'Set System Restore Size',
+      'Enable Windows Updates',
+      'Windows Explorer',
+      ),
+    'Install Software': (
+      'Firefox', # Needed to handle profile upgrade nonsense
+      ),
+    'Run Programs': (
+      'Microsoft Store Updates',
+      ),
+    'System Summary': (
+      'Operating System',
+      'Windows Activation',
+      'Secure Boot',
+      'Installed RAM',
+      'Storage Status',
+      'Virus Protection',
+      'Partitions 4K Aligned',
+      ),
+    },
+  'Hardware': {
+    'Configure System': (
+      'Enable BSoD MiniDumps',
+      'Enable RegBack',
+      'Enable System Restore',
+      'Set System Restore Size',
+      'Enable Windows Updates',
+      ),
+    'System Information': (
+      'Backup Registry',
+      ),
+    'System Summary': (
+      'Operating System',
+      'Windows Activation',
+      'Secure Boot',
+      'Installed RAM',
+      'Storage Status',
+      'Virus Protection',
+      'Partitions 4K Aligned',
+      ),
+    'Run Programs': (
+      'Device Manager',
+      'HWiNFO Sensors',
+      'XMPlay',
+      ),
+    },
+  'Verify': {
+    'Configure System': (
+      'Enable BSoD MiniDumps',
+      'Enable RegBack',
+      'Enable System Restore',
+      'Set System Restore Size',
+      'Enable Windows Updates',
+      'Windows Explorer',
+      ),
+    'System Summary': (
+      'Operating System',
+      'Windows Activation',
+      'Secure Boot',
+      'Installed RAM',
+      'Storage Status',
+      'Virus Protection',
+      'Installed Office',
+      'Partitions 4K Aligned',
+      ),
+    },
+  'Custom': {}, # Will remain empty at runtime
+  }
+
+
+if __name__ == '__main__':
+  try:
+    wk.setup.win.run_auto_setup(BASE_MENUS, PRESETS)
+  except KeyboardInterrupt:
+    wk.ui.cli.abort()
+  except SystemExit:
+    raise
+  except: # noqa: E722
+    wk.ui.cli.major_exception()

scripts/borrowed/set-eol.ps1

@@ -1,45 +0,0 @@
-## Borrowed from https://ss64.com/ps/syntax-set-eol.html
-#
-# set-eol.ps1
-# Change the line endings of a text file to: Windows (CR/LF), Unix (LF) or Mac (CR)
-# Requires PowerShell 3.0 or greater
-
-# Syntax
-#       ./set-eol.ps1 -lineEnding {mac|unix|win} -file FullFilename
-
-#     mac, unix or win  : The file endings desired.
-#     FullFilename      : The full pathname of the file to be modified.
-
-#     ./set-eol win "c:\demo\data.txt"
-
-[CmdletBinding()]
-Param(
-  [Parameter(Mandatory=$True,Position=1)]
-    [ValidateSet("mac","unix","win")] 
-    [string]$lineEnding,
-  [Parameter(Mandatory=$True)]
-    [string]$file
-)
-
-# Convert the friendly name into a PowerShell EOL character
-Switch ($lineEnding) {
-  "mac"  { $eol="`r" }
-  "unix" { $eol="`n" }
-  "win"  { $eol="`r`n" }
-} 
-
-# Replace CR+LF with LF
-$text = [IO.File]::ReadAllText($file) -replace "`r`n", "`n"
-[IO.File]::WriteAllText($file, $text)
-
-# Replace CR with LF
-$text = [IO.File]::ReadAllText($file) -replace "`r", "`n"
-[IO.File]::WriteAllText($file, $text)
-
-#  At this point all line-endings should be LF.
-
-# Replace LF with intended EOL char
-if ($eol -ne "`n") {
-  $text = [IO.File]::ReadAllText($file) -replace "`n", $eol
-  [IO.File]::WriteAllText($file, $text)
-}

scripts/build-ufd

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Wizard Kit: Build UFD Tool"""
+"""WizardKit: Build UFD Tool"""
 # vim: sts=2 sw=2 ts=2
 
 import wk
@@ -10,5 +10,5 @@ if __name__ == '__main__':
     wk.kit.ufd.build_ufd()
   except SystemExit:
     raise
-  except: #pylint: disable=bare-except
+  except: # noqa: E722
-    wk.std.major_exception()
+    wk.ui.cli.major_exception()

scripts/build_kit_windows.py

@@ -0,0 +1,15 @@
+"""WizardKit: Build Kit (Windows)."""
+# vim: sts=2 sw=2 ts=2
+
+import wk
+
+
+if __name__ == '__main__':
+  try:
+    wk.kit.build.build_kit()
+  except KeyboardInterrupt:
+    wk.ui.cli.abort()
+  except SystemExit:
+    raise
+  except: # noqa: E722
+    wk.ui.cli.major_exception()

scripts/build_pe.ps1

@@ -1,657 +0,0 @@
-# Wizard Kit: Windows PE Build Tool
-
-## Init ##
-#Requires -Version 3.0
-#Requires -RunAsAdministrator
-if (Test-Path Env:\DEBUG) {
-  Set-PSDebug -Trace 1
-}
-$Host.UI.RawUI.WindowTitle = "Wizard Kit: Windows PE Build Tool"
-$WD = $(Split-Path $MyInvocation.MyCommand.Path)
-$Bin = (Get-Item $WD -Force).Parent.FullName
-$Root = (Get-Item $Bin -Force).Parent.FullName
-$Build = "$Root\BUILD_PE"
-$LogDir = "$Build\Logs"
-$Temp = "$Build\Temp"
-$Date = Get-Date -UFormat "%Y-%m-%d"
-$Host.UI.RawUI.BackgroundColor = "Black"
-$Host.UI.RawUI.ForegroundColor = "White"
-$HostSystem32 = "{0}\System32" -f $Env:SystemRoot
-$HostSysWOW64 = "{0}\SysWOW64" -f $Env:SystemRoot
-$DISM = "{0}\DISM.exe" -f $Env:DISMRoot
-#Enable TLS 1.2
-[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
-
-## Functions ##
-function Ask-User ($text = "Kotaero") {
-  $text += " [Y/N]"
-  while ($true) {
-    $answer = read-host $text
-    if ($answer -imatch "^(y|yes)$") {
-      $answer = $true
-      break
-    } elseif ($answer -imatch "^(n|no|nope)$") {
-      $answer = $false
-      break
-    }
-  }
-  $answer
-}
-function Abort {
-  Write-Host -ForegroundColor "Red" "`nAborted."
-  WKPause "Press Enter to exit... "
-  exit
-}
-function MakeClean {
-  $Folders = @(
-    "$Build\Mount",
-    "$Build\PEFiles")
-  $Clean = $false
-  foreach ($f in $Folders) {
-    if (Test-Path $f) {
-      Write-Host -ForegroundColor "Yellow" ("Found: {0}" -f $f)
-      $Clean = $true
-    }
-  }
-  if (($Clean) -and (Ask-User "Delete the above folder(s)?")) {
-    foreach ($f in $Folders) {
-      if (Test-Path $f) {
-        Remove-Item -Path $f -Recurse -Force
-      }
-    }
-  }
-}
-function DownloadFile ($Path, $Name, $Url) {
-  $OutFile = "{0}\{1}" -f $Path, $Name
-
-  Write-Host ("Downloading: $Name")
-  New-Item -Type Directory $Path 2>&1 | Out-Null
-  try {
-    Invoke-WebRequest -Uri $Url -OutFile $OutFile
-  }
-  catch {
-    Write-Host ("  ERROR: Failed to download file." ) -ForegroundColor "Red"
-    $global:DownloadErrors += 1
-  }
-}
-function FindDynamicUrl ($SourcePage, $RegEx) {
-  # Get source page
-  Invoke-Webrequest -Uri $SourcePage -OutFile "tmp_page"
-
-  # Search for real url
-  $Url = Get-Content "tmp_page" | Where-Object {$_ -imatch $RegEx}
-  $Url = $Url -ireplace '.*(a |)href="([^"]+)".*', '$2'
-  $Url = $Url -ireplace ".*(a |)href='([^']+)'.*", '$2'
-
-  # Remove tmp_page
-  Remove-Item "tmp_page"
-
-  $Url | Select-Object -First 1
-}
-function WKPause ($Message = "Press Enter to continue... ") {
-  Write-Host $Message -NoNewLine
-  Read-Host
-}
-
-## PowerShell equivalent of Python's "if __name__ == '__main__'"
-# Code based on StackOverflow comments
-# Question:     https://stackoverflow.com/q/4693947
-# Using answer: https://stackoverflow.com/a/5582692
-# Asked by:     https://stackoverflow.com/users/65164/mark-mascolino
-# Answer by:    https://stackoverflow.com/users/696808/bacon-bits
-if ($MyInvocation.InvocationName -ne ".") {
-  Clear-Host
-  Write-Host "Wizard Kit: Windows PE Build Tool`n`n`n`n`n"
-
-  ## Prep ##
-  try {
-    Import-Module -Name $Env:DISMRoot -ErrorAction "stop"
-  }
-  catch {
-    Write-Host -ForegroundColor "Red" "ERROR: Failed to load DISM CmdLet"
-    Abort
-  }
-  Push-Location "$WD"
-  MakeClean
-  New-Item -Type Directory $Build 2>&1 | Out-Null
-  New-Item -Type Directory $LogDir 2>&1 | Out-Null
-
-  ## main.py ##
-  if (!(Test-Path "$Build\main.py") -or (Ask-User "Replace existing main.py?")) {
-    Copy-Item -Path "$Bin\Scripts\settings\main.py" -Destination "$Build\main.py" -Force
-  }
-  WKPause "Press Enter to open settings..."
-  Start-Process "$HostSystem32\notepad.exe" -ArgumentList @("$Build\main.py") -Wait
-  $KitNameFull = (Get-Content "$Build\main.py" | Where-Object {$_ -match 'FULL'}) -replace ".*'(.*)'$", '$1'
-  $KitNameShort = (Get-Content "$Build\main.py" | Where-Object {$_ -match 'SHORT'}) -replace ".*'(.*)'$", '$1'
-
-  if (Ask-User "Update Tools?") {
-    $DownloadErrors = 0
-
-    ## Download Tools ##
-    $ToolSources = @(
-      # 7-Zip
-      @("7z-installer.msi", "https://www.7-zip.org/a/7z1900.msi"),
-      @("7z-extra.7z", "https://www.7-zip.org/a/7z1900-extra.7z"),
-      # Blue Screen View
-      @("bluescreenview32.zip", "http://www.nirsoft.net/utils/bluescreenview.zip"),
-      @("bluescreenview64.zip", "http://www.nirsoft.net/utils/bluescreenview-x64.zip"),
-      # ConEmu
-      @("ConEmuPack.7z", "https://github.com/Maximus5/ConEmu/releases/download/v19.03.10/ConEmuPack.190310.7z"),
-      # Fast Copy
-      @("fastcopy.zip", "http://ftp.vector.co.jp/71/31/2323/FastCopy363_installer.exe"),
-      # HWiNFO
-      @("hwinfo.zip", "http://files2.majorgeeks.com/377527622c5325acc1cb937fb149d0de922320c0/systeminfo/hwi_602.zip"),
-      # Killer Network Drivers
-      @(
-        "killerinf.zip",
-        ("https://www.killernetworking.com"+(FindDynamicUrl "https://www.killernetworking.com/killersupport/category/other-downloads" "Download Killer-Ethernet").replace('&', '&'))
-      ),
-      # Notepad++
-      @("npp_x86.7z", "https://notepad-plus-plus.org/repository/7.x/7.6.4/npp.7.6.4.bin.minimalist.7z"),
-      @("npp_amd64.7z", "https://notepad-plus-plus.org/repository/7.x/7.6.4/npp.7.6.4.bin.minimalist.x64.7z"),
-      # NT Password Editor
-      @("ntpwed.zip", "http://cdslow.org.ru/files/ntpwedit/ntpwed07.zip"),
-      # Prime95
-      @("prime95_32.zip", "http://www.mersenne.org/ftp_root/gimps/p95v294b7.win32.zip"),
-      @("prime95_64.zip", "http://www.mersenne.org/ftp_root/gimps/p95v294b8.win64.zip"),
-      # ProduKey
-      @("produkey32.zip", "http://www.nirsoft.net/utils/produkey.zip"),
-      @("produkey64.zip", "http://www.nirsoft.net/utils/produkey-x64.zip"),
-      # Python
-      @("python32.zip", "https://www.python.org/ftp/python/3.7.2/python-3.7.2.post1-embed-win32.zip"),
-      @("python64.zip", "https://www.python.org/ftp/python/3.7.2/python-3.7.2.post1-embed-amd64.zip"),
-      # Python: psutil
-      @(
-        "psutil64.whl",
-        (FindDynamicUrl "https://pypi.org/project/psutil/" "href=.*-cp37-cp37m-win_amd64.whl")
-      ),
-      @(
-        "psutil32.whl",
-        (FindDynamicUrl "https://pypi.org/project/psutil/" "href=.*-cp37-cp37m-win32.whl")
-      ),
-      # Q-Dir
-      @("qdir32.zip", "https://www.softwareok.com/Download/Q-Dir_Portable.zip"),
-      @("qdir64.zip", "https://www.softwareok.com/Download/Q-Dir_Portable_x64.zip"),
-      # TestDisk / PhotoRec
-      @("testdisk32.zip", "https://www.cgsecurity.org/testdisk-7.1-WIP.win.zip"),
-      @("testdisk64.zip", "https://www.cgsecurity.org/testdisk-7.1-WIP.win64.zip"),
-      # VirtIO drivers
-      @("virtio-win.iso", "https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/latest-virtio/virtio-win.iso"),
-      # Visual C++ Runtimes
-      @("vcredist_x86.exe", "https://aka.ms/vs/15/release/vc_redist.x86.exe"),
-      @("vcredist_x64.exe", "https://aka.ms/vs/15/release/vc_redist.x64.exe"),
-      # wimlib-imagex
-      @("wimlib32.zip", "https://wimlib.net/downloads/wimlib-1.13.0-windows-i686-bin.zip"),
-      @("wimlib64.zip", "https://wimlib.net/downloads/wimlib-1.13.0-windows-x86_64-bin.zip")
-    )
-    foreach ($Tool in $ToolSources) {
-      DownloadFile -Path $Temp -Name $Tool[0] -Url $Tool[1]
-    }
-
-    ## Bail ##
-    # If errors were encountered during downloads
-    if ($DownloadErrors -gt 0) {
-      Abort
-    }
-
-    ## Install ##
-    # Visual C++ Runtimes
-    Write-Host "Installing: Visual C++ Runtimes"
-    $ArgumentList = @("/install", "/passive", "/norestart")
-    Start-Process -FilePath "$Temp\vcredist_x86.exe" -ArgumentList $ArgumentList -Wait
-    Start-Process -FilePath "$Temp\vcredist_x64.exe" -ArgumentList $ArgumentList -Wait
-
-    ## Extract ##
-    # 7-Zip
-    Write-Host "Extracting: 7-Zip"
-    try {
-      $ArgumentList = @("/a", "$Temp\7z-installer.msi", "TARGETDIR=$Temp\7zi", "/qn")
-      Start-Process -FilePath "$HostSystem32\msiexec.exe" -ArgumentList $ArgumentList -Wait
-      $SevenZip = "$Temp\7zi\Files\7-Zip\7z.exe"
-      $ArgumentList = @(
-        "e", "$Temp\7z-extra.7z", "-o$Build\bin\amd64\7-Zip",
-        "-aoa", "-bso0", "-bse0", "-bsp0",
-        "x64\7za.exe", "*.txt")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      $ArgumentList = @(
-        "e", "$Temp\7z-extra.7z", "-o$Build\bin\x86\7-Zip",
-        "-aoa", "-bso0", "-bse0", "-bsp0",
-        "7za.exe", "*.txt")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-    # Blue Screen View
-    Write-Host "Extracting: BlueScreenView"
-    try {
-      $ArgumentList = @(
-        "x", "$Temp\bluescreenview64.zip", "-o$Build\bin\amd64\BlueScreenView",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      $ArgumentList = @(
-        "x", "$Temp\bluescreenview32.zip", "-o$Build\bin\x86\BlueScreenView",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-    # ConEmu
-    Write-Host "Extracting: ConEmu"
-    try {
-      $ArgumentList = @(
-        "x", "$Temp\ConEmuPack.7z", "-o$Build\bin\amd64\ConEmu",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      Remove-Item "$Build\bin\amd64\ConEmu\ConEmu.exe"
-      Remove-Item "$Build\bin\amd64\ConEmu\ConEmu.map"
-      Move-Item "$Build\bin\amd64\ConEmu\ConEmu64.exe" "$Build\bin\amd64\ConEmu\ConEmu.exe" -Force
-      Move-Item "$Build\bin\amd64\ConEmu\ConEmu64.map" "$Build\bin\amd64\ConEmu\ConEmu.map" -Force
-      $ArgumentList = @(
-        "x", "$Temp\ConEmuPack.7z", "-o$Build\bin\x86\ConEmu",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      Remove-Item "$Build\bin\x86\ConEmu\ConEmu64.exe"
-      Remove-Item "$Build\bin\x86\ConEmu\ConEmu64.map"
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-    # Fast Copy
-    Write-Host "Extracting: FastCopy"
-    try {
-      # Extract Installer
-      $ArgumentList = @(
-        "e", "$Temp\fastcopy.zip", "-o$Temp",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-
-      # Extract 64-bit
-      $ArgumentList = @(
-        "/NOSUBDIR", "/DIR=$Build\bin\amd64\FastCopy",
-        "/EXTRACT64")
-      Start-Process -FilePath "$TEMP\FastCopy354_installer.exe" -ArgumentList $ArgumentList -NoNewWindow -Wait
-      Remove-Item "$Build\bin\amd64\FastCopy\setup.exe" -Force
-
-      # Extract 32-bit
-      $ArgumentList = @(
-        "/NOSUBDIR", "/DIR=$Build\bin\x86\FastCopy",
-        "/EXTRACT32")
-      Start-Process -FilePath "$TEMP\FastCopy354_installer.exe" -ArgumentList $ArgumentList -NoNewWindow -Wait
-      Remove-Item "$Build\bin\x86\FastCopy\setup.exe" -Force
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-
-    # Killer Network Driver
-    Write-Host "Extracting: Killer Network Driver"
-    try {
-      $ArgumentList = @(
-        "e", "$Temp\killerinf.zip", "-o$Build\Drivers\amd64\Killer",
-        "-aoa", "-bso0", "-bse0", "-bsp0",
-        "Production\Windows10-x64\Eth\*")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      $ArgumentList = @(
-        "e", "$Temp\killerinf.zip", "-o$Build\Drivers\x86\Killer",
-        "-aoa", "-bso0", "-bse0", "-bsp0",
-        "Production\Windows10-x86\Eth\*")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-    # HWiNFO
-    Write-Host "Extracting: HWiNFO"
-    try {
-      $ArgumentList = @(
-        "e", "$Temp\hwinfo.zip", "-o$Build\bin\amd64\HWiNFO",
-        "-aoa", "-bso0", "-bse0", "-bsp0", "HWiNFO64.exe")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      $ArgumentList = @(
-        "e", "$Temp\hwinfo.zip", "-o$Build\bin\x86\HWiNFO",
-        "-aoa", "-bso0", "-bse0", "-bsp0", "HWiNFO32.exe")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      Move-Item "$Build\bin\amd64\HWiNFO\HWiNFO64.exe" "$Build\bin\amd64\HWiNFO\HWiNFO.exe" -Force
-      Move-Item "$Build\bin\x86\HWiNFO\HWiNFO32.exe" "$Build\bin\x86\HWiNFO\HWiNFO.exe" -Force
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-    # Notepad++
-    Write-Host "Extracting: Notepad++"
-    try {
-      $ArgumentList = @(
-        "x", "$Temp\npp_amd64.7z", "-o$Build\bin\amd64\NotepadPlusPlus",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      $ArgumentList = @(
-        "x", "$Temp\npp_x86.7z", "-o$Build\bin\x86\NotepadPlusPlus",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      Move-Item "$Build\bin\amd64\NotepadPlusPlus\notepad++.exe" "$Build\bin\amd64\NotepadPlusPlus\notepadplusplus.exe" -Force
-      Move-Item "$Build\bin\x86\NotepadPlusPlus\notepad++.exe" "$Build\bin\x86\NotepadPlusPlus\notepadplusplus.exe" -Force
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-    # NT Password Editor
-    Write-Host "Extracting: NT Password Editor"
-    try {
-      $ArgumentList = @(
-        "e", "$Temp\ntpwed.zip", ('-o"{0}\bin\amd64\NT Password Editor"' -f $Build),
-        "-aoa", "-bso0", "-bse0", "-bsp0",
-        "ntpwedit64.exe", "*.txt")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      Move-Item "$Build\bin\amd64\NT Password Editor\ntpwedit64.exe" "$Build\bin\amd64\NT Password Editor\ntpwedit.exe" -Force
-      $ArgumentList = @(
-        "e", "$Temp\ntpwed.zip", ('-o"{0}\bin\x86\NT Password Editor"' -f $Build),
-        "-aoa", "-bso0", "-bse0", "-bsp0",
-        "ntpwedit.exe", "*.txt")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-    # PhotoRec / TestDisk
-    Write-Host "Extracting: PhotoRec / TestDisk"
-    try {
-      $ArgumentList = @(
-        "x", "$Temp\testdisk64.zip", "-o$Build\bin\amd64\TestDisk",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      # Remove destination since Move-Item -Force can't handle this recursive merge
-      Remove-Item "$Build\bin\amd64\TestDisk" -Recurse -Force 2>&1 | Out-Null
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      Move-Item "$Build\bin\amd64\TestDisk\testdisk-7.1-WIP\*" "$Build\bin\amd64\TestDisk" -Force
-      Remove-Item "$Build\bin\amd64\TestDisk\testdisk-7.1-WIP" -Recurse -Force
-      $ArgumentList = @(
-        "x", "$Temp\testdisk32.zip", "-o$Build\bin\x86\TestDisk",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      # Remove destination since Move-Item -Force can't handle this recursive merge
-      Remove-Item "$Build\bin\x86\TestDisk" -Recurse -Force 2>&1 | Out-Null
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      Move-Item "$Build\bin\x86\TestDisk\testdisk-7.1-WIP\*" "$Build\bin\x86\TestDisk" -Force
-      Remove-Item "$Build\bin\x86\TestDisk\testdisk-7.1-WIP" -Recurse -Force
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-    # Prime95
-    Write-Host "Extracting: Prime95"
-    try {
-      $ArgumentList = @(
-        "x", "$Temp\prime95_64.zip", "-o$Build\bin\amd64\Prime95",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      $ArgumentList = @(
-        "x", "$Temp\prime95_32.zip", "-o$Build\bin\x86\Prime95",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-    # ProduKey
-    try {
-      $ArgumentList = @(
-        "x", "$Temp\produkey64.zip", "-o$Build\bin\amd64\ProduKey",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      $ArgumentList = @(
-        "x", "$Temp\produkey32.zip", "-o$Build\bin\x86\ProduKey",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-    # Python (x64)
-    Write-Host "Extracting: Python (x64)"
-    try {
-      $ArgumentList = @(
-        "x", "$Temp\python64.zip", "-o$Build\bin\amd64\python",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      $ArgumentList = @(
-        "x", "$Temp\psutil64.whl", "-o$Build\bin\amd64\python",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-    try {
-      Copy-Item -Path "$HostSystem32\vcruntime140.dll" -Destination "$Build\bin\amd64\python\vcruntime140.dll" -Force
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to copy Visual C++ Runtime DLL." ) -ForegroundColor "Red"
-    }
-
-    # Python (x32)
-    Write-Host "Extracting: Python (x32)"
-    try {
-      $ArgumentList = @(
-        "x", "$Temp\python32.zip", "-o$Build\bin\x86\python",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      $ArgumentList = @(
-        "x", "$Temp\psutil32.whl", "-o$Build\bin\x86\python",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-    try {
-      Copy-Item -Path "$HostSysWOW64\vcruntime140.dll" -Destination "$Build\bin\x86\python\vcruntime140.dll" -Force
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to copy Visual C++ Runtime DLL." ) -ForegroundColor "Red"
-    }
-
-    # Q-Dir
-    Write-Host "Extracting: Q-Dir"
-    try {
-      $ArgumentList = @(
-        "x", "$Temp\qdir64.zip", "-o$Build\bin\amd64",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      Move-Item "$Build\bin\amd64\Q-Dir\Q-Dir_x64.exe" "$Build\bin\amd64\Q-Dir\Q-Dir.exe" -Force
-      $ArgumentList = @(
-        "x", "$Temp\qdir32.zip", "-o$Build\bin\x86",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-    # VirtIO Drivers
-    Write-Host "Extracting: VirtIO Drivers"
-    try {
-      $ArgumentList = @(
-        "e", "$Temp\virtio-win.iso", "-o$Build\Drivers\amd64\VirtIO",
-        "-aoa", "-bso0", "-bse0", "-bsp0",
-        "*\w10\amd64\*")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      $ArgumentList = @(
-        "e", "$Temp\virtio-win.iso", "-o$Build\Drivers\x86\VirtIO",
-        "-aoa", "-bso0", "-bse0", "-bsp0",
-        "*\w10\x86\*")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-    # wimlib-imagex
-    try {
-      $ArgumentList = @(
-        "x", "$Temp\wimlib64.zip", "-o$Build\bin\amd64\wimlib",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-      $ArgumentList = @(
-        "x", "$Temp\wimlib32.zip", "-o$Build\bin\x86\wimlib",
-        "-aoa", "-bso0", "-bse0", "-bsp0")
-      Start-Process -FilePath $SevenZip -ArgumentList $ArgumentList -NoNewWindow -Wait
-    }
-    catch {
-      Write-Host ("  ERROR: Failed to extract files." ) -ForegroundColor "Red"
-    }
-
-    ## Cleanup ##
-    if (Ask-User "Delete temp files?") {
-      Remove-Item "$Temp" -Recurse
-    }
-  }
-
-  ## Build ##
-  foreach ($Arch in @("amd64", "x86")) {
-    $Drivers = "$Build\Drivers\$Arch"
-    $Mount = "$Build\Mount"
-    $PEFiles = "$Build\PEFiles\$Arch"
-
-    # Copy WinPE files
-    Write-Host "Copying files..."
-    $Cmd = ("{0}\copype.cmd" -f $Env:WinPERoot)
-    Start-Process -FilePath $Cmd -ArgumentList @($Arch, $PEFiles) -NoNewWindow -Wait
-
-    # Remove unwanted items
-    foreach ($SubDir in @("media", "media\Boot", "media\EFI\Microsoft\Boot")) {
-      foreach ($Item in Get-ChildItem "$PEFiles\$SubDir") {
-        if ($Item.Name -inotmatch "^(boot|efi|en-us|sources|fonts|resources|bcd|memtest)") {
-          Remove-Item -Path $Item.FullName -Recurse -Force
-        }
-      }
-    }
-
-    # Mount image
-    Write-Host "Mounting image..."
-    New-Item -Path $Mount -ItemType "directory" -Force | Out-Null
-    Mount-WindowsImage -Path $Mount -ImagePath "$PEFiles\media\sources\boot.wim" -Index 1 -LogPath "$LogDir\DISM.log"
-
-    # Add drivers
-    Add-WindowsDriver -Path $Mount -Driver $Drivers -Recurse -LogPath "$LogDir\DISM.log"
-
-    # Add packages
-    Write-Host "Adding packages:"
-    $WinPEPackages = @(
-      "WinPE-EnhancedStorage",
-      "WinPE-FMAPI",
-      "WinPE-WMI",
-      "WinPE-SecureStartup"
-    )
-    foreach ($Package in $WinPEPackages) {
-      $PackagePath = ("{0}\{1}\WinPE_OCs\{2}.cab" -f $Env:WinPERoot, $Arch, $Package)
-      Write-Host "    $Package..."
-      Add-WindowsPackage –PackagePath $PackagePath –Path $Mount -LogPath "$LogDir\DISM.log"
-      $LangPackagePath = ("{0}\{1}\WinPE_OCs\en-us\{2}_en-us.cab" -f $Env:WinPERoot, $Arch, $Package)
-      if (Test-Path $LangPackagePath) {
-        Add-WindowsPackage –PackagePath $LangPackagePath –Path $Mount -LogPath "$LogDir\DISM.log"
-      }
-    }
-
-    # Set RamDisk size
-    $ArgumentList = @(
-      ('/Image:"{0}"' -f $Mount),
-      "/Set-ScratchSpace:512",
-      ('/LogPath:"{0}\DISM.log"' -f $LogDir)
-    )
-    Start-Process -FilePath $DISM -ArgumentList $ArgumentList -NoNewWindow -Wait
-
-    # Add tools
-    Write-Host "Copying tools..."
-    Copy-Item -Path "$Build\bin\$Arch" -Destination "$Mount\.bin" -Recurse -Force
-    Copy-Item -Path "$Root\.pe_items\_include\*" -Destination "$Mount\.bin" -Recurse -Force
-    if ($Arch -eq "amd64") {
-      $DestIni = "$Mount\.bin\HWiNFO\HWiNFO64.INI"
-    } else {
-      $DestIni = "$Mount\.bin\HWiNFO\HWiNFO32.INI"
-    }
-    Move-Item -Path "$Mount\.bin\HWiNFO\HWiNFO.INI" -Destination $DestIni -Force
-    Copy-Item -Path "$Root\Images\WinPE.jpg" -Destination "$Mount\.bin\ConEmu\ConEmu.jpg" -Recurse -Force
-    Copy-Item -Path "$Bin\Scripts" -Destination "$Mount\.bin\Scripts" -Recurse -Force
-    Copy-Item -Path "$Build\main.py" -Destination "$Mount\.bin\Scripts\settings\main.py" -Force
-
-    # Add System32 items
-    $HostSystem32 = "{0}\System32" -f $Env:SystemRoot
-    Copy-Item -Path "$Root\.pe_items\System32\*" -Destination "$Mount\Windows\System32" -Recurse -Force
-    $ArgumentList = @("/f", "$Mount\Windows\System32\winpe.jpg", "/a")
-    Start-Process -FilePath "$HostSystem32\takeown.exe" -ArgumentList $ArgumentList -NoNewWindow -Wait
-    $ArgumentList = @("$Mount\Windows\System32\winpe.jpg", "/grant", "Administrators:F")
-    Start-Process -FilePath "$HostSystem32\icacls.exe" -ArgumentList $ArgumentList -NoNewWindow -Wait
-    Copy-Item -Path "$Root\Images\WinPE.jpg" -Destination "$Mount\Windows\System32\winpe.jpg" -Recurse -Force
-
-    # Load registry hives
-    Write-Host "Updating Registry..."
-    $Reg = "$HostSystem32\reg.exe"
-    $ArgumentList = @("load", "HKLM\WinPE-SW", "$Mount\Windows\System32\config\SOFTWARE")
-    Start-Process -FilePath $Reg -ArgumentList $ArgumentList -NoNewWindow -Wait
-    $ArgumentList = @("load", "HKLM\WinPE-SYS", "$Mount\Windows\System32\config\SYSTEM")
-    Start-Process -FilePath $Reg -ArgumentList $ArgumentList -NoNewWindow -Wait
-
-    # Add tools to path
-    ## .NET code to properly handle REG_EXPAND_SZ values
-    ## Credit: https://www.sepago.com/blog/2013/08/22/reading-and-writing-regexpandsz-data-with-powershell
-    ## By: Marius Gawenda
-    $Hive = [Microsoft.Win32.Registry]::LocalMachine
-    $RegPath = "WinPE-SYS\ControlSet001\Control\Session Manager\Environment"
-    $RegKey = $Hive.OpenSubKey($RegPath)
-    $CurValue = $RegKey.GetValue(
-      "Path", $false, [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames)
-    $NewValue = "$CurValue;%SystemDrive%\.bin\7-Zip;%SystemDrive%\.bin\python;%SystemDrive%\.bin\wimlib"
-    Set-ItemProperty -Path "HKLM:\$RegPath" -Name "Path" -Value $NewValue -Force | Out-Null
-    $Hive.close()
-    $RegKey.close()
-
-    # Replace Notepad
-    $RegPath = "HKLM:\WinPE-SW\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\notepad.exe"
-    $NewValue = 'cmd /c "%SystemDrive%\.bin\NotepadPlusPlus\npp.cmd"'
-    New-Item -Path $RegPath -Force | Out-Null
-    New-ItemProperty -Path $RegPath -Name "Debugger" -Value $NewValue -Force | Out-Null
-
-    # Run garbage collection to release potential stale handles
-    ## Credit: https://jrich523.wordpress.com/2012/03/06/powershell-loading-and-unloading-registry-hives/
-    Start-Sleep -Seconds 2
-    [gc]::collect()
-
-    # Unload registry hives
-    Start-Sleep -Seconds 2
-    Start-Process -FilePath $Reg -ArgumentList @("unload", "HKLM\WinPE-SW") -NoNewWindow -Wait
-    Start-Process -FilePath $Reg -ArgumentList @("unload", "HKLM\WinPE-SYS") -NoNewWindow -Wait
-
-    # Unmount image
-    Write-Host "Dismounting image..."
-    Dismount-WindowsImage -Path $Mount -Save -LogPath "$LogDir\DISM.log"
-
-    # Create ISO
-    New-Item -Type Directory "$Root\OUT_PE" 2>&1 | Out-Null
-    $ArgumentList = @("/iso", $PEFiles, "$Root\OUT_PE\$KitNameShort-WinPE-$Date-$Arch.iso")
-    $Cmd = "{0}\MakeWinPEMedia.cmd" -f $Env:WinPERoot
-    Start-Process -FilePath $Cmd -ArgumentList $ArgumentList -NoNewWindow -Wait
-  }
-
-  ## Cleanup ##
-  Remove-Item -Path "$Build\Mount" -Recurse -Force
-  Remove-Item -Path "$Build\PEFiles" -Recurse -Force
-
-  ## Done ##
-  Pop-Location
-  Write-Host "`nDone."
-  WKPause "Press Enter to exit... "
-}

scripts/check_av.ps1

@@ -0,0 +1,13 @@
+# WizardKit: Check Antivirus
+
+#Requires -Version 3.0
+if (Test-Path Env:\DEBUG) {
+  Set-PSDebug -Trace 1
+}
+$Host.UI.RawUI.WindowTitle = "WizardKit: Check Antivirus"
+$Host.UI.RawUI.BackgroundColor = "black"
+$Host.UI.RawUI.ForegroundColor = "white"
+$ProgressPreference = "SilentlyContinue"
+
+# Main
+Get-CimInstance -Namespace "root\SecurityCenter2" -ClassName AntivirusProduct | select displayName,productState | ConvertTo-Json

scripts/check_disk.py

@@ -1,49 +0,0 @@
-"""Wizard Kit: Check or repair the %SYSTEMDRIVE% filesystem via CHKDSK"""
-# vim: sts=2 sw=2 ts=2
-
-import os
-import wk
-
-
-def main():
-  """Run or schedule CHKDSK and show result."""
-  title = f'{wk.cfg.main.KIT_NAME_FULL}: Check Disk Tool'
-  menu = wk.std.Menu(title=title)
-  try_print = wk.std.TryAndPrint()
-  wk.std.clear_screen()
-  wk.std.set_title(title)
-  print('')
-
-  # Add menu entries
-  menu.add_option('Offline scan')
-  menu.add_option('Online scan')
-
-  # Show menu and make selection
-  selection = menu.simple_select()
-
-  # Run or schedule scan
-  if 'Offline' in selection[0]:
-    function = wk.os.win.run_chkdsk_offline
-    msg_good = 'Scheduled'
-  else:
-    function = wk.os.win.run_chkdsk_online
-    msg_good = 'No issues detected'
-  try_print.run(
-    message=f'CHKDSK ({os.environ.get("SYSTEMDRIVE")})...',
-    function=function,
-    msg_good=msg_good,
-    )
-
-  # Done
-  print('')
-  print('Done.')
-  wk.std.pause('Press Enter to exit...')
-
-
-if __name__ == '__main__':
-  try:
-    main()
-  except SystemExit:
-    raise
-  except: #pylint: disable=bare-except
-    wk.std.major_exception()

scripts/check_partition_alignment.ps1

@@ -0,0 +1,13 @@
+# WizardKit: Check Partition Alignment
+
+#Requires -Version 3.0
+if (Test-Path Env:\DEBUG) {
+  Set-PSDebug -Trace 1
+}
+$Host.UI.RawUI.WindowTitle = "WizardKit: Check Partition Alignment"
+$Host.UI.RawUI.BackgroundColor = "black"
+$Host.UI.RawUI.ForegroundColor = "white"
+$ProgressPreference = "SilentlyContinue"
+
+# Main
+Get-CimInstance -Query "Select * from Win32_DiskPartition" | select Name,Size,StartingOffset | ConvertTo-Json

scripts/ddrescue-tui

@@ -1,15 +1,23 @@
 #!/bin/bash
 #
-## Wizard Kit: ddrescue TUI Launcher
+## WizardKit: ddrescue TUI Launcher
+
+__OS_NAME="$(uname -s)"
+if [[ "$__OS_NAME" == "Darwin" ]]; then
+  __OS_NAME="macOS"
+fi
+__NOTICE="This script is not fully supported under $__OS_NAME!
+
+Limitations:
+    Map files are saved to a RAM disk so you can't resume after a restart.
+    Only whole devices are supported.
+
+Press Enter to continue..."
 
 # Check if running under Linux
-os_name="$(uname -s)"
+if [[ "$__OS_NAME" != "Linux" ]]; then
-if [[ "$os_name" == "Darwin" ]]; then
+  echo "${__NOTICE}"
-  os_name="macOS"
+  read -r _dontcare
-fi
-if [[ "$os_name" != "Linux" ]]; then
-  echo "This script is not supported under $os_name." 1>&2
-  exit 1
 fi
 
 source launch-in-tmux

scripts/ddrescue-tui.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Wizard Kit: ddrescue TUI"""
+"""WizardKit: ddrescue TUI"""
 # vim: sts=2 sw=2 ts=2
 
 import wk
@@ -7,8 +7,8 @@ import wk
 
 if __name__ == '__main__':
   try:
-    wk.hw.ddrescue.main()
+    wk.clone.ddrescue.main()
   except SystemExit:
     raise
-  except: #pylint: disable=bare-except
+  except: # noqa: E722
-    wk.std.major_exception()
+    wk.ui.cli.major_exception()

scripts/disable_password_expiration.ps1

@@ -0,0 +1,13 @@
+# WizardKit: Disable Password Expiration (Local Accounts)
+
+#Requires -Version 3.0
+if (Test-Path Env:\DEBUG) {
+  Set-PSDebug -Trace 1
+}
+$Host.UI.RawUI.WindowTitle = "Disable Password Expiration"
+$Host.UI.RawUI.BackgroundColor = "black"
+$Host.UI.RawUI.ForegroundColor = "white"
+$ProgressPreference = "SilentlyContinue"
+
+# Main
+Get-LocalUser | Set-LocalUser -PasswordNeverExpires $true

scripts/echo-and-hold

@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-## Wizard Kit: "echo" text to screen and "hold" by waiting for user input
+## WizardKit: "echo" text to screen and "hold" by waiting for user input
 
 function usage {
     echo "Usage: $(basename "$0") \"text\""

scripts/embedded_python_env.py

@@ -0,0 +1,24 @@
+"""WizardKit: Embedded Python helper.
+
+This saves the keystrokes needed to fix the path and import wk. To use:
+python.exe -i embedded_python_env.py
+"""
+# vim: sts=2 sw=2 ts=2
+
+import pickle
+import wk
+
+
+# Functions
+def load_state():
+  with open('debug/state.pickle', 'rb') as f:
+    return pickle.load(f)
+
+
+# Main
+wk.ui.cli.print_colored(
+  (wk.cfg.main.KIT_NAME_FULL, ': ', 'Debug Console'),
+  ('GREEN', None, 'YELLOW'),
+  sep='',
+  )
+print('')

scripts/export_bitlocker.py

@@ -0,0 +1,6 @@
+"""WizardKit: Export Bitlocker Tool"""
+# vim: sts=2 sw=2 ts=2
+
+import wk
+
+wk.os.win.export_bitlocker_info()

scripts/get_raw_disks.ps1

@@ -0,0 +1,3 @@
+# WizardKit: Get RAW disks
+
+Get-Disk | Where-Object {$_.PartitionStyle -eq "RAW"} | Select FriendlyName,Size,PartitionStyle | ConvertTo-JSON

scripts/hw-diags

@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-## Wizard Kit: HW Diagnostics Launcher
+## WizardKit: HW Diagnostics Launcher
 
 source launch-in-tmux
 

scripts/hw-diags.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Wizard Kit: Hardware Diagnostics"""
+"""WizardKit: Hardware Diagnostics"""
 # vim: sts=2 sw=2 ts=2
 
 import wk
@@ -10,5 +10,5 @@ if __name__ == '__main__':
     wk.hw.diags.main()
   except SystemExit:
     raise
-  except: #pylint: disable=bare-except
+  except: # noqa: E722
-    wk.std.major_exception()
+    wk.ui.cli.major_exception()

scripts/hw-sensors

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Wizard Kit: Hardware Sensors"""
+"""WizardKit: Hardware Sensors"""
 # vim: sts=2 sw=2 ts=2
 
 import platform
@@ -7,15 +7,15 @@ import platform
 import wk
 
 
-def main():
+def main() -> None:
   """Show sensor data on screen."""
   sensors = wk.hw.sensors.Sensors()
   if platform.system() == 'Darwin':
-    wk.std.clear_screen()
+    wk.ui.cli.clear_screen()
     while True:
       print('\033[100A', end='')
       sensors.update_sensor_data()
-      wk.std.print_report(sensors.generate_report('Current', 'Max'))
+      wk.ui.cli.print_report(sensors.generate_report('Current', 'Max'))
       wk.std.sleep(1)
   elif platform.system() == 'Linux':
     proc = wk.exe.run_program(cmd=['mktemp'])
@@ -42,5 +42,5 @@ if __name__ == '__main__':
     pass
   except SystemExit:
     raise
-  except: #pylint: disable=bare-except
+  except: # noqa: E722
-    wk.std.major_exception()
+    wk.ui.cli.major_exception()

scripts/init_client_dir.cmd

@@ -1,4 +1,4 @@
-:: Wizard Kit: Create client_dir folder(s)
+:: WizardKit: Create client_dir folder(s)
 
 @echo off
 if defined DEBUG (@echo on)
@@ -26,7 +26,7 @@ set _minute=%_minute:~-2%
 set iso_date=%_yyyy%-%_mm%-%_dd%
 
 :SetVars
-set "SETTINGS=%bin%\Scripts\settings\main.py"
+set "SETTINGS=%bin%\Scripts\wk\cfg\main.py"
 for /f "tokens=* usebackq" %%f in (`findstr KIT_NAME_SHORT "%SETTINGS%"`) do (
   set "_v=%%f"
   set "_v=!_v:*'=!"

scripts/install_winget.ps1

@@ -0,0 +1,37 @@
+# WizardKit: Install winget (if needed)
+
+#Requires -Version 3.0
+if (Test-Path Env:\DEBUG) {
+  Set-PSDebug -Trace 1
+}
+$Host.UI.RawUI.WindowTitle = "WizardKit: Winget installer"
+$Host.UI.RawUI.BackgroundColor = "black"
+$Host.UI.RawUI.ForegroundColor = "white"
+$ProgressPreference = "SilentlyContinue"
+
+# STATIC VARIABLES
+$EXIT_OK = 0
+$EXIT_INSTALLED = 1
+$EXIT_FAILED_TO_INSTALL = 2
+
+# Main
+$NeedsInstalled = $false
+try {
+  $_ = $(winget --version)
+}
+catch {
+  $NeedsInstalled = $true
+}
+
+# Install
+if (! $NeedsInstalled) {
+  exit $EXIT_INSTALLED
+  }
+try {
+  Add-AppxPackage -ErrorAction Stop -RegisterByFamilyName -MainPackage Microsoft.DesktopAppInstaller_8wekyb3d8bbwe
+}
+catch {
+  exit $EXIT_FAILED_TO_INSTALL
+}
+
+exit $EXIT_OK

scripts/journal-datarec-monitor

@@ -0,0 +1,7 @@
+#!/bin/bash
+#
+## Monitor journal log for data recovery related events
+
+echo -e 'Monitoring journal output...\n'
+journalctl -kf \
+  | grep -Ei --color=always 'ata|nvme|scsi|sd[a..z]+|usb|comreset|critical|error'

scripts/launch-in-tmux

@@ -1,27 +1,27 @@
 #!/bin/bash
 #
-## Wizard Kit: TMUX Launcher
+## WizardKit: TMUX Launcher
 
 # Live macOS env workaround
 tmux_args=()
 if [[ -e "/.wk-live-macos" ]]; then
-  tmux_args=(-f "/etc/tmux.conf" -S "$(mktemp).socket")
+  tmux_args=(-f "/etc/tmux.conf" -S "/Volumes/RAM_Disk/.tmux.socket")
 fi
 
 function ask() {
-    while :; do
+  while :; do
-        read -p "$1 [Y/N] " -r answer
+    read -p "$1 [Y/N] " -r answer
-        if echo "$answer" | grep -Eiq '^(y|yes|sure)$'; then
+    if echo "$answer" | grep -Eiq '^(y|yes|sure)$'; then
-            return 0
+      return 0
-        elif echo "$answer" | grep -Eiq '^(n|no|nope)$'; then
+    elif echo "$answer" | grep -Eiq '^(n|no|nope)$'; then
-            return 1
+      return 1
-        fi
+    fi
-    done
+  done
 }
 
 function err () {
-    echo "$0:" "$@" >&2
+  echo "$0:" "$@" >&2
-    return 1
+  return 1
 }
 
 function launch_in_tmux() {
@@ -31,44 +31,44 @@ function launch_in_tmux() {
   [[ -n "${TMUX_CMD:-}" ]] || return $(err "Required variable missing (TMUX_CMD)")
 
   # Check for running session
-  if tmux "${tmux_args[@]}" list-session | grep -q "$SESSION_NAME"; then
+  if tmux "${tmux_args[@]}" list-session 2>&1 | grep -q "$SESSION_NAME"; then
-      echo "WARNING: tmux session $SESSION_NAME already exists."
+    echo "WARNING: tmux session $SESSION_NAME already exists."
-      echo ""
+    echo ""
-      if ask "Connect to current session?"; then
+    if ask "Connect to current session?"; then
-          if [[ -n "${TMUX:-}" ]]; then
+      if [[ -n "${TMUX:-}" ]]; then
-              # Running inside TMUX, switch to session
+        # Running inside TMUX, switch to session
-              tmux "${tmux_args[@]}" switch-client -t "$SESSION_NAME"
+        tmux "${tmux_args[@]}" switch-client -t "$SESSION_NAME"
-              if ! jobs %% >/dev/null 2>&1; then
+        if ! jobs %% >/dev/null 2>&1; then
-                # No running jobs, try exiting abandoned tmux session
+          # No running jobs, try exiting abandoned tmux session
-                exit 0
+          exit 0
-              fi
+        fi
-          else
-              # Running outside TMUX, attach to session
-              tmux "${tmux_args[@]}" attach-session -t "$SESSION_NAME"
-          fi
-          return 0
-      elif ask "Kill current session and start new session?"; then
-          tmux "${tmux_args[@]}" kill-session -t "$SESSION_NAME" || \
-              die "Failed to kill session: $SESSION_NAME"
       else
-          echo "Aborted."
+        # Running outside TMUX, attach to session
-          return 1
+        tmux "${tmux_args[@]}" attach-session -t "$SESSION_NAME"
       fi
+      return 0
+    elif ask "Kill current session and start new session?"; then
+      tmux "${tmux_args[@]}" kill-session -t "$SESSION_NAME" || \
+        die "Failed to kill session: $SESSION_NAME"
+    else
+      echo "Aborted."
+      return 1
+    fi
   fi
 
   # Start session
   if [[ -n "${TMUX:-}" ]]; then
-      # Running inside TMUX, save current session/window names
+    # Running inside TMUX, save current session/window names
-      ORIGINAL_SESSION_NAME="$(tmux "${tmux_args[@]}" display-message -p '#S')"
+    ORIGINAL_SESSION_NAME="$(tmux "${tmux_args[@]}" display-message -p '#S')"
-      ORIGINAL_WINDOW_NAME="$(tmux "${tmux_args[@]}" display-message -p '#W')"
+    ORIGINAL_WINDOW_NAME="$(tmux "${tmux_args[@]}" display-message -p '#W')"
-      tmux "${tmux_args[@]}" rename-session "$SESSION_NAME"
+    tmux "${tmux_args[@]}" rename-session "$SESSION_NAME"
-      tmux "${tmux_args[@]}" rename-window "$WINDOW_NAME"
+    tmux "${tmux_args[@]}" rename-window "$WINDOW_NAME"
-      "$TMUX_CMD" "$@"
+    "$TMUX_CMD" "$@"
-      # Restore previous session/window names
+    # Restore previous session/window names
-      tmux "${tmux_args[@]}" rename-session "${ORIGINAL_SESSION_NAME}"
+    tmux "${tmux_args[@]}" rename-session "${ORIGINAL_SESSION_NAME}"
-      tmux "${tmux_args[@]}" rename-window "${ORIGINAL_WINDOW_NAME}"
+    tmux "${tmux_args[@]}" rename-window "${ORIGINAL_WINDOW_NAME}"
   else
-      # Running outside TMUX, start/attach to session
+    # Running outside TMUX, start/attach to session
-      tmux "${tmux_args[@]}" new-session -s "$SESSION_NAME" -n "$WINDOW_NAME" "$TMUX_CMD" "$@"
+    tmux "${tmux_args[@]}" new-session -s "$SESSION_NAME" -n "$WINDOW_NAME" "$TMUX_CMD" "$@"
   fi
 }

scripts/launch_sdio.py

@@ -0,0 +1,99 @@
+"""WizardKit: Launch Snappy Driver Installer Origin"""
+# vim: sts=2 sw=2 ts=2
+
+from subprocess import CompletedProcess
+
+import wk
+from wk.cfg.net import SDIO_SERVER
+
+
+# STATIC VARIABLES
+MOUNT_EXCEPTIONS = (
+  RuntimeError,
+  wk.exe.subprocess.CalledProcessError,
+  )
+SDIO_LOCAL_PATH = wk.kit.tools.get_tool_path("SDIO", "SDIO")
+SDIO_REMOTE_PATH = wk.io.get_path_obj(
+  (
+    fr'\\{SDIO_SERVER["Address"]}\{SDIO_SERVER["Share"]}\{SDIO_SERVER["Path"]}'
+    fr'\SDIO{"64" if wk.os.win.ARCH == "64" else ""}.exe'
+    ),
+  resolve=False,
+  )
+
+# Functions
+def try_again() -> bool:
+  """Ask to try again or quit."""
+  if wk.ui.cli.ask('  Try again?'):
+    return True
+  if not wk.ui.cli.ask('  Use local version?'):
+    wk.ui.cli.abort()
+  return False
+
+
+def use_network_sdio() -> bool:
+  """Try to mount SDIO server."""
+  use_network = False
+  def _mount_server() -> CompletedProcess:
+    print('Connecting to server...  (Press CTRL+c to use local copy)')
+    return wk.net.mount_network_share(SDIO_SERVER, read_write=False)
+
+  # Bail early
+  if not SDIO_SERVER['Address']:
+    return use_network
+
+  # Main loop
+  while True:
+    try:
+      proc = _mount_server()
+    except KeyboardInterrupt:
+      break
+    except MOUNT_EXCEPTIONS as err:
+      wk.ui.cli.print_error(f'  {err}')
+      if not try_again():
+        break
+    else:
+      if proc.returncode == 0:
+        # Network copy available
+        use_network = True
+        break
+
+      # Failed to mount
+      wk.ui.cli.print_error('  Failed to mount server')
+      if not try_again():
+        break
+
+  # Done
+  return use_network
+
+
+if __name__ == '__main__':
+  wk.ui.cli.set_title(
+    f'{wk.cfg.main.KIT_NAME_FULL}: Snappy Driver Installer Origin Launcher',
+    )
+  log_dir = wk.log.format_log_path(tool=True).parent
+  USE_NETWORK = False
+
+  # Windows 11 workaround
+  if wk.os.win.OS_VERSION == 11:
+    appid_services = ['appid', 'appidsvc', 'applockerfltr']
+    for svc in appid_services:
+      wk.os.win.stop_service(svc)
+    if any([wk.os.win.get_service_status(s) != 'stopped' for s in appid_services]):
+      raise wk.std.GenericWarning('Failed to stop AppID services')
+
+  # Try to mount server
+  try:
+    USE_NETWORK = use_network_sdio()
+  except KeyboardInterrupt:
+    wk.ui.cli.abort()
+
+  # Run SDIO
+  EXE_PATH = SDIO_LOCAL_PATH
+  if USE_NETWORK:
+    EXE_PATH = SDIO_REMOTE_PATH
+    print('Using network copy!')
+  else:
+    print('Using local copy!')
+  cmd = [EXE_PATH, '-log_dir', log_dir]
+  wk.exe.run_program(cmd, check=False, cwd=EXE_PATH.parent)

scripts/max-cpu-temp

@@ -0,0 +1,67 @@
+#!/bin/env python3
+#
+
+import json
+import re
+import subprocess
+
+from typing import Any
+
+CPU_REGEX = re.compile(r'(core|k\d+)temp', re.IGNORECASE)
+NON_TEMP_REGEX = re.compile(r'^(fan|in|curr)', re.IGNORECASE)
+
+def get_data() -> dict[Any, Any]:
+  cmd = ('sensors', '-j')
+  data = {}
+  raw_data = []
+
+  try:
+    proc = subprocess.run(
+      args=cmd,
+      stdout=subprocess.PIPE,
+      stderr=subprocess.PIPE,
+      encoding='utf-8',
+      check=True,
+      )
+  except subprocess.CalledProcessError:
+    return data
+
+  for line in proc.stdout.splitlines():
+    if line.strip() == ',':
+      # Assuming malformatted line caused by missing data
+      continue
+    raw_data.append(line)
+
+  try:
+    data = json.loads('\n'.join(raw_data))
+  except json.JSONDecodeError:
+    # Still broken, just return the empty dict
+    pass
+
+  return data
+
+def get_max_temp(data) -> str:
+  cpu_temps = []
+  max_cpu_temp = '??° C'
+  for adapter, sources in data.items():
+    if not CPU_REGEX.search(adapter):
+      continue
+    sources.pop('Adapter', None)
+
+    for labels in sources.values():
+      for label, temp in sorted(labels.items()):
+        if 'input' not in label or NON_TEMP_REGEX.search(label):
+          continue
+        cpu_temps.append(temp)
+
+  # Format data
+  if cpu_temps:
+    max_cpu_temp = int(max(cpu_temps))
+    max_cpu_temp = f'{max_cpu_temp:02d}° C'
+
+  # Done
+  return max_cpu_temp
+
+if __name__ == '__main__':
+  sensor_data = get_data()
+  print(get_max_temp(sensor_data))

scripts/mount-all-volumes

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Wizard Kit: Mount all volumes"""
+"""WizardKit: Mount all volumes"""
 # vim: sts=2 sw=2 ts=2
 
 import sys
@@ -8,33 +8,34 @@ import wk
 
 
 # Functions
-def main():
+def main() -> None:
   """Mount all volumes and show results."""
-  wk.std.print_standard(f'{wk.cfg.main.KIT_NAME_FULL}: Volume mount tool')
+  wk.ui.cli.print_standard(f'{wk.cfg.main.KIT_NAME_FULL}: Volume mount tool')
-  wk.std.print_standard(' ')
+  wk.ui.cli.print_standard(' ')
 
   # Mount volumes and get report
-  wk.std.print_standard('Mounting volumes...')
+  wk.ui.cli.print_standard('Mounting volumes...')
-  report = wk.os.linux.mount_volumes()
+  wk.os.linux.mount_volumes()
+  report = wk.os.linux.build_volume_report()
 
   # Show results
-  wk.std.print_info('Results')
+  wk.ui.cli.print_info('Results')
-  wk.std.print_report(report, indent=2)
+  wk.ui.cli.print_report(report)
 
   # GUI mode
   if 'gui' in sys.argv:
-    wk.std.pause('Press Enter to exit...')
+    wk.ui.cli.pause('Press Enter to exit...')
     wk.exe.popen_program(['nohup', 'thunar', '/media'])
 
 
 if __name__ == '__main__':
   if wk.std.PLATFORM != 'Linux':
     os_name = wk.std.PLATFORM.replace('Darwin', 'macOS')
-    wk.std.print_error(f'This script is not supported under {os_name}.')
+    wk.ui.cli.print_error(f'This script is not supported under {os_name}.')
-    wk.std.abort()
+    wk.ui.cli.abort()
   try:
     main()
   except SystemExit:
     raise
-  except: #pylint: disable=bare-except
+  except: # noqa: E722
-    wk.std.major_exception()
+    wk.ui.cli.major_exception()

scripts/mount-backup-shares

@@ -1,15 +1,14 @@
 #!/usr/bin/env python3
-"""Wizard Kit: Mount Backup Shares"""
+"""WizardKit: Mount Backup Shares"""
-# pylint: disable=invalid-name
 # vim: sts=2 sw=2 ts=2
 
 import wk
 
 
 # Functions
-def main():
+def main() -> None:
   """Attempt to mount backup shares and print report."""
-  wk.std.print_info('Mounting Backup Shares')
+  wk.ui.cli.print_info('Mounting Backup Shares')
   report = wk.net.mount_backup_shares()
   for line in report:
     color = 'GREEN'
@@ -18,7 +17,7 @@ def main():
       color = 'RED'
     elif 'Already' in line:
       color = 'YELLOW'
-    print(wk.std.color_string(line, color))
+    print(wk.ansi.color_string(line, color))
 
 
 if __name__ == '__main__':
@@ -26,5 +25,5 @@ if __name__ == '__main__':
     main()
   except SystemExit:
     raise
-  except: #pylint: disable=bare-except
+  except: # noqa: E722
-    wk.std.major_exception()
+    wk.ui.cli.major_exception()

scripts/mount-raw-image

@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-## Wizard Kit: RAW image mounting tool
+## WizardKit: RAW image mounting tool
 
 set -o errexit
 set -o errtrace

scripts/msword-search

@@ -1,11 +1,13 @@
 #!/bin/python3
 #
-## Wizard Kit: MS Word content search tool
+## WizardKit: MS Word content search tool
 
 import os
 import re
 import sys
 
+import wk
+
 # STATIC VARIABLES
 SCANDIR = os.getcwd()
 USAGE = '''Usage: {script} <search-terms>...
@@ -13,12 +15,6 @@ USAGE = '''Usage: {script} <search-terms>...
 
   This script will search all doc/docx files below the current directory for
   the search-terms provided (case-insensitive).'''.format(script=__file__)
-
-# Init
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-from functions.network import *
-init_global_vars()
-
 REGEX_DOC_FILES = re.compile(r'\.docx?$', re.IGNORECASE)
 
 
@@ -34,10 +30,10 @@ def scan_file(file_path, search):
   match = False
   try:
     if entry.name.lower().endswith('.docx'):
-      result = run_program(['unzip', '-p', entry.path])
+      result = wk.exe.run_program(['unzip', '-p', entry.path])
     else:
       # Assuming .doc
-      result = run_program(['antiword', entry.path])
+      result = wk.exe.run_program(['antiword', entry.path])
     out = result.stdout.decode()
     match = re.search(search, out, re.IGNORECASE)
   except Exception:
@@ -50,13 +46,13 @@ def scan_file(file_path, search):
 if __name__ == '__main__':
   try:
     # Prep
-    clear_screen()
+    wk.ui.cli.clear_screen()
     terms = [re.sub(r'\s+', r'\s*', t) for t in sys.argv[1:]]
     search = '({})'.format('|'.join(terms))
 
     if len(sys.argv) == 1:
       # Print usage
-      print_standard(USAGE)
+      wk.ui.cli.print_standard(USAGE)
     else:
       matches = []
       for entry in scan_for_docs(SCANDIR):
@@ -64,21 +60,20 @@ if __name__ == '__main__':
       # Strip None values (i.e. non-matching entries)
       matches = [m for m in matches if m]
       if matches:
-        print_success('Found {} {}:'.format(
+        wk.ui.cli.print_success('Found {} {}:'.format(
           len(matches),
           'Matches' if len(matches) > 1 else 'Match'))
         for match in matches:
-          print_standard(match)
+          wk.ui.cli.print_standard(match)
       else:
-        print_error('No matches found.')
+        wk.ui.cli.print_error('No matches found.')
 
     # Done
-    print_standard('\nDone.')
+    wk.ui.cli.print_standard('\nDone.')
     #pause("Press Enter to exit...")
-    exit_script()
+  except SystemExit:
-  except SystemExit as sys_exit:
+    raise
-    exit_script(sys_exit.code)
+  except: # noqa: E722
-  except:
+    wk.ui.cli.major_exception()
-    major_exception()
 
 # vim: sts=2 sw=2 ts=2

scripts/numlock

@@ -0,0 +1,10 @@
+#!/bin/env bash
+#
+## Enable numlock if no battery is detected
+## Credit: https://wiki.archlinux.org/title/Activating_numlock_on_bootup#With_systemd_service
+
+if ! compgen -G "/sys/class/power_supply/BAT*" >/dev/null; then
+  for tty in /dev/tty{1..6}; do
+    /usr/bin/setleds -D +num < "$tty"
+  done
+fi

scripts/outer_scripts_to_review/check_disk.py

@@ -1,57 +0,0 @@
-# Wizard Kit: Check or repair the %SYSTEMDRIVE% filesystem via CHKDSK
-
-import os
-import sys
-
-# Init
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-from functions.repairs import *
-init_global_vars()
-os.system('title {}: Check Disk Tool'.format(KIT_NAME_FULL))
-set_log_file('Check Disk.log')
-
-if __name__ == '__main__':
-  try:
-    stay_awake()
-    clear_screen()
-    other_results = {
-      'Error': {
-        'CalledProcessError':   'Unknown Error',
-      },
-      'Warning': {
-        'GenericRepair':    'Repaired',
-        'UnsupportedOSError':   'Unsupported OS',
-      }}
-    options = [
-      {'Name': 'Run CHKDSK scan (read-only)', 'Repair': False},
-      {'Name': 'Schedule CHKDSK scan (offline repair)', 'Repair': True}]
-    actions = [{'Name': 'Quit', 'Letter': 'Q'}]
-    selection = menu_select(
-      '{}: Check Disk Menu\n'.format(KIT_NAME_FULL),
-      main_entries=options,
-      action_entries=actions)
-    print_info('{}: Check Disk Menu\n'.format(KIT_NAME_FULL))
-    if selection == 'Q':
-      abort()
-    elif selection.isnumeric():
-      repair = options[int(selection)-1]['Repair']
-      if repair:
-        cs = 'Scheduled'
-      else:
-        cs = 'No issues'
-      message = 'CHKDSK ({SYSTEMDRIVE})...'.format(**global_vars['Env'])
-      try_and_print(message=message, function=run_chkdsk,
-        cs=cs, other_results=other_results, repair=repair)
-    else:
-      abort()
-
-    # Done
-    print_success('Done.')
-    pause("Press Enter to exit...")
-    exit_script()
-  except SystemExit as sys_exit:
-    exit_script(sys_exit.code)
-  except:
-    major_exception()
-
-# vim: sts=2 sw=2 ts=2

scripts/outer_scripts_to_review/dism.py

@@ -1,58 +0,0 @@
-# Wizard Kit: Check or repair component store health via DISM
-
-import os
-import sys
-
-# Init
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-from functions.repairs import *
-init_global_vars()
-os.system('title {}: DISM helper Tool'.format(KIT_NAME_FULL))
-set_log_file('DISM Helper.log')
-
-if __name__ == '__main__':
-  try:
-    stay_awake()
-    clear_screen()
-    other_results = {
-      'Error': {
-        'CalledProcessError':   'Unknown Error',
-      },
-      'Warning': {
-        'GenericRepair':    'Repaired',
-        'UnsupportedOSError':   'Unsupported OS',
-      }}
-    disabled = bool(global_vars['OS']['Version'] not in ('8', '8.1', '10'))
-    options = [
-      {'Name': 'Check Health', 'Repair': False, 'Disabled': disabled},
-      {'Name': 'Restore Health', 'Repair': True, 'Disabled': disabled}]
-    actions = [{'Name': 'Quit', 'Letter': 'Q'}]
-    selection = menu_select(
-      '{}: DISM Menu\n'.format(KIT_NAME_FULL),
-      main_entries=options,
-      action_entries=actions)
-    print_info('{}: DISM Menu\n'.format(KIT_NAME_FULL))
-    if selection == 'Q':
-      abort()
-    elif selection.isnumeric():
-      repair = options[int(selection)-1]['Repair']
-      if repair:
-        message='DISM RestoreHealth...'
-      else:
-        message='DISM ScanHealth...'
-      try_and_print(message=message, function=run_dism,
-        cs='No corruption', ns='Corruption detected',
-        other_results=other_results, repair=repair)
-    else:
-      abort()
-
-    # Done
-    print_success('Done.')
-    pause("Press Enter to exit...")
-    exit_script()
-  except SystemExit as sys_exit:
-    exit_script(sys_exit.code)
-  except:
-    major_exception()
-
-# vim: sts=2 sw=2 ts=2

scripts/outer_scripts_to_review/install_sw_bundle.py

@@ -1,63 +0,0 @@
-# Wizard Kit: Install the standard SW bundle based on the OS version
-
-import os
-import sys
-
-# Init
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-from functions.setup import *
-init_global_vars()
-os.system('title {}: SW Bundle Tool'.format(KIT_NAME_FULL))
-set_log_file('Install SW Bundle.log')
-
-if __name__ == '__main__':
-  try:
-    stay_awake()
-    clear_screen()
-    print_info('{}: SW Bundle Tool\n'.format(KIT_NAME_FULL))
-    other_results = {
-      'Error': {
-        'CalledProcessError':   'Unknown Error',
-        'FileNotFoundError':  'File not found',
-      },
-      'Warning': {
-        'GenericRepair':    'Repaired',
-        'UnsupportedOSError':   'Unsupported OS',
-      }}
-    answer_extensions = ask('Install Extensions?')
-    answer_vcr = ask('Install Visual C++ Runtimes?')
-    answer_ninite = ask('Install Ninite Bundle?')
-    if answer_ninite and global_vars['OS']['Version'] in ['7']:
-      # Vista is dead, not going to check for it
-      answer_mse = ask('Install MSE?')
-    else:
-      answer_mse = False
-
-    print_info('Installing Programs')
-    if answer_vcr:
-      install_vcredists()
-    if answer_ninite:
-      result = try_and_print(message='Ninite bundle...',
-        function=install_ninite_bundle, cs='Started',
-        mse=answer_mse, other_results=other_results)
-      for proc in result['Out']:
-        # Wait for all processes to finish
-        proc.wait()
-    if answer_extensions:
-      print_info('Installing Extensions')
-      try_and_print(message='Classic Shell skin...',
-        function=install_classicstart_skin,
-        other_results=other_results)
-      try_and_print(message='Google Chrome extensions...',
-        function=install_chrome_extensions)
-      try_and_print(message='Mozilla Firefox extensions...',
-        function=install_firefox_extensions,
-        other_results=other_results)
-    print_standard('\nDone.')
-    exit_script()
-  except SystemExit as sys_exit:
-    exit_script(sys_exit.code)
-  except:
-    major_exception()
-
-# vim: sts=2 sw=2 ts=2

scripts/outer_scripts_to_review/install_vcredists.py

@@ -1,35 +0,0 @@
-# Wizard Kit: Install Visual C++ Runtimes
-
-import os
-import sys
-
-# Init
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-from functions.setup import *
-init_global_vars()
-os.system('title {}: Install Visual C++ Runtimes'.format(KIT_NAME_FULL))
-set_log_file('Install Visual C++ Runtimes.log')
-
-if __name__ == '__main__':
-  try:
-    stay_awake()
-    clear_screen()
-    print_info('{}: Install Visual C++ Runtimes\n'.format(KIT_NAME_FULL))
-    other_results = {
-      'Error': {
-        'CalledProcessError':   'Unknown Error',
-      }}
-
-    if ask('Install Visual C++ Runtimes?'):
-      install_vcredists()
-    else:
-      abort()
-
-    print_standard('\nDone.')
-    exit_script()
-  except SystemExit as sys_exit:
-    exit_script(sys_exit.code)
-  except:
-    major_exception()
-
-# vim: sts=2 sw=2 ts=2

scripts/outer_scripts_to_review/system_diagnostics.py

@@ -1,173 +0,0 @@
-# Wizard Kit: System Diagnostics
-
-import os
-import sys
-
-# Init
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-from functions.browsers import *
-from functions.info import *
-from functions.product_keys import *
-from functions.repairs import *
-from functions.sw_diags import *
-init_global_vars()
-os.system('title {}: System Diagnostics Tool'.format(KIT_NAME_FULL))
-set_log_file('System Diagnostics.log')
-
-# Static Variables
-BLEACH_BIT_CLEANERS = {
-  'Applications': (
-    'adobe_reader.cache',
-    'adobe_reader.tmp',
-    'amule.tmp',
-    'flash.cache',
-    'gimp.tmp',
-    'hippo_opensim_viewer.cache',
-    'java.cache',
-    'libreoffice.cache',
-    'liferea.cache',
-    'miro.cache',
-    'openofficeorg.cache',
-    'pidgin.cache',
-    'secondlife_viewer.Cache',
-    'thunderbird.cache',
-    'vuze.backup_files',
-    'vuze.cache',
-    'vuze.tmp',
-    'yahoo_messenger.cache',
-  ),
-  'Browsers': (
-    'chromium.cache',
-    'chromium.current_session',
-    'firefox.cache',
-    'firefox.session_restore',
-    'google_chrome.cache',
-    'google_chrome.session',
-    'google_earth.temporary_files',
-    'internet_explorer.temporary_files',
-    'opera.cache',
-    'opera.current_session',
-    'safari.cache',
-    'seamonkey.cache',
-  ),
-  'System': (
-    'system.clipboard',
-    'system.tmp',
-    'winapp2_windows.jump_lists',
-    'winapp2_windows.ms_search',
-    'windows_explorer.run',
-    'windows_explorer.search_history',
-    'windows_explorer.thumbnails',
-  ),
-}
-
-if __name__ == '__main__':
-  try:
-    stay_awake()
-    clear_screen()
-    print_info('{}: System Diagnostics Tool\n'.format(KIT_NAME_FULL))
-    ticket_number = get_ticket_number()
-    other_results = {
-      'Error': {
-        'CalledProcessError':   'Unknown Error',
-        'FileNotFoundError':  'File not found',
-      },
-      'Warning': {
-        'GenericRepair':    'Repaired',
-        'UnsupportedOSError':   'Unsupported OS',
-      }}
-    if ENABLED_TICKET_NUMBERS:
-      print_info('Starting System Diagnostics for Ticket #{}\n'.format(
-        ticket_number))
-
-    # Sanitize Environment
-    print_info('Sanitizing Environment')
-    try_and_print(message='Running RKill...',
-      function=run_rkill, cs='Done', other_results=other_results)
-    try_and_print(message='Running TDSSKiller...',
-      function=run_tdsskiller, cs='Done', other_results=other_results)
-
-    # Re-run if earlier process was stopped.
-    stay_awake()
-
-    # Start diags
-    print_info('Starting Background Scans')
-    check_connection()
-    try_and_print(message='Running HitmanPro...',
-      function=run_hitmanpro, cs='Started', other_results=other_results)
-    try_and_print(message='Running Autoruns...',
-      function=run_autoruns, cs='Started', other_results=other_results)
-
-    # OS Health Checks
-    print_info('OS Health Checks')
-    try_and_print(
-      message='CHKDSK ({SYSTEMDRIVE})...'.format(**global_vars['Env']),
-      function=run_chkdsk, other_results=other_results)
-    try_and_print(message='SFC scan...',
-      function=run_sfc_scan, other_results=other_results)
-    try_and_print(message='DISM CheckHealth...',
-      function=run_dism, other_results=other_results, repair=False)
-
-    # Scan for supported browsers
-    print_info('Scanning for browsers')
-    scan_for_browsers()
-
-    # Run BleachBit cleaners
-    print_info('BleachBit Cleanup')
-    for k, v in sorted(BLEACH_BIT_CLEANERS.items()):
-      try_and_print(message='  {}...'.format(k),
-        function=run_bleachbit,
-        cs='Done', other_results=other_results,
-        cleaners=v, preview=True)
-
-    # Export system info
-    print_info('Backup System Information')
-    try_and_print(message='AIDA64 reports...',
-      function=run_aida64, cs='Done', other_results=other_results)
-    backup_browsers()
-    try_and_print(message='File listing...',
-      function=backup_file_list, cs='Done', other_results=other_results)
-    try_and_print(message='Power plans...',
-      function=backup_power_plans, cs='Done')
-    try_and_print(message='Product Keys...',
-      function=run_produkey, cs='Done', other_results=other_results)
-    try_and_print(message='Registry...',
-      function=backup_registry, cs='Done', other_results=other_results)
-
-    # Summary
-    print_info('Summary')
-    try_and_print(message='Operating System:',
-      function=show_os_name, ns='Unknown', silent_function=False)
-    try_and_print(message='Activation:',
-      function=show_os_activation, ns='Unknown', silent_function=False)
-    try_and_print(message='Installed RAM:',
-      function=show_installed_ram, ns='Unknown', silent_function=False)
-    show_free_space()
-    try_and_print(message='Temp Size:',
-      function=show_temp_files_size, silent_function=False)
-    try_and_print(message='Installed Antivirus:',
-      function=get_installed_antivirus, ns='Unknown',
-      other_results=other_results, print_return=True)
-    try_and_print(message='Installed Office:',
-      function=get_installed_office, ns='Unknown',
-      other_results=other_results, print_return=True)
-    try_and_print(message='Product Keys:',
-      function=get_product_keys, ns='Unknown', print_return=True)
-
-    # User data
-    print_info('User Data')
-    try:
-      show_user_data_summary()
-    except Exception:
-      print_error('  Unknown error.')
-
-    # Done
-    print_standard('\nDone.')
-    pause('Press Enter to exit...')
-    exit_script()
-  except SystemExit as sys_exit:
-    exit_script(sys_exit.code)
-  except:
-    major_exception()
-
-# vim: sts=2 sw=2 ts=2

scripts/outer_scripts_to_review/system_setup.py

@@ -1,355 +0,0 @@
-'''Wizard Kit: System Setup'''
-# pylint: disable=wildcard-import,wrong-import-position
-# vim: sts=2 sw=2 ts=2
-
-import os
-import sys
-
-# Init
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-from collections import OrderedDict
-from functions.activation import *
-from functions.browsers import *
-from functions.cleanup import *
-from functions.info import *
-from functions.product_keys import *
-from functions.setup import *
-from functions.sw_diags import *
-from functions.windows_updates import *
-init_global_vars()
-os.system('title {}: System Setup'.format(KIT_NAME_FULL))
-set_log_file('System Setup.log')
-
-
-# STATIC VARIABLES
-# pylint: disable=bad-whitespace,line-too-long
-OTHER_RESULTS = {
-  'Error': {
-    'BIOSKeyNotFoundError':     'BIOS KEY NOT FOUND',
-    'CalledProcessError':       'UNKNOWN ERROR',
-    'FileNotFoundError':        'FILE NOT FOUND',
-    'GenericError':             'UNKNOWN ERROR',
-    'Not4KAlignedError':        'FALSE',
-    'SecureBootDisabledError':  'DISABLED',
-    'WindowsUnsupportedError':  'UNSUPPORTED',
-  },
-  'Warning': {
-    'GenericRepair':            'REPAIRED',
-    'NoProfilesError':          'NO PROFILES FOUND',
-    'NotInstalledError':        'NOT INSTALLED',
-    'OSInstalledLegacyError':   'OS INSTALLED LEGACY',
-    'SecureBootNotAvailError':  'NOT AVAILABLE',
-    'SecureBootUnknownError':   'UNKNOWN',
-    'UnsupportedOSError':       'UNSUPPORTED OS',
-    'WindowsOutdatedError':     'OUTDATED',
-    },
-  }
-SETUP_ACTIONS = OrderedDict({
-  # Install software
-  'Installing Programs':    {'Info': True},
-  'VCR':                    {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': install_vcredists, 'Just run': True,},
-  'LibreOffice':            {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': install_libreoffice,
-                             'If answer': 'LibreOffice', 'KWArgs': {'quickstart': False, 'register_mso_types': True, 'use_mso_formats': False, 'vcredist': False},
-                             },
-  'Ninite bundle':          {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': install_ninite_bundle, 'KWArgs': {'cs': 'STARTED'},},
-
-  # Browsers
-  'Scanning for browsers':  {'Info': True},
-  'Scan':                   {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': scan_for_browsers, 'Just run': True, 'KWArgs': {'skip_ie': True},},
-  'Backing up browsers':    {'Info': True},
-  'Backup browsers':        {'New': False,  'Dat': True,  'Cur': True,  'HW': False, 'Function': backup_browsers, 'Just run': True,},
-
-  # Install extensions
-  'Installing Extensions':  {'Info': True},
-  'Classic Shell skin':     {'New': True,   'Dat': True,  'Cur': False, 'HW': False, 'Function': install_classicstart_skin, 'Win10 only': True,},
-  'Chrome extensions':      {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': install_chrome_extensions,},
-  'Firefox extensions':     {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': install_firefox_extensions,},
-
-  # Configure software'
-  'Configuring Programs':   {'Info': True},
-  'Browser add-ons':        {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': install_adblock, 'Just run': True,
-                             'Pause': 'Please enable uBlock Origin for all browsers',
-                             },
-  'Classic Start':          {'New': True,   'Dat': True,  'Cur': False, 'HW': False, 'Function': config_classicstart, 'Win10 only': True,},
-  'Config Windows Updates': {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': config_windows_updates, 'Win10 only': True,},
-  'Enable Windows Updates': {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': enable_windows_updates, 'KWArgs': {'silent': True},},
-  'Explorer (system)':      {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': config_explorer_system, 'Win10 only': True,},
-  'Explorer (user)':        {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': config_explorer_user, 'Win10 only': True,},
-  'Restart Explorer':       {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': restart_explorer,},
-  'Restore default UAC':    {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': restore_default_uac,},
-  'Update Clock':           {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': update_clock,},
-
-  # Cleanup
-  'Cleaning up':            {'Info': True},
-  'AdwCleaner':             {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': cleanup_adwcleaner,},
-  'Desktop':                {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': cleanup_desktop,},
-  'KIT_NAME_FULL':          {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': delete_empty_folders,},
-
-  # System Info
-  'Exporting system info':  {'Info': True},
-  'AIDA64 Report':          {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': run_aida64,},
-  'File listing':           {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': backup_file_list,},
-  'Power plans':            {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': backup_power_plans,},
-  'Product Keys':           {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': run_produkey,},
-  'Registry':               {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': backup_registry,},
-
-  # Show Summary
-  'Summary':                {'Info': True},
-  'Operating System':       {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': show_os_name, 'KWArgs': {'ns': 'UNKNOWN', 'silent_function': False},},
-  'Activation':             {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': show_os_activation, 'KWArgs': {'ns': 'UNKNOWN', 'silent_function': False},},
-  'BIOS Activation':        {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': activate_with_bios, 'If not activated': True,},
-  'Secure Boot':            {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': check_secure_boot_status, 'KWArgs': {'show_alert': False},},
-  'Installed RAM':          {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': show_installed_ram, 'KWArgs': {'ns': 'UNKNOWN', 'silent_function': False},},
-  'Temp size':              {'New': False,  'Dat': False, 'Cur': True,  'HW': False, 'Function': show_temp_files_size, 'KWArgs': {'ns': 'UNKNOWN', 'silent_function': False},},
-  'Show free space':        {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': show_free_space, 'Just run': True,},
-  'Installed AV':           {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': get_installed_antivirus, 'KWArgs': {'ns': 'UNKNOWN', 'print_return': True},},
-  'Installed Office':       {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': get_installed_office, 'KWArgs': {'ns': 'UNKNOWN', 'print_return': True},},
-  'Partitions 4K aligned':  {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': check_4k_alignment, 'KWArgs': {'cs': 'TRUE', 'ns': 'FALSE'},},
-
-  # Open things
-  'Opening Programs':       {'Info': True},
-  'Device Manager':         {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': open_device_manager, 'KWArgs': {'cs': 'STARTED'},},
-  'HWiNFO sensors':         {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': run_hwinfo_sensors, 'KWArgs': {'cs': 'STARTED'},},
-  'Speed test':             {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': open_speedtest, 'KWArgs': {'cs': 'STARTED'},},
-  'Windows Updates':        {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': open_windows_updates, 'KWArgs': {'cs': 'STARTED'},},
-  'Windows Activation':     {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Function': open_windows_activation, 'If not activated': True, 'KWArgs': {'cs': 'STARTED'},},
-  'Sleep':                  {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': sleep, 'Just run': True, 'KWArgs': {'seconds': 3},},
-  'XMPlay':                 {'New': True,   'Dat': True,  'Cur': True,  'HW': True,  'Function': run_xmplay, 'KWArgs': {'cs': 'STARTED'},},
-  })
-SETUP_ACTION_KEYS = (
-  'Function',
-  'If not activated',
-  'Info',
-  'Just run',
-  'KWArgs',
-  'Pause',
-  )
-SETUP_QUESTIONS = {
-  # AV
-  'MSE':          {'New': None,   'Dat': None,  'Cur': None,  'HW': False, 'Ninite': True},
-
-  # LibreOffice
-  'LibreOffice':  {'New': None,   'Dat': None,  'Cur': None,  'HW': False, 'Ninite': True},
-
-  # Ninite
-  'Base':         {'New': True,   'Dat': True,  'Cur': True,  'HW': False, 'Ninite': True},
-  'Missing':      {'New': False,  'Dat': True,  'Cur': False, 'HW': False, 'Ninite': True},
-  'Standard':     {'New': True,   'Dat': True,  'Cur': False, 'HW': False, 'Ninite': True},
-  }
-# pylint: enable=bad-whitespace,line-too-long
-
-
-# Functions
-def check_os_and_abort():
-  """Check OS and prompt to abort if not supported."""
-  result = try_and_print(
-    message='OS support status...',
-    function=check_os_support_status,
-    cs='GOOD',
-    )
-  if not result['CS'] and 'Unsupported' in result['Error']:
-    print_warning('OS version not supported by this script')
-    if not ask('Continue anyway? (NOT RECOMMENDED)'):
-      abort()
-
-
-def get_actions(setup_mode, answers):
-  """Get actions to perform based on setup_mode, returns OrderedDict."""
-  actions = OrderedDict({})
-  for _key, _val in SETUP_ACTIONS.items():
-    _action = {}
-    _if_answer = _val.get('If answer', False)
-    _win10_only = _val.get('Win10 only', False)
-
-    # Set enabled status
-    _enabled = _val.get(setup_mode, False)
-    if _if_answer:
-      _enabled = _enabled and answers[_if_answer]
-    if _win10_only:
-      _enabled = _enabled and global_vars['OS']['Version'] == '10'
-    _action['Enabled'] = _enabled
-
-    # Set other keys
-    for _sub_key in SETUP_ACTION_KEYS:
-      _action[_sub_key] = _val.get(_sub_key, None)
-
-    # Fix KWArgs
-    if _action.get('KWArgs', {}) is None:
-      _action['KWArgs'] = {}
-
-    # Handle "special" actions
-    if _key == 'KIT_NAME_FULL':
-      # Cleanup WK folders
-      _key = KIT_NAME_FULL
-      _action['KWArgs'] = {'folder_path': global_vars['ClientDir']}
-    elif _key == 'Ninite bundle':
-      # Add install_ninite_bundle() kwargs
-      _action['KWArgs'].update({
-        kw.lower(): kv for kw, kv in answers.items()
-        if SETUP_QUESTIONS.get(kw, {}).get('Ninite', False)
-        })
-    elif _key == 'Explorer (user)':
-      # Explorer settings (user)
-      _action['KWArgs'] = {'setup_mode': setup_mode}
-
-    # Add to dict
-    actions[_key] = _action
-
-  return actions
-
-
-def get_answers(setup_mode):
-  """Get setup answers based on setup_mode and user input, returns dict."""
-  answers = {k: v.get(setup_mode, False) for k, v in SETUP_QUESTIONS.items()}
-
-  # Answer setup questions as needed
-  if answers['MSE'] is None and global_vars['OS']['Version'] == '7':
-    answers.update(get_av_selection())
-
-  if answers['LibreOffice'] is None:
-    answers['LibreOffice'] = ask('Install LibreOffice?')
-
-  return answers
-
-
-def get_av_selection():
-  """Get AV selection."""
-  av_answers = {
-    'MSE': False,
-    }
-  av_options = [
-    {
-      'Name': 'Microsoft Security Essentials',
-      'Disabled': global_vars['OS']['Version'] not in ['7'],
-      },
-    ]
-  actions = [
-    {'Name': 'None', 'Letter': 'N'},
-    {'Name': 'Quit', 'Letter': 'Q'},
-    ]
-
-  # Show menu
-  selection = menu_select(
-    'Please select an option to install',
-    main_entries=av_options,
-    action_entries=actions)
-  if selection.isnumeric():
-    index = int(selection) - 1
-    if 'Microsoft' in av_options[index]['Name']:
-      av_answers['MSE'] = True
-  elif selection == 'Q':
-    abort()
-
-  return av_answers
-
-
-def get_mode():
-  """Get mode via menu_select, returns str."""
-  setup_mode = None
-  mode_options = [
-    {'Name': 'New', 'Display Name': 'New / Clean install (no data)'},
-    {'Name': 'Dat', 'Display Name': 'Clean install with data migration'},
-    {'Name': 'Cur', 'Display Name': 'Original OS (post-repair or overinstall)'},
-    {'Name': 'HW', 'Display Name': 'Hardware service (i.e. no software work)'},
-    ]
-  actions = [
-    {'Name': 'Quit', 'Letter': 'Q'},
-    ]
-
-  # Get selection
-  selection = menu_select(
-    'Please select a setup mode',
-    main_entries=mode_options,
-    action_entries=actions)
-  if selection.isnumeric():
-    index = int(selection) - 1
-    setup_mode = mode_options[index]['Name']
-  elif selection == 'Q':
-    abort()
-
-  return setup_mode
-
-
-def main():
-  """Main function."""
-  stay_awake()
-  clear_screen()
-
-  # Check installed OS
-  check_os_and_abort()
-
-  # Get setup mode
-  setup_mode = get_mode()
-
-  # Get answers to setup questions
-  answers = get_answers(setup_mode)
-
-  # Get actions to perform
-  actions = get_actions(setup_mode, answers)
-
-  # Perform actions
-  for action, values in actions.items():
-    kwargs = values.get('KWArgs', {})
-
-    # Print info lines
-    if values.get('Info', False):
-      print_info(action)
-      continue
-
-    # Print disabled actions
-    if not values.get('Enabled', False):
-      show_data(
-        message='{}...'.format(action),
-        data='DISABLED',
-        warning=True,
-        )
-      continue
-
-    # Check Windows activation if requested
-    if values.get('If not activated', False) and windows_is_activated():
-      # Skip
-      continue
-
-    # Run function
-    if values.get('Just run', False):
-      values['Function'](**kwargs)
-    else:
-      result = try_and_print(
-        message='{}...'.format(action),
-        function=values['Function'],
-        other_results=OTHER_RESULTS,
-        **kwargs)
-
-    # Wait for Ninite proc(s)
-    if action == 'Ninite bundle':
-      print_standard('Waiting for installations to finish...')
-      try:
-        for proc in result['Out']:
-          proc.wait()
-      except KeyboardInterrupt:
-        pass
-
-    # Pause
-    if values.get('Pause', False):
-      print_standard(values['Pause'])
-      pause()
-
-  # Show alert box for SecureBoot issues
-  try:
-    check_secure_boot_status(show_alert=True)
-  except Exception: # pylint: disable=broad-except
-    # Ignoring exceptions since we just want to show the popup
-    pass
-
-  # Done
-  pause('Press Enter to exit... ')
-
-
-if __name__ == '__main__':
-  try:
-    main()
-    exit_script()
-  except SystemExit as sys_exit:
-    exit_script(sys_exit.code)
-  except: # pylint: disable=bare-except
-    major_exception()

scripts/outer_scripts_to_review/transferred_keys.py

@@ -1,29 +0,0 @@
-# Wizard Kit: Search for product keys in the transfer folder
-
-import os
-import sys
-
-# Init
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-from functions.product_keys import *
-init_global_vars()
-os.system('title {}: Transferred Key Finder'.format(KIT_NAME_FULL))
-set_log_file('Transferred Keys.log')
-
-if __name__ == '__main__':
-  try:
-    stay_awake()
-    clear_screen()
-    print_info('{}: Transferred Key Finder\n'.format(KIT_NAME_FULL))
-    try_and_print(message='Searching for keys...',
-      function=list_clientdir_keys, print_return=True)
-
-    # Done
-    print_standard('\nDone.')
-    exit_script()
-  except SystemExit as sys_exit:
-    exit_script(sys_exit.code)
-  except:
-    major_exception()
-
-# vim: sts=2 sw=2 ts=2

scripts/outer_scripts_to_review/update_kit.py

@@ -1,143 +0,0 @@
-# Wizard Kit: Download the latest versions of the programs in the kit
-
-import os
-import sys
-
-# Init
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-from functions.update import *
-init_global_vars()
-os.system('title {}: Kit Update Tool'.format(KIT_NAME_FULL))
-
-if __name__ == '__main__':
-  try:
-    clear_screen()
-    print_info('{}: Kit Update Tool\n'.format(KIT_NAME_FULL))
-    other_results = {
-      'Error': {
-        'CalledProcessError': 'Unknown Error',
-      }}
-
-    ## Prep ##
-    update_sdio = ask('Update SDI Origin?')
-
-    ## Download ##
-    print_success('Downloading tools')
-
-    # Data Recovery
-    print_info('  Data Recovery')
-    try_and_print(message='TestDisk / PhotoRec...', function=update_testdisk, other_results=other_results, width=40)
-
-    # Data Transfers
-    print_info('  Data Transfers')
-    try_and_print(message='FastCopy...', function=update_fastcopy, other_results=other_results, width=40)
-    try_and_print(message='wimlib...', function=update_wimlib, other_results=other_results, width=40)
-    try_and_print(message='XYplorer...', function=update_xyplorer, other_results=other_results, width=40)
-
-    # Diagnostics
-    print_info('  Diagnostics')
-    try_and_print(message='AIDA64...', function=update_aida64, other_results=other_results, width=40)
-    try_and_print(message='Autoruns...', function=update_autoruns, other_results=other_results, width=40)
-    try_and_print(message='BleachBit...', function=update_bleachbit, other_results=other_results, width=40)
-    try_and_print(message='Blue Screen View...', function=update_bluescreenview, other_results=other_results, width=40)
-    try_and_print(message='ERUNT...', function=update_erunt, other_results=other_results, width=40)
-    try_and_print(message='Hitman Pro...', function=update_hitmanpro, other_results=other_results, width=40)
-    try_and_print(message='HWiNFO...', function=update_hwinfo, other_results=other_results, width=40)
-    try_and_print(message='NirCmd...', function=update_nircmd, other_results=other_results, width=40)
-    try_and_print(message='ProduKey...', function=update_produkey, other_results=other_results, width=40)
-
-    # Drivers
-    print_info('  Drivers')
-    try_and_print(message='Intel RST...', function=update_intel_rst, other_results=other_results, width=40)
-    try_and_print(message='Intel SSD Toolbox...', function=update_intel_ssd_toolbox, other_results=other_results, width=40)
-    try_and_print(message='Samsing Magician...', function=update_samsung_magician, other_results=other_results, width=40)
-    if update_sdio:
-      try_and_print(message='Snappy Driver Installer Origin...', function=update_sdi_origin, other_results=other_results, width=40)
-
-    # Installers
-    print_info('  Installers')
-    try_and_print(message='Adobe Reader DC...', function=update_adobe_reader_dc, other_results=other_results, width=40)
-    try_and_print(message='LibreOffice...', function=update_libreoffice, other_results=other_results, width=40)
-    try_and_print(message='Macs Fan Control...', function=update_macs_fan_control, other_results=other_results, width=40)
-    try_and_print(message='MS Office...', function=update_office, other_results=other_results, width=40)
-    try_and_print(message='Visual C++ Runtimes...', function=update_vcredists, other_results=other_results, width=40)
-    try_and_print(message='Windows Updates...', function=download_windows_updates, other_results=other_results, width=40)
-    update_all_ninite(other_results=other_results, width=40)
-
-    # Misc
-    print_info('  Misc')
-    try_and_print(message='Caffeine...', function=update_caffeine, other_results=other_results, width=40)
-    try_and_print(message='Classic Start Skin...', function=update_classic_start_skin, other_results=other_results, width=40)
-    try_and_print(message='Du...', function=update_du, other_results=other_results, width=40)
-    try_and_print(message='Everything...', function=update_everything, other_results=other_results, width=40)
-    try_and_print(message='Firefox Extensions...', function=update_firefox_ublock_origin, other_results=other_results, width=40)
-    try_and_print(message='PuTTY...', function=update_putty, other_results=other_results, width=40)
-    try_and_print(message='Notepad++...', function=update_notepadplusplus, other_results=other_results, width=40)
-    try_and_print(message='WizTree...', function=update_wiztree, other_results=other_results, width=40)
-    try_and_print(message='XMPlay...', function=update_xmplay, other_results=other_results, width=40)
-
-    # Repairs
-    print_info('  Repairs')
-    try_and_print(message='AdwCleaner...', function=update_adwcleaner, other_results=other_results, width=40)
-    try_and_print(message='KVRT...', function=update_kvrt, other_results=other_results, width=40)
-    try_and_print(message='RKill...', function=update_rkill, other_results=other_results, width=40)
-    try_and_print(message='TDSS Killer...', function=update_tdsskiller, other_results=other_results, width=40)
-
-    # Uninstallers
-    print_info('  Uninstallers')
-    try_and_print(message='IObit Uninstaller...', function=update_iobit_uninstaller, other_results=other_results, width=40)
-
-    ## Review ##
-    print_standard('Please review the results and download/extract any missing items to .cbin')
-    pause('Press Enter to compress the .cbin items')
-
-    ## Compress ##
-    print_success('Compressing tools')
-    print_info('  _Drivers')
-    for item in os.scandir(r'{}\_Drivers'.format(global_vars['CBinDir'])):
-      if not re.search(r'^(_Drivers|.*7z)$', item.name, re.IGNORECASE):
-        try_and_print(
-          message='{}...'.format(item.name),
-          function=compress_and_remove_item,
-          other_results = other_results,
-          width=40,
-          item = item)
-    print_info('  .cbin')
-    for item in os.scandir(global_vars['CBinDir']):
-      if not re.search(r'^(_Drivers|_include|.*7z)$', item.name, re.IGNORECASE):
-        try_and_print(
-          message='{}...'.format(item.name),
-          function=compress_and_remove_item,
-          other_results = other_results,
-          width=40,
-          item = item)
-
-    ## Generate Launchers
-    print_success('Generating launchers')
-    for section in sorted(LAUNCHERS.keys()):
-      print_info('  {}'.format(section))
-      for name, options in sorted(LAUNCHERS[section].items()):
-        try_and_print(message=name, function=generate_launcher,
-          section=section, name=name, options=options,
-          other_results=other_results, width=40)
-
-    # Rename "Copy WizardKit.cmd" (if necessary)
-    source = r'{}\Scripts\Copy WizardKit.cmd'.format(global_vars['BinDir'])
-    dest = r'{}\Copy {}.cmd'.format(global_vars['BaseDir'], KIT_NAME_FULL)
-    if os.path.exists(source):
-      try:
-        shutil.move(source, dest)
-      except Exception:
-        print_error('  Failed to rename "{}.cmd" to "{}.cmd"'.format(
-          'Copy WizardKit', KIT_NAME_FULL))
-
-    # Done
-    print_standard('\nDone.')
-    pause("Press Enter to exit...")
-    exit_script()
-  except SystemExit as sys_exit:
-    exit_script(sys_exit.code)
-  except:
-    major_exception()
-
-# vim: sts=2 sw=2 ts=2

scripts/outer_scripts_to_review/user_data_transfer.py

@@ -1,67 +0,0 @@
-# Wizard Kit: Copy user data to the system from a local or network source
-
-import os
-import sys
-
-# Init
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-from functions.data import *
-from functions.repairs import *
-init_global_vars()
-os.system('title {}: User Data Transfer Tool'.format(KIT_NAME_FULL))
-set_log_file('User Data Transfer.log')
-
-if __name__ == '__main__':
-  try:
-    # Prep
-    stay_awake()
-    clear_screen()
-    print_info('{}: User Data Transfer Tool\n'.format(KIT_NAME_FULL))
-
-    # Get backup name prefix
-    ticket_number = get_ticket_number()
-    if ENABLED_TICKET_NUMBERS:
-      backup_prefix = ticket_number
-    else:
-      backup_prefix = get_simple_string(prompt='Enter backup name prefix')
-      backup_prefix = backup_prefix.replace(' ', '_')
-
-    # Set destination
-    folder_path = r'{}\Transfer'.format(KIT_NAME_SHORT)
-    dest = select_destination(folder_path=folder_path,
-      prompt='Which disk are we transferring to?')
-
-    # Set source items
-    source = select_source(backup_prefix)
-    items = scan_source(source, dest)
-
-    # Transfer
-    clear_screen()
-    print_info('Transfer Details:\n')
-    if ENABLED_TICKET_NUMBERS:
-      show_data('Ticket:',    ticket_number)
-    show_data('Source:',    source.path)
-    show_data('Destination:',   dest)
-
-    if (not ask('Proceed with transfer?')):
-      umount_backup_shares()
-      abort()
-
-    print_info('Transferring Data')
-    transfer_source(source, dest, items)
-    try_and_print(message='Removing extra files...',
-      function=cleanup_transfer, cs='Done', dest_path=dest)
-    umount_backup_shares()
-
-    # Done
-    try_and_print(message='Running KVRT...',
-      function=run_kvrt, cs='Started')
-    print_standard('\nDone.')
-    pause("Press Enter to exit...")
-    exit_script()
-  except SystemExit as sys_exit:
-    exit_script(sys_exit.code)
-  except:
-    major_exception()
-
-# vim: sts=2 sw=2 ts=2

scripts/outer_scripts_to_review/windows_updates.py

@@ -1,46 +0,0 @@
-# Wizard Kit: Windows updates
-
-import os
-import sys
-
-# Init
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-from functions.windows_updates import *
-init_global_vars()
-os.system('title {}: Windows Updates Tool'.format(KIT_NAME_FULL))
-set_log_file('Windows Updates Tool.log')
-
-if __name__ == '__main__':
-  try:
-    clear_screen()
-    print_info('{}: Windows Updates Tool\n'.format(KIT_NAME_FULL))
-
-    # Check args
-    if '--disable' in sys.argv:
-      disable_windows_updates()
-    elif '--enable' in sys.argv:
-      enable_windows_updates()
-    else:
-      print_error('Bad mode.')
-      abort()
-
-    # Done
-    exit_script()
-  except GenericError as err:
-    # Failed to complete request, show error(s) and prompt tech
-    print_standard(' ')
-    for line in str(err).splitlines():
-      print_warning(line)
-    print_standard(' ')
-    print_error('Error(s) encountered, see above.')
-    print_standard(' ')
-    if '--disable' in sys.argv:
-      print_standard('Please reboot and try again.')
-    pause('Press Enter to exit... ')
-    exit_script(1)
-  except SystemExit as sys_exit:
-    exit_script(sys_exit.code)
-  except:
-    major_exception()
-
-# vim: sts=2 sw=2 ts=2

scripts/outer_scripts_to_review/winpe_root_menu.py

@@ -1,23 +0,0 @@
-# Wizard Kit: WinPE Root Menu
-
-import os
-import sys
-
-# Init
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-from functions.winpe_menus import *
-# Fix 7-Zip name
-TOOLS['SevenZip'].pop('64')
-init_global_vars()
-set_title('{}: Root Menu'.format(KIT_NAME_FULL))
-set_log_file('WinPE.log')
-
-if __name__ == '__main__':
-  try:
-    menu_root()
-  except SystemExit as sys_exit:
-    exit_script(sys_exit.code)
-  except:
-    major_exception()
-
-# vim: sts=2 sw=2 ts=2

scripts/pacinit

@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-## Wizard Kit: Update pacman settings to usage in live sessions
+## WizardKit: Update pacman settings to usage in live sessions
 
 # Disable custom repo (used at build-time)
 sudo sed -i -r "s/^(\[custom\])/#\1/" /etc/pacman.conf
@@ -10,6 +10,9 @@ sudo sed -i -r "s/^(Server = )/#\1/" /etc/pacman.conf
 # Disable signature checks
 sudo sed -i -r "s/^SigLevel.*/SigLevel = Never/" /etc/pacman.conf
 
-# Refresh package databases
+# Init Pacman keyring
-sudo pacman -Sy
+sudo systemctl start pacman-init.service
+
+# Refresh package databases and install packages (if provided)
+sudo pacman -Sy "$@"
 

scripts/photorec-sort

@@ -1,150 +0,0 @@
-#!/bin/bash
-#
-## sort photorec results into something usefull
-
-## Set paths
-recup_dir="${1%/}"
-[ -n "$recup_dir" ] || recup_dir="."
-recup_dir="$(realpath "$recup_dir")"
-out_dir="$recup_dir/Recovered"
-bad_dir="$recup_dir/Corrupt"
-
-## Test path before starting (using current dir if not specified)
-for d in $recup_dir/recup*; do
-    ### Source: http://stackoverflow.com/a/6364244
-    ## Check if the glob gets expanded to existing files.
-    ## If not, f here will be exactly the pattern above
-    ## and the exists test will evaluate to false.
-    [ -e "$d" ] && echo "Found recup folder(s)" || {
-        echo "ERROR: No recup folders found"
-        echo "Usage: $0 recup_dir"
-        exit 1
-    }
-
-    ## This is all we needed to know, so we can break after the first iteration
-    break
-done
-
-# Hard link files into folders by type
-for d in $recup_dir/recup*; do
-    if [ -d "$d" ]; then
-        echo "Linking $d"
-        pushd $d >/dev/null
-        find -type f | while read k; do
-            file="$(basename "$k")"
-            src="$(realpath "$k")"
-            ext="$(echo "${file##*.}" | tr '[:upper:]' '[:lower:]')"
-            ext_dir="$out_dir/$ext"
-            if [ "${file##*.}" = "$file" ]; then
-                ext_dir="$out_dir/_MISC_"
-            elif [ "$ext" = "jpg" ] && [ "${file:0:1}" = "t" ]; then
-                ext_dir="$out_dir/jpg-thumbnail"
-            fi
-            #echo "  $file -> $ext_dir"
-            [ -d "$ext_dir" ] || mkdir -p "$ext_dir"
-            ln "$src" "$ext_dir"
-        done
-        popd >/dev/null
-    else
-        echo "ERROR: '$d' not a directory"
-    fi
-done
-
-## Check the files output by photorec for corruption
-pushd "$out_dir" >/dev/null
-
-# Check archives with 7-Zip
-#for d in 7z bz2 gz lzh lzo rar tar xz zip; do
-#    if [ -d "$d" ]; then
-#        echo "Checking $d files"
-#        pushd "$d" >/dev/null
-#        for f in *; do
-#            if ! 7z t "$f" >/dev/null 2>&1; then
-#                #echo "  BAD: $f"
-#                [ -d "$bad_dir/$d" ] || mkdir -p "$bad_dir/$d"
-#                mv -n "$f" "$bad_dir/$d/$f"
-#            fi
-#        done
-#        popd >/dev/null
-#    fi
-#done
-
-# Check Audio/Video files with ffprobe
-for d in avi flac flv m4a m4p m4v mkv mid mov mp2 mp3 mp4 mpg mpg2 ogg ts vob wav; do
-    if [ -d "$d" ]; then
-        echo "Checking $d files"
-        pushd "$d" >/dev/null
-        for f in *; do
-            if ! ffprobe "$f" >/dev/null 2>&1; then
-                #echo "  BAD: $f"
-                [ -d "$bad_dir/$d" ] || mkdir -p "$bad_dir/$d"
-                mv -n "$f" "$bad_dir/$d/$f"
-            fi
-        done
-        popd >/dev/null
-    fi
-done
-
-# Check .doc files with antiword
-if [ -d "doc" ]; then
-    echo "Checking doc files"
-    pushd "doc" >/dev/null
-    for f in *doc; do
-        if ! antiword "$f" >/dev/null 2>&1; then
-            #echo "  BAD: $f"
-            [ -d "$bad_dir/doc" ] || mkdir -p "$bad_dir/doc"
-            mv -n "$f" "$bad_dir/doc/$f"
-        fi
-    done
-    popd >/dev/null
-fi
-
-# Check .docx files with 7z and grep
-if [ -d "docx" ]; then
-    echo "Checking docx files"
-    pushd "docx" >/dev/null
-    for f in *docx; do
-        if ! 7z l "$f" | grep -q -s "word/document.xml"; then
-            #echo "  BAD: $f"
-            [ -d "$bad_dir/docx" ] || mkdir -p "$bad_dir/docx"
-            mv -n "$f" "$bad_dir/docx/$f"
-        fi
-    done
-    popd >/dev/null
-fi
-
-# Sort pictures by date (only for common camera formats)
-for d in jpg mrw orf raf raw rw2 tif x3f; do
-    if [ -d "$d" ]; then
-        echo "Sorting $d files by date"
-        pushd "$d" >/dev/null
-        for f in *; do
-            date_dir="$(date -d "$(stat -c %y "$f")" +"%F")"
-            [ -d "$date_dir" ] || mkdir "$date_dir"
-            mv -n "$f" "$date_dir/"
-        done
-        popd >/dev/null
-    fi
-done
-
-# Sort mov files by encoded date
-if [ -d "mov" ]; then
-    echo "Sorting mov files by date"
-    pushd "mov" >/dev/null
-    for f in *mov; do
-        enc_date="$(mediainfo "$f" | grep -i "Encoded date" | head -1 | sed -r 's/.*: //')"
-        date_dir="$(date -d "$enc_date" +"%F")"
-        echo "$date_dir" | grep -E -q -s '^[0-9]{4}-[0-9]{2}-[0-9]{2}$' || date_dir="Unknown Date"
-        [ -d "$date_dir" ] || mkdir "$date_dir"
-        mv -n "$f" "$date_dir/"
-    done
-    popd >/dev/null
-fi
-
-## sort audio files by tags
-
-## sort matroska files by metadata
-
-## return to original dir
-popd >/dev/null
-

scripts/pyproject.toml

@@ -0,0 +1,19 @@
+[tool.ruff.per-file-ignores]
+# Init files
+"wk/__init__.py" = ["F401"]
+"wk/cfg/__init__.py" = ["F401"]
+"wk/clone/__init__.py" = ["F401"]
+"wk/hw/__init__.py" = ["F401"]
+"wk/kit/__init__.py" = ["F401"]
+"wk/os/__init__.py" = ["F401"]
+"wk/repairs/__init__.py" = ["F401"]
+"wk/setup/__init__.py" = ["F401"]
+"wk/ui/__init__.py" = ["F401"]
+
+# Long lines
+"wk/borrowed/acpi.py" = ["E501", "F841"]
+"wk/cfg/ddrescue.py" = ["E501"]
+"wk/cfg/hw.py" = ["E501"]
+"wk/cfg/launchers.py" = ["E501"]
+"wk/cfg/setup.py" = ["E501"]
+"wk/cfg/sources.py" = ["E501"]

scripts/remount-rw

@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-## Wizard Kit: Volume remount tool
+## WizardKit: Volume remount tool
 
 if ! mount | grep -q "$1"; then
     echo "ERROR: Can't remount $1"

scripts/resize-and-run

@@ -0,0 +1,33 @@
+#!/bin/bash
+#
+
+# Magic numbers:
+## Width:  | 20 | term_x | 20 | 180 (conky) | 20 |
+## Height: | 24 | 10 (titlebar) | term_y | 24 | 30 (Tint2) |
+## X Offset: 20 - 5 (shadow?)
+## Y Offset: 24 - 5 (shadow?)
+conky_width=180
+gap_x=20
+gap_y=24
+picom_shadow=5
+tint2_height=30
+titlebar_height=10
+
+source ~/.screen_data
+
+if [[ "${dpi}" -ge 192 ]]; then
+  conky_width=360
+  gap_x=40
+  gap_y=48
+  picom_shadow=5
+  tint2_height=60
+  titlebar_height=20
+fi
+
+offset_x=$(echo "$gap_x - $picom_shadow" | bc)
+offset_y=$(echo "$gap_y - $picom_shadow" | bc)
+term_width="$(echo "$width_px - ($gap_x * 3) - $conky_width" | bc)"
+term_height="$(echo "$height_px - ($gap_y * 2) - $titlebar_height - $tint2_height" | bc)"
+
+sleep 0.1s
+wmctrl -r :ACTIVE: -e "0,$offset_x,$offset_y,$term_width,$term_height" && "$@"

scripts/safemode_enter.py

@@ -1,37 +0,0 @@
-"""Wizard Kit: Enter SafeMode by editing the BCD"""
-# vim: sts=2 sw=2 ts=2
-
-import wk
-
-
-def main():
-  """Prompt user to enter safe mode."""
-  title = f'{wk.cfg.main.KIT_NAME_FULL}: SafeMode Tool'
-  try_print = wk.std.TryAndPrint()
-  wk.std.clear_screen()
-  wk.std.set_title(title)
-  wk.std.print_info(title)
-  print('')
-
-  # Ask
-  if not wk.std.ask('Enable booting to SafeMode (with Networking)?'):
-    wk.std.abort()
-  print('')
-
-  # Configure SafeMode
-  try_print.run('Set BCD option...', wk.os.win.enable_safemode)
-  try_print.run('Enable MSI in SafeMode...', wk.os.win.enable_safemode_msi)
-
-  # Done
-  print('Done.')
-  wk.std.pause('Press Enter to reboot...')
-  wk.exe.run_program('shutdown -r -t 3'.split(), check=False)
-
-
-if __name__ == '__main__':
-  try:
-    main()
-  except SystemExit:
-    raise
-  except: #pylint: disable=bare-except
-    wk.std.major_exception()

scripts/safemode_exit.py

@@ -1,37 +0,0 @@
-"""Wizard Kit: Exit SafeMode by editing the BCD"""
-# vim: sts=2 sw=2 ts=2
-
-import wk
-
-
-def main():
-  """Prompt user to exit safe mode."""
-  title = f'{wk.cfg.main.KIT_NAME_FULL}: SafeMode Tool'
-  try_print = wk.std.TryAndPrint()
-  wk.std.clear_screen()
-  wk.std.set_title(title)
-  wk.std.print_info(title)
-  print('')
-
-  # Ask
-  if not wk.std.ask('Disable booting to SafeMode?'):
-    wk.std.abort()
-  print('')
-
-  # Configure SafeMode
-  try_print.run('Remove BCD option...', wk.os.win.disable_safemode)
-  try_print.run('Disable MSI in SafeMode...', wk.os.win.disable_safemode_msi)
-
-  # Done
-  print('Done.')
-  wk.std.pause('Press Enter to reboot...')
-  wk.exe.run_program('shutdown -r -t 3'.split(), check=False)
-
-
-if __name__ == '__main__':
-  try:
-    main()
-  except SystemExit:
-    raise
-  except: #pylint: disable=bare-except
-    wk.std.major_exception()

scripts/sfc_scan.py

@@ -1,35 +0,0 @@
-"""Wizard Kit: Check, and possibly repair, system file health via SFC"""
-# vim: sts=2 sw=2 ts=2
-
-import wk
-
-
-def main():
-  """Run SFC and report result."""
-  title = f'{wk.cfg.main.KIT_NAME_FULL}: SFC Tool'
-  try_print = wk.std.TryAndPrint()
-  wk.std.clear_screen()
-  wk.std.set_title(title)
-  wk.std.print_info(title)
-  print('')
-
-  # Ask
-  if not wk.std.ask('Run a SFC scan now?'):
-    wk.std.abort()
-  print('')
-
-  # Run
-  try_print.run('SFC scan...', wk.os.win.run_sfc_scan)
-
-  # Done
-  print('Done')
-  wk.std.pause('Press Enter to exit...')
-
-
-if __name__ == '__main__':
-  try:
-    main()
-  except SystemExit:
-    raise
-  except: #pylint: disable=bare-except
-    wk.std.major_exception()

scripts/start-max

@@ -0,0 +1,4 @@
+#!/bin/bash
+#
+
+wmctrl -r:ACTIVE: -b toggle,maximized_vert,maximized_horz && "$@"

scripts/unmount-backup-shares

@@ -1,22 +1,21 @@
 #!/usr/bin/env python3
-"""Wizard Kit: Unmount Backup Shares"""
+"""WizardKit: Unmount Backup Shares"""
-# pylint: disable=invalid-name
 # vim: sts=2 sw=2 ts=2
 
 import wk
 
 
 # Functions
-def main():
+def main() -> None:
   """Attempt to mount backup shares and print report."""
-  wk.std.print_info('Unmounting Backup Shares')
+  wk.ui.cli.print_info('Unmounting Backup Shares')
   report = wk.net.unmount_backup_shares()
   for line in report:
     color = 'GREEN'
     line = f'  {line}'
     if 'Not mounted' in line:
       color = 'YELLOW'
-    print(wk.std.color_string(line, color))
+    print(wk.ui.ansi.color_string(line, color))
 
 
 if __name__ == '__main__':
@@ -24,5 +23,5 @@ if __name__ == '__main__':
     main()
   except SystemExit:
     raise
-  except: #pylint: disable=bare-except
+  except: # noqa: E722
-    wk.std.major_exception()
+    wk.ui.cli.major_exception()

scripts/upload-logs

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # vim: sts=2 sw=2 ts=2
-"""Wizard Kit: Upload Logs"""
+"""WizardKit: Upload Logs"""
 
 import datetime
 import os
@@ -25,24 +25,24 @@ if PLATFORM not in ('macOS', 'Linux'):
 
 
 # Functions
-def main():
+def main() -> None:
   """Upload logs for review."""
   lines = []
-  try_and_print = wk.std.TryAndPrint()
+  try_and_print = wk.ui.cli.TryAndPrint()
 
   # Set log
   wk.log.update_log_path(dest_name='Upload-Logs', timestamp=True)
 
   # Instructions
-  wk.std.print_success(f'{wk.cfg.main.KIT_NAME_FULL}: Upload Logs')
+  wk.ui.cli.print_success(f'{wk.cfg.main.KIT_NAME_FULL}: Upload Logs')
-  wk.std.print_standard('')
+  wk.ui.cli.print_standard('')
-  wk.std.print_standard('Please state the reason for the review.')
+  wk.ui.cli.print_standard('Please state the reason for the review.')
-  wk.std.print_info('  End note with an empty line.')
+  wk.ui.cli.print_info('  End note with an empty line.')
-  wk.std.print_standard('')
+  wk.ui.cli.print_standard('')
 
   # Get reason note
   while True:
-    text = wk.std.input_text('> ')
+    text = wk.ui.cli.input_text('> ')
     if not text:
       lines.append('')
       break
@@ -60,17 +60,16 @@ def main():
     raise SystemExit(1)
 
 
-def upload_log_dir(reason='Testing'):
+def upload_log_dir(reason='Testing') -> None:
   """Upload compressed log_dir to the crash server."""
   server = wk.cfg.net.CRASH_SERVER
   dest = pathlib.Path(f'~/{reason}_{NOW.strftime("%Y-%m-%dT%H%M%S%z")}.txz')
   dest = dest.expanduser().resolve()
-  data = None
 
   # Compress LOG_DIR (relative to parent dir)
   os.chdir(LOG_DIR.parent)
   cmd = ['tar', 'caf', dest.name, LOG_DIR.name]
-  proc = wk.exe.run_program(cmd, check=False)
+  wk.exe.run_program(cmd, check=False)
 
   # Upload compressed data
   url = f'{server["Url"]}/{dest.name}'

scripts/wk-debug

@@ -0,0 +1,5 @@
+#!/bin/bash
+#
+## WizardKit: Debug Launcher
+
+python3 -i /usr/local/bin/wk_debug.py

scripts/wk-exit

@@ -1,31 +0,0 @@
-#!/bin/bash
-#
-## WizardKit: GUI exit script
-# Inspired by: https://github.com/cramermarius/rofi-menus/blob/master/scripts/powermenu.sh
-
-actions="Restart\nPoweroff\nLogout"
-temp_file="$(mktemp --suffix=.png)"
-
-# Show blurred background
-import -window root "${temp_file}"
-convert "${temp_file}" -blur 0x4 "${temp_file}"
-feh -F "${temp_file}" &
-feh_pid="$!"
-
-# Show menu
-selection="$(echo -e "$actions" | rofi -i -lines 3 -dmenu -p "Power Menu")"
-
-# Done
-kill "${feh_pid}"
-case $selection in
-  Logout)
-    wk-power-command logout
-    ;;
-  Poweroff)
-    wk-power-command poweroff
-    ;;
-  Restart)
-    wk-power-command reboot
-    ;;
-esac
-

scripts/wk-power-command

@@ -2,20 +2,51 @@
 #
 ## Wizard Kit: Wrapper for logout, reboot, & poweroff
 
-# Unmount filesystems
+set -o errexit
-find /media -maxdepth 1 -mindepth 1 -type d \
+set -o errtrace
-  -exec udevil umount "{}" \;
+set -o nounset
+set -o pipefail
 
-# Flush write cache
+# Functions
-sudo sync
+function linux_power_cmd() {
+  case "${1:-x}" in
+    poweroff)
+      sudo systemctl poweroff;;
+    reboot)
+      sudo systemctl reboot;;
+    *)
+      openbox --exit;;
+  esac
+}
+
+function macos_power_cmd() {
+  case "${1:-x}" in
+    poweroff)
+      shutdown -h now;;
+    reboot)
+      shutdown -r now;;
+    *)
+      exit;;
+  esac
+}
+
+# "Main"
+if [[ -e "/.wk-live-macos" ]]; then
+  # Flush write cache
+  sync
+
+  # Perform requested action
+  macos_power_cmd "${1:-x}"
+else
+  # Unmount filesystems
+  find /media -maxdepth 1 -mindepth 1 -type d \
+    -exec udevil umount "{}" \;
+
+  # Flush write cache
+  sudo sync
+
+  # Perform requested action
+ linux_power_cmd "${1:-x}"
+fi
 
-# Perform requested action
-case "${1:-x}" in
-  poweroff)
-    sudo systemctl poweroff;;
-  reboot)
-    sudo systemctl reboot;;
-  *)
-    openbox --exit;;
-esac
 exit 0

scripts/wk.prev/debug/hw_diags.py

@@ -1,186 +0,0 @@
-# Wizard Kit: Debug - HW Diagnostics
-
-import base64
-import requests
-
-from functions.common import *
-
-def debug_report_cpu(cpu_obj):
-  """Generate report for CpuObj, returns list."""
-  report = []
-
-  # CPU Info
-  report.append('CPU: {}'.format(cpu_obj.name))
-  report.append('lscpu:')
-  for k, v in sorted(cpu_obj.lscpu.items()):
-    report.append('  {}: {}'.format(k, v))
-
-  # Tests
-  report.append('Tests:')
-  for k, v in cpu_obj.tests.items():
-    report.extend(debug_report_test(v, k))
-
-  # Done
-  return report
-
-
-def debug_report_disk(disk_obj):
-  """Generate report for DiskObj, returns list."""
-  report = []
-  expand = [
-    'lsblk',
-    'nvme_attributes',
-    'nvme_smart_notes',
-    'smart_attributes',
-    'smart_self_test',
-    'smartctl',
-    ]
-  skip = [
-    'add_nvme_smart_note',
-    'calc_io_dd_values',
-    'check_attributes',
-    'check_smart_self_test',
-    'description',
-    'disable_test',
-    'generate_attribute_report',
-    'generate_disk_report',
-    'get_details',
-    'get_size',
-    'get_smart_details',
-    'name',
-    'safety_check',
-    'tests',
-    ]
-
-  # Disk Info
-  report.append('Disk: {} {}'.format(
-    disk_obj.name, disk_obj.description))
-  for a in dir(disk_obj):
-    if a.startswith('_') or a in skip:
-      continue
-    if a in expand:
-      report.append('{}:'.format(a))
-      attr = getattr(disk_obj, a)
-      try:
-        for k, v in sorted(attr.items()):
-          report.append('  {}: {}'.format(k, v))
-      except Exception:
-        # Ignore
-        pass
-    else:
-      report.append('{}: {}'.format(a, getattr(disk_obj, a)))
-
-  # Tests
-  report.append('Tests:')
-  for k, v in disk_obj.tests.items():
-    report.extend(debug_report_test(v, k))
-
-  # Done
-  return report
-
-
-def debug_report_state(state):
-  """Generate report for State, returns list."""
-  report = []
-
-  # Devs
-  report.append('CPU: {}'.format(state.cpu))
-  report.append('Disks: {}'.format(state.disks))
-
-  # Settings
-  report.append('Progress Out: {}'.format(state.progress_out))
-  report.append('Quick Mode: {}'.format(state.quick_mode))
-
-  # Tests
-  report.append('Tests:')
-  for k, v in state.tests.items():
-    report.append('  {}:'.format(k))
-    for k2, v2 in sorted(v.items()):
-      report.append('    {}: {}'.format(k2, v2))
-
-  # tmux
-  if hasattr(state, 'tmux_layout'):
-    report.append('tmux Layout:')
-    for k, v in state.tmux_layout.items():
-      report.append('  {}: {}'.format(k, str(v)))
-  if hasattr(state, 'panes'):
-    report.append('tmux Panes:')
-    for k, v in state.panes.items():
-      report.append('  {}: {}'.format(k, str(v)))
-
-  # Done
-  return report
-
-
-def debug_report_test(test_obj, test_name):
-  """Generate report for TestObj, returns list."""
-  report = ['  {}:'.format(test_name)]
-  skip = ['update_status']
-
-  # Attributes
-  for a in [a for a in dir(test_obj) if not a.startswith('_')]:
-    if a in skip:
-      continue
-    report.append('    {}: {}'.format(a, getattr(test_obj, a)))
-
-  # Done
-  return report
-
-
-def save_debug_reports(state, global_vars):
-  """Save debug reports if possible."""
-  debug_dest = '{}/debug'.format(global_vars['LogDir'])
-  os.makedirs(debug_dest, exist_ok=True)
-
-  # State
-  with open('{}/state.report'.format(debug_dest), 'a') as f:
-    for line in debug_report_state(state):
-      f.write('{}\n'.format(line))
-
-  # CPU
-  with open('{}/cpu.report'.format(debug_dest), 'a') as f:
-    for line in debug_report_cpu(state.cpu):
-      f.write('{}\n'.format(line))
-
-  # Disk(s)
-  for disk in state.disks:
-    with open('{}/disk_{}.report'.format(debug_dest, disk.name), 'a') as f:
-      for line in debug_report_disk(disk):
-        f.write('{}\n'.format(line))
-
-
-def upload_logdir(global_vars, reason='Crash'):
-  """Upload compressed LogDir to CRASH_SERVER."""
-  source = global_vars['LogDir']
-  source = source[source.rfind('/')+1:]
-  dest = 'HW-Diags_{reason}_{Date-Time}.txz'.format(
-    reason=reason,
-    **global_vars,
-    )
-  data = None
-
-  # Compress LogDir
-  os.chdir('{}/..'.format(global_vars['LogDir']))
-  cmd = ['tar', 'caf', dest, source]
-  run_program(cmd)
-
-  # Read file
-  with open(dest, 'rb') as f:
-    data = f.read()
-
-  # Upload data
-  url = '{}/{}'.format(CRASH_SERVER['Url'], dest)
-  r = requests.put(
-    url,
-    data=data,
-    headers={'X-Requested-With': 'XMLHttpRequest'},
-    auth=(CRASH_SERVER['User'], CRASH_SERVER['Pass']))
-  # Raise exception if upload NS
-  if not r.ok:
-    raise GenericError
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/activation.py

@@ -1,73 +0,0 @@
-# Wizard Kit: Functions - Activation
-
-import subprocess
-
-from borrowed import acpi
-from functions.common import *
-from os import environ
-
-
-# STATIC VARIABLES
-SLMGR = r'{}\System32\slmgr.vbs'.format(environ.get('SYSTEMROOT'))
-
-
-def activate_with_bios():
-  """Attempt to activate Windows with a key stored in the BIOS."""
-  # Code borrowed from https://github.com/aeruder/get_win8key
-  #####################################################
-  #script to query windows 8.x OEM key from PC firmware
-  #ACPI -> table MSDM -> raw content -> byte offset 56 to end
-  #ck, 03-Jan-2014 (christian@korneck.de)
-  #####################################################
-  bios_key = None
-  table = b"MSDM"
-  if acpi.FindAcpiTable(table) is True:
-    rawtable = acpi.GetAcpiTable(table)
-    #http://msdn.microsoft.com/library/windows/hardware/hh673514
-    #byte offset 36 from beginning \
-    #   = Microsoft 'software licensing data structure' \
-    #   / 36 + 20 bytes offset from beginning = Win Key
-    bios_key = rawtable[56:len(rawtable)].decode("utf-8")
-  if bios_key is None:
-    raise BIOSKeyNotFoundError
-
-  # Install Key
-  cmd = ['cscript', '//nologo', SLMGR, '/ipk', bios_key]
-  subprocess.run(cmd, check=False)
-  sleep(5)
-
-  # Attempt activation
-  cmd = ['cscript', '//nologo', SLMGR, '/ato']
-  subprocess.run(cmd, check=False)
-  sleep(5)
-
-  # Check status
-  if not windows_is_activated():
-    raise Exception('Activation Failed')
-
-
-def get_activation_string():
-  """Get activation status, returns str."""
-  act_str = subprocess.run(
-    ['cscript', '//nologo', SLMGR, '/xpr'], check=False,
-    stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-  act_str = act_str.stdout.decode()
-  act_str = act_str.splitlines()
-  act_str = act_str[1].strip()
-  return act_str
-
-
-def windows_is_activated():
-  """Check if Windows is activated via slmgr.vbs and return bool."""
-  activation_string = subprocess.run(
-    ['cscript', '//nologo', SLMGR, '/xpr'], check=False,
-    stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-  activation_string = activation_string.stdout.decode()
-
-  return bool(activation_string and 'permanent' in activation_string)
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/backup.py

@@ -1,219 +0,0 @@
-# Wizard Kit: Functions - Backup
-
-import ctypes
-
-from functions.disk import *
-
-
-# Regex
-REGEX_BAD_PATH_NAMES = re.compile(
-  r'([<>:"/\|\?\*]'
-  r'|^(CON|PRN|AUX|NUL|COM\d*|LPT\d*)$)'
-  r'|^\s+'
-  r'|[\s\.]+$',
-  re.IGNORECASE)
-
-
-def backup_partition(disk, par):
-  """Create a backup image of a partition."""
-  if (par.get('Image Exists', False)
-      or par['Number'] in disk['Bad Partitions']):
-    raise GenericAbort
-
-  cmd = [
-    global_vars['Tools']['wimlib-imagex'],
-    'capture',
-    '{}:\\'.format(par['Letter']),
-    par['Image Path'],
-    par['Image Name'], # Image name
-    par['Image Name'], # Image description
-    '--compress=none',
-    ]
-  dest_dir = re.sub(r'(.*)\\.*$', r'\1', par['Image Path'], re.IGNORECASE)
-  os.makedirs(dest_dir, exist_ok=True)
-  run_program(cmd)
-
-
-def fix_path(path):
-  """Replace invalid filename characters with underscores."""
-  local_drive = path[1:2] == ':'
-  new_path = REGEX_BAD_PATH_NAMES.sub('_', path)
-  if local_drive:
-    new_path = '{}:{}'.format(new_path[0:1], new_path[2:])
-  return new_path
-
-
-def get_volume_display_name(mountpoint):
-  """Get display name from volume mountpoint and label, returns str."""
-  name = mountpoint
-  try:
-    kernel32 = ctypes.windll.kernel32
-    vol_name_buffer = ctypes.create_unicode_buffer(1024)
-    fs_name_buffer = ctypes.create_unicode_buffer(1024)
-    serial_number = None
-    max_component_length = None
-    file_system_flags = None
-
-    vol_info = kernel32.GetVolumeInformationW(
-      ctypes.c_wchar_p(mountpoint),
-      vol_name_buffer,
-      ctypes.sizeof(vol_name_buffer),
-      serial_number,
-      max_component_length,
-      file_system_flags,
-      fs_name_buffer,
-      ctypes.sizeof(fs_name_buffer)
-      )
-
-    name = '{} "{}"'.format(name, vol_name_buffer.value)
-  except:
-    pass
-
-  return name
-
-
-def prep_disk_for_backup(destination, disk, backup_prefix):
-  """Gather details about the disk and its partitions.
-
-  This includes partitions that can't be backed up,
-    whether backups already exist on the BACKUP_SERVER,
-    partition names/sizes/used space, etc."""
-  disk['Clobber Risk'] = []
-  width = len(str(len(disk['Partitions'])))
-
-  # Get partition totals
-  disk['Bad Partitions'] = [par['Number'] for par in disk['Partitions']
-    if is_bad_partition(par)]
-  num_valid_partitions = len(disk['Partitions']) - len(disk['Bad Partitions'])
-  disk['Valid Partitions'] = num_valid_partitions
-  if disk['Valid Partitions'] <= 0:
-    print_error('ERROR: No partitions can be backed up for this disk')
-    raise GenericAbort
-
-  # Prep partitions
-  for par in disk['Partitions']:
-    display = '{size} {fs}'.format(
-      num = par['Number'],
-      width = width,
-      size = par['Size'],
-      fs = par['FileSystem'])
-
-    if par['Number'] in disk['Bad Partitions']:
-      # Set display string using partition description & OS type
-      display = '* {display}\t\t{q}{name}{q}\t{desc} ({os})'.format(
-        display = display,
-        q = '"' if par['Name'] != '' else '',
-        name = par['Name'],
-        desc = par['Description'],
-        os = par['OS'])
-    else:
-      # Update info for WIM capturing
-      par['Image Name'] = par['Name'] if par['Name'] else 'Unknown'
-      if 'IP' in destination:
-        par['Image Path'] = r'\\{}\{}\{}'.format(
-          destination['IP'], destination['Share'], backup_prefix)
-      else:
-        par['Image Path'] = r'{}:\{}'.format(
-          destination['Letter'], backup_prefix)
-      par['Image Path'] += r'\{}_{}.wim'.format(
-        par['Number'], par['Image Name'])
-      par['Image Path'] = fix_path(par['Image Path'])
-
-      # Check for existing backups
-      par['Image Exists'] = os.path.exists(par['Image Path'])
-      if par['Image Exists']:
-        disk['Clobber Risk'].append(par['Number'])
-        display = '+ {}'.format(display)
-      else:
-        display = '  {}'.format(display)
-
-      # Append rest of Display String for valid/clobber partitions
-      display += ' (Used: {used})\t{q}{name}{q}'.format(
-        used = par['Used Space'],
-        q = '"' if par['Name'] != '' else '',
-        name = par['Name'])
-    # For all partitions
-    par['Display String'] = display
-
-  # Set description for bad partitions
-  warnings = '\n'
-  if disk['Bad Partitions']:
-    warnings += '{}  * Unsupported filesystem{}\n'.format(
-      COLORS['YELLOW'], COLORS['CLEAR'])
-  if disk['Clobber Risk']:
-    warnings += '{}  + Backup exists on {}{}\n'.format(
-      COLORS['BLUE'], destination['Name'], COLORS['CLEAR'])
-  if disk['Bad Partitions'] or disk['Clobber Risk']:
-    warnings += '\n{}Marked partition(s) will NOT be backed up.{}\n'.format(
-      COLORS['YELLOW'], COLORS['CLEAR'])
-  disk['Backup Warnings'] = warnings
-
-
-def select_backup_destination(auto_select=True):
-  """Select a backup destination from a menu, returns server dict."""
-  destinations = [s for s in BACKUP_SERVERS if s['Mounted']]
-  actions = [
-    {'Name': 'Main Menu', 'Letter': 'M'},
-    ]
-
-  # Add local disks
-  for d in psutil.disk_partitions():
-    if re.search(
-        r'^{}'.format(global_vars['Env']['SYSTEMDRIVE']),
-        d.mountpoint,
-        re.IGNORECASE):
-      # Skip current OS drive
-      pass
-    elif 'fixed' in d.opts:
-      # Skip DVD, etc
-      destinations.append({
-        'Name':   'Local Disk - {}'.format(
-          get_volume_display_name(d.mountpoint)),
-        'Letter':   re.sub(r'^(\w):\\.*$', r'\1', d.mountpoint),
-        })
-
-  # Size check
-  for dest in destinations:
-    if 'IP' in dest:
-      dest['Usage'] = shutil.disk_usage(r'\\{IP}\{Share}'.format(**dest))
-    else:
-      dest['Usage'] = shutil.disk_usage('{}:\\'.format(dest['Letter']))
-    dest['Free Space'] = human_readable_size(dest['Usage'].free)
-    dest['Display Name'] = '{Name} ({Free Space} available)'.format(**dest)
-
-  # Bail
-  if not destinations:
-    print_warning('No backup destinations found.')
-    raise GenericAbort
-
-  # Skip menu?
-  if len(destinations) == 1 and auto_select:
-    return destinations[0]
-
-  selection = menu_select(
-    title = 'Where are we backing up to?',
-    main_entries = destinations,
-    action_entries = actions)
-  if selection == 'M':
-    raise GenericAbort
-  else:
-    return destinations[int(selection)-1]
-
-
-def verify_wim_backup(partition):
-  """Verify WIM integrity."""
-  if not os.path.exists(partition['Image Path']):
-    raise PathNotFoundError
-  cmd = [
-    global_vars['Tools']['wimlib-imagex'],
-    'verify',
-    partition['Image Path'],
-    '--nocheck',
-    ]
-  run_program(cmd)
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/browsers.py

@@ -1,470 +0,0 @@
-# Wizard Kit: Functions - Browsers
-
-from functions.common import *
-from operator import itemgetter
-from settings.browsers import *
-
-
-# Define other_results for later try_and_print
-browser_data = {}
-other_results = {
-  'Error': {
-    'MultipleInstallationsError': 'Multiple installations detected',
-    },
-  'Warning': {
-    'NotInstalledError': 'Not installed',
-    'NoProfilesError': 'No profiles found',
-    }
-  }
-
-
-def archive_all_users():
-  """Create backups for all browsers for all users."""
-  users_root = r'{}\Users'.format(global_vars['Env']['SYSTEMDRIVE'])
-  user_envs = []
-
-  # Build list of valid users
-  for user_name in os.listdir(users_root):
-    valid_user = True
-    if user_name in ('Default', 'Default User'):
-      # Skip default users
-      continue
-    user_path = os.path.join(users_root, user_name)
-    appdata_local = os.path.join(user_path, r'AppData\Local')
-    appdata_roaming = os.path.join(user_path, r'AppData\Roaming')
-    valid_user = valid_user and os.path.exists(appdata_local)
-    valid_user = valid_user and os.path.exists(appdata_roaming)
-    if valid_user:
-      user_envs.append({
-        'USERNAME': user_name,
-        'USERPROFILE': user_path,
-        'APPDATA': appdata_roaming,
-        'LOCALAPPDATA': appdata_local})
-
-  # Backup browsers for all valid users
-  print_info('Backing up browsers')
-  for fake_env in sorted(user_envs, key=itemgetter('USERPROFILE')):
-    print_standard('  {}'.format(fake_env['USERNAME']))
-    for b_k, b_v in sorted(SUPPORTED_BROWSERS.items()):
-      if b_k == 'Mozilla Firefox Dev':
-        continue
-      source_path = b_v['user_data_path'].format(**fake_env)
-      if not os.path.exists(source_path):
-        continue
-      source_items = source_path + '*'
-      archive_path = r'{BackupDir}\Browsers ({USERNAME})\{Date}'.format(
-        **global_vars, **fake_env)
-      os.makedirs(archive_path, exist_ok=True)
-      archive_path += r'\{}.7z'.format(b_k)
-      cmd = [
-        global_vars['Tools']['SevenZip'],
-        'a', '-aoa', '-bso0', '-bse0', '-mx=1',
-        archive_path, source_items]
-      try_and_print(message='{}...'.format(b_k),
-        function=run_program, cmd=cmd)
-    print_standard(' ')
-
-
-def archive_browser(name):
-  """Create backup of Browser saved in the BackupDir."""
-  source = '{}*'.format(browser_data[name]['user_data_path'])
-  dest = r'{BackupDir}\Browsers ({USERNAME})\{Date}'.format(
-    **global_vars, **global_vars['Env'])
-  archive = r'{}\{}.7z'.format(dest, name)
-  os.makedirs(dest, exist_ok=True)
-  cmd = [
-    global_vars['Tools']['SevenZip'],
-    'a', '-aoa', '-bso0', '-bse0', '-mx=1',
-    '-mhe=on', '-p{}'.format(ARCHIVE_PASSWORD),
-    archive, source]
-  run_program(cmd)
-
-
-def backup_browsers():
-  """Create backup of all detected browser profiles."""
-  for name in [k for k, v in sorted(browser_data.items()) if v['profiles']]:
-    try_and_print(message='{}...'.format(name),
-    function=archive_browser, name=name)
-
-
-def clean_chromium_profile(profile):
-  """Recreate profile with only the essential user data.
-
-  This is done by renaming the existing profile, creating a new folder
-  with the original name, then copying the essential files from the
-  backup folder. This way the original state is preserved in case
-  something goes wrong.
-  """
-  if profile is None:
-    raise Exception
-  backup_path = '{path}_{Date}.bak'.format(
-    path=profile['path'], **global_vars)
-  backup_path = non_clobber_rename(backup_path)
-  shutil.move(profile['path'], backup_path)
-  os.makedirs(profile['path'], exist_ok=True)
-
-  # Restore essential files from backup_path
-  for entry in os.scandir(backup_path):
-    if REGEX_CHROMIUM_ITEMS.search(entry.name):
-      shutil.copy(entry.path, r'{}\{}'.format(
-        profile['path'], entry.name))
-
-
-def clean_internet_explorer(**kwargs):
-  """Uses the built-in function to reset IE and sets the homepage.
-
-  NOTE: kwargs set but unused as a workaround."""
-  kill_process('iexplore.exe')
-  run_program(['rundll32.exe', 'inetcpl.cpl,ResetIEtoDefaults'], check=False)
-  key = r'Software\Microsoft\Internet Explorer\Main'
-
-  # Set homepage
-  with winreg.OpenKey(HKCU, key, access=winreg.KEY_WRITE) as _key:
-    winreg.SetValueEx(_key, 'Start Page', 0,
-      winreg.REG_SZ, DEFAULT_HOMEPAGE)
-    try:
-      winreg.DeleteValue(_key, 'Secondary Start Pages')
-    except FileNotFoundError:
-      pass
-
-
-def clean_mozilla_profile(profile):
-  """Recreate profile with only the essential user data.
-
-  This is done by renaming the existing profile, creating a new folder
-  with the original name, then copying the essential files from the
-  backup folder. This way the original state is preserved in case
-  something goes wrong.
-  """
-  if profile is None:
-    raise Exception
-  backup_path = '{path}_{Date}.bak'.format(
-    path=profile['path'], **global_vars)
-  backup_path = non_clobber_rename(backup_path)
-  shutil.move(profile['path'], backup_path)
-  homepages = []
-  os.makedirs(profile['path'], exist_ok=True)
-
-  # Restore essential files from backup_path
-  for entry in os.scandir(backup_path):
-    if REGEX_MOZILLA.search(entry.name):
-      if entry.is_dir():
-        shutil.copytree(entry.path, r'{}\{}'.format(
-          profile['path'], entry.name))
-      else:
-        shutil.copy(entry.path, r'{}\{}'.format(
-          profile['path'], entry.name))
-
-  # Set profile defaults
-  with open(r'{path}\prefs.js'.format(**profile), 'a', encoding='ascii') as f:
-    for k, v in MOZILLA_PREFS.items():
-      f.write('user_pref("{}", {});\n'.format(k, v))
-
-
-def get_browser_details(name):
-  """Get installation and profile details for all supported browsers."""
-  browser = SUPPORTED_BROWSERS[name].copy()
-
-  # Update user_data_path
-  browser['user_data_path'] = browser['user_data_path'].format(
-    **global_vars['Env'])
-
-  # Find executable (if multiple files are found, the last one is used)
-  exe_path = None
-  num_installs = 0
-  for install_path in ['LOCALAPPDATA', 'PROGRAMFILES(X86)', 'PROGRAMFILES']:
-    test_path = r'{install_path}\{rel_install_path}\{exe_name}'.format(
-      install_path = global_vars['Env'].get(install_path, ''),
-      **browser)
-    if os.path.exists(test_path):
-      num_installs += 1
-      exe_path = test_path
-
-  # Find profile(s)
-  profiles = []
-  if browser['base'] == 'ie':
-    profiles.append({'name': 'Default', 'path': None})
-  elif 'Google Chrome' in name:
-    profiles.extend(
-      get_chromium_profiles(
-        search_path=browser['user_data_path']))
-  elif browser['base'] == 'mozilla':
-    dev = 'Dev' in name
-    profiles.extend(
-      get_mozilla_profiles(
-        search_path=browser['user_data_path'], dev=dev))
-    if exe_path and not dev and len(profiles) == 0:
-      # e.g. If Firefox is installed but no profiles were found.
-      ## Rename profiles.ini and create a new default profile
-      profiles_ini_path = browser['user_data_path'].replace(
-        'Profiles', 'profiles.ini')
-      if os.path.exists(profiles_ini_path):
-        backup_path = '{path}_{Date}.bak'.format(
-          path=profiles_ini_path, **global_vars)
-        backup_path = non_clobber_rename(backup_path)
-        shutil.move(profiles_ini_path, backup_path)
-      run_program([exe_path, '-createprofile', 'default'], check=False)
-      profiles.extend(
-        get_mozilla_profiles(
-          search_path=browser['user_data_path'], dev=dev))
-
-  elif 'Opera' in name:
-    if os.path.exists(browser['user_data_path']):
-      profiles.append(
-        {'name': 'Default', 'path': browser['user_data_path']})
-
-  # Get homepages
-  if browser['base'] == 'ie':
-    # IE is set to only have one profile above
-    profiles[0]['homepages'] = get_ie_homepages()
-  elif browser['base'] == 'mozilla':
-    for profile in profiles:
-      prefs_path = r'{path}\prefs.js'.format(**profile)
-      profile['homepages'] = get_mozilla_homepages(prefs_path=prefs_path)
-
-  # Add to browser_data
-  browser_data[name] = browser
-  browser_data[name].update({
-    'exe_path': exe_path,
-    'profiles': profiles,
-    })
-
-  # Raise installation warnings (if any)
-  if num_installs == 0:
-    raise NotInstalledError
-  elif num_installs > 1 and browser['base'] != 'ie':
-    raise MultipleInstallationsError
-
-
-def get_chromium_profiles(search_path):
-  """Find any chromium-style profiles and return as a list of dicts."""
-  profiles = []
-  try:
-    for entry in os.scandir(search_path):
-      if entry.is_dir() and REGEX_CHROMIUM_PROFILE.search(entry.name):
-        profiles.append(entry)
-        REGEX_PROFILE_BACKUP = r'\.\w+bak.*'
-    profiles = [p for p in profiles if not REGEX_BACKUP.search(p.name)]
-    # Convert os.DirEntries to dicts
-    profiles = [{'name': p.name, 'path': p.path} for p in profiles]
-  except Exception:
-    pass
-
-  return profiles
-
-
-def get_ie_homepages():
-  """Read homepages from the registry and return as a list."""
-  homepages = []
-  main_page = ''
-  extra_pages = []
-  key = r'Software\Microsoft\Internet Explorer\Main'
-  with winreg.OpenKey(HKCU, key) as _key:
-     try:
-       main_page = winreg.QueryValueEx(_key, 'Start Page')[0]
-     except FileNotFoundError:
-       pass
-     try:
-       extra_pages = winreg.QueryValueEx(_key, 'Secondary Start Pages')[0]
-     except FileNotFoundError:
-       pass
-  if main_page != '':
-    homepages.append(main_page)
-  if len(extra_pages) > 0:
-    homepages.extend(extra_pages)
-
-  # Remove all curly braces
-  homepages = [h.replace('{', '').replace('}', '') for h in homepages]
-  return homepages
-
-
-def get_mozilla_homepages(prefs_path):
-  """Read homepages from prefs.js and return as a list."""
-  homepages = []
-  try:
-    with open(prefs_path, 'r') as f:
-      search = re.search(
-        r'browser\.startup\.homepage", "([^"]*)"',
-        f.read(), re.IGNORECASE)
-      if search:
-        homepages = search.group(1).split('|')
-  except Exception:
-    pass
-
-  return homepages
-
-
-def get_mozilla_profiles(search_path, dev=False):
-  """Find any mozilla-style profiles and return as a list of dicts."""
-  profiles = []
-  try:
-    for entry in os.scandir(search_path):
-      if entry.is_dir():
-        if 'dev-edition' in entry.name:
-          # NOTE: Not always present which can lead
-          # to Dev profiles being marked as non-Dev
-          ## NOTE 2: It is possible that a non-Dev profile
-          ##    to be created with 'dev-edition' in the name.
-          ##    (It wouldn't make sense, but possible)
-          if dev:
-            profiles.append(entry)
-        elif not dev:
-          profiles.append(entry)
-    profiles = [p for p in profiles if not REGEX_BACKUP.search(p.name)]
-    # Convert os.DirEntries to dicts
-    profiles = [{'name': p.name, 'path': p.path} for p in profiles]
-  except Exception:
-    pass
-
-  return profiles
-
-
-def install_adblock(indent=8, width=32, just_firefox=False):
-  """Install adblock for all supported browsers."""
-  for browser in sorted(browser_data):
-    if just_firefox and browser_data[browser]['base'] != 'mozilla':
-      continue
-    exe_path = browser_data[browser].get('exe_path', None)
-    if not exe_path:
-      if browser_data[browser]['profiles']:
-        print_standard(
-          '{indent}{browser:<{width}}'.format(
-            indent=' '*indent, width=width, browser=browser+'...'),
-          end='', flush=True)
-        print_warning('Profile(s) detected but browser not installed',
-          timestamp=False)
-      else:
-        # Only warn if profile(s) are detected.
-        pass
-    else:
-      # Set urls to open
-      urls = []
-      if browser_data[browser]['base'] == 'chromium':
-        if browser == 'Google Chrome':
-          # Check for system exensions
-          try:
-            winreg.QueryValue(HKLM, UBO_CHROME_REG)
-          except FileNotFoundError:
-            urls.append(UBO_CHROME)
-          try:
-            winreg.QueryValue(HKLM, UBO_EXTRA_CHROME_REG)
-          except FileNotFoundError:
-            urls.append(UBO_EXTRA_CHROME)
-
-          if len(urls) == 0:
-            urls = ['chrome://extensions']
-        elif 'Opera' in browser:
-          urls.append(UBO_OPERA)
-        else:
-          urls.append(UBO_CHROME)
-          urls.append(UBO_EXTRA_CHROME)
-
-      elif browser_data[browser]['base'] == 'mozilla':
-        # Check for system extensions
-        try:
-          with winreg.OpenKey(HKLM, UBO_MOZILLA_REG) as key:
-            winreg.QueryValueEx(key, UBO_MOZILLA_REG_NAME)
-        except FileNotFoundError:
-          urls = [UBO_MOZILLA]
-        else:
-          if os.path.exists(UBO_MOZZILA_PATH):
-            urls = ['about:addons']
-          else:
-            urls = [UBO_MOZILLA]
-
-      elif browser_data[browser]['base'] == 'ie':
-        urls.append(IE_GALLERY)
-
-      # By using check=False we're skipping any return codes so
-      # it should only fail if the program can't be run
-      #   (or can't be found).
-      # In other words, this isn't tracking the addon/extension's
-      #   installation status.
-      try_and_print(message='{}...'.format(browser),
-        indent=indent, width=width,
-        cs='Started', function=popen_program,
-        cmd=[exe_path, *urls], check=False)
-
-
-def is_installed(browser_name):
-  """Checks if browser is installed based on exe_path, returns bool."""
-  browser_name = browser_name.replace(' Chromium', '')
-  return bool(browser_data.get(browser_name, {}).get('exe_path', False))
-
-
-def list_homepages(indent=8, width=32):
-  """List current homepages for reference."""
-  browser_list = [k for k, v in sorted(browser_data.items()) if v['exe_path']]
-  for browser in browser_list:
-    # Skip Chromium-based browsers
-    if browser_data[browser]['base'] == 'chromium':
-      print_info(
-        '{indent}{browser:<{width}}'.format(
-          indent=' '*indent, width=width, browser=browser+'...'),
-        end='', flush=True)
-      print_warning('Not implemented', timestamp=False)
-      continue
-
-    # All other browsers
-    print_info('{indent}{browser:<{width}}'.format(
-      indent=' '*indent, width=width, browser=browser+'...'))
-    for profile in browser_data[browser].get('profiles', []):
-      name = profile.get('name', '?')
-      homepages = profile.get('homepages', [])
-      if len(homepages) == 0:
-        print_standard(
-          '{indent}{name:<{width}}'.format(
-            indent=' '*indent, width=width, name=name),
-          end='', flush=True)
-        print_warning('None found', timestamp=False)
-      else:
-        for page in homepages:
-          print_standard('{indent}{name:<{width}}{page}'.format(
-            indent=' '*indent, width=width, name=name, page=page))
-
-
-def profile_present(browser_name):
-  """Checks if a profile was detected for browser, returns bool."""
-  browser_name = browser_name.replace(' Chromium', '')
-  return bool(browser_data.get(browser_name, {}).get('profiles', False))
-
-
-def reset_browsers(indent=8, width=32):
-  """Reset all detected browsers to safe defaults."""
-  browser_list = [k for k, v in sorted(browser_data.items()) if v['profiles']]
-  for browser in browser_list:
-    print_info('{indent}{name}'.format(indent=' '*indent, name=browser))
-    for profile in browser_data[browser]['profiles']:
-      if browser_data[browser]['base'] == 'chromium':
-        function = clean_chromium_profile
-      elif browser_data[browser]['base'] == 'ie':
-        function = clean_internet_explorer
-      elif browser_data[browser]['base'] == 'mozilla':
-        function = clean_mozilla_profile
-      try_and_print(
-        message='{}...'.format(profile['name']),
-        indent=indent, width=width, function=function,
-        other_results=other_results, profile=profile)
-
-
-def scan_for_browsers(just_firefox=False, silent=False):
-  """Scan system for any supported browsers."""
-  for name, details in sorted(SUPPORTED_BROWSERS.items()):
-    if just_firefox and details['base'] != 'mozilla':
-      continue
-    if silent:
-      try:
-        get_browser_details(name)
-      except Exception:
-        # Ignore errors in silent mode
-        pass
-    else:
-      try_and_print(message='{}...'.format(name),
-        function=get_browser_details, cs='Detected',
-        other_results=other_results, name=name)
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/cleanup.py

@@ -1,144 +0,0 @@
-'''Wizard Kit: Functions - Cleanup'''
-# pylint: disable=no-name-in-module,wildcard-import
-# vim: sts=2 sw=2 ts=2
-
-from functions.setup import *
-from settings.cleanup import *
-
-def cleanup_adwcleaner():
-  """Move AdwCleaner folders into the ClientDir."""
-  source_path = r'{SYSTEMDRIVE}\AdwCleaner'.format(**global_vars['Env'])
-  source_quarantine = r'{}\Quarantine'.format(source_path)
-
-  # Quarantine
-  if os.path.exists(source_quarantine):
-    os.makedirs(global_vars['QuarantineDir'], exist_ok=True)
-    dest_name = r'{QuarantineDir}\AdwCleaner_{Date-Time}'.format(
-      **global_vars)
-    dest_name = non_clobber_rename(dest_name)
-    shutil.move(source_quarantine, dest_name)
-
-  # Delete source folder if empty
-  delete_empty_folders(source_path)
-
-  # Main folder
-  if os.path.exists(source_path):
-    os.makedirs(global_vars['LogDir'], exist_ok=True)
-    dest_name = r'{LogDir}\Tools\AdwCleaner'.format(
-      **global_vars)
-    dest_name = non_clobber_rename(dest_name)
-    shutil.move(source_path, dest_name)
-
-
-def cleanup_cbs(dest_folder):
-  """Safely cleanup a known CBS archive bug under Windows 7.
-
-  If a CbsPersist file is larger than 2 Gb then the auto archive feature
-  continually fails and will fill up the system drive with temp files.
-
-  This function moves the temp files and CbsPersist file to a temp folder,
-  compresses the CbsPersist files with 7-Zip, and then opens the temp folder
-  for the user to manually save the backup files and delete the temp files.
-  """
-  backup_folder = r'{dest_folder}\CbsFix'.format(dest_folder=dest_folder)
-  temp_folder = r'{backup_folder}\Temp'.format(backup_folder=backup_folder)
-  os.makedirs(backup_folder, exist_ok=True)
-  os.makedirs(temp_folder, exist_ok=True)
-
-  # Move files into temp folder
-  cbs_path = r'{SYSTEMROOT}\Logs\CBS'.format(**global_vars['Env'])
-  for entry in os.scandir(cbs_path):
-    # CbsPersist files
-    if entry.name.lower().startswith('cbspersist'):
-      dest_name = r'{}\{}'.format(temp_folder, entry.name)
-      dest_name = non_clobber_rename(dest_name)
-      shutil.move(entry.path, dest_name)
-  temp_path = r'{SYSTEMROOT}\Temp'.format(**global_vars['Env'])
-  for entry in os.scandir(temp_path):
-    # cab_ files
-    if entry.name.lower().startswith('cab_'):
-      dest_name = r'{}\{}'.format(temp_folder, entry.name)
-      dest_name = non_clobber_rename(dest_name)
-      shutil.move(entry.path, dest_name)
-
-  # Compress CbsPersist files with 7-Zip
-  cmd = [
-    global_vars['Tools']['SevenZip'],
-    'a', '-t7z', '-mx=3', '-bso0', '-bse0',
-    r'{}\CbsPersists.7z'.format(backup_folder),
-    r'{}\CbsPersist*'.format(temp_folder)]
-  run_program(cmd)
-
-
-def cleanup_desktop():
-  """Move known backup files and reports into the ClientDir."""
-  dest_folder = r'{LogDir}\Tools'.format(**global_vars)
-  os.makedirs(dest_folder, exist_ok=True)
-
-  desktop_path = r'{USERPROFILE}\Desktop'.format(**global_vars['Env'])
-  for entry in os.scandir(desktop_path):
-    if DESKTOP_ITEMS.search(entry.name):
-      dest_name = r'{}\{}'.format(dest_folder, entry.name)
-      dest_name = non_clobber_rename(dest_name)
-      shutil.move(entry.path, dest_name)
-
-  # Remove dir if empty
-  delete_empty_folders(dest_folder)
-
-
-def delete_empty_folders(folder_path):
-  """Delete all empty folders in path (depth first)."""
-  if not os.path.exists(folder_path) or not os.path.isdir(folder_path):
-    # Bail early (silently)
-    return
-
-  # Delete empty subfolders first
-  for item in os.scandir(folder_path):
-    if item.is_dir():
-      delete_empty_folders(item.path)
-
-  # Remove top folder
-  try:
-    os.rmdir(folder_path)
-  except OSError:
-    pass
-
-
-def delete_registry_key(hive, key, recurse=False):
-  """Delete a registry key and all it's subkeys."""
-  access = winreg.KEY_ALL_ACCESS
-
-  try:
-    if recurse:
-      # Delete all subkeys first
-      with winreg.OpenKeyEx(hive, key, 0, access) as k:
-        key_info = winreg.QueryInfoKey(k)
-        for x in range(key_info[0]):
-          subkey = r'{}\{}'.format(key, winreg.EnumKey(k, 0))
-          delete_registry_key(hive, subkey)
-
-    # Delete key
-    winreg.DeleteKey(hive, key)
-  except FileNotFoundError:
-    # Ignore
-    pass
-
-
-def delete_registry_value(hive, key, value):
-  """Delete a registry value."""
-  access = winreg.KEY_ALL_ACCESS
-  with winreg.OpenKeyEx(hive, key, 0, access) as k:
-    winreg.DeleteValue(k, value)
-
-
-def restore_default_uac():
-  """Restores default UAC settings via the registry."""
-  if global_vars['OS']['Version'] == '10':
-    write_registry_settings(UAC_DEFAULTS_WIN10, all_users=True)
-  else:
-    # Haven't checked Win8 settings, only applying minimum set
-    write_registry_settings(UAC_DEFAULTS_WIN7, all_users=True)
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")

scripts/wk.prev/functions/common.py

@@ -1,434 +0,0 @@
-# Wizard Kit: Functions - Common
-
-import os
-import psutil
-import re
-import shutil
-import subprocess
-import sys
-import time
-import traceback
-try:
-  import winreg
-except ModuleNotFoundError:
-  if psutil.WINDOWS:
-    raise
-
-from settings.main import *
-from settings.tools import *
-from settings.windows_builds import *
-from subprocess import CalledProcessError
-
-
-# Global variables
-global_vars = {}
-
-
-# STATIC VARIABLES
-COLORS = {
-  'CLEAR':  '\033[0m',
-  'RED':    '\033[31m',
-  'ORANGE': '\033[31;1m',
-  'GREEN':  '\033[32m',
-  'YELLOW': '\033[33m',
-  'BLUE':   '\033[34m',
-  'PURPLE': '\033[35m',
-  'CYAN':   '\033[36m',
-  }
-try:
-  HKU =  winreg.HKEY_USERS
-  HKCR = winreg.HKEY_CLASSES_ROOT
-  HKCU = winreg.HKEY_CURRENT_USER
-  HKLM = winreg.HKEY_LOCAL_MACHINE
-except NameError:
-  if psutil.WINDOWS:
-    raise
-
-
-# Error Classes
-class BIOSKeyNotFoundError(Exception):
-  pass
-
-class BinNotFoundError(Exception):
-  pass
-
-class GenericAbort(Exception):
-  pass
-
-class GenericError(Exception):
-  pass
-
-class GenericRepair(Exception):
-  pass
-
-class MultipleInstallationsError(Exception):
-  pass
-
-class NoProfilesError(Exception):
-  pass
-
-class Not4KAlignedError(Exception):
-  pass
-
-class NotInstalledError(Exception):
-  pass
-
-class OSInstalledLegacyError(Exception):
-  pass
-
-class PathNotFoundError(Exception):
-  pass
-
-class UnsupportedOSError(Exception):
-  pass
-
-class SecureBootDisabledError(Exception):
-  pass
-
-class SecureBootNotAvailError(Exception):
-  pass
-
-class SecureBootUnknownError(Exception):
-  pass
-
-class WindowsOutdatedError(Exception):
-  pass
-
-class WindowsUnsupportedError(Exception):
-  pass
-
-
-# General functions
-def exit_script(return_value=0):
-  """Exits the script after some cleanup and opens the log (if set)."""
-  # Remove dirs (if empty)
-  for dir in ['BackupDir', 'LogDir', 'TmpDir']:
-    try:
-      os.rmdir(global_vars[dir])
-    except Exception:
-      pass
-
-  # Open Log (if it exists)
-  log = global_vars.get('LogFile', '')
-  if log and os.path.exists(log) and psutil.WINDOWS and ENABLED_OPEN_LOGS:
-    try:
-      extract_item('NotepadPlusPlus', silent=True)
-      popen_program(
-        [global_vars['Tools']['NotepadPlusPlus'],
-        global_vars['LogFile']])
-    except Exception:
-      print_error('ERROR: Failed to extract Notepad++ and open log.')
-      pause('Press Enter to exit...')
-
-  # Kill Caffeine if still running
-  kill_process('caffeine.exe')
-
-  # Exit
-  sys.exit(return_value)
-
-
-def extract_item(item, filter='', silent=False):
-  """Extract item from .cbin into .bin."""
-  cmd = [
-    global_vars['Tools']['SevenZip'], 'x', '-aos', '-bso0', '-bse0',
-    '-p{ArchivePassword}'.format(**global_vars),
-    r'-o{BinDir}\{item}'.format(item=item, **global_vars),
-    r'{CBinDir}\{item}.7z'.format(item=item, **global_vars),
-    filter]
-  if not silent:
-    print_standard('Extracting "{item}"...'.format(item=item))
-  try:
-    run_program(cmd)
-  except FileNotFoundError:
-    if not silent:
-      print_warning('WARNING: Archive not found')
-  except subprocess.CalledProcessError:
-    if not silent:
-      print_warning('WARNING: Errors encountered while exctracting data')
-
-
-def get_process(name=None):
-  """Get process by name, returns psutil.Process obj."""
-  proc = None
-  if not name:
-    raise GenericError
-
-  for p in psutil.process_iter():
-    try:
-      if p.name() == name:
-        proc = p
-    except psutil._exceptions.NoSuchProcess:
-      # Process finished during iteration? Going to ignore
-      pass
-  return proc
-
-
-def get_ticket_number():
-  """Get TicketNumber from user, save in LogDir, and return as str."""
-  if not ENABLED_TICKET_NUMBERS:
-    return None
-  ticket_number = None
-  while ticket_number is None:
-    _input = input('Enter ticket number: ')
-    if re.match(r'^([0-9]+([-_]?\w+|))$', _input):
-      ticket_number = _input
-      out_file = r'{}\TicketNumber'.format(global_vars['LogDir'])
-      if not psutil.WINDOWS:
-        out_file = out_file.replace('\\', '/')
-      with open(out_file, 'w', encoding='utf-8') as f:
-        f.write(ticket_number)
-  return ticket_number
-
-
-def kill_process(name):
-  """Kill any running caffeine.exe processes."""
-  for proc in psutil.process_iter():
-    if proc.name() == name:
-      proc.kill()
-
-
-def stay_awake():
-  """Prevent the system from sleeping or hibernating."""
-  # DISABLED due to VCR2008 dependency
-  return
-  # Bail if caffeine is already running
-  for proc in psutil.process_iter():
-    if proc.name() == 'caffeine.exe':
-      return
-  # Extract and run
-  extract_item('Caffeine', silent=True)
-  try:
-    popen_program([global_vars['Tools']['Caffeine']])
-  except Exception:
-    print_error('ERROR: No caffeine available.')
-    print_warning('Please set the power setting to High Performance.')
-
-
-def wait_for_process(name, poll_rate=3):
-  """Wait for process by name."""
-  running = True
-  while running:
-    sleep(poll_rate)
-    running = False
-    for proc in psutil.process_iter():
-      try:
-        if re.search(r'^{}'.format(name), proc.name(), re.IGNORECASE):
-          running = True
-      except psutil._exceptions.NoSuchProcess:
-        # Assuming process closed during iteration
-        pass
-  sleep(1)
-
-
-# global_vars functions
-def init_global_vars(silent=False):
-  """Sets global variables based on system info."""
-  if not silent:
-    print_info('Initializing')
-  if psutil.WINDOWS:
-    os.system('title Wizard Kit')
-  if psutil.LINUX:
-    init_functions = [
-      ['Checking environment...', set_linux_vars],
-      ['Clearing collisions...',  clean_env_vars],
-      ]
-  else:
-    init_functions = [
-      ['Checking .bin...',    find_bin],
-      ['Checking environment...', set_common_vars],
-      ['Checking OS...',      check_os],
-      ['Checking tools...',     check_tools],
-      ['Creating folders...',   make_tmp_dirs],
-      ['Clearing collisions...',  clean_env_vars],
-      ]
-  try:
-    if silent:
-      for f in init_functions:
-        f[1]()
-    else:
-      for f in init_functions:
-        try_and_print(
-          message=f[0], function=f[1],
-          cs='Done', ns='Error', catch_all=False)
-  except:
-    major_exception()
-
-
-def check_os():
-  """Set OS specific variables."""
-  tmp = {}
-
-  # Query registry
-  path = r'SOFTWARE\Microsoft\Windows NT\CurrentVersion'
-  with winreg.OpenKey(HKLM, path) as key:
-    for name in ['CurrentBuild', 'CurrentVersion', 'ProductName']:
-      try:
-        tmp[name] = winreg.QueryValueEx(key, name)[0]
-      except FileNotFoundError:
-        tmp[name] = 'Unknown'
-
-  # Handle CurrentBuild collision
-  if tmp['CurrentBuild'] == '9200':
-    if tmp['CurrentVersion'] == '6.2':
-      # Windown 8, set to fake build number
-      tmp['CurrentBuild'] = '9199'
-    else:
-      # Windows 8.1, leave alone
-      pass
-
-  # Check bit depth
-  tmp['Arch'] = 32
-  if 'PROGRAMFILES(X86)' in global_vars['Env']:
-    tmp['Arch'] = 64
-
-  # Get Windows build info
-  build_info = WINDOWS_BUILDS.get(tmp['CurrentBuild'], None)
-  if build_info is None:
-    # Not in windows_builds.py
-    build_info = [
-      'Unknown',
-      'Build {}'.format(tmp['CurrentBuild']),
-      None,
-      None,
-      'unrecognized']
-  else:
-    build_info = list(build_info)
-  tmp['Version'] = build_info.pop(0)
-  tmp['Release'] = build_info.pop(0)
-  tmp['Codename'] = build_info.pop(0)
-  tmp['Marketing Name'] = build_info.pop(0)
-  tmp['Notes'] = build_info.pop(0)
-
-  # Set name
-  tmp['Name'] = tmp['ProductName']
-  if tmp['Release']:
-    tmp['Name'] += ' {}'.format(tmp['Release'])
-  if tmp['Codename']:
-    tmp['Name'] += ' "{}"'.format(tmp['Codename'])
-  if tmp['Marketing Name']:
-    tmp['Name'] += ' / "{}"'.format(tmp['Marketing Name'])
-  tmp['Name'] = re.sub(r'\s+', ' ', tmp['Name'])
-
-  # Set display name
-  tmp['DisplayName'] = '{} x{}'.format(tmp['Name'], tmp['Arch'])
-  if tmp['Notes']:
-    tmp['DisplayName'] += ' ({})'.format(tmp['Notes'])
-
-  global_vars['OS'] = tmp
-
-
-def check_tools():
-  """Set tool variables based on OS bit-depth and tool availability."""
-  if global_vars['OS'].get('Arch', 32) == 64:
-    global_vars['Tools'] = {
-      k: v.get('64', v.get('32')) for (k, v) in TOOLS.items()}
-  else:
-    global_vars['Tools'] = {k: v.get('32') for (k, v) in TOOLS.items()}
-
-  # Fix paths
-  global_vars['Tools'] = {k: os.path.join(global_vars['BinDir'], v)
-    for (k, v) in global_vars['Tools'].items()}
-
-
-def clean_env_vars():
-  """Remove conflicting global_vars and env variables.
-
-  This fixes an issue where both global_vars and
-  global_vars['Env'] are expanded at the same time."""
-  for key in global_vars.keys():
-    global_vars['Env'].pop(key, None)
-
-
-def find_bin():
-  """Find .bin folder in the cwd or it's parents."""
-  wd = os.getcwd()
-  base = None
-  while base is None:
-    if os.path.exists('.bin'):
-      base = os.getcwd()
-      break
-    if re.fullmatch(r'\w:\\', os.getcwd()):
-      break
-    os.chdir('..')
-  os.chdir(wd)
-  if base is None:
-    raise BinNotFoundError
-  global_vars['BaseDir'] = base
-
-
-def generate_global_vars_report():
-  """Build readable string from global_vars, returns str."""
-  report = ['global_vars: {']
-  for k, v in sorted(global_vars.items()):
-    if k == 'Env':
-      continue
-    if isinstance(v, list):
-      report.append('  {}: ['.format(str(k)))
-      for item in v:
-        report.append('    {}'.format(str(v)))
-      report.append('  ]')
-    elif isinstance(v, dict):
-      report.append('  {}: {{'.format(str(k)))
-      for item_k, item_v in sorted(v.items()):
-        report.append('    {:<15} {}'.format(
-          str(item_k)+':', str(item_v)))
-      report.append('  }')
-    else:
-      report.append('  {:<18}{}'.format(str(k)+':', str(v)))
-  report.append('  Env:')
-  for k, v in sorted(global_vars.get('Env', {}).items()):
-    report.append('    {:<15} {}'.format(
-      str(k)+':', str(v)))
-  report.append('}')
-
-  return '\n'.join(report)
-
-
-def make_tmp_dirs():
-  """Make temp directories."""
-  os.makedirs(global_vars['BackupDir'], exist_ok=True)
-  os.makedirs(global_vars['LogDir'], exist_ok=True)
-  os.makedirs(r'{}\{}'.format(
-    global_vars['LogDir'], KIT_NAME_FULL), exist_ok=True)
-  os.makedirs(r'{}\Tools'.format(global_vars['LogDir']), exist_ok=True)
-  os.makedirs(global_vars['TmpDir'], exist_ok=True)
-
-
-def set_common_vars():
-  """Set common variables."""
-  global_vars['Date'] =             time.strftime("%Y-%m-%d")
-  global_vars['Date-Time'] =        time.strftime("%Y-%m-%d_%H%M_%z")
-  global_vars['Env'] =              os.environ.copy()
-
-  global_vars['ArchivePassword'] =  ARCHIVE_PASSWORD
-  global_vars['BinDir'] =           r'{BaseDir}\.bin'.format(**global_vars)
-  global_vars['CBinDir'] =          r'{BaseDir}\.cbin'.format(**global_vars)
-  global_vars['ClientDir'] =        r'{SYSTEMDRIVE}\{prefix}'.format(
-                                      prefix=KIT_NAME_SHORT, **global_vars['Env'])
-  global_vars['BackupDir'] =        r'{ClientDir}\Backups'.format(**global_vars)
-  global_vars['LogDir'] =           r'{ClientDir}\Logs\{Date}'.format(**global_vars)
-  global_vars['QuarantineDir'] =    r'{ClientDir}\Quarantine'.format(**global_vars)
-  global_vars['TmpDir'] =           r'{BinDir}\tmp'.format(**global_vars)
-
-
-def set_linux_vars():
-  """Set common variables in a Linux environment.
-
-  These assume we're running under a WK-Linux build."""
-  result = run_program(['mktemp', '-d'])
-  global_vars['TmpDir'] =           result.stdout.decode().strip()
-  global_vars['Date'] =             time.strftime("%Y-%m-%d")
-  global_vars['Date-Time'] =        time.strftime("%Y-%m-%d_%H%M_%z")
-  global_vars['Env'] =              os.environ.copy()
-  global_vars['BinDir'] =           '/usr/local/bin'
-  global_vars['LogDir'] =           '{}/Logs'.format(global_vars['Env']['HOME'])
-  global_vars['Tools'] = {
-    'wimlib-imagex': 'wimlib-imagex',
-    'SevenZip': '7z',
-    }
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/data.py

@@ -1,854 +0,0 @@
-# Wizard Kit: Functions - Data
-
-import ctypes
-
-from functions.json import *
-from operator import itemgetter
-from settings.data import *
-
-
-# Classes
-class LocalDisk():
-  def __init__(self, disk):
-    self.disk = disk
-    self.name = disk.mountpoint.upper()
-    self.path = self.name
-  def is_dir(self):
-    # Should always be true
-    return True
-  def is_file(self):
-    # Should always be false
-    return False
-
-
-class SourceItem():
-  def __init__(self, name, path):
-    self.name = name
-    self.path = path
-
-
-# Functions
-def cleanup_transfer(dest_path):
-  """Fix attributes and move excluded items to separate folder."""
-  try:
-    # Remove dest_path if empty
-    os.rmdir(dest_path)
-  except OSError:
-    pass
-  if not os.path.exists(dest_path):
-    # Bail if dest_path was empty and removed
-    raise Exception
-
-  # Fix attributes
-  cmd = ['attrib', '-a', '-h', '-r', '-s', dest_path]
-  run_program(cmd, check=False)
-
-  for root, dirs, files in os.walk(dest_path, topdown=False):
-    for name in dirs:
-      # Remove empty directories and junction points
-      try:
-        os.rmdir(os.path.join(root, name))
-      except OSError:
-        pass
-    for name in files:
-      # "Remove" files based on exclusion regex
-      if REGEX_EXCL_ITEMS.search(name):
-        # Make dest folder
-        dest_name = root.replace(dest_path, dest_path+'.Removed')
-        os.makedirs(dest_name, exist_ok=True)
-        # Set dest filename
-        dest_name = os.path.join(dest_name, name)
-        dest_name = non_clobber_rename(dest_name)
-        source_name = os.path.join(root, name)
-        try:
-          shutil.move(source_name, dest_name)
-        except Exception:
-          pass
-
-
-def find_core_storage_volumes(device_path=None):
-  """Try to create block devices for any Apple CoreStorage volumes."""
-  corestorage_uuid = '53746f72-6167-11aa-aa11-00306543ecac'
-  dmsetup_cmd_file = '{TmpDir}/dmsetup_command'.format(**global_vars)
-
-  # Get CoreStorage devices
-  cmd = [
-    'lsblk', '--json', '--list', '--paths',
-    '--output', 'NAME,PARTTYPE']
-  if device_path:
-    cmd.append(device_path)
-  json_data = get_json_from_command(cmd)
-  devs = json_data.get('blockdevices', [])
-  devs = [d for d in devs if d.get('parttype', '') == corestorage_uuid]
-  if devs:
-    print_standard(' ')
-    print_standard('Detected CoreStorage partition{}'.format(
-      '' if len(devs) == 1 else 's'))
-    print_standard('  Scanning for inner volume(s)....')
-
-  # Search for inner volumes and setup dev mappers
-  for dev in devs:
-    dev_path = dev.get('name', '')
-    if not dev_path:
-      # Can't setup block device without the dev path
-      continue
-    dev_name = re.sub(r'.*/', '', dev_path)
-    log_path = '{LogDir}/testdisk_{dev_name}.log'.format(
-      dev_name=dev_name, **global_vars)
-
-    # Run TestDisk
-    cmd = [
-      'sudo', 'testdisk',
-      '/logname', log_path, '/debug', '/log',
-      '/cmd', dev_path, 'partition_none,analyze']
-    result = run_program(cmd, check=False)
-    if result.returncode:
-      # i.e. return code is non-zero
-      continue
-    if not os.path.exists(log_path):
-      # TestDisk failed to write log
-      continue
-
-    # Check log for found volumes
-    cs_vols = {}
-    with open(log_path, 'r', encoding='utf-8', errors='ignore') as f:
-      for line in f.readlines():
-        r = re.match(
-          r'^.*echo "([^"]+)" . dmsetup create test(\d)$',
-          line.strip(),
-          re.IGNORECASE)
-        if r:
-          cs_name = 'CoreStorage_{}_{}'.format(dev_name, r.group(2))
-          cs_vols[cs_name] = r.group(1)
-
-    # Create mapper device(s)
-    for name, dm_cmd in sorted(cs_vols.items()):
-      with open(dmsetup_cmd_file, 'w') as f:
-        f.write(dm_cmd)
-      cmd = ['sudo', 'dmsetup', 'create', name, dmsetup_cmd_file]
-      run_program(cmd, check=False)
-
-
-def fix_path_sep(path_str):
-  """Replace non-native and duplicate dir separators, returns str."""
-  return re.sub(r'(\\|/)+', lambda s: os.sep, path_str)
-
-
-def is_valid_wim_file(item):
-  """Checks if the item is a valid WIM file, returns bool."""
-  valid = bool(item.is_file() and REGEX_WIM_FILE.search(item.name))
-  if valid:
-    extract_item('wimlib', silent=True)
-    cmd = [global_vars['Tools']['wimlib-imagex'], 'info', item.path]
-    try:
-      run_program(cmd)
-    except subprocess.CalledProcessError:
-      valid = False
-      print_log('WARNING: Image "{}" damaged.'.format(item.name))
-  return valid
-
-
-def get_mounted_volumes():
-  """Get mounted volumes, returns dict."""
-  cmd = [
-    'findmnt',
-    '--list',
-    '--json',
-    '--bytes',
-    '--invert',
-    '--types', (
-      'autofs,binfmt_misc,bpf,cgroup,cgroup2,configfs,debugfs,devpts,'
-      'devtmpfs,hugetlbfs,mqueue,proc,pstore,securityfs,sysfs,tmpfs'
-      ),
-    '--output', 'SOURCE,TARGET,FSTYPE,LABEL,SIZE,AVAIL,USED']
-  json_data = get_json_from_command(cmd)
-  mounted_volumes = []
-  for item in json_data.get('filesystems', []):
-    mounted_volumes.append(item)
-    mounted_volumes.extend(item.get('children', []))
-  return {item['source']: item for item in mounted_volumes}
-
-
-def mount_volumes(
-    all_devices=True, device_path=None,
-    read_write=False, core_storage=True):
-  """Mount all detected filesystems."""
-  report = {}
-  cmd = [
-    'lsblk', '--json', '--paths',
-    '--output', 'NAME,FSTYPE,LABEL,UUID,PARTTYPE,TYPE,SIZE']
-  if not all_devices and device_path:
-    # Only mount volumes for specific device
-    cmd.append(device_path)
-
-  # Check for Apple CoreStorage volumes first
-  if core_storage:
-    find_core_storage_volumes(device_path)
-
-  # Get list of block devices
-  json_data = get_json_from_command(cmd)
-  devs = json_data.get('blockdevices', [])
-
-  # Get list of volumes
-  volumes = {}
-  for dev in devs:
-    if not dev.get('children', []):
-      volumes.update({dev['name']: dev})
-    for child in dev.get('children', []):
-      if not child.get('children', []):
-        volumes.update({child['name']: child})
-      for grandchild in child.get('children', []):
-        volumes.update({grandchild['name']: grandchild})
-        for great_grandchild in grandchild.get('children', []):
-          volumes.update({great_grandchild['name']: great_grandchild})
-
-  # Get list of mounted volumes
-  mounted_volumes = get_mounted_volumes()
-
-  # Loop over volumes
-  for vol_path, vol_data in volumes.items():
-    vol_data['show_data'] = {
-      'message': vol_path.replace('/dev/mapper/', ''),
-      'data': None,
-      }
-    if re.search(r'^loop\d', vol_path, re.IGNORECASE):
-      # Skip loopback devices
-      vol_data['show_data']['data'] = 'Skipped'
-      vol_data['show_data']['warning'] = True
-      report[vol_path] = vol_data
-    elif 'children' in vol_data:
-      # Skip LVM/RAID partitions (the real volume is mounted separately)
-      vol_data['show_data']['data'] = vol_data.get('fstype', 'Unknown')
-      if vol_data.get('label', None):
-        vol_data['show_data']['data'] += ' "{}"'.format(vol_data['label'])
-      vol_data['show_data']['info'] = True
-      report[vol_path] = vol_data
-    else:
-      if vol_path in mounted_volumes:
-        vol_data['show_data']['warning'] = True
-      else:
-        # Mount volume
-        cmd = ['udevil', 'mount',
-          '-o', 'rw' if read_write else 'ro',
-          vol_path]
-        try:
-          run_program(cmd)
-        except subprocess.CalledProcessError:
-          vol_data['show_data']['data'] = 'Failed to mount'
-          vol_data['show_data']['error'] = True
-      # Update mounted_volumes data
-      mounted_volumes = get_mounted_volumes()
-
-      # Format pretty result string
-      if vol_data['show_data']['data'] == 'Failed to mount':
-        vol_data['mount_point'] = None
-      else:
-        fstype = vol_data.get('fstype', 'Unknown FS')
-        size_used = human_readable_size(
-          mounted_volumes[vol_path]['used'],
-          decimals=1,
-          )
-        size_avail = human_readable_size(
-          mounted_volumes[vol_path]['avail'],
-          decimals=1,
-          )
-        vol_data['size_avail'] = size_avail
-        vol_data['size_used'] = size_used
-        vol_data['mount_point'] = mounted_volumes[vol_path]['target']
-        vol_data['show_data']['data'] = 'Mounted on {}'.format(
-          mounted_volumes[vol_path]['target'])
-        vol_data['show_data']['data'] = '{:40} ({}, {} used, {} free)'.format(
-          vol_data['show_data']['data'],
-          fstype,
-          size_used,
-          size_avail)
-
-      # Update report
-      report[vol_path] = vol_data
-
-  return report
-
-
-def mount_backup_shares(read_write=False):
-  """Mount the backup shares unless labeled as already mounted."""
-  if psutil.LINUX:
-    mounted_volumes = get_mounted_volumes()
-  for server in BACKUP_SERVERS:
-    if psutil.LINUX:
-      # Update mounted status
-      source = '//{IP}/{Share}'.format(**server)
-      dest = '/Backups/{Name}'.format(**server)
-      mounted_str = '(Already) Mounted {}'.format(dest)
-      data = mounted_volumes.get(source, {})
-      if dest == data.get('target', ''):
-        server['Mounted'] = True
-    elif psutil.WINDOWS:
-      mounted_str = '(Already) Mounted {Name}'.format(**server)
-    if server['Mounted']:
-      print_warning(mounted_str)
-      continue
-
-    mount_network_share(server, read_write)
-
-
-def mount_network_share(server, read_write=False):
-  """Mount a network share defined by server."""
-  uid = '1000'
-
-  # Get UID
-  cmd = ['id', '--user', 'tech']
-  result = run_program(cmd, check=False, encoding='utf-8', errors='ignore')
-  if result.stdout.strip().isnumeric():
-    uid = result.stdout.strip()
-
-  if read_write:
-    username = server['RW-User']
-    password = server['RW-Pass']
-  else:
-    username = server['User']
-    password = server['Pass']
-  if psutil.WINDOWS:
-    cmd = [
-      'net', 'use', r'\\{IP}\{Share}'.format(**server),
-      '/user:{}'.format(username), password]
-    warning = r'Failed to mount \\{Name}\{Share}, {IP} unreachable.'.format(
-      **server)
-    error = r'Failed to mount \\{Name}\{Share} ({IP})'.format(**server)
-    success = 'Mounted {Name}'.format(**server)
-  elif psutil.LINUX:
-    # Make mountpoint
-    cmd = [
-      'sudo', 'mkdir', '-p',
-      '/Backups/{Name}'.format(**server)]
-    run_program(cmd)
-
-    # Set mount options
-    cmd_options = [
-      # Assuming GID matches UID
-      'gid={}'.format(uid),
-      'uid={}'.format(uid),
-      ]
-    cmd_options.append('rw' if read_write else 'ro')
-    cmd_options.append('username={}'.format(username))
-    if password:
-      cmd_options.append('password={}'.format(password))
-    else:
-      # Skip password check
-      cmd_options.append('guest')
-
-    # Set mount command
-    cmd = [
-      'sudo', 'mount',
-      '//{IP}/{Share}'.format(**server).replace('\\', '/'),
-      '/Backups/{Name}'.format(**server),
-      '-o', ','.join(cmd_options),
-      ]
-
-    # Set result messages
-    warning = 'Failed to mount /Backups/{Name}, {IP} unreachable.'.format(
-      **server)
-    error = 'Failed to mount /Backups/{Name}'.format(**server)
-    success = 'Mounted /Backups/{Name}'.format(**server)
-
-  # Test connection
-  try:
-    ping(server['IP'])
-  except subprocess.CalledProcessError:
-    print_warning(warning)
-    sleep(1)
-    return False
-
-  # Mount
-  try:
-    run_program(cmd)
-  except Exception:
-    print_error(error)
-    sleep(1)
-  else:
-    print_info(success)
-    server['Mounted'] = True
-
-
-def run_fast_copy(items, dest):
-  """Copy items to dest using FastCopy."""
-  if not items:
-    raise Exception
-
-  cmd = [global_vars['Tools']['FastCopy'], *FAST_COPY_ARGS]
-  cmd.append(r'/logfile={LogDir}\Tools\FastCopy.log'.format(**global_vars))
-  cmd.extend(items)
-  cmd.append('/to={}\\'.format(dest))
-
-  run_program(cmd)
-
-
-def run_wimextract(source, items, dest):
-  """Extract items from source WIM to dest folder."""
-  if not items:
-    raise Exception
-  extract_item('wimlib', silent=True)
-
-  # Write files.txt
-  with open(r'{}\wim_files.txt'.format(global_vars['TmpDir']), 'w',
-    encoding='utf-8') as f:
-    # Defaults
-    for item in items:
-      f.write('{}\n'.format(item))
-  sleep(1) # For safety?
-
-  # Extract files
-  cmd = [
-    global_vars['Tools']['wimlib-imagex'],
-    'extract',
-    source, '1',
-    r'@{}\wim_files.txt'.format(global_vars['TmpDir']),
-    '--dest-dir={}\\'.format(dest),
-    '--no-acls',
-    '--nullglob']
-  run_program(cmd)
-
-
-def list_source_items(source_obj, rel_path=None):
-  """List items in a dir or WIM, returns list of SourceItem objects."""
-  items = []
-  rel_path = '{}{}'.format(os.sep, rel_path) if rel_path else ''
-  if source_obj.is_dir():
-    source_path = '{}{}'.format(source_obj.path, rel_path)
-    items = [SourceItem(name=item.name, path=item.path)
-      for item in os.scandir(source_path)]
-  else:
-    # Prep wimlib-imagex
-    if psutil.WINDOWS:
-      extract_item('wimlib', silent=True)
-    cmd = [
-      global_vars['Tools']['wimlib-imagex'], 'dir',
-      source_obj.path, '1']
-    if rel_path:
-      cmd.append('--path={}'.format(rel_path))
-
-    # Get item list
-    try:
-      items = run_program(cmd)
-    except subprocess.CalledProcessError:
-      print_error('ERROR: Failed to get file list.')
-      raise
-
-    # Strip non-root items
-    items = [fix_path_sep(i.strip())
-      for i in items.stdout.decode('utf-8', 'ignore').splitlines()]
-    if rel_path:
-      items = [i.replace(rel_path, '') for i in items]
-    items = [i for i in items
-      if i.count(os.sep) == 1 and i.strip() != os.sep]
-    items = [SourceItem(name=i[1:], path=rel_path+i) for i in items]
-
-  # Done
-  return items
-
-
-def scan_source(source_obj, dest_path, rel_path='', interactive=True):
-  """Scan source for files/folders to transfer, returns list.
-
-  This will scan the root and (recursively) any Windows.old folders."""
-  selected_items = []
-  win_olds = []
-
-  # Root Items
-  root_items = []
-  item_list = list_source_items(source_obj, rel_path)
-  for item in item_list:
-    if REGEX_WINDOWS_OLD.search(item.name):
-      item.name = '{}{}{}'.format(
-        rel_path,
-        os.sep if rel_path else '',
-        item.name)
-      win_olds.append(item)
-    elif REGEX_INCL_ROOT_ITEMS.search(item.name):
-      print_success('Auto-Selected: {}'.format(item.path))
-      root_items.append('{}'.format(item.path))
-    elif not REGEX_EXCL_ROOT_ITEMS.search(item.name):
-      if not interactive:
-        print_success('Auto-Selected: {}'.format(item.path))
-        root_items.append('{}'.format(item.path))
-      else:
-        prompt = 'Transfer: "{}{}{}" ?'.format(
-          rel_path,
-          os.sep if rel_path else '',
-          item.name)
-        choices = ['Yes', 'No', 'All', 'Quit']
-        answer = choice(prompt=prompt, choices=choices)
-        if answer == 'Quit':
-          abort()
-        elif answer == 'All':
-          interactive = False
-        if answer in ['Yes', 'All']:
-          root_items.append('{}'.format(item.path))
-  if root_items:
-    selected_items.append({
-      'Message':    '{}{}Root Items...'.format(
-        rel_path,
-        ' ' if rel_path else ''),
-      'Items':    root_items.copy(),
-      'Destination':  dest_path})
-
-  # Fonts
-  font_obj = get_source_item_obj(source_obj, rel_path, 'Windows/Fonts')
-  if font_obj:
-    selected_items.append({
-      'Message':    '{}{}Fonts...'.format(
-        rel_path,
-        ' ' if rel_path else ''),
-      'Items':    [font_obj.path],
-      'Destination':  '{}{}Windows'.format(
-        dest_path, os.sep)})
-
-  # Registry
-  registry_items = []
-  for folder in ['config', 'OEM']:
-    folder_obj = get_source_item_obj(
-      source_obj, rel_path, 'Windows/System32/{}'.format(folder))
-    if folder_obj:
-      registry_items.append(folder_obj.path)
-  if registry_items:
-    selected_items.append({
-      'Message':    '{}{}Registry...'.format(
-        rel_path,
-        ' ' if rel_path else ''),
-      'Items':    registry_items.copy(),
-      'Destination':  '{}{}Windows{}System32'.format(
-        dest_path, os.sep, os.sep)})
-
-  # Windows.old(s)
-  for old in win_olds:
-    selected_items.extend(scan_source(
-      source_obj,
-      '{}{}{}'.format(dest_path, os.sep, old.name),
-      rel_path=old.name,
-      interactive=False))
-
-  # Done
-  return selected_items
-
-
-def get_source_item_obj(source_obj, rel_path, item_path):
-  """Check if the item exists, returns SourceItem object or None."""
-  item_obj = None
-  item_path = fix_path_sep(item_path)
-  if source_obj.is_dir():
-    item_obj = SourceItem(
-      name = item_path,
-      path = '{}{}{}{}{}'.format(
-        source_obj.path,
-        os.sep,
-        rel_path,
-        os.sep if rel_path else '',
-        item_path))
-    if not os.path.exists(item_obj.path):
-      item_obj = None
-  else:
-    # Assuming WIM file
-    if psutil.WINDOWS:
-      extract_item('wimlib', silent=True)
-    cmd = [
-      global_vars['Tools']['wimlib-imagex'], 'dir',
-      source_obj.path, '1',
-      '--path={}'.format(item_path),
-      '--one-file-only']
-    try:
-      run_program(cmd)
-    except subprocess.CalledProcessError:
-      # function will return None below
-      pass
-    else:
-      item_obj = SourceItem(
-        name = item_path,
-        path = '{}{}{}{}'.format(
-          os.sep,
-          rel_path,
-          os.sep if rel_path else '',
-          item_path))
-  return item_obj
-
-
-def select_destination(folder_path, prompt='Select destination'):
-  """Select destination drive, returns path as string."""
-  disk = select_volume(prompt)
-  if 'fixed' not in disk['Disk'].opts:
-    folder_path = folder_path.replace('\\', '-')
-  path = '{disk}{folder_path}_{Date}'.format(
-    disk = disk['Disk'].mountpoint,
-    folder_path = folder_path,
-    **global_vars)
-
-  # Avoid merging with existing folder
-  path = non_clobber_rename(path)
-  os.makedirs(path, exist_ok=True)
-
-  return path
-
-
-def select_source(backup_prefix):
-  """Select matching backup from BACKUP_SERVERS, returns obj."""
-  selected_source = None
-  local_sources = []
-  remote_sources = []
-  sources = []
-  mount_backup_shares(read_write=False)
-
-  # Check for prefix folders on servers
-  for server in BACKUP_SERVERS:
-    if server['Mounted']:
-      print_standard('Scanning {}...'.format(server['Name']))
-      for d in os.scandir(r'\\{IP}\{Share}'.format(**server)):
-        if (d.is_dir()
-          and d.name.lower().startswith(backup_prefix.lower())):
-          # Add folder to remote_sources
-          remote_sources.append({
-            'Name': '{:9}| File-Based:   [DIR]  {}'.format(
-              server['Name'], d.name),
-            'Server': server,
-            'Sort': d.name,
-            'Source': d})
-
-  # Check for images and subfolders
-  for prefix_path in remote_sources.copy():
-    for item in os.scandir(prefix_path['Source'].path):
-      if item.is_dir():
-        # Add folder to remote_sources
-        remote_sources.append({
-          'Name': r'{:9}| File-Based:   [DIR]  {}\{}'.format(
-            prefix_path['Server']['Name'],  # Server
-            prefix_path['Source'].name,   # Prefix folder
-            item.name,            # Sub-folder
-            ),
-          'Server': prefix_path['Server'],
-          'Sort': r'{}\{}'.format(
-            prefix_path['Source'].name,   # Prefix folder
-            item.name,            # Sub-folder
-            ),
-          'Source': item})
-
-        # Check for images in folder
-        for subitem in os.scandir(item.path):
-          if REGEX_WIM_FILE.search(item.name):
-            # Add image to remote_sources
-            try:
-              size = human_readable_size(item.stat().st_size)
-            except Exception:
-              size = '  ?  ?' # unknown
-            remote_sources.append({
-              'Disabled': bool(not is_valid_wim_file(subitem)),
-              'Name': r'{:9}| Image-Based:  {:>7}  {}\{}\{}'.format(
-                prefix_path['Server']['Name'],  # Server
-                size,               # Size (duh)
-                prefix_path['Source'].name,   # Prefix folder
-                item.name,            # Sub-folder
-                subitem.name,           # Image file
-                ),
-              'Server': prefix_path['Server'],
-              'Sort': r'{}\{}\{}'.format(
-                prefix_path['Source'].name,   # Prefix folder
-                item.name,            # Sub-folder
-                subitem.name,           # Image file
-                ),
-              'Source': subitem})
-      elif REGEX_WIM_FILE.search(item.name):
-        # Add image to remote_sources
-        try:
-          size = human_readable_size(item.stat().st_size)
-        except Exception:
-          size = '  ?  ?' # unknown
-        remote_sources.append({
-          'Disabled': bool(not is_valid_wim_file(item)),
-          'Name': r'{:9}| Image-Based:  {:>7}  {}\{}'.format(
-            prefix_path['Server']['Name'],  # Server
-            size,               # Size (duh)
-            prefix_path['Source'].name,   # Prefix folder
-            item.name,            # Image file
-            ),
-          'Server': prefix_path['Server'],
-          'Sort': r'{}\{}'.format(
-            prefix_path['Source'].name,   # Prefix folder
-            item.name,            # Image file
-            ),
-          'Source': item})
-
-  # Check for local sources
-  print_standard('Scanning for local sources...')
-  set_thread_error_mode(silent=True) # Prevents "No disk" popups
-  sys_drive = global_vars['Env']['SYSTEMDRIVE']
-  for d in psutil.disk_partitions():
-    if re.search(r'^{}'.format(sys_drive), d.mountpoint, re.IGNORECASE):
-      # Skip current OS drive
-      continue
-    if 'fixed' in d.opts:
-      # Skip DVD, etc
-      local_sources.append({
-        'Name': '{:9}| File-Based:   [DISK] {}'.format(
-          '  Local', d.mountpoint),
-        'Sort': d.mountpoint,
-        'Source': LocalDisk(d)})
-      # Check for images and subfolders
-      for item in os.scandir(d.mountpoint):
-        if REGEX_WIM_FILE.search(item.name):
-          try:
-            size = human_readable_size(item.stat().st_size)
-          except Exception:
-            size = '  ?  ?' # unknown
-          local_sources.append({
-            'Disabled': bool(not is_valid_wim_file(item)),
-            'Name': r'{:9}| Image-Based:  {:>7}  {}{}'.format(
-              '  Local', size, d.mountpoint, item.name),
-            'Sort': r'{}{}'.format(d.mountpoint, item.name),
-            'Source': item})
-        elif REGEX_EXCL_ROOT_ITEMS.search(item.name):
-          pass
-        elif REGEX_EXCL_ITEMS.search(item.name):
-          pass
-        elif item.is_dir():
-          # Add folder to local_sources
-          local_sources.append({
-            'Name': r'{:9}| File-Based:   [DIR]  {}{}'.format(
-              '  Local', d.mountpoint, item.name),
-            'Sort': r'{}{}'.format(d.mountpoint, item.name),
-            'Source': item})
-
-  set_thread_error_mode(silent=False) # Return to normal
-
-  # Build Menu
-  local_sources.sort(key=itemgetter('Sort'))
-  remote_sources.sort(key=itemgetter('Sort'))
-  sources.extend(local_sources)
-  sources.extend(remote_sources)
-  actions = [{'Name': 'Quit', 'Letter': 'Q'}]
-
-  # Select backup from sources
-  if len(sources) > 0:
-    selection = menu_select(
-      'Which backup are we using?',
-      main_entries=sources,
-      action_entries=actions,
-      disabled_label='DAMAGED')
-    if selection == 'Q':
-      umount_backup_shares()
-      exit_script()
-    else:
-      selected_source = sources[int(selection)-1]['Source']
-  else:
-    print_error('ERROR: No backups found using prefix: {}.'.format(
-      backup_prefix))
-    umount_backup_shares()
-    pause("Press Enter to exit...")
-    exit_script()
-
-  # Sanity check
-  if selected_source.is_file():
-    # Image-Based
-    if not REGEX_WIM_FILE.search(selected_source.name):
-      print_error('ERROR: Unsupported image: {}'.format(
-        selected_source.path))
-      raise GenericError
-
-  # Done
-  return selected_source
-
-
-def select_volume(title='Select disk', auto_select=True):
-  """Select disk from attached disks. returns dict."""
-  actions =   [{'Name': 'Quit', 'Letter': 'Q'}]
-  disks =   []
-
-  # Build list of disks
-  set_thread_error_mode(silent=True) # Prevents "No disk" popups
-  for d in psutil.disk_partitions():
-    info = {
-      'Disk': d,
-      'Name': d.mountpoint}
-    try:
-      usage = psutil.disk_usage(d.device)
-      free = '{free} / {total} available'.format(
-        free = human_readable_size(usage.free, 2),
-        total = human_readable_size(usage.total, 2))
-    except Exception:
-      # Meh, leaving unsupported destinations out
-      pass
-      # free = 'Unknown'
-      # info['Disabled'] = True
-    else:
-      info['Display Name'] = '{}  ({})'.format(info['Name'], free)
-      disks.append(info)
-  set_thread_error_mode(silent=False) # Return to normal
-
-  # Skip menu?
-  if len(disks) == 1 and auto_select:
-    return disks[0]
-
-  # Show menu
-  selection = menu_select(title, main_entries=disks, action_entries=actions)
-  if selection == 'Q':
-    exit_script()
-  else:
-    return disks[int(selection)-1]
-
-
-def set_thread_error_mode(silent=True):
-  """Disable or Enable Windows error message dialogs.
-
-  Disable when scanning disks to avoid popups for empty cardreaders, etc
-  """
-  # Code borrowed from: https://stackoverflow.com/a/29075319
-  kernel32 = ctypes.WinDLL('kernel32')
-
-  if silent:
-    kernel32.SetThreadErrorMode(SEM_FAIL, ctypes.byref(SEM_NORMAL))
-  else:
-    kernel32.SetThreadErrorMode(SEM_NORMAL, ctypes.byref(SEM_NORMAL))
-
-
-def transfer_source(source_obj, dest_path, selected_items):
-  """Transfer, or extract, files/folders from source to destination."""
-  if source_obj.is_dir():
-    # Run FastCopy for each selection "group"
-    for group in selected_items:
-      try_and_print(message=group['Message'],
-        function=run_fast_copy, cs='Done',
-        items=group['Items'],
-        dest=group['Destination'])
-  else:
-    if REGEX_WIM_FILE.search(source_obj.name):
-      # Extract files from WIM
-      for group in selected_items:
-        try_and_print(message=group['Message'],
-          function=run_wimextract, cs='Done',
-          source=source_obj.path,
-          items=group['Items'],
-          dest=dest_path)
-    else:
-      print_error('ERROR: Unsupported image: {}'.format(source_obj.path))
-      raise GenericError
-
-
-def umount_backup_shares():
-  """Unmount the backup shares regardless of current status."""
-  for server in BACKUP_SERVERS:
-    umount_network_share(server)
-
-
-def umount_network_share(server):
-  """Unmount a network share defined by server."""
-  cmd = r'net use \\{IP}\{Share} /delete'.format(**server)
-  cmd = cmd.split(' ')
-  try:
-    run_program(cmd)
-  except Exception:
-    print_error(r'Failed to umount \\{Name}\{Share}.'.format(**server))
-    sleep(1)
-  else:
-    print_info('Umounted {Name}'.format(**server))
-    server['Mounted'] = False
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/disk.py

@@ -1,414 +0,0 @@
-# Wizard Kit: Functions - Disk
-
-from functions.common import *
-from settings.partition_uids import *
-
-
-# Regex
-REGEX_BAD_PARTITION = re.compile(r'(RAW|Unknown)', re.IGNORECASE)
-REGEX_DISK_GPT = re.compile(
-  r'Disk ID: {[A-Z0-9]+-[A-Z0-9]+-[A-Z0-9]+-[A-Z0-9]+-[A-Z0-9]+}',
-  re.IGNORECASE)
-REGEX_DISK_MBR = re.compile(r'Disk ID: [A-Z0-9]+', re.IGNORECASE)
-REGEX_DISK_RAW = re.compile(r'Disk ID: 00000000', re.IGNORECASE)
-
-
-def assign_volume_letters():
-  """Assign a volume letter to all available volumes."""
-  remove_volume_letters()
-
-  # Write script
-  script = []
-  for vol in get_volumes():
-    script.append('select volume {}'.format(vol['Number']))
-    script.append('assign')
-
-  # Run
-  run_diskpart(script)
-
-
-def get_boot_mode():
-  """Check if the boot mode was UEFI or legacy."""
-  boot_mode = 'Legacy'
-  try:
-    reg_key = winreg.OpenKey(
-      winreg.HKEY_LOCAL_MACHINE, r'System\CurrentControlSet\Control')
-    reg_value = winreg.QueryValueEx(reg_key, 'PEFirmwareType')[0]
-    if reg_value == 2:
-      boot_mode = 'UEFI'
-  except:
-    boot_mode = 'Unknown'
-
-  return boot_mode
-
-
-def get_disk_details(disk):
-  """Get disk details using DiskPart."""
-  details = {}
-  script = [
-    'select disk {}'.format(disk['Number']),
-    'detail disk']
-
-  # Run
-  try:
-    result = run_diskpart(script)
-  except subprocess.CalledProcessError:
-    pass
-  else:
-    output = result.stdout.decode().strip()
-    # Remove empty lines
-    tmp = [s.strip() for s in output.splitlines() if s.strip() != '']
-    # Set disk name
-    details['Name'] = tmp[4]
-    # Split each line on ':' skipping those without ':'
-    tmp = [s.split(':') for s in tmp if ':' in s]
-    # Add key/value pairs to the details variable and return dict
-    details.update({key.strip(): value.strip() for (key, value) in tmp})
-
-  return details
-
-
-def get_disks():
-  """Get list of attached disks using DiskPart."""
-  disks = []
-
-  try:
-    # Run script
-    result = run_diskpart(['list disk'])
-  except subprocess.CalledProcessError:
-    pass
-  else:
-    # Append disk numbers
-    output = result.stdout.decode().strip()
-    for tmp in re.findall(r'Disk (\d+)\s+\w+\s+(\d+\s+\w+)', output):
-      num = tmp[0]
-      size = human_readable_size(tmp[1])
-      disks.append({'Number': num, 'Size': size})
-
-  return disks
-
-
-def get_partition_details(disk, partition):
-  """Get partition details using DiskPart and fsutil."""
-  details = {}
-  script = [
-    'select disk {}'.format(disk['Number']),
-    'select partition {}'.format(partition['Number']),
-    'detail partition']
-
-  # Diskpart details
-  try:
-    # Run script
-    result = run_diskpart(script)
-  except subprocess.CalledProcessError:
-    pass
-  else:
-    # Get volume letter or RAW status
-    output = result.stdout.decode().strip()
-    tmp = re.search(r'Volume\s+\d+\s+(\w|RAW)\s+', output)
-    if tmp:
-      if tmp.group(1).upper() == 'RAW':
-        details['FileSystem'] = RAW
-      else:
-        details['Letter'] = tmp.group(1)
-    # Remove empty lines from output
-    tmp = [s.strip() for s in output.splitlines() if s.strip() != '']
-    # Split each line on ':' skipping those without ':'
-    tmp = [s.split(':') for s in tmp if ':' in s]
-    # Add key/value pairs to the details variable and return dict
-    details.update({key.strip(): value.strip() for (key, value) in tmp})
-
-  # Get MBR type / GPT GUID for extra details on "Unknown" partitions
-  guid = PARTITION_UIDS.get(details.get('Type').upper(), {})
-  if guid:
-    details.update({
-      'Description':  guid.get('Description', '')[:29],
-      'OS':       guid.get('OS', 'Unknown')[:27]})
-
-  if 'Letter' in details:
-    # Disk usage
-    try:
-      tmp = psutil.disk_usage('{}:\\'.format(details['Letter']))
-    except OSError as err:
-      details['FileSystem'] = 'Unknown'
-      details['Error'] = err.strerror
-    else:
-      details['Used Space'] = human_readable_size(tmp.used)
-
-    # fsutil details
-    cmd = [
-      'fsutil',
-      'fsinfo',
-      'volumeinfo',
-      '{}:'.format(details['Letter'])
-      ]
-    try:
-      result = run_program(cmd)
-    except subprocess.CalledProcessError:
-      pass
-    else:
-      output = result.stdout.decode().strip()
-      # Remove empty lines from output
-      tmp = [s.strip() for s in output.splitlines() if s.strip() != '']
-      # Add "Feature" lines
-      details['File System Features'] = [s.strip() for s in tmp
-        if ':' not in s]
-      # Split each line on ':' skipping those without ':'
-      tmp = [s.split(':') for s in tmp if ':' in s]
-      # Add key/value pairs to the details variable and return dict
-      details.update({key.strip(): value.strip() for (key, value) in tmp})
-
-  # Set Volume Name
-  details['Name'] = details.get('Volume Name', '')
-
-  # Set FileSystem Type
-  if details.get('FileSystem', '') not in ['RAW', 'Unknown']:
-    details['FileSystem'] = details.get('File System Name', 'Unknown')
-
-  return details
-
-
-def get_partitions(disk):
-  """Get list of partition using DiskPart."""
-  partitions = []
-  script = [
-    'select disk {}'.format(disk['Number']),
-    'list partition']
-
-  try:
-    # Run script
-    result = run_diskpart(script)
-  except subprocess.CalledProcessError:
-    pass
-  else:
-    # Append partition numbers
-    output = result.stdout.decode().strip()
-    regex = r'Partition\s+(\d+)\s+\w+\s+(\d+\s+\w+)\s+'
-    for tmp in re.findall(regex, output, re.IGNORECASE):
-      num = tmp[0]
-      size = human_readable_size(tmp[1])
-      partitions.append({'Number': num, 'Size': size})
-
-  return partitions
-
-
-def get_table_type(disk):
-  """Get disk partition table type using DiskPart."""
-  part_type = 'Unknown'
-  script = [
-    'select disk {}'.format(disk['Number']),
-    'uniqueid disk']
-
-  try:
-    result = run_diskpart(script)
-  except subprocess.CalledProcessError:
-    pass
-  else:
-    output = result.stdout.decode().strip()
-    if REGEX_DISK_GPT.search(output):
-      part_type = 'GPT'
-    elif REGEX_DISK_MBR.search(output):
-      part_type = 'MBR'
-    elif REGEX_DISK_RAW.search(output):
-      part_type = 'RAW'
-
-  return part_type
-
-
-def get_volumes():
-  """Get list of volumes using DiskPart."""
-  vols = []
-  try:
-    result = run_diskpart(['list volume'])
-  except subprocess.CalledProcessError:
-    pass
-  else:
-    # Append volume numbers
-    output = result.stdout.decode().strip()
-    for tmp in re.findall(r'Volume (\d+)\s+([A-Za-z]?)\s+', output):
-      vols.append({'Number': tmp[0], 'Letter': tmp[1]})
-
-  return vols
-
-
-def is_bad_partition(par):
-  """Check if the partition is accessible."""
-  return 'Letter' not in par or REGEX_BAD_PARTITION.search(par['FileSystem'])
-
-
-def prep_disk_for_formatting(disk=None):
-  """Gather details about the disk and its partitions."""
-  disk['Format Warnings'] = '\n'
-  width = len(str(len(disk['Partitions'])))
-
-  # Bail early
-  if disk is None:
-    raise Exception('Disk not provided.')
-
-  # Set boot method and partition table type
-  disk['Use GPT'] = True
-  if (get_boot_mode() == 'UEFI'):
-    if (not ask("Setup Windows to use UEFI booting?")):
-      disk['Use GPT'] = False
-  else:
-    if (ask("Setup Windows to use BIOS/Legacy booting?")):
-      disk['Use GPT'] = False
-
-  # Set Display and Warning Strings
-  if len(disk['Partitions']) == 0:
-    disk['Format Warnings'] += 'No partitions found\n'
-  for partition in disk['Partitions']:
-    display = '{size} {fs}'.format(
-      num = partition['Number'],
-      width = width,
-      size = partition['Size'],
-      fs = partition['FileSystem'])
-
-    if is_bad_partition(partition):
-      # Set display string using partition description & OS type
-      display += '\t\t{q}{name}{q}\t{desc} ({os})'.format(
-        display = display,
-        q = '"' if partition['Name'] != '' else '',
-        name = partition['Name'],
-        desc = partition['Description'],
-        os = partition['OS'])
-    else:
-      # List space used instead of partition description & OS type
-      display += ' (Used: {used})\t{q}{name}{q}'.format(
-        used = partition['Used Space'],
-        q = '"' if partition['Name'] != '' else '',
-        name = partition['Name'])
-    # For all partitions
-    partition['Display String'] = display
-
-
-def reassign_volume_letter(letter, new_letter='I'):
-  """Assign a new letter to a volume using DiskPart."""
-  if not letter:
-    # Ignore
-    return None
-  script = [
-    'select volume {}'.format(letter),
-    'remove noerr',
-    'assign letter={}'.format(new_letter)]
-  try:
-    run_diskpart(script)
-  except subprocess.CalledProcessError:
-    pass
-  else:
-    return new_letter
-
-
-def remove_volume_letters(keep=None):
-  """Remove all assigned volume letters using DiskPart."""
-  if not keep:
-    keep = ''
-
-  script = []
-  for vol in get_volumes():
-    if vol['Letter'].upper() != keep.upper():
-      script.append('select volume {}'.format(vol['Number']))
-      script.append('remove noerr')
-
-  # Run script
-  try:
-    run_diskpart(script)
-  except subprocess.CalledProcessError:
-    pass
-
-
-def run_diskpart(script):
-  """Run DiskPart script."""
-  tempfile = r'{}\diskpart.script'.format(global_vars['Env']['TMP'])
-
-  # Write script
-  with open(tempfile, 'w') as f:
-    for line in script:
-      f.write('{}\n'.format(line))
-
-  # Run script
-  cmd = [
-    r'{}\Windows\System32\diskpart.exe'.format(
-      global_vars['Env']['SYSTEMDRIVE']),
-    '/s', tempfile]
-  result = run_program(cmd)
-  sleep(2)
-  return result
-
-
-def scan_disks():
-  """Get details about the attached disks"""
-  disks = get_disks()
-
-  # Get disk details
-  for disk in disks:
-    # Get partition style
-    disk['Table'] = get_table_type(disk)
-
-    # Get disk name/model and physical details
-    disk.update(get_disk_details(disk))
-
-    # Get partition info for disk
-    disk['Partitions'] = get_partitions(disk)
-
-    for partition in disk['Partitions']:
-      # Get partition details
-      partition.update(get_partition_details(disk, partition))
-
-  # Done
-  return disks
-
-
-def select_disk(title='Which disk?', disks=[]):
-  """Select a disk from the attached disks"""
-  # Build menu
-  disk_options = []
-  for disk in disks:
-    display_name = '{}\t[{}] ({}) {}'.format(
-      disk.get('Size', ''),
-      disk.get('Table', ''),
-      disk.get('Type', ''),
-      disk.get('Name', 'Unknown'),
-      )
-    pwidth=len(str(len(disk['Partitions'])))
-    for partition in disk['Partitions']:
-      # Main text
-      p_name = 'Partition {num:>{width}}: {size} ({fs})'.format(
-        num = partition['Number'],
-        width = pwidth,
-        size = partition['Size'],
-        fs = partition['FileSystem'])
-      if partition['Name']:
-        p_name += '\t"{}"'.format(partition['Name'])
-
-      # Show unsupported partition(s)
-      if is_bad_partition(partition):
-        p_name = '{YELLOW}{p_name}{CLEAR}'.format(
-          p_name=p_name, **COLORS)
-
-      display_name += '\n\t\t\t{}'.format(p_name)
-    if not disk['Partitions']:
-      display_name += '\n\t\t\t{}No partitions found.{}'.format(
-        COLORS['YELLOW'], COLORS['CLEAR'])
-
-    disk_options.append({'Name': display_name, 'Disk': disk})
-  actions = [
-    {'Name': 'Main Menu', 'Letter': 'M'},
-    ]
-
-  # Menu loop
-  selection = menu_select(
-    title = title,
-    main_entries = disk_options,
-    action_entries = actions)
-
-  if (selection.isnumeric()):
-    return disk_options[int(selection)-1]['Disk']
-  elif (selection == 'M'):
-    raise GenericAbort
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/info.py

@@ -1,500 +0,0 @@
-# Wizard Kit: Functions - Information
-
-from borrowed import knownpaths
-from functions.activation import *
-from operator import itemgetter
-from settings.info import *
-
-
-def backup_file_list():
-  """Export current file listing for the system."""
-  extract_item('Everything', silent=True)
-  cmd = [
-    global_vars['Tools']['Everything'],
-    '-nodb',
-    '-create-filelist',
-    r'{LogDir}\File List.txt'.format(**global_vars),
-    global_vars['Env']['SYSTEMDRIVE']]
-  run_program(cmd)
-
-
-def backup_power_plans():
-  """Export current power plans."""
-  os.makedirs(r'{BackupDir}\Power Plans\{Date}'.format(
-    **global_vars), exist_ok=True)
-  plans = run_program(['powercfg', '/L'])
-  plans = plans.stdout.decode().splitlines()
-  plans = [p for p in plans if re.search(r'^Power Scheme', p)]
-  for p in plans:
-    guid = re.sub(r'Power Scheme GUID:\s+([0-9a-f\-]+).*', r'\1', p)
-    name = re.sub(
-      r'Power Scheme GUID:\s+[0-9a-f\-]+\s+\(([^\)]+)\).*', r'\1', p)
-    out = r'{BackupDir}\Power Plans\{Date}\{name}.pow'.format(
-      name=name, **global_vars)
-    if not os.path.exists(out):
-      cmd = ['powercfg', '-export', out, guid]
-      run_program(cmd, check=False)
-
-
-def backup_registry(overwrite=False):
-  """Backup registry including user hives."""
-  extract_item('erunt', silent=True)
-  cmd = [
-    global_vars['Tools']['ERUNT'],
-    r'{BackupDir}\Registry\{Date}'.format(**global_vars),
-    'sysreg',
-    'curuser',
-    'otherusers',
-    '/noprogresswindow']
-  if overwrite:
-    cmd.append('/noconfirmdelete')
-  run_program(cmd)
-
-
-def get_folder_size(path):
-  """Get (human-readable) size of folder passed, returns str."""
-  size = 'Unknown'
-  cmd = [global_vars['Tools']['Du'], '-c', '-nobanner', '-q', path]
-  try:
-    out = run_program(cmd)
-  except FileNotFoundError:
-    # Failed to find folder
-    pass
-  except subprocess.CalledProcessError:
-    # Failed to get folder size
-    pass
-  else:
-    try:
-      size = out.stdout.decode().split(',')[-2]
-    except IndexError:
-      # Failed to parse csv data
-      pass
-    else:
-      size = human_readable_size(size)
-  return size
-
-
-def get_installed_antivirus():
-  """Get list of installed Antivirus programs."""
-  programs = []
-  cmd = ['WMIC', r'/namespace:\\root\SecurityCenter2',
-    'path', 'AntivirusProduct',
-    'get', 'displayName', '/value']
-  out = run_program(cmd)
-  out = out.stdout.decode().strip()
-  products = out.splitlines()
-  products = [p.split('=')[1] for p in products if p]
-  for prod in sorted(products):
-    # Get product state and check if it's enabled
-    # credit: https://jdhitsolutions.com/blog/powershell/5187/get-antivirus-product-status-with-powershell/
-    cmd = ['WMIC', r'/namespace:\\root\SecurityCenter2',
-      'path', 'AntivirusProduct',
-      'where', 'displayName="{}"'.format(prod),
-      'get', 'productState', '/value']
-    out = run_program(cmd)
-    out = out.stdout.decode().strip()
-    state = out.split('=')[1]
-    state = hex(int(state))
-    if str(state)[3:5] not in ['10', '11']:
-      programs.append('[Disabled] {}'.format(prod))
-    else:
-      programs.append(prod)
-
-  if len(programs) == 0:
-    programs = ['No programs found']
-  return programs
-
-
-def get_installed_office():
-  """Get list of installed Office programs."""
-  programs = []
-  log_file = r'{LogDir}\Installed Program List (AIDA64).txt'.format(
-    **global_vars)
-  with open (log_file, 'r') as f:
-    for line in sorted(f.readlines()):
-      if REGEX_OFFICE.search(line):
-        programs.append(line[4:82].strip())
-
-  if len(programs) == 0:
-    programs = ['No programs found']
-  return programs
-
-
-def get_shell_path(folder, user='current'):
-  """Get shell path using knownpaths, returns str.
-
-  NOTE: Only works for the current user.
-  Code based on https://gist.github.com/mkropat/7550097
-  """
-  path = None
-  folderid = None
-  if user.lower() == 'public':
-    user = 'common'
-  try:
-    folderid = getattr(knownpaths.FOLDERID, folder)
-  except AttributeError:
-    # Unknown folder ID, ignore and return None
-    pass
-
-  if folderid:
-    try:
-      path = knownpaths.get_path(
-        folderid, getattr(knownpaths.UserHandle, user))
-    except PathNotFoundError:
-      # Folder not found, ignore and return None
-      pass
-
-  return path
-
-
-def get_user_data_paths(user):
-  """Get user data paths for provided user, returns dict."""
-  hive_path = user['SID']
-  paths = {
-    'Profile': {
-      'Path': None,
-      },
-    'Shell Folders': {},
-    'Extra Folders': {},
-    }
-  unload_hive = False
-
-  if user['Name'] == global_vars['Env']['USERNAME']:
-    # We can use SHGetKnownFolderPath for the current user
-    paths['Profile']['Path'] = get_shell_path('Profile')
-    paths['Shell Folders'] = {f: {'Path': get_shell_path(f)}
-      for f in SHELL_FOLDERS.keys()}
-  else:
-    # We have to use the NTUSER.dat hives which isn't recommended by MS
-    try:
-      key_path = r'{}\{}'.format(REG_PROFILE_LIST, user['SID'])
-      with winreg.OpenKey(HKLM, key_path) as key:
-        paths['Profile']['Path'] = winreg.QueryValueEx(
-          key, 'ProfileImagePath')[0]
-    except Exception:
-      # Profile path not found, leaving as None.
-      pass
-
-    # Shell folders (Prep)
-    if not reg_path_exists(HKU, hive_path) and paths['Profile']['Path']:
-      # User not logged-in, loading hive
-      # Also setting unload_hive so it will be unloaded later.
-      hive_path = TMP_HIVE_PATH
-      cmd = ['reg', 'load', r'HKU\{}'.format(TMP_HIVE_PATH),
-        r'{}\NTUSER.DAT'.format(paths['Profile']['Path'])]
-      unload_hive = True
-      try:
-        run_program(cmd)
-      except subprocess.CalledProcessError:
-        # Failed to load user hive
-        pass
-
-    # Shell folders
-    shell_folders = r'{}\{}'.format(hive_path, REG_SHELL_FOLDERS)
-    if (reg_path_exists(HKU, hive_path)
-      and reg_path_exists(HKU, shell_folders)):
-      with winreg.OpenKey(HKU, shell_folders) as key:
-        for folder, values in SHELL_FOLDERS.items():
-          for value in values:
-            try:
-              path = winreg.QueryValueEx(key, value)[0]
-            except FileNotFoundError:
-              # Skip missing values
-              pass
-            else:
-              paths['Shell Folders'][folder] = {'Path': path}
-              # Stop checking values for this folder
-              break
-
-    # Shell folder (extra check)
-    if paths['Profile']['Path']:
-      for folder in SHELL_FOLDERS.keys():
-        folder_path = r'{Path}\{folder}'.format(
-          folder=folder, **paths['Profile'])
-        if (folder not in paths['Shell Folders']
-          and os.path.exists(folder_path)):
-          paths['Shell Folders'][folder] = {'Path': folder_path}
-
-  # Extra folders
-  if paths['Profile']['Path']:
-    for folder in EXTRA_FOLDERS:
-      folder_path = r'{Path}\{folder}'.format(
-        folder=folder, **paths['Profile'])
-      if os.path.exists(folder_path):
-        paths['Extra Folders'][folder] = {'Path': folder_path}
-
-  # Shell folders (cleanup)
-  if unload_hive:
-    cmd = ['reg', 'unload', r'HKU\{}'.format(TMP_HIVE_PATH)]
-    run_program(cmd, check=False)
-
-  # Done
-  return paths
-
-
-def get_user_folder_sizes(users):
-  """Update list(users) to include folder paths and sizes."""
-  extract_item('du', filter='du*', silent=True)
-  # Configure Du
-  winreg.CreateKey(HKCU, r'Software\Sysinternals\Du')
-  with winreg.OpenKey(HKCU,
-    r'Software\Sysinternals\Du', access=winreg.KEY_WRITE) as key:
-    winreg.SetValueEx(key, 'EulaAccepted', 0, winreg.REG_DWORD, 1)
-
-  for u in users:
-    u.update(get_user_data_paths(u))
-    if u['Profile']['Path']:
-      u['Profile']['Size'] = get_folder_size(u['Profile']['Path'])
-      for folder in u['Shell Folders'].keys():
-        u['Shell Folders'][folder]['Size'] = get_folder_size(
-          u['Shell Folders'][folder]['Path'])
-      for folder in u['Extra Folders'].keys():
-        u['Extra Folders'][folder]['Size'] = get_folder_size(
-          u['Extra Folders'][folder]['Path'])
-
-
-def get_user_list():
-  """Get user list via WMIC, returns list of dicts."""
-  users = []
-
-  # Get user info from WMI
-  cmd = ['wmic', 'useraccount', 'get', '/format:csv']
-  try:
-    out = run_program(cmd)
-  except subprocess.CalledProcessError:
-    # Meh, return empty list to avoid a full crash
-    return users
-
-  entries = out.stdout.decode().splitlines()
-  entries = [e.strip().split(',') for e in entries if e.strip()]
-
-  # Add user(s) to dict
-  keys = entries[0]
-  for e in entries[1:]:
-    # Create dict using 1st line (keys)
-    e = dict(zip(keys, e))
-    # Set Active status via 'Disabled' TRUE/FALSE str
-    e['Active'] = bool(e['Disabled'].upper() == 'FALSE')
-    # Assume SIDs ending with 1000+ are "Standard" and others are "System"
-    e['Type'] = 'Standard' if re.search(r'-1\d+$', e['SID']) else 'System'
-    users.append(e)
-
-  # Sort list
-  users.sort(key=itemgetter('Name'))
-
-  # Done
-  return users
-
-
-def reg_path_exists(hive, path):
-  """Test if specified path exists, returns bool."""
-  try:
-    winreg.QueryValue(hive, path)
-  except FileNotFoundError:
-    return False
-  else:
-    return True
-
-
-def run_aida64():
-  """Run AIDA64 to save system reports."""
-  extract_item('AIDA64', silent=True)
-  # All system info
-  config = r'{BinDir}\AIDA64\full.rpf'.format(**global_vars)
-  report_file = r'{LogDir}\System Information (AIDA64).html'.format(
-    **global_vars)
-  if not os.path.exists(report_file):
-    cmd = [
-      global_vars['Tools']['AIDA64'],
-      '/R', report_file,
-      '/CUSTOM', config,
-      '/HTML', '/SILENT', '/SAFEST']
-    run_program(cmd, check=False)
-
-  # Installed Programs
-  config = r'{BinDir}\AIDA64\installed_programs.rpf'.format(**global_vars)
-  report_file = r'{LogDir}\Installed Program List (AIDA64).txt'.format(
-    **global_vars)
-  if not os.path.exists(report_file):
-    cmd = [
-      global_vars['Tools']['AIDA64'],
-      '/R', report_file,
-      '/CUSTOM', config,
-      '/TEXT', '/SILENT', '/SAFEST']
-    run_program(cmd, check=False)
-
-  # Product Keys
-  config = r'{BinDir}\AIDA64\licenses.rpf'.format(**global_vars)
-  report_file = r'{LogDir}\Product Keys (AIDA64).txt'.format(**global_vars)
-  if not os.path.exists(report_file):
-    cmd = [
-      global_vars['Tools']['AIDA64'],
-      '/R', report_file,
-      '/CUSTOM', config,
-      '/TEXT', '/SILENT', '/SAFEST']
-    run_program(cmd, check=False)
-
-
-def run_bleachbit(cleaners=None, preview=True):
-  """Run BleachBit preview and save log.
-
-  If preview is True then no files should be deleted."""
-  error_path = r'{}\Tools\BleachBit.err'.format(global_vars['LogDir'])
-  log_path = error_path.replace('err', 'log')
-  extract_item('BleachBit', silent=True)
-
-  # Safety check
-  if not cleaners:
-    # Disable cleaning and use preset config
-    cleaners = ['--preset']
-    preview = True
-
-  # Run
-  cmd = [
-    global_vars['Tools']['BleachBit'],
-    '--preview' if preview else '--clean']
-  cmd.extend(cleaners)
-  out = run_program(cmd, check=False)
-
-  # Save stderr
-  if out.stderr.decode().splitlines():
-    with open(error_path, 'a', encoding='utf-8') as f:
-      for line in out.stderr.decode().splitlines():
-        f.write(line.strip() + '\n')
-
-  # Save stdout
-  with open(log_path, 'a', encoding='utf-8') as f:
-    for line in out.stdout.decode().splitlines():
-      f.write(line.strip() + '\n')
-
-
-def show_disk_usage(disk):
-  """Show free and used space for a specified disk."""
-  print_standard('{:5}'.format(disk.device.replace('/', ' ')),
-    end='', flush=True, timestamp=False)
-  try:
-    usage = psutil.disk_usage(disk.device)
-    display_string = '{percent:>5.2f}% Free  ({free} / {total})'.format(
-      percent = 100 - usage.percent,
-      free = human_readable_size(usage.free, 2),
-      total = human_readable_size(usage.total, 2))
-    if usage.percent > 85:
-      print_error(display_string, timestamp=False)
-    elif usage.percent > 75:
-      print_warning(display_string, timestamp=False)
-    else:
-      print_standard(display_string, timestamp=False)
-  except Exception:
-    print_warning('Unknown', timestamp=False)
-
-
-def show_free_space(indent=8, width=32):
-  """Show free space info for all fixed disks."""
-  message = 'Free Space:'
-  for disk in psutil.disk_partitions():
-    try:
-      if 'fixed' in disk.opts:
-        try_and_print(message=message, function=show_disk_usage,
-          ns='Unknown', silent_function=False,
-          indent=indent, width=width, disk=disk)
-        message = ''
-    except Exception:
-      pass
-
-
-def show_installed_ram():
-  """Show installed RAM."""
-  mem = psutil.virtual_memory()
-  if mem.total > 5905580032:
-    # > 5.5 Gb so 6Gb or greater
-    print_standard(human_readable_size(mem.total).strip(), timestamp=False)
-  elif mem.total > 3758096384:
-    # > 3.5 Gb so 4Gb or greater
-    print_warning(human_readable_size(mem.total).strip(), timestamp=False)
-  else:
-    print_error(human_readable_size(mem.total).strip(), timestamp=False)
-
-
-def show_os_activation():
-  """Show OS activation info."""
-  act_str = get_activation_string()
-  if windows_is_activated():
-    print_standard(act_str, timestamp=False)
-  elif re.search(r'unavailable', act_str, re.IGNORECASE):
-    print_warning(act_str, timestamp=False)
-  else:
-    print_error(act_str, timestamp=False)
-
-
-def show_os_name():
-  """Show extended OS name (including warnings)."""
-  os_name = global_vars['OS']['DisplayName']
-  if global_vars['OS']['Arch'] == 32:
-    # Show all 32-bit installs as an error message
-    print_error(os_name, timestamp=False)
-  else:
-    if re.search(
-        r'(preview build|unrecognized|unsupported)',
-        os_name,
-        re.IGNORECASE):
-      print_error(os_name, timestamp=False)
-    elif re.search(r'outdated', os_name, re.IGNORECASE):
-      print_warning(os_name, timestamp=False)
-    else:
-      print_standard(os_name, timestamp=False)
-
-
-def show_temp_files_size():
-  """Show total size of temp files identified by BleachBit."""
-  size_str = None
-  total = 0
-  with open(r'{LogDir}\Tools\BleachBit.log'.format(**global_vars), 'r') as f:
-    for line in f.readlines():
-      if re.search(r'^Disk space (to be |)recovered:', line, re.IGNORECASE):
-        size = re.sub(r'.*: ', '', line.strip())
-        size = re.sub(r'(\w)iB$', r' \1b', size)
-        total += convert_to_bytes(size)
-        size_str = human_readable_size(total, decimals=1)
-  if size_str is None:
-    print_warning('UNKNOWN', timestamp=False)
-  else:
-    print_standard(size_str, timestamp=False)
-
-
-def show_user_data_summary(indent=8, width=32):
-  """Print user data folder sizes for all users."""
-  users = get_user_list()
-  users = [u for u in users if u['Active']]
-  get_user_folder_sizes(users)
-  for user in users:
-    if ('Size' not in user['Profile']
-      and not any(user['Shell Folders'])
-      and not any(user['Extra Folders'])):
-      # Skip empty users
-      continue
-    print_success('{indent}User: {user}'.format(
-      indent = ' '*int(indent/2),
-      user = user['Name']))
-    for section in ['Profile', None, 'Shell Folders', 'Extra Folders']:
-      folders = []
-      if section is None:
-        # Divider
-        print_standard('{}{}'.format(' '*indent, '-'*(width+6)))
-      elif section == 'Profile':
-        folders = {'Profile': user['Profile']}
-      else:
-        folders = user[section]
-      for folder in folders:
-        print_standard(
-          '{indent}{folder:<{width}}{size:>6} ({path})'.format(
-            indent =  ' ' * indent,
-            width =   width,
-            folder =  folder,
-            size =    folders[folder].get('Size', 'Unknown'),
-            path =    folders[folder].get('Path', 'Unknown')))
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/json.py

@@ -1,32 +0,0 @@
-# Wizard Kit: Functions - JSON
-
-import json
-
-from functions.common import *
-
-def get_json_from_command(cmd, check=True, ignore_errors=True):
-  """Capture JSON content from cmd output, returns dict.
-
-  If the data can't be decoded then either an exception is raised
-  or an empty dict is returned depending on ignore_errors.
-  """
-  errors = 'strict'
-  json_data = {}
-
-  if ignore_errors:
-    errors = 'ignore'
-
-  try:
-    result = run_program(cmd, check=check, encoding='utf-8', errors=errors)
-    json_data = json.loads(result.stdout)
-  except (subprocess.CalledProcessError, json.decoder.JSONDecodeError):
-    if not ignore_errors:
-      raise
-
-  return json_data
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/product_keys.py

@@ -1,120 +0,0 @@
-# Wizard Kit: Functions - Product Keys
-
-from functions.common import *
-
-
-# Regex
-REGEX_REGISTRY_DIRS = re.compile(
-  r'^(config$|RegBack$|System32$|Transfer|Win)',
-  re.IGNORECASE)
-REGEX_SOFTWARE_HIVE = re.compile(r'^Software$', re.IGNORECASE)
-
-
-def extract_keys():
-  """Extract keys from provided hives and return a dict."""
-  keys = {}
-
-  # Extract keys
-  extract_item('ProduKey', silent=True)
-  for hive in find_software_hives():
-    cmd = [
-      global_vars['Tools']['ProduKey'],
-      '/IEKeys', '0',
-      '/WindowsKeys', '1',
-      '/OfficeKeys', '1',
-      '/ExtractEdition', '1',
-      '/nosavereg',
-      '/regfile', hive,
-      '/scomma', '']
-    try:
-      out = run_program(cmd)
-    except subprocess.CalledProcessError:
-      # Ignore and return empty dict
-      pass
-    else:
-      for line in out.stdout.decode().splitlines():
-        # Add key to keys under product only if unique
-        tmp = line.split(',')
-        product = tmp[0]
-        key = tmp[2]
-        if product not in keys:
-          keys[product] = []
-        if key not in keys[product]:
-          keys[product].append(key)
-
-  # Done
-  return keys
-
-
-def list_clientdir_keys():
-  """List product keys found in hives inside the ClientDir."""
-  keys = extract_keys()
-  key_list = []
-  if keys:
-    for product in sorted(keys):
-      key_list.append(product)
-      for key in sorted(keys[product]):
-        key_list.append('  {key}'.format(key=key))
-  else:
-    key_list.append('No keys found.')
-
-  return key_list
-
-
-def find_software_hives():
-  """Search for transferred SW hives and return a list."""
-  hives = []
-  search_paths = [global_vars['ClientDir']]
-
-  while len(search_paths) > 0:
-    for item in os.scandir(search_paths.pop(0)):
-      if item.is_dir() and REGEX_REGISTRY_DIRS.search(item.name):
-        search_paths.append(item.path)
-      if item.is_file() and REGEX_SOFTWARE_HIVE.search(item.name):
-        hives.append(item.path)
-
-  return hives
-
-
-def get_product_keys():
-  """List product keys from saved report."""
-  keys = []
-  log_file = r'{LogDir}\Product Keys (ProduKey).txt'.format(**global_vars)
-  with open (log_file, 'r') as f:
-    for line in f.readlines():
-      if re.search(r'^Product Name', line):
-        line = re.sub(r'^Product Name\s+:\s+(.*)', r'\1', line.strip())
-        keys.append(line)
-
-  if keys:
-    return keys
-  else:
-    return ['No product keys found']
-
-
-def run_produkey():
-  """Run ProduKey and save report in the ClientDir."""
-  extract_item('ProduKey', silent=True)
-  log_file = r'{LogDir}\Product Keys (ProduKey).txt'.format(**global_vars)
-  if not os.path.exists(log_file):
-    # Clear current configuration
-    for config in ['ProduKey.cfg', 'ProduKey64.cfg']:
-      config = r'{BinDir}\ProduKey\{config}'.format(
-        config=config, **global_vars)
-      try:
-        if os.path.exists(config):
-          os.remove(config)
-      except Exception:
-        pass
-    cmd = [
-      global_vars['Tools']['ProduKey'],
-      '/nosavereg',
-      '/stext',
-      log_file]
-    run_program(cmd, check=False)
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/repairs.py

@@ -1,136 +0,0 @@
-# Wizard Kit: Functions - Repairs
-
-from functions.common import *
-
-
-def run_chkdsk(repair=False):
-  """Run CHKDSK scan or schedule offline repairs."""
-  if repair:
-    run_chkdsk_offline()
-  else:
-    run_chkdsk_scan()
-
-
-def run_chkdsk_scan():
-  """Run CHKDSK in a "split window" and report errors."""
-  if global_vars['OS']['Version'] in ('8', '8.1', '10'):
-    cmd = ['chkdsk', global_vars['Env']['SYSTEMDRIVE'], '/scan', '/perf']
-  else:
-    cmd = ['chkdsk', global_vars['Env']['SYSTEMDRIVE']]
-  out = run_program(cmd, check=False)
-  # retcode == 0: no issues
-  # retcode == 1: fixed issues (also happens when chkdsk.exe is killed?)
-  # retcode == 2: issues
-  if int(out.returncode) > 0:
-    # print_error('  ERROR: CHKDSK encountered errors')
-    raise GenericError
-
-  # Save stderr
-  with open(r'{LogDir}\Tools\CHKDSK.err'.format(**global_vars), 'a') as f:
-    for line in out.stderr.decode().splitlines():
-      f.write(line.strip() + '\n')
-  # Save stdout
-  with open(r'{LogDir}\Tools\CHKDSK.log'.format(**global_vars), 'a') as f:
-    for line in out.stdout.decode().splitlines():
-      f.write(line.strip() + '\n')
-
-
-def run_chkdsk_offline():
-  """Set filesystem 'dirty bit' to force a chkdsk during next boot."""
-  cmd = [
-    'fsutil', 'dirty',
-    'set',
-    global_vars['Env']['SYSTEMDRIVE']]
-  out = run_program(cmd, check=False)
-  if int(out.returncode) > 0:
-    raise GenericError
-
-
-def run_dism(repair=False):
-  """Run DISM to either scan or repair component store health."""
-  if global_vars['OS']['Version'] in ('8', '8.1', '10'):
-    if repair:
-      # Restore Health
-      cmd = [
-        'DISM', '/Online',
-        '/Cleanup-Image', '/RestoreHealth',
-        r'/LogPath:"{LogDir}\Tools\DISM_RestoreHealth.log"'.format(
-          **global_vars),
-        '-new_console:n', '-new_console:s33V']
-    else:
-      # Scan Health
-      cmd = [
-        'DISM', '/Online',
-        '/Cleanup-Image', '/ScanHealth',
-        r'/LogPath:"{LogDir}\Tools\DISM_ScanHealth.log"'.format(
-          **global_vars),
-        '-new_console:n', '-new_console:s33V']
-    run_program(cmd, pipe=False, check=False, shell=True)
-    wait_for_process('dism')
-    # Now check health
-    cmd = [
-      'DISM', '/Online',
-      '/Cleanup-Image', '/CheckHealth',
-      r'/LogPath:"{LogDir}\Tools\DISM_CheckHealth.log"'.format(**global_vars)]
-    result = run_program(cmd, shell=True).stdout.decode()
-    # Check result
-    if 'no component store corruption detected' not in result.lower():
-      raise GenericError
-  else:
-    raise UnsupportedOSError
-
-
-def run_kvrt():
-  """Run KVRT."""
-  extract_item('KVRT', silent=True)
-  os.makedirs(global_vars['QuarantineDir'], exist_ok=True)
-  cmd = [
-    global_vars['Tools']['KVRT'],
-    '-accepteula', '-dontcryptsupportinfo', '-fixednames',
-    '-d', global_vars['QuarantineDir'],
-    '-processlevel', '3']
-  popen_program(cmd, pipe=False)
-
-
-def run_sfc_scan():
-  """Run SFC in a "split window" and report errors."""
-  cmd = [
-    r'{SYSTEMROOT}\System32\sfc.exe'.format(**global_vars['Env']),
-    '/scannow']
-  out = run_program(cmd, check=False)
-  # Save stderr
-  with open(r'{LogDir}\Tools\SFC.err'.format(**global_vars), 'a') as f:
-    for line in out.stderr.decode('utf-8', 'ignore').splitlines():
-      f.write(line.strip() + '\n')
-  # Save stdout
-  with open(r'{LogDir}\Tools\SFC.log'.format(**global_vars), 'a') as f:
-    for line in out.stdout.decode('utf-8', 'ignore').splitlines():
-      f.write(line.strip() + '\n')
-  # Check result
-  log_text = out.stdout.decode('utf-8', 'ignore').replace('\0', '')
-  if re.findall(r'did\s+not\s+find\s+any\s+integrity\s+violations', log_text):
-    pass
-  elif re.findall(r'successfully\s+repaired\s+them', log_text):
-    raise GenericRepair
-  else:
-    raise GenericError
-
-
-def run_tdsskiller():
-  """Run TDSSKiller."""
-  extract_item('TDSSKiller', silent=True)
-  os.makedirs(r'{QuarantineDir}\TDSSKiller'.format(
-    **global_vars), exist_ok=True)
-  cmd = [
-    global_vars['Tools']['TDSSKiller'],
-    '-l', r'{LogDir}\Tools\TDSSKiller.log'.format(**global_vars),
-    '-qpath', r'{QuarantineDir}\TDSSKiller'.format(**global_vars),
-    '-accepteula', '-accepteulaksn',
-    '-dcexact', '-tdlfs']
-  run_program(cmd, pipe=False)
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/safemode.py

@@ -1,45 +0,0 @@
-# Wizard Kit: Functions - SafeMode
-
-from functions.common import *
-
-
-# STATIC VARIABLES
-REG_MSISERVER = r'HKLM\SYSTEM\CurrentControlSet\Control\SafeBoot\Network\MSIServer'
-
-
-def disable_safemode_msi():
-  """Disable MSI access under safemode."""
-  cmd = ['reg', 'delete', REG_MSISERVER, '/f']
-  run_program(cmd)
-
-
-def disable_safemode():
-  """Edit BCD to remove safeboot value."""
-  cmd = ['bcdedit', '/deletevalue', '{default}', 'safeboot']
-  run_program(cmd)
-
-
-def enable_safemode_msi():
-  """Enable MSI access under safemode."""
-  cmd = ['reg', 'add', REG_MSISERVER, '/f']
-  run_program(cmd)
-  cmd = ['reg', 'add', REG_MSISERVER, '/ve',
-      '/t', 'REG_SZ', '/d', 'Service', '/f']
-  run_program(cmd)
-
-
-def enable_safemode():
-  """Edit BCD to set safeboot as default."""
-  cmd = ['bcdedit', '/set', '{default}', 'safeboot', 'network']
-  run_program(cmd)
-
-
-def reboot(delay=3):
-  cmd = ['shutdown', '-r', '-t', '{}'.format(delay)]
-  run_program(cmd, check=False)
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/sensors.py

@@ -1,243 +0,0 @@
-'''Wizard Kit: Functions - Sensors'''
-# pylint: disable=no-name-in-module,wildcard-import
-# vim: sts=2 sw=2 ts=2
-
-import json
-import re
-
-from functions.tmux import *
-from settings.sensors import *
-
-
-# Error Classes
-class ThermalLimitReachedError(Exception):
-  '''Thermal limit reached error.'''
-
-
-def clear_temps(sensor_data):
-  """Clear saved temps but keep structure, returns dict."""
-  for _section, _adapters in sensor_data.items():
-    for _adapter, _sources in _adapters.items():
-      for _source, _data in _sources.items():
-        _data['Temps'] = []
-
-
-def fix_sensor_str(_s):
-  """Cleanup string and return str."""
-  _s = re.sub(r'^(\w+)-(\w+)-(\w+)', r'\1 (\2 \3)', _s, re.IGNORECASE)
-  _s = _s.title()
-  _s = _s.replace('Coretemp', 'CPUTemp')
-  _s = _s.replace('Acpi', 'ACPI')
-  _s = _s.replace('ACPItz', 'ACPI TZ')
-  _s = _s.replace('Isa ', 'ISA ')
-  _s = _s.replace('Pci ', 'PCI ')
-  _s = _s.replace('Id ', 'ID ')
-  _s = re.sub(r'(\D+)(\d+)', r'\1 \2', _s, re.IGNORECASE)
-  _s = re.sub(r'^K (\d+)Temp', r'AMD K\1 Temps', _s, re.IGNORECASE)
-  _s = re.sub(r'T(ctl|die)', r'CPU (T\1)', _s, re.IGNORECASE)
-  return _s
-
-
-def generate_sensor_report(
-    sensor_data, *temp_labels,
-    colors=True, cpu_only=False):
-  """Generate report based on temp_labels, returns list if str."""
-  report = []
-  for _section, _adapters in sorted(sensor_data.items()):
-    # CPU temps then Other temps
-    if cpu_only and 'CPU' not in _section:
-      continue
-    for _adapter, _sources in sorted(_adapters.items()):
-      # Adapter
-      report.append(fix_sensor_str(_adapter))
-      for _source, _data in sorted(_sources.items()):
-        # Source
-        _line = '{:18}  '.format(fix_sensor_str(_source))
-        # Temps (skip label for Current)
-        for _label in temp_labels:
-          _line += '{}{}{} '.format(
-            _label.lower() if _label != 'Current' else '',
-            ': ' if _label != 'Current' else '',
-            get_temp_str(_data.get(_label, '???'), colors=colors))
-        report.append(_line)
-      if not cpu_only:
-        report.append(' ')
-
-  # Handle empty reports (i.e. no sensors detected)
-  if not report:
-    report = [
-      '{}WARNING: No sensors found{}'.format(
-        COLORS['YELLOW'] if colors else '',
-        COLORS['CLEAR'] if colors else ''),
-      ' ',
-      'Please monitor temps manually']
-
-  # Done
-  return report
-
-
-def get_colored_temp_str(temp):
-  """Get colored string based on temp, returns str."""
-  try:
-    temp = float(temp)
-  except ValueError:
-    return '{YELLOW}{temp}{CLEAR}'.format(temp=temp, **COLORS)
-  if temp > TEMP_LIMITS['RED']:
-    color = COLORS['RED']
-  elif temp > TEMP_LIMITS['ORANGE']:
-    color = COLORS['ORANGE']
-  elif temp > TEMP_LIMITS['YELLOW']:
-    color = COLORS['YELLOW']
-  elif temp > TEMP_LIMITS['GREEN']:
-    color = COLORS['GREEN']
-  elif temp > 0:
-    color = COLORS['BLUE']
-  else:
-    color = COLORS['CLEAR']
-  return '{color}{prefix}{temp:2.0f}°C{CLEAR}'.format(
-    color=color,
-    prefix='-' if temp < 0 else '',
-    temp=temp,
-    **COLORS)
-
-
-def get_raw_sensor_data():
-  """Read sensor data and return dict."""
-  json_data = {}
-  cmd = ['sensors', '-j']
-
-  # Get raw data
-  try:
-    result = run_program(cmd)
-    result = result.stdout.decode('utf-8', errors='ignore').splitlines()
-  except subprocess.CalledProcessError:
-    # Assuming no sensors available, set to empty list
-    result = []
-
-  # Workaround for bad sensors
-  raw_data = []
-  for line in result:
-    if line.strip() == ',':
-      # Assuming malformatted line caused by missing data
-      continue
-    raw_data.append(line)
-
-  # Parse JSON data
-  try:
-    json_data = json.loads('\n'.join(raw_data))
-  except json.JSONDecodeError:
-    # Still broken, just return the empty dict
-    pass
-
-  # Done
-  return json_data
-
-
-def get_sensor_data():
-  """Parse raw sensor data and return new dict."""
-  json_data = get_raw_sensor_data()
-  sensor_data = {'CPUTemps': {}, 'Other': {}}
-  for _adapter, _sources in json_data.items():
-    if is_cpu_adapter(_adapter):
-      _section = 'CPUTemps'
-    else:
-      _section = 'Other'
-    sensor_data[_section][_adapter] = {}
-    _sources.pop('Adapter', None)
-
-    # Find current temp and add to dict
-    ## current temp is labeled xxxx_input
-    for _source, _labels in _sources.items():
-      for _label, _temp in _labels.items():
-        if _label.startswith('fan'):
-          # Skip fan RPMs
-          continue
-        if 'input' in _label:
-          sensor_data[_section][_adapter][_source] = {
-            'Current': _temp,
-            'Label': _label,
-            'Max': _temp,
-            'Temps': [_temp],
-            }
-
-  # Remove empty sections
-  for _k, _v in sensor_data.items():
-    _v = {_k2: _v2 for _k2, _v2 in _v.items() if _v2}
-
-  # Done
-  return sensor_data
-
-
-def get_temp_str(temp, colors=True):
-  """Get temp string, returns str."""
-  if colors:
-    return get_colored_temp_str(temp)
-  try:
-    temp = float(temp)
-  except ValueError:
-    return '{}'.format(temp)
-  else:
-    return '{}{:2.0f}°C'.format(
-      '-' if temp < 0 else '',
-      temp)
-
-
-def is_cpu_adapter(adapter):
-  """Checks if adapter is a known CPU adapter, returns bool."""
-  is_cpu = re.search(r'(core|k\d+)temp', adapter, re.IGNORECASE)
-  return bool(is_cpu)
-
-
-def monitor_sensors(monitor_pane, monitor_file):
-  """Continually update sensor data and report to screen."""
-  sensor_data = get_sensor_data()
-  while True:
-    update_sensor_data(sensor_data)
-    with open(monitor_file, 'w') as _f:
-      report = generate_sensor_report(sensor_data, 'Current', 'Max')
-      _f.write('\n'.join(report))
-    sleep(1)
-    if monitor_pane and not tmux_poll_pane(monitor_pane):
-      break
-
-
-def save_average_temp(sensor_data, temp_label, seconds=10):
-  """Save average temps under temp_label, returns dict."""
-  clear_temps(sensor_data)
-
-  # Get temps
-  for _i in range(seconds): # pylint: disable=unused-variable
-    update_sensor_data(sensor_data)
-    sleep(1)
-
-  # Calculate averages
-  for _section, _adapters in sensor_data.items():
-    for _adapter, _sources in _adapters.items():
-      for _source, _data in _sources.items():
-        _data[temp_label] = sum(_data['Temps']) / len(_data['Temps'])
-
-
-def update_sensor_data(sensor_data, thermal_limit=None):
-  """Read sensors and update existing sensor_data, returns dict."""
-  json_data = get_raw_sensor_data()
-  for _section, _adapters in sensor_data.items():
-    for _adapter, _sources in _adapters.items():
-      for _source, _data in _sources.items():
-        try:
-          _label = _data['Label']
-          _temp = json_data[_adapter][_source][_label]
-          _data['Current'] = _temp
-          _data['Max'] = max(_temp, _data['Max'])
-          _data['Temps'].append(_temp)
-        except Exception: # pylint: disable=broad-except
-          # Dumb workound for Dell sensors with changing source names
-          pass
-
-        # Check if thermal limit reached
-        if thermal_limit and _section == 'CPUTemps':
-          if max(_data['Current'], _data['Max']) >= thermal_limit:
-            raise ThermalLimitReachedError('CPU temps reached limit')
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")

scripts/wk.prev/functions/setup.py

@@ -1,359 +0,0 @@
-# Wizard Kit: Functions - Setup
-
-from functions.browsers import *
-from functions.json import *
-from functions.update import *
-from settings.setup import *
-from settings.sources import *
-
-
-# Configuration
-def config_classicstart():
-  """Configure ClassicStart."""
-  # User level, not system level
-  cs_exe = r'{PROGRAMFILES}\Classic Shell\ClassicStartMenu.exe'.format(
-    **global_vars['Env'])
-  skin = r'{PROGRAMFILES}\Classic Shell\Skins\Metro-Win10-Black.skin7'.format(
-    **global_vars['Env'])
-  extract_item('ClassicStartSkin', silent=True)
-
-  # Stop Classic Start
-  run_program([cs_exe, '-exit'], check=False)
-  sleep(1)
-  kill_process('ClassicStartMenu.exe')
-
-  # Configure
-  write_registry_settings(SETTINGS_CLASSIC_START, all_users=False)
-  if global_vars['OS']['Version'] == '10' and os.path.exists(skin):
-    # Enable Win10 theme if on Win10
-    key_path = r'Software\IvoSoft\ClassicStartMenu\Settings'
-    with winreg.OpenKey(HKCU, key_path, access=winreg.KEY_WRITE) as key:
-      winreg.SetValueEx(
-        key, 'SkinW7', 0, winreg.REG_SZ, 'Metro-Win10-Black')
-      winreg.SetValueEx(key, 'SkinVariationW7', 0, winreg.REG_SZ, '')
-
-  # Pin Browser to Start Menu (Classic)
-  firefox = r'{PROGRAMDATA}\Start Menu\Programs\Mozilla Firefox.lnk'.format(
-    **global_vars['Env'])
-  chrome = r'{PROGRAMDATA}\Start Menu\Programs\Google Chrome.lnk'.format(
-    **global_vars['Env'])
-  dest_path = r'{APPDATA}\ClassicShell\Pinned'.format(**global_vars['Env'])
-  source = None
-  dest = None
-  if os.path.exists(firefox):
-    source = firefox
-    dest = r'{}\Mozilla Firefox.lnk'.format(dest_path)
-  elif os.path.exists(chrome):
-    source = chrome
-    dest = r'{}\Google Chrome.lnk'.format(dest_path)
-  if source:
-    try:
-      os.makedirs(dest_path, exist_ok=True)
-      shutil.copy(source, dest)
-    except Exception:
-      pass # Meh, it's fine without
-
-  # (Re)start Classic Start
-  run_program([cs_exe, '-exit'], check=False)
-  sleep(1)
-  kill_process('ClassicStartMenu.exe')
-  sleep(1)
-  popen_program(cs_exe)
-
-
-def config_explorer_system():
-  """Configure Windows Explorer for all users."""
-  write_registry_settings(SETTINGS_EXPLORER_SYSTEM, all_users=True)
-
-
-def config_explorer_user(setup_mode='All'):
-  """Configure Windows Explorer for current user per setup_mode."""
-  settings_explorer_user = {
-    k: v for k, v in SETTINGS_EXPLORER_USER.items()
-    if setup_mode not in v.get('Invalid modes', [])
-    }
-  write_registry_settings(settings_explorer_user, all_users=False)
-
-
-def config_windows_updates():
-  """Configure Windows updates."""
-  write_registry_settings(SETTINGS_WINDOWS_UPDATES, all_users=True)
-
-
-def update_clock():
-  """Set Timezone and sync clock."""
-  run_program(['tzutil', '/s', WINDOWS_TIME_ZONE], check=False)
-  run_program(['net', 'stop', 'w32ime'], check=False)
-  run_program(
-    ['w32tm', '/config', '/syncfromflags:manual',
-      '/manualpeerlist:"us.pool.ntp.org time.nist.gov time.windows.com"',
-      ],
-    check=False)
-  run_program(['net', 'start', 'w32ime'], check=False)
-  run_program(['w32tm', '/resync', '/nowait'], check=False)
-
-
-def write_registry_settings(settings, all_users=False):
-  """Write registry values from custom dict of dicts."""
-  hive = HKCU
-  if all_users:
-    hive = HKLM
-  for k, v in settings.items():
-    # CreateKey
-    access = winreg.KEY_WRITE
-    if 'WOW64_32' in v:
-      access = access | winreg.KEY_WOW64_32KEY
-    winreg.CreateKeyEx(hive, k, 0, access)
-
-    # Create values
-    with winreg.OpenKeyEx(hive, k, 0, access) as key:
-      for name, value in v.get('DWORD Items', {}).items():
-        winreg.SetValueEx(key, name, 0, winreg.REG_DWORD, value)
-      for name, value in v.get('SZ Items', {}).items():
-        winreg.SetValueEx(key, name, 0, winreg.REG_SZ, value)
-
-
-# Installations
-def find_current_software():
-  """Find currently installed software, returns list."""
-  ninite_extras_path = r'{BaseDir}\Installers\Extras'.format(**global_vars)
-  installers = []
-
-  # Browsers
-  scan_for_browsers(silent=True)
-  for browser in ('Google Chrome', 'Mozilla Firefox', 'Opera Chromium'):
-    if is_installed(browser):
-      installers.append(
-        r'{}\Web Browsers\{}.exe'.format(ninite_extras_path, browser))
-
-  # TODO: Add more sections
-
-  return installers
-
-def find_missing_software():
-  """Find missing software based on dirs/files present, returns list."""
-  ninite_extras_path = r'{BaseDir}\Installers\Extras'.format(**global_vars)
-  installers = []
-
-  # Browsers
-  scan_for_browsers(silent=True)
-  for browser in ('Google Chrome', 'Mozilla Firefox', 'Opera Chromium'):
-    if profile_present(browser):
-      installers.append(
-        r'{}\Web Browsers\{}.exe'.format(ninite_extras_path, browser))
-
-  # TODO: Add more sections
-
-  return installers
-
-
-def install_adobe_reader():
-  """Install Adobe Reader."""
-  cmd = [
-    r'{BaseDir}\Installers\Extras\Office\Adobe Reader DC.exe'.format(
-      **global_vars),
-    '/sAll',
-    '/msi', '/norestart', '/quiet',
-    'ALLUSERS=1',
-    'EULA_ACCEPT=YES']
-  run_program(cmd)
-
-
-def install_chrome_extensions():
-  """Install Google Chrome extensions for all users."""
-  write_registry_settings(SETTINGS_GOOGLE_CHROME, all_users=True)
-
-
-def install_classicstart_skin():
-  """Extract ClassicStart skin to installation folder."""
-  if global_vars['OS']['Version'] not in ('8', '8.1', '10'):
-    raise UnsupportedOSError
-  extract_item('ClassicStartSkin', silent=True)
-  source = r'{BinDir}\ClassicStartSkin\Metro-Win10-Black.skin7'.format(
-    **global_vars)
-  dest_path = r'{PROGRAMFILES}\Classic Shell\Skins'.format(
-    **global_vars['Env'])
-  dest = r'{}\Metro-Win10-Black.skin7'.format(dest_path)
-  os.makedirs(dest_path, exist_ok=True)
-  shutil.copy(source, dest)
-
-
-def install_firefox_extensions():
-  """Install Firefox extensions for all users."""
-  dist_path = r'{PROGRAMFILES}\Mozilla Firefox\distribution\extensions'.format(
-    **global_vars['Env'])
-  source_path = r'{CBinDir}\FirefoxExtensions.7z'.format(**global_vars)
-  if not os.path.exists(source_path):
-    raise FileNotFoundError
-
-  # Update registry
-  write_registry_settings(SETTINGS_MOZILLA_FIREFOX_32, all_users=True)
-  write_registry_settings(SETTINGS_MOZILLA_FIREFOX_64, all_users=True)
-
-  # Extract extension(s) to distribution folder
-  cmd = [
-    global_vars['Tools']['SevenZip'], 'e', '-aos', '-bso0', '-bse0',
-    '-p{ArchivePassword}'.format(**global_vars),
-    '-o{dist_path}'.format(dist_path=dist_path),
-    source_path]
-  run_program(cmd)
-
-
-def install_libreoffice(
-    quickstart=True, register_mso_types=True,
-    use_mso_formats=False, vcredist=False):
-  """Install LibreOffice using specified settings."""
-  cmd = [
-    'msiexec', '/passive', '/norestart',
-    '/i', r'{}\Installers\Extras\Office\LibreOffice.msi'.format(
-      global_vars['BaseDir']),
-    'REBOOTYESNO=No',
-    'ISCHECKFORPRODUCTUPDATES=0',
-    'QUICKSTART={}'.format(1 if quickstart else 0),
-    'UI_LANGS=en_US',
-    'VC_REDIST={}'.format(1 if vcredist else 0),
-    ]
-  if register_mso_types:
-    cmd.append('REGISTER_ALL_MSO_TYPES=1')
-  else:
-    cmd.append('REGISTER_NO_MSO_TYPES=1')
-  xcu_dir = r'{APPDATA}\LibreOffice\4\user'.format(**global_vars['Env'])
-  xcu_file = r'{}\registrymodifications.xcu'.format(xcu_dir)
-
-  # Set default save format
-  if use_mso_formats and not os.path.exists(xcu_file):
-    os.makedirs(xcu_dir, exist_ok=True)
-    with open(xcu_file, 'w', encoding='utf-8', newline='\n') as f:
-      f.write(LIBREOFFICE_XCU_DATA)
-
-  # Install LibreOffice
-  run_program(cmd, check=True)
-
-def install_ninite_bundle(
-    # pylint: disable=too-many-arguments,too-many-branches
-    base=True,
-    browsers_only=False,
-    libreoffice=False,
-    missing=False,
-    mse=False,
-    standard=True,
-    ):
-  """Run Ninite installer(s), returns list of Popen objects."""
-  popen_objects = []
-  if browsers_only:
-    # This option is deprecated
-    installer_path = r'{BaseDir}\Installers\Extras\Web Browsers'.format(
-      **global_vars)
-    scan_for_browsers(silent=True)
-    for browser in ('Google Chrome', 'Mozilla Firefox', 'Opera Chromium'):
-      if is_installed(browser):
-        cmd = r'{}\{}.exe'.format(installer_path, browser)
-        popen_objects.append(popen_program(cmd))
-
-    # Bail
-    return popen_objects
-
-  # Main selections
-  main_selections = []
-  if base:
-    main_selections.append('base')
-  if standard:
-    if global_vars['OS']['Version'] in ('8', '8.1', '10'):
-      main_selections.append('standard')
-    else:
-      main_selections.append('standard7')
-  if main_selections:
-    # Only run if base and/or standard are enabled
-    cmd = r'{}\Installers\Extras\Bundles\{}.exe'.format(
-      global_vars['BaseDir'],
-      '-'.join(main_selections),
-      )
-    popen_objects.append(popen_program([cmd]))
-
-  # Extra selections
-  extra_selections = {}
-  for cmd in find_current_software():
-    extra_selections[cmd] = True
-  if missing:
-    for cmd in find_missing_software():
-      extra_selections[cmd] = True
-
-  # Remove overlapping selections
-  regex = []
-  for n_name, n_group in NINITE_REGEX.items():
-    if n_name in main_selections:
-      regex.extend(n_group)
-  regex = '({})'.format('|'.join(regex))
-  extra_selections = {
-    cmd: True for cmd in extra_selections
-    if not re.search(regex, cmd, re.IGNORECASE)
-    }
-
-  # Start extra selections
-  for cmd in extra_selections:
-    popen_objects.append(popen_program([cmd]))
-
-  # Microsoft Security Essentials
-  if mse:
-    cmd = r'{}\Installers\Extras\Security\{}'.format(
-      global_vars['BaseDir'],
-      'Microsoft Security Essentials.exe',
-      )
-    popen_objects.append(popen_program([cmd]))
-
-  # LibreOffice
-  if libreoffice:
-    cmd = r'{}\Installers\Extras\Office\{}'.format(
-      global_vars['BaseDir'],
-      'LibreOffice.exe',
-      )
-    popen_objects.append(popen_program([cmd]))
-
-  # Done
-  return popen_objects
-
-
-def install_vcredists():
-  """Install all supported Visual C++ runtimes."""
-  extract_item('_vcredists', silent=True)
-  prev_dir = os.getcwd()
-  try:
-    os.chdir(r'{BinDir}\_vcredists'.format(**global_vars))
-  except FileNotFoundError:
-    # Ignored since the loop below will report the errors
-    pass
-  for vcr in VCR_REDISTS:
-    try_and_print(message=vcr['Name'], function=run_program,
-      cmd=vcr['Cmd'], other_results=OTHER_RESULTS)
-
-  os.chdir(prev_dir)
-
-
-# Misc
-def open_device_manager():
-  popen_program(['mmc', 'devmgmt.msc'])
-
-
-def open_speedtest():
-  popen_program(['start', '', 'https://fast.com'], shell=True)
-
-
-def open_windows_activation():
-  popen_program(['slui'])
-
-
-def open_windows_updates():
-  popen_program(['control', '/name', 'Microsoft.WindowsUpdate'])
-
-
-def restart_explorer():
-  """Restart Explorer."""
-  kill_process('explorer.exe')
-  sleep(2)
-  kill_process('explorer.exe')
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/sw_diags.py

@@ -1,244 +0,0 @@
-# Wizard Kit: Functions - SW Diagnostics
-
-import ctypes
-
-from functions.common import *
-from settings.sw_diags import *
-
-
-def check_4k_alignment(show_alert=False):
-  """Check that all partitions are 4K aligned."""
-  aligned = True
-  cmd = ['WMIC', 'partition', 'get', 'StartingOffset']
-  offsets = []
-
-  # Get offsets
-  result = run_program(cmd, encoding='utf-8', errors='ignore', check=False)
-  offsets = result.stdout.splitlines()
-
-  # Check offsets
-  for off in offsets:
-    off = off.strip()
-    if not off.isnumeric():
-      # Skip
-      continue
-
-    try:
-      aligned = aligned and int(off) % 4096 == 0
-    except ValueError:
-      # Ignore, this check is low priority
-      pass
-
-  # Show alert
-  if show_alert:
-    show_alert_box('One or more partitions are not 4K aligned')
-    raise Not4KAlignedError
-
-
-def check_connection():
-  """Check if the system is online and optionally abort the script."""
-  while True:
-    result = try_and_print(message='Ping test...',  function=ping, cs='OK')
-    if result['CS']:
-      break
-    if not ask('ERROR: System appears offline, try again?'):
-      if ask('Continue anyway?'):
-        break
-      else:
-        abort()
-
-
-def check_os_support_status():
-  """Check if current OS is supported."""
-  msg = ''
-  outdated = False
-  unsupported = False
-
-  # Check OS version/notes
-  os_info = global_vars['OS'].copy()
-  if os_info['Notes'] == 'unsupported':
-    msg = 'The installed version of Windows is no longer supported'
-    unsupported = True
-  elif os_info['Notes'] == 'preview build':
-    msg = 'Preview builds are not officially supported'
-    unsupported = True
-  elif os_info['Version'] == '10' and os_info['Notes'] == 'outdated':
-    msg = 'The installed version of Windows is outdated'
-    outdated = True
-  if 'Preview' not in msg:
-    msg += '\n\nPlease consider upgrading before continuing setup.'
-
-  # Show alert
-  if outdated or unsupported:
-    show_alert_box(msg)
-
-  # Raise exception if necessary
-  if outdated:
-    raise WindowsOutdatedError
-  if unsupported:
-    raise WindowsUnsupportedError
-
-
-def check_secure_boot_status(show_alert=False):
-  """Checks UEFI Secure Boot status via PowerShell."""
-  boot_mode = get_boot_mode()
-  cmd = ['PowerShell', '-Command', 'Confirm-SecureBootUEFI']
-  result = run_program(cmd, check=False)
-
-  # Check results
-  if result.returncode == 0:
-    out = result.stdout.decode()
-    if 'True' in out:
-      # It's on, do nothing
-      return
-    elif 'False' in out:
-      if show_alert:
-        show_alert_box('Secure Boot DISABLED')
-      raise SecureBootDisabledError
-    else:
-      if show_alert:
-        show_alert_box('Secure Boot status UNKNOWN')
-      raise SecureBootUnknownError
-  else:
-    if boot_mode != 'UEFI':
-      if (show_alert and
-        global_vars['OS']['Version'] in ('8', '8.1', '10')):
-        # OS supports Secure Boot
-        show_alert_box('Secure Boot DISABLED\n\nOS installed LEGACY')
-      raise OSInstalledLegacyError
-    else:
-      # Check error message
-      err = result.stderr.decode()
-      if 'Cmdlet not supported' in err:
-        if show_alert:
-          show_alert_box('Secure Boot UNAVAILABLE?')
-        raise SecureBootNotAvailError
-      else:
-        if show_alert:
-          show_alert_box('Secure Boot ERROR')
-        raise GenericError
-
-
-def get_boot_mode():
-  """Check if Windows is booted in UEFI or Legacy mode, returns str."""
-  kernel = ctypes.windll.kernel32
-  firmware_type = ctypes.c_uint()
-
-  # Get value from kernel32 API
-  try:
-    kernel.GetFirmwareType(ctypes.byref(firmware_type))
-  except:
-    # Just set to zero
-    firmware_type = ctypes.c_uint(0)
-
-  # Set return value
-  type_str = 'Unknown'
-  if firmware_type.value == 1:
-    type_str = 'Legacy'
-  elif firmware_type.value == 2:
-    type_str = 'UEFI'
-
-  return type_str
-
-
-def run_autoruns():
-  """Run AutoRuns in the background with VirusTotal checks enabled."""
-  extract_item('Autoruns', filter='autoruns*', silent=True)
-  # Update AutoRuns settings before running
-  for path, settings in AUTORUNS_SETTINGS.items():
-    winreg.CreateKey(HKCU, path)
-    with winreg.OpenKey(HKCU, path, access=winreg.KEY_WRITE) as key:
-      for name, value in settings.items():
-        winreg.SetValueEx(key, name, 0, winreg.REG_DWORD, value)
-  popen_program(global_vars['Tools']['AutoRuns'], minimized=True)
-
-
-def run_hwinfo_sensors():
-  """Run HWiNFO sensors."""
-  path = r'{BinDir}\HWiNFO'.format(**global_vars)
-  for bit in [32, 64]:
-    # Configure
-    source = r'{}\general.ini'.format(path)
-    dest =   r'{}\HWiNFO{}.ini'.format(path, bit)
-    shutil.copy(source, dest)
-    with open(dest, 'a') as f:
-      f.write('SensorsOnly=1\n')
-      f.write('SummaryOnly=0\n')
-  popen_program(global_vars['Tools']['HWiNFO'])
-
-
-def run_nircmd(*cmd):
-  """Run custom NirCmd."""
-  extract_item('NirCmd', silent=True)
-  cmd = [global_vars['Tools']['NirCmd'], *cmd]
-  run_program(cmd, check=False)
-
-
-def run_xmplay():
-  """Run XMPlay to test audio."""
-  extract_item('XMPlay', silent=True)
-  cmd = [global_vars['Tools']['XMPlay'],
-    r'{BinDir}\XMPlay\music.7z'.format(**global_vars)]
-
-  # Unmute audio first
-  extract_item('NirCmd', silent=True)
-  run_nircmd('mutesysvolume', '0')
-
-  # Open XMPlay
-  popen_program(cmd)
-
-
-def run_hitmanpro():
-  """Run HitmanPro in the background."""
-  extract_item('HitmanPro', silent=True)
-  cmd = [
-    global_vars['Tools']['HitmanPro'],
-    '/quiet', '/noinstall', '/noupload',
-    r'/log={LogDir}\Tools\HitmanPro.txt'.format(**global_vars)]
-  popen_program(cmd)
-
-
-def run_process_killer():
-  """Kill most running processes skipping those in the whitelist.txt."""
-  # borrowed from TronScript (reddit.com/r/TronScript)
-  # credit to /u/cuddlychops06
-  prev_dir = os.getcwd()
-  extract_item('ProcessKiller', silent=True)
-  os.chdir(r'{BinDir}\ProcessKiller'.format(**global_vars))
-  run_program(['ProcessKiller.exe', '/silent'], check=False)
-  os.chdir(prev_dir)
-
-
-def run_rkill():
-  """Run RKill and cleanup afterwards."""
-  extract_item('RKill', silent=True)
-  cmd = [
-    global_vars['Tools']['RKill'],
-    '-s', '-l', r'{LogDir}\Tools\RKill.log'.format(**global_vars),
-    '-new_console:n', '-new_console:s33V']
-  run_program(cmd, check=False)
-  wait_for_process('RKill')
-
-  # RKill cleanup
-  desktop_path = r'{USERPROFILE}\Desktop'.format(**global_vars['Env'])
-  if os.path.exists(desktop_path):
-    for item in os.scandir(desktop_path):
-      if re.search(r'^RKill', item.name, re.IGNORECASE):
-        dest = r'{LogDir}\Tools\{name}'.format(
-          name=dest, **global_vars)
-        dest = non_clobber_rename(dest)
-        shutil.move(item.path, dest)
-
-
-def show_alert_box(message, title=None):
-  """Show Windows alert box with message."""
-  if not title:
-    title = '{} Warning'.format(KIT_NAME_FULL)
-  message_box = ctypes.windll.user32.MessageBoxW
-  message_box(None, message, title, 0x00001030)
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/threading.py

@@ -1,47 +0,0 @@
-# Wizard Kit: Functions - Threading
-
-from threading import Thread
-from queue import Queue, Empty
-
-# Classes
-class NonBlockingStreamReader():
-  """Class to allow non-blocking reads from a stream."""
-  # Credits:
-  ## https://gist.github.com/EyalAr/7915597
-  ## https://stackoverflow.com/a/4896288
-
-  def __init__(self, stream):
-    self.stream = stream
-    self.queue = Queue()
-
-    def populate_queue(stream, queue):
-      """Collect lines from stream and put them in queue."""
-      while True:
-        line = stream.read(1)
-        if line:
-          queue.put(line)
-
-    self.thread = start_thread(
-      populate_queue,
-      args=(self.stream, self.queue))
-
-  def read(self, timeout=None):
-    try:
-      return self.queue.get(block = timeout is not None,
-          timeout = timeout)
-    except Empty:
-      return None
-
-
-# Functions
-def start_thread(function, args=[], daemon=True):
-  """Run function as thread in background, returns Thread object."""
-  thread = Thread(target=function, args=args, daemon=daemon)
-  thread.start()
-  return thread
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/tmux.py

@@ -1,187 +0,0 @@
-# Wizard Kit: Functions - tmux
-
-from functions.common import *
-
-
-def create_file(filepath):
-  """Create file if it doesn't exist."""
-  if not os.path.exists(filepath):
-    with open(filepath, 'w') as f:
-      f.write('')
-
-
-def tmux_capture_pane(pane_id=None):
-  """Capture text from target, or current, pane, returns str."""
-  cmd = ['tmux', 'capture-pane', '-p']
-  if pane_id:
-    cmd.extend(['-t', pane_id])
-  text = ''
-
-  # Capture
-  result = run_program(cmd, check=False, encoding='utf-8', errors='ignore')
-  text = result.stdout
-
-  # Done
-  return str(text)
-
-
-def tmux_get_pane_size(pane_id=None):
-  """Get target, or current, pane size, returns tuple."""
-  x = -1
-  y = -1
-  cmd = ['tmux', 'display', '-p']
-  if pane_id:
-    cmd.extend(['-t', pane_id])
-  cmd.append('#{pane_width} #{pane_height}')
-
-  # Run cmd and set x & y
-  result = run_program(cmd, check=False)
-  try:
-    x, y = result.stdout.decode().strip().split()
-    x = int(x)
-    y = int(y)
-  except Exception:
-    # Ignore and return unrealistic values
-    pass
-
-  return (x, y)
-
-
-def tmux_kill_all_panes(pane_id=None):
-  """Kill all tmux panes except the active pane or pane_id if specified."""
-  cmd = ['tmux', 'kill-pane', '-a']
-  if pane_id:
-    cmd.extend(['-t', pane_id])
-  run_program(cmd, check=False)
-
-
-def tmux_kill_pane(*panes):
-  """Kill tmux pane by id."""
-  cmd = ['tmux', 'kill-pane', '-t']
-  for pane_id in panes:
-    if not pane_id:
-      # Skip empty strings, None values, etc
-      continue
-    run_program(cmd+[pane_id], check=False)
-
-
-def tmux_poll_pane(pane_id):
-  """Check if pane exists, returns bool."""
-  cmd = ['tmux', 'list-panes', '-F', '#D']
-  result = run_program(cmd, check=False)
-  panes = result.stdout.decode().splitlines()
-  return pane_id in panes
-
-
-def tmux_resize_pane(pane_id=None, x=None, y=None, **kwargs):
-  """Resize pane to specific hieght or width."""
-  if not x and not y:
-    raise Exception('Neither height nor width specified.')
-
-  cmd = ['tmux', 'resize-pane']
-  if pane_id:
-    # NOTE: If pane_id not specified then the current pane will be resized
-    cmd.extend(['-t', pane_id])
-  if x:
-    cmd.extend(['-x', str(x)])
-  elif y:
-    cmd.extend(['-y', str(y)])
-
-  run_program(cmd, check=False)
-
-
-def tmux_split_window(
-    lines=None, percent=None,
-    behind=False, vertical=False,
-    follow=False, target_pane=None,
-    command=None, working_dir=None,
-    text=None, watch=None, watch_cmd='cat'):
-  """Run tmux split-window command and return pane_id as str."""
-  # Bail early
-  if not lines and not percent:
-    raise Exception('Neither lines nor percent specified.')
-  if not command and not text and not watch:
-    raise Exception('No command, text, or watch file specified.')
-
-  # Build cmd
-  cmd = ['tmux', 'split-window', '-PF', '#D']
-  if behind:
-    cmd.append('-b')
-  if vertical:
-    cmd.append('-v')
-  else:
-    cmd.append('-h')
-  if not follow:
-    cmd.append('-d')
-  if lines is not None:
-    cmd.extend(['-l', str(lines)])
-  elif percent is not None:
-    cmd.extend(['-p', str(percent)])
-  if target_pane:
-    cmd.extend(['-t', str(target_pane)])
-
-  if working_dir:
-    cmd.extend(['-c', working_dir])
-  if command:
-    cmd.extend(command)
-  elif text:
-    cmd.extend(['echo-and-hold "{}"'.format(text)])
-  elif watch:
-    create_file(watch)
-    if watch_cmd == 'cat':
-      cmd.extend([
-        'watch', '--color', '--no-title',
-        '--interval', '1',
-        'cat', watch])
-    elif watch_cmd == 'tail':
-      cmd.extend(['tail', '-f', watch])
-
-  # Run and return pane_id
-  result = run_program(cmd)
-  return result.stdout.decode().strip()
-
-
-def tmux_switch_client(target_session=None):
-  """Switch to target tmux session, or previous if none specified."""
-  cmd = ['tmux', 'switch-client']
-  if target_session:
-    cmd.extend(['-t', target_session])
-  else:
-    # Switch to previous instead
-    cmd.append('-p')
-
-  run_program(cmd, check=False)
-
-
-def tmux_update_pane(
-    pane_id, command=None, working_dir=None,
-    text=None, watch=None, watch_cmd='cat'):
-  """Respawn with either a new command or new text."""
-  # Bail early
-  if not command and not text and not watch:
-    raise Exception('No command, text, or watch file specified.')
-
-  cmd = ['tmux', 'respawn-pane', '-k', '-t', pane_id]
-  if working_dir:
-    cmd.extend(['-c', working_dir])
-  if command:
-    cmd.extend(command)
-  elif text:
-    cmd.extend(['echo-and-hold "{}"'.format(text)])
-  elif watch:
-    create_file(watch)
-    if watch_cmd == 'cat':
-      cmd.extend([
-        'watch', '--color', '--no-title',
-        '--interval', '1',
-        'cat', watch])
-    elif watch_cmd == 'tail':
-      cmd.extend(['tail', '-f', watch])
-
-  run_program(cmd)
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/windows_setup.py

@@ -1,220 +0,0 @@
-# Wizard Kit: Functions - Windows Setup
-
-from functions.data import *
-from functions.disk import *
-from settings.windows_setup import *
-
-
-def find_windows_image(windows_version):
-  """Search for a Windows source image file, returns dict.
-
-  Searches on local disks and then the WINDOWS_SERVER share."""
-  image = {}
-  imagefile = windows_version['Image File']
-  imagename = windows_version['Image Name']
-
-  # Search local source
-  set_thread_error_mode(silent=True) # Prevents "No disk" popups
-  for d in psutil.disk_partitions():
-    for ext in ['esd', 'wim', 'swm']:
-      path = '{}images\{}.{}'.format(d.mountpoint, imagefile, ext)
-      if os.path.isfile(path) and wim_contains_image(path, imagename):
-        image['Path'] = path
-        image['Letter'] = d.mountpoint[:1].upper()
-        image['Local'] = True
-        if ext == 'swm':
-          image['Glob'] = '--ref="{}*.swm"'.format(image['Path'][:-4])
-        break
-  set_thread_error_mode(silent=False) # Return to normal
-
-  # Check for network source
-  if not image:
-    mount_windows_share()
-    if WINDOWS_SERVER['Mounted']:
-      for ext in ['esd', 'wim', 'swm']:
-        path = r'\\{}\{}\images\{}.{}'.format(
-          WINDOWS_SERVER['IP'],
-          WINDOWS_SERVER['Share'],
-          imagefile,
-          ext)
-        if os.path.isfile(path) and wim_contains_image(path, imagename):
-          image['Path'] = path
-          image['Letter'] = None
-          image['Local'] = False
-          if ext == 'swm':
-            image['Glob'] = '--ref="{}*.swm"'.format(
-              image['Path'][:-4])
-          break
-
-  # Display image to be used (if any) and return
-  if image:
-    print_info('Using image: {}'.format(image['Path']))
-    return image
-  else:
-    print_error('Failed to find Windows source image for {}'.format(
-      windows_version['Name']))
-    raise GenericAbort
-
-
-def format_disk(disk, use_gpt):
-  """Format disk for use as a Windows OS disk."""
-  if use_gpt:
-    format_gpt(disk)
-  else:
-    format_mbr(disk)
-
-
-def format_gpt(disk):
-  """Format disk for use as a Windows OS disk using the GPT layout."""
-  script = [
-    # Partition table
-    'select disk {}'.format(disk['Number']),
-    'clean',
-    'convert gpt',
-
-    # System partition
-    # NOTE: ESP needs to be >= 260 for Advanced Format 4K disks
-    'create partition efi size=500',
-    'format quick fs=fat32 label="System"',
-    'assign letter="S"',
-
-    # Microsoft Reserved (MSR) partition
-    'create partition msr size=128',
-
-    # Windows partition
-    'create partition primary',
-    'format quick fs=ntfs label="Windows"',
-    'assign letter="W"',
-
-    # Recovery Tools partition
-    'shrink minimum=500',
-    'create partition primary',
-    'format quick fs=ntfs label="Recovery Tools"',
-    'assign letter="T"',
-    'set id="de94bba4-06d1-4d40-a16a-bfd50179d6ac"',
-    'gpt attributes=0x8000000000000001',
-    ]
-
-  # Run
-  run_diskpart(script)
-
-
-def format_mbr(disk):
-  """Format disk for use as a Windows OS disk using the MBR layout."""
-  script = [
-    # Partition table
-    'select disk {}'.format(disk['Number']),
-    'clean',
-
-    # System partition
-    'create partition primary size=100',
-    'format fs=ntfs quick label="System Reserved"',
-    'active',
-    'assign letter="S"',
-
-    # Windows partition
-    'create partition primary',
-    'format fs=ntfs quick label="Windows"',
-    'assign letter="W"',
-
-    # Recovery Tools partition
-    'shrink minimum=500',
-    'create partition primary',
-    'format quick fs=ntfs label="Recovery"',
-    'assign letter="T"',
-    'set id=27',
-    ]
-
-  # Run
-  run_diskpart(script)
-
-
-def mount_windows_share():
-  """Mount the Windows images share unless already mounted."""
-  if not WINDOWS_SERVER['Mounted']:
-    # Mounting read-write in case a backup was done in the same session
-    # and the server was left mounted read-write. This avoids throwing an
-    # error by trying to mount the same server with multiple credentials.
-    mount_network_share(WINDOWS_SERVER, read_write=True)
-
-
-def select_windows_version():
-  """Select Windows version from a menu, returns dict."""
-  actions = [
-    {'Name': 'Main Menu', 'Letter': 'M'},
-    ]
-
-  # Menu loop
-  selection = menu_select(
-    title = 'Which version of Windows are we installing?',
-    main_entries = WINDOWS_VERSIONS,
-    action_entries = actions)
-
-  if selection.isnumeric():
-    return WINDOWS_VERSIONS[int(selection)-1]
-  elif selection == 'M':
-    raise GenericAbort
-
-
-def setup_windows(windows_image, windows_version):
-  """Apply a Windows image to W:"""
-  cmd = [
-    global_vars['Tools']['wimlib-imagex'],
-    'apply',
-    windows_image['Path'],
-    windows_version['Image Name'],
-    'W:\\']
-  if 'Glob' in windows_image:
-    cmd.extend(windows_image['Glob'])
-  run_program(cmd)
-
-
-def setup_windows_re(windows_version, windows_letter='W', tools_letter='T'):
-  """Setup the WinRE partition."""
-  win = r'{}:\Windows'.format(windows_letter)
-  winre = r'{}\System32\Recovery\WinRE.wim'.format(win)
-  dest = r'{}:\Recovery\WindowsRE'.format(tools_letter)
-
-  # Copy WinRE.wim
-  os.makedirs(dest, exist_ok=True)
-  shutil.copy(winre, r'{}\WinRE.wim'.format(dest))
-
-  # Set location
-  cmd = [
-    r'{}\System32\ReAgentc.exe'.format(win),
-    '/setreimage',
-    '/path', dest,
-    '/target', win]
-  run_program(cmd)
-
-
-def update_boot_partition(system_letter='S', windows_letter='W', mode='ALL'):
-  """Setup the Windows boot partition."""
-  cmd = [
-    r'{}\Windows\System32\bcdboot.exe'.format(
-      global_vars['Env']['SYSTEMDRIVE']),
-    r'{}:\Windows'.format(windows_letter),
-    '/s', '{}:'.format(system_letter),
-    '/f', mode]
-  run_program(cmd)
-
-
-def wim_contains_image(filename, imagename):
-  """Check if an ESD/WIM contains the specified image, returns bool."""
-  cmd = [
-    global_vars['Tools']['wimlib-imagex'],
-    'info',
-    filename,
-    imagename]
-  try:
-    run_program(cmd)
-  except subprocess.CalledProcessError:
-    return False
-
-  return True
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/windows_updates.py

@@ -1,143 +0,0 @@
-# Wizard Kit: Functions - Windows updates
-
-from functions.common import *
-
-
-# Functions
-def delete_folder(folder_path):
-  """Near-useless wrapper for shutil.rmtree."""
-  shutil.rmtree(folder_path)
-
-
-def disable_service(service_name):
-  """Set service startup to disabled."""
-  run_program(['sc', 'config', service_name, 'start=', 'disabled'])
-
-  # Verify service was disabled
-  start_type = get_service_start_type(service_name)
-  if not start_type.lower().startswith('disabled'):
-    raise GenericError('Failed to disable service {}'.format(service_name))
-
-
-def disable_windows_updates():
-  """Disable windows updates and clear SoftwareDistribution folder."""
-  indent=2
-  width=52
-  update_folders = [
-    r'{WINDIR}\SoftwareDistribution'.format(**global_vars['Env']),
-    r'{SYSTEMDRIVE}\$WINDOWS.~BT'.format(**global_vars['Env']),
-  ]
-
-  for service in ('wuauserv', 'bits'):
-    # Stop service
-    result = try_and_print(
-      'Stopping service {}...'.format(service),
-      indent=indent, width=width,
-      function=stop_service, service_name=service)
-    if not result['CS']:
-      result = try_and_print(
-        'Stopping service {}...'.format(service),
-        indent=indent, width=width,
-        function=stop_service, service_name=service)
-      if not result['CS']:
-        raise GenericError('Service {} could not be stopped.'.format(service))
-
-    # Disable service
-    result = try_and_print(
-      'Disabling service {}...'.format(service),
-      indent=indent, width=width,
-      function=disable_service, service_name=service)
-    if not result['CS']:
-      result = try_and_print(
-        'Disabling service {}...'.format(service),
-        indent=indent, width=width,
-        function=disable_service, service_name=service)
-      if not result['CS']:
-        raise GenericError('Service {} could not be disabled.'.format(service))
-
-  # Delete update folders
-  for folder_path in update_folders:
-    if os.path.exists(folder_path):
-      result = try_and_print(
-        'Deleting folder {}...'.format(folder_path),
-        indent=indent, width=width,
-        function=delete_folder, folder_path=folder_path)
-      if not result['CS']:
-        raise GenericError('Failed to remove folder {}'.format(folder_path))
-
-
-def enable_service(service_name, start_type='auto'):
-  """Enable service by setting start type."""
-  run_program(['sc', 'config', service_name, 'start=', start_type])
-
-
-def enable_windows_updates(silent=False):
-  """Enable windows updates"""
-  indent=2
-  width=52
-
-  for service in ('bits', 'wuauserv'):
-    # Enable service
-    start_type = 'auto'
-    if service == 'wuauserv':
-      start_type = 'demand'
-    if silent:
-      try:
-        enable_service(service, start_type=start_type)
-      except Exception:
-        # Try again
-        enable_service(service, start_type=start_type)
-    else:
-      result = try_and_print(
-        'Enabling service {}...'.format(service),
-        indent=indent, width=width,
-        function=enable_service, service_name=service, start_type=start_type)
-      if not result['CS']:
-        result = try_and_print(
-          'Enabling service {}...'.format(service),
-          indent=indent, width=width,
-          function=enable_service, service_name=service, start_type=start_type)
-        if not result['CS']:
-          raise GenericError('Service {} could not be enabled.'.format(service))
-
-
-def get_service_status(service_name):
-  """Get service status using psutil, returns str."""
-  status = 'Unknown'
-  try:
-    service = psutil.win_service_get(service_name)
-    status = service.status()
-  except psutil.NoSuchProcess:
-    # Ignore and return 'Unknown' below
-    pass
-
-  return status
-
-
-def get_service_start_type(service_name):
-  """Get service startup type using psutil, returns str."""
-  start_type = 'Unknown'
-  try:
-    service = psutil.win_service_get(service_name)
-    start_type = service.start_type()
-  except psutil.NoSuchProcess:
-    # Ignore and return 'Unknown' below
-    pass
-
-  return start_type
-
-
-def stop_service(service_name):
-  """Stop service."""
-  run_program(['net', 'stop', service_name], check=False)
-
-  # Verify service was stopped
-  status = get_service_status(service_name)
-  if not status.lower().startswith('stopped'):
-    raise GenericError('Failed to stop service {}'.format(service_name))
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/functions/winpe_menus.py

@@ -1,435 +0,0 @@
-# Wizard Kit: WinPE Menus
-
-from functions.backup import *
-from functions.disk import *
-from functions.windows_setup import *
-from settings.winpe import *
-
-
-def check_pe_tools():
-  """Fix tool paths for WinPE layout."""
-  for k in PE_TOOLS.keys():
-    PE_TOOLS[k]['Path'] = r'{}\{}'.format(
-      global_vars['BinDir'], PE_TOOLS[k]['Path'])
-  global_vars['Tools']['wimlib-imagex'] = re.sub(
-    r'\\x(32|64)',
-    r'',
-    global_vars['Tools']['wimlib-imagex'],
-    re.IGNORECASE)
-
-
-def menu_backup():
-  """Take backup images of partition(s) in the WIM format."""
-  errors = False
-  other_results = {
-    'Error': {
-      'CalledProcessError':   'Unknown Error',
-      'PathNotFoundError':  'Missing',
-    },
-    'Warning': {
-      'GenericAbort':     'Skipped',
-      'GenericRepair':    'Repaired',
-    }}
-  set_title('{}: Backup Menu'.format(KIT_NAME_FULL))
-
-  # Set backup prefix
-  clear_screen()
-  print_standard('{}\n'.format(global_vars['Title']))
-  ticket_number = get_ticket_number()
-  if ENABLED_TICKET_NUMBERS:
-    backup_prefix = ticket_number
-  else:
-    backup_prefix = get_simple_string(prompt='Enter backup name prefix')
-    backup_prefix = backup_prefix.replace(' ', '_')
-
-  # Assign drive letters
-  try_and_print(
-    message = 'Assigning letters...',
-    function = assign_volume_letters,
-    other_results = other_results)
-
-  # Mount backup shares
-  mount_backup_shares(read_write=True)
-
-  # Select destination
-  destination = select_backup_destination(auto_select=False)
-
-  # Scan disks
-  result = try_and_print(
-    message = 'Getting disk info...',
-    function = scan_disks,
-    other_results = other_results)
-  if result['CS']:
-    disks = result['Out']
-  else:
-    print_error('ERROR: No disks found.')
-    raise GenericAbort
-
-  # Select disk to backup
-  disk = select_disk('For which disk are we creating backups?', disks)
-  if not disk:
-    raise GenericAbort
-
-  # "Prep" disk
-  prep_disk_for_backup(destination, disk, backup_prefix)
-
-  # Display details for backup task
-  clear_screen()
-  print_info('Create Backup - Details:\n')
-  if ENABLED_TICKET_NUMBERS:
-    show_data(message='Ticket:', data=ticket_number)
-  show_data(
-    message = 'Source:',
-    data = '[{}] ({}) {} {}'.format(
-      disk.get('Table', ''),
-      disk.get('Type', ''),
-      disk.get('Name', 'Unknown'),
-      disk.get('Size', ''),
-      ),
-    )
-  show_data(
-    message = 'Destination:',
-    data = destination.get('Display Name', destination['Name']),
-    )
-  for par in disk['Partitions']:
-    message = 'Partition {}:'.format(par['Number'])
-    data = par['Display String']
-    if par['Number'] in disk['Bad Partitions']:
-      show_data(message=message, data=data, width=30, warning=True)
-      if 'Error' in par:
-        show_data(message='', data=par['Error'], error=True)
-    elif par['Image Exists']:
-      show_data(message=message, data=data, width=30, info=True)
-    else:
-      show_data(message=message, data=data, width=30)
-  print_standard(disk['Backup Warnings'])
-
-  # Ask to proceed
-  if (not ask('Proceed with backup?')):
-    raise GenericAbort
-
-  # Backup partition(s)
-  print_info('\n\nStarting task.\n')
-  for par in disk['Partitions']:
-    result = try_and_print(
-      message = 'Partition {} Backup...'.format(par['Number']),
-      function = backup_partition,
-      other_results = other_results,
-      disk = disk,
-      par = par)
-    if not result['CS'] and not isinstance(result['Error'], GenericAbort):
-      errors = True
-      par['Error'] = result['Error']
-
-  # Verify backup(s)
-  if disk['Valid Partitions']:
-    print_info('\n\nVerifying backup images(s)\n')
-    for par in disk['Partitions']:
-      if par['Number'] in disk['Bad Partitions']:
-        continue # Skip verification
-      result = try_and_print(
-        message = 'Partition {} Image...'.format(par['Number']),
-        function = verify_wim_backup,
-        other_results = other_results,
-        partition = par)
-      if not result['CS']:
-        errors = True
-        par['Error'] = result['Error']
-
-  # Print summary
-  if errors:
-    print_warning('\nErrors were encountered and are detailed below.')
-    for par in [p for p in disk['Partitions'] if 'Error' in p]:
-      print_standard('  Partition {} Error:'.format(par['Number']))
-      if hasattr(par['Error'], 'stderr'):
-        try:
-          par['Error'] = par['Error'].stderr.decode()
-        except:
-          # Deal with badly formatted error message
-          pass
-      try:
-        par['Error'] = par['Error'].splitlines()
-        par['Error'] = [line.strip() for line in par['Error']]
-        par['Error'] = [line for line in par['Error'] if line]
-        for line in par['Error']:
-          print_error('\t{}'.format(line))
-      except:
-        print_error('\t{}'.format(par['Error']))
-  else:
-    print_success('\nNo errors were encountered during imaging.')
-  if 'LogFile' in global_vars and ask('\nReview log?'):
-    cmd = [
-      global_vars['Tools']['NotepadPlusPlus'],
-      global_vars['LogFile']]
-    try:
-      popen_program(cmd)
-    except Exception:
-      print_error('ERROR: Failed to open log.')
-      sleep(30)
-  pause('\nPress Enter to return to main menu... ')
-
-
-def menu_root():
-  """Main WinPE menu."""
-  check_pe_tools()
-  menus = [
-    {'Name': 'Create Backups', 'Menu': menu_backup},
-    {'Name': 'Setup Windows', 'Menu': menu_setup},
-    {'Name': 'Misc Tools', 'Menu': menu_tools},
-    ]
-  actions = [
-    {'Name': 'Command Prompt', 'Letter': 'C'},
-    {'Name': 'Reboot', 'Letter': 'R'},
-    {'Name': 'Shutdown', 'Letter': 'S'},
-    ]
-
-  # Main loop
-  while True:
-    set_title(KIT_NAME_FULL)
-    selection = menu_select(
-      title = 'Main Menu',
-      main_entries = menus,
-      action_entries = actions,
-      secret_exit = True)
-
-    if (selection.isnumeric()):
-      try:
-        menus[int(selection)-1]['Menu']()
-      except GenericAbort:
-        print_warning('\nAborted\n')
-        pause('Press Enter to return to main menu... ')
-    elif (selection == 'C'):
-      run_program(['cmd', '-new_console:n'], check=False)
-    elif (selection == 'R'):
-      run_program(['wpeutil', 'reboot'])
-    elif (selection == 'S'):
-      run_program(['wpeutil', 'shutdown'])
-    else:
-      sys.exit()
-
-
-def menu_setup():
-  """Format a disk, apply a Windows image, and create boot files."""
-  errors = False
-  other_results = {
-    'Error': {
-      'CalledProcessError':   'Unknown Error',
-      'PathNotFoundError':  'Missing',
-    },
-    'Warning': {
-      'GenericAbort':     'Skipped',
-      'GenericRepair':    'Repaired',
-    }}
-  set_title('{}: Setup Menu'.format(KIT_NAME_FULL))
-
-  # Set ticket ID
-  clear_screen()
-  print_standard('{}\n'.format(global_vars['Title']))
-  ticket_number = get_ticket_number()
-
-  # Select the version of Windows to apply
-  windows_version = select_windows_version()
-
-  # Find Windows image
-  # NOTE: Reassign volume letters to ensure all devices are scanned
-  try_and_print(
-    message = 'Assigning volume letters...',
-    function = assign_volume_letters,
-    other_results = other_results)
-  windows_image = find_windows_image(windows_version)
-
-  # Scan disks
-  result = try_and_print(
-    message = 'Getting disk info...',
-    function = scan_disks,
-    other_results = other_results)
-  if result['CS']:
-    disks = result['Out']
-  else:
-    print_error('ERROR: No disks found.')
-    raise GenericAbort
-
-  # Select disk to use as the OS disk
-  dest_disk = select_disk('To which disk are we installing Windows?', disks)
-  if not dest_disk:
-    raise GenericAbort
-
-  # "Prep" disk
-  prep_disk_for_formatting(dest_disk)
-
-  # Display details for setup task
-  clear_screen()
-  print_info('Setup Windows - Details:\n')
-  if ENABLED_TICKET_NUMBERS:
-    show_data(message='Ticket:', data=ticket_number)
-  show_data(message='Installing:', data=windows_version['Name'])
-  show_data(
-    message = 'Boot Method:',
-    data = 'UEFI (GPT)' if dest_disk['Use GPT'] else 'Legacy (MBR)')
-  show_data(message='Using Image:', data=windows_image['Path'])
-  show_data(
-    message = 'ERASING:',
-    data = '[{}] ({}) {} {}\n'.format(
-      dest_disk.get('Table', ''),
-      dest_disk.get('Type', ''),
-      dest_disk.get('Name', 'Unknown'),
-      dest_disk.get('Size', ''),
-      ),
-    warning = True)
-  for par in dest_disk['Partitions']:
-    show_data(
-      message = 'Partition {}:'.format(par['Number']),
-      data = par['Display String'],
-      warning = True)
-  print_warning(dest_disk['Format Warnings'])
-
-  if (not ask('Is this correct?')):
-    raise GenericAbort
-
-  # Safety check
-  print_standard('\nSAFETY CHECK')
-  print_warning('All data will be DELETED from the '
-          'disk and partition(s) listed above.')
-  print_warning('This is irreversible and will lead '
-          'to {CLEAR}{RED}DATA LOSS.'.format(**COLORS))
-  if (not ask('Asking again to confirm, is this correct?')):
-    raise GenericAbort
-
-  # Remove volume letters so S, T, & W can be used below
-  try_and_print(
-    message = 'Removing volume letters...',
-    function = remove_volume_letters,
-    other_results = other_results,
-    keep=windows_image['Letter'])
-
-  # Assign new letter for local source if necessary
-  if windows_image['Local'] and windows_image['Letter'] in ['S', 'T', 'W']:
-    new_letter = try_and_print(
-      message = 'Reassigning source volume letter...',
-      function = reassign_volume_letter,
-      other_results = other_results,
-      letter=windows_image['Letter'])
-    windows_image['Path'] = '{}{}'.format(
-      new_letter, windows_image['Path'][1:])
-    windows_image['Letter'] = new_letter
-
-  # Format and partition disk
-  result = try_and_print(
-    message = 'Formatting disk...',
-    function = format_disk,
-    other_results = other_results,
-    disk = dest_disk,
-    use_gpt = dest_disk['Use GPT'])
-  if not result['CS']:
-    # We need to crash as the disk is in an unknown state
-    print_error('ERROR: Failed to format disk.')
-    raise GenericAbort
-
-  # Apply Image
-  result = try_and_print(
-    message = 'Applying image...',
-    function = setup_windows,
-    other_results = other_results,
-    windows_image = windows_image,
-    windows_version = windows_version)
-  if not result['CS']:
-    # We need to crash as the disk is in an unknown state
-    print_error('ERROR: Failed to apply image.')
-    raise GenericAbort
-
-  # Create Boot files
-  try_and_print(
-    message = 'Updating boot files...',
-    function = update_boot_partition,
-    other_results = other_results)
-
-  # Setup WinRE
-  try_and_print(
-    message = 'Updating recovery tools...',
-    function = setup_windows_re,
-    other_results = other_results,
-    windows_version = windows_version)
-
-  # Copy WinPE log(s)
-  source = r'{}\Logs'.format(global_vars['ClientDir'])
-  dest = r'W:\{}\Logs\WinPE'.format(KIT_NAME_SHORT)
-  shutil.copytree(source, dest)
-
-  # Print summary
-  print_standard('\nDone.')
-  if 'LogFile' in global_vars and ask('\nReview log?'):
-    cmd = [
-      global_vars['Tools']['NotepadPlusPlus'],
-      global_vars['LogFile']]
-    try:
-      popen_program(cmd)
-    except Exception:
-      print_error('ERROR: Failed to open log.')
-      sleep(30)
-  pause('\nPress Enter to return to main menu... ')
-
-
-def menu_tools():
-  """Tool launcher menu."""
-  tools = [{'Name': k} for k in sorted(PE_TOOLS.keys())]
-  actions = [{'Name': 'Main Menu', 'Letter': 'M'},]
-  set_title(KIT_NAME_FULL)
-
-  # Menu loop
-  while True:
-    selection = menu_select(
-      title = 'Tools Menu',
-      main_entries = tools,
-      action_entries = actions)
-    if (selection.isnumeric()):
-      name = tools[int(selection)-1]['Name']
-      cmd = [PE_TOOLS[name]['Path']] + PE_TOOLS[name].get('Args', [])
-      if name == 'Blue Screen View':
-        # Select path to scan
-        minidump_path = select_minidump_path()
-        if minidump_path:
-          cmd.extend(['/MiniDumpFolder', minidump_path])
-      try:
-        popen_program(cmd)
-      except Exception:
-        print_error('Failed to run {}'.format(name))
-        sleep(2)
-        pause()
-    elif (selection == 'M'):
-      break
-
-
-def select_minidump_path():
-  """Select BSOD minidump path from a menu."""
-  dumps = []
-
-  # Assign volume letters first
-  assign_volume_letters()
-
-  # Search for minidumps
-  set_thread_error_mode(silent=True) # Prevents "No disk" popups
-  for d in psutil.disk_partitions():
-    if global_vars['Env']['SYSTEMDRIVE'].upper() in d.mountpoint:
-      # Skip RAMDisk
-      continue
-    if os.path.exists(r'{}Windows\MiniDump'.format(d.mountpoint)):
-      dumps.append({'Name': r'{}Windows\MiniDump'.format(d.mountpoint)})
-  set_thread_error_mode(silent=False) # Return to normal
-
-  # Check results before showing menu
-  if len(dumps) == 0:
-    print_error('ERROR: No BSoD / MiniDump paths found')
-    sleep(2)
-    return None
-
-  # Menu
-  selection = menu_select(
-    title = 'Which BSoD / MiniDump path are we scanning?',
-    main_entries = dumps)
-  return dumps[int(selection) - 1]['Name']
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/settings/browsers.py

@@ -1,99 +0,0 @@
-# Wizard Kit: Settings - Browsers
-
-import os
-import re
-
-# General
-DEFAULT_HOMEPAGE =      'https://www.google.com/'
-IE_GALLERY =            'https://www.microsoft.com/en-us/iegallery'
-MOZILLA_PREFS = {
-  'browser.search.defaultenginename': '"Google"',
-  'browser.search.defaultenginename.US': '"Google"',
-  'browser.search.geoSpecificDefaults': 'false',
-  'browser.startup.homepage': '"{}"'.format(DEFAULT_HOMEPAGE),
-  'extensions.ui.lastCategory': '"addons://list/extension"',
-  }
-SUPPORTED_BROWSERS = {
-  'Internet Explorer': {
-    'base':             'ie',
-    'exe_name':         'iexplore.exe',
-    'rel_install_path': 'Internet Explorer',
-    'user_data_path':   r'{USERPROFILE}\Favorites',
-    },
-  'Google Chrome': {
-    'base':             'chromium',
-    'exe_name':         'chrome.exe',
-    'rel_install_path': r'Google\Chrome\Application',
-    'user_data_path':   r'{LOCALAPPDATA}\Google\Chrome\User Data',
-    },
-  'Google Chrome Canary': {
-    'base':             'chromium',
-    'exe_name':         'chrome.exe',
-    'rel_install_path': r'Google\Chrome SxS\Application',
-    'user_data_path':   r'{LOCALAPPDATA}\Google\Chrome SxS\User Data',
-    },
-  'Mozilla Firefox': {
-    'base':             'mozilla',
-    'exe_name':         'firefox.exe',
-    'rel_install_path': 'Mozilla Firefox',
-    'user_data_path':   r'{APPDATA}\Mozilla\Firefox\Profiles',
-    },
-  'Mozilla Firefox Dev': {
-    'base':             'mozilla',
-    'exe_name':         'firefox.exe',
-    'rel_install_path': 'Firefox Developer Edition',
-    'user_data_path':   r'{APPDATA}\Mozilla\Firefox\Profiles',
-    },
-  'Opera': {
-    'base':             'chromium',
-    'exe_name':         'launcher.exe',
-    'rel_install_path': 'Opera',
-    'user_data_path':   r'{APPDATA}\Opera Software\Opera Stable',
-    },
-  'Opera Beta': {
-    'base':             'chromium',
-    'exe_name':         'launcher.exe',
-    'rel_install_path': 'Opera beta',
-    'user_data_path':   r'{APPDATA}\Opera Software\Opera Next',
-    },
-  'Opera Dev': {
-    'base':             'chromium',
-    'exe_name':         'launcher.exe',
-    'rel_install_path': 'Opera developer',
-    'user_data_path':   r'{APPDATA}\Opera Software\Opera Developer',
-    },
-  }
-
-# Regex
-REGEX_BACKUP = re.compile(
-  r'\.\w*bak.*',
-  re.IGNORECASE)
-REGEX_CHROMIUM_PROFILE = re.compile(
-  r'^(Default|Profile)',
-  re.IGNORECASE)
-REGEX_CHROMIUM_ITEMS = re.compile(
-  r'^(Bookmarks|Cookies|Favicons|Google Profile'
-  r'|History|Login Data|Top Sites|TransportSecurity'
-  r'|Visited Links|Web Data)',
-  re.IGNORECASE)
-REGEX_MOZILLA = re.compile(
-  r'^(bookmarkbackups|(cookies|formhistory|places).sqlite'
-  r'|key3.db|logins.json|persdict.dat)$',
-  re.IGNORECASE)
-
-# uBlock Origin
-UBO_CHROME =            'https://chrome.google.com/webstore/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm?hl=en'
-UBO_CHROME_REG =        r'Software\Wow6432Node\Google\Chrome\Extensions\cjpalhdlnbpafiamejdnhcphjbkeiagm'
-UBO_EXTRA_CHROME =      'https://chrome.google.com/webstore/detail/ublock-origin-extra/pgdnlhfefecpicbbihgmbmffkjpaplco?hl=en'
-UBO_EXTRA_CHROME_REG =  r'Software\Wow6432Node\Google\Chrome\Extensions\pgdnlhfefecpicbbihgmbmffkjpaplco'
-UBO_MOZILLA =           'https://addons.mozilla.org/en-us/firefox/addon/ublock-origin/'
-UBO_MOZZILA_PATH =      r'{}\Mozilla Firefox\distribution\extensions\ublock_origin.xpi'.format(os.environ.get('PROGRAMFILES'))
-UBO_MOZILLA_REG =       r'Software\Mozilla\Firefox\Extensions'
-UBO_MOZILLA_REG_NAME =  'uBlock0@raymondhill.net'
-UBO_OPERA =             'https://addons.opera.com/en/extensions/details/ublock/?display=en'
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2 tw=0

scripts/wk.prev/settings/cleanup.py

@@ -1,37 +0,0 @@
-'''Wizard Kit: Settings - Cleanup'''
-# vim: sts=2 sw=2 ts=2
-
-import re
-
-# Regex
-DESKTOP_ITEMS = re.compile(
-  r'^(JRT|RKill|sc-cleaner)',
-  re.IGNORECASE,
-  )
-
-# Registry
-UAC_DEFAULTS_WIN7 = {
-  r'Software\Microsoft\Windows\CurrentVersion\Policies\System': {
-    'DWORD Items': {
-      'ConsentPromptBehaviorAdmin': 5,
-      'EnableLUA': 1,
-      'PromptOnSecureDesktop': 1,
-      },
-    },
-  }
-UAC_DEFAULTS_WIN10 = {
-  r'Software\Microsoft\Windows\CurrentVersion\Policies\System': {
-    'DWORD Items': {
-      'ConsentPromptBehaviorAdmin': 5,
-      'ConsentPromptBehaviorUser': 3,
-      'EnableInstallerDetection': 1,
-      'EnableLUA': 1,
-      'EnableVirtualization': 1,
-      'PromptOnSecureDesktop': 1,
-      },
-    },
-  }
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")

scripts/wk.prev/settings/data.py

@@ -1,105 +0,0 @@
-# Wizard Kit: Settings - Data
-
-import ctypes
-import re
-
-from settings.main import *
-
-# FastCopy
-FAST_COPY_EXCLUDES = [
-  r'\*.esd',
-  r'\*.swm',
-  r'\*.wim',
-  r'\*.dd',
-  r'\*.dd.tgz',
-  r'\*.dd.txz',
-  r'\*.map',
-  r'\*.dmg',
-  r'\*.image',
-  r'$RECYCLE.BIN',
-  r'$Recycle.Bin',
-  r'.AppleDB',
-  r'.AppleDesktop',
-  r'.AppleDouble',
-  r'.com.apple.timemachine.supported',
-  r'.dbfseventsd',
-  r'.DocumentRevisions-V100*',
-  r'.DS_Store',
-  r'.fseventsd',
-  r'.PKInstallSandboxManager',
-  r'.Spotlight*',
-  r'.SymAV*',
-  r'.symSchedScanLockxz',
-  r'.TemporaryItems',
-  r'.Trash*',
-  r'.vol',
-  r'.VolumeIcon.icns',
-  r'desktop.ini',
-  r'Desktop?DB',
-  r'Desktop?DF',
-  r'hiberfil.sys',
-  r'lost+found',
-  r'Network?Trash?Folder',
-  r'pagefile.sys',
-  r'Recycled',
-  r'RECYCLER',
-  r'System?Volume?Information',
-  r'Temporary?Items',
-  r'Thumbs.db',
-  ]
-FAST_COPY_ARGS = [
-  '/cmd=noexist_only',
-  '/utf8',
-  '/skip_empty_dir',
-  '/linkdest',
-  '/no_ui',
-  '/auto_close',
-  '/exclude={}'.format(';'.join(FAST_COPY_EXCLUDES)),
-  ]
-
-# Regex
-REGEX_EXCL_ITEMS = re.compile(
-  r'^(\.(AppleDB|AppleDesktop|AppleDouble'
-  r'|com\.apple\.timemachine\.supported|dbfseventsd'
-  r'|DocumentRevisions-V100.*|DS_Store|fseventsd|PKInstallSandboxManager'
-  r'|Spotlight.*|SymAV.*|symSchedScanLockxz|TemporaryItems|Trash.*'
-  r'|vol|VolumeIcon\.icns)|desktop\.(ini|.*DB|.*DF)'
-  r'|(hiberfil|pagefile)\.sys|lost\+found|Network\.*Trash\.*Folder'
-  r'|Recycle[dr]|System\.*Volume\.*Information|Temporary\.*Items'
-  r'|Thumbs\.db)$',
-  re.IGNORECASE)
-REGEX_EXCL_ROOT_ITEMS = re.compile(
-  r'^(boot(mgr|nxt)$|Config.msi'
-  r'|(eula|globdata|install|vc_?red)'
-  r'|.*.sys$|System Volume Information|RECYCLER?|\$Recycle\.bin'
-  r'|\$?Win(dows(.old.*|\.  BT|)$|RE_)|\$GetCurrent|Windows10Upgrade'
-  r'|PerfLogs|Program Files|SYSTEM.SAV'
-  r'|.*\.(esd|swm|wim|dd|map|dmg|image)$)',
-  re.IGNORECASE)
-REGEX_INCL_ROOT_ITEMS = re.compile(
-  r'^(AdwCleaner|(My\s*|)(Doc(uments?( and Settings|)|s?)|Downloads'
-  r'|Media|Music|Pic(ture|)s?|Vid(eo|)s?)'
-  r'|{prefix}(-?Info|-?Transfer|)'
-  r'|(ProgramData|Recovery|Temp.*|Users)$'
-  r'|.*\.(log|txt|rtf|qb\w*|avi|m4a|m4v|mp4|mkv|jpg|png|tiff?)$)'
-  r''.format(prefix=KIT_NAME_SHORT),
-  re.IGNORECASE)
-REGEX_WIM_FILE = re.compile(
-  r'\.wim$',
-  re.IGNORECASE)
-REGEX_WINDOWS_OLD = re.compile(
-  r'^Win(dows|)\.old',
-  re.IGNORECASE)
-
-# Thread error modes
-## Code borrowed from: https://stackoverflow.com/a/29075319
-SEM_NORMAL = ctypes.c_uint()
-SEM_FAILCRITICALERRORS = 1
-SEM_NOOPENFILEERRORBOX = 0x8000
-SEM_FAIL = SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/settings/ddrescue.py

@@ -1,61 +0,0 @@
-# Wizard Kit: Settings - ddrescue-tui
-
-import re
-
-from collections import OrderedDict
-
-# General
-MAP_DIR = '/Backups/ddrescue-tui'
-RECOMMENDED_FSTYPES = ['ext3', 'ext4', 'xfs']
-RECOMMENDED_MAP_FSTYPES = ['cifs', 'ext2', 'ext3', 'ext4', 'vfat', 'xfs']
-USAGE = """  {script_name} clone [source [destination]]
-  {script_name} image [source [destination]]
-  (e.g. {script_name} clone /dev/sda /dev/sdb)
-"""
-
-# Layout
-SIDE_PANE_WIDTH = 21
-TMUX_LAYOUT = OrderedDict({
-  'Source':   {'y': 2,         'Check': True},
-  'Started':  {'x': SIDE_PANE_WIDTH, 'Check': True},
-  'Progress': {'x': SIDE_PANE_WIDTH, 'Check': True},
-})
-
-# ddrescue
-AUTO_PASS_1_THRESHOLD = 95
-AUTO_PASS_2_THRESHOLD = 98
-DDRESCUE_SETTINGS = {
-  '--binary-prefixes':  {'Enabled': True,                 'Hidden': True, },
-  '--data-preview':     {'Enabled': True,   'Value': '5', 'Hidden': True, },
-  '--idirect':          {'Enabled': True,                                 },
-  '--odirect':          {'Enabled': True,                                 },
-  '--max-read-rate':    {'Enabled': False,  'Value': '1MiB',              },
-  '--min-read-rate':    {'Enabled': True,   'Value': '64KiB',             },
-  '--reopen-on-error':  {'Enabled': True,                                 },
-  '--retry-passes':     {'Enabled': True,   'Value': '0',                 },
-  '--test-mode':        {'Enabled': False,  'Value': 'test.map',          },
-  '--timeout':          {'Enabled': True,   'Value': '5m',                },
-  '-vvvv':              {'Enabled': True,                 'Hidden': True, },
-  }
-ETOC_REFRESH_RATE = 30 # in seconds
-REGEX_DDRESCUE_LOG = re.compile(
-  r'^\s*(?P<key>\S+):\s+'
-  r'(?P<size>\d+)\s+'
-  r'(?P<unit>[PTGMKB])i?B?',
-  re.IGNORECASE,
-  )
-REGEX_REMAINING_TIME = re.compile(
-  r'remaining time:'
-  r'\s*((?P<days>\d+)d)?'
-  r'\s*((?P<hours>\d+)h)?'
-  r'\s*((?P<minutes>\d+)m)?'
-  r'\s*((?P<seconds>\d+)s)?'
-  r'\s*(?P<na>n/a)?',
-  re.IGNORECASE
-  )
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/settings/hw_diags.py

@@ -1,113 +0,0 @@
-# Wizard Kit: Settings - HW Diagnostics
-
-from collections import OrderedDict
-
-# General
-DEBUG_MODE = False
-OVERRIDES_FORCED = False
-OVERRIDES_LIMITED = True # If True this disables OVERRIDE_FORCED
-STATUSES = {
-  'RED':    ['Denied', 'ERROR', 'NS', 'TimedOut'],
-  'YELLOW': ['Aborted', 'N/A', 'OVERRIDE', 'Unknown', 'Working'],
-  'GREEN':  ['CS'],
-}
-TESTS_CPU = ['Prime95']
-TESTS_DISK = [
-  'I/O Benchmark',
-  'NVMe / SMART',
-  'badblocks',
-  ]
-
-# Layout
-## NOTE: Colors will be applied in functions/hw_diags.py
-QUICK_LABEL = '{YELLOW}(Quick){CLEAR}'
-SIDE_PANE_WIDTH = 20
-TOP_PANE_TEXT = '{GREEN}Hardware Diagnostics{CLEAR}'
-TMUX_LAYOUT = OrderedDict({
-  'Top':            {'y': 2,                'Check': True},
-  'Started':        {'x': SIDE_PANE_WIDTH,  'Check': True},
-  'Progress':       {'x': SIDE_PANE_WIDTH,  'Check': True},
-  # Testing panes
-  'Prime95':        {'y': 11,               'Check': False},
-  'Temps':          {'y': 1000,             'Check': False},
-  'SMART':          {'y': 3,                'Check': True},
-  'badblocks':      {'y': 5,                'Check': True},
-  'I/O Benchmark':  {'y': 1000,             'Check': False},
-})
-
-# Tests: badblocks
-## NOTE: Force 4K read block size for disks >= to 3TB
-BADBLOCKS_LARGE_DISK = 3*1024**4
-
-# Tests: I/O Benchmark
-IO_VARS = {
-  'Block Size': 512*1024,
-  'Chunk Size': 32*1024**2,
-  'Minimum Test Size': 10*1024**3,
-  'Alt Test Size Factor': 0.01,
-  'Progress Refresh Rate': 5,
-  'Scale 8': [2**(0.56*(x+1))+(16*(x+1)) for x in range(8)],
-  'Scale 16': [2**(0.56*(x+1))+(16*(x+1)) for x in range(16)],
-  'Scale 32': [2**(0.56*(x+1)/2)+(16*(x+1)/2) for x in range(32)],
-  'Threshold Graph Fail': 65*1024**2,
-  'Threshold Graph Warn': 135*1024**2,
-  'Threshold Graph Great': 750*1024**2,
-  'Threshold HDD Min': 50*1024**2,
-  'Threshold HDD High Avg': 75*1024**2,
-  'Threshold HDD Low Avg': 65*1024**2,
-  'Threshold SSD Min': 90*1024**2,
-  'Threshold SSD High Avg': 135*1024**2,
-  'Threshold SSD Low Avg': 100*1024**2,
-  'Graph Horizontal': ('▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'),
-  'Graph Horizontal Width': 40,
-  'Graph Vertical': (
-    '▏',    '▎',    '▍',    '▌',
-    '▋',    '▊',    '▉',    '█',
-    '█▏',   '█▎',   '█▍',   '█▌',
-    '█▋',   '█▊',   '█▉',   '██',
-    '██▏',  '██▎',  '██▍',  '██▌',
-    '██▋',  '██▊',  '██▉',  '███',
-    '███▏', '███▎', '███▍', '███▌',
-    '███▋', '███▊', '███▉', '████'),
-  }
-
-# Tests: NVMe/SMART
-ATTRIBUTES = {
-  'NVMe': {
-    'critical_warning': {'Critical': True,  'Ignore': False,  'Warning': None,  'Error': 1,     'Maximum': None,  },
-    'media_errors':     {'Critical': True,  'Ignore': False,  'Warning': None,  'Error': 1,     'Maximum': None,  },
-    'power_on_hours':   {'Critical': False, 'Ignore': True,   'Warning': 17532, 'Error': 26298, 'Maximum': None,  },
-    'unsafe_shutdowns': {'Critical': False, 'Ignore': True,   'Warning': 1,     'Error': None,  'Maximum': None,  },
-    },
-  'SMART': {
-    5:    {'Hex': '05', 'Critical': True,   'Ignore': False,  'Warning': None,  'Error': 1,     'Maximum': None,  },
-    9:    {'Hex': '09', 'Critical': False,  'Ignore': True,   'Warning': 17532, 'Error': 26298, 'Maximum': None,  },
-    10:   {'Hex': '10', 'Critical': False,  'Ignore': False,  'Warning': 1,     'Error': 10,    'Maximum': 10000, },
-    184:  {'Hex': 'B8', 'Critical': False,  'Ignore': False,  'Warning': 1,     'Error': 10,    'Maximum': 10000, },
-    187:  {'Hex': 'BB', 'Critical': False,  'Ignore': False,  'Warning': 1,     'Error': 10,    'Maximum': 10000, },
-    188:  {'Hex': 'BC', 'Critical': False,  'Ignore': False,  'Warning': 1,     'Error': 10,    'Maximum': 10000, },
-    196:  {'Hex': 'C4', 'Critical': False,  'Ignore': False,  'Warning': 1,     'Error': 10,    'Maximum': 10000, },
-    197:  {'Hex': 'C5', 'Critical': True,   'Ignore': False,  'Warning': None,  'Error': 1,     'Maximum': None,  },
-    198:  {'Hex': 'C6', 'Critical': True,   'Ignore': False,  'Warning': None,  'Error': 1,     'Maximum': None,  },
-    199:  {'Hex': 'C7', 'Critical': False,  'Ignore': True,   'Warning': None,  'Error': 1,     'Maximum': None,  },
-    201:  {'Hex': 'C9', 'Critical': False,  'Ignore': False,  'Warning': None,  'Error': 1,     'Maximum': 10000, },
-    },
-  }
-ATTRIBUTE_COLORS = (
-  # NOTE: The order here is important; least important to most important.
-  ('Warning', 'YELLOW'),
-  ('Error', 'RED'),
-  ('Maximum', 'PURPLE'),
-  )
-KEY_NVME = 'nvme_smart_health_information_log'
-KEY_SMART = 'ata_smart_attributes'
-
-# Tests: Prime95
-MPRIME_LIMIT = 7    # of minutes to run Prime95
-THERMAL_LIMIT = 95  # Abort temperature in Celsius
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2 tw=0

scripts/wk.prev/settings/info.py

@@ -1,58 +0,0 @@
-# Wizard Kit: Settings - Information
-
-import re
-
-# General
-REG_PROFILE_LIST = r'SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList'
-REG_SHELL_FOLDERS = r'Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders'
-TMP_HIVE_PATH = 'TEMP_HIVE_MOUNT'
-EXTRA_FOLDERS = [
-  'Dropbox',
-  'Google Drive',
-  'OneDrive',
-  'SkyDrive',
-]
-SHELL_FOLDERS = {
-  #GUIDs from: https://msdn.microsoft.com/en-us/library/windows/desktop/dd378457(v=vs.85).aspx
-  'Desktop': (
-    '{B4BFCC3A-DB2C-424C-B029-7FE99A87C641}',
-    ),
-  'Documents': (
-    'Personal',
-    '{FDD39AD0-238F-46AF-ADB4-6C85480369C7}',
-    ),
-  'Downloads': (
-    '{374DE290-123F-4565-9164-39C4925E467B}',
-    ),
-  'Favorites': (
-    '{1777F761-68AD-4D8A-87BD-30B759FA33DD}',
-    ),
-  'Music': (
-    'My Music',
-    '{4BD8D571-6D19-48D3-BE97-422220080E43}',
-    ),
-  'Pictures': (
-    'My Pictures',
-    '{33E28130-4E1E-4676-835A-98395C3BC3BB}',
-    ),
-  'Videos': (
-    'My Video',
-    '{18989B1D-99B5-455B-841C-AB7C74E4DDFC}',
-    ),
-}
-
-# Regex
-REGEX_OFFICE = re.compile(
-  r'(Microsoft (Office\s+'
-    r'(365|Enterprise|Home|Pro(\s|fessional)'
-    r'|Single|Small|Standard|Starter|Ultimate|system)'
-    r'|Works[-\s\d]+\d)'
-  r'|(Libre|Open|Star)\s*Office'
-  r'|WordPerfect|Gnumeric|Abiword)',
-  re.IGNORECASE)
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2

scripts/wk.prev/settings/launchers.py

@@ -1,602 +0,0 @@
-'''Wizard Kit: Settings - Launchers'''
-# pylint: disable=line-too-long
-# vim: sts=2 sw=2 ts=2
-
-LAUNCHERS = {
-  r'(Root)': {
-    'System Diagnostics': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'system_diagnostics.py',
-      'L_ELEV': 'True',
-      },
-    'System Setup': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'system_setup.py',
-      'L_ELEV': 'True',
-      },
-    },
-  r'Data Recovery': {
-    'PhotoRec (CLI)': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'TestDisk',
-      'L_ITEM': 'photorec_win.exe',
-      'L_ELEV': 'True',
-      'L__CLI': 'True',
-      },
-    'PhotoRec': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'TestDisk',
-      'L_ITEM': 'qphotorec_win.exe',
-      'L_ELEV': 'True',
-      },
-    'TestDisk': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'TestDisk',
-      'L_ITEM': 'testdisk_win.exe',
-      'L_ELEV': 'True',
-      'L__CLI': 'True',
-      },
-    },
-  r'Data Transfers': {
-    # pylint: disable=bad-continuation
-    'FastCopy (as ADMIN)': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'FastCopy',
-      'L_ITEM': 'FastCopy.exe',
-      'L_ARGS': (
-        r' /logfile=%log_dir%\Tools\FastCopy.log'
-        r' /cmd=noexist_only'
-        r' /utf8'
-        r' /skip_empty_dir'
-        r' /linkdest'
-        r' /exclude='
-          r'$RECYCLE.BIN;'
-          r'$Recycle.Bin;'
-          r'.AppleDB;'
-          r'.AppleDesktop;'
-          r'.AppleDouble;'
-          r'.com.apple.timemachine.supported;'
-          r'.dbfseventsd;'
-          r'.DocumentRevisions-V100*;'
-          r'.DS_Store;'
-          r'.fseventsd;'
-          r'.PKInstallSandboxManager;'
-          r'.Spotlight*;'
-          r'.SymAV*;'
-          r'.symSchedScanLockxz;'
-          r'.TemporaryItems;'
-          r'.Trash*;'
-          r'.vol;'
-          r'.VolumeIcon.icns;'
-          r'desktop.ini;'
-          r'Desktop?DB;'
-          r'Desktop?DF;'
-          r'hiberfil.sys;'
-          r'lost+found;'
-          r'Network?Trash?Folder;'
-          r'pagefile.sys;'
-          r'Recycled;'
-          r'RECYCLER;'
-          r'System?Volume?Information;'
-          r'Temporary?Items;'
-          r'Thumbs.db'
-        r' /to=%client_dir%\Transfer_%iso_date%\ '
-        ),
-      'L_ELEV': 'True',
-      'Extra Code': [
-        r'call "%bin%\Scripts\init_client_dir.cmd" /Logs /Transfer',
-        ],
-      },
-    'FastCopy': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'FastCopy',
-      'L_ITEM': 'FastCopy.exe',
-      'L_ARGS': (
-        r' /logfile=%log_dir%\Tools\FastCopy.log'
-        r' /cmd=noexist_only'
-        r' /utf8'
-        r' /skip_empty_dir'
-        r' /linkdest'
-        r' /exclude='
-          r'$RECYCLE.BIN;'
-          r'$Recycle.Bin;'
-          r'.AppleDB;'
-          r'.AppleDesktop;'
-          r'.AppleDouble;'
-          r'.com.apple.timemachine.supported;'
-          r'.dbfseventsd;'
-          r'.DocumentRevisions-V100*;'
-          r'.DS_Store;'
-          r'.fseventsd;'
-          r'.PKInstallSandboxManager;'
-          r'.Spotlight*;'
-          r'.SymAV*;'
-          r'.symSchedScanLockxz;'
-          r'.TemporaryItems;'
-          r'.Trash*;'
-          r'.vol;'
-          r'.VolumeIcon.icns;'
-          r'desktop.ini;'
-          r'Desktop?DB;'
-          r'Desktop?DF;'
-          r'hiberfil.sys;'
-          r'lost+found;'
-          r'Network?Trash?Folder;'
-          r'pagefile.sys;'
-          r'Recycled;'
-          r'RECYCLER;'
-          r'System?Volume?Information;'
-          r'Temporary?Items;'
-          r'Thumbs.db'
-        r' /to=%client_dir%\Transfer_%iso_date%\ '
-        ),
-      'Extra Code': [
-        r'call "%bin%\Scripts\init_client_dir.cmd" /Logs /Transfer',
-        ],
-      },
-    'KVRT': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'KVRT',
-      'L_ITEM': 'KVRT.exe',
-      'L_ARGS': (
-        r' -accepteula'
-        r' -d %q_dir%'
-        r' -processlevel 3'
-        r' -dontcryptsupportinfo'
-        r' -fixednames'
-        ),
-      'Extra Code': [
-        r'call "%bin%\Scripts\init_client_dir.cmd" /Quarantine',
-        r'set "q_dir=%client_dir%\Quarantine\KVRT"',
-        r'mkdir "%q_dir%">nul 2>&1',
-        ],
-      },
-    'Transferred Keys': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'transferred_keys.py',
-      'L_ELEV': 'True',
-      },
-    'User Data Transfer': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'user_data_transfer.py',
-      'L_ELEV': 'True',
-      },
-    'XYplorer (as ADMIN)': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'XYplorerFree',
-      'L_ITEM': 'XYplorerFree.exe',
-      'L_ARGS': r'/exp /win=max %userprofile%',
-      'L_ELEV': 'True',
-      },
-    'XYplorer': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'XYplorerFree',
-      'L_ITEM': 'XYplorerFree.exe',
-      'L_ARGS': r'/exp /win=max %userprofile%',
-      },
-    },
-  r'Diagnostics': {
-    'HWiNFO': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'HWiNFO',
-      'L_ITEM': 'HWiNFO.exe',
-      'Extra Code': [
-        r'for %%a in (32 64) do (',
-        r'  copy /y "%bin%\HWiNFO\general.ini" "%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r'  (echo SensorsOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r'  (echo SummaryOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r')',
-        ],
-      },
-    'ProduKey': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'ProduKey',
-      'L_ITEM': 'ProduKey.exe',
-      'L_ELEV': 'True',
-      'Extra Code': [
-        r'if exist "%bin%\ProduKey" (',
-        r'  del "%bin%\ProduKey\ProduKey.cfg" 2>nul',
-        r'  del "%bin%\ProduKey\ProduKey64.cfg" 2>nul',
-        r')',
-        ],
-      },
-    },
-  r'Diagnostics\Extras': {
-    'AIDA64': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'AIDA64',
-      'L_ITEM': 'aida64.exe',
-      },
-    'Autoruns (with VirusTotal Scan)': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'Autoruns',
-      'L_ITEM': 'Autoruns.exe',
-      'L_ARGS': '-e',
-      'Extra Code': [
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v checkvirustotal /t REG_DWORD /d 1 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v shownomicrosoft /t REG_DWORD /d 1 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v shownowindows /t REG_DWORD /d 1 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v showonlyvirustotal /t REG_DWORD /d 1 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v submitvirustotal /t REG_DWORD /d 0 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v verifysignatures /t REG_DWORD /d 1 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns\SigCheck /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns\Streams /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns\VirusTotal /v VirusTotalTermsAccepted /t REG_DWORD /d 1 /f >nul',
-        ],
-      },
-    'BleachBit': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'BleachBit',
-      'L_ITEM': 'bleachbit.exe',
-      },
-    'BlueScreenView': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'BlueScreenView',
-      'L_ITEM': 'BlueScreenView.exe',
-      },
-    'ERUNT': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'erunt',
-      'L_ITEM': 'ERUNT.EXE',
-      'L_ARGS': r'%client_dir%\Backups\Registry\%iso_date% sysreg curuser otherusers',
-      'L_ELEV': 'True',
-      'Extra Code': [
-        r'call "%bin%\Scripts\init_client_dir.cmd" /Logs',
-        ],
-      },
-    'HitmanPro': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'HitmanPro',
-      'L_ITEM': 'HitmanPro.exe',
-      'Extra Code': [
-        r'call "%bin%\Scripts\init_client_dir.cmd" /Logs',
-        ],
-      },
-    'HWiNFO (Sensors)': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'HWiNFO',
-      'L_ITEM': 'HWiNFO.exe',
-      'Extra Code': [
-        r'for %%a in (32 64) do (',
-        r'  copy /y "%bin%\HWiNFO\general.ini" "%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r'  (echo SensorsOnly=1)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r'  (echo SummaryOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r')',
-        ],
-      },
-    },
-  r'Drivers': {
-    'Intel RST (Current Release)': {
-      'L_TYPE': 'Executable',
-      'L_PATH': r'_Drivers\Intel RST',
-      'L_ITEM': 'SetupRST_17.2.exe',
-      'L_7ZIP': 'SetupRST_17.2.exe',
-      },
-    'Intel RST (Previous Releases)': {
-      'L_TYPE': 'Folder',
-      'L_PATH': r'_Drivers\Intel RST',
-      'L_ITEM': '.',
-      'L_NCMD': 'True',
-      },
-    'Intel SSD Toolbox': {
-      'L_TYPE': 'Executable',
-      'L_PATH': r'_Drivers\Intel SSD Toolbox',
-      'L_ITEM': 'Intel SSD Toolbox.exe',
-      },
-    'Samsing Magician': {
-      'L_TYPE': 'Executable',
-      'L_PATH': r'_Drivers\Samsung Magician',
-      'L_ITEM': 'Samsung Magician.exe',
-      },
-    'Snappy Driver Installer Origin': {
-      'L_TYPE': 'Executable',
-      'L_PATH': r'_Drivers\SDIO',
-      'L_ITEM': 'SDIO.exe',
-      },
-    },
-  r'Drivers\Extras': {
-    'Acer': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'HWiNFO',
-      'L_ITEM': 'HWiNFO.exe',
-      'Extra Code': [
-        r'for %%a in (32 64) do (',
-        r'  copy /y "%bin%\HWiNFO\general.ini" "%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r'  (echo SensorsOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r'  (echo SummaryOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r')',
-        r'start "" "http://us.acer.com/ac/en/US/content/drivers"',
-        ],
-      },
-    'Lenovo': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'HWiNFO',
-      'L_ITEM': 'HWiNFO.exe',
-      'Extra Code': [
-        r'for %%a in (32 64) do (',
-        r'  copy /y "%bin%\HWiNFO\general.ini" "%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r'  (echo SensorsOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r'  (echo SummaryOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r')',
-        r'start "" "https://pcsupport.lenovo.com/us/en/"',
-        ],
-      },
-    'Toshiba': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'HWiNFO',
-      'L_ITEM': 'HWiNFO.exe',
-      'Extra Code': [
-        r'for %%a in (32 64) do (',
-        r'  copy /y "%bin%\HWiNFO\general.ini" "%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r'  (echo SensorsOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r'  (echo SummaryOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
-        r')',
-        r'start "" "http://support.toshiba.com/drivers"',
-        ],
-      },
-    },
-  r'Installers': {
-    'SW Bundle': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'install_sw_bundle.py',
-      'L_ELEV': 'True',
-      },
-    },
-  r'Installers\Extras\Office\2016': {
-    'Home and Business (x32)': {
-      'L_TYPE': 'Office',
-      'L_PATH': '2016',
-      'L_ITEM': '2016_hb_32.xml',
-      'L_NCMD': 'True',
-      },
-    'Home and Business (x64)': {
-      'L_TYPE': 'Office',
-      'L_PATH': '2016',
-      'L_ITEM': '2016_hb_64.xml',
-      'L_NCMD': 'True',
-      },
-    'Home and Student (x32)': {
-      'L_TYPE': 'Office',
-      'L_PATH': '2016',
-      'L_ITEM': '2016_hs_32.xml',
-      'L_NCMD': 'True',
-      },
-    'Home and Student (x64)': {
-      'L_TYPE': 'Office',
-      'L_PATH': '2016',
-      'L_ITEM': '2016_hs_64.xml',
-      'L_NCMD': 'True',
-      },
-    },
-  r'Installers\Extras\Office\2019': {
-    'Home and Business (x32)': {
-      'L_TYPE': 'Office',
-      'L_PATH': '2019',
-      'L_ITEM': '2019_hb_32.xml',
-      'L_NCMD': 'True',
-      },
-    'Home and Business (x64)': {
-      'L_TYPE': 'Office',
-      'L_PATH': '2019',
-      'L_ITEM': '2019_hb_64.xml',
-      'L_NCMD': 'True',
-      },
-    'Home and Student (x32)': {
-      'L_TYPE': 'Office',
-      'L_PATH': '2019',
-      'L_ITEM': '2019_hs_32.xml',
-      'L_NCMD': 'True',
-      },
-    'Home and Student (x64)': {
-      'L_TYPE': 'Office',
-      'L_PATH': '2019',
-      'L_ITEM': '2019_hs_64.xml',
-      'L_NCMD': 'True',
-      },
-    'Office 365 (x32)': {
-      'L_TYPE': 'Office',
-      'L_PATH': '2019',
-      'L_ITEM': '365_32.xml',
-      'L_NCMD': 'True',
-      },
-    'Office 365 (x64)': {
-      'L_TYPE': 'Office',
-      'L_PATH': '2019',
-      'L_ITEM': '365_64.xml',
-      'L_NCMD': 'True',
-      },
-    },
-  r'Installers\Extras\Runtimes': {
-    'Visual C++ Runtimes': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'install_vcredists.py',
-      'L_ELEV': 'True',
-      },
-    },
-  r'Misc': {
-    'Activate Windows': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'activate.py',
-      'L_ELEV': 'True',
-      },
-    'Cleanup CBS Temp Files': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'cbs_fix.py',
-      'L_ELEV': 'True',
-      },
-    'ConEmu (as ADMIN)': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'ConEmu',
-      'L_ITEM': 'ConEmu.exe',
-      'L_ELEV': 'True',
-      },
-    'ConEmu': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'ConEmu',
-      'L_ITEM': 'ConEmu.exe',
-      },
-    'Disable Windows Updates': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'windows_updates.py',
-      'L_ARGS': '--disable',
-      'L_ELEV': 'True',
-      },
-    'Enable Windows Updates': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'windows_updates.py',
-      'L_ARGS': '--enable',
-      'L_ELEV': 'True',
-      },
-    'Enter SafeMode': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'safemode_enter.py',
-      'L_ELEV': 'True',
-      },
-    'Everything': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'Everything',
-      'L_ITEM': 'Everything.exe',
-      'L_ARGS': '-nodb',
-      'L_ELEV': 'True',
-      },
-    'Exit SafeMode': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'safemode_exit.py',
-      'L_ELEV': 'True',
-      },
-    'Notepad++': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'notepadplusplus',
-      'L_ITEM': 'notepadplusplus.exe',
-      },
-    'PuTTY': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'PuTTY',
-      'L_ITEM': 'PUTTY.EXE',
-      },
-    'WizTree': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'WizTree',
-      'L_ITEM': 'WizTree.exe',
-      'L_ELEV': 'True',
-      },
-    'XMPlay': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'XMPlay',
-      'L_ITEM': 'xmplay.exe',
-      'L_ARGS': r'"%bin%\XMPlay\music.7z"',
-      },
-    },
-  r'Repairs': {
-    'AdwCleaner': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'AdwCleaner',
-      'L_ITEM': 'AdwCleaner.exe',
-      },
-    'Autoruns': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'Autoruns',
-      'L_ITEM': 'Autoruns.exe',
-      'L_ARGS': '-e',
-      'Extra Code': [
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v checkvirustotal /t REG_DWORD /d 0 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v shownomicrosoft /t REG_DWORD /d 1 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v shownowindows /t REG_DWORD /d 1 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v showonlyvirustotal /t REG_DWORD /d 0 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v submitvirustotal /t REG_DWORD /d 0 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns /v verifysignatures /t REG_DWORD /d 0 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns\SigCheck /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns\Streams /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
-        r'reg add HKCU\Software\Sysinternals\AutoRuns\VirusTotal /v VirusTotalTermsAccepted /t REG_DWORD /d 1 /f >nul',
-        ],
-      },
-    'CHKDSK': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'check_disk.py',
-      'L_ELEV': 'True',
-      },
-    'DISM': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'dism.py',
-      'L_ELEV': 'True',
-      },
-    'KVRT': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'KVRT',
-      'L_ITEM': 'KVRT.exe',
-      'L_ARGS': (
-        r' -accepteula'
-        r' -d %q_dir%'
-        r' -processlevel 3'
-        r' -dontcryptsupportinfo'
-        r' -fixednames'
-        ),
-      'Extra Code': [
-        r'call "%bin%\Scripts\init_client_dir.cmd" /Quarantine',
-        r'set "q_dir=%client_dir%\Quarantine\KVRT"',
-        r'mkdir "%q_dir%">nul 2>&1',
-        ],
-      },
-    'RKill': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'RKill',
-      'L_ITEM': 'RKill.exe',
-      'L_ARGS': r'-s -l %log_dir%\Tools\RKill.log',
-      'L_ELEV': 'True',
-      'Extra Code': [
-        r'call "%bin%\Scripts\init_client_dir.cmd" /Logs',
-        ],
-      },
-    'SFC Scan': {
-      'L_TYPE': 'PyScript',
-      'L_PATH': 'Scripts',
-      'L_ITEM': 'sfc_scan.py',
-      'L_ELEV': 'True',
-      },
-    'TDSSKiller': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'TDSSKiller',
-      'L_ITEM': 'TDSSKiller.exe',
-      'L_ARGS': (
-        r' -l %log_dir%\Tools\TDSSKiller.log'
-        r' -qpath %q_dir%'
-        r' -accepteula'
-        r' -accepteulaksn'
-        r' -dcexact'
-        r' -tdlfs'
-        ),
-      'Extra Code': [
-        r'call "%bin%\Scripts\init_client_dir.cmd" /Quarantine',
-        r'set "q_dir=%client_dir%\Quarantine\TDSSKiller"',
-        r'mkdir "%q_dir%">nul 2>&1',
-        ],
-      },
-    },
-  r'Uninstallers': {
-    'IObit Uninstaller': {
-      'L_TYPE': 'Executable',
-      'L_PATH': 'IObitUninstallerPortable',
-      'L_ITEM': 'IObitUninstallerPortable.exe',
-      },
-    },
-  }
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")

scripts/wk.prev/settings/main.py

@@ -1,90 +0,0 @@
-# Wizard Kit: Settings - Main / Branding
-
-# Features
-ENABLED_OPEN_LOGS = False
-ENABLED_TICKET_NUMBERS = False
-ENABLED_UPLOAD_DATA = False
-
-# STATIC VARIABLES (also used by BASH and BATCH files)
-## NOTE: There are no spaces around the = for easier parsing in BASH and BATCH
-# Main Kit
-ARCHIVE_PASSWORD='Abracadabra'
-KIT_NAME_FULL='WizardKit'
-KIT_NAME_SHORT='WK'
-SUPPORT_MESSAGE='Please let 2Shirt know by opening an issue on GitHub'
-# Live Linux
-ROOT_PASSWORD='Abracadabra'
-TECH_PASSWORD='Abracadabra'
-# Server IP addresses
-OFFICE_SERVER_IP='10.0.0.10'
-QUICKBOOKS_SERVER_IP='10.0.0.10'
-# Time Zones
-LINUX_TIME_ZONE='America/Denver'            # See 'timedatectl list-timezones' for valid values
-WINDOWS_TIME_ZONE='Mountain Standard Time'  # See 'tzutil /l' for valid values
-
-# SERVER VARIABLES
-## NOTE: Windows can only use one user per server. This means that if
-##       one server serves multiple shares then you have to use the same
-##       user/password for all of those shares.
-BACKUP_SERVERS = [
-  { 'IP':      '10.0.0.10',
-    'Name':     'ServerOne',
-    'Mounted':  False,
-    'Share':    'Backups',
-    'User':     'restore',
-    'Pass':     'Abracadabra',
-    'RW-User':  'backup',
-    'RW-Pass':  'Abracadabra',
-    },
-  { 'IP':       '10.0.0.11',
-    'Name':     'ServerTwo',
-    'Mounted':  False,
-    'Share':    'Backups',
-    'User':     'restore',
-    'Pass':     'Abracadabra',
-    'RW-User':  'backup',
-    'RW-Pass':  'Abracadabra',
-    },
-  ]
-CRASH_SERVER = {
-  'Name':       'CrashServer',
-  'Url':        '',
-  'User':       '',
-  'Pass':       '',
-  }
-OFFICE_SERVER = {
-  'IP':         OFFICE_SERVER_IP,
-  'Name':       'ServerOne',
-  'Mounted':    False,
-  'Share':      'Office',
-  'User':       'restore',
-  'Pass':       'Abracadabra',
-  'RW-User':    'backup',
-  'RW-Pass':    'Abracadabra',
-  }
-QUICKBOOKS_SERVER = {
-  'IP':         QUICKBOOKS_SERVER_IP,
-  'Name':       'ServerOne',
-  'Mounted':    False,
-  'Share':      'QuickBooks',
-  'User':       'restore',
-  'Pass':       'Abracadabra',
-  'RW-User':    'backup',
-  'RW-Pass':    'Abracadabra',
-  }
-WINDOWS_SERVER = {
-  'IP':         '10.0.0.10',
-  'Name':       'ServerOne',
-  'Mounted':    False,
-  'Share':      'Windows',
-  'User':       'restore',
-  'Pass':       'Abracadabra',
-  'RW-User':    'backup',
-  'RW-Pass':    'Abracadabra',
-  }
-
-
-if __name__ == '__main__':
-  print("This file is not meant to be called directly.")
-
-# vim: sts=2 sw=2 ts=2