diff --git a/README.md b/README.md
index 6b752e01..1a766ad1 100644
--- a/README.md
+++ b/README.md
@@ -1,46 +1,2 @@
 # Utilities for the IBEX Project
 
-## repo-tools
-
-Python scripts to manipulate the ibex repositories.
-
-### Installation
-
-    cd ibex_utils\repo_tool
-    pip install .
-
-### Usage
-
-    python change_repos.py [-h] [--dry-run] -u USERNAME -o OWNER
-                       [--repo-file REPO_FILE] [--repo REPO]
-                       [--ms-from DATE_FROM] [--ms-to DATE_TO] [--ms-close]
-                       [--label-name ENSURE_LABEL]
-                       [--label-colour ENSURE_LABEL_COLOUR]
-                       [--label-file ENSURE_LABEL_FILE]
-
-    Manipulate a set of repositories, you can add milestones, close milestones, add labels.
-      E.g. -u John-Holt-Tessella -o ISISComputingGroup --ms-from 2010-04-02 --ms-to 2011-05-02 --dry_run --repo repo_name
-
-    optional arguments:
-      -h, --help            show this help message and exit
-      --dry-run             Don't change anything just tell me what you would do.
-      -u USERNAME, --username USERNAME                       GitHub username
-      -o OWNER, --owner OWNER                        Owner of the repositories
-      --repo-file REPO_FILE
-                            Apply the changes to repositories in this file. File is list of repository names,
-                            comments (lines starting with a #) and blank lines are ignored
-      --repo REPO           Apply the changes to this repository
-      --ms-from DATE_FROM   Date from which the sprint starts.
-      --ms-to DATE_TO       Date to which the sprint runs.
-      --ms-close            Close all sprint milestones which are passed with
-                            closed tickets.
-      --label-name ENSURE_LABEL
-                            Ensure that the repository has the following label
-      --label-colour ENSURE_LABEL_COLOUR
-                            Ensure that the repository has a label that is this
-                            colour. Colours are colour code no leading #, e.g.
-                            626262
-      --label-file ENSURE_LABEL_FILE
-                            Ensure that the repository has the following labels
-                            read from this file. File is lines of '<colour code>, <label name>'
-                            Comment lines (lines starting with a #) and blank lines are ignored.
diff --git a/SECI_Config_Analyser/Directory_Operations.py b/SECI_Config_Analyser/Directory_Operations.py
deleted file mode 100644
index 806e5eda..00000000
--- a/SECI_Config_Analyser/Directory_Operations.py
+++ /dev/null
@@ -1,111 +0,0 @@
-# 1. read in directory listing
-# 2. create lists of *.conf and *.comp files from directory
-# 3. for each file, parse XML for required tag and add value to list
-# 4. remove duplicates from list
-
-import xml.etree.ElementTree as ET
-from fnmatch import fnmatch
-from os import listdir
-
-
-class ReadConfigFiles:
-    """
-    Reads SECI configuration files and extracts VI names
-    """
-
-    def __init__(self, search_path):
-        """
-        create lists for filenames and initialise to empty lists
-        call methods for reading directory contents and searching for config filenames
-        :param search_path: the search path for files
-        """
-
-        self.full_path = search_path
-        self.directory_contents = listdir(self.full_path)
-        self.config_filenames = []
-        self.comp_filenames = []
-        self.vi_list = []
-        self._extract_config_filenames()
-
-    def _extract_config_filenames(self):
-        """
-        extract SECI config (*.conf) & component (*.comp) filenames
-        add to separate lists
-        """
-
-        for filename in self.directory_contents:
-            if fnmatch(filename, "*.conf"):
-                self.config_filenames.append(filename)
-
-            elif fnmatch(filename, "*.comp"):
-                self.comp_filenames.append(filename)
-
-    def _parse_vis_from_files(self, filenames):
-        """
-        extracts VI names and paths from config files
-        :param filenames: list of filenames to process
-        :return: vis_in_files: list of VIs with fullpaths
-        """
-
-        vis_in_files = []
-
-        for filename in filenames:
-            filename_and_path = self.full_path + filename
-            vis_in_file = self._parse_file(filename_and_path)
-            vis_in_files.extend(vis_in_file)
-
-        return vis_in_files
-
-    @staticmethod
-    def _parse_file(filename_and_path):
-        """
-        reads XML file and creates list of values for "FilePath" tag
-        :param filename_and_path: absolute path of file to be parsed
-        :return: vis_in_file: list of  VIs in file
-        """
-
-        vis_in_file = []
-        tree = ET.parse(filename_and_path)
-        root = tree.getroot()
-        for child in root.iter("FilePath"):
-            vi_path = ET.tostring(child, encoding=None, method="text")
-            vis_in_file.append(vi_path.strip())
-
-        return vis_in_file
-
-    @staticmethod
-    def _remove_duplicates(input_list):
-        """
-        remove duplicates from list, then sort alphabetically
-        :param input_list: input list
-        :return: output_list: original list with duplicates removed
-        """
-
-        # maintain list of "encountered" items in dummy list
-        # if item not in this list, add item to it and to output list
-
-        output_list = list()
-        encountered = set()
-
-        for item in input_list:
-            item = str(item, "UTF-8")
-            if item not in encountered:
-                output_list.append(item)
-                encountered.add(item)
-
-        # sort alphabetically
-        output_list.sort()
-
-        return output_list
-
-    def analyse_config_files(self):
-        """
-        call methods to process files
-        :return: config_vis: list containing absolute paths of VIs within SECI config file
-        :return: comp_vis:   list containing absolute paths of VIs within SECI sub-config file
-        """
-
-        config_vis = self._remove_duplicates(self._parse_vis_from_files(self.config_filenames))
-        comp_vis = self._remove_duplicates(self._parse_vis_from_files(self.comp_filenames))
-
-        return config_vis, comp_vis
diff --git a/SECI_Config_Analyser/SECI_Config_Analyser.py b/SECI_Config_Analyser/SECI_Config_Analyser.py
deleted file mode 100644
index 48b94ce6..00000000
--- a/SECI_Config_Analyser/SECI_Config_Analyser.py
+++ /dev/null
@@ -1,73 +0,0 @@
-"""
-Script to analyse SECI configurations and components and output results to file
-"""
-
-import argparse
-from os import system
-
-from Directory_Operations import ReadConfigFiles
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Analyse the SECI configuration files of specified instrument and output results to file"
-    )
-
-    parser.add_argument(
-        "--instrument", "-i", type=str, default=None, help="instrument to be analysed"
-    )
-
-    parser.add_argument(
-        "--output_file", "-o", type=str, default=None, help="file to write the results to"
-    )
-
-    parser.add_argument(
-        "--adminaccount",
-        "-a",
-        type=str,
-        default=None,
-        help=r"admin account name (without host i.e. NOT \\NDXxxx\xxx, just xxx",
-    )
-
-    parser.add_argument(
-        "--adminpassword", "-p", type=str, default=None, help="admin account password"
-    )
-
-    args = parser.parse_args()
-
-    if args.instrument is None:
-        parser.print_help()
-
-    if args.output_file is None:
-        args.output_file = f"{args.instrument.upper()}_-_VIs_from_SECI_configs.txt"
-
-    # open reference to appropriate network drive with supplied credentials
-
-    print("Connecting to remote directory...")
-    system(
-        f"net use \\\\ndx{args.instrument}\\c$ /user:ndx{args.instrument}\\{args.adminaccount} {args.adminpassword}"
-    )
-
-    # create instance of 'ReadConfigFiles' as 'filelist' and supply directory to be read
-
-    print("Reading configuration files...")
-    filelist = ReadConfigFiles(
-        f"//ndx{args.instrument}/c$/Program Files (x86)/STFC ISIS Facility/SECI/Configurations/"
-    )
-
-    print("Analysing files...")
-    xml_data = filelist.analyse_config_files()
-
-    # delete reference to network drive
-
-    print("Removing network connection...")
-    system(f"net use \\\\ndx{args.instrument}\\c$ /delete")
-
-    # concatenate each element in list with newline character, then print whole string
-
-    print("Writing output file...")
-    with open(args.output_file, "w") as outputfile:
-        outputfile.write(f"SECI configuration analysis for {args.instrument.upper()}:\n\n")
-
-        for item in xml_data:
-            outputfile.write("\n".join(x for x in item))
-            outputfile.write(f"\nNumber of VIs in configuration/component: {str(len(item))}\n\n")
diff --git a/SECI_Config_Analyser/__init__.py b/SECI_Config_Analyser/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/galil_ini_parser/change_home_conventions.py b/galil_ini_parser/change_home_conventions.py
deleted file mode 100644
index 1a081658..00000000
--- a/galil_ini_parser/change_home_conventions.py
+++ /dev/null
@@ -1,99 +0,0 @@
-import argparse
-import pathlib
-from distutils.util import strtobool
-
-from galil_ini_parser import (
-    apply_home_shift,
-    common_setting_names,
-    extract_galil_settings_from_file,
-)
-
-parser = argparse.ArgumentParser()
-parser.add_argument("-i", "--input_file", help="Input file location", action="store", required=True)
-parser.add_argument(
-    "-o", "--output_file", help="Output file location", action="store", required=True
-)
-parser.add_argument(
-    "--reference_file",
-    help="Location of a file to compare output of this script to",
-    action="store",
-)
-args = parser.parse_args()
-
-input_file = pathlib.Path(args.input_file)
-output_file = pathlib.Path(args.output_file)
-
-if input_file == output_file:
-    raise RuntimeError("Output file cannot overwrite input file")
-
-with open(input_file) as f:
-    file_contents = f.readlines()
-
-galil_crates = extract_galil_settings_from_file(file_contents)
-
-output_contents = []
-warnings = []
-
-for galil in galil_crates.values():
-    for axis in galil.axes.values():
-        axis_negated = axis.get_value(common_setting_names["NEGATED"], strtobool)
-
-        old_offset = axis.get_value(common_setting_names["OFFSET"], float, default_value=0.0)
-        old_user_offset = axis.get_value(
-            common_setting_names["USER_OFFSET"], float, default_value=0.0
-        )
-        old_homeval = axis.get_value(common_setting_names["HOMEVAL"], float)
-
-        old_hlim = axis.get_value(common_setting_names["HLIM"], float)
-        old_llim = axis.get_value(common_setting_names["LLIM"], float)
-
-        if axis_negated:
-            warnings.append(
-                "Warning! Script untested on axes with NEGATED set to True. Manually verify distances from home position to limits are unchanged for axis {}/{}.".format(
-                    galil.crate_index, axis.axis_index
-                )
-            )
-
-        new_settings = apply_home_shift(
-            old_homeval, old_offset, old_user_offset, old_hlim, old_llim
-        )
-        for setting, value in new_settings.items():
-            if value is not None:
-                print(
-                    "Setting Galil {galil} Axis {axis} {setting} to {value}".format(
-                        galil=galil.crate_index,
-                        axis=axis.axis_index,
-                        setting=setting,
-                        value="{:8.6f}".format(value),
-                    )
-                )
-                axis.set_value(setting, "{:8.6f}".format(value))
-
-    output_contents.extend(galil.get_save_strings())
-
-with open(output_file, "w") as f:
-    f.write("\n".join(output_contents))
-    f.write("\n")
-
-if args.reference_file is not None:
-    # Compare the new galil settings to a reference file (hand-migrated)
-    reference_file = pathlib.Path(args.reference_file)
-    with open(reference_file, "r") as f:
-        reference_contents = f.readlines()
-    reference_galils = extract_galil_settings_from_file(reference_contents)
-
-    galils_with_new_settings = extract_galil_settings_from_file(output_contents)
-    for galil in galils_with_new_settings.values():
-        reference_galil = reference_galils[galil.crate_index]
-        for axis in galil.axes.values():
-            print("Galil {} Axis {}".format(galil.crate_index, axis.axis_index))
-            reference_axis = reference_galil.axes[axis.axis_index]
-            for setting in axis.settings.keys():
-                # Loop though all the settings, see where the differences are
-                reference = reference_axis.get_value(setting, str)
-                script = axis.get_value(setting, str)
-                if reference != script:
-                    print("{} New value: {} Reference value: {}".format(setting, script, reference))
-
-for warning in warnings:
-    print(warning)
diff --git a/galil_ini_parser/galil_ini_parser.py b/galil_ini_parser/galil_ini_parser.py
deleted file mode 100644
index 91775aec..00000000
--- a/galil_ini_parser/galil_ini_parser.py
+++ /dev/null
@@ -1,209 +0,0 @@
-import re
-from collections import OrderedDict
-from typing import Any, Dict, List, Optional
-
-AXIS_NUMBER_REGEX = r"(?<=Axis )\S+"
-
-common_setting_names = {
-    "HOMEVAL": "Home Position",
-    "USER_OFFSET": "User Offset",
-    "OFFSET": "Offset",
-    "LLIM": "Soft Min",
-    "HLIM": "Soft Max",
-    "NEGATED": "Negate Motor Direction",
-    "ENCODER_RES": "Encoder Steps Per Unit",
-    "MOTOR_RES": "Motor Steps Per Unit",
-}
-
-
-def apply_home_shift(
-    old_homeval: float, old_offset: float, old_user_offset: float, old_hlim: float, old_llim: float
-) -> Dict[str, Optional[str]]:
-    """
-    Combines both the user and axis offsets into one (the new axis offset).
-    Shifts the axis limits by the difference between the old and new home position
-
-    Args:
-        old_homeval: The current Home Postion in the settings file
-        old_hlim: The current soft max limit in the settings file.
-        old_llim: The current soft min limit in the settings file.
-        old_user_offset: The current user offset in the settings file
-        old_offset: The current axis offset in the settings file
-    Returns:
-        new_settings: Dictionary containing the string representation of the updated values.
-    """
-
-    old_combined_offset = old_offset + old_user_offset
-
-    # Set offset = homeval, so home position written to device is (homeval - offset) = 0
-    new_offset = old_homeval
-    new_user_offset = 0.0
-
-    # Distance to shift the limits by to maintain distance from limits to home position
-    difference_in_schemes = old_combined_offset - new_offset
-
-    # Infinite limits do not get changed (set to None so can be ignored)
-    if abs(old_hlim) != float("inf"):
-        new_hlim = old_hlim + difference_in_schemes
-    else:
-        new_hlim = None
-
-    if abs(old_llim) != float("inf"):
-        new_llim = old_llim + difference_in_schemes
-    else:
-        new_llim = None
-
-    new_settings = {
-        common_setting_names["OFFSET"]: new_offset,
-        common_setting_names["HLIM"]: new_hlim,
-        common_setting_names["LLIM"]: new_llim,
-        common_setting_names["USER_OFFSET"]: new_user_offset,
-    }
-    return new_settings
-
-
-class Galil:
-    def __init__(self, crate_index: int):
-        self.crate_index = crate_index
-        self.settings = OrderedDict()
-        self.axes = {}
-
-    def parse_line(self, line) -> None:
-        """
-        Adds a line of the galil ini file to this class
-        """
-        axis_index = self.get_axis_letter_from_line(line)
-        if axis_index is None:
-            # Not referring to an axis so is a global setting for crate
-            setting, value = line.split("=")
-            setting = setting.strip()
-            value = value.strip()
-            self.settings[setting] = value
-        elif axis_index in self.axes.keys():
-            axis = self.axes[axis_index]
-            axis.add_setting_from_ini_line(line)
-        else:
-            new_axis = Axis(axis_index)
-            new_axis.add_setting_from_ini_line(line)
-
-            self.axes[axis_index] = new_axis
-
-    def get_axis_letter_from_line(self, ini_line: str) -> str:
-        """
-        Extracts the letter of the axis referred to in a line of the ini file
-        """
-        matches = re.search(AXIS_NUMBER_REGEX, ini_line)
-        if matches is not None:
-            return matches.group(0)
-        else:
-            return None
-
-    def get_save_strings(self) -> List[str]:
-        """
-        Returns a strings can containing all settings for all axes on this crate
-        """
-        settings = ["[{}]".format(self.crate_index)]
-        for crate_setting, setting_value in self.settings.items():
-            settings.append(
-                "{setting} = {value}".format(setting=crate_setting, value=setting_value)
-            )
-        for axis_letter in self.axes.keys():
-            axis = self.axes[axis_letter]
-            for setting, value in axis.settings.items():
-                settings.append(
-                    "Axis {axis_letter} {setting} = {value}".format(
-                        axis_letter=axis_letter, setting=setting, value=value
-                    )
-                )
-        return settings
-
-
-class Axis:
-    def __init__(self, axis_index: str):
-        self.settings = {}
-        self.axis_index = axis_index
-        self.axis_line_prefix = "Axis {}".format(axis_index)
-
-    def scrub_axis_prefix(self, ini_line: str) -> str:
-        """
-        Removes the axis identifier from a line in the ini file. Returns a string which defines its setting
-
-        Args:
-            ini_line: Line from the ini file
-
-        Returns:
-            String containing "setting_name = value" pair
-        """
-        return ini_line[len(self.axis_line_prefix) :].strip()
-
-    def add_setting_from_ini_line(self, ini_line: str):
-        """
-        Imports a new setting from a line in the galil ini file
-        """
-        setting = self.scrub_axis_prefix(ini_line)
-        split_line = setting.split("=")
-        key = split_line[0].strip()
-
-        # This captures settings which contain an equals sign in them
-        value = "=".join(split_line[1:]).strip()
-        self.set_value(key, value, make_new=True)
-
-    def get_value(self, setting: str, caster: Any, default_value: Any = None) -> Optional[Any]:
-        """
-        Attempts to get the setting for this axis and cast it to type 'type'.
-
-        Args:
-            setting: The name of the setting to get
-            caster: Function which casts string to expected type of setting
-            default_value: The value to be returned if the setting was not found
-
-        Returns:
-            value: The setting, cast using supplied caster. Equals default_value if setting does not exist on this axis
-        """
-
-        try:
-            value = caster(self.settings[setting])
-        except KeyError:
-            value = default_value
-
-        return value
-
-    def set_value(self, setting: str, value: str, make_new: bool = False) -> None:
-        """
-        Sets the setting with the specified value
-
-        Args:
-            setting: The setting to set
-            value: A string representation of the value to set
-            make_new: If True, create a new setting even if it does not currently exist
-        """
-        if setting in self.settings.keys() or make_new:
-            self.settings[setting] = value
-
-
-def extract_galil_settings_from_file(file: List[str]) -> Dict[str, Galil]:
-    """
-    Given a file contatining galil settings, extract the settings as Galil objects
-
-    Args:
-        file: List of lines from the settings files
-
-    Returns:
-        galil_crates: Dictionary containing the Galil settings held in file
-    """
-    galil_crates = {}
-    for line in file:
-        # New galil crate if line starts [Gx]
-        if line.startswith("[G"):
-            crate_index = line.strip().strip("[]")
-            galil_crates[crate_index] = Galil(crate_index)
-        elif "=" in line:
-            galil_crates[crate_index].parse_line(line)
-        else:
-            print(
-                "Line did not contain valid setting or galil identifier information, ignoring: {}".format(
-                    line
-                )
-            )
-
-    return galil_crates
diff --git a/galil_ini_parser/parser_tests.py b/galil_ini_parser/parser_tests.py
deleted file mode 100644
index 1bcf7852..00000000
--- a/galil_ini_parser/parser_tests.py
+++ /dev/null
@@ -1,291 +0,0 @@
-import unittest
-from typing import Dict
-
-from mock import patch
-from parameterized import parameterized
-
-from galil_ini_parser import (
-    Axis,
-    Galil,
-    apply_home_shift,
-    common_setting_names,
-    extract_galil_settings_from_file,
-)
-
-GALIL_CRATE_INDEX = "G1"
-AXIS_INDEX = "A"
-
-SETTING_STRING_WITHOUT_AXIS = "{setting} = {value}"
-SETTING_STRING_WITH_AXIS = "Axis {axis_index} {setting} = {value}"
-
-
-def POPULATE_AXIS(
-    offset: float, user_offset: float, homeval: float, hlim: float, llim: float
-) -> Dict[str, float]:
-    """
-    Creates a dictionary with key/value pairs corresponding to axis parameters to be changed
-    """
-    axis = {
-        common_setting_names["OFFSET"]: offset,
-        common_setting_names["USER_OFFSET"]: user_offset,
-        common_setting_names["HOMEVAL"]: homeval,
-        common_setting_names["HLIM"]: hlim,
-        common_setting_names["LLIM"]: llim,
-    }
-
-    return axis
-
-
-TEST_AXIS_CASES = [
-    (
-        "Nonzero homeval nonzero offset",
-        POPULATE_AXIS(7.0, 3.0, 20.0, 50.0, 10.0),
-        POPULATE_AXIS(20.0, 0.0, 20.0, 40.0, 0.0),
-    ),
-    (
-        "Zero homeval nonzero offsets",
-        POPULATE_AXIS(10.0, 5.0, 0.0, 50.0, -10.0),
-        POPULATE_AXIS(0.0, 0.0, 0.0, 65.0, 5.0),
-    ),
-    (
-        "Nonzero homeval zero offsets",
-        POPULATE_AXIS(0.0, 0.0, 1045.0, 1045.0, -10.0),
-        POPULATE_AXIS(1045.0, 0.0, 1045.0, 0.0, -1055.0),
-    ),
-    (
-        "Infinite limits",
-        POPULATE_AXIS(7.0, 3.0, 20.0, float("inf"), -1.0 * float("inf")),
-        POPULATE_AXIS(20.0, 0.0, 20.0, None, None),
-    ),
-]
-
-FLOAT_SETTING = {"Setting": 1.2}
-
-
-class GalilTests(unittest.TestCase):
-    """
-    Tests for the galil crate class
-    """
-
-    def setUp(self):
-        self.galil = Galil(GALIL_CRATE_INDEX)
-
-    def test_GIVEN_new_galil_object_THEN_settings_dictionary_is_empty(self):
-        self.assertEqual(len(self.galil.settings.keys()), 0)
-
-    def test_GIVEN_new_galil_object_THEN_axis_list_is_empty(self):
-        self.assertEqual(len(self.galil.axes.keys()), 0)
-
-    def test_GIVEN_setting_line_with_no_axis_label_THEN_line_gets_added_to_crate_settings(self):
-        new_setting = "Setting"
-        setting_value = "value"
-        self.galil.parse_line(
-            SETTING_STRING_WITHOUT_AXIS.format(setting=new_setting, value=setting_value)
-        )
-
-        self.assertEqual(self.galil.settings[new_setting], setting_value)
-
-    def test_GIVEN_setting_line_with_axis_label_WHEN_that_axis_does_not_exist_THEN_axis_label_extracted_correctly(
-        self,
-    ):
-        axis_index = "A"
-        new_setting = "Setting"
-        setting_value = "value"
-        extracted_axis_letter = self.galil.get_axis_letter_from_line(
-            SETTING_STRING_WITH_AXIS.format(
-                axis_index=axis_index, setting=new_setting, value=setting_value
-            )
-        )
-
-        self.assertEqual(axis_index, extracted_axis_letter)
-
-    def test_GIVEN_setting_line_with_axis_label_WHEN_that_axis_does_not_exist_THEN_new_axis_is_made(
-        self,
-    ):
-        axis_index = "A"
-        new_setting = "Setting"
-        setting_value = "value"
-
-        self.assertNotIn(axis_index, self.galil.axes.keys())
-
-        self.galil.parse_line(
-            SETTING_STRING_WITH_AXIS.format(
-                axis_index=axis_index, setting=new_setting, value=setting_value
-            )
-        )
-
-        self.assertIn(axis_index, self.galil.axes.keys())
-
-    def test_GIVEN_setting_line_with_axis_label_WHEN_that_axis_does_exist_THEN_setting_gets_added_to_axis(
-        self,
-    ):
-        axis_index = "A"
-        new_setting = "Setting"
-        setting_value = "value"
-        self.galil.parse_line(
-            SETTING_STRING_WITH_AXIS.format(
-                axis_index=axis_index, setting=new_setting, value=setting_value
-            )
-        )
-
-        self.assertEqual(self.galil.axes[axis_index].settings[new_setting], setting_value)
-
-    def test_GIVEN_settings_on_crate_WHEN_save_string_requested_THEN_first_line_is_crate_identifier(
-        self,
-    ):
-        galil_save_string = self.galil.get_save_strings()
-        self.assertEqual(galil_save_string[0], "[{}]".format(GALIL_CRATE_INDEX))
-
-    def test_GIVEN_settings_on_crate_and_axes_WHEN_save_string_requested_THEN_settings_from_crate_and_axes_are_present(
-        self,
-    ):
-        axis_index = "A"
-        axis_setting = "Offset"
-        axis_setting_value = "12.3"
-
-        crate_setting = "unit"
-        crate_setting_value = "mm"
-
-        axis = Axis(axis_index)
-        axis.settings[axis_setting] = axis_setting_value
-
-        self.galil.axes[axis_index] = axis
-        self.galil.settings[crate_setting] = crate_setting_value
-
-        save_string = self.galil.get_save_strings()
-
-        self.assertIn(
-            SETTING_STRING_WITHOUT_AXIS.format(setting=crate_setting, value=crate_setting_value),
-            save_string,
-        )
-        self.assertIn(
-            SETTING_STRING_WITH_AXIS.format(
-                axis_index=axis_index, setting=axis_setting, value=axis_setting_value
-            ),
-            save_string,
-        )
-
-
-class AxisTests(unittest.TestCase):
-    """
-    Tests for the galil axis class
-    """
-
-    def setUp(self):
-        self.axis = Axis("A")
-
-    def test_GIVEN_settings_line_WHEN_line_contains_axis_prefix_THEN_axis_prefix_removed_from_line(
-        self,
-    ):
-        axis_index = "A"
-        new_setting = "Setting"
-        setting_value = "value"
-        parsed_settings_line = self.axis.scrub_axis_prefix(
-            SETTING_STRING_WITH_AXIS.format(
-                axis_index=axis_index, setting=new_setting, value=setting_value
-            )
-        )
-
-        self.assertEqual(
-            parsed_settings_line,
-            SETTING_STRING_WITHOUT_AXIS.format(setting=new_setting, value=setting_value),
-        )
-
-    def test_GIVEN_settings_line_THEN_setting_correctly_added_to_axis(self):
-        axis_index = "A"
-        new_setting = "Setting"
-        setting_value = "value"
-
-        self.axis.add_setting_from_ini_line(
-            SETTING_STRING_WITH_AXIS.format(
-                axis_index=axis_index, setting=new_setting, value=setting_value
-            )
-        )
-
-        self.assertEqual(self.axis.settings[new_setting], setting_value)
-
-    @parameterized.expand(
-        [
-            ("pos_float", 12.3, float),
-            ("neg_float", -12.3, float),
-            ("pos_inf", float("inf"), float),
-            ("neg_inf", -float("inf"), float),
-            ("pos_int", 123, int),
-            ("neg_int", -123, int),
-            ("string", "string_value", str),
-        ]
-    )
-    def test_GIVEN_set_value_exists_WHEN_value_retrieved_THEN_correct_value_returned(
-        self, _, setting_value, caster
-    ):
-        new_setting = "Setting"
-
-        self.axis.settings[new_setting] = setting_value
-
-        self.assertEqual(self.axis.get_value(new_setting, caster), setting_value)
-
-    def test_GIVEN_set_value_does_not_exist_WHEN_value_retieved_THEN_None_is_returned(self):
-        setting_does_not_exist = "Setting"
-
-        self.assertNotIn(setting_does_not_exist, self.axis.settings.keys())
-
-        self.assertIsNone(self.axis.get_value(setting_does_not_exist, str))
-
-    def test_GIVEN_new_setting_is_set_WHEN_make_new_not_true_THEN_no_setting_is_added(self):
-        setting_to_add = "Setting"
-        sample_value = "value"
-
-        self.assertNotIn(setting_to_add, self.axis.settings.keys())
-
-        self.axis.set_value(setting_to_add, sample_value, make_new=False)
-
-        self.assertNotIn(setting_to_add, self.axis.settings.keys())
-
-    def test_GIVEN_new_setting_is_set_WHEN_make_new_is_true_THEN_new_setting_is_added(self):
-        setting_to_add = "Setting"
-        sample_value = "value"
-
-        self.assertNotIn(setting_to_add, self.axis.settings.keys())
-
-        self.axis.set_value(setting_to_add, sample_value, make_new=True)
-
-        self.assertIn(setting_to_add, self.axis.settings.keys())
-
-
-class IniParserTests(unittest.TestCase):
-    """
-    Tests for the code which changes SECI offsets to IBEX offsets
-    """
-
-    @parameterized.expand(TEST_AXIS_CASES)
-    def test_GIVEN_test_case_axis_WHEN_new_limits_calculated_THEN_correct_values_returned(
-        self, _, axis, corrected_axis
-    ):
-        new_axis_values = apply_home_shift(
-            axis[common_setting_names["HOMEVAL"]],
-            axis[common_setting_names["OFFSET"]],
-            axis[common_setting_names["USER_OFFSET"]],
-            axis[common_setting_names["HLIM"]],
-            axis[common_setting_names["LLIM"]],
-        )
-
-        for key in new_axis_values.keys():
-            self.assertEqual(corrected_axis[key], new_axis_values[key])
-
-    def test_GIVEN_sample_ini_file_WHEN_parsed_THEN_new_galil_objects_created(self):
-        galil_1_name = "G0"
-        galil_2_name = "G1"
-
-        split_ini_file = [
-            "[{}]".format(galil_1_name),
-            "setting = value",
-            "Axis A setting = value",
-            "[{}]".format(galil_2_name),
-            "setting = value",
-            "Axis B setting = value",
-        ]
-
-        with patch("galil_ini_parser.Galil") as mock_galil:
-            extract_galil_settings_from_file(split_ini_file)
-            mock_galil.assert_any_call(galil_1_name)
-            mock_galil.assert_any_call(galil_2_name)
diff --git a/ibex_log_parser/parse.py b/ibex_log_parser/parse.py
deleted file mode 100644
index c4af640d..00000000
--- a/ibex_log_parser/parse.py
+++ /dev/null
@@ -1,146 +0,0 @@
-import os
-import re
-from datetime import datetime
-
-# Filter log lines containing
-TICKET = "Ticket2162:"
-
-# Severe log line
-SEVERE = "SEVERE:"
-SEVERE_LINE_START = f"{SEVERE} {TICKET}"
-
-
-class LogLine:
-    def __init__(self, time, pv, message):
-        self.time = time
-        self.message = message.strip()
-        self.pv = pv.strip()
-
-    def __repr__(self):
-        date_time_string = datetime.strftime(self.time, "%H:%M:%S.%f")
-        return f"{date_time_string}: {self.message}"
-
-
-def parse_severe_line(previous_line, line):
-    # Mar 22, 2017 12:04:24 PM org.epics.pvmanager.SourceDesiredRateDecoupler sendDesiredRateEvent
-    pattern = r"(.* (?:AM|PM)).*"
-    match = re.match(pattern, previous_line)
-    (date_string,) = match.groups()
-    date_time = datetime.strptime(date_string, "%b %d, %Y %I:%M:%S %p")
-    # SEVERE: Ticket2162: TE:NDW1407:CS:IOC:INSTETC_01:DEVIOS:TOD - PVDirector event connected true
-
-    match = re.match(SEVERE_LINE_START + "(.*) - (.*)", line)
-    if match is None:
-        exit(f"ERROR: servere message not match {line}")
-
-    pv, message = match.groups()
-
-    return LogLine(date_time, pv, message)
-
-
-def parse_normal_line(line):
-    # *2017-03-22 12:04:24.556 [PVMgr Worker 3] INFO  org.epics.pvmanager.PVReaderImpl - Ticket2162: TE:NDW1407:CS:BLOCKSERVER:PVS:ACTIVE - PVReaderImpl valueChange
-
-    pattern = r"\*(.*) \[.*" + TICKET + r"(.*) - (.*)"
-    match = re.match(pattern, line)
-    if match is None:
-        print(f"Can not understand {line}")
-        return None
-
-    time_string, pv, message = match.groups()
-
-    dateTime = datetime.strptime(time_string, r"%Y-%m-%d %H:%M:%S.%f")
-
-    return LogLine(dateTime, pv, message)
-
-
-def check_time(time, start_time_hour, start_time_mins, start_time_secs):
-    if time.hour != start_time_hour:
-        return time.hour > start_time_hour
-
-    if time.minute != start_time_mins:
-        return time.minute > start_time_mins
-
-    return time.second >= start_time_secs
-
-
-def print_and_log(log_file, message):
-    print(message)
-    log_file.write(f"\n{message}")
-
-
-def read_log_files(log_file, day, month):
-    filedir = r"C:\Instrument\runtime-ibex.product\logs" + "\\" + month
-    filepaths = [
-        os.path.join(filedir, filepath)
-        for filepath in os.listdir(filedir)
-        if month + "-" + day in filepath
-    ]
-    filepaths.append(r"C:\Instrument\runtime-ibex.product\logs\isis.log")
-
-    pvChanges = []
-    previous_line = ""
-    for filepath in filepaths:
-        print_and_log(log_file, f"Reading: {filepath}")
-        with open(filepath) as file:
-            for line in file:
-                if TICKET in line:
-                    if line.startswith(SEVERE):
-                        pvChange = parse_severe_line(previous_line, line)
-                    else:
-                        pvChange = parse_normal_line(line)
-
-                    if pvChange is not None:
-                        pvChanges.append(pvChange)
-                previous_line = line
-
-    return sorted(pvChanges, key=lambda student: student.time)
-
-
-def log_changed_pvs(log_file, pvChanges):
-    print_and_log(log_file, "PVS:")
-    for pv_name in set([x.pv for x in pvChanges]):
-        print_and_log(log_file, f"    {pv_name}")
-    print_and_log(log_file, "\n\n")
-
-
-def log_pv_timeline(log_file, pvChanges, wanted_pvs):
-    print_and_log(log_file, f"Timeline for {wanted_pvs}")
-    for pvChange in pvChanges:
-        if pvChange.pv in wanted_pvs:
-            print_and_log(log_file, "{0:>20} = {1}".format(pvChange.pv.strip()[-20:], pvChange))
-
-
-def log_events_after_time(log_file, pvChanges, start_time_hour, start_time_mins, start_time_secs):
-    print_and_log(log_file, f"Timeline after {start_time_hour}:{start_time_mins}:{start_time_secs}")
-    for pvChange in pvChanges:
-        if check_time(pvChange.time, start_time_hour, start_time_mins, start_time_secs):
-            print_and_log(log_file, "{0:>20} = {1}".format(pvChange.pv.strip()[-20:], pvChange))
-
-
-def log_flow_control(log_file, pvChanges):
-    print_and_log(log_file, "Flow control")
-    for pvChange in pvChanges:
-        if str("flow control") in str(pvChange.message).lower():
-            print_and_log(log_file, pvChange)
-
-
-if __name__ == "__main__":
-    month = "2017-04"
-    day = "06"
-
-    start_time_hour = 16
-    start_time_mins = 24
-    start_time_secs = 00
-
-    with open(r"c:\tmp\ibexLog{0}-{1}.txt".format(month, day), mode="w") as log_file:
-        pvChanges = read_log_files(log_file, day, month)
-
-        log_changed_pvs(log_file, pvChanges)
-
-        log_pv_timeline(log_file, pvChanges, ["TE:NDW1407:CS:SB:TEMP1", "all"])
-        # log_pv_timeline(log_file, pvChanges, ["TE:NDW1407:SIMPLE:NUMBERED1", "unknown", "buffer"])
-
-        # log_events_after_time(log_file, pvChanges, start_time_hour, start_time_mins, start_time_secs)
-
-        # log_flow_control(log_file, pvChanges)
diff --git a/installation_and_upgrade/instrument_deploy.bat b/installation_and_upgrade/instrument_deploy.bat
index d2a3b41e..559cd691 100644
--- a/installation_and_upgrade/instrument_deploy.bat
+++ b/installation_and_upgrade/instrument_deploy.bat
@@ -1,3 +1,5 @@
+REM instrument_deploy.bat - used for upgrading IBEX on an instrument PC. 
+
 setlocal EnableDelayedExpansion
 
 REM check if console has Administrative privileges
diff --git a/installation_and_upgrade/instrument_install.bat b/installation_and_upgrade/instrument_install.bat
index adf6eb39..986b6e3e 100644
--- a/installation_and_upgrade/instrument_install.bat
+++ b/installation_and_upgrade/instrument_install.bat
@@ -1,3 +1,5 @@
+REM instrument_install.bat - used for installing IBEX for the first time on an instrument PC. 
+
 setlocal EnableDelayedExpansion
 
 REM check if console has Administrative privileges
diff --git a/installation_and_upgrade/instrument_update.bat b/installation_and_upgrade/instrument_update.bat
deleted file mode 100644
index e4af392a..00000000
--- a/installation_and_upgrade/instrument_update.bat
+++ /dev/null
@@ -1,20 +0,0 @@
-setlocal EnableDelayedExpansion
-call "%~dp0define_latest_genie_python.bat"
-if %errorlevel% neq 0 goto ERROR
-set "SOURCE=\\isis.cclrc.ac.uk\inst$\Kits$\CompGroup\ICP\Releases\4.0.0"
-
-set "STOP_IBEX=C:\Instrument\Apps\EPICS\stop_ibex_server"
-set "START_IBEX=C:\Instrument\Apps\EPICS\start_ibex_server"
-IF EXIST "C:\Instrument\Apps\EPICS" (start /wait cmd /c "%STOP_IBEX%")
-
-call "%LATEST_PYTHON%" "%~dp0IBEX_upgrade.py" --release_dir "%SOURCE%" --confirm_step instrument_update
-if %errorlevel% neq 0 goto ERROR
-start /wait cmd /c "%START_IBEX%"
-
-call "%~dp0remove_genie_python.bat" %LATEST_PYTHON_DIR%
-exit /b 0
-
-:ERROR
-set errcode = %ERRORLEVEL%
-call "%~dp0remove_genie_python.bat" %LATEST_PYTHON_DIR%
-EXIT /b !errcode!
diff --git a/repo_tool/repository_manipulator/RepositoryManipulator.py b/repo_tool/repository_manipulator/RepositoryManipulator.py
deleted file mode 100644
index 7367fa15..00000000
--- a/repo_tool/repository_manipulator/RepositoryManipulator.py
+++ /dev/null
@@ -1,282 +0,0 @@
-"""
-This file is part of the ISIS IBEX application.
-Copyright (C) 2012-2016 Science & Technology Facilities Council.
-All rights reserved.
-
-This program is distributed in the hope that it will be useful.
-This program and the accompanying materials are made available under the
-terms of the Eclipse Public License v1.0 which accompanies this distribution.
-EXCEPT AS EXPRESSLY SET FORTH IN THE ECLIPSE PUBLIC LICENSE V1.0, THE PROGRAM
-AND ACCOMPANYING MATERIALS ARE PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES
-OR CONDITIONS OF ANY KIND.  See the Eclipse Public License v1.0 for more details.
-"""
-
-import re
-from datetime import datetime, timedelta
-
-import pytz as pytz
-from github3 import GitHubError, login
-
-# template for the sprint milestones title
-SPRINT_MILESTONE_REGEX = "SPRINT_(\d+)_(\d+)_(\d+)"
-SPRINT_MILESTONE_TEMPLATE = "SPRINT_{year:04d}_{month:02d}_{day:02d}"
-
-
-class UserError(Exception):
-    """
-    Exception with a message that can be shown to the user
-    """
-
-    def __init__(self, detail):
-        super(UserError, self).__init__()
-        self.detail = detail
-
-    def __str__(self):
-        return self.detail
-
-
-class RepositoryManipulator:
-    """
-    GitHub Repository Manipulator class
-
-    Provides functions that can manipulate a set of repositories in GitHub
-    Uses github3.py: https://github.com/sigmavirus24/github3.py
-    """
-
-    def __init__(self, username, token, login_method=login, dry_run=False):
-        """
-        Constructor
-        :param username: username
-        :param token: token for access to GitHub
-        :param login_method: method to login to GitHub and provide a GitHub manipulation object
-        :param dry_run: true if nothing should be added or deleted
-        :return:
-        """
-        self._repo_list = []
-        self.dry_run = dry_run
-        try:
-            self.github_api = login_method(username, token=token)
-        except GitHubError as ex:
-            raise UserError(f"Failed to log in. {str(ex)}")
-
-    @staticmethod
-    def get_checked_date(date_string):
-        """
-        Return a date dictionary from a text date
-        :param date_string: date string YYYY-MM-DD
-        :return: date dictionary
-        """
-        match = re.match("(\d{4})-(\d+)-(\d+)\s*", date_string)
-        if match is None:
-            raise UserError("Date must of format YYYY-MM-DD")
-        try:
-            return datetime(int(match.group(1)), int(match.group(2)), int(match.group(3)))
-        except (ValueError, TypeError):
-            raise UserError("Invalid date")
-
-    def add_all_repos_for_owner(self, owner_name="ISISComputingGroup"):
-        """
-        Add all the repositories for an owner to the list of repositories to manipulate;
-        assume owner is an organisation but default to user if organisation doesn't exist
-        :param owner_name: name of the owner; organisation/user
-        :return:
-        :raises UserError: when repository can not be found
-        """
-        try:
-            organisation = self.github_api.organization(owner_name)
-        except GitHubError as ex:
-            raise UserError(f"Failed to get owner as organisation. {str(ex)}")
-
-        try:
-            if organisation is None:
-                print(f"Owner {owner_name} not found as organisation, defaulting to user")
-                iter_repos = self.github_api.iter_user_repos(owner_name)
-            else:
-                iter_repos = organisation.iter_repos()
-            self._add_to_repositories_to_use(iter_repos)
-        except GitHubError as ex:
-            raise UserError(f"Failed to get owner's repositories. {str(ex)}")
-
-    def _add_to_repositories_to_use(self, iter_repos):
-        """
-        Add the repositories from the generator to the list and sort by name
-        :param iter_repos: generator for repositories
-        :return:
-        """
-        for repo in iter_repos:
-            self._repo_list.append(repo)
-        self._sort_repo_list()
-
-    def _sort_repo_list(self):
-        """
-        sort the repository list
-        :return: nothing
-        """
-        self._repo_list.sort(key=lambda x: x.name)
-
-    def use_repos_for_user(self, owner):
-        """
-        Add all repositories from the currently logged in user to the list of repositories to manipulate
-        :param owner: owner of the repos
-        :return:
-        """
-        try:
-            self._add_to_repositories_to_use(self.github_api.iter_user_repos(owner))
-        except GitHubError as ex:
-            raise UserError(f"Failed to get user repositories. {str(ex)}")
-
-    def add_repository_from(self, owner, names):
-        """
-        Add repositories to those to be manipulated
-        :param owner: owner of the repository
-        :param names: repository names
-        :return: nothing
-        """
-        try:
-            for name in names:
-                repo = self.github_api.repository(owner, name)
-                if repo is None:
-                    raise UserError(f"Repository {name} does not exist for {owner}")
-                self._repo_list.append(repo)
-                self._sort_repo_list()
-        except GitHubError as ex:
-            raise UserError(f"Failed to get named repositories. {str(ex)}")
-
-    def update_milestones(self, date_from, date_to, close_old_milestones):
-        """
-        Update milestones for all selected repositories
-        :param date_to: date that the milestone runs to
-        :param date_from: date that the milestone runs from
-        :param close_old_milestones: close old sprint milestones, if possible
-        :return:
-        """
-        print("Milestones")
-        print("")
-        if date_from is not None:
-            from_date = RepositoryManipulator.get_checked_date(date_from)
-            new_milestone_title = SPRINT_MILESTONE_TEMPLATE.format(
-                year=from_date.year, month=from_date.month, day=from_date.day
-            )
-            due_on_date = RepositoryManipulator.get_checked_date(date_to)
-            due_on = due_on_date.isoformat() + "Z"
-        else:
-            due_on = None
-            new_milestone_title = None
-
-        for repo in self._repo_list:
-            print(f"{repo.name}:")
-            if not repo.has_issues:
-                print("    no issues milestone not updates")
-            else:
-                self._update_milestones_on_rep(
-                    due_on, new_milestone_title, repo, close_old_milestones
-                )
-
-    def _update_milestones_on_rep(self, due_on, new_milestone_title, repo, close_old_milestones):
-        """
-        Create a new milestones for the repository if it does not exist already
-        :param due_on: date that the milestone is due on
-        :param new_milestone_title: title for the milestone
-        :param repo: repository to which it should be added
-        :return:
-        """
-        for milestone in repo.iter_milestones(state="open"):
-            if close_old_milestones:
-                self._close_milestone_if_old(milestone, repo.name)
-            if new_milestone_title is not None and milestone.title == new_milestone_title:
-                return
-
-        if new_milestone_title is None:
-            return
-
-        print(f"    milestone add {new_milestone_title}")
-        if not self.dry_run:
-            milestone = repo.create_milestone(
-                title=new_milestone_title, description="Milestone for sprint.", due_on=due_on
-            )
-            if milestone is None:
-                raise UserError("Unknown error creating milestone on repository.")
-
-    def _close_milestone_if_old(self, milestone, repo_name):
-        """
-        Close a milestone if it is old
-        :param milestone: milestone to close
-        :param repo_name: repository that the milestone is from
-        :return:
-        :raises UserError: if there is a problem closing the milestone
-        """
-
-        match = re.match(SPRINT_MILESTONE_REGEX, milestone.title)
-        if match is not None:
-            year = int(match.group(1))
-            month = int(match.group(2))
-            day = int(match.group(3))
-
-            milestone_date = datetime(year, month, day, tzinfo=pytz.utc)
-            close_issue = milestone.due_on is not None and milestone.due_on < datetime.now(pytz.utc)
-            if not close_issue and milestone_date + timedelta(days=31) < datetime.now(pytz.utc):
-                close_issue = True
-
-            if close_issue and milestone.open_issues > 0:
-                print(
-                    f"Milestone '{milestone.title}' is past its due date but has open issues so can not be closed"
-                )
-            elif close_issue:
-                print(f"Close {milestone.title}")
-                if not self.dry_run:
-                    if not milestone.update(state="closed"):
-                        raise UserError(
-                            f"Can not close milestone '{milestone.title}' in repo '{repo_name}'"
-                        )
-
-    def update_labels(self, ensure_labels):
-        """
-        Update labels on all repositories
-        :param ensure_labels: labels to ensure are on the repository; list of (colour, name) tuples
-        :type ensure_labels: list(tuple(string, string))
-        :return:
-        """
-        print("Labels")
-        print("")
-
-        for repo in self._repo_list:
-            print(f"{repo.name}:")
-            if not repo.has_issues:
-                print("    no issues labels not updates")
-            else:
-                self._update_labels_on_rep(ensure_labels, repo)
-
-    def _update_labels_on_rep(self, ensure_labels, repo):
-        """
-        Update the labels on a single repository
-        :param ensure_labels: labels to ensure are on the repository; list of (colour, name) tuples
-        :param repo: repository top update
-        :return:
-        """
-        current_labels = {}
-        for label in repo.iter_labels():
-            current_labels[label.name] = label
-
-        for label_name, label_colour in ensure_labels:
-            try:
-                if label_name not in current_labels.keys():
-                    print(f"    label add {label_name}")
-                    if not self.dry_run:
-                        label = repo.create_label(label_name, label_colour)
-                        if label is None:
-                            raise UserError("Unknown error creating label on repository.")
-                        current_labels[label_name] = label
-                elif current_labels[label_name].color != label_colour:
-                    current_labels[label_name].update(name=label_name, color=label_colour)
-            except GitHubError as ex:
-                if ex.code == 422:
-                    raise UserError("Validation filed on create/modify label")
-
-    def list_repos(self):
-        """
-        List the repositories
-        :return:
-        """
-        print("Repository set")
-        for repo in self._repo_list:
-            print(f"  {repo.name}:")
diff --git a/repo_tool/repository_manipulator/__init__.py b/repo_tool/repository_manipulator/__init__.py
deleted file mode 100644
index 2a697034..00000000
--- a/repo_tool/repository_manipulator/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-__all__ = ["repository_manipulator"]
diff --git a/repo_tool/scripts/change_repos.py b/repo_tool/scripts/change_repos.py
deleted file mode 100644
index 5009accf..00000000
--- a/repo_tool/scripts/change_repos.py
+++ /dev/null
@@ -1,266 +0,0 @@
-#!/usr/bin/env python
-
-"""
-This file is part of the ISIS IBEX application.
-Copyright (C) 2012-2016 Science & Technology Facilities Council.
-All rights reserved.
-
-This program is distributed in the hope that it will be useful.
-This program and the accompanying materials are made available under the
-terms of the Eclipse Public License v1.0 which accompanies this distribution.
-EXCEPT AS EXPRESSLY SET FORTH IN THE ECLIPSE PUBLIC LICENSE V1.0, THE PROGRAM
-AND ACCOMPANYING MATERIALS ARE PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES
-OR CONDITIONS OF ANY KIND.  See the Eclipse Public License v1.0 for more details.
-"""
-
-import argparse
-import sys
-from getpass import getpass
-
-from repo_tool.repository_manipulator.RepositoryManipulator import RepositoryManipulator, UserError
-
-
-def main(settings, token):
-    """
-    Main function
-    :param settings: settings
-    :param token: git hub token
-    :return: error code
-    """
-    try:
-        isis_repo_access = RepositoryManipulator(settings.username, token, dry_run=settings.dry_run)
-
-        if settings.repo is not None:
-            isis_repo_access.add_repository_from(settings.owner, [settings.repo])
-        elif settings.repo_file is not None:
-            repository_names = _get_repository_name_from_file(settings.repo_file)
-            isis_repo_access.add_repository_from(settings.owner, repository_names)
-        else:
-            isis_repo_access.add_all_repos_for_owner(settings.owner)
-
-        # milestones
-        action = False
-        if settings.date_from is not None or settings.ms_close:
-            action = True
-            isis_repo_access.update_milestones(
-                settings.date_from, settings.date_to, settings.ms_close
-            )
-
-        # labels
-        labels_list = []
-        if settings.ensure_label is not None:
-            action = True
-            labels_list.append((settings.ensure_label, settings.ensure_label_colour))
-        if settings.ensure_label_file is not None:
-            labels_list.extend(_get_labels_from(settings.ensure_label_file))
-            action = True
-        if len(labels_list) > 0:
-            isis_repo_access.update_labels(labels_list)
-
-        # other
-        if not action:
-            isis_repo_access.list_repos()
-
-        return 0
-    except UserError as ex:
-        print(f"Failed to update repositories: {ex}")
-        return -1
-
-
-def _get_repository_name_from_file(filename):
-    """
-    Get the repository names from a file
-    :param filename: filename
-    :return: unique items in file
-    """
-    try:
-        repository_names = set()
-        with open(filename) as file:
-            for line in file:
-                repo_name = line.strip()
-                if repo_name != "" and not repo_name.startswith("#"):
-                    repository_names.add(repo_name)
-            if len(repository_names) == 0:
-                raise UserError("File has no entries in")
-    except IOError as ex:
-        raise UserError(f"Can not open repository list file, {ex}")
-    return repository_names
-
-
-def _get_labels_from(filename):
-    """
-    Get the labels from a file
-    :param filename: file to get names from
-    :return: label names and colours
-    """
-    try:
-        has_comment = False
-        labels = []
-        with open(filename) as file:
-            for line in file:
-                label_line = line.strip()
-                is_comment = label_line.startswith("#")
-                has_comment = has_comment or is_comment
-                if label_line != "" and not is_comment:
-                    split_line = line.split(",", 1)
-                    if len(split_line) != 2:
-                        raise UserError(
-                            f"Label lines must be <colour code>, <label name>. Line: {label_line}"
-                        )
-                    label_colour = split_line[0].strip()
-                    label_name = split_line[1].strip()
-                    if label_name == "":
-                        raise UserError(f"Label name must not be empty. Line: {label_line}")
-                    if label_colour == "":
-                        raise UserError(f"Label colour must not be empty. Line: {label_line}")
-
-                    labels.append((label_name, label_colour))
-        if len(labels) == 0:
-            if has_comment:
-                raise UserError(
-                    "Labels file has no entries in. "
-                    "NB Lines with a # are comment, colours should not start with a hash"
-                )
-            else:
-                raise UserError("Labels file has no entries in")
-    except IOError as ex:
-        raise UserError(f"Can not open labels file, {ex}")
-    return labels
-
-
-def _parse_command_line():
-    """
-    Parse the command line
-    :return: settings for the run
-    """
-    parser = argparse.ArgumentParser(
-        description="Manipulate a set of repositories, you can add milestones, close milestones, add labels. "
-        "E.g. -u John-Holt-Tessella -o John-Holt-Tessella --ms-from 2010-04-02 --ms-to 2011-05-02 "
-        "--dry_run --repo repo_name"
-    )
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="Don't change anything just tell me what you would do.",
-    )
-    parser.add_argument("-u", "--username", required=True, help="GitHub username")
-
-    # specify repositories
-    parser.add_argument(
-        "-o",
-        "--owner",
-        required=True,
-        default="ISISComputingGroup",
-        help="Owner of the repositories",
-    )
-    parser.add_argument(
-        "--repo-file",
-        required=False,
-        default=None,
-        dest="repo_file",
-        help="Apply the changes to repositories in this file. File is list of repository names,"
-        "comments (lines starting with a #) and blank lines are ignored",
-    )
-    parser.add_argument(
-        "--repo",
-        required=False,
-        default=None,
-        dest="repo",
-        help="Apply the changes to this repository",
-    )
-
-    # milestone creation
-    parser.add_argument(
-        "--ms-from", required=False, dest="date_from", help="Date from which the sprint starts."
-    )
-    parser.add_argument(
-        "--ms-to", required=False, dest="date_to", help="Date to which the sprint runs."
-    )
-
-    # milestone close
-    parser.add_argument(
-        "--ms-close",
-        dest="ms_close",
-        action="store_true",
-        help="Close all sprint milestones which are passed with closed tickets.",
-    )
-
-    # label creation
-    parser.add_argument(
-        "--label-name",
-        required=False,
-        default=None,
-        dest="ensure_label",
-        help="Ensure that the repository has the following label",
-    )
-    parser.add_argument(
-        "--label-colour",
-        required=False,
-        default=None,
-        dest="ensure_label_colour",
-        help="Ensure that the repository has a label that is this colour. Colours are colour code no "
-        "leading #, e.g. 626262",
-    )
-    parser.add_argument(
-        "--label-file",
-        required=False,
-        default=None,
-        dest="ensure_label_file",
-        help="Ensure that the repository has the following labels read from this file. "
-        "File is lines of '<colour code>, <label name>'",
-    )
-
-    if len(sys.argv) == 1:
-        sys.stderr.write(
-            "You need to use commandline arguments and you passed none. If in windows make sure your *.py "
-            'is linked to "...\\python.exe "%1" %*" or use python change_repos.py <args> \n'
-        )
-
-    settings = parser.parse_args()
-
-    if settings.date_from is not None or settings.date_to is not None:
-        if settings.date_from is None or settings.date_to is None:
-            print("Error from and to date for milestone must be set if one is")
-            exit(-1)
-        try:
-            RepositoryManipulator.get_checked_date(settings.date_from)
-        except UserError as ex:
-            print(f"Error in from date: {ex}")
-            exit(-1)
-        try:
-            RepositoryManipulator.get_checked_date(settings.date_to)
-        except UserError as ex:
-            print(f"Error in to date: {ex}")
-            exit(-1)
-
-    if settings.ensure_label is not None or settings.ensure_label_colour is not None:
-        if settings.ensure_label is None or settings.ensure_label_colour is None:
-            print("Error label name and colour must both be set if one is")
-            exit(-1)
-
-    return settings
-
-
-def _get_user_token():
-    """
-    Get the users access token for github
-    :return: token
-    """
-    token = ""
-    while token == "":
-        token = getpass("GitHub token for user (blank for help): ")
-        if token == "":
-            print("To get a personal token from git hub")
-            print("  1. Log into git hub")
-            print("  2. Open Your Setting (from icon top right)")
-            print("  3. Click Personal access tokens")
-            print("  4. Generate new token")
-            print("  5. Add token description")
-            print("  6. Select repo (Full control of private repositories)")
-            print("  7. Generate token")
-            print("  8. Copy the token an store it somewhere safe")
-    return token
-
-
-if __name__ == "__main__":
-    exit(main(_parse_command_line(), _get_user_token()))
diff --git a/repo_tool/scripts/proposal_printing.py b/repo_tool/scripts/proposal_printing.py
deleted file mode 100644
index 6c6e34ab..00000000
--- a/repo_tool/scripts/proposal_printing.py
+++ /dev/null
@@ -1,345 +0,0 @@
-"""
-A Utility to check and provide a printable list of proposed and ready tickets ready for prioritisation.
-To use this the python-docx package needs to be installed.
-There is limited error checking, and there are plenty of adaptations to make to this to improve it.
-This is fairly nasty code - but it is a first iteration to get some of the job done.
-This code is currently tailored to printing proposals.
-The final Prioritise.docx, which will be in the same folder as this script, can be opened and printed two to a page.
-Print it by going in print printer propeties  -> Priniting Shortcuts -> Pages per sheet = 2 pages per sheet
-"""
-
-import docx
-import requests
-from six import moves
-
-# Globals - used in a couple of locations
-
-
-BASE_URL_FOR_ISSUE = r"https://api.github.com/repos/ISISComputingGroup/IBEX/issues"
-BASE_URL_PROPOSALS = (
-    r"https://api.github.com/search/issues?q=repo:ISISComputingGroup/"
-    r"IBEX+type:issue+state:open+label:{label}&page={page_number}&per_page={num_per_page}"
-)
-
-
-def get_web_content_as_json(url, auth):
-    """
-    This will go and get the contents listed at a URL, and bring it back as a JSON object.
-    This needs a try...catch implemented
-
-    Args:
-        url: url to get json from
-        auth: authentication
-
-    Returns: contents of url as a dictionary
-
-    """
-    page_to_get = requests.get(url, auth=auth)
-    contents = page_to_get.json()
-    try:
-        message = contents["message"]
-        raise Exception(f"URL returned message: {message}")
-    except (KeyError, TypeError):
-        pass
-    page_to_get.close()
-    return contents
-
-
-class IbexTicket:
-    """
-    Give our use of labels, this is a class to deal with just those aspects needed for printing for prioritisation.
-    """
-
-    # Internal constants
-    LabelsToPrioritise = ["proposal", "ready", "in progress"]
-
-    # Fields
-    PrioritiseMe = False
-    Number = 0000
-    Title = "Default Ticket Title"
-    Author = "An IBEX Team Member"
-    Labels = []
-    Proposer = "An IBEX Team Member"
-    Estimate = "Un-estimated"
-
-    # Initialisation, the two modes were towards development when some limitation was needed to avoid hitting the
-    # API service too much
-    def __init__(self, entry, auth, from_file=False):
-        if from_file:
-            # The file format is known, and so can be treated in a hack-y way
-            data = entry.split(";")
-            self.Number = int(data[0][1:])
-            self.Title = data[1]
-            self.Author = data[2]
-            labels = data[3]
-            labels = labels.replace("[", "")
-            labels = labels.replace("]", "")
-            labels = labels.replace("'", "")
-            labels = labels.replace(",", "")
-            self.Labels = labels.split()
-            self.Proposer = data[4][:-1]
-            self.priority_decision(from_file)
-            # See if there is already an estimate for the ticket
-            self.get_estimate()
-        else:
-            # This will be JSON information that can be interpreted
-            # Error checking should be added here
-            self.Number = entry["number"]
-            self.Title = entry["title"]
-            self.Author = entry["user"]["login"]
-            # Labels need to be dealt with in a slightly different manner as these are a nested JSON structure
-            remote_labels = entry["labels"]
-            labels = []
-            for label in remote_labels:
-                labels.append(str(label["name"]))
-            self.Labels = labels
-            # If there are any labels that need prioritising, make sure they are listed for prioritisation
-            if any(ltp in self.LabelsToPrioritise for ltp in labels):
-                self.priority_decision()
-            # See if there is already an estimate for the ticket
-            self.get_estimate()
-
-    def get_estimate(self):
-        # Look for an estimate in the labels and apply a value if appropriate
-        for labels in self.Labels:
-            if is_number(labels):
-                self.Estimate = float(labels)
-                self.Labels.remove(labels)
-
-    def print_ticket(self):
-        # So that you can read it in a console window
-        print("Number: %d" % self.Number)
-        print("Title: %s" % self.Title)
-        print("Author: %s" % self.Author)
-        print("Labels: %s" % self.Labels)
-        print("Proposer: %s" % self.Proposer)
-        print("Estimate: %s" % self.Estimate)
-
-    def file_line(self):
-        # Print the bare minimum to the file so that development on the data can continue
-        return "#%d;%s;%s;%s;%s\r" % (
-            self.Number,
-            self.Title,
-            self.Author,
-            self.Labels,
-            self.Proposer,
-        )
-
-    def priority_decision(self, from_file=False):
-        # Decide if this should be prioritised
-        # If it is ready, we ought to consider it
-        if not self.Labels:
-            return
-        if "ready" in self.Labels:
-            # If it is rework we don't want to consider it, so if it ready, rework should not be an associated label
-            if "rework" not in self.Labels:
-                self.Proposer = ""
-                self.PrioritiseMe = True
-        else:
-            self.PrioritiseMe = True
-            if from_file:
-                self.Proposer = ""
-            else:
-                # Get the events to find the most recent proposer
-                url = BASE_URL_FOR_ISSUE + "/" + str(self.Number) + "/events"
-
-                contents = get_web_content_as_json(url, auth)
-
-                proposers = {}
-                # Get the list of proposers from the events
-                for event in contents:
-                    if event["event"] == "labeled":
-                        if event["label"]["name"] == "proposal":
-                            proposers[event["created_at"]] = event["actor"]["login"]
-                # If there is only one proposer, use that proposer ID, otehrwise sort the proposal creation times,
-                # and use the proposer from the last one in the list
-                if proposers:
-                    times = sorted(proposers.keys())
-                    self.Proposer = proposers[times[-1]]
-
-
-def get_open_tickets(auth, label):
-    """
-    Get all the open tickets
-    Will have to page the readbacks
-    Note that page 0 and 1 are the same page!
-    A Page that is too big comes back with no data, just []
-    Args:
-        auth: autherentication
-
-    Returns: tickets
-    """
-    tickets = []
-
-    url = BASE_URL_PROPOSALS.format(page_number=1, num_per_page=1, label=label)
-
-    contents = get_web_content_as_json(url, auth)
-    total_open = contents["total_count"]
-    # Only need to open enough pages to view the open ones, rather than check for an empty page,
-    # calculate the number of pages needed.
-    # An error check should be considered for the next iteration.
-    number_of_pages = (total_open / 100) + 1
-
-    # Open the file for writing during paignation.
-    with open("out.txt", "w") as f:
-        # Open each page, looking at 100 open issues
-        for page_number in range(number_of_pages):
-            print(f"Looking at page {page_number + 1}")
-            url = BASE_URL_PROPOSALS.format(
-                page_number=page_number + 1, num_per_page=100, label=label
-            )
-            contents = get_web_content_as_json(url, auth)["items"]
-            for entry in contents:
-                # Use a local variable as using in two places at this point
-                dev = IbexTicket(entry, auth)
-                # Add to the Tickets global for use in other parts of the program
-                # Next iteration shuld just return this list
-                tickets.append(dev)
-                # Write to the file as you go
-                f.write(dev.file_line())
-
-    return tickets
-
-
-def load_tickets_from_file(filename):
-    """
-    Load tickets from file
-    Args:
-        filename:
-
-    Returns:
-
-    """
-    tickets = []
-    # Load the file created to aid in development
-    with open(filename, "r") as f:
-        for line in f:
-            tickets.append(IbexTicket(line, auth=None, from_file=True))
-    return tickets
-
-
-def is_number(number):
-    """
-    Check for a number, and swallow the error
-    Args:
-        number: number as string
-
-    Returns:True if it is a number; False otherwise
-
-    """
-    try:
-        float(number)
-        return True
-    except ValueError:
-        return False
-
-
-def add_info(
-    document,
-    printable,
-    alignment=docx.enum.text.WD_ALIGN_PARAGRAPH.LEFT,
-    point=40,
-    bold=False,
-    italic=False,
-):
-    # Add the details to the document for easy printing
-    Paragraph = document.add_paragraph()
-    Paragraph.alignment = alignment
-    Run = Paragraph.add_run(printable)
-    Font = Run.font
-    Font.size = docx.shared.Pt(point)
-    Run.bold = bold
-    Run.italic = italic
-
-
-###########
-##########
-#########
-# Above here be classes, below be stuff to run
-#########
-##########
-###########
-
-
-def get_tickets_generate_doc(auth, from_file, label):
-    """
-    Get the tickets and generate the document in word
-    Args:
-        auth: wuthentication to use for github
-        from_file: True to get data from a file; False otherwise
-
-    """
-    # Use one or the other of these lines, depending on what you are allowed to do, and what you have available
-    if from_file:
-        tickets = load_tickets_from_file("out.txt")
-    else:
-        tickets = get_open_tickets(auth, label)
-
-    # Just in case you want to look at it
-    # for Ticket in Tickets:
-    #    Ticket.print_ticket()
-
-    # Create a document for printing - this needs to be moved into a function/class
-    document = docx.Document()
-
-    # Initialise the document, change the orientation
-    section = document.sections[0]
-    new_width, new_height = section.page_height, section.page_width
-    section.orientation = docx.enum.section.WD_ORIENT.LANDSCAPE
-    section.page_width = new_width
-    section.page_height = new_height
-
-    # Loop through the tickets to add the information to the page ready for printing
-    # Should consider adding the other labels as well...
-    for Ticket in tickets:
-        if Ticket.PrioritiseMe:
-            add_info(
-                document,
-                str(Ticket.Estimate),
-                alignment=docx.enum.text.WD_ALIGN_PARAGRAPH.RIGHT,
-                point=36,
-            )
-            num_size = 96
-            title_size = 48
-            if len(Ticket.Title) > 35:
-                num_size = 84
-                title_size = 32
-            add_info(document, "#" + str(Ticket.Number), point=num_size, bold=True)
-            add_info(document, Ticket.Title, point=title_size)
-            number_of_rows = max(2, len(Ticket.Labels))
-            table = document.add_table(rows=number_of_rows, cols=2)
-            people_cells = table.columns[0].cells
-            add_info(people_cells[0], "Author: " + Ticket.Author, point=20)
-            add_info(people_cells[1], "Proposed by: " + Ticket.Proposer, italic=True, point=14)
-            label_cells = table.columns[1].cells
-            if Ticket.Labels:
-                label_index = 0
-                for label in Ticket.Labels:
-                    if not is_number(label):
-                        add_info(label_cells[label_index], label, point=14)
-                        label_index = label_index + 1
-            document.add_page_break()
-
-    # Save the document so that you can load and print it
-    document.save("Prioritise.docx")
-
-
-if __name__ == "__main__":
-    username = moves.input("Username (blank for no auth): ")
-    if username != "":
-        token = moves.input("Token (generated in personal tokens): ")
-        auth_pair = (username, token)
-    else:
-        auth_pair = None
-
-    from_file = moves.input("From file (Y or N): ").upper()[0] == "Y"
-    label = moves.input("Label (p - proposal, r - ready, i - in+progress, anything else): ")
-    if label[0] == "p":
-        label = "proposal"
-    elif label[0] == "r":
-        label = "ready"
-    elif label[0] == "i":
-        label = '"in+progress"'
-
-    print(label)
-    get_tickets_generate_doc(auth_pair, from_file, label)
diff --git a/repo_tool/setup.py b/repo_tool/setup.py
deleted file mode 100644
index 2a2592dd..00000000
--- a/repo_tool/setup.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python
-
-from distutils.core import setup
-
-setup(
-    name="GitHubRepositoryManipulation",
-    version="1.0",
-    description="Utilities to manipulate a set of GitHub repositories",
-    author="IBEX group",
-    author_email="",
-    url="",
-    scripts=["scripts/change_repos.py"],
-    install_requires=["github3.py", "pytz"],
-    packages=["repository_manipulator"],
-)
diff --git a/repo_tool/standard_labels.txt b/repo_tool/standard_labels.txt
deleted file mode 100644
index 599ca208..00000000
--- a/repo_tool/standard_labels.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-# A List of standard Labels
-#
-# File format is:
-#   # - coment
-#   <label colour>, <label text>
-
-fc2929, bug
-cccccc, duplicate
-84b6eb, enhancement
-159818, help wanted
-0052cc, ICP
-e6e6e6, invalid
-cc317c, question
-5319e7, ticket
-ffffff, wontfix
diff --git a/repo_tool/test/__init__.py b/repo_tool/test/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/repo_tool/test/test_login.py b/repo_tool/test/test_login.py
deleted file mode 100644
index e2869718..00000000
--- a/repo_tool/test/test_login.py
+++ /dev/null
@@ -1,91 +0,0 @@
-import unittest
-from datetime import datetime
-
-from github3 import GitHubError
-from hamcrest import *
-from mock import Mock
-
-from repo_tool.repository_manipulator.RepositoryManipulator import RepositoryManipulator, UserError
-
-
-class GitHubMock:
-    username = None
-    token = None
-
-    git_hub_mock = None
-
-    def __init__(self, repo_list=None):
-        self.repo_list = repo_list
-
-    @staticmethod
-    def login(user, token):
-        if (GitHubMock.username is None and GitHubMock.token is None) or (
-            user == GitHubMock.username and token == GitHubMock.token
-        ):
-            if GitHubMock.git_hub_mock is None:
-                return GitHubMock()
-            else:
-                return GitHubMock.git_hub_mock
-
-        resp = Mock(side_effect="Error")
-        resp.status_code = 401
-        raise GitHubError(resp)
-
-    @staticmethod
-    def setUsernameAndPassword(usename, token):
-        GitHubMock.username = usename
-        GitHubMock.token = token
-
-
-class TestLogin(unittest.TestCase):
-    def setUp(self):
-        self.github = GitHubMock
-
-    def test_with_invalid_credential_user_cannot_log_in(self):
-        GitHubMock.setUsernameAndPassword("user", "token")
-
-        assert_that(
-            calling(RepositoryManipulator).with_args(
-                username="", token="", login_method=self.github.login
-            ),
-            raises(UserError),
-        )
-
-    def test_with_valid_credential_does_not_throw_excpetion(self):
-        username = "user"
-        token = "token"
-        GitHubMock.setUsernameAndPassword(username, token)
-
-        isis_repos = RepositoryManipulator(
-            username=username, token=token, login_method=self.github.login
-        )
-
-
-class TestCheckedDate(unittest.TestCase):
-    def test_GIVEN_blank_WHN_get_checked_date_THEN_error(self):
-        date_string = ""
-
-        assert_that(
-            calling(RepositoryManipulator.get_checked_date).with_args(date_string),
-            raises(UserError),
-        )
-
-    def test_GIVEN_valid_WHN_get_checked_date_THEN_date_tuple_retuned(self):
-        date_string = "2010-02-01"
-        expected_date = datetime(2010, 0o2, 0o1)
-
-        result = RepositoryManipulator.get_checked_date(date_string)
-
-        assert_that(result, is_(expected_date))
-
-    def test_GIVEN_invalid_WHN_get_checked_date_THEN_error(self):
-        date_string = "2010-13-20"
-
-        assert_that(
-            calling(RepositoryManipulator.get_checked_date).with_args(date_string),
-            raises(UserError),
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()