diff --git a/scripts/osmo_interact_common.py b/scripts/osmo_interact_common.py
deleted file mode 100644
index 5efc22d..0000000
--- a/scripts/osmo_interact_common.py
+++ /dev/null
@@ -1,469 +0,0 @@
-#!/usr/bin/env python3
-#
-# (C) 2017 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
-# All rights reserved.
-#
-# Author: Neels Hofmeyr <nhofmeyr@sysmocom.de>
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-'''
-Common code for osmo_interact_vty.py and osmo_interact_ctrl.py.
-This implements all of application interaction, piping and verification.
-osmo_interact_{vty,ctrl}.py plug VTY and CTRL interface specific bits.
-'''
-
-import argparse
-import sys
-import os
-import subprocess
-import time
-import traceback
-import socket
-import shlex
-import re
-
-
-class Interact:
-
-    class StepBase:
-        command = None
-        result = None
-        leading_blanks = None
-
-        def __init__(self):
-            self.result = []
-
-        def verify_interact_state(self, interact_instance):
-            # for example to verify that the last VTY prompt received shows the
-            # right node.
-            pass
-
-        def command_str(self, interact_instance=None):
-            return self.command
-
-        def __str__(self):
-            return '%s\n%s' % (self.command_str(), '\n'.join(self.result))
-
-        @staticmethod
-        def is_next_step(line, interact_instance):
-            assert not "implemented by InteractVty.VtyStep and InteractCtrl.CtrlStep"
-
-    socket = None
-
-    def __init__(self, step_class, port, host, verbose=False, update=False):
-        '''
-        host is the hostname to connect to.
-        port is the CTRL port to connect on.
-        '''
-        self.Step = step_class
-        self.port = port
-        self.host = host
-        self.verbose = verbose
-        self.update = update
-
-        if not port:
-            raise Exception("You need to provide port number to connect to")
-
-    def connect(self):
-        assert self.socket is None
-        retries = 30
-        took = 0
-        while True:
-            took += 1
-            try:
-                self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                self.socket.setblocking(1)
-                self.socket.connect((self.host, int(self.port)))
-            except IOError:
-                retries -= 1
-                if retries <= 0:
-                    raise
-                time.sleep(.1)
-                continue
-            break
-
-    def close(self):
-        if self.socket is None:
-            return
-        self.socket.close()
-        self.socket = None
-
-    def command(self, command):
-        assert not "implemented separately by InteractVty and InteractCtrl"
-
-    def verify_transcript_file(self, transcript_file):
-        with open(transcript_file, 'r') as f:
-            content = f.read()
-
-        try:
-            result = self.verify_transcript(content)
-        except:
-            print('Error while verifying transcript file %r' % transcript_file, file=sys.stderr)
-            sys.stderr.flush()
-            raise
-
-        if not self.update:
-            return
-        content = '\n'.join(result)
-        with open(transcript_file, 'w') as f:
-            f.write(content)
-
-    def verify_transcript(self, transcript):
-        ''''
-        transcript is a "screenshot" of a session, a multi-line string
-        including commands and expected results.
-        Feed commands to self.command() and verify the expected results.
-        '''
-
-        # parse steps
-        steps = []
-        step = None
-        blank_lines = 0
-        for line in transcript.splitlines():
-            if not line:
-                blank_lines += 1
-                continue
-            next_step_started = self.Step.is_next_step(line, self)
-            if next_step_started:
-                if step:
-                    steps.append(step)
-                step = next_step_started
-                step.leading_blanks = blank_lines
-                blank_lines = 0
-            elif step:
-                # we only count blank lines directly preceding the start of a
-                # next step. Insert blank lines in the middle of a response
-                # back into the response:
-                if blank_lines:
-                    step.result.extend([''] * blank_lines)
-                blank_lines = 0
-                step.result.append(line)
-        if step:
-            steps.append(step)
-        step = None
-
-        actual_result = []
-
-        # run steps
-        step_nr = 0
-        for step in steps:
-            step_nr += 1
-            try:
-                if self.verbose:
-                    if step.leading_blanks:
-                        print('\n' * step.leading_blanks, end='')
-                    print(step.command_str())
-                    sys.stdout.flush()
-
-                step.verify_interact_state(self)
-
-                res = self.command(step.command)
-
-                if self.verbose:
-                    sys.stderr.flush()
-                    sys.stdout.flush()
-                    print('\n'.join(res))
-                    sys.stdout.flush()
-
-                if step.leading_blanks:
-                    actual_result.extend([''] * step.leading_blanks)
-                actual_result.append(step.command_str(self))
-
-                match_result = self.match_lines(step.result, res)
-
-                if self.update:
-                    if match_result is True:
-                        # preserve any wildcards
-                        actual_result.extend(step.result)
-                    else:
-                        # mismatch, take exactly what came in
-                        actual_result.extend(res)
-                    continue
-                if match_result is not True:
-                    raise Exception('Result mismatch:\n%s\n\nExpected:\n[\n%s\n]\n\nGot:\n[\n%s\n%s\n]'
-                                    % (match_result, step, step.command_str(), '\n'.join(res)))
-            except:
-                print('Error during transcript step %d:\n[\n%s\n]' % (step_nr, step),
-                      file=sys.stderr)
-                sys.stderr.flush()
-                raise
-
-        # final line ending
-        actual_result.append('')
-        return actual_result
-
-    @staticmethod
-    def match_lines(expect, got):
-        '''
-        Match two lists of strings, allowing certain wildcards:
-        - In 'expect', if a line is exactly '...', it matches any number of
-          arbitrary lines in 'got'; the implementation is trivial and skips
-          lines to the first occurence in 'got' that continues after '...'.
-        - If an 'expect' line is '... !regex', it matches any number of
-          lines like '...', but the given regex must not match any of those
-          lines.
-
-        Return 'True' on match, or a string describing the mismatch.
-        '''
-        def match_line(expect_line, got_line):
-            return expect_line == got_line
-
-        ANY = '...'
-        ANY_EXCEPT = '... !'
-
-        e = 0
-        g = 0
-        while e < len(expect):
-            if expect[e] == ANY or expect[e].startswith(ANY_EXCEPT):
-                wildcard = expect[e]
-                e += 1
-                g_end = g
-
-                if e >= len(expect):
-                    # anything left in 'got' is accepted.
-                    g_end = len(got)
-
-                # look for the next occurence of the expected line in 'got'
-                while g_end < len(got) and not match_line(expect[e], got[g_end]):
-                    g_end += 1
-
-                if wildcard == ANY:
-                    # no restrictions on lines
-                    g = g_end
-
-                elif wildcard.startswith(ANY_EXCEPT):
-                    except_re = re.compile(wildcard[len(ANY_EXCEPT):])
-                    while g < g_end:
-                        if except_re.search(got[g]):
-                          return ('Got forbidden line for wildcard %r:'
-                                  ' did not expect %r in line %d of response'
-                                  % (wildcard, got[g], g))
-                        g += 1
-
-                continue
-
-            if g >= len(got):
-                return 'Cannot find line %r' % expect[e]
-
-            if not match_line(expect[e], got[g]):
-                return 'Mismatch:\nExpect:\n%r\nGot:\n%r' % (expect[e], got[g])
-
-            e += 1
-            g += 1
-
-        if g < len(got):
-            return 'Did not expect line %r' % got[g]
-        return True
-
-    def feed_commands(self, output, command_strs):
-        for command_str in command_strs:
-            for command in command_str.splitlines():
-                res = self.command(command)
-                output.write('\n'.join(res))
-                output.write('\n')
-
-def end_process(proc, quiet=False):
-    if not proc:
-        return
-
-    rc = proc.poll()
-    if rc is not None:
-        if not quiet:
-            print('Process has already terminated with', rc)
-        proc.wait()
-        return
-
-    proc.terminate()
-    time_to_wait_for_term = 5
-    wait_step = 0.001
-    waited_time = 0
-    while True:
-        # poll returns None if proc is still running
-        if proc.poll() is not None:
-            break
-        waited_time += wait_step
-        # make wait_step approach 1.0
-        wait_step = (1. + 5. * wait_step) / 6.
-        if waited_time >= time_to_wait_for_term:
-            break
-        time.sleep(wait_step)
-
-    if proc.poll() is None:
-        # termination seems to be slower than that, let's just kill
-        proc.kill()
-        if not quiet:
-            print("Killed child process")
-    elif waited_time > .002:
-        if not quiet:
-            print("Terminating took %.3fs" % waited_time)
-    proc.wait()
-
-class Application:
-    proc = None
-    _devnull = None
-
-    @staticmethod
-    def devnull():
-        if Application._devnull is None:
-            Application._devnull = open(os.devnull, 'w')
-        return Application._devnull
-
-    def __init__(self, run_app_str, purge_output=True, quiet=False):
-        self.command_tuple = shlex.split(run_app_str)
-        self.purge_output = purge_output
-        self.quiet = quiet
-
-    def run(self):
-        out_err = None
-        if self.purge_output:
-            out_err = Application.devnull()
-
-        if not self.quiet:
-            print('Launching: cd %r; %s' % (os.getcwd(), ' '.join(self.command_tuple)))
-        self.proc = subprocess.Popen(self.command_tuple, stdout=out_err, stderr=out_err)
-
-    def stop(self):
-        end_process(self.proc, self.quiet)
-
-def verify_application(run_app_str, interact, transcript_file, verbose):
-    passed = None
-    application = None
-
-    sys.stdout.flush()
-    sys.stderr.flush()
-
-    if run_app_str:
-        application = Application(run_app_str, purge_output=not verbose)
-        application.run()
-
-    try:
-        interact.connect()
-        interact.verify_transcript_file(transcript_file)
-        passed = True
-    except:
-        traceback.print_exc()
-        passed = False
-    interact.close()
-
-    if application:
-        application.stop()
-
-    sys.stdout.flush()
-    sys.stderr.flush()
-
-    return passed
-
-def common_parser():
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-r', '--run', dest='run_app_str',
-                        help='command to run to launch application to test,'
-                        ' including command line arguments. If omitted, no'
-                        ' application is launched.')
-    parser.add_argument('-p', '--port', dest='port',
-                        help="Port to reach the application at.")
-    parser.add_argument('-H', '--host', dest='host', default='localhost',
-                        help="Host to reach the application at.")
-    return parser
-
-def parser_add_verify_args(parser):
-    parser.add_argument('-u', '--update', dest='update', action='store_true',
-                        help='Do not verify, but OVERWRITE transcripts based on'
-                        ' the application\'s current behavior. OVERWRITES TRANSCRIPT'
-                        ' FILES.')
-    parser.add_argument('-v', '--verbose', action='store_true',
-                        help='Print commands and application output')
-    parser.add_argument('transcript_files', nargs='*', help='transcript file(s) to verify')
-    return parser
-
-def parser_add_run_args(parser):
-    parser.add_argument('-O', '--output', dest='output_path',
-                        help="Write command results to a file instead of stdout."
-                        "('-O -' writes to stdout and is the default)")
-    parser.add_argument('-c', '--command', dest='cmd_str',
-                        help="Run this command (before reading input files, if any)."
-                        " multiple commands may be separated by ';'")
-    parser.add_argument('cmd_files', nargs='*', help='file(s) with plain commands to run')
-    return parser
-
-def main_run_commands(run_app_str, output_path, cmd_str, cmd_files, interact):
-    to_stdout = False
-    if not output_path or output_path == '-':
-        to_stdout = True
-        output = sys.stdout
-    else:
-        output = open(output_path, 'w')
-
-    application = None
-
-    if run_app_str:
-        application = Application(run_app_str, quiet=to_stdout)
-        application.run()
-
-    try:
-        interact.connect()
-
-        if cmd_str:
-            interact.feed_commands(output, cmd_str.split(';'))
-
-        for f_path in (cmd_files or []):
-            with open(f_path, 'r') as f:
-                interact.feed_commands(output, f.read().decode('utf-8').splitlines())
-
-        if not (cmd_str or cmd_files):
-            while True:
-                line = sys.stdin.readline()
-                if not line:
-                    break;
-                interact.feed_commands(output, line.split(';'))
-    except:
-        traceback.print_exc()
-    finally:
-        if not to_stdout:
-            try:
-                output.close()
-            except:
-                traceback.print_exc()
-
-        try:
-            interact.close()
-        except:
-            traceback.print_exc()
-
-        if application:
-            try:
-                application.stop()
-            except:
-                traceback.print_exc()
-
-def main_verify_transcripts(run_app_str, transcript_files, interact, verbose):
-    results = []
-    for t in transcript_files:
-        passed = verify_application(run_app_str=run_app_str,
-                                    interact=interact,
-                                    transcript_file=t,
-                                    verbose=verbose)
-        results.append((passed, t))
-
-    print('\nRESULTS:')
-    all_passed = True
-    for passed, t in results:
-        print('%s: %s' % ('pass' if passed else 'FAIL', t))
-        all_passed = all_passed and passed
-    print()
-
-    if not all_passed:
-        sys.exit(1)
-
-# vim: tabstop=4 shiftwidth=4 expandtab nocin ai
diff --git a/scripts/osmo_interact_ctrl.py b/scripts/osmo_interact_ctrl.py
index 9b1a20b..eb88800 100755
--- a/scripts/osmo_interact_ctrl.py
+++ b/scripts/osmo_interact_ctrl.py
@@ -18,83 +18,8 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-'''
-Run CTRL commands or test transcripts against a given application.  Commandline
-invocation exposes only direct command piping, the transcript verification code
-is exposed as commandline args by osmo_verify_transcript_ctrl.py.
-'''
+from osmopy.osmo_interact.ctrl import main_interact_ctrl
 
-import re
-
-from osmopy.osmo_interact_common import *
-from osmopy.osmo_ipa import Ctrl, IPA
-
-class InteractCtrl(Interact):
-    next_id = 1
-    keep_ids = True
-    re_command = re.compile('^(SET|GET) ([^ ]*) (.*)$')
-
-    class CtrlStep(Interact.StepBase):
-
-        @staticmethod
-        def is_next_step(line, interact_instance):
-            m = InteractCtrl.re_command.match(line)
-            if not m:
-                return None
-            next_step = InteractCtrl.CtrlStep()
-
-            set_get = m.group(1)
-            cmd_id = m.group(2)
-            var_val = m.group(3)
-            if not interact_instance.keep_ids:
-                cmd_id = interact_instance.next_id
-                interact_instance.next_id += 1
-            next_step.command = '%s %s %s' % (set_get, cmd_id, var_val)
-
-            return next_step
-
-    def __init__(self, port, host, verbose=False, update=False, keep_ids=True):
-        if not update:
-            keep_ids = True
-        self.keep_ids = keep_ids
-        super().__init__(InteractCtrl.CtrlStep, port=port, host=host, verbose=verbose, update=update)
-
-    def connect(self):
-        self.next_id = 1
-        super().connect()
-
-    def send(self, data):
-        data = Ctrl().add_header(data)
-        return self.socket.send(data) == len(data)
-
-    def receive(self):
-        responses = []
-        data = self.socket.recv(4096)
-        while (len(data)>0):
-            (response_with_header, data) = IPA().split_combined(data)
-            response = Ctrl().rem_header(response_with_header)
-            responses.append(response.decode('utf-8'))
-        return responses
-
-    def command(self, command):
-        assert self.send(command)
-        res = self.receive()
-        split_responses = []
-        for r in res:
-            split_responses.extend(r.splitlines())
-        sys.stdout.flush()
-        sys.stderr.flush()
-        return split_responses
-
-if __name__ == '__main__':
-    parser = common_parser()
-    parser_add_run_args(parser)
-    args = parser.parse_args()
-
-    interact = InteractCtrl(args.port, args.host, verbose=False, update=False,
-                            keep_ids=True)
-
-    main_run_commands(args.run_app_str, args.output_path, args.cmd_str,
-                      args.cmd_files, interact)
+main_interact_ctrl()
 
 # vim: tabstop=4 shiftwidth=4 expandtab nocin ai
diff --git a/scripts/osmo_interact_vty.py b/scripts/osmo_interact_vty.py
index b57cd8c..b47b46c 100755
--- a/scripts/osmo_interact_vty.py
+++ b/scripts/osmo_interact_vty.py
@@ -18,163 +18,8 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-'''
-Run VTY commands or test transcripts against a given application.  Commandline
-invocation exposes only direct command piping, the transcript verification code
-is exposed as commandline args by osmo_verify_transcript_vty.py.
-'''
+from osmopy.osmo_interact.vty import main_interact_vty
 
-import re
-
-from osmopy.osmo_interact_common import *
-
-class InteractVty(Interact):
-
-    class VtyStep(Interact.StepBase):
-        expect_node = None   # e.g. '(config-net)'
-        expect_prompt_char = None # '>' or '#'
-
-        def __init__(self, prompt):
-            super().__init__()
-            self.prompt = prompt
-
-        def verify_interact_state(self, interact_instance):
-            if interact_instance.update:
-                return
-            if interact_instance.this_node != self.expect_node:
-                raise Exception('Mismatch: expected VTY node %r in the prompt, got %r'
-                                % (self.expect_node, interact_instance.this_node))
-            if interact_instance.this_prompt_char != self.expect_prompt_char:
-                raise Exception('Mismatch: expected VTY prompt character %r, got %r'
-                                % (self.expect_prompt_char, interact_instance.this_prompt_char))
-
-        @staticmethod
-        def is_next_step(line, interact_instance):
-            m = interact_instance.re_prompt.match(line)
-            if not m:
-                return None
-            next_step = InteractVty.VtyStep(interact_instance.prompt)
-            next_step.expect_node = m.group(1)
-            next_step.expect_prompt_char = m.group(2)
-            next_step.command = m.group(3)
-            return next_step
-
-        def command_str(self, interact_instance=None):
-            if interact_instance is None:
-                node = self.expect_node
-                prompt_char = self.expect_prompt_char
-            else:
-                node = interact_instance.last_node
-                prompt_char = interact_instance.last_prompt_char
-            if node:
-                node = '(%s)' % node
-            node = node or ''
-            return '%s%s%s %s' % (self.prompt, node, prompt_char, self.command)
-
-    def __init__(self, prompt, port, host, verbose, update):
-        self.prompt = prompt
-        super().__init__(InteractVty.VtyStep, port, host, verbose, update)
-
-    def connect(self):
-        self.this_node = None
-        self.this_prompt_char = '>' # slight cheat for initial prompt char
-        self.last_node = None
-        self.last_prompt_char = None
-
-        super().connect()
-        # receive the first welcome message and discard
-        data = self.socket.recv(4096)
-        if not self.prompt:
-            b = data
-            b = b[b.rfind(b'\n') + 1:]
-            while b and (b[0] < ord('A') or b[0] > ord('z')):
-                b = b[1:]
-            prompt_str = b.decode('utf-8')
-            if '>' in prompt_str:
-                self.prompt = prompt_str[:prompt_str.find('>')]
-        if not self.prompt:
-            raise Exception('Could not find application name; needed to decode prompts.'
-                            ' Initial data was: %r' % data)
-        self.re_prompt = re.compile('^%s(?:\(([\w-]*)\))?([#>]) (.*)$' % self.prompt)
-
-    def _command(self, command_str, timeout=10):
-        self.socket.send(command_str.encode())
-
-        waited_since = time.time()
-        received_lines = []
-        last_line = ''
-
-        while True:
-            new_data = self.socket.recv(4096).decode('utf-8')
-
-            last_line = "%s%s" % (last_line, new_data)
-
-            if last_line:
-                lines = last_line.splitlines()
-                received_lines.extend(lines[:-1])
-                last_line = lines[-1]
-
-            match = self.re_prompt.match(last_line)
-            if not match:
-                if time.time() - waited_since > timeout:
-                    raise IOError("Failed to read data (did the app crash?)")
-                time.sleep(.1)
-                continue
-
-            self.last_node = self.this_node
-            self.last_prompt_char = self.this_prompt_char
-            self.this_node = match.group(1) or None
-            self.this_prompt_char = match.group(2)
-            break
-
-        # expecting to have received the command we sent as echo, remove it
-        clean_command_str = command_str.strip()
-        if clean_command_str.endswith('?'):
-            clean_command_str = clean_command_str[:-1]
-        if received_lines and received_lines[0] == clean_command_str:
-            received_lines = received_lines[1:]
-        return received_lines
-
-    def command(self, command_str, timeout=10):
-        command_str = command_str or '\r'
-        if command_str[-1] not in '?\r\t':
-            command_str = command_str + '\r'
-
-        received_lines = self._command(command_str, timeout)
-
-        # send escape to cancel the '?' command line
-        if command_str[-1] == '?':
-            self._command('\x03', timeout)
-
-        return received_lines
-
-def parser_add_vty_args(parser):
-    parser.add_argument('-n', '--prompt-name', dest='prompt',
-                        help="Name used in application's telnet VTY prompt."
-                        " If omitted, will attempt to determine the name from"
-                        " the initial VTY prompt.")
-    return parser
-
-if __name__ == '__main__':
-    parser = common_parser()
-    parser_add_vty_args(parser)
-    parser_add_run_args(parser)
-    parser.add_argument('-X', '--gen-xml-ref', dest='gen_xml', action='store_true',
-                        help="Equivalent to '-c \"show online-help\" -O -',"
-                        " can be used to generate the VTY reference file as"
-                        " required by osmo-gsm-manuals.git.")
-    args = parser.parse_args()
-
-    if args.gen_xml:
-        if args.cmd_str:
-            raise Exception('It does not make sense to pass both --command and'
-                            ' --gen-xml-ref.')
-        args.cmd_str = 'show online-help'
-
-    interact = InteractVty(args.prompt, args.port, args.host,
-                           verbose=False, update=False)
-
-    main_run_commands(args.run_app_str, args.output_path, args.cmd_str,
-                      args.cmd_files, interact)
+main_interact_vty()
 
 # vim: tabstop=4 shiftwidth=4 expandtab nocin ai
diff --git a/scripts/osmo_verify_transcript_ctrl.py b/scripts/osmo_verify_transcript_ctrl.py
index 3afbc62..b24fbfa 100755
--- a/scripts/osmo_verify_transcript_ctrl.py
+++ b/scripts/osmo_verify_transcript_ctrl.py
@@ -18,41 +18,8 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-'''
-Run CTRL test transcripts against a given application.
+from osmopy.osmo_interact.ctrl import main_verify_transcript_ctrl
 
-A CTRL transcript contains CTRL commands and their expected results.
-It looks like:
-
-"
-SET 1 var val
-SET_REPLY 1 var OK
-GET 2 var
-GET_REPLY 2 var val
-"
-
-The application to be tested is described by
-- a binary to run,
-- command line arguments to pass to the binary,
-- the CTRL port.
-
-This module can either be run directly to run or update a given CTRL transcript,
-or it can be imported as a module to run more complex setups.
-'''
-
-from osmopy.osmo_interact_ctrl import *
-
-if __name__ == '__main__':
-    parser = common_parser()
-    parser_add_verify_args(parser)
-    parser.add_argument('-i', '--keep-ids', dest='keep_ids', action='store_true',
-                        help='With --update, default is to overwrite the command IDs'
-                        ' so that they are consecutive numbers starting from 1.'
-                        ' With --keep-ids, do not change these command IDs.')
-    args = parser.parse_args()
-
-    interact = InteractCtrl(args.port, args.host, args.verbose, args.update, args.keep_ids)
-
-    main_verify_transcripts(args.run_app_str, args.transcript_files, interact, args.verbose)
+main_verify_transcript_ctrl()
 
 # vim: tabstop=4 shiftwidth=4 expandtab nocin ai
diff --git a/scripts/osmo_verify_transcript_vty.py b/scripts/osmo_verify_transcript_vty.py
index e70c36c..2695e86 100755
--- a/scripts/osmo_verify_transcript_vty.py
+++ b/scripts/osmo_verify_transcript_vty.py
@@ -18,50 +18,8 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-'''
-Run VTY test transcripts against a given application.
+from osmopy.osmo_interact.vty import main_verify_transcript_vty
 
-A VTY transcript contains VTY commands and their expected results.
-It looks like:
-
-"
-OsmoHLR> enable
-
-OsmoHLR# subscriber show imsi 123456789023000
-% No subscriber for imsi = '123456789023000'
-OsmoHLR# subscriber show msisdn 12345
-% No subscriber for msisdn = '12345'
-
-OsmoHLR# subscriber create imsi 123456789023000
-% Created subscriber 123456789023000
-    ID: 1
-    IMSI: 123456789023000
-    MSISDN: none
-    No auth data
-"
-
-The application to be tested is described by
-- a binary to run,
-- command line arguments to pass to the binary,
-- the VTY telnet port,
-- the application name as printed in the VTY prompt.
-
-This module can either be run directly to run or update a given VTY transcript,
-or it can be imported as a module to run more complex setups.
-'''
-
-import re
-
-from osmopy.osmo_interact_vty import *
-
-if __name__ == '__main__':
-    parser = common_parser()
-    parser_add_vty_args(parser)
-    parser_add_verify_args(parser)
-    args = parser.parse_args()
-
-    interact = InteractVty(args.prompt, args.port, args.host, args.verbose, args.update)
-
-    main_verify_transcripts(args.run_app_str, args.transcript_files, interact, args.verbose)
+main_verify_transcript_vty()
 
 # vim: tabstop=4 shiftwidth=4 expandtab nocin ai