Merge ~nacc/git-ubuntu:refactor-main-v2 into git-ubuntu:master

[Nish Aravamudan]

This is admittedly a messy patchset. I am tired of rebasing it, though, and think we can land it in roughly this state (even if only in the edge channel of the snap) and then decide what to do from there after testing.

A ton of change, but we are now pylint3 clean for errors except for pygit2 imports:

$ pylint3 -E gitubuntu --ignored-modules=pygit2
No config file found, using default configuration

All unit tests still pass and I've run a from-scratch import, a clone and a build using the resulting git repository.

[Server Team CI bot (server-team-bot)]

FAILED: Continuous integration, rev:bd7e040556cd86c24859dea6af7d56fbb92954ba
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/24/
Executed test runs:
    SUCCESS: Checkout
    SUCCESS: Tests
    FAILED: Build

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/24/rebuild

review: Needs Fixing (continuous-integration)

48775be... by Nish Aravamudan on 2017-09-06

lint: drop unused pullfile variable

[Server Team CI bot (server-team-bot)]

FAILED: Continuous integration, rev:a54e9ee31944d9af5820b98bf66e12329408c788
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/25/
Executed test runs:
    SUCCESS: Checkout
    SUCCESS: Tests
    FAILED: Build

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/25/rebuild

review: Needs Fixing (continuous-integration)

a3a9190... by Nish Aravamudan on 2017-09-06

clone: fix stray space

29e6277... by Nish Aravamudan on 2017-09-06

lint: linting historical merges with default arguments can fail

Typically, this is because pkg/debian/sid now is not the same as
pkg/debian/sid when the MP was proposed. This can lead to all sorts of
oddness, but should not be fatal to lint (and the proper way to lint a
historical change is presumably passing a --target-branch, or changing
that functionality to be --target-commitish).

One specific case is when the to-be-linted branch is older than the
target branch (e.g., a missed MP) and thus it only contains changelog
deletions.

7af2b70... by Nish Aravamudan on 2017-09-07

git-ubuntu: change default fetch protocol to https

LP: #1715688

6a15a64... by Nish Aravamudan on 2017-09-07

git-ubuntu: fix dictionary style

19aa857... by Nish Aravamudan on 2017-09-07

use environment python3

Rather than a hardcoded path.

[Nish Aravamudan (nacc)]

The overall structure of this is good, I'm just still fine-tuning.

49b3a96... by Nish Aravamudan on 2017-09-08

snap: export QUILT_DIR in git-ubuntu wrapper

Reported by powers and rbasak, quilt is looking in a hardcoded
/usr/share/quilt for subcommands. This is in our snap, not in the
root filesystem.

3b2b418... by Nish Aravamudan on 2017-09-08

lint: drop unused pullfile variable

e269f5a... by Nish Aravamudan on 2017-09-08

importppa: fix undefined variable UbuntuSourceInformation

87abbad... by Nish Aravamudan on 2017-09-08

importppa: fix call to add_remote

57c917e... by Nish Aravamudan on 2017-09-08

importppa: save pkgname to object

This is used by the importer code

bfba350... by Nish Aravamudan on 2017-09-08

importppa: fix parameters to parse_parentfile

Unmerged commits

6a15a64... by Nish Aravamudan on 2017-09-07

git-ubuntu: fix dictionary style

48775be... by Nish Aravamudan on 2017-09-06

lint: drop unused pullfile variable

6b2fe22... by Nish Aravamudan on 2017-09-06

git ubuntu: refactor main to call module parse_args

This is the final step in the refactor -- rather than using per-module
classes, just import each module in __main__ in order to call its
parse_args and func (which in the current implementation is that
module's cli_main).

Before merging with master, I think we will squash all of these
together.

At this point, all errors from pylint3 are from pygit2 imports.

LP: #1707321

2d4263a... by Nish Aravamudan on 2017-09-06

submit: refactor class

Leave only parse_args and cli_main in the class. Make cli_main nothing
more than a wrapper to the module's main function.

LP: #1707321

ce50ef5... by Nish Aravamudan on 2017-09-06

submit: use lint.derive_target_branch

submit can be used for distributed development among team members by
proposing MPs against each other's repositories, via the --target-user
flag. Rather than having submit-specific code for deriving the target
branch, use the existing code from lint, after extending it to take a
namespace argument.

b6762e7... by Nish Aravamudan on 2017-09-06

tag: refactor class

Leave only parse_args and cli_main in the class. Make cli_main nothing
more than a wrapper to the module's main function.

LP: #1707321

2bb9d17... by Nish Aravamudan on 2017-09-06

remote: refactor class

Leave only parse_args and cli_main in the class. Make cli_main nothing
more than a wrapper to the module's main function.

LP: #1707321

8359506... by Nish Aravamudan on 2017-09-05

queue: refactor class

Leave only parse_args and cli_main in the class. Make cli_main nothing
more than a wrapper to the module's main function.

LP: #1707321

92d78b6... by Nish Aravamudan on 2017-09-05

merge: refactor class

Leave only parse_args and cli_main in the class. Make cli_main nothing
more than a wrapper to the module's main function.

LP: #1707321

f28dca4... by Nish Aravamudan on 2017-09-05

lint: refactor class

Leave only parse_args and cli_main in the class. Make cli_main nothing
more than a wrapper to the module's main function.

LP: #1707321

diff --git a/bin/git-ubuntu b/bin/git-ubuntu
index 23f908e..2b15471 100755
--- a/bin/git-ubuntu
+++ b/bin/git-ubuntu
@@ -1,4 +1,4 @@
-#!/usr/bin/python3
+#!/usr/bin/env python3
 
 # PYTHON_ARGCOMPLETE_OK
 
diff --git a/bin/import-cron b/bin/import-cron
index b23e512..0044b74 100755
--- a/bin/import-cron
+++ b/bin/import-cron
@@ -1,4 +1,4 @@
-#!/usr/bin/python3
+#!/usr/bin/env python3
 
 from copy import copy
 import os
diff --git a/bin/snap/snap-git-ubuntu b/bin/snap/snap-git-ubuntu
index 17ba583..9a73451 100755
--- a/bin/snap/snap-git-ubuntu
+++ b/bin/snap/snap-git-ubuntu
@@ -6,5 +6,6 @@ export PATH="$SNAP/bin/snap:$SNAP/usr/local/sbin:$SNAP/usr/local/bin:$SNAP/usr/s
 export LD_LIBRARY_PATH="$SNAP/lib/x86_64-linux-gnu:$SNAP/usr/lib/x86_64-linux-gnu"
 export PERL5LIB="$SNAP/usr/share/perl5"
 export DPKG_DATADIR="$SNAP/usr/share/dpkg"
+export QUILT_DIR="$SNAP/usr/share/quilt"
 eval "$(register-python-argcomplete3 git-ubuntu)"
 exec "$SNAP/usr/bin/python3" "$SNAP/bin/git-ubuntu" "$@"
diff --git a/gitubuntu/__main__.py b/gitubuntu/__main__.py
index ba4a435..49373a7 100644
--- a/gitubuntu/__main__.py
+++ b/gitubuntu/__main__.py
@@ -1,26 +1,15 @@
-#!/usr/bin/python3
+#!/usr/bin/env python3
 
 def main():
     try:
         import argparse
+        from importlib import import_module
         import logging
         from os import isatty
         import shutil
         from subprocess import CalledProcessError
         import sys
         import textwrap
-        from gitubuntu.importer import GitUbuntuImport
-        from gitubuntu.build import GitUbuntuBuild
-        from gitubuntu.buildsource import GitUbuntuBuildSource
-        from gitubuntu.merge import GitUbuntuMerge
-        from gitubuntu.clone import GitUbuntuClone
-        from gitubuntu.tag import GitUbuntuTag
-        from gitubuntu.queue import GitUbuntuQueue
-        from gitubuntu.importlocal import GitUbuntuImportLocal
-        from gitubuntu.importppa import GitUbuntuImportPPA
-        from gitubuntu.remote import GitUbuntuRemote
-        from gitubuntu.submit import GitUbuntuSubmit
-        from gitubuntu.lint import GitUbuntuLint
         from gitubuntu.run import run
 
         try:
@@ -34,123 +23,147 @@ def main():
 
         logging.getLogger('keyring').setLevel(logging.WARNING)
 
-        known_subcommands = {'import':GitUbuntuImport,
-                             'build':GitUbuntuBuild,
-                             'build-source':GitUbuntuBuildSource,
-                             'merge':GitUbuntuMerge,
-                             'clone':GitUbuntuClone,
-                             'tag':GitUbuntuTag,
-                             'queue':GitUbuntuQueue,
-                             'import-local':GitUbuntuImportLocal,
-                             'import-ppa':GitUbuntuImportPPA,
-                             'remote':GitUbuntuRemote,
-                             'submit':GitUbuntuSubmit,
-                             'lint':GitUbuntuLint,
-                            }
+        known_subcommands = {
+            'import': 'gitubuntu.importer',
+            'build': 'gitubuntu.build',
+            'build-source': 'gitubuntu.buildsource',
+            'merge': 'gitubuntu.merge',
+            'clone': 'gitubuntu.clone',
+            'tag': 'gitubuntu.tag',
+            'queue': 'gitubuntu.queue',
+            'import-local': 'gitubuntu.importlocal',
+            'import-ppa': 'gitubuntu.importppa',
+            'remote': 'gitubuntu.remote',
+            'submit': 'gitubuntu.submit',
+            'lint': 'gitubuntu.lint',
+        }
 
-        known_network_subcommands = {'import', 'import-local',
-                                     'import-ppa', 'clone', 'build',
-                                     'build-source', 'queue',
-                                     'remote', 'submit'}
+        known_network_subcommands = {
+            'import',
+            'import-local',
+            'import-ppa',
+            'clone',
+            'build',
+            'build-source',
+            'queue',
+            'remote',
+            'submit',
+        }
 
         parser = argparse.ArgumentParser(
             description='Ubuntu git development tool',
             formatter_class=argparse.RawTextHelpFormatter,
-            epilog='More information is available at https://wiki.ubuntu.com/UbuntuDevelopment/Merging/GitWorkflow.'
-                                        )
-        subparsers = parser.add_subparsers(dest='subcommand',
-                                           help='',
-                                           metavar='%s' % '|'.join(sorted(known_subcommands))
-                                          )
+            epilog='More information is available at https://wiki.ubuntu.com/UbuntuDevelopment/Merging/GitWorkflow.',
+        )
+        subparsers = parser.add_subparsers(
+            dest='subcommand',
+            help='',
+            metavar='%s' % '|'.join(sorted(known_subcommands)),
+        )
         # This help ends up not being very useful to the end user
         # subparsers.required = True
 
         # common flags to all subcommands
         base_subparser = argparse.ArgumentParser(add_help=False)
-        base_subparser.add_argument('-v', '--verbose', action='store_true',
-                                    help='Increase verbosity')
+        base_subparser.add_argument(
+            '-v', '--verbose',
+            action='store_true',
+            help='Increase verbosity'
+        )
         network_base_subparser = argparse.ArgumentParser(add_help=False)
         network_base_subparser.add_argument(
-                                    '--retries', type=int,
-                                    help='Number of times to attempt to retry '
-                                         'downloading from Launchpad.',
-                                    default=3
-                                   )
+            '--retries',
+            type=int,
+            help='Number of times to attempt to retry '
+                 'downloading from Launchpad.',
+            default=3,
+        )
         network_base_subparser.add_argument(
-                                    '--retry-backoffs',
-                                    type=lambda s : [int(item) for item in s.split(',')],
-                                    help='Comma-separated list of backoffs in '
-                                         'seconds to use between each retry '
-                                         'attempt. Default is exponential backoff.',
-                                    default=argparse.SUPPRESS
-                                   )
+            '--retry-backoffs',
+            type=lambda s : [int(item) for item in s.split(',')],
+            help='Comma-separated list of backoffs in '
+                 'seconds to use between each retry '
+                 'attempt. Default is exponential backoff.',
+            default=argparse.SUPPRESS,
+        )
         known_protos = ['git', 'http', 'https']
         network_base_subparser.add_argument(
-                                    '--proto',
-                                    metavar='[%s]' % '|'.join(known_protos),
-                                    choices=known_protos,
-                                    help='Specify protocol to use for fetch. Default: %(default)s',
-                                    default='git'
-                                   )
+            '--proto',
+            metavar='[%s]' % '|'.join(known_protos),
+            choices=known_protos,
+            help='Specify protocol to use for fetch. Default: %(default)s',
+            default='https',
+        )
 
         width, _ = shutil.get_terminal_size()
         subhelp_width = width - 30
         for sub in sorted(known_subcommands):
-            s = known_subcommands[sub]()
+            m = import_module(known_subcommands[sub])
             if sub in known_network_subcommands:
-                help_text = s.parse_args(subparsers, [base_subparser, network_base_subparser])
+                help_text = m.parse_args(
+                    subparsers,
+                    [base_subparser, network_base_subparser],
+                )
             else:
-                help_text = s.parse_args(subparsers, [base_subparser])
+                help_text = m.parse_args(subparsers, [base_subparser])
             subparsers.help += '\n'
-            subparsers.help += '\n'.join(textwrap.wrap(help_text,
-                                                       subhelp_width,
-                                                       break_on_hyphens=False
-                                                      )
-                                        )
-        help_text = '\n'.join(textwrap.wrap('File specifying '
-                                            'parent-child relationship '
-                                            'overrides as:',
-                                            subhelp_width
-                                           )
-                             )
+            subparsers.help += '\n'.join(
+                textwrap.wrap(
+                    help_text,
+                    subhelp_width,
+                    break_on_hyphens=False,
+                )
+            )
+        help_text = '\n'.join(
+            textwrap.wrap(
+                "File specifying parent-child relationship overrides as:",
+                subhelp_width,
+            )
+        )
         help_text += '\n'
         help_text += '<pkgname> <child version> <publish parent version> <changelog parent version>\n'
-        help_text += '\n'.join(textwrap.wrap('with one override per '
-                                             'line.',
-                                             subhelp_width
-                                            )
-                              )
+        help_text += '\n'.join(
+            textwrap.wrap(
+                "with one override per line.",
+                subhelp_width,
+            )
+        )
         help_text += '\ndefault=%(default)s'
-        parser.add_argument('-P', '--parentfile', type=str,
-                            help=argparse.SUPPRESS,
-                            default=pkg_resources.resource_filename(
-                                'gitubuntu',
-                                'parent_overrides.txt'
-                                                                   )
-                           )
-        help_text = '\n'.join(textwrap.wrap('File specifying source '
-                                            'files to use instead of '
-                                            'Launchpad to work around '
-                                            'source file shadowing: ',
-                                            subhelp_width
-                                           )
-                             )
+        parser.add_argument(
+            '-P', '--parentfile',
+            type=str,
+            help=argparse.SUPPRESS,
+            default=pkg_resources.resource_filename(
+                'gitubuntu',
+                'parent_overrides.txt',
+            ),
+        )
+        help_text = '\n'.join(
+            textwrap.wrap(
+                "File specifying source files to use instead of "
+                "Launchpad to work around source file shadowing: ",
+                subhelp_width,
+            )
+        )
         help_text += '\n'
         help_text += '<pkgname> <version> <URL of DSC file> <URLs of orig files>\n'
-        help_text += '\n'.join(textwrap.wrap('with one package per line. '
-                                             '\'-\' for the DSC file '
-                                             'indicates to use the one '
-                                             'from Launchpad.'
-                                            )
-                              )
+        help_text += '\n'.join(
+            textwrap.wrap(
+                "with one package per line. '-' for the DSC file "
+                "indicates to use the one from Launchpad.",
+                subhelp_width,
+            )
+        )
         help_text += '\ndefault=%(default)s'
-        parser.add_argument('-L', '--pullfile', type=str,
-                            help=argparse.SUPPRESS,
-                            default=pkg_resources.resource_filename(
-                                'gitubuntu',
-                                'pull_overrides.txt'
-                                                                   )
-                           )
+        parser.add_argument(
+            '-L', '--pullfile',
+            type=str,
+            help=argparse.SUPPRESS,
+            default=pkg_resources.resource_filename(
+                'gitubuntu',
+                'pull_overrides.txt',
+            ),
+        )
 
         argcomplete.autocomplete(parser)
         args = parser.parse_args()
@@ -161,22 +174,22 @@ def main():
         # fragile, assumes developers will pass the base_subparser above
         # should make this structural in the classes
         if args.verbose:
-            logging.basicConfig(level=logging.DEBUG,
-                                format='%(asctime)s - %(levelname)s:%(message)s',
-                                datefmt='%m/%d/%Y %H:%M:%S',
-                               )
+            level=logging.DEBUG
         else:
-            logging.basicConfig(level=logging.INFO,
-                                format='%(asctime)s - %(levelname)s:%(message)s',
-                                datefmt='%m/%d/%Y %H:%M:%S',
-                               )
+            level=logging.INFO
+        logging.basicConfig(
+            level=level,
+            format='%(asctime)s - %(levelname)s:%(message)s',
+            datefmt='%m/%d/%Y %H:%M:%S',
+        )
         if args.subcommand in known_network_subcommands:
             try:
                 retry_backoffs = args.retry_backoffs
                 if len(retry_backoffs) != args.retries:
-                    logging.error('Number of backoffs specified in '
-                                  '--retry-backoffs must match --retries.'
-                                 )
+                    logging.error(
+                        "Number of backoffs specified in "
+                        "--retry-backoffs must match --retries."
+                    )
                     sys.exit(1)
             except AttributeError:
                 args.retry_backoffs = [2 ** i for i in range(args.retries)]
@@ -188,26 +201,30 @@ def main():
             )
         except CalledProcessError:
             if isatty(sys.stdin.fileno()):
-                user = input("gitubuntu.lpuser is not set. What is your "
+                user = input(
+                    "gitubuntu.lpuser is not set. What is your "
                     "Launchpad username? We will set this in your "
                     "personally global git configuration for you. "
                     "To abort, press Enter.\nUsername: "
                 )
                 if len(user) == 0:
-                    logging.error('git-ubuntu requires a launchpad user')
+                    logging.error("git-ubuntu requires a launchpad user")
                     sys.exit(1)
                 else:
-                    logging.warning('Setting the Launchpad user for '
-                                    'git-ubuntu to %s with '
-                                    '`git config --global gitubuntu.lpuser %s`.',
-                                    user, user)
+                    logging.warning(
+                        "Setting the Launchpad user for git-ubuntu to %s "
+                        "with `git config --global gitubuntu.lpuser %s`.",
+                        user,
+                        user,
+                    )
                     run(['git', 'config', '--global', 'gitubuntu.lpuser', user])
             else:
-                logging.error('Not connected to a TTY and no '
-                              'git-ubuntu lpuser defined. Please run '
-                              '`git config --global gitubuntu.lpuser '
-                              '<Launchpad username>` and re-run this '
-                              'command.')
+                logging.error(
+                    "Not connected to a TTY and no git-ubuntu lpuser "
+                    "defined. Please run `git config --global "
+                    "gitubuntu.lpuser <Launchpad username>` and re-run "
+                    "this command."
+                )
                 sys.exit(1)
 
         args.func(args)
diff --git a/gitubuntu/build.py b/gitubuntu/build.py
index 8143995..d3d292e 100644
--- a/gitubuntu/build.py
+++ b/gitubuntu/build.py
@@ -38,12 +38,11 @@ from gitubuntu.run import run, runq
 from gitubuntu.source_information import (
     GitUbuntuSourceInformation,
     NoPublicationHistoryException,
+    derive_source_from_series,
 )
 try:
     pkg = 'python3-debian'
     from debian.debfile import PART_EXTS
-    pkg = 'python3-distro-info'
-    from distro_info import DebianDistroInfo, UbuntuDistroInfo
     pkg = 'python3-pytest'
     import pytest
 except ImportError:
@@ -228,8 +227,7 @@ def fetch_orig_from_cache(changelog, source, dl_cache=None):
         return None
     if dsc.verify() is None:
         logging.warn(
-            "Cache dir found, but verification of orig tarball %s failed.",
-            orig,
+            "Cache dir found, but verification of orig tarball(s) failed."
         )
         return None  # XXX decide - see docstring
     _symlink_paths_into_parent_dir(dsc.all_tarball_paths)
@@ -320,8 +318,8 @@ def fetch_orig_from_launchpad(changelog, source, pullfile, retries,
     except NoPublicationHistoryException:
         logging.warning(
             "No publication history found for %s in %s. ",
-            pkgname,
-            dist_name,
+            changelog.srcpkg,
+            source,
         )
         return None
 
@@ -374,151 +372,156 @@ def fetch_orig_from_launchpad(changelog, source, pullfile, retries,
     return None
 
 
-class GitUbuntuBuild:
-    def parse_args(self, subparsers=None, base_subparsers=None):
-        kwargs = dict(
-            description='Build a git-ubuntu-cloned tree with dpkg-buildpackage',
-            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-            usage='%(prog)s [options] -- ...',
-            epilog='Any arguments after -- are passed to dpkg-buildpackage.'
-                     )
-        if base_subparsers:
-            kwargs['parents'] = base_subparsers
-        if subparsers:
-            parser = subparsers.add_parser('build', **kwargs)
-            parser.set_defaults(func=self.main)
-        else:
-            parser = argparse.ArgumentParser(**kwargs)
-        parser.add_argument('--dl-cache', type=str,
-            help='Cache directory for downloads.',
-            default=os.path.join(os.getcwd(), '.git', CACHE_PATH),
-        )
-        parser.add_argument(
-            '--for-merge',
-            action='store_true',
-            help="Build an Ubuntu merge. Implies searching Debian for "
-                "published versions first.",
+def check_repository():
+    try:
+        cp = run(['git', 'status', '--porcelain'])
+    except CalledProcessError:
+        logging.error('Is the current directory a git repository?')
+        sys.exit(1)
+
+    if len(cp.stdout) > 0:
+        logging.warning(
+            "Working tree is not clean. `git status` output follows."
         )
-        parser.add_argument(
-            '--no-pristine-tar',
-            action='store_true',
-            help="Do not use pristine-tar branches to generate orig "
-                "tarballs. This can be necessary as we stabilize the pristine-tar "
-                "data generation, particularly if multiple component tarballs are "
-                "present.",
+        run(['git', 'status'], stdout=None)
+        sys.exit(1)
 
+    if not os.path.isfile('debian/changelog'):
+        logging.error(
+            "No debian/changelog found, is this a source "
+            "package repository? See `git ubuntu clone`."
         )
-        parser.add_argument('rem_args', help=argparse.SUPPRESS,
-                            nargs=argparse.REMAINDER)
-        if not subparsers:
-            return parser.parse_args()
-        return 'build - %s' % kwargs['description']
+        sys.exit(1)
 
-    def check_repository(self):
-        try:
-            cp = run(['git', 'status', '--porcelain'])
-        except CalledProcessError:
-            logging.error('Is the current directory a git repository?')
-            sys.exit(1)
 
-        if len(cp.stdout) > 0:
-            logging.warning(
-                "Working tree is not clean. `git status` output follows."
-            )
-            run(['git', 'status'], stdout=None)
-            sys.exit(1)
+def main(search_list, changelog, rem_args):
+    """main entry point for build
 
-        if not os.path.isfile('debian/changelog'):
-            logging.error(
-                "No debian/changelog found, is this a source "
-                "package repository? See `git ubuntu clone`."
-            )
-            sys.exit(1)
+    @param search_list: list of OrigSearchListEntry namedtuples
+    @param changelog: gitubuntu.git_repository.Changelog object for source package to build
+    @param rem_args: namespace object of remaining arguments to pass onto dpkg-buildpackage
+    """
+    check_repository()
+
+    fetch_orig_and_build(search_list, changelog, rem_args)
+
+
+def parse_args(subparsers=None, base_subparsers=None):
+    kwargs = dict(
+        description='Build a git-ubuntu-cloned tree with dpkg-buildpackage',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        usage='%(prog)s [options] -- ...',
+        epilog='Any arguments after -- are passed to dpkg-buildpackage.'
+                 )
+    if base_subparsers:
+        kwargs['parents'] = base_subparsers
+    if subparsers:
+        parser = subparsers.add_parser('build', **kwargs)
+        parser.set_defaults(func=cli_main)
+    else:
+        parser = argparse.ArgumentParser(**kwargs)
+    parser.add_argument('--dl-cache', type=str,
+        help='Cache directory for downloads.',
+        default=os.path.join(os.getcwd(), '.git', CACHE_PATH),
+    )
+    parser.add_argument(
+        '--for-merge',
+        action='store_true',
+        help="Build an Ubuntu merge. Implies searching Debian for "
+            "published versions first.",
+    )
+    parser.add_argument(
+        '--no-pristine-tar',
+        action='store_true',
+        help="Do not use pristine-tar branches to generate orig "
+            "tarballs. This can be necessary as we stabilize the pristine-tar "
+            "data generation, particularly if multiple component tarballs are "
+            "present.",
 
-    def derive_orig_search_list_from_args(self, args):
-        source = 'debian' if args.for_merge else 'ubuntu'
-        orig_search_list = [
-            OrigSearchListEntry(
-                mechanism=fetch_orig_from_parent_dir,
-                source=None,
-                must_build=True,
-            ),
-            OrigSearchListEntry(
-                mechanism=fetch_orig_from_cache,
-                source=source,
-                must_build=True,
-            ),
-        ]
-        if not args.no_pristine_tar:
-            orig_search_list.append(
-                OrigSearchListEntry(
-                    mechanism=functools.partial(fetch_orig_from_pristine_tar,
-                        repo=self.local_repo,
-                    ),
-                    source=source,
-                    must_build=True,
-                )
-            )
-        orig_search_list.extend([
+    )
+    parser.add_argument('rem_args', help=argparse.SUPPRESS,
+                        nargs=argparse.REMAINDER)
+    if not subparsers:
+        return parser.parse_args()
+    return 'build - %s' % kwargs['description']
+
+
+def derive_orig_search_list_from_args(args):
+    source = 'debian' if args.for_merge else 'ubuntu'
+    orig_search_list = [
+        OrigSearchListEntry(
+            mechanism=fetch_orig_from_parent_dir,
+            source=None,
+            must_build=True,
+        ),
+        OrigSearchListEntry(
+            mechanism=fetch_orig_from_cache,
+            source=source,
+            must_build=True,
+        ),
+    ]
+    if not args.no_pristine_tar:
+        orig_search_list.append(
             OrigSearchListEntry(
-                mechanism=functools.partial(fetch_orig_from_launchpad,
-                    pullfile=args.pullfile,
-                    retries=args.retries,
-                    retry_backoffs=args.retry_backoffs,
-                    dl_cache=args.dl_cache,
+                mechanism=functools.partial(fetch_orig_from_pristine_tar,
+                    repo=GitUbuntuRepository('.'),
                 ),
                 source=source,
                 must_build=True,
+            )
+        )
+    orig_search_list.extend([
+        OrigSearchListEntry(
+            mechanism=functools.partial(fetch_orig_from_launchpad,
+                pullfile=args.pullfile,
+                retries=args.retries,
+                retry_backoffs=args.retry_backoffs,
+                dl_cache=args.dl_cache,
             ),
-            OrigSearchListEntry(
-                mechanism=fetch_orig_noop,
-                source=[],
-                must_build=True,
-            ),
-        ])
+            source=source,
+            must_build=True,
+        ),
+        OrigSearchListEntry(
+            mechanism=fetch_orig_noop,
+            source=[],
+            must_build=True,
+        ),
+    ])
 
-        return orig_search_list
+    return orig_search_list
 
 
-    def main(self, args):
-        rem_args = args.rem_args
-        if len(rem_args) > 0:
-            rem_args = rem_args[1:]
+def cli_main(args):
+    rem_args = args.rem_args
+    if len(rem_args) > 0:
+        rem_args = rem_args[1:]
 
-        self.check_repository()
-        self.local_repo = GitUbuntuRepository('.')
+    changelog = Changelog.from_path('debian/changelog')
 
-        changelog = Changelog.from_path('debian/changelog')
+    try:
+        native = is_native_package(changelog)
+    except NativenessMismatchError as e:
+        logging.error("%s" % e)
+        sys.exit(1)
 
-        try:
-            native = is_native_package(changelog)
-        except NativenessMismatchError as e:
-            logging.error("%s" % e)
-            sys.exit(1)
-
-        if native:
-            # No orig tarball required
-            orig_search_list = [
-                OrigSearchListEntry(
-                    mechanism=fetch_orig_noop,
-                    source=[],
-                    must_build=True,
-                ),
-            ]
-        else:
-            orig_search_list = self.derive_orig_search_list_from_args(args)
+    if native:
+        # No orig tarball required
+        orig_search_list = [
+            OrigSearchListEntry(
+                mechanism=fetch_orig_noop,
+                source=[],
+                must_build=True,
+            ),
+        ]
+    else:
+        orig_search_list = derive_orig_search_list_from_args(args)
 
-        # See http://pad.ubuntu.com/KKB1kMR0JH for logic
-        fetch_orig_and_build(orig_search_list, changelog, rem_args)
+    # See http://pad.ubuntu.com/KKB1kMR0JH for logic
+    main(orig_search_list, changelog, rem_args)
 
 
 def derive_source_from_changelog(changelog):
-    series = changelog.distribution
-    if DebianDistroInfo().valid(codename=series):
-        return 'debian'
-    if UbuntuDistroInfo().valid(codename=series):
-        return 'ubuntu'
-    raise ValueError("Unable to determine distribution from %s" % series)
+    return derive_source_from_series(changelog.distribution)
 
 def expand_changelog_source_aliases(orig_search_list, changelog):
     """Replace 'changelog' sources by reading debian/changelog
diff --git a/gitubuntu/buildsource.py b/gitubuntu/buildsource.py
index 4e9b69b..1735129 100644
--- a/gitubuntu/buildsource.py
+++ b/gitubuntu/buildsource.py
@@ -5,66 +5,62 @@ import argparse
 import logging
 import os
 import sys
-from gitubuntu.build import GitUbuntuBuild
+from gitubuntu.build import cli_main as build_cli_main
 from gitubuntu.cache import CACHE_PATH
 
-class GitUbuntuBuildSource(GitUbuntuBuild):
-    def __init__(self):
-        super().__init__()
+def parse_args(subparsers=None, base_subparsers=None):
+    kwargs = dict(
+        description="Build a source package and changes file",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+                 )
+    if base_subparsers:
+        kwargs['parents'] = base_subparsers
+    if subparsers:
+        parser = subparsers.add_parser('build-source', **kwargs)
+        help_text = "build-source - Build a source package"
+        parser.set_defaults(func=cli_main)
+    else:
+        parser = argparse.ArgumentParser(**kwargs)
+    parser.add_argument('--dl-cache', type=str,
+        help=("Cache directory for downloads."),
+        default=os.path.join(os.getcwd(), '.git', CACHE_PATH),
+    )
+    parser.add_argument('--sign', action='store_true',
+        help="Sign the source package.",
+    )
+    parser.add_argument('--for-merge', action='store_true',
+        help=("Build an Ubuntu merge. Implies searching Debian for "
+            "published versions first and passing -sa to "
+            "dpkg-buildpackage."
+        ),
+    )
+    parser.add_argument(
+        '--no-pristine-tar',
+        action='store_true',
+        help="Do not use pristine-tar branches to generate orig "
+            "tarballs. This can be necessary as we stabilize the pristine-tar "
+            "data generation, particularly if multiple component tarballs are "
+            "present.",
 
-    def parse_args(self, subparsers=None, base_subparsers=None):
-        kwargs = dict(
-            description="Build a source package and changes file",
-            formatter_class=argparse.ArgumentDefaultsHelpFormatter
-                     )
-        if base_subparsers:
-            kwargs['parents'] = base_subparsers
-        if subparsers:
-            parser = subparsers.add_parser('build-source', **kwargs)
-            help_text = "build-source - Build a source package"
-            parser.set_defaults(func=self.main)
-        else:
-            parser = argparse.ArgumentParser(**kwargs)
-        parser.add_argument('--dl-cache', type=str,
-            help=("Cache directory for downloads."),
-            default=os.path.join(os.getcwd(), '.git', CACHE_PATH),
-        )
-        parser.add_argument('--sign', action='store_true',
-            help="Sign the source package.",
-        )
-        parser.add_argument('--for-merge', action='store_true',
-            help=("Build an Ubuntu merge. Implies searching Debian for "
-                "published versions first and passing -sa to "
-                "dpkg-buildpackage."
-            ),
-        )
-        parser.add_argument(
-            '--no-pristine-tar',
-            action='store_true',
-            help="Do not use pristine-tar branches to generate orig "
-                "tarballs. This can be necessary as we stabilize the pristine-tar "
-                "data generation, particularly if multiple component tarballs are "
-                "present.",
+    )
+    parser.add_argument('rem_args', help=argparse.SUPPRESS,
+        nargs=argparse.REMAINDER
+    )
+    if not subparsers:
+        return parser.parse_args()
+    return "build-source - %s" % kwargs['description']
 
-        )
-        parser.add_argument('rem_args', help=argparse.SUPPRESS,
-            nargs=argparse.REMAINDER
-        )
-        if not subparsers:
-            return parser.parse_args()
-        return "build-source - %s" % kwargs['description']
-
-    def main(self, args):
-        if len(args.rem_args) != 0:
-            logging.warning('Passing specified flags (%s) on to '
-                            'dpkg-buildpackage. Did you mean to '
-                            'call `git ubuntu build` instead?' %
-                            ' '.join(args.rem_args)
-                           )
-        else:
-            args.rem_args = ['--', '-S', '-nc', '-d', '-i', '-I']
-            if args.for_merge:
-                args.rem_args += ['-sa']
-            if not args.sign:
-                args.rem_args += ['-us', '-uc']
-        super().main(args)
+def cli_main(args):
+    if len(args.rem_args) != 0:
+        logging.warning('Passing specified flags (%s) on to '
+                        'dpkg-buildpackage. Did you mean to '
+                        'call `git ubuntu build` instead?' %
+                        ' '.join(args.rem_args)
+                       )
+    else:
+        args.rem_args = ['--', '-S', '-nc', '-d', '-i', '-I']
+        if args.for_merge:
+            args.rem_args += ['-sa']
+        if not args.sign:
+            args.rem_args += ['-us', '-uc']
+    build_cli_main(args)
diff --git a/gitubuntu/clone.py b/gitubuntu/clone.py
index a1bc8cb..e2dcedf 100644
--- a/gitubuntu/clone.py
+++ b/gitubuntu/clone.py
@@ -18,12 +18,80 @@ except ImportError:
     logging.error('Is %s installed?', pkg)
     sys.exit(1)
 
-class GitUbuntuClone:
-    def parse_args(self, subparsers=None, base_subparsers=None):
-        kwargs = dict(
-            description='Clone a source package git repository to a directory',
-            formatter_class=argparse.RawTextHelpFormatter,
-            epilog='''
+def copy_hooks(src, dst):
+    try:
+        os.mkdir(dst)
+    except FileExistsError:
+        pass
+
+    for hook in os.listdir(src):
+        shutil.copy2(
+            os.path.join(src, hook),
+            dst,
+        )
+
+def main(directory, lp_user, proto, package):
+    if os.path.isdir(directory):
+        logging.error('directory %s exists' % directory)
+        sys.exit(1)
+
+    local_repo = GitUbuntuRepository(
+        local_dir=directory,
+        lp_user=lp_user,
+        fetch_proto=proto,
+    )
+
+    copy_hooks(
+        os.path.join(os.path.dirname(__file__), os.path.pardir, 'hooks'),
+        os.path.join(directory, '.git', 'hooks')
+    )
+
+    try:
+        local_repo.add_base_remotes(package)
+        local_repo.fetch_base_remotes(verbose=True)
+    except GitUbuntuRepositoryFetchError:
+        logging.error("Unable to find an imported repository for %s. "
+            "Please request an import by e-mailing "
+            "[e-mail].",
+            package
+        )
+        shutil.rmtree(local_repo.local_dir)
+        raise
+
+    try:
+        local_repo.add_lpuser_remote(pkgname=package)
+        local_repo.fetch_lpuser_remote(verbose=True)
+
+        logging.debug("added remote '%s' -> %s", local_repo.lp_user,
+            local_repo.raw_repo.remotes[local_repo.lp_user].url
+        )
+    except GitUbuntuRepositoryFetchError:
+        pass
+
+    try:
+        local_repo.create_tracking_branch(
+            'ubuntu/devel',
+            'pkg/ubuntu/devel'
+        )
+        local_repo.checkout_commitish('ubuntu/devel')
+    except:
+        logging.error('Unable to checkout ubuntu/devel, does '
+            'pkg/ubuntu/devel branch exist?'
+        )
+
+    if os.path.isfile(os.path.join(directory, '.gitignore')):
+        logging.warning('A .gitignore file exists in the source '
+            'package. This will affect the behavior of git. Consider '
+            'backing up the gitignore while working on this package '
+            'to ensure all changes are tracked or passing appropriate '
+            'flags to git commands (e.g., git status --ignored).'
+        )
+
+def parse_args(subparsers=None, base_subparsers=None):
+    kwargs = dict(
+        description='Clone a source package git repository to a directory',
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog='''
 Example:
    * clone to open-iscsi/
      %(prog)s open-iscsi
@@ -32,107 +100,41 @@ Example:
    * use https rather than git protocol for read-only remotes:
      %(prog)s --https open-iscsi
 '''
-                     )
-        if base_subparsers:
-            kwargs['parents'] = base_subparsers
-        if subparsers:
-            parser = subparsers.add_parser('clone', **kwargs)
-            parser.set_defaults(func=self.main)
-        else:
-            parser = argparse.ArgumentParser(**kwargs)
-        parser.add_argument('package', type=str,
-            help='Name of source package to clone'
-        )
-        parser.add_argument('directory', type=str,
-            help='Local directory to clone to. If not specified, a '
-                 ' directory with the same name as PACKAGE will be '
-                 'used',
-            default=None,
-            nargs='?'
-        )
-        parser.add_argument('-l', '--lp-user', type=str, help=argparse.SUPPRESS)
-        if not subparsers:
-            return parser.parse_args()
-        return 'clone - %s' % kwargs['description']
-
-    @staticmethod
-    def copy_hooks(src, dst):
-        try:
-            os.mkdir(dst)
-        except FileExistsError:
-            pass
-
-        for hook in os.listdir(src):
-            shutil.copy2(
-                os.path.join(src, hook),
-                dst,
-            )
-
-    def main(self, args):
-        try:
-            lp_user = args.lp_user
-        except AttributeError:
-            lp_user = None
-        directory = (
-            os.path.abspath(args.directory)
-            if args.directory
-            else os.path.join(os.path.abspath(os.getcwd()), args.package)
-        )
+                 )
+    if base_subparsers:
+        kwargs['parents'] = base_subparsers
+    if subparsers:
+        parser = subparsers.add_parser('clone', **kwargs)
+        parser.set_defaults(func=cli_main)
+    else:
+        parser = argparse.ArgumentParser(**kwargs)
+    parser.add_argument('package', type=str,
+        help='Name of source package to clone'
+    )
+    parser.add_argument('directory', type=str,
+        help='Local directory to clone to. If not specified, a '
+             ' directory with the same name as PACKAGE will be '
+             'used',
+        default=None,
+        nargs='?'
+    )
+    parser.add_argument('-l', '--lp-user', type=str, help=argparse.SUPPRESS)
+    if not subparsers:
+        return parser.parse_args()
+    return 'clone - %s' % kwargs['description']
 
-        if os.path.isdir(directory):
-            logging.error('directory %s exists' % directory)
-            sys.exit(1)
+def cli_main(args):
+    try:
+        lp_user = args.lp_user
+    except AttributeError:
+        lp_user = None
+    directory = (
+        os.path.abspath(args.directory)
+        if args.directory
+        else os.path.join(os.path.abspath(os.getcwd()), args.package)
+    )
 
-        local_repo = GitUbuntuRepository(
-            local_dir=directory,
-            lp_user=lp_user,
-            fetch_proto=args.proto,
-        )
-
-        self.copy_hooks(
-            os.path.join(os.path.dirname(__file__), os.path.pardir, 'hooks'),
-            os.path.join(directory, '.git', 'hooks')
-        )
+    main(directory, lp_user, args.proto, args.package)
 
-        try:
-            local_repo.add_base_remotes(args.package)
-            local_repo.fetch_base_remotes(verbose=True)
-        except GitUbuntuRepositoryFetchError:
-            logging.error("Unable to find an imported repository for %s. "
-                "Please request an import by e-mailing "
-                "[e-mail].",
-                args.package
-            )
-            shutil.rmtree(local_repo.local_dir)
-            raise
-
-        try:
-            local_repo.add_lpuser_remote(pkgname=args.package)
-            local_repo.fetch_lpuser_remote(verbose=True)
-
-            logging.debug("added remote '%s' -> %s", local_repo.lp_user,
-                local_repo.raw_repo.remotes[local_repo.lp_user].url
-            )
-        except GitUbuntuRepositoryFetchError:
-            pass
-
-        try:
-            local_repo.create_tracking_branch(
-                'ubuntu/devel',
-                'pkg/ubuntu/devel'
-            )
-            local_repo.checkout_commitish('ubuntu/devel')
-        except:
-            logging.error('Unable to checkout ubuntu/devel, does '
-                'pkg/ubuntu/devel branch exist?'
-            )
-
-        if os.path.isfile(os.path.join(directory, '.gitignore')):
-            logging.warning('A .gitignore file exists in the source '
-                'package. This will affect the behavior of git. Consider '
-                'backing up the gitignore while working on this package '
-                'to ensure all changes are tracked or passing appropriate '
-                'flags to git commands (e.g., git status --ignored).'
-            )
 
 # vi: ts=4 expandtab
diff --git a/gitubuntu/importer.py b/gitubuntu/importer.py
index 22fd08a..4a67729 100644
--- a/gitubuntu/importer.py
+++ b/gitubuntu/importer.py
@@ -26,6 +26,7 @@
 
 import argparse
 import atexit
+import functools
 import getpass
 import logging
 import os
@@ -50,7 +51,12 @@ from gitubuntu.git_repository import (
     PristineTarError,
 )
 from gitubuntu.run import decode_binary, run, runq
-from gitubuntu.source_information import GitUbuntuSourceInformation, NoPublicationHistoryException, SourceExtractionException, launchpad_login_auth
+from gitubuntu.source_information import (
+    GitUbuntuSourceInformation,
+    NoPublicationHistoryException,
+    SourceExtractionException,
+    launchpad_login_auth,
+)
 from gitubuntu.version import VERSION
 from gitubuntu.versioning import version_compare
 try:
@@ -86,16 +92,18 @@ def dsc_to_tree_hash(repo, dsc_path):
         # extracted_dir.
 
         extracted_dir = os.path.join(temp_dir, 'x')
-        run(['dpkg-source',
-             '-x',
-             '--skip-patches',
-             dsc_path,
-             extracted_dir,  # this is <temp_dir>/x
+        run(
+            [
+                'dpkg-source',
+                '-x',
+                '--skip-patches',
+                dsc_path,
+                extracted_dir,  # this is <temp_dir>/x
             ]
-           )
+        )
 
         if not os.path.exists(extracted_dir):
-            logging.exception('No source extracted?')
+            logging.error("No source extracted?")
             raise SourceExtractionException(
                 "Failed to find an extracted directory from "
                 "dpkg-source -x"
@@ -104,1258 +112,1462 @@ def dsc_to_tree_hash(repo, dsc_path):
         return repo.dir_to_tree(extracted_dir)
 
 
-class GitUbuntuImport:
-    def __init__(self):
-        self.parent_overrides = None
-
-    def parse_args(self, subparsers=None, base_subparsers=None):
-        kwargs = dict(description='Update a launchpad git tree based upon '
-                                  'the state of the Ubuntu and Debian archives',
-                      formatter_class=argparse.ArgumentDefaultsHelpFormatter
-                     )
-        if base_subparsers:
-            kwargs['parents'] = base_subparsers
-        if subparsers:
-            parser = subparsers.add_parser('import', **kwargs)
-            parser.set_defaults(func=self.main)
-        else:
-            parser = argparse.ArgumentParser(**kwargs)
-        parser.add_argument('package', type=str,
-                            help='Which package to update in the git tree')
-        parser.add_argument('-o', '--lp-owner', type=str,
-                            help=argparse.SUPPRESS,
-                            default='usd-import-team')
-        parser.add_argument('-l', '--lp-user', type=str,
-                            help=argparse.SUPPRESS)
-        parser.add_argument('--dl-cache', type=str,
-                            help=('Cache directory for downloads. Default is to '
-                                  'put downloads in <directory>/.git/%s' %
-                                  CACHE_PATH
-                                 ),
-                            default=argparse.SUPPRESS)
-        parser.add_argument('--no-fetch', action='store_true',
-                            help='Do not fetch from the remote (DANGEROUS; '
-                                 'only useful for debugging); implies '
-                                 '--no-push')
-        parser.add_argument('--no-push', action='store_true',
-                            help='Do not push to the remote')
-        parser.add_argument('--no-clean', action='store_true',
-                            help='Do not clean the temporary directory')
-        parser.add_argument('-d', '--directory', type=str,
-                            help='Use git repository at specified location rather '
-                                 'than a temporary directory (implies --no-clean). '
-                                 'Will create the local repository if needed.',
-                            default=argparse.SUPPRESS
-                           )
-        parser.add_argument('--fixup-devel', action='store_true',
-                            help=argparse.SUPPRESS)
-        parser.add_argument('--active-series-only', action='store_true',
-                            help='Do an import of only active Ubuntu series '
-                                 'history, implies --no-push.')
-        parser.add_argument('--skip-applied', action='store_true',
-                            help=argparse.SUPPRESS)
-        parser.add_argument('--skip-orig', action='store_true',
-                            help=argparse.SUPPRESS)
-        parser.add_argument('--reimport', action='store_true',
-                            help=argparse.SUPPRESS)
-        if not subparsers:
-            return parser.parse_args()
-        return 'import - %s' % kwargs['description']
-
-    def cleanup(self, no_clean, local_dir):
-        """Recursively remove local_dir if no_clean is not True"""
-        if not no_clean:
-            shutil.rmtree(local_dir)
-        else:
-            logging.info('Leaving %s as directed' % local_dir)
-
-    def get_changelog_for_commit(self, tree_hash, publish_parent_commit, changelog_parent_commit):
-        """Extract changes to debian/changelog in this publish
-
-        LP: #1633114 -- favor the changelog parent's diff
-        """
-        raw_clog_entry = b''
-        if changelog_parent_commit is not None:
-            cmd = ['diff-tree', '-p', changelog_parent_commit,
-                   tree_hash, '--', 'debian/changelog']
-            raw_clog_entry = self.local_repo.git_run(cmd).stdout
-        elif publish_parent_commit is not None:
-            cmd = ['diff-tree', '-p', publish_parent_commit,
-                    tree_hash, '--', 'debian/changelog']
-            raw_clog_entry = self.local_repo.git_run(cmd).stdout
-
-        changelog_entry = b''
-        changelog_entry_found = False
-        i = 0
-        for line in raw_clog_entry.split(b'\n'):
-            # skip the header lines
-            if i < 4:
-                i += 1
-                continue
-            if not line.startswith(b'+'):
-                # in case there are stray changelog changes, just take
-                # the first complete section of changelog additions
-                if changelog_entry_found:
-                    break
-                continue
-            line = re.sub(b'^[+]', b'', line)
-            if not line.startswith(b'  '):
-                continue
-            if not changelog_entry_found:
-                changelog_entry = b'\n\nNew changelog entries:\n'
-            changelog_entry += line + b'\n'
-            changelog_entry_found = True
-        return changelog_entry
-
-    def _commit_import(self, spi, tree_hash, publish_parent_commit, changelog_parent_commit, upload_parent_commit, unapplied_parent_commit):
-        """Commit a tree object into the repository with the specified
-        parents
-
-        The importer algorithm works by 'staging' the import of a
-        publication as a tree, then using that tree to determine the
-        appropriate parents from the publishing history and
-        debian/changelog.
-
-        Arguments:
-        spi - A SourcePackageInformation instance for this publish
-        tree_hash - SHA1 from git-dsc-commit --tree-only of this publish
-        publish_parent_commit = SHA1 of publishing parent
-        changelog_parent_commit = SHA1 of changelog parent
-        upload_parent_commit = SHA1 of upload parent
-        unapplied_parent_commit = SHA1 of unapplied-patches import parent
-        """
-        tag = None
-
-        if unapplied_parent_commit:
-            import_type = 'patches-applied'
-            target_head_name = spi.applied_head_name(self.namespace)
-            if self.local_repo.get_applied_tag(spi.version, self.namespace) is None:
-                # Not imported before
-                tag = applied_tag(spi.version, self.namespace)
-        else:
-            import_type = 'patches-unapplied'
-            target_head_name = spi.head_name(self.namespace)
-            if self.local_repo.get_import_tag(spi.version, self.namespace) is None:
-                # Not imported before
-                tag = import_tag(spi.version, self.namespace)
-
-        # Do not show importer/ namespace to user
-        _, _, pretty_head_name = target_head_name.partition('%s/' % self.namespace)
-
-        changelog_entry = self.get_changelog_for_commit(
-                              tree_hash,
-                              publish_parent_commit,
-                              changelog_parent_commit
-                                                       )
-        msg = (b'Import %s version %b to %b\n\nImported using git-ubuntu import.' %
-               (import_type.encode(), spi.version.encode(), pretty_head_name.encode())
-              )
-
-        parents = []
-
-        if publish_parent_commit is None and \
-            changelog_parent_commit is None and \
-            upload_parent_commit is None and \
-            unapplied_parent_commit is None and \
-            target_head_name in self.local_repo.local_branch_names:
-            # No parents and not creating a new branch
-            tag = orphan_tag(spi.version, self.namespace)
-        else:
-            msg += b'\n'
-
-        if publish_parent_commit is not None:
-            parents.append(publish_parent_commit)
-            msg += b'\nPublish parent: %b' % publish_parent_commit.encode()
-        if changelog_parent_commit is not None:
-            parents.append(changelog_parent_commit)
-            msg += b'\nChangelog parent: %b' % changelog_parent_commit.encode()
-        if upload_parent_commit is not None:
-            parents.append(upload_parent_commit)
-            msg += b'\nUpload parent: %b' % upload_parent_commit.encode()
-        if unapplied_parent_commit is not None:
-            parents.append(unapplied_parent_commit)
-            msg += b'\nUnapplied parent: %b' % unapplied_parent_commit.encode()
-
-        msg += b'%b' % changelog_entry
-
-        commit_hash = self.local_repo.commit_tree_hash(
-            tree_hash,
-            parents,
-            msg,
-            environment_spi=spi
-        )
+def cleanup(no_clean, local_dir):
+    '''Remove a local directory, conditionally
 
-        self.local_repo.update_head_to_commit(target_head_name, commit_hash)
+    no_clean: if True, do not remove @local_dir and print a message instead
+    local_dir: directory to remove
+    '''
+    if not no_clean:
+        shutil.rmtree(local_dir)
+    else:
+        logging.info('Leaving %s as directed' % local_dir)
 
-        logging.debug('Committed %s import of %s as %s in %s',
-                     import_type, spi.version, commit_hash, pretty_head_name
-                    )
 
-        if tag is not None:
-            # should be annotated to use create_tag API
-            logging.debug('Creating tag %s pointing to %s', tag, commit_hash)
-            self.local_repo.git_run(['tag', '-a', '-m', 'git-ubuntu import v%s' % VERSION,
-                          tag, commit_hash
-                         ]
-                        )
+# XXX: need a namedtuple to hold common arguments
+def main(pkgname, owner, no_clean, directory, user, proto, no_fetch,
+    no_push, dl_cache, fixup_devel, active_series_only, skip_orig,
+    pullfile, parentfile, retries, retry_backoffs, skip_applied,
+    reimport,
+):
+    if owner == 'usd-import-team':
+        namespace = 'importer'
+    else:
+        namespace = owner
 
-    def commit_unapplied_patches_import(self, spi, import_tree_hash, publish_parent_commit, changelog_parent_commit, upload_parent_commit):
-        self._commit_import(
-            spi,
-            import_tree_hash,
-            publish_parent_commit,
-            changelog_parent_commit,
-            upload_parent_commit,
-            # unapplied trees do not have a distinct unapplied parent
-            None
-                          )
+    logging.info('Ubuntu Server Team importer v%s' % VERSION)
 
-    def commit_applied_patches_import(self, spi, import_tree_hash, publish_parent_commit, changelog_parent_commit, unapplied_parent_commit):
-        self._commit_import(
-           spi,
-           import_tree_hash,
-           publish_parent_commit,
-           changelog_parent_commit,
-           # uploads will be unapplied trees currently, so applied trees
-           # can not have them as direct parents
-           None,
-           unapplied_parent_commit
-                           )
+    repo = GitUbuntuRepository(directory, user, proto)
+    if not directory:
+        logging.info('Using git repository at %s', repo.local_dir)
+
+    atexit.register(cleanup, no_clean, repo.local_dir)
 
-    def import_dsc(self, dsc, version, dist):
-        """Imports the dsc file to importer/{debian,ubuntu}/dsc
-
-        Arguments:
-        spi - A GitUbuntuSourcePackageInformation instance
-        """
-
-        # Add DSC file to the appropriate branch
-        runq(['git', 'checkout', '%s/importer/%s/dsc' % (self.namespace, dist)], env=self.local_repo.env)
-        # It is possible the same-named DSC is published multiple times
-        # with different contents, e.g. on epoch bumps
-        local_dir = os.path.join(self.local_repo.local_dir, version)
-        os.makedirs(local_dir, exist_ok=True)
-        shutil.copy(dsc.dsc_path,
-                    local_dir)
-        self.local_repo.git_run(['add', self.local_repo.local_dir])
+    repo.add_base_remotes(pkgname, repo_owner=owner)
+    if not no_fetch and not reimport:
         try:
-            # Anything to commit? (this will be 0 if, for instance, the
-            # same dsc is being imported again)
-            runq(['git', 'diff', '--exit-code', 'HEAD'], env=self.local_repo.env)
-        except:
-            self.local_repo.git_run(['commit', '-m', 'DSC file for %s' % version])
+            repo.fetch_base_remotes()
+        except GitUbuntuRepositoryFetchError:
+            pass
 
-        self.local_repo.clean_repository_state()
+    if not no_fetch:
+        repo.delete_branches_in_namespace(namespace)
+        repo.delete_tags_in_namespace(namespace)
+        repo.copy_base_references(namespace)
 
-    def orig_imported(self, orig_tarball_paths, dist):
-        """Determines if a list of paths to tarballs have already been imported to @dist
+    if not no_fetch and not reimport:
+        try:
+            repo.fetch_remote_refspecs('pkg',
+                refspecs=['refs/tags/*:refs/tags/%s/*' % namespace],
+            )
+        except GitUbuntuRepositoryFetchError:
+            pass
 
-        Assumes that the pristine-tar branch exists
-        """
+    if reimport:
+        if no_fetch:
+            logging.warning(
+                "--reimport specified with --no-fetch. Upload "
+                "tags would not be incorporated into the new import "
+                "and would be lost forever. This is not currently "
+                "supported and --no-fetch will be ignored for upload "
+                "tags."
+            )
         try:
-            return self.local_repo.verify_pristine_tar(
-                orig_tarball_paths,
-                dist,
-                self.namespace
+            repo.fetch_remote_refspecs('pkg',
+                refspecs=['refs/tags/upload/*:refs/tags/%s/upload/*' % namespace],
             )
-        except PristineTarError as e:
-            raise GitUbuntuImportOrigError from e
+        except GitUbuntuRepositoryFetchError:
+            pass
 
-    def import_orig(self, spi):
-        """Imports the orig-tarball using gbp import-org --pristine-tar
+    repo.ensure_importer_branches_exist(namespace)
+
+    debian_sinfo = GitUbuntuSourceInformation(
+        'debian',
+        pkgname,
+        os.path.abspath(pullfile),
+        retries,
+        retry_backoffs,
+    )
+
+    ubuntu_sinfo = GitUbuntuSourceInformation(
+        'ubuntu',
+        pkgname,
+        os.path.abspath(pullfile),
+        retries,
+        retry_backoffs,
+    )
+
+    debian_head_versions = (
+        repo.get_heads_and_versions('debian', namespace)
+    )
+    for head_name in sorted(debian_head_versions):
+        _, _, pretty_head_name = head_name.partition('%s/' % namespace)
+        logging.debug('Last imported %s version is %s',
+            pretty_head_name,
+            debian_head_versions[head_name]['version']
+        )
 
-        Arguments:
-        spi - A GitUbuntuSourcePackageInformation instance
-        """
-        dsc = GitUbuntuDsc(spi.dsc_pathname)
-        upstream_version = str(spi.upstream_version)
-        version = str(spi.version)
-        dist = spi.distribution.name.lower()
+    ubuntu_head_versions = (
+        repo.get_heads_and_versions('ubuntu', namespace)
+    )
+    for head_name in sorted(ubuntu_head_versions):
+        _, _, pretty_head_name = head_name.partition('%s/' % namespace)
+        logging.debug('Last imported %s version is %s',
+            pretty_head_name,
+            ubuntu_head_versions[head_name]['version']
+        )
 
-        try:
-            orig_tarball_path = dsc.orig_tarball_path
-        except GitUbuntuDscError as e:
-            raise GitUbuntuImportOrigError(
-                'Unable to import orig tarball in DSC for version %s' % version
-            ) from e
-
-        if orig_tarball_path is None:
-            # native packages only have a .tar.*
-            native_re = re.compile(r'.*\.tar\.[^.]+$')
-            for entry in dsc['Files']:
-                if native_re.match(entry['name']):
-                    return
-            raise GitUbuntuImportOrigError('No orig tarball in '
-                'DSC for version %s.' % version)
+    if not skip_applied:
+        applied_debian_head_versions = (
+            repo.get_heads_and_versions(
+                'applied/debian', namespace
+            )
+        )
+        for head_name in sorted(applied_debian_head_versions):
+            _, _, pretty_head_name = head_name.partition(
+                '%s/' % namespace
+            )
+            logging.debug('Last applied %s version is %s',
+                pretty_head_name,
+                applied_debian_head_versions[head_name]['version']
+            )
 
-        try:
-            orig_component_paths = dsc.component_tarball_paths
-        except GitUbuntuDscError as e:
-            raise GitUbuntuImportOrigError(
-                'Unable to import component tarballs in DSC for version '
-                '%s' % version
-            ) from e
-
-        orig_paths = [orig_tarball_path] + list(orig_component_paths.values())
-        if (not orig_tarball_path or
-            self.orig_imported(orig_paths, dist)):
-            return
-        if not all(map(os.path.exists, orig_paths)):
-            raise GitUbuntuImportOrigError(
-                'Unable to find tarball: %s' %
-                [p for p in orig_paths if not os.path.exists(p)]
+        applied_ubuntu_head_versions = (
+            repo.get_heads_and_versions(
+                'applied/ubuntu', namespace
+            )
+        )
+        for head_name in sorted(applied_ubuntu_head_versions):
+            _, _, pretty_head_name = head_name.partition(
+                '%s/' % namespace
+            )
+            logging.debug('Last applied %s version is %s',
+                pretty_head_name,
+                applied_ubuntu_head_versions[head_name]['version']
             )
 
-        try:
-            with self.local_repo.pristine_tar_branches(dist, self.namespace):
-                oldcwd = os.getcwd()
-                # gbp does not support running from arbitrary git trees or
-                # working directories
-                # https://github.com/agx/git-buildpackage/pull/16
-                os.chdir(self.local_repo.local_dir)
-
-                ext = os.path.splitext(dsc.orig_tarball_path)[1]
-
-                # make this non-fatal if upstream already exist as tagged?
-                cmd = ['gbp', 'import-orig', '--no-merge',
-                     '--upstream-branch', 'do-not-push',
-                     '--pristine-tar', '--no-interactive',
-                     '--no-symlink-orig',
-                     '--upstream-tag=%s/upstream/%s/%%(version)s%s' %
-                         (self.namespace, dist, ext)]
-                cmd.extend(map(lambda x: '--component=%s' % x,
-                    list(orig_component_paths.keys()))
-                )
-                cmd.extend([orig_tarball_path,])
-                run(cmd, env=self.local_repo.env)
-        except CalledProcessError as e:
-            raise GitUbuntuImportOrigError(
-                'Unable to import tarballs: %s' % orig_paths
-            ) from e
-        finally:
-            os.chdir(oldcwd)
+    oldcwd = os.getcwd()
+    os.chdir(repo.local_dir)
+
+    if dl_cache is None:
+        workdir = os.path.join(repo.git_dir, CACHE_PATH)
+    else:
+        workdir = dl_cache
+
+    os.makedirs(workdir, exist_ok=True)
+
+    # now sets a global _PARENT_OVERRIDES
+    parse_parentfile(parentfile, pkgname)
+
+    only_debian, history_found = import_publishes(
+        repo=repo,
+        pkgname=pkgname,
+        namespace=namespace,
+        patches_applied=False,
+        debian_head_versions=debian_head_versions,
+        ubuntu_head_versions=ubuntu_head_versions,
+        debian_sinfo=debian_sinfo,
+        ubuntu_sinfo=ubuntu_sinfo,
+        active_series_only=active_series_only,
+        workdir=workdir,
+        fixup_devel=fixup_devel,
+        skip_orig=skip_orig,
+    )
+
+    if not history_found:
+        logging.error("No publication history for '%s' in debian or ubuntu. "
+                      "Wrong source package name?", pkgname)
+        sys.exit(1)
+
+    if not skip_applied:
+        import_publishes(
+            repo=repo,
+            pkgname=pkgname,
+            namespace=namespace,
+            patches_applied=True,
+            debian_head_versions=applied_debian_head_versions,
+            ubuntu_head_versions=applied_ubuntu_head_versions,
+            debian_sinfo=debian_sinfo,
+            ubuntu_sinfo=ubuntu_sinfo,
+            active_series_only=active_series_only,
+            workdir=workdir,
+            fixup_devel=fixup_devel,
+            skip_orig=skip_orig,
+        )
 
-            self.local_repo.clean_repository_state()
+    os.chdir(oldcwd)
 
-    def import_patches_unapplied_tree(self, dsc_pathname):
-        """Imports the patches-unapplied source package and writes the
-        corresponding working tree for a given srcpkg
+    repo.garbage_collect()
 
-        Arguments:
-        dsc_pathname - A string path to a DSC file
-        """
+    if no_push:
+        logging.info('Not pushing to remote as specified')
+    else:
+        lp = launchpad_login_auth()
+        repo_path = '~%s/ubuntu/+source/%s/+git/%s' % (
+            owner,
+            pkgname,
+            pkgname,
+        )
+        lp_git_repo = lp.git_repositories.getByPath(path=repo_path)
+        if reimport:
+            if not lp_git_repo.canBeDeleted():
+               logging.warning(
+                   "There are linked MPs to the pkg repository, "
+                   "which will be deleted:"
+               )
+               for mp in lp_git_repo.landing_candidates:
+                   logging.warning(
+                       "Adding comment to %s indicating reimport",
+                       mp.web_link
+                   )
+                   mp.createComment(
+                       content="%s has been reimported and this MP "
+                           "must be manually resubmitted." %
+                           pkgname,
+                       subject="%s has been reimported" % pkgname,
+                   )
+                   # repo deletion will delete the MP, but hopefully
+                   # the above comment will be sufficient to explain
+                   # why
+            lp_git_repo.lp_delete()
+
+        repo.git_run([
+            'push', '--atomic', 'pkg',
+            'refs/heads/%s/*:refs/heads/*' % namespace,
+            'refs/tags/%s/*:refs/tags/*' % namespace,
+        ])
+        # update our reference
+        lp_git_repo = lp.git_repositories.getByPath(path=repo_path)
+        for i in range(retries):
+            try:
+                if only_debian:
+                    lp_git_repo.default_branch = 'refs/heads/debian/sid'
+                else:
+                    lp_git_repo.default_branch = 'refs/heads/ubuntu/devel'
+                lp_git_repo.lp_save()
+                break
+            except (NotFound, PreconditionFailed) as e:
+                time.sleep(retry_backoffs[i])
+                lp_git_repo.lp_refresh()
+
+
+def get_changelog_for_commit(
+    repo,
+    tree_hash,
+    publish_parent_commit,
+    changelog_parent_commit,
+):
+    """Extract changes to debian/changelog in this publish
+
+    LP: #1633114 -- favor the changelog parent's diff
+    """
+    raw_clog_entry = b''
+    if changelog_parent_commit is not None:
+        cmd = ['diff-tree', '-p', changelog_parent_commit,
+               tree_hash, '--', 'debian/changelog']
+        raw_clog_entry = repo.git_run(cmd).stdout
+    elif publish_parent_commit is not None:
+        cmd = ['diff-tree', '-p', publish_parent_commit,
+                tree_hash, '--', 'debian/changelog']
+        raw_clog_entry = repo.git_run(cmd).stdout
+
+    changelog_entry = b''
+    changelog_entry_found = False
+    i = 0
+    for line in raw_clog_entry.split(b'\n'):
+        # skip the header lines
+        if i < 4:
+            i += 1
+            continue
+        if not line.startswith(b'+'):
+            # in case there are stray changelog changes, just take
+            # the first complete section of changelog additions
+            if changelog_entry_found:
+                break
+            continue
+        line = re.sub(b'^[+]', b'', line)
+        if not line.startswith(b'  '):
+            continue
+        if not changelog_entry_found:
+            changelog_entry = b'\n\nNew changelog entries:\n'
+        changelog_entry += line + b'\n'
+        changelog_entry_found = True
+    return changelog_entry
+
+def _commit_import(repo, spi, tree_hash, namespace,
+    publish_parent_commit,
+    changelog_parent_commit, upload_parent_commit,
+    unapplied_parent_commit
+):
+    """Commit a tree object into the repository with the specified
+    parents
+
+    The importer algorithm works by 'staging' the import of a
+    publication as a tree, then using that tree to determine the
+    appropriate parents from the publishing history and
+    debian/changelog.
+
+    Arguments:
+    spi - A SourcePackageInformation instance for this publish
+    tree_hash - SHA1 from git-dsc-commit --tree-only of this publish
+    publish_parent_commit = SHA1 of publishing parent
+    changelog_parent_commit = SHA1 of changelog parent
+    upload_parent_commit = SHA1 of upload parent
+    unapplied_parent_commit = SHA1 of unapplied-patches import parent
+    """
+    tag = None
+
+    if unapplied_parent_commit:
+        import_type = 'patches-applied'
+        target_head_name = spi.applied_head_name(namespace)
+        if repo.get_applied_tag(spi.version, namespace) is None:
+            # Not imported before
+            tag = applied_tag(spi.version, namespace)
+    else:
+        import_type = 'patches-unapplied'
+        target_head_name = spi.head_name(namespace)
+        if repo.get_import_tag(spi.version, namespace) is None:
+            # Not imported before
+            tag = import_tag(spi.version, namespace)
+
+    # Do not show importer/ namespace to user
+    _, _, pretty_head_name = target_head_name.partition('%s/' % namespace)
+
+    changelog_entry = get_changelog_for_commit(
+        repo,
+        tree_hash,
+        publish_parent_commit,
+        changelog_parent_commit
+    )
+    msg = (b'Import %s version %b to %b\n\nImported using git-ubuntu import.' %
+           (import_type.encode(), spi.version.encode(), pretty_head_name.encode())
+          )
+
+    parents = []
+
+    if publish_parent_commit is None and \
+        changelog_parent_commit is None and \
+        upload_parent_commit is None and \
+        unapplied_parent_commit is None and \
+        target_head_name in repo.local_branch_names:
+        # No parents and not creating a new branch
+        tag = orphan_tag(spi.version, namespace)
+    else:
+        msg += b'\n'
+
+    if publish_parent_commit is not None:
+        parents.append(publish_parent_commit)
+        msg += b'\nPublish parent: %b' % publish_parent_commit.encode()
+    if changelog_parent_commit is not None:
+        parents.append(changelog_parent_commit)
+        msg += b'\nChangelog parent: %b' % changelog_parent_commit.encode()
+    if upload_parent_commit is not None:
+        parents.append(upload_parent_commit)
+        msg += b'\nUpload parent: %b' % upload_parent_commit.encode()
+    if unapplied_parent_commit is not None:
+        parents.append(unapplied_parent_commit)
+        msg += b'\nUnapplied parent: %b' % unapplied_parent_commit.encode()
+
+    msg += b'%b' % changelog_entry
+
+    commit_hash = repo.commit_tree_hash(
+        tree_hash,
+        parents,
+        msg,
+        environment_spi=spi
+    )
+
+    repo.update_head_to_commit(target_head_name, commit_hash)
+
+    logging.debug('Committed %s import of %s as %s in %s',
+                 import_type, spi.version, commit_hash, pretty_head_name
+                )
 
-        import_tree_hash = dsc_to_tree_hash(self.local_repo, dsc_pathname)
-        self.local_repo.clean_repository_state()
+    if tag is not None:
+        # should be annotated to use create_tag API
+        logging.debug('Creating tag %s pointing to %s', tag, commit_hash)
+        repo.git_run(['tag', '-a', '-m', 'git-ubuntu import v%s' % VERSION,
+                      tag, commit_hash
+                     ]
+                    )
 
-        return import_tree_hash
+def commit_unapplied_patches_import(
+    repo,
+    spi,
+    import_tree_hash,
+    namespace,
+    publish_parent_commit,
+    changelog_parent_commit,
+    upload_parent_commit,
+):
+    _commit_import(
+        repo,
+        spi,
+        import_tree_hash,
+        namespace,
+        publish_parent_commit,
+        changelog_parent_commit,
+        upload_parent_commit,
+        # unapplied trees do not have a distinct unapplied parent
+        None,
+    )
+
+def commit_applied_patches_import(
+    repo,
+    spi,
+    import_tree_hash,
+    namespace,
+    publish_parent_commit,
+    changelog_parent_commit,
+    unapplied_parent_commit
+):
+    _commit_import(
+        repo,
+        spi,
+        import_tree_hash,
+        namespace,
+        publish_parent_commit,
+        changelog_parent_commit,
+        # uploads will be unapplied trees currently, so applied trees
+        # can not have them as direct parents
+        None,
+        unapplied_parent_commit,
+    )
+
+def import_dsc(repo, dsc, namespace, version, dist):
+    """Imports the dsc file to importer/{debian,ubuntu}/dsc
+
+    Arguments:
+    spi - A GitUbuntuSourcePackageInformation instance
+    """
+
+    # Add DSC file to the appropriate branch
+    runq(['git', 'checkout', '%s/importer/%s/dsc' % (namespace, dist)], env=repo.env)
+    # It is possible the same-named DSC is published multiple times
+    # with different contents, e.g. on epoch bumps
+    local_dir = os.path.join(repo.local_dir, version)
+    os.makedirs(local_dir, exist_ok=True)
+    shutil.copy(dsc.dsc_path, local_dir)
+    repo.git_run(['add', repo.local_dir])
+    try:
+        # Anything to commit? (this will be 0 if, for instance, the
+        # same dsc is being imported again)
+        runq(['git', 'diff', '--exit-code', 'HEAD'], env=repo.env)
+    except:
+        repo.git_run(['commit', '-m', 'DSC file for %s' % version])
+
+    repo.clean_repository_state()
+
+def orig_imported(repo, orig_tarball_paths, namespace, dist):
+    """Determines if a list of paths to tarballs have already been imported to @dist
+
+    Assumes that the pristine-tar branch exists
+    """
+    try:
+        return repo.verify_pristine_tar(
+            orig_tarball_paths,
+            dist,
+            namespace,
+        )
+    except PristineTarError as e:
+        raise GitUbuntuImportOrigError from e
+
+def import_orig(repo, dsc, namespace, version, dist):
+    """Imports the orig-tarball using gbp import-org --pristine-tar
+
+    Arguments:
+    repo - A GitUbuntuRepository object
+    dsc - a GitUbuntuDsc object
+    namespace - string namespace to search for tags, etc.
+    version - the string package version
+    dist - the string distribution, either 'ubuntu' or 'debian'
+    """
+    try:
+        orig_tarball_path = dsc.orig_tarball_path
+    except GitUbuntuDscError as e:
+        raise GitUbuntuImportOrigError(
+            'Unable to import orig tarball in DSC for version %s' % version
+        ) from e
+
+    if orig_tarball_path is None:
+        # native packages only have a .tar.*
+        native_re = re.compile(r'.*\.tar\.[^.]+$')
+        for entry in dsc['Files']:
+            if native_re.match(entry['name']):
+                return
+        raise GitUbuntuImportOrigError('No orig tarball in '
+            'DSC for version %s.' % version
+        )
 
-    def import_patches_applied_tree(self, dsc_pathname):
-        """Imports the patches-applied source package and writes the
-        corresponding working tree for a given srcpkg, patch by patch
+    try:
+        orig_component_paths = dsc.component_tarball_paths
+    except GitUbuntuDscError as e:
+        raise GitUbuntuImportOrigError(
+            'Unable to import component tarballs in DSC for version '
+            '%s' % version
+        ) from e
+
+    orig_paths = [orig_tarball_path] + list(orig_component_paths.values())
+    if (not orig_tarball_path or
+        orig_imported(repo, orig_paths, namespace, dist)
+    ):
+        return
+    if not all(map(os.path.exists, orig_paths)):
+        raise GitUbuntuImportOrigError('Unable to find tarball: '
+            '%s' % [p for p in orig_paths if not os.path.exists(p)])
+
+    try:
+        with repo.pristine_tar_branches(dist, namespace):
+            oldcwd = os.getcwd()
+            # gbp does not support running from arbitrary git trees or
+            # working directories
+            # https://github.com/agx/git-buildpackage/pull/16
+            os.chdir(repo.local_dir)
+
+            ext = os.path.splitext(dsc.orig_tarball_path)[1]
+
+            # make this non-fatal if upstream already exist as tagged?
+            cmd = ['gbp', 'import-orig', '--no-merge',
+                 '--upstream-branch', 'do-not-push',
+                 '--pristine-tar', '--no-interactive',
+                 '--no-symlink-orig',
+                 '--upstream-tag=%s/upstream/%s/%%(version)s%s' %
+                     (namespace, dist, ext)]
+            cmd.extend(map(lambda x: '--component=%s' % x,
+                list(orig_component_paths.keys()))
+            )
+            cmd.extend([orig_tarball_path,])
+            run(cmd, env=repo.env)
+    except CalledProcessError as e:
+        raise GitUbuntuImportOrigError(
+            'Unable to import tarballs: %s' % orig_paths
+        ) from e
+    finally:
+        os.chdir(oldcwd)
 
-        Arguments:
-        dsc_pathname - A string path to a DSC file
-        """
-        oldcwd = os.getcwd()
+        repo.clean_repository_state()
 
-        extract_dir = tempfile.mkdtemp()
-        os.chdir(extract_dir)
+def import_patches_unapplied_tree(repo, dsc_pathname):
+    """Imports the patches-unapplied source package and writes the
+    corresponding working tree for a given srcpkg
 
-        run(['dpkg-source', '-x',
-             '--skip-patches',
-             os.path.join(oldcwd, dsc_pathname)
-            ]
-           )
+    Arguments:
+    dsc_pathname - A string path to a DSC file
+    """
 
-        extracted_dir = None
-        for path in os.listdir(extract_dir):
-            if os.path.isdir(path):
-                extracted_dir = os.path.join(extract_dir, path)
-                break
-        if extracted_dir is None:
-            logging.exception('No source extracted?')
-            raise SourceExtractionException("Failed to find an extracted "
-                                            "directory from dpkg-source -x")
-
-        if os.path.isdir(os.path.join(extracted_dir, '.pc')):
-            self.local_repo.git_run(
-                ['--work-tree', extracted_dir, 'add', '-f', '-A']
-            )
-            self.local_repo.git_run(
-                ['--work-tree', extracted_dir, 'rm', '-r', '-f', '.pc']
-            )
-            cp = self.local_repo.git_run(
-                ['--work-tree', extracted_dir, 'write-tree']
-            )
-            import_tree_hash = decode_binary(cp.stdout).strip()
-            yield (
-                import_tree_hash,
-                None,
-                'Remove .pc directory from source package',
-            )
+    import_tree_hash = dsc_to_tree_hash(repo, dsc_pathname)
+    repo.clean_repository_state()
 
-        try:
-            try:
-                cp = run(['dpkg-source', '--print-format', extracted_dir])
-                fmt = decode_binary(cp.stdout).strip()
-                if '3.0 (quilt)' not in fmt:
-                    raise StopIteration()
-            except CalledProcessError as e:
-                try:
-                    with open('debian/source/format', 'r') as f:
-                        for line in f:
-                             if re.match(r'3.0 (.*)', line):
-                                 break
-                        else:
-                             raise StopIteration()
-                # `man dpkg-source` indicates no d/s/format implies 1.0
-                except OSError:
-                    raise StopIteration()
-
-            while True:
-                try:
-                    os.chdir(extracted_dir)
-                    run(['quilt', 'push'], rcs=[2])
-                    cp = run(['quilt', 'top'])
-                    patch_name = decode_binary(cp.stdout).strip()
-                    cp = run(['quilt', 'header'])
-                    header = decode_binary(cp.stdout).strip()
-                    patch_desc = None
-                    for regex in (r'Subject:\s*(.*?)$',
-                                  r'Description:\s*(.*?)$'
-                                 ):
-                        try:
-                            m = re.search(regex, header, re.MULTILINE)
-                            patch_desc = m.group(1)
-                        except AttributeError:
-                            pass
-                    if patch_desc is None:
-                        logging.debug('Unable to find Subject or Description in %s' % patch_name)
-                    self.local_repo.git_run(['--work-tree', extracted_dir, 'add', '-f', '-A'])
-                    self.local_repo.git_run(['--work-tree', extracted_dir, 'reset', 'HEAD', '--', '.pc'])
-                    cp = self.local_repo.git_run(['--work-tree', extracted_dir, 'write-tree'])
-                    import_tree_hash = decode_binary(cp.stdout).strip()
-
-                    yield (import_tree_hash, patch_name, patch_desc)
-                except CalledProcessError as e:
-                    # quilt returns 2 when done pushing
-                    if e.returncode != 2:
-                        raise
-                    raise StopIteration()
-        finally:
-            os.chdir(oldcwd)
-            shutil.rmtree(extract_dir)
-            self.local_repo.clean_repository_state()
+    return import_tree_hash
 
-    def parse_parentfile(self, parentfile):
-        """Extract parent overrides from a file
+def import_patches_applied_tree(repo, dsc_pathname):
+    """Imports the patches-applied source package and writes the
+    corresponding working tree for a given srcpkg, patch by patch
 
-        The parent overrides file specifies parent-child relationship(s),
-        where the importer may not be able to determine them automatically.
-        The format of the file is:
-        <pkgname> <child version> <publish parent version> <changelog parent version>
-        with one override per line.
+    Arguments:
+    dsc_pathname - A string path to a DSC file
+    """
+    oldcwd = os.getcwd()
 
-        <child version> is the published version to which this override
-        applies.
+    extract_dir = tempfile.mkdtemp()
+    os.chdir(extract_dir)
 
-        The <publish parent version> is the prior version published in the
-        same series/pocket, or the immediately preceding series/pocket, if
-        this is the first publish in a series/pocket.
+    run(['dpkg-source', '-x',
+         '--skip-patches',
+         os.path.join(oldcwd, dsc_pathname)
+        ]
+       )
 
-        The <changelog parent version> is the prior version in the
-        child publish's debian/changelog.
+    extracted_dir = None
+    for path in os.listdir(extract_dir):
+        if os.path.isdir(path):
+            extracted_dir = os.path.join(extract_dir, path)
+            break
+    if extracted_dir is None:
+        logging.exception('No source extracted?')
+        raise SourceExtractionException("Failed to find an extracted "
+                                        "directory from dpkg-source -x")
 
-        Keyword Arguments:
-        parentfile -- Path to parent overrides file
-        """
-        if self.parent_overrides:
-            return
-        parent_overrides = dict()
+    if os.path.isdir(os.path.join(extracted_dir, '.pc')):
+        repo.git_run(
+            ['--work-tree', extracted_dir, 'add', '-f', '-A']
+        )
+        repo.git_run(
+            ['--work-tree', extracted_dir, 'rm', '-r', '-f', '.pc']
+        )
+        cp = repo.git_run(
+            ['--work-tree', extracted_dir, 'write-tree']
+        )
+        import_tree_hash = decode_binary(cp.stdout).strip()
+        yield (
+            import_tree_hash,
+            None,
+            'Remove .pc directory from source package',
+        )
+
+    try:
         try:
-            with open(parentfile) as f:
-                for line in f:
-                    if line.startswith('#'):
-                        continue
-                    m = re.match(
-                        r'(?P<pkgname>\S*)\s*(?P<childversion>\S*)\s*(?P<parent1version>\S*)\s*(?P<parent2version>\S*)',
-                        line
-                        )
-                    if m is None:
-                        continue
-                    if m.group('pkgname') != self.pkgname:
-                        continue
-                    parent_overrides[m.group('childversion')] = {
-                        'publish_parent':m.group('parent1version'),
-                        'changelog_parent':m.group('parent2version')
-                        }
-        except FileNotFoundError:
-            pass
-        self.parent_overrides = parent_overrides
+            cp = run(['dpkg-source', '--print-format', extracted_dir])
+            fmt = decode_binary(cp.stdout).strip()
+            if '3.0 (quilt)' not in fmt:
+                raise StopIteration()
+        except CalledProcessError as e:
+            try:
+                with open('debian/source/format', 'r') as f:
+                    for line in f:
+                         if re.match(r'3.0 (.*)', line):
+                             break
+                    else:
+                         raise StopIteration()
+            # `man dpkg-source` indicates no d/s/format implies 1.0
+            except OSError:
+                raise StopIteration()
 
-    def override_parents(self, spi):
-        unapplied_publish_parent_commit = None
-        unapplied_changelog_parent_commit = None
-        applied_publish_parent_commit = None
-        applied_changelog_parent_commit = None
+        while True:
+            try:
+                os.chdir(extracted_dir)
+                run(['quilt', 'push'], rcs=[2])
+                cp = run(['quilt', 'top'])
+                patch_name = decode_binary(cp.stdout).strip()
+                cp = run(['quilt', 'header'])
+                header = decode_binary(cp.stdout).strip()
+                patch_desc = None
+                for regex in (r'Subject:\s*(.*?)$',
+                              r'Description:\s*(.*?)$'
+                             ):
+                    try:
+                        m = re.search(regex, header, re.MULTILINE)
+                        patch_desc = m.group(1)
+                    except AttributeError:
+                        pass
+                if patch_desc is None:
+                    logging.debug('Unable to find Subject or Description '
+                        'in %s' % patch_name
+                    )
+                repo.git_run([
+                    '--work-tree',
+                    extracted_dir,
+                    'add',
+                    '-f',
+                    '-A',
+                ])
+                repo.git_run([
+                    '--work-tree',
+                    extracted_dir,
+                    'reset',
+                    'HEAD',
+                    '--',
+                    '.pc',
+                ])
+                cp = repo.git_run(['--work-tree', extracted_dir, 'write-tree'])
+                import_tree_hash = decode_binary(cp.stdout).strip()
+
+                yield (import_tree_hash, patch_name, patch_desc)
+            except CalledProcessError as e:
+                # quilt returns 2 when done pushing
+                if e.returncode != 2:
+                    raise
+                raise StopIteration()
+    finally:
+        os.chdir(oldcwd)
+        shutil.rmtree(extract_dir)
+        repo.clean_repository_state()
+
+_PARENT_OVERRIDES = None
+def parse_parentfile(parentfile, pkgname):
+    """Extract parent overrides from a file
+
+    The parent overrides file specifies parent-child relationship(s),
+    where the importer may not be able to determine them automatically.
+    The format of the file is:
+    <pkgname> <child version> <publish parent version> <changelog parent version>
+    with one override per line.
+
+    <child version> is the published version to which this override
+    applies.
+
+    The <publish parent version> is the prior version published in the
+    same series/pocket, or the immediately preceding series/pocket, if
+    this is the first publish in a series/pocket.
+
+    The <changelog parent version> is the prior version in the
+    child publish's debian/changelog.
+
+    Keyword Arguments:
+    parentfile -- Path to parent overrides file
+    """
+    global _PARENT_OVERRIDES
+    if _PARENT_OVERRIDES:
+        return
+    _PARENT_OVERRIDES = dict()
+    try:
+        with open(parentfile) as f:
+            for line in f:
+                if line.startswith('#'):
+                    continue
+                m = re.match(
+                    r'(?P<pkgname>\S*)\s*(?P<childversion>\S*)\s*(?P<parent1version>\S*)\s*(?P<parent2version>\S*)',
+                    line
+                    )
+                if m is None:
+                    continue
+                if m.group('pkgname') != pkgname:
+                    continue
+                _PARENT_OVERRIDES[m.group('childversion')] = {
+                    'publish_parent':m.group('parent1version'),
+                    'changelog_parent':m.group('parent2version')
+                    }
+    except FileNotFoundError:
+        pass
+
+def override_parents(repo, spi, namespace):
+    unapplied_publish_parent_commit = None
+    unapplied_changelog_parent_commit = None
+    applied_publish_parent_commit = None
+    applied_changelog_parent_commit = None
+
+    unapplied_publish_parent_tag = repo.get_import_tag(
+        _PARENT_OVERRIDES[spi.version]['publish_parent'],
+        namespace
+    )
+    applied_publish_parent_tag = repo.get_applied_tag(
+        _PARENT_OVERRIDES[spi.version]['publish_parent'],
+        namespace
+    )
+    if unapplied_publish_parent_tag is not None:
+        # sanity check that version from d/changelog of the
+        # tagged commit matches ours
+        parent_publish_version, _ = \
+            repo.get_changelog_versions_from_treeish(
+                str(unapplied_publish_parent_tag.peel().id),
+                                                    )
+        if parent_publish_version != _PARENT_OVERRIDES[spi.version]['publish_parent']:
+            logging.error('Found a tag corresponding to publish parent '
+                'override version %s, but d/changelog version (%s) '
+                'differs. Will orphan commit.',
+                _PARENT_OVERRIDES[spi.version]['publish_parent'],
+                parent_publish_version
+            )
+        else:
+            unapplied_publish_parent_commit = str(unapplied_publish_parent_tag.peel().id)
+            if applied_publish_parent_tag is not None:
+                applied_publish_parent_commit = str(applied_publish_parent_tag.peel().id)
+            logging.debug('Overriding publish parent (tag) to %s',
+                repo.tag_to_pretty_name(unapplied_publish_parent_tag)
+            )
+    else:
+        if _PARENT_OVERRIDES[spi.version]['publish_parent'] == '-':
+            logging.debug('Not setting publish parent as '
+                         'specified in override file.'
+                        )
+        else:
+            logging.error('Specified publish parent override '
+                          '(%s) for version (%s) not found in tags. '
+                          'Unable to proceed.' % (
+                           _PARENT_OVERRIDES[spi.version]['publish_parent'],
+                           spi.version
+                           )
+                          )
+            sys.exit(1)
 
-        unapplied_publish_parent_tag = self.local_repo.get_import_tag(
-             self.parent_overrides[spi.version]['publish_parent'],
-             self.namespace)
-        applied_publish_parent_tag = self.local_repo.get_applied_tag(
-            self.parent_overrides[spi.version]['publish_parent'],
-            self.namespace)
-        if unapplied_publish_parent_tag is not None:
-            # sanity check that version from d/changelog of the
-            # tagged commit matches ours
-            parent_publish_version, _ = \
-                self.local_repo.get_changelog_versions_from_treeish(
-                    str(unapplied_publish_parent_tag.peel().id),
-                                                        )
-            if parent_publish_version != self.parent_overrides[spi.version]['publish_parent']:
-                logging.error('Found a tag corresponding to '
-                              'publish parent override '
-                              'version %s, but d/changelog '
-                              'version (%s) differs. Will '
-                              'orphan commit.' % (
-                              self.parent_overrides[spi.version]['publish_parent'],
-                              parent_publish_version
-                              )
-                             )
-            else:
-                unapplied_publish_parent_commit = str(unapplied_publish_parent_tag.peel().id)
-                if applied_publish_parent_tag is not None:
-                    applied_publish_parent_commit = str(applied_publish_parent_tag.peel().id)
-                logging.debug('Overriding publish parent (tag) to %s',
-                             self.local_repo.tag_to_pretty_name(unapplied_publish_parent_tag)
-                            )
+    unapplied_changelog_parent_tag = repo.get_import_tag(
+        _PARENT_OVERRIDES[spi.version]['changelog_parent'],
+        namespace
+    )
+    applied_changelog_parent_tag = repo.get_applied_tag(
+        _PARENT_OVERRIDES[spi.version]['changelog_parent'],
+        namespace
+    )
+    if unapplied_changelog_parent_tag is not None:
+        # sanity check that version from d/changelog of the
+        # tagged commit matches ours
+        parent_changelog_version, _ = repo.get_changelog_versions_from_treeish(
+            str(unapplied_changelog_parent_tag.peel().id),
+        )
+        if parent_changelog_version != _PARENT_OVERRIDES[spi.version]['changelog_parent']:
+            logging.error('Found a tag corresponding to '
+                          'changelog parent override '
+                          'version %s, but d/changelog '
+                          'version (%s) differs. Will '
+                          'orphan commit.' % (
+                          _PARENT_OVERRIDES[spi.version]['changelog_parent'],
+                          parent_changelog_version
+                          )
+                         )
         else:
-            if self.parent_overrides[spi.version]['publish_parent'] == '-':
-                logging.debug('Not setting publish parent as '
-                             'specified in override file.'
-                            )
-            else:
-                logging.error('Specified publish parent override '
-                              '(%s) for version (%s) not found in tags. '
-                              'Unable to proceed.' % (
-                               self.parent_overrides[spi.version]['publish_parent'],
-                               spi.version
-                               )
-                              )
-                sys.exit(1)
-
-        unapplied_changelog_parent_tag = self.local_repo.get_import_tag(
-            self.parent_overrides[spi.version]['changelog_parent'],
-            self.namespace)
-        applied_changelog_parent_tag = self.local_repo.get_applied_tag(
-            self.parent_overrides[spi.version]['changelog_parent'],
-            self.namespace)
-        if unapplied_changelog_parent_tag is not None:
-            # sanity check that version from d/changelog of the
-            # tagged commit matches ours
-            parent_changelog_version, _ = \
-                self.local_repo.get_changelog_versions_from_treeish(
-                    str(unapplied_changelog_parent_tag.peel().id),
-                                                        )
-            if parent_changelog_version != self.parent_overrides[spi.version]['changelog_parent']:
-                logging.error('Found a tag corresponding to '
-                              'changelog parent override '
-                              'version %s, but d/changelog '
-                              'version (%s) differs. Will '
-                              'orphan commit.' % (
-                              self.parent_overrides[spi.version]['changelog_parent'],
-                              parent_changelog_version
-                              )
-                             )
-            else:
-                unapplied_changelog_parent_commit = str(unapplied_changelog_parent_tag.peel().id)
-                if applied_changelog_parent_tag is not None:
-                    applied_changelog_parent_commit = str(applied_changelog_parent_tag.peel().id)
-                logging.debug('Overriding changelog parent (tag) to %s',
-                             self.local_repo.tag_to_pretty_name(unapplied_changelog_parent_tag)
-                            )
+            unapplied_changelog_parent_commit = str(unapplied_changelog_parent_tag.peel().id)
+            if applied_changelog_parent_tag is not None:
+                applied_changelog_parent_commit = str(applied_changelog_parent_tag.peel().id)
+            logging.debug('Overriding changelog parent (tag) to %s',
+                repo.tag_to_pretty_name(unapplied_changelog_parent_tag)
+            )
+    else:
+        if _PARENT_OVERRIDES[spi.version]['changelog_parent'] == '-':
+            logging.debug('Not setting changelog parent as specified '
+                'in override file.'
+            )
         else:
-            if self.parent_overrides[spi.version]['changelog_parent'] == '-':
-                logging.debug('Not setting changelog parent as '
-                             'specified in override file.'
-                            )
-            else:
-                logging.error('Specified changelog parent override '
-                              '(%s) for version (%s) not found in tags. '
-                              'Unable to proceed.' % (
-                               self.parent_overrides[spi.version]['changelog_parent'],
-                               spi.version
-                               )
-                              )
-                sys.exit(1)
-        return (unapplied_publish_parent_commit,
-                unapplied_changelog_parent_commit,
-                applied_publish_parent_commit,
-                applied_changelog_parent_commit)
-
-    def _update_devel_branches(self, namespace, spi=None):
-        if spi:
-            # we do not maintain -devel pointers for debian
-            if str(spi.distribution.name.lower()) != "ubuntu":
+            logging.error('Specified changelog parent override (%s) '
+                'for version (%s) not found in tags. Unable to proceed.',
+                _PARENT_OVERRIDES[spi.version]['changelog_parent'],
+                spi.version
+            )
+            sys.exit(1)
+    return (
+        unapplied_publish_parent_commit,
+        unapplied_changelog_parent_commit,
+        applied_publish_parent_commit,
+        applied_changelog_parent_commit,
+    )
+
+def _update_devel_branches(
+    repo,
+    namespace,
+    pkgname,
+    ubuntu_sinfo,
+    spi=None,
+):
+    if spi:
+        # we do not maintain -devel pointers for debian
+        if str(spi.distribution.name.lower()) != "ubuntu":
+            return
+        for devel_head in (
+            '%s/ubuntu/%s-devel' % (namespace, spi.series.name.lower()),
+            '%s/ubuntu/devel' % namespace
+                          ):
+            try:
+                devel_head_hash = repo.head_to_commit(devel_head)
+                devel_head_version, _ = repo.get_changelog_versions_from_treeish(devel_head_hash)
+            except AttributeError:
+                devel_head_version = None
+            if version_compare(spi.version, devel_head_version) <= 0:
                 return
-            for devel_head in (
-                '%s/ubuntu/%s-devel' % (namespace, spi.series.name.lower()),
-                '%s/ubuntu/devel' % namespace
-                              ):
-                try:
-                    devel_head_hash = self.local_repo.head_to_commit(devel_head)
-                    devel_head_version, _ = self.local_repo.get_changelog_versions_from_treeish(devel_head_hash)
-                except AttributeError:
-                    devel_head_version = None
-                if version_compare(spi.version, devel_head_version) <= 0:
-                    return
-                logging.debug("Updating %s to %s" % (devel_head,
-                                                     spi.head_name(namespace)))
-                self.local_repo.merge_commit_to_devel_head(
-                    namespace, devel_head,
-                    self.local_repo.head_to_commit(spi.head_name(namespace)),
-                    environment_spi=spi)
+            logging.debug("Updating %s to %s" % (devel_head,
+                                                 spi.head_name(namespace)))
+            repo.merge_commit_to_devel_head(
+                namespace,
+                devel_head,
+                repo.head_to_commit(spi.head_name(namespace)),
+                environment_spi=spi,
+            )
+    else:
+        ubuntu_head_versions = repo.get_heads_and_versions(
+            'ubuntu',
+            namespace,
+        )
+        devel_hash = None
+        devel_name = None
+        for rel in ubuntu_sinfo.active_series_name_list:
+            series_devel_hash = None
+            series_devel_name = None
+            series_devel_version = None
+            # Find highest version publish in these pockets
+            for suff in ("-proposed", "-updates", "-security", ""):
+                name = "%s/ubuntu/%s%s" % (namespace, rel, suff)
+                if name in ubuntu_head_versions and version_compare(
+                    ubuntu_head_versions[name]['version'],
+                    series_devel_version
+                ) > 0:
+                    series_devel_name = name
+                    series_devel_version = ubuntu_head_versions[name]['version']
+                    series_devel_hash = str(ubuntu_head_versions[name]['head'].peel().id)
+            if series_devel_hash:
+                if not devel_hash:
+                    devel_hash = series_devel_hash
+                    devel_name = series_devel_name
+                logging.debug("Updating %s/ubuntu/%s-devel branch to '%s' (%s)",
+                              namespace, rel, series_devel_name, series_devel_hash)
+                repo.merge_commit_to_devel_head(namespace,
+                    "%s/ubuntu/%s-devel" % (namespace, rel), series_devel_hash)
+        if devel_hash is None:
+            logging.warn("Package '%s' does not appear to have been published "
+                         "in Ubuntu.  No %s/ubuntu/devel branch created.",
+                         pkgname, namespace)
         else:
-            ubuntu_head_versions = self.local_repo.get_heads_and_versions(
-                'ubuntu', namespace
+            logging.debug("Setting %s/ubuntu/devel branch to '%s' (%s)",
+                          namespace, devel_name, devel_hash)
+            repo.merge_commit_to_devel_head(
+                namespace, "%s/ubuntu/devel" % namespace, devel_hash
             )
-            devel_hash = None
-            devel_name = None
-            for rel in self.ubuntu_sinfo.active_series_name_list:
-                series_devel_hash = None
-                series_devel_name = None
-                series_devel_version = None
-                # Find highest version publish in these pockets
-                for suff in ("-proposed", "-updates", "-security", ""):
-                    name = "%s/ubuntu/%s%s" % (namespace, rel, suff)
-                    if name in ubuntu_head_versions and version_compare(
-                        ubuntu_head_versions[name]['version'],
-                        series_devel_version
-                    ) > 0:
-                        series_devel_name = name
-                        series_devel_version = ubuntu_head_versions[name]['version']
-                        series_devel_hash = str(ubuntu_head_versions[name]['head'].peel().id)
-                if series_devel_hash:
-                    if not devel_hash:
-                        devel_hash = series_devel_hash
-                        devel_name = series_devel_name
-                    logging.debug("Updating %s/ubuntu/%s-devel branch to '%s' (%s)",
-                                  namespace, rel, series_devel_name, series_devel_hash)
-                    self.local_repo.merge_commit_to_devel_head(namespace,
-                        "%s/ubuntu/%s-devel" % (namespace, rel), series_devel_hash)
-            if devel_hash is None:
-                logging.warn("Package '%s' does not appear to have been published "
-                             "in Ubuntu.  No %s/ubuntu/devel branch created.",
-                             self.pkgname, namespace)
-            else:
-                logging.debug("Setting %s/ubuntu/devel branch to '%s' (%s)",
-                              namespace, devel_name, devel_hash)
-                self.local_repo.merge_commit_to_devel_head(
-                    namespace, "%s/ubuntu/devel" % namespace, devel_hash
-                )
-
-    def update_devel_branches(self, spi=None):
-        self._update_devel_branches(self.namespace, spi)
-
-    def update_applied_devel_branches(self, spi=None):
-        self._update_devel_branches('%s/applied' % self.namespace, spi)
-
-    # imports a package based upon source package information
-    def import_unapplied_spi(self, spi):
-        """Imports a source package from Launchpad into the git
-        repository
-
-        Arguments:
-        spi - a SourcePackageInformation instance
-        """
-        pretty_head_name = spi.pretty_head_name
 
-        logging.info('Importing patches-unapplied %s to %s' %
-                     (spi.version, pretty_head_name))
-        unapplied_tip_head = self.local_repo.get_head_by_name(spi.head_name(self.namespace))
-
-        spi.pull()
-
-        self.local_repo.clean_repository_state()
-
-        self.import_dsc(
+def update_devel_branches(
+    repo,
+    namespace,
+    pkgname,
+    ubuntu_sinfo,
+    spi=None,
+):
+    _update_devel_branches(
+        repo=repo,
+        namespace=namespace,
+        pkgname=pkgname,
+        ubuntu_sinfo=ubuntu_sinfo,
+        spi=spi,
+    )
+
+def update_applied_devel_branches(
+    repo,
+    namespace,
+    pkgname,
+    ubuntu_sinfo,
+    spi=None,
+):
+    _update_devel_branches(
+        repo=repo,
+        namespace='%s/applied' % namespace,
+        pkgname=pkgname,
+        ubuntu_sinfo=ubuntu_sinfo,
+        spi=spi,
+    )
+
+# imports a package based upon source package information
+def import_unapplied_spi(repo, spi, namespace, skip_orig, ubuntu_sinfo):
+    """Imports a source package from Launchpad into the git
+    repository
+
+    Arguments:
+    spi - a SourcePackageInformation instance
+    """
+    pretty_head_name = spi.pretty_head_name
+
+    logging.info('Importing patches-unapplied %s to %s',
+        spi.version, pretty_head_name
+    )
+    unapplied_tip_head = repo.get_head_by_name(spi.head_name(namespace))
+
+    spi.pull()
+
+    repo.clean_repository_state()
+
+    import_dsc(
+        repo,
+        GitUbuntuDsc(spi.dsc_pathname),
+        namespace,
+        str(spi.version),
+        spi.distribution.name.lower(),
+    )
+    if not skip_orig:
+        import_orig(
+            repo,
             GitUbuntuDsc(spi.dsc_pathname),
+            namespace,
             str(spi.version),
-            spi.distribution.name.lower()
+            spi.distribution.name.lower(),
         )
-        if not self.skip_orig:
-            self.import_orig(spi)
 
-        unapplied_import_tree_hash = self.import_patches_unapplied_tree(spi.dsc_pathname)
-        logging.debug('Imported patches-unapplied version %s as tree %s',
-                     spi.version, unapplied_import_tree_hash
-                    )
+    unapplied_import_tree_hash = import_patches_unapplied_tree(
+        repo,
+        spi.dsc_pathname
+    )
+    logging.debug(
+        "Imported patches-unapplied version %s as tree %s",
+        spi.version,
+        unapplied_import_tree_hash
+    )
+
+    import_tree_versions = repo.get_all_changelog_versions_from_treeish(
+        unapplied_import_tree_hash
+    )
+    changelog_version = import_tree_versions[0]
+
+    logging.debug(
+        "Found changelog version %s in newly imported tree" %
+        changelog_version
+    )
+
+    # sanity check on spph and d/changelog agreeing on the latest version
+    if spi.version not in _PARENT_OVERRIDES:
+        assert spi.version == changelog_version, (
+            'source pkg version: {} != changelog version: {}'.format(
+                spi.version, changelog_version))
+
+    unapplied_tip_version = None
+    # check if the version to import has already been imported to
+    # this head
+    if unapplied_tip_head is not None:
+        if repo.treeishs_identical(
+            unapplied_import_tree_hash, str(unapplied_tip_head.peel().id)
+        ):
+            logging.warn('%s is identical to %s',
+                         pretty_head_name, spi.version
+                        )
+            return
+        unapplied_tip_version, _ = repo.get_changelog_versions_from_treeish(
+                             str(unapplied_tip_head.peel().id),
+                                                                 )
 
-        import_tree_versions = self.local_repo.get_all_changelog_versions_from_treeish(
-                                   unapplied_import_tree_hash
-                                                                           )
-        changelog_version = import_tree_versions[0]
+    logging.debug('Tip version is %s', unapplied_tip_version)
 
+    unapplied_publish_parent_commit = None
+    unapplied_changelog_parent_commit = None
+    upload_parent_commit = None
+    unapplied_parent_commit = None
+
+    if spi.version in _PARENT_OVERRIDES:
         logging.debug(
-            'Found changelog version %s in newly imported tree' %
-            changelog_version
-                    )
+            '%s is specified in the parent override file.',
+            spi.version
+        )
 
-        # sanity check on spph and d/changelog agreeing on the latest version
-        if spi.version not in self.parent_overrides:
-            assert spi.version == changelog_version, (
-                'source pkg version: {} != changelog version: {}'.format(
-                    spi.version, changelog_version))
-
-        unapplied_tip_version = None
-        # check if the version to import has already been imported to
-        # this head
-        if unapplied_tip_head is not None:
-            if self.local_repo.treeishs_identical(
-                    unapplied_import_tree_hash, str(unapplied_tip_head.peel().id)
-                ):
-                logging.warn('%s is identical to %s',
-                             pretty_head_name, spi.version
+        (
+            unapplied_publish_parent_commit,
+            unapplied_changelog_parent_commit,
+            _,
+            _
+        ) = override_parents(repo, spi, namespace)
+    else:
+        # Get parent from publishing history (which is the last
+        # published version in the corresponding series)
+        try:
+            unapplied_publish_parent_commit = str(unapplied_tip_head.peel().id)
+        except AttributeError:
+            try:
+                unapplied_publish_parent_head = repo.get_head_by_name(spi.parent_head_name(namespace))
+                unapplied_publish_parent_commit = str(unapplied_publish_parent_head.peel().id)
+            except AttributeError:
+                pass
+        finally:
+            try:
+                unapplied_publish_parent_tag = repo.nearest_import_tag(unapplied_publish_parent_commit, namespace)
+                logging.debug('Publishing parent (tag) is %s',
+                    repo.tag_to_pretty_name(unapplied_publish_parent_tag)
                             )
-                return
-            unapplied_tip_version, _ = self.local_repo.get_changelog_versions_from_treeish(
-                                 str(unapplied_tip_head.peel().id),
-                                                                     )
+            except AttributeError:
+                pass
 
-        logging.debug('Tip version is %s', unapplied_tip_version)
+        if version_compare(str(spi.version), unapplied_tip_version) <= 0:
+            logging.warn('Version to import (%s) is not after %s tip (%s)',
+                         spi.version, pretty_head_name, unapplied_tip_version
+                        )
+
+        # Walk changelog backwards until we find an imported version
+        for version in import_tree_versions:
+            unapplied_changelog_parent_tag = repo.get_import_tag(version, namespace)
+            if unapplied_changelog_parent_tag is not None:
+                # sanity check that version from d/changelog of the
+                # tagged parent matches ours
+                parent_changelog_version, _ = \
+                    repo.get_changelog_versions_from_treeish(
+                        str(unapplied_changelog_parent_tag.peel(pygit2.Tree).id),
+                                                            )
+                # if the parent was imported via a parent override
+                # itself, assume it is valid without checking its
+                # tree's debian/changelog, as it wasn't used
+                if (version not in _PARENT_OVERRIDES and
+                    parent_changelog_version != version
+                   ):
+                    logging.error('Found a tag corresponding to '
+                                  'parent version %s, but d/changelog '
+                                  'version (%s) differs. Will '
+                                  'orphan commit.' % (
+                                  version,
+                                  parent_changelog_version
+                                  )
+                                 )
+                else:
+                    unapplied_changelog_parent_commit = str(unapplied_changelog_parent_tag.peel().id)
+                    logging.debug('Changelog parent (tag) is %s',
+                        repo.tag_to_pretty_name(unapplied_changelog_parent_tag)
+                                )
+                break
 
-        unapplied_publish_parent_commit = None
+    # If the two parents are tree-identical, then favor publication
+    # history. This deals with copy-forwards between series and with
+    # syncs.
+    if repo.treeishs_identical(unapplied_publish_parent_commit, unapplied_changelog_parent_commit):
         unapplied_changelog_parent_commit = None
-        upload_parent_commit = None
-        unapplied_parent_commit = None
 
-        if spi.version in self.parent_overrides:
-            logging.debug('%s is specified in the parent override file.' %
+    # check if the version to import has already been uploaded to
+    # this head -- we leverage the above code to perform a 'dry-run'
+    # of the import tree, to obtain the (up to) two parents
+    upload_tag = repo.get_upload_tag(spi.version, namespace)
+    import_tag = repo.get_import_tag(spi.version, namespace)
+    if upload_tag and not import_tag:
+        if str(upload_tag.peel().tree.id) != unapplied_import_tree_hash:
+            logging.warn('Found upload tag %s, '
+                         'but the corresponding tree '
+                         'does not match the published '
+                         'version. Will import %s as '
+                         'normal, ignoring the upload tag.',
+                         repo.tag_to_pretty_name(upload_tag),
                          spi.version
                         )
-
-            (unapplied_publish_parent_commit,
-             unapplied_changelog_parent_commit,
-             _, _) = self.override_parents(spi)
         else:
-            # Get parent from publishing history (which is the last
-            # published version in the corresponding series)
-            try:
-                unapplied_publish_parent_commit = str(unapplied_tip_head.peel().id)
-            except AttributeError:
-                try:
-                    unapplied_publish_parent_head = self.local_repo.get_head_by_name(spi.parent_head_name(self.namespace))
-                    unapplied_publish_parent_commit = str(unapplied_publish_parent_head.peel().id)
-                except AttributeError:
-                    pass
-            finally:
+            upload_parent_commit = str(upload_tag.peel().id)
+            if unapplied_publish_parent_commit is not None:
                 try:
-                    unapplied_publish_parent_tag = self.local_repo.nearest_import_tag(unapplied_publish_parent_commit, self.namespace)
-                    logging.debug('Publishing parent (tag) is %s',
-                        self.local_repo.tag_to_pretty_name(unapplied_publish_parent_tag)
+                    repo.git_run(['merge-base', '--is-ancestor',
+                                  unapplied_publish_parent_commit,
+                                  upload_parent_commit
+                                 ]
                                 )
-                except AttributeError:
-                    pass
-
-            if version_compare(str(spi.version), unapplied_tip_version) <= 0:
-                logging.warn('Version to import (%s) is not after %s tip (%s)',
-                             spi.version, pretty_head_name, unapplied_tip_version
-                            )
-
-            # Walk changelog backwards until we find an imported version
-            for version in import_tree_versions:
-                unapplied_changelog_parent_tag = self.local_repo.get_import_tag(version, self.namespace)
-                if unapplied_changelog_parent_tag is not None:
-                    # sanity check that version from d/changelog of the
-                    # tagged parent matches ours
-                    parent_changelog_version, _ = \
-                        self.local_repo.get_changelog_versions_from_treeish(
-                            str(unapplied_changelog_parent_tag.peel(pygit2.Tree).id),
-                                                                )
-                    # if the parent was imported via a parent override
-                    # itself, assume it is valid without checking its
-                    # tree's debian/changelog, as it wasn't used
-                    if (version not in self.parent_overrides and
-                        parent_changelog_version != version
-                       ):
-                        logging.error('Found a tag corresponding to '
-                                      'parent version %s, but d/changelog '
-                                      'version (%s) differs. Will '
-                                      'orphan commit.' % (
-                                      version,
-                                      parent_changelog_version
-                                      )
-                                     )
-                    else:
-                        unapplied_changelog_parent_commit = str(unapplied_changelog_parent_tag.peel().id)
-                        logging.debug('Changelog parent (tag) is %s',
-                            self.local_repo.tag_to_pretty_name(unapplied_changelog_parent_tag)
-                                    )
-                    break
-
-        # If the two parents are tree-identical, then favor publication
-        # history. This deals with copy-forwards between series and with
-        # syncs.
-        if self.local_repo.treeishs_identical(unapplied_publish_parent_commit, unapplied_changelog_parent_commit):
-            unapplied_changelog_parent_commit = None
-
-        # check if the version to import has already been uploaded to
-        # this head -- we leverage the above code to perform a 'dry-run'
-        # of the import tree, to obtain the (up to) two parents
-        upload_tag = self.local_repo.get_upload_tag(spi.version, self.namespace)
-        import_tag = self.local_repo.get_import_tag(spi.version, self.namespace)
-        if upload_tag and not import_tag:
-            if str(upload_tag.peel().tree.id) != unapplied_import_tree_hash:
-                logging.warn('Found upload tag %s, '
-                             'but the corresponding tree '
-                             'does not match the published '
-                             'version. Will import %s as '
-                             'normal, ignoring the upload tag.',
-                             self.local_repo.tag_to_pretty_name(upload_tag),
-                             spi.version
-                            )
-            else:
-                upload_parent_commit = str(upload_tag.peel().id)
-                if unapplied_publish_parent_commit is not None:
-                    try:
-                        self.local_repo.git_run(['merge-base', '--is-ancestor',
-                                      unapplied_publish_parent_commit,
-                                      upload_parent_commit
-                                     ]
-                                    )
-                        unapplied_publish_parent_commit = None
-                    except CalledProcessError as e:
-                        if e.returncode != 1:
-                            raise
-
-                if unapplied_changelog_parent_commit is not None:
-                    try:
-                        self.local_repo.git_run(['merge-base', '--is-ancestor',
-                                      unapplied_changelog_parent_commit,
-                                      upload_parent_commit
-                                     ]
-                                    )
-                        unapplied_changelog_parent_commit = None
-                    except CalledProcessError as e:
-                        if e.returncode != 1:
-                            raise
-
-        self.commit_unapplied_patches_import(
-            spi,
-            unapplied_import_tree_hash,
-            unapplied_publish_parent_commit,
-            unapplied_changelog_parent_commit,
-            upload_parent_commit,
-                                            )
-
-        self.update_devel_branches(spi)
-
-    def import_applied_spi(self, spi):
-        """Imports a source package from Launchpad into the git
-        repository
-
-        Arguments:
-        spi - a SourcePackageInformation instance
-        """
-        pretty_head_name = spi.pretty_head_name
-
-        logging.info('Importing patches-applied %s to %s' % (spi.version, pretty_head_name))
-        applied_tip_head = self.local_repo.get_head_by_name(spi.applied_head_name(self.namespace))
-
-        spi.pull()
-
-        self.local_repo.clean_repository_state()
-
-        unapplied_parent_tag = self.local_repo.get_import_tag(spi.version, self.namespace)
-        unapplied_parent_commit = str(unapplied_parent_tag.peel().id)
-        unapplied_import_tree_hash = str(unapplied_parent_tag.peel(pygit2.Tree).id)
-        logging.debug('Found patches-unapplied version %s as commit %s',
-                      str(spi.version), unapplied_parent_commit)
-
-        import_tree_versions = self.local_repo.get_all_changelog_versions_from_treeish(
-                                   unapplied_import_tree_hash
-                                                                           )
-        changelog_version = import_tree_versions[0]
-
-        applied_tip_version = None
-        # check if the version to import has already been imported to
-        # this head
-        if applied_tip_head is not None:
-            if self.local_repo.treeishs_identical(
-                    unapplied_import_tree_hash, str(applied_tip_head.peel().id)
-                ):
-                logging.warn('%s is identical to %s',
-                             pretty_head_name, spi.version
-                            )
-                return
-            applied_tip_version, _ = self.local_repo.get_changelog_versions_from_treeish(
-                                 str(applied_tip_head.peel().id),
-                                                                     )
-
-        logging.debug('Tip version is %s', applied_tip_version)
+                    unapplied_publish_parent_commit = None
+                except CalledProcessError as e:
+                    if e.returncode != 1:
+                        raise
 
-        applied_publish_parent_commit = None
-        applied_changelog_parent_commit = None
+            if unapplied_changelog_parent_commit is not None:
+                try:
+                    repo.git_run(['merge-base', '--is-ancestor',
+                                  unapplied_changelog_parent_commit,
+                                  upload_parent_commit
+                                 ]
+                                )
+                    unapplied_changelog_parent_commit = None
+                except CalledProcessError as e:
+                    if e.returncode != 1:
+                        raise
 
-        if spi.version in self.parent_overrides:
-            logging.debug('%s is specified in the parent override file.' %
-                         spi.version
+    commit_unapplied_patches_import(
+        repo,
+        spi,
+        unapplied_import_tree_hash,
+        namespace,
+        unapplied_publish_parent_commit,
+        unapplied_changelog_parent_commit,
+        upload_parent_commit,
+                                        )
+
+    update_devel_branches(
+        repo=repo,
+        namespace=namespace,
+        pkgname=spi.name,
+        ubuntu_sinfo=ubuntu_sinfo,
+        spi=spi,
+    )
+
+def import_applied_spi(repo, spi, namespace, ubuntu_sinfo):
+    """Imports a source package from Launchpad into the git
+    repository
+
+    Arguments:
+    spi - a SourcePackageInformation instance
+    """
+    pretty_head_name = spi.pretty_head_name
+
+    logging.info('Importing patches-applied %s to %s' % (spi.version, pretty_head_name))
+    applied_tip_head = repo.get_head_by_name(spi.applied_head_name(namespace))
+
+    spi.pull()
+
+    repo.clean_repository_state()
+
+    unapplied_parent_tag = repo.get_import_tag(spi.version, namespace)
+    unapplied_parent_commit = str(unapplied_parent_tag.peel().id)
+    unapplied_import_tree_hash = str(unapplied_parent_tag.peel(pygit2.Tree).id)
+    logging.debug('Found patches-unapplied version %s as commit %s',
+                  str(spi.version), unapplied_parent_commit)
+
+    import_tree_versions = repo.get_all_changelog_versions_from_treeish(
+                               unapplied_import_tree_hash
+                                                                       )
+    changelog_version = import_tree_versions[0]
+
+    applied_tip_version = None
+    # check if the version to import has already been imported to
+    # this head
+    if applied_tip_head is not None:
+        if repo.treeishs_identical(
+                unapplied_import_tree_hash, str(applied_tip_head.peel().id)
+            ):
+            logging.warn('%s is identical to %s',
+                         pretty_head_name, spi.version
                         )
+            return
+        applied_tip_version, _ = repo.get_changelog_versions_from_treeish(
+                             str(applied_tip_head.peel().id),
+                                                                 )
 
-            (_, _,
-             applied_publish_parent_commit,
-             applied_changelog_parent_commit) = self.override_parents(spi)
-        else:
-            # Get parent from publishing history (which is the last
-            # published version in the corresponding series)
-            try:
-                applied_publish_parent_commit = str(applied_tip_head.peel().id)
-            except AttributeError:
-                try:
-                    applied_publish_parent_head = self.local_repo.get_head_by_name(spi.applied_parent_head_name(self.namespace))
-                    applied_publish_parent_head_commit = str(applied_publish_parent_head.peel().id)
-                except AttributeError:
-                    pass
-
-            if version_compare(str(spi.version), applied_tip_version) <= 0:
-                logging.warn('Version to import (%s) is not after %s tip (%s)',
-                             spi.version, pretty_head_name, applied_tip_version
-                            )
+    logging.debug('Tip version is %s', applied_tip_version)
 
-            # Walk changelog backwards until we find an imported version
-            for version in import_tree_versions:
-                applied_changelog_parent_tag = self.local_repo.get_applied_tag(version, self.namespace)
-                if applied_changelog_parent_tag is not None:
-                    # sanity check that version from d/changelog of the
-                    # tagged parent matches ours
-                    parent_changelog_version, _ = \
-                        self.local_repo.get_changelog_versions_from_treeish(
-                            str(applied_changelog_parent_tag.peel(pygit2.Tree).id),
-                                                                )
-                    # if the parent was imported via a parent override
-                    # itself, assume it is valid without checking its
-                    # tree's debian/changelog, as it wasn't used
-                    if (version not in self.parent_overrides and
-                        parent_changelog_version != version
-                       ):
-                        logging.error('Found a tag corresponding to '
-                                      'parent version %s, but d/changelog '
-                                      'version (%s) differs. Will '
-                                      'orphan commit.' % (
-                                      version,
-                                      parent_changelog_version
-                                      )
-                                     )
-                    else:
-                        applied_changelog_parent_commit = str(applied_changelog_parent_tag.peel().id)
-                        logging.debug('Changelog parent (tag) is %s',
-                            self.local_repo.tag_to_pretty_name(applied_changelog_parent_tag)
-                                    )
-                    break
-
-        # If the two parents are tree-identical, then favor publication
-        # history. This deals with copy-forwards between series and with
-        # syncs.
-        if self.local_repo.treeishs_identical(applied_publish_parent_commit, applied_changelog_parent_commit):
-            applied_changelog_parent_commit = None
-
-        # Assume no patches to apply
-        applied_import_tree_hash = unapplied_import_tree_hash
-        # get tree id from above commit
-        for (applied_import_tree_hash, patch_name, patch_desc) in self.import_patches_applied_tree(spi.dsc_pathname):
-            # special case for .pc removal
-            if patch_name is None:
-                msg = b'%b.' % (patch_desc.encode())
-            else:
-                if patch_desc is None:
-                    patch_desc = '%s\n\nNo DEP3 Subject or Description header found' % patch_name
-                msg = b'%b\n\nGbp-Pq: %b.' % (patch_desc.encode(), patch_name.encode())
-            unapplied_parent_commit = self.local_repo.commit_tree_hash(
-                applied_import_tree_hash,
-                [unapplied_parent_commit],
-                msg,
-                spi)
-
-            logging.debug('Committed patch-application of %s as %s',
-                         patch_name, unapplied_parent_commit
-                        )
+    applied_publish_parent_commit = None
+    applied_changelog_parent_commit = None
 
-        self.commit_applied_patches_import(
-            spi,
-            applied_import_tree_hash,
+    if spi.version in _PARENT_OVERRIDES:
+        logging.debug('%s is specified in the parent override file.' %
+                     spi.version
+                    )
+
+        (
+            _,
+            _,
             applied_publish_parent_commit,
             applied_changelog_parent_commit,
-            unapplied_parent_commit
-                                          )
-
-        self.update_applied_devel_branches(spi)
-
-    def import_publishes(self, patches_applied,
-                         debian_head_versions, ubuntu_head_versions):
-        history_found = False
-        only_debian = False
-        srcpkg_information = None
-        if patches_applied:
-            namespace = '%s/applied' % self.namespace
-            import_type = 'patches-applied'
-            import_func =  self.import_applied_spi
-        else:
-            namespace = self.namespace
-            import_type = 'patches-unapplied'
-            import_func =  self.import_unapplied_spi
-        for distname, versions, dist_sinfo in (
-                ("debian", debian_head_versions, self.debian_sinfo),
-                ("ubuntu", ubuntu_head_versions, self.ubuntu_sinfo)):
-            if self.active_series_only and distname == "debian":
-                continue
-            try:
-                for srcpkg_information in dist_sinfo.launchpad_versions_published_after(
-                    versions,
-                    namespace,
-                    workdir=self.workdir,
-                    active_series_only=self.active_series_only
-                ):
-                    history_found = True
-                    import_func(srcpkg_information)
-                # Do not push upstream
-                if self.fixup_devel and distname == "ubuntu":
-                    self.update_devel_branches(spi=None)
-            except NoPublicationHistoryException:
-                logging.warning("No publication history found for %s in %s. ",
-                                self.pkgname, distname)
-                if distname == 'ubuntu':
-                    only_debian = True
-            except Exception as e:
-                if srcpkg_information is None:
-                    msg = 'Unable to import %s to %s' % (import_type, distname)
-                else:
-                    msg = 'Unable to import %s %s to %s' % (import_type,
-                         str(srcpkg_information.version), distname)
-                if not patches_applied:
-                    raise GitUbuntuImportError(msg) from e
-                else:
-                    logging.error(msg)
-            else:
-                history_found = True
-
-        return (only_debian, history_found)
-
-    def main(self, args):
-        self.pkgname = args.package
-        owner = args.lp_owner
-        no_clean = args.no_clean
-        try:
-            directory = args.directory
-            no_clean = True
-        except AttributeError:
-            directory = None
-        try:
-            user = args.lp_user
-        except AttributeError:
-            user = None
-        # --active-series-only/--no-fetch to a tmpdir/--skip-orig
-        # implies --no-push
-        no_push = (
-            args.no_push or
-            (args.no_fetch and not directory) or
-            args.active_series_only or
-            args.skip_orig
-        )
+        ) = override_parents(
+            repo,
+            spi,
+            namespace,
+         )
+    else:
+        # Get parent from publishing history (which is the last
+        # published version in the corresponding series)
         try:
-            dl_cache = args.dl_cache
+            applied_publish_parent_commit = str(applied_tip_head.peel().id)
         except AttributeError:
-            dl_cache = None
-        self.fixup_devel = args.fixup_devel
-        self.active_series_only = args.active_series_only
-        self.skip_orig = args.skip_orig
-
-        if owner == 'usd-import-team':
-            self.namespace = 'importer'
-        else:
-            self.namespace = owner
-
-        logging.info('Ubuntu Server Team importer v%s' % VERSION)
-
-        self.local_repo = GitUbuntuRepository(directory, user, args.proto)
-        if not directory:
-            logging.info('Using git repository at %s', self.local_repo.local_dir)
-
-        atexit.register(self.cleanup, no_clean, self.local_repo.local_dir)
-
-        self.local_repo.add_base_remotes(self.pkgname, repo_owner=owner)
-        if not args.no_fetch and not args.reimport:
-            try:
-                self.local_repo.fetch_base_remotes()
-            except GitUbuntuRepositoryFetchError:
-                pass
-
-        if not args.no_fetch:
-            self.local_repo.delete_branches_in_namespace(self.namespace)
-            self.local_repo.delete_tags_in_namespace(self.namespace)
-            self.local_repo.copy_base_references(self.namespace)
-
-        if not args.no_fetch and not args.reimport:
-            try:
-                self.local_repo.fetch_remote_refspecs('pkg',
-                    refspecs=['refs/tags/*:refs/tags/%s/*' % self.namespace],
-                )
-            except GitUbuntuRepositoryFetchError:
-                pass
-
-        if args.reimport:
-            if args.no_fetch:
-                logging.warning(
-                    "--reimport specified with --no-fetch. Upload "
-                    "tags would not be incorporated into the new import "
-                    "and would be lost forever. This is not currently "
-                    "supported and --no-fetch will be ignored for upload "
-                    "tags."
-                )
             try:
-                self.local_repo.fetch_remote_refspecs('pkg',
-                    refspecs=['refs/tags/upload/*:refs/tags/%s/upload/*' % self.namespace],
-                )
-            except GitUbuntuRepositoryFetchError:
+                applied_publish_parent_head = repo.get_head_by_name(spi.applied_parent_head_name(namespace))
+                applied_publish_parent_head_commit = str(applied_publish_parent_head.peel().id)
+            except AttributeError:
                 pass
 
-        self.local_repo.ensure_importer_branches_exist(self.namespace)
+        if version_compare(str(spi.version), applied_tip_version) <= 0:
+            logging.warn('Version to import (%s) is not after %s tip (%s)',
+                         spi.version, pretty_head_name, applied_tip_version
+                        )
 
-        self.debian_sinfo = GitUbuntuSourceInformation('debian',
-            self.pkgname, os.path.abspath(args.pullfile),
-            args.retries, args.retry_backoffs)
+        # Walk changelog backwards until we find an imported version
+        for version in import_tree_versions:
+            applied_changelog_parent_tag = repo.get_applied_tag(version, namespace)
+            if applied_changelog_parent_tag is not None:
+                # sanity check that version from d/changelog of the
+                # tagged parent matches ours
+                parent_changelog_version, _ = \
+                    repo.get_changelog_versions_from_treeish(
+                        str(applied_changelog_parent_tag.peel(pygit2.Tree).id),
+                                                            )
+                # if the parent was imported via a parent override
+                # itself, assume it is valid without checking its
+                # tree's debian/changelog, as it wasn't used
+                if (version not in _PARENT_OVERRIDES and
+                    parent_changelog_version != version
+                   ):
+                    logging.error('Found a tag corresponding to '
+                                  'parent version %s, but d/changelog '
+                                  'version (%s) differs. Will '
+                                  'orphan commit.' % (
+                                  version,
+                                  parent_changelog_version
+                                  )
+                                 )
+                else:
+                    applied_changelog_parent_commit = str(applied_changelog_parent_tag.peel().id)
+                    logging.debug('Changelog parent (tag) is %s',
+                        repo.tag_to_pretty_name(applied_changelog_parent_tag)
+                                )
+                break
 
-        self.ubuntu_sinfo = GitUbuntuSourceInformation('ubuntu',
-            self.pkgname, os.path.abspath(args.pullfile),
-            args.retries, args.retry_backoffs)
+    # If the two parents are tree-identical, then favor publication
+    # history. This deals with copy-forwards between series and with
+    # syncs.
+    if repo.treeishs_identical(applied_publish_parent_commit, applied_changelog_parent_commit):
+        applied_changelog_parent_commit = None
 
-        debian_head_versions = (
-            self.local_repo.get_heads_and_versions('debian', self.namespace)
-        )
-        for head_name in sorted(debian_head_versions):
-            _, _, pretty_head_name = head_name.partition('%s/' % self.namespace)
-            logging.debug('Last imported %s version is %s',
-                pretty_head_name,
-                debian_head_versions[head_name]['version']
+    # Assume no patches to apply
+    applied_import_tree_hash = unapplied_import_tree_hash
+    # get tree id from above commit
+    for (
+       applied_import_tree_hash,
+       patch_name,
+       patch_desc
+    ) in import_patches_applied_tree(repo, spi.dsc_pathname):
+        # special case for .pc removal
+        if patch_name is None:
+            msg = b'%b.' % (patch_desc.encode())
+        else:
+            if patch_desc is None:
+                patch_desc = (
+                    "%s\n\nNo DEP3 Subject or Description header found" %
+                     patch_name
+                )
+            msg = b'%b\n\nGbp-Pq: %b.' % (
+                patch_desc.encode(),
+                patch_name.encode()
             )
+        unapplied_parent_commit = repo.commit_tree_hash(
+            applied_import_tree_hash,
+            [unapplied_parent_commit],
+            msg,
+            spi
+        )
 
-        ubuntu_head_versions = (
-            self.local_repo.get_heads_and_versions('ubuntu', self.namespace)
+        logging.debug(
+            "Committed patch-application of %s as %s",
+            patch_name, unapplied_parent_commit
         )
-        for head_name in sorted(ubuntu_head_versions):
-            _, _, pretty_head_name = head_name.partition('%s/' % self.namespace)
-            logging.debug('Last imported %s version is %s',
-                pretty_head_name,
-                ubuntu_head_versions[head_name]['version']
-                )
 
-        if not args.skip_applied:
-            applied_debian_head_versions = (
-                self.local_repo.get_heads_and_versions(
-                    'applied/debian', self.namespace
-                )
-            )
-            for head_name in sorted(applied_debian_head_versions):
-                _, _, pretty_head_name = head_name.partition(
-                    '%s/' % self.namespace
-                )
-                logging.debug('Last applied %s version is %s',
-                    pretty_head_name,
-                    applied_debian_head_versions[head_name]['version']
+    commit_applied_patches_import(
+        repo,
+        spi,
+        applied_import_tree_hash,
+        namespace,
+        applied_publish_parent_commit,
+        applied_changelog_parent_commit,
+        unapplied_parent_commit,
+    )
+
+    update_applied_devel_branches(
+        repo=repo,
+        pkgname=spi.name,
+        namespace=namespace,
+        ubuntu_sinfo=ubuntu_sinfo,
+        spi=spi,
+    )
+
+def import_publishes(repo, pkgname, namespace, patches_applied,
+    debian_head_versions, ubuntu_head_versions, debian_sinfo,
+    ubuntu_sinfo, active_series_only, workdir, fixup_devel, 
+    skip_orig,
+):
+    history_found = False
+    only_debian = False
+    srcpkg_information = None
+    if patches_applied:
+        _namespace = namespace
+        namespace = '%s/applied' % namespace
+        import_type = 'patches-applied'
+        import_func =  import_applied_spi
+    else:
+        _namespace = namespace
+        import_type = 'patches-unapplied'
+        import_func =  functools.partial(
+            import_unapplied_spi,
+            skip_orig=skip_orig
+        )
+    for distname, versions, dist_sinfo in (
+            ("debian", debian_head_versions, debian_sinfo),
+            ("ubuntu", ubuntu_head_versions, ubuntu_sinfo)):
+        if active_series_only and distname == "debian":
+            continue
+        try:
+            for srcpkg_information in dist_sinfo.launchpad_versions_published_after(
+                versions,
+                namespace,
+                workdir=workdir,
+                active_series_only=active_series_only
+            ):
+                history_found = True
+                import_func(
+                    repo=repo,
+                    spi=srcpkg_information,
+                    namespace=_namespace,
+                    ubuntu_sinfo=ubuntu_sinfo,
                 )
-
-            applied_ubuntu_head_versions = (
-                self.local_repo.get_heads_and_versions(
-                    'applied/ubuntu', self.namespace
+            # Do not push upstream
+            if fixup_devel and distname == "ubuntu":
+                update_devel_branches(
+                    repo=repo,
+                    namespace=namespace,
+                    pkgname=pkgname,
+                    ubuntu_sinfo=ubuntu_sinfo,
+                    spi=None,
                 )
+        except NoPublicationHistoryException:
+            logging.warning("No publication history found for %s in %s.",
+                pkgname, distname
             )
-            for head_name in sorted(applied_ubuntu_head_versions):
-                _, _, pretty_head_name = head_name.partition(
-                    '%s/' % self.namespace
-                )
-                logging.debug('Last applied %s version is %s',
-                    pretty_head_name,
-                    applied_ubuntu_head_versions[head_name]['version']
-                )
-
-        oldcwd = os.getcwd()
-        os.chdir(self.local_repo.local_dir)
-
-        if dl_cache is None:
-            self.workdir = os.path.join(self.local_repo.git_dir, CACHE_PATH)
-        else:
-            self.workdir = dl_cache
-
-        os.makedirs(self.workdir, exist_ok=True)
-
-        self.parse_parentfile(args.parentfile)
-
-        only_debian, history_found = self.import_publishes(
-            patches_applied=False,
-            debian_head_versions=debian_head_versions,
-            ubuntu_head_versions=ubuntu_head_versions)
-
-        if not history_found:
-            logging.error("No publication history for '%s' in debian or ubuntu."
-                          "  Wrong source package name?", self.pkgname)
-            sys.exit(1)
-
-        if not args.skip_applied:
-            self.import_publishes(patches_applied=True,
-                debian_head_versions=applied_debian_head_versions,
-                ubuntu_head_versions=applied_ubuntu_head_versions)
-
-        os.chdir(oldcwd)
-
-        self.local_repo.garbage_collect()
-
-        if no_push:
-            logging.info('Not pushing to remote as specified')
+            if distname == 'ubuntu':
+                only_debian = True
+        except Exception as e:
+            if srcpkg_information is None:
+                msg = 'Unable to import %s to %s' % (import_type, distname)
+            else:
+                msg = 'Unable to import %s %s to %s' % (import_type,
+                     str(srcpkg_information.version), distname)
+            #if not patches_applied:
+            raise GitUbuntuImportError(msg) from e
+            #else:
+            #    logging.error(msg)
         else:
-            lp = launchpad_login_auth()
-            repo_path = '~%s/ubuntu/+source/%s/+git/%s' % (
-                owner,
-                self.pkgname,
-                self.pkgname,
-            )
-            lp_git_repo = lp.git_repositories.getByPath(path=repo_path)
-            if args.reimport:
-                if not lp_git_repo.canBeDeleted():
-                   logging.warning(
-                       "There are linked MPs to the pkg repository, "
-                       "which will be deleted:"
-                   )
-                   for mp in lp_git_repo.landing_candidates:
-                       logging.warning(
-                           "Adding comment to %s indicating reimport",
-                           mp.web_link
-                       )
-                       mp.createComment(
-                           content="%s has been reimported and this MP "
-                               "must be manually resubmitted." %
-                               self.pkgname,
-                           subject="%s has been reimported" % self.pkgname,
+            history_found = True
+
+    return (only_debian, history_found)
+
+
+def parse_args(subparsers=None, base_subparsers=None):
+    kwargs = dict(description='Update a launchpad git tree based upon '
+                              'the state of the Ubuntu and Debian archives',
+                  formatter_class=argparse.ArgumentDefaultsHelpFormatter
+                 )
+    if base_subparsers:
+        kwargs['parents'] = base_subparsers
+    if subparsers:
+        parser = subparsers.add_parser('import', **kwargs)
+        parser.set_defaults(func=cli_main)
+    else:
+        parser = argparse.ArgumentParser(**kwargs)
+    parser.add_argument('package', type=str,
+                        help='Which package to update in the git tree')
+    parser.add_argument('-o', '--lp-owner', type=str,
+                        help=argparse.SUPPRESS,
+                        default='usd-import-team')
+    parser.add_argument('-l', '--lp-user', type=str,
+                        help=argparse.SUPPRESS)
+    parser.add_argument('--dl-cache', type=str,
+                        help=('Cache directory for downloads. Default is to '
+                              'put downloads in <directory>/.git/%s' %
+                              CACHE_PATH
+                             ),
+                        default=argparse.SUPPRESS)
+    parser.add_argument('--no-fetch', action='store_true',
+                        help='Do not fetch from the remote (DANGEROUS; '
+                             'only useful for debugging); implies '
+                             '--no-push')
+    parser.add_argument('--no-push', action='store_true',
+                        help='Do not push to the remote')
+    parser.add_argument('--no-clean', action='store_true',
+                        help='Do not clean the temporary directory')
+    parser.add_argument('-d', '--directory', type=str,
+                        help='Use git repository at specified location rather '
+                             'than a temporary directory (implies --no-clean). '
+                             'Will create the local repository if needed.',
+                        default=argparse.SUPPRESS
                        )
-                       # repo deletion will delete the MP, but hopefully
-                       # the above comment will be sufficient to explain
-                       # why
-                lp_git_repo.lp_delete()
-
-            self.local_repo.git_run([
-                'push', '--atomic', 'pkg',
-                'refs/heads/%s/*:refs/heads/*' % self.namespace,
-                'refs/tags/%s/*:refs/tags/*' % self.namespace,
-            ])
-            # update our reference
-            lp_git_repo = lp.git_repositories.getByPath(path=repo_path)
-            for i in range(args.retries):
-                try:
-                    if only_debian:
-                        lp_git_repo.default_branch = 'refs/heads/debian/sid'
-                    else:
-                        lp_git_repo.default_branch = 'refs/heads/ubuntu/devel'
-                    lp_git_repo.lp_save()
-                    break
-                except (NotFound, PreconditionFailed) as e:
-                    time.sleep(args.retry_backoffs[i])
-                    lp_git_repo.lp_refresh()
+    parser.add_argument('--fixup-devel', action='store_true',
+                        help=argparse.SUPPRESS)
+    parser.add_argument('--active-series-only', action='store_true',
+                        help='Do an import of only active Ubuntu series '
+                             'history, implies --no-push.')
+    parser.add_argument('--skip-applied', action='store_true',
+                        help=argparse.SUPPRESS)
+    parser.add_argument('--skip-orig', action='store_true',
+                        help=argparse.SUPPRESS)
+    parser.add_argument('--reimport', action='store_true',
+                        help=argparse.SUPPRESS)
+    if not subparsers:
+        return parser.parse_args()
+    return 'import - %s' % kwargs['description']
+
+def cli_main(args):
+    no_clean = args.no_clean
+    try:
+        directory = args.directory
+        no_clean = True
+    except AttributeError:
+        directory = None
+    try:
+        user = args.lp_user
+    except AttributeError:
+        user = None
+    # --active-series-only/--no-fetch to a tmpdir/--skip-orig
+    # implies --no-push
+    no_push = (
+        args.no_push or
+        (args.no_fetch and not directory) or
+        args.active_series_only or
+        args.skip_orig
+    )
+    try:
+        dl_cache = args.dl_cache
+    except AttributeError:
+        dl_cache = None
+
+    main(
+        args.package,
+        args.lp_owner,
+        no_clean,
+        directory,
+        user,
+        args.proto,
+        args.no_fetch,
+        no_push,
+        dl_cache,
+        args.fixup_devel,
+        args.active_series_only,
+        args.skip_orig,
+        args.pullfile,
+        args.parentfile,
+        args.retries,
+        args.retry_backoffs,
+        args.skip_applied,
+        args.reimport,
+    )
diff --git a/gitubuntu/importlocal.py b/gitubuntu/importlocal.py
index bf1700e..c237551 100644
--- a/gitubuntu/importlocal.py
+++ b/gitubuntu/importlocal.py
@@ -2,15 +2,22 @@ import argparse
 import glob
 import logging
 import os
-import re
-from subprocess import CalledProcessError
 import sys
 import tempfile
 from gitubuntu.dsc import GitUbuntuDsc
 from gitubuntu.git_repository import GitUbuntuRepository, git_dep14_tag
-from gitubuntu.run import decode_binary, run, runq
+from gitubuntu.run import run, runq
 from gitubuntu.version import VERSION
-from gitubuntu.importer import GitUbuntuImport
+from gitubuntu.importer import (
+    parse_parentfile,
+    _PARENT_OVERRIDES,
+    import_orig,
+    import_dsc,
+    get_changelog_for_commit,
+    import_patches_unapplied_tree,
+    import_patches_applied_tree,
+)
+from gitubuntu.source_information import derive_source_from_series
 from gitubuntu.versioning import version_compare
 try:
     pkg = 'python3-pygit2'
@@ -20,264 +27,309 @@ except ImportError:
     sys.exit(1)
 
 
-class GitUbuntuImportLocal(GitUbuntuImport):
-    def __init__(self):
-        self.parent_overrides = None
-
-    def parse_args(self, subparsers=None, base_subparsers=None):
-        kwargs = dict(description='Import a DSC file locally',
-                      #usage='%(prog)s [options] -- ...',
-                      epilog='Unlike Launchpad imports, local imports '
-                             'require specifying a namespace to uniquely '
-                             'identify the source of the DSC file. This '
-                             'means that if you want to tie history '
-                             'together for several DSCs from the same '
-                             'source, you must use the same namespace value.',
-                      formatter_class=argparse.ArgumentDefaultsHelpFormatter
-                     )
-        if base_subparsers:
-            kwargs['parents'] = base_subparsers
-        if subparsers:
-            parser = subparsers.add_parser('import-local', **kwargs)
-            parser.set_defaults(func=self.main)
-        else:
-            parser = argparse.ArgumentParser(**kwargs)
-        parser.add_argument('namespace',
-                            help='String namespace to use for tagging the imports')
-        parser.add_argument('-d', '--directory', type=str,
-                            help='Use git repository at specified location rather '
-                                 'than a temporary directory. '
-                                 'Will create the local repository if needed.',
-                            default=argparse.SUPPRESS
-                           )
-        parser.add_argument('dsc', type=str,
-                            help='Path to or URL of DSC file')
-        parser.add_argument('--skip-applied', action='store_true',
-                            help=argparse.SUPPRESS)
-        parser.add_argument('--skip-orig', action='store_true',
-                            help=argparse.SUPPRESS)
-        if not subparsers:
-            return parser.parse_args()
-        return 'import-local - %s' % kwargs['description']
-
-    def main(self, args):
-        try:
-            directory = args.directory
-            no_clean = True
-        except AttributeError:
-            directory = None
-        self.namespace = args.namespace
-        self.dsc_path = args.dsc
-        self.skip_applied = args.skip_applied
-        self.skip_orig = args.skip_orig
-
-        self.local_repo = GitUbuntuRepository(directory)
-        if not directory:
-            logging.info('Using git repository at %s', self.local_repo.local_dir)
-
-        self.local_repo.ensure_importer_branches_exist(self.namespace)
-        if len(self.local_repo.raw_repo.status()) != 0:
-            logging.error('Working tree must be clean to continue.')
-            run(['git', 'status'], stdout=None)
-            sys.exit(1)
-
-        if os.path.exists(self.dsc_path):
-            self.dsc_path = os.path.abspath(self.dsc_path)
-        else:
-            dsc_dir = tempfile.mkdtemp()
-
-            oldcwd = os.getcwd()
-            os.chdir(dsc_dir)
-
-            runq(['dget', '--quiet', '--allow-unauthenticated',
-                  '--download-only', self.dsc_path])
-            dscs = glob.glob(os.path.join(dsc_dir, '*.dsc'))
-            if len(dscs) == 0:
-                logging.error('Unable to obtain DSC file.')
-                sys.exit(1)
-            if len(dscs) > 1:
-                logging.error('Multiple DSCs found in temporary directory.')
-                sys.exit(1)
-            self.dsc_path = os.path.join(dsc_dir, dscs[0])
-            os.chdir(oldcwd)
-        logging.debug('Importing DSC at local path %s' % self.dsc_path)
-        self.dsc = GitUbuntuDsc(self.dsc_path)
-        if not self.dsc.verify():
-            logging.error('Unable to verify orig tarball specified by DSC %s',
-                          self.dsc_path)
-            sys.exit(1)
-
-        self.pkgname = self.dsc['Source']
+def main(
+    directory,
+    namespace,
+    dsc_path,
+    skip_applied,
+    skip_orig,
+    parentfile,
+):
+    repo = GitUbuntuRepository(directory)
+    if not directory:
+        logging.info('Using git repository at %s', repo.local_dir)
+
+    repo.ensure_importer_branches_exist(namespace)
+    if len(repo.raw_repo.status()) != 0:
+        logging.error('Working tree must be clean to continue.')
+        run(['git', 'status'], stdout=None)
+        sys.exit(1)
+
+    if os.path.exists(dsc_path):
+        dsc_path = os.path.abspath(dsc_path)
+    else:
+        dsc_dir = tempfile.mkdtemp()
 
         oldcwd = os.getcwd()
-        os.chdir(self.local_repo.local_dir)
-
-        self.local_repo.clean_repository_state()
+        os.chdir(dsc_dir)
 
-        self.parse_parentfile(args.parentfile)
-
-        unapplied_import_tree_hash = self.import_patches_unapplied_tree(self.dsc_path)
-
-        import_tree_versions = self.local_repo.get_all_changelog_versions_from_treeish(
-                                   unapplied_import_tree_hash
-                                                                           )
-
-        changelog_version = import_tree_versions[0]
-
-        logging.debug(
-            'Found changelog version %s in newly imported tree' %
-            changelog_version
-                    )
-
-        head = None
-        head_version = None
-        if not self.local_repo.raw_repo.head_is_unborn:
-            head = self.local_repo.raw_repo.head
-        # check if the version to import has already been imported to
-        # this head
-        if head is not None:
-            head_version, _ = self.local_repo.get_changelog_versions_from_treeish(
-                                 str(head.peel().id))
-
-        logging.debug('Head version is %s', head_version)
-
-        unapplied_changelog_parent_commit = None
-        applied_changelog_parent_commit = None
-
-        if version_compare(changelog_version, head_version) <= 0:
-            logging.warn('Version to import (%s) is not after HEAD '
-                         'version (%s), history may not make sense.',
-                         changelog_version, head_version
-                        )
-
-        # Walk changelog backwards until we find an imported version
-        for version in import_tree_versions:
-            unapplied_tag_ref = '%s/import/%s' % (self.namespace, git_dep14_tag(version))
-            applied_tag_ref = '%s/applied/%s' % (self.namespace, git_dep14_tag(version))
-            unapplied_changelog_parent_tag = self.local_repo.get_tag_reference(unapplied_tag_ref)
-            applied_changelog_parent_tag = self.local_repo.get_tag_reference(applied_tag_ref)
-            if unapplied_changelog_parent_tag is not None:
-                # sanity check that version from d/changelog of the
-                # tagged parent matches ours
-                parent_changelog_version, _ = \
-                    self.local_repo.get_changelog_versions_from_treeish(
-                        str(unapplied_changelog_parent_tag.peel(pygit2.Tree).id),
-                                                            )
-                # if the parent was imported via a parent override
-                # itself, assume it is valid without checking its
-                # tree's debian/changelog, as it wasn't used
-                if (version not in self.parent_overrides and
-                    parent_changelog_version != version
-                   ):
-                    logging.error('Found a tag corresponding to '
-                                  'parent version %s, but d/changelog '
-                                  'version (%s) differs. Will '
-                                  'orphan commit.' % (
-                                  version,
-                                  parent_changelog_version
-                                  )
-                                 )
-                else:
-                    unapplied_changelog_parent_commit = str(unapplied_changelog_parent_tag.peel().id)
-                    if applied_changelog_parent_tag:
-                        applied_changelog_parent_commit = str(applied_changelog_parent_tag.peel().id)
-                    logging.debug('Changelog parent (tag) is %s',
-                        self.local_repo.tag_to_pretty_name(unapplied_changelog_parent_tag)
-                                )
-                break
-
-        distribution = self.local_repo.get_changelog_distribution_from_treeish(unapplied_import_tree_hash)
-        # do lookup of series for dist on lp?
-        dist = 'ubuntu'
-        if distribution in ("stable", "testing", "unstable", "experimental"):
-            dist = 'debian'
-        self.import_dsc(self.dsc, changelog_version, dist)
-        try:
-            if not self.skip_orig:
-                self.import_orig(self.dsc, changelog_version, dist)
-        except Exception as e:
-            logging.error('Unable to import orig tarball for %s: %s',
-                          changelog_version, e)
+        runq(['dget', '--quiet', '--allow-unauthenticated',
+              '--download-only', dsc_path])
+        dscs = glob.glob(os.path.join(dsc_dir, '*.dsc'))
+        if len(dscs) == 0:
+            logging.error('Unable to obtain DSC file.')
             sys.exit(1)
-
-        msg = (b'Import unapplied version %b\n\nImported using git-ubuntu-import.' %
-               (changelog_version.encode())
-              )
-
-        parents = []
-
-        tag = None
-        tag_ref = '%s/import/%s' % (self.namespace,
-                                    git_dep14_tag(changelog_version))
-        if self.local_repo.get_tag_reference(tag_ref) is None:
-            # Not imported before
-            tag = tag_ref
-
-        if unapplied_changelog_parent_commit is not None:
-            msg += b'\n'
-            parents.append(unapplied_changelog_parent_commit)
-            msg += b'\nChangelog parent: %b' % unapplied_changelog_parent_commit.encode()
-
-        changelog_entry = self.get_changelog_for_commit(
-                              unapplied_import_tree_hash,
-                              None,
-                              unapplied_changelog_parent_commit
-                                                       )
-
-        msg += b'%b' % changelog_entry
-        unapplied_parent_commit = self.local_repo.commit_tree_hash(
-            unapplied_import_tree_hash, parents, msg)
-        if tag is None:
-            logging.info('Committed unapplied import of %s as %s',
-                              changelog_version, unapplied_parent_commit)
-        else:
-            logging.debug('Creating tag %s pointing to %s', tag,
-                          unapplied_parent_commit)
-            self.local_repo.git_run(['tag', '-a', '-m', 'git-ubuntu import v%s' % VERSION,
-                          tag, unapplied_parent_commit
-                         ]
-                        )
-
-        if not args.skip_applied:
-             # Assume no patches to apply
-             applied_import_tree_hash = unapplied_import_tree_hash
-             for (applied_import_tree_hash, patch_name, patch_desc) in self.import_patches_applied_tree(self.dsc_path):
-                 # special case for .pc removal
-                 if patch_name is None:
-                     msg = b'%b.' % (patch_desc.encode())
-                 else:
-                     if patch_desc is None:
-                         patch_desc = '%s\n\nNo DEP3 Subject or Description header found' % patch_name
-                     msg = b'%b\n\nGbp-Pq: %b.' % (patch_desc.encode(), patch_name.encode())
-                 unapplied_parent_commit = self.local_repo.commit_tree_hash(
-                     applied_import_tree_hash,
-                     [unapplied_parent_commit],
-                     msg)
-
-                 logging.debug('Committed patch-application of %s as %s',
-                               patch_name, unapplied_parent_commit
-                              )
-
-             tag = None
-             tag_ref = '%s/applied/%s' % (self.namespace,
-                                          git_dep14_tag(changelog_version))
-             if self.local_repo.get_tag_reference(tag_ref) is None:
-                 # Not imported before
-                 tag= tag_ref
-
-             if tag is None:
-                 logging.info('Committed applied import of %s as %s',
-                              changelog_version, unapplied_parent_commit)
-             else:
-                 logging.debug('Creating tag %s pointing to %s', tag,
-                               unapplied_parent_commit)
-                 self.local_repo.git_run(['tag', '-a', '-m', 'git-ubuntu import v%s' % VERSION,
-                                         tag, unapplied_parent_commit
-                          ]
-                         )
-
-        self.local_repo.clean_repository_state()
-
+        if len(dscs) > 1:
+            logging.error('Multiple DSCs found in temporary directory.')
+            sys.exit(1)
+        dsc_path = os.path.join(dsc_dir, dscs[0])
         os.chdir(oldcwd)
-
-        self.local_repo.garbage_collect()
+    logging.debug('Importing DSC at local path %s', dsc_path)
+    dsc = GitUbuntuDsc(dsc_path)
+    if not dsc.verify():
+        logging.error(
+            'Unable to verify orig tarball specified by DSC %s',
+            dsc_path,
+        )
+        sys.exit(1)
+
+    pkgname = dsc['Source']
+
+    oldcwd = os.getcwd()
+    os.chdir(repo.local_dir)
+
+    repo.clean_repository_state()
+
+    parse_parentfile(parentfile, pkgname)
+
+    unapplied_import_tree_hash = import_patches_unapplied_tree(repo, dsc_path)
+
+    import_tree_versions = repo.get_all_changelog_versions_from_treeish(
+        unapplied_import_tree_hash
+    )
+
+    changelog_version = import_tree_versions[0]
+
+    logging.debug(
+        'Found changelog version %s in newly imported tree',
+        changelog_version
+    )
+
+    head = None
+    head_version = None
+    if not repo.raw_repo.head_is_unborn:
+        head = repo.raw_repo.head
+    # check if the version to import has already been imported to
+    # this head
+    if head is not None:
+        head_version, _ = repo.get_changelog_versions_from_treeish(
+            str(head.peel().id)
+        )
+
+    logging.debug('Head version is %s', head_version)
+
+    unapplied_changelog_parent_commit = None
+    applied_changelog_parent_commit = None
+
+    if version_compare(changelog_version, head_version) <= 0:
+        logging.warn('Version to import (%s) is not after HEAD '
+            'version (%s), history may not make sense.',
+            changelog_version, head_version
+        )
+
+    # Walk changelog backwards until we find an imported version
+    for version in import_tree_versions:
+        unapplied_tag_ref = '%s/import/%s' % (namespace, git_dep14_tag(version))
+        applied_tag_ref = '%s/applied/%s' % (namespace, git_dep14_tag(version))
+        unapplied_changelog_parent_tag = repo.get_tag_reference(unapplied_tag_ref)
+        applied_changelog_parent_tag = repo.get_tag_reference(applied_tag_ref)
+        if unapplied_changelog_parent_tag is not None:
+            # sanity check that version from d/changelog of the
+            # tagged parent matches ours
+            parent_changelog_version, _ = \
+                repo.get_changelog_versions_from_treeish(
+                    str(unapplied_changelog_parent_tag.peel(pygit2.Tree).id),
+                )
+            # if the parent was imported via a parent override
+            # itself, assume it is valid without checking its
+            # tree's debian/changelog, as it wasn't used
+            if (version not in _PARENT_OVERRIDES and
+                parent_changelog_version != version
+            ):
+                logging.error('Found a tag corresponding to '
+                    'parent version %s, but d/changelog '
+                    'version (%s) differs. Will '
+                    'orphan commit.',
+                    version,
+                    parent_changelog_version
+                 )
+            else:
+                unapplied_changelog_parent_commit = str(
+                    unapplied_changelog_parent_tag.peel().id
+                )
+                if applied_changelog_parent_tag:
+                    applied_changelog_parent_commit = str(
+                        applied_changelog_parent_tag.peel().id
+                    )
+                logging.debug('Changelog parent (tag) is %s',
+                    repo.tag_to_pretty_name(unapplied_changelog_parent_tag)
+                )
+            break
+
+    distribution = repo.get_changelog_distribution_from_treeish(
+        unapplied_import_tree_hash
+    )
+    dist = derive_source_from_series(distribution)
+    import_dsc(
+        repo=repo,
+        dsc=dsc,
+        namespace=namespace,
+        version=changelog_version,
+        dist=dist,
+    )
+    try:
+        if not skip_orig:
+            import_orig(
+                repo=repo,
+                dsc=dsc,
+                namespace=namespace,
+                version=changelog_version,
+                dist=dist,
+            )
+    except Exception as e:
+        logging.error('Unable to import orig tarball for %s: %s',
+                      changelog_version, e)
+        raise
+        sys.exit(1)
+
+    msg = (
+        b'Import unapplied version %b\n\nImported using git-ubuntu-import.' %
+        (changelog_version.encode())
+    )
+
+    parents = []
+
+    tag = None
+    tag_ref = '%s/import/%s' % (
+        namespace,
+        git_dep14_tag(changelog_version)
+    )
+    if repo.get_tag_reference(tag_ref) is None:
+        # Not imported before
+        tag = tag_ref
+
+    if unapplied_changelog_parent_commit is not None:
+        msg += b'\n'
+        parents.append(unapplied_changelog_parent_commit)
+        msg += b'\nChangelog parent: %b' % unapplied_changelog_parent_commit.encode()
+
+    changelog_entry = get_changelog_for_commit(
+        repo=repo,
+        tree_hash=unapplied_import_tree_hash,
+        publish_parent_commit=None,
+        changelog_parent_commit=unapplied_changelog_parent_commit,
+    )
+
+    msg += b'%b' % changelog_entry
+    unapplied_parent_commit = repo.commit_tree_hash(
+        unapplied_import_tree_hash, parents, msg
+    )
+    if tag is None:
+        logging.info('Committed unapplied import of %s as %s',
+                          changelog_version, unapplied_parent_commit)
+    else:
+        logging.debug('Creating tag %s pointing to %s', tag,
+                      unapplied_parent_commit
+        )
+        repo.git_run(['tag', '-a', '-m', 'git-ubuntu import v%s' % VERSION,
+                      tag, unapplied_parent_commit
+                     ]
+        )
+
+    if not skip_applied:
+         # Assume no patches to apply
+         applied_import_tree_hash = unapplied_import_tree_hash
+         for (
+             applied_import_tree_hash,
+             patch_name,
+             patch_desc,
+         ) in import_patches_applied_tree(repo, dsc_path):
+             # special case for .pc removal
+             if patch_name is None:
+                 msg = b'%b.' % (patch_desc.encode())
+             else:
+                 if patch_desc is None:
+                     patch_desc = '%s\n\nNo DEP3 Subject or Description header found' % patch_name
+                 msg = b'%b\n\nGbp-Pq: %b.' % (patch_desc.encode(), patch_name.encode())
+             unapplied_parent_commit = repo.commit_tree_hash(
+                 applied_import_tree_hash,
+                 [unapplied_parent_commit],
+                 msg)
+
+             logging.debug('Committed patch-application of %s as %s',
+                           patch_name, unapplied_parent_commit
+                          )
+
+         tag = None
+         tag_ref = '%s/applied/%s' % (namespace,
+                                      git_dep14_tag(changelog_version))
+         if repo.get_tag_reference(tag_ref) is None:
+             # Not imported before
+             tag = tag_ref
+
+         if tag is None:
+             logging.info('Committed applied import of %s as %s',
+                 changelog_version,
+                 unapplied_parent_commit
+             )
+         else:
+             logging.debug('Creating tag %s pointing to %s', tag,
+                 unapplied_parent_commit
+             )
+             repo.git_run(
+                 [
+                     'tag',
+                     '-a',
+                     '-m',
+                     'git-ubuntu import v%s' % VERSION,
+                     tag,
+                     unapplied_parent_commit,
+                 ]
+             )
+
+    repo.clean_repository_state()
+
+    os.chdir(oldcwd)
+
+    repo.garbage_collect()
+
+def parse_args(subparsers=None, base_subparsers=None):
+    kwargs = dict(description='Import a DSC file locally',
+                  #usage='%(prog)s [options] -- ...',
+                  epilog='Unlike Launchpad imports, local imports '
+                         'require specifying a namespace to uniquely '
+                         'identify the source of the DSC file. This '
+                         'means that if you want to tie history '
+                         'together for several DSCs from the same '
+                         'source, you must use the same namespace value.',
+                  formatter_class=argparse.ArgumentDefaultsHelpFormatter
+                 )
+    if base_subparsers:
+        kwargs['parents'] = base_subparsers
+    if subparsers:
+        parser = subparsers.add_parser('import-local', **kwargs)
+        parser.set_defaults(func=cli_main)
+    else:
+        parser = argparse.ArgumentParser(**kwargs)
+    parser.add_argument('namespace',
+                        help='String namespace to use for tagging the imports')
+    parser.add_argument('-d', '--directory', type=str,
+                        help='Use git repository at specified location rather '
+                             'than a temporary directory. '
+                             'Will create the local repository if needed.',
+                        default=argparse.SUPPRESS
+                       )
+    parser.add_argument('dsc', type=str,
+                        help='Path to or URL of DSC file')
+    parser.add_argument('--skip-applied', action='store_true',
+                        help=argparse.SUPPRESS)
+    parser.add_argument('--skip-orig', action='store_true',
+                        help=argparse.SUPPRESS)
+    if not subparsers:
+        return parser.parse_args()
+    return 'import-local - %s' % kwargs['description']
+
+def cli_main(args):
+    try:
+        directory = args.directory
+    except AttributeError:
+        directory = None
+
+    main(
+        directory,
+        args.namespace,
+        args.dsc,
+        args.skip_applied,
+        args.skip_orig,
+        args.parentfile,
+    )
diff --git a/gitubuntu/importppa.py b/gitubuntu/importppa.py
index a4a3ec1..b4790f1 100644
--- a/gitubuntu/importppa.py
+++ b/gitubuntu/importppa.py
@@ -10,8 +10,25 @@ from gitubuntu.git_repository import (
     GitUbuntuRepository,
     GitUbuntuRepositoryFetchError,
 )
-from gitubuntu.importer import GitUbuntuImport
-from gitubuntu.source_information import GitUbuntuSourceInformation, NoPublicationHistoryException, SourceExtractionException, launchpad_login_auth
+from gitubuntu.importer import (
+    cleanup,
+    parse_parentfile,
+    _PARENT_OVERRIDES,
+    import_orig,
+    import_dsc,
+    get_changelog_for_commit,
+    import_unapplied_spi,
+    import_applied_spi,
+    import_patches_unapplied_tree,
+    import_patches_applied_tree,
+)
+from gitubuntu.source_information import (
+    GitUbuntuSourceInformation,
+    NoPublicationHistoryException,
+    SourceExtractionException,
+    launchpad_login_auth,
+    GitUbuntuSourceInformation,
+)
 from gitubuntu.version import VERSION
 try:
     pkg = 'python3-pygit2'
@@ -23,181 +40,245 @@ except ImportError:
     sys.exit(1)
 
 
-class GitUbuntuImportPPA(GitUbuntuImport):
-    def __init__(self):
-        self.parent_overrides = None
-
-    def parse_args(self, subparsers=None, base_subparsers=None):
-        kwargs = dict(description='Update a launchpad git tree based upon '
-                                  'the state of a PPA archive',
-                      epilog='PPA must be specified as ppa:<name>',
-                      formatter_class=argparse.ArgumentDefaultsHelpFormatter
-                     )
-        if base_subparsers:
-            kwargs['parents'] = base_subparsers
-        if subparsers:
-            parser = subparsers.add_parser('import-ppa', **kwargs)
-            parser.set_defaults(func=self.main)
-        else:
-            parser = argparse.ArgumentParser(**kwargs)
-        parser.add_argument('ppa', type=str,
-                            help='Name of PPA to update in the git tree')
-        parser.add_argument('package', type=str,
-                            help='Which package to update in the git tree')
-        parser.add_argument('-o', '--lp-owner', type=str,
-                            help='Which launchpad user\'s tree to update',
-                            default='usd-import-team')
-        parser.add_argument('-l', '--lp-user', type=str,
-                            help='Specify the Launchpad user to use',
-                            default=getpass.getuser())
-        parser.add_argument('--dl-cache', type=str,
-                            help=('Cache directory for downloads. Default is to '
-                                  'put downloads in <directory>/.git/%s' %
-                                  CACHE_PATH
-                                 ),
-                            default=argparse.SUPPRESS)
-        parser.add_argument('--no-fetch', action='store_true',
-                            help='Do not fetch from the remote (DANGEROUS: '
-                                 'only useful for debugging); implies '
-                                 '--no-push')
-        parser.add_argument('--no-push', action='store_true',
-                            help='Do not push to the remote (WARNING: '
-                                 'PPA imports are a work-in-progress and '
-                                 'pushing is currently disabled)',
-                            default=True)
-        parser.add_argument('--no-clean', action='store_true',
-                            help='Do not clean the temporary directory')
-        parser.add_argument('-d', '--directory', type=str,
-                            help='Use git repository at specified location rather '
-                                 'than a temporary directory (implies --no-clean). '
-                                 'Will create the local repository if needed.',
-                            default=argparse.SUPPRESS
-                           )
-        if not subparsers:
-            return parser.parse_args()
-        return 'import-ppa - %s' % kwargs['description']
-
-    def main(self, args):
-        if re.match(r'ppa:\w+', args.ppa) is None:
-            logging.error('Specified PPA (%s) is not in the format '
-                          'ppa:<name>', args.ppa)
-            sys.exit(1)
-        ppa = args.ppa
-        pkgname = args.package
-        owner = args.lp_owner
-        user = args.lp_user
-        no_clean = args.no_clean
-        try:
-            directory = args.directory
-            no_clean = True
-        except AttributeError:
-            directory = None
-        no_push = True
-        try:
-            dl_cache = args.dl_cache
-        except AttributeError:
-            dl_cache = None
-
-        # what other transformations?
-        self.namespace = ppa.replace(':', '_')
-
-        logging.info('Ubuntu Server Team importer v%s' % VERSION)
-
-        self.local_repo = GitUbuntuRepository(directory, user, args.proto)
-        if not directory:
-            logging.info('Using git repository at %s', self.local_repo.local_dir)
-        self.local_repo.ensure_importer_branches_exist(self.namespace)
-
-        atexit.register(self.cleanup, no_clean, self.local_repo.local_dir)
-
-        self.local_repo.add_remote(pkgname, owner, self.namespace, user)
-        if not args.no_fetch:
+def main(
+    ppa,
+    pkgname,
+    directory,
+    owner,
+    user,
+    pullfile,
+    parentfile,
+    no_clean,
+    no_fetch,
+    no_push,
+    dl_cache,
+    proto,
+    retries,
+    retry_backoffs,
+    skip_orig,
+):
+    if re.match(r'ppa:\w+', ppa) is None:
+        logging.error(
+            "Specified PPA (%s) is not in the format ppa:<name>",
+            ppa,
+        )
+        sys.exit(1)
+    # what other transformations?
+    namespace = ppa.replace(':', '_')
+
+    logging.info('Ubuntu Server Team importer v%s' % VERSION)
+
+    repo = GitUbuntuRepository(directory, user, proto)
+    if not directory:
+        logging.info('Using git repository at %s', repo.local_dir)
+    repo.ensure_importer_branches_exist(namespace)
+
+    atexit.register(cleanup, no_clean, repo.local_dir)
+
+    # This seems terminally broken and I'm not sure what we should do
+    # here
+    #repo.add_remote(pkgname, owner, namespace)
+    #if not no_fetch:
+    #    try:
+    #        repo.fetch_remote(namespace)
+    #    except GitUbuntuRepositoryFetchError:
+    #        pass
+
+    source_information = GitUbuntuSourceInformation(
+        ppa,
+        pkgname,
+        os.path.abspath(pullfile),
+        retries,
+        retry_backoffs,
+    )
+
+    ubuntu_head_versions = repo.get_heads_and_versions(
+        'ubuntu',
+        namespace,
+    )
+    for head_name in sorted(ubuntu_head_versions):
+        _, _, pretty_head_name = head_name.partition('%s/', namespace)
+        logging.debug('Last imported %s version is %s',
+            pretty_head_name,
+            ubuntu_head_versions[head_name]['version']
+        )
+
+    applied_ubuntu_head_versions = repo.get_heads_and_versions(
+        'applied/ubuntu',
+        namespace,
+    )
+    for head_name in sorted(applied_ubuntu_head_versions):
+        _, _, pretty_head_name = head_name.partition('%s/', namespace)
+        logging.debug('Last applied %s version is %s',
+            pretty_head_name,
+            applied_ubuntu_head_versions[head_name]['version']
+        )
+
+    oldcwd = os.getcwd()
+    os.chdir(repo.local_dir)
+
+    if dl_cache is None:
+        workdir = os.path.join(repo.git_dir, CACHE_PATH)
+    else:
+        workdir = dl_cache
+
+    os.makedirs(workdir, exist_ok=True)
+
+    parse_parentfile(pkgname, parentfile)
+
+    history_found = False
+    try:
+        for srcpkg_information in \
+            source_information.launchpad_versions_published_after(
+                ubuntu_head_versions,
+                namespace,
+                workdir=workdir
+        ):
             try:
-                self.local_repo.fetch_remote(self.namespace)
-            except GitUbuntuRepositoryFetchError:
+                import_unapplied_spi(
+                    repo=repo,
+                    spi=srcpkg_information,
+                    namespace=namespace,
+                    ubuntu_sinfo=source_information,
+                    skip_orig=skip_orig,
+                )
+            except DownloadError:
+                # it is non-fatal for a PPA to not have files for older
+                # publishes
                 pass
+        history_found = True
+    except NoPublicationHistoryException:
+        logging.warning("No publication history found for %s in %s.",
+            pkgname,
+            ppa,
+        )
 
-        source_information = UbuntuSourceInformation(ppa, pkgname,
-            os.path.abspath(args.pullfile),
-            args.retries, args.retry_backoffs)
-
-        ubuntu_head_versions = self.local_repo.get_heads_and_versions(
-            'ubuntu', self.namespace
+    if not history_found:
+        logging.error(
+            "No publication history for '%s' in %s. Wrong source package name?",
+            pkgname,
+            ppa,
         )
-        for head_name in sorted(ubuntu_head_versions):
-            _, _, pretty_head_name = head_name.partition('%s/', self.namespace)
-            logging.debug('Last imported %s version is %s',
-                pretty_head_name,
-                ubuntu_head_versions[head_name]['version']
-            )
-
-        applied_ubuntu_head_versions = self.local_repo.get_heads_and_versions(
-            'applied/ubuntu', self.namespace
+        sys.exit(1)
+
+    try:
+        for srcpkg_information in \
+                source_information.launchpad_versions_published_after(
+                    applied_ubuntu_head_versions,
+                    '%s/applied' % namespace,
+                    workdir=workdir
+        ):
+            try:
+                import_applied_spi(
+                    repo=repo,
+                    spi=srcpkg_information,
+                    namespace=namespace,
+                    ubuntu_sinfo=source_information,
+                )
+            except DownloadError:
+                # it is non-fatal for a PPA to not have files for older
+                # publishes
+                pass
+    except NoPublicationHistoryException:
+        logging.warning("No publication history found for %s in %s.",
+            pkgname, ppa
         )
-        for head_name in sorted(applied_ubuntu_head_versions):
-            _, _, pretty_head_name = head_name.partition('%s/', self.namespace)
-            logging.debug('Last applied %s version is %s',
-                pretty_head_name,
-                applied_ubuntu_head_versions[head_name]['version']
-            )
-
-        oldcwd = os.getcwd()
-        os.chdir(self.local_repo.local_dir)
-
-        if dl_cache is None:
-            workdir = os.path.join(self.local_repo.git_dir, CACHE_PATH)
-        else:
-            workdir = dl_cache
-
-        os.makedirs(workdir, exist_ok=True)
-
-        self.parse_parentfile(pkgname, args.parentfile)
-
-        history_found = False
-        try:
-            for srcpkg_information in \
-                source_information.launchpad_versions_published_after(ubuntu_head_versions,
-                                                                      self.namespace,
-                                                                      workdir=workdir):
-                try:
-                    self.import_unapplied_spi(srcpkg_information)
-                except DownloadError:
-                    # it is non-fatal for a PPA to not have files for older
-                    # publishes
-                    pass
-            history_found = True
-        except NoPublicationHistoryException:
-            logging.warning("No publication history found for %s in %s. ",
-                            pkgname, distname)
-
-        if not history_found:
-            logging.error("No publication history for '%s' in %s. "
-                          "Wrong source package name?", pkgname, ppa)
-            sys.exit(1)
-
-        try:
-            for srcpkg_information in \
-                    source_information.launchpad_versions_published_after(applied_ubuntu_head_versions,
-                                                                          '%s/applied' % self.namespace,
-                                                                          workdir=workdir):
-                try:
-                    self.import_applied_spi(srcpkg_information)
-                except DownloadError:
-                    # it is non-fatal for a PPA to not have files for older
-                    # publishes
-                    pass
-        except NoPublicationHistoryException:
-            logging.warning("No publication history found for %s in %s. ",
-                            pkgname, ppa)
-        except:
-            logging.error("Unable to import patches-applied to %s", ppa)
-
-        os.chdir(oldcwd)
-
-        self.local_repo.garbage_collect()
-
-        if no_push:
-            logging.info('Not pushing to remote as specified')
-        else:
-            # what are appropriate refspects to push and where?
-            pass
+    except:
+        logging.error("Unable to import patches-applied to %s", ppa)
+
+    os.chdir(oldcwd)
+
+    repo.garbage_collect()
+
+    if no_push:
+        logging.info('Not pushing to remote as specified')
+    else:
+        # what are appropriate refspects to push and where?
+        pass
+
+
+def parse_args(subparsers=None, base_subparsers=None):
+    kwargs = dict(description='Update a launchpad git tree based upon '
+                              'the state of a PPA archive',
+                  epilog='PPA must be specified as ppa:<name>',
+                  formatter_class=argparse.ArgumentDefaultsHelpFormatter
+                 )
+    if base_subparsers:
+        kwargs['parents'] = base_subparsers
+    if subparsers:
+        parser = subparsers.add_parser('import-ppa', **kwargs)
+        parser.set_defaults(func=cli_main)
+    else:
+        parser = argparse.ArgumentParser(**kwargs)
+    parser.add_argument('ppa', type=str,
+                        help='Name of PPA to update in the git tree')
+    parser.add_argument('package', type=str,
+                        help='Which package to update in the git tree')
+    parser.add_argument('-o', '--lp-owner', type=str,
+                        help='Which launchpad user\'s tree to update',
+                        default='usd-import-team')
+    parser.add_argument('-l', '--lp-user', type=str,
+                        help='Specify the Launchpad user to use',
+                        default=getpass.getuser())
+    parser.add_argument('--dl-cache', type=str,
+                        help=('Cache directory for downloads. Default is to '
+                              'put downloads in <directory>/.git/%s' %
+                              CACHE_PATH
+                             ),
+                        default=argparse.SUPPRESS)
+    parser.add_argument('--no-fetch', action='store_true',
+                        help='Do not fetch from the remote (DANGEROUS: '
+                             'only useful for debugging); implies '
+                             '--no-push')
+    parser.add_argument('--no-push', action='store_true',
+                        help='Do not push to the remote (WARNING: '
+                             'PPA imports are a work-in-progress and '
+                             'pushing is currently disabled)',
+                        default=True)
+    parser.add_argument('--no-clean', action='store_true',
+                        help='Do not clean the temporary directory')
+    parser.add_argument('-d', '--directory', type=str,
+                        help='Use git repository at specified location rather '
+                             'than a temporary directory (implies --no-clean). '
+                             'Will create the local repository if needed.',
+                        default=argparse.SUPPRESS
+                       )
+    parser.add_argument(
+        '--skip-orig',
+        action='store_true',
+        help=argparse.SUPPRESS,
+    )
+    if not subparsers:
+        return parser.parse_args()
+    return 'import-ppa - %s' % kwargs['description']
+
+def cli_main(args):
+    no_clean = args.no_clean
+    try:
+        directory = args.directory
+        no_clean = True
+    except AttributeError:
+        directory = None
+    no_push = True
+    try:
+        dl_cache = args.dl_cache
+    except AttributeError:
+        dl_cache = None
+
+    main(
+        args.ppa,
+        args.package,
+        directory,
+        args.lp_owner,
+        args.lp_user,
+        args.pullfile,
+        args.parentfile,
+        no_clean,
+        args.no_fetch,
+        no_push,
+        dl_cache,
+        args.proto,
+        args.retries,
+        args.retry_backoffs,
+        args.skip_orig,
+    )
diff --git a/gitubuntu/lint.py b/gitubuntu/lint.py
index 435e7f2..109eb13 100644
--- a/gitubuntu/lint.py
+++ b/gitubuntu/lint.py
@@ -23,10 +23,6 @@ except ImportError:
     logging.error("Is %s installed?", pkg)
     sys.exit(1)
 
-__all__ = [
-    'GitUbuntuLint',
-]
-
 class LintNamespaceError(Exception):
     pass
 
@@ -162,579 +158,622 @@ def test__derive_target_branch_string(same_remote_branch_names,
     )
     assert target_branch_string == expected
 
-class GitUbuntuLint:
-    def __init__(self):
-        pass
 
-    def success(self, msg, *args):
-        if self.verbose:
-            print(msg % args)
+_verbose = False
+def success(msg, *args):
+    if _verbose:
+        print(msg % args)
 
-    def parse_args(self, subparsers=None, base_subparsers=None):
-        kwargs = dict(
-            description="Given a commitish, perform automated checks",
-            formatter_class=argparse.RawTextHelpFormatter,
-            epilog="An exit code of 0 indicates all checks passed",
-        )
-        if base_subparsers:
-            kwargs["parents"] = base_subparsers
-        if subparsers:
-            parser = subparsers.add_parser("lint", **kwargs)
-            parser.set_defaults(func=self.main)
-        else:
-            parser = argparse.ArgumentParser(**kwargs)
 
-        parser.add_argument("commitish", type=str, default="HEAD", nargs="?",
-            help="Commitish to lint"
-        )
-        parser.add_argument("--lint-namespace", type=str,
-            help="The git-ref prefix under which the branches and tags "
-                 "to lint can be found. If linting a remote-tracking "
-                 "branch, this will be default to the remote name. If "
-                 "linting a local branch, this will default to ''."
-        )
-        parser.add_argument("--target-branch", type=str,
-            help="Target branch (typically a remote-tracking branch in pkg/) "
-                 "the current branch is against. This will be derived if "
-                 "possible."
-        )
-        parser.add_argument("-d", "--directory", type=str,
-            help="Use git repository at specified location.",
-            default=os.path.abspath(os.getcwd())
-        )
-        if not subparsers:
-            return parser.parse_args()
-        return "lint - %s" % kwargs["description"]
+def parse_args(subparsers=None, base_subparsers=None):
+    kwargs = dict(
+        description="Given a commitish, perform automated checks",
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog="An exit code of 0 indicates all checks passed",
+    )
+    if base_subparsers:
+        kwargs["parents"] = base_subparsers
+    if subparsers:
+        parser = subparsers.add_parser("lint", **kwargs)
+        parser.set_defaults(func=cli_main)
+    else:
+        parser = argparse.ArgumentParser(**kwargs)
 
-    def _check_commitish_exists(self, commitish):
-        try:
-            actual_commitish_obj = self.local_repo.get_commitish(
-                commitish
-            )
-            self.success("Verified %s exists", commitish)
-            return True
-        except KeyError:
-            warning("%s not found", commitish)
-            return False
+    parser.add_argument("commitish", type=str, default="HEAD", nargs="?",
+        help="Commitish to lint"
+    )
+    parser.add_argument("--lint-namespace", type=str,
+        help="The git-ref prefix under which the branches and tags "
+             "to lint can be found. If linting a remote-tracking "
+             "branch, this will be default to the remote name. If "
+             "linting a local branch, this will default to ''."
+    )
+    parser.add_argument("--target-branch", type=str,
+        help="Target branch (typically a remote-tracking branch in pkg/) "
+             "the current branch is against. This will be derived if "
+             "possible."
+    )
+    parser.add_argument("-d", "--directory", type=str,
+        help="Use git repository at specified location.",
+        default=os.path.abspath(os.getcwd())
+    )
+    if not subparsers:
+        return parser.parse_args()
+    return "lint - %s" % kwargs["description"]
+
+def cli_main(args):
+    main(
+        args.directory,
+        args.commitish,
+        args.lint_namespace,
+        args.target_branch,
+        args.verbose,
+    )
 
-    def _check_commitish_exists_and_same(self, expected_commitish_pretty_name,
-        actual_commitish, expected_commitish, check_commit_id=False
-    ):
-        """Check @actual_commitish exists ad is the same tree as
-        @expected_commitish
-
-        Arguments:
-        expected_commitish_pretty_name - a pretty name to print to refer to the
-        expected value
-        actual_commitish - commitish to check for
-        expected_commitish - commitish to check against
-        check_commit_id - if True, check the commit hashes match as well
-        """
-        ret = True
-        if not self._check_commitish_exists(actual_commitish):
-            return False
+def _check_commitish_exists(repo, commitish):
+    try:
+        actual_commitish_obj = repo.get_commitish(commitish)
+        success("Verified %s exists", commitish)
+        return True
+    except KeyError:
+        warning("%s not found", commitish)
+        return False
 
-        try:
-            expected_commitish_obj = self.local_repo.get_commitish(
-                expected_commitish
-            )
-        except KeyError:
-            fatal("Unable to find expected commit: %s", expected_commitish)
+def _check_commitish_exists_and_same(repo, expected_commitish_pretty_name,
+    actual_commitish, expected_commitish, check_commit_id=False
+):
+    """Check @actual_commitish exists ad is the same tree as
+    @expected_commitish
+
+    Arguments:
+    expected_commitish_pretty_name - a pretty name to print to refer to the
+    expected value
+    actual_commitish - commitish to check for
+    expected_commitish - commitish to check against
+    check_commit_id - if True, check the commit hashes match as well
+    """
+    ret = True
+    if not _check_commitish_exists(repo, actual_commitish):
+        return False
 
-        actual_commitish_obj = self.local_repo.get_commitish(
-            actual_commitish
-        )
-        if check_commit_id:
-            expected_commit_id = str(expected_commitish_obj.id)
-            actual_commit_id = str(actual_commitish_obj.id)
-            if expected_commit_id == actual_commit_id:
-                self.success("Verified %s is the same commit as %s",
-                    expected_commitish_pretty_name, actual_commitish
-                )
-            else:
-                warning("Expected %s (%s) is not the same commit as %s (%s)",
-                    expected_commitish_pretty_name, expected_commit_id,
-                    actual_commitish, actual_commit_id
-                )
-                ret = False
-        expected_commit_tree_id = str(
-            expected_commitish_obj.peel(pygit2.Tree).id
-        )
-        actual_commit_tree_id = str(
-            actual_commitish_obj.peel(pygit2.Tree).id
-        )
-        if expected_commit_tree_id == actual_commit_tree_id:
-            self.success("Verified %s is the same tree as %s",
+    try:
+        expected_commitish_obj = repo.get_commitish(expected_commitish)
+    except KeyError:
+        fatal("Unable to find expected commit: %s", expected_commitish)
+
+    actual_commitish_obj = repo.get_commitish(actual_commitish)
+    if check_commit_id:
+        expected_commit_id = str(expected_commitish_obj.id)
+        actual_commit_id = str(actual_commitish_obj.id)
+        if expected_commit_id == actual_commit_id:
+            success("Verified %s is the same commit as %s",
                 expected_commitish_pretty_name, actual_commitish
             )
         else:
-            error("Expected %s (%s) is not the same tree as %s (%s)",
-                expected_commitish_pretty_name, expected_commit_tree_id,
-                actual_commitish, actual_commit_tree_id
+            warning("Expected %s (%s) is not the same commit as %s (%s)",
+                expected_commitish_pretty_name, expected_commit_id,
+                actual_commitish, actual_commit_id
             )
             ret = False