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)

[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)

[Nish Aravamudan (nacc)]

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

[Andreas Hasenack (ahasenack)]

I see help_text being built several times in gitubuntu/__main__.py, but not being used:

        help_text = '\n'.join( ...
        help_text += '\n'
        help_text += '<pkgname> ...
        help_text += ...
        parser.add_argument(
            '-P', '--parentfile',
            type=str,
            help=argparse.SUPPRESS,
            default=pkg_resources.resource_filename(
                'gitubuntu',
                'parent_overrides.txt',
            ),
        )
        help_text = '\n'.join(... <--- starts over

Maybe you meant to use it in parser.add_argument()?
        parser.add_argument(
            '-P', '--parentfile',
            type=str,
            help=help_text, <---------
            default=pkg_resources.resource_filename(
                'gitubuntu',
                'parent_overrides.txt',
            ),
        )

[Andreas Hasenack (ahasenack)]

Ok, first pass on gitubuntu/__main__.py.

These are notes to myself regarding the changes that I reviewed and saw:
- switch to use import_module
- code reformatting (probably as a result of lint)
- switch from calling the module's class instance method to calling the module's parse_args() method, which also sets args.func to be m.cli_main() via parser.set_defaults() (to be verified in each module still in this review)
- cleaner setting of debug logging

The whole buildup of the parser is still a bit confusing to me, but I can see that in this branch it was must moved around for better formatting and not really changed. Some of this could probably me moved to methods/functions at some point to make it easier to read. Not something for this branch at this time.

The review continues! :)

[Nish Aravamudan (nacc)]

On Fri, Sep 8, 2017 at 1:00 PM, Andreas Hasenack <email address hidden> wrote:
> Ok, first pass on gitubuntu/__main__.py.
>
> These are notes to myself regarding the changes that I reviewed and saw:
> - switch to use import_module
> - code reformatting (probably as a result of lint)

One of our goals for 1.0 is to cleanup style to follow doc/STYLE.md as
we touch code. That's why there are some stylistic changes
intereleaved.

> - switch from calling the module's class instance method to calling the module's parse_args() method, which also sets args.func to be m.cli_main() via parser.set_defaults() (to be verified in each module still in this review)

We always called instance parse_args then the implicit func via the default.

Now, we set call a module's parse_args and then the implicit func via
the default.

> - cleaner setting of debug logging
>
> The whole buildup of the parser is still a bit confusing to me, but I can see that in this branch it was must moved around for better formatting and not really changed. Some of this could probably me moved to methods/functions at some point to make it easier to read. Not something for this branch at this time.
>
> The review continues! :)
>
>
> Diff comments:
>
>> diff --git a/gitubuntu/__main__.py b/gitubuntu/__main__.py
>> index eb6078a..49373a7 100644
>> --- a/gitubuntu/__main__.py
>> +++ b/gitubuntu/__main__.py
>> @@ -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,
>
> Both "user" can be in the same line, and no need for the trailing comma.

Yeah, I wasn't 100% with how we wanted to handle this specific case of
style. Quoting STYLE.md:

 * If a method call goes to multiple lines, use one parameter per line, each
   ending in a trailing comma including the last parameter, and the closing
   bracket on a separate final line.

Technically, these are parameters to logging.warning, not
substitutions to the parameter string.

[Andreas Hasenack (ahasenack)]

Notes for gitubuntu/build.py:
- not a class anymore
- class.parse_args -> module.parse_args:
  - parser.set_defaults points at cli_main now
- class.check_repository -> module.check_repository:
  - no change
- class.derive_orig_search_list_from_args -> module.derive_orig_search_list_from_args:
  - one change:
     if not args.no_pristine_tar:
         orig_search_list.append(
             OrigSearchListEntry(
                 mechanism=functools.partial(fetch_orig_from_pristine_tar,
+ repo=self.local_repo,
- repo=GitUbuntuRepository('.'),
  - local_repo was being set to repo=GitUbuntuRepository('.') before, so it's ok
- class.main -> split into module.cli_main which calls module.main

Other minor changes:
- derive_orig_search_list_from_args()
  - Use of GitUbuntuRepository('.') insgtead of self.local_repo
- fetch_orig_from_launchpad:
  - build: fix use of undefined variables
- fetch_orig_from_cache: tiny logging change
- derive_orig_search_list_from_args: local_repo to GitUbuntuRepository('.')
- git_repository: move derive_source_from_series from build

+1 for gitubuntu/build.py. Next up is gitubuntu/buildsource.py

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

FAILED: Continuous integration, rev:6a15a640423df39fc68adc657c7f32aef117749d
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/40/
Executed test runs:
    SUCCESS: Checkout
    FAILED: Style Check

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

review: Needs Fixing (continuous-integration)

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

FAILED: Continuous integration, rev:6a15a640423df39fc68adc657c7f32aef117749d
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/44/
Executed test runs:
    SUCCESS: Checkout
    SUCCESS: Style Check
    SUCCESS: Unit Tests
    FAILED: Integration Tests

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

review: Needs Fixing (continuous-integration)

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

PASSED: Continuous integration, rev:5d0cb19e1fcbc2711d478eec9df40809d5cd8953
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/57/
Executed test runs:
    SUCCESS: Checkout
    SUCCESS: Style Check
    SUCCESS: Unit Tests
    SUCCESS: Integration Tests
    IN_PROGRESS: Declarative: Post Actions

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

review: Approve (continuous-integration)

9cb168b... by Nish Aravamudan on 2017-09-08

lint: rework so that main is a more useful function

This will be folded up with the other changes before merging.

6f347d1... by Nish Aravamudan on 2017-09-08

remote: rework so that main is a more useful function

This will be folded up with the other changes before merging.

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

PASSED: Continuous integration, rev:9ba1036b3937a1bdcb3b9151497bbb181cc45023
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/58/
Executed test runs:
    SUCCESS: Checkout
    SUCCESS: Style Check
    SUCCESS: Unit Tests
    SUCCESS: Integration Tests
    IN_PROGRESS: Declarative: Post Actions

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

review: Approve (continuous-integration)

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

PASSED: Continuous integration, rev:960a19c34771f455df02253617749317749e299d
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/61/
Executed test runs:
    SUCCESS: Checkout
    SUCCESS: Style Check
    SUCCESS: Unit Tests
    SUCCESS: Integration Tests
    IN_PROGRESS: Declarative: Post Actions

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

review: Approve (continuous-integration)

[Andreas Hasenack (ahasenack)]

build_source.py: OK

gitubuntu/clone.py:
cli_main() calls main() and discards its return value. main() however returns "local_repo", is that correct? It's not documented in main's docstrings, and in the previous gitubuntu/clone.py module there was no such return value.

def main(package, directory=None, lp_user=None, proto=None):
    """Entry point to clone subcommand

    @package: Name of source package
    @directory: directory to clone the repository into
    @lp_user: user to authenticate to Launchpad as
    @proto: protocol to use (one of 'http', 'https', 'git')

    If directory is None, a relative directory with the same name as
    package will be used.

    If lp_user is None, value of `git config gitubuntu.lpuser` will be
    used.

    If proto is None, the default value from gitubuntu.__main__ will be
    used (top_level_defaults.proto).
    """
(...)
    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).'
        )

    return local_repo <-----

[Andreas Hasenack (ahasenack)]

gitubuntu/importer.py:
- docstrings overall. A new branch with just docstrings fixes should address these
- import_publishes(): commented code, should either be removed (new change) or uncommented (so it's like the previous import_publishes):

            #if not patches_applied:
            raise GitUbuntuImportError(msg) from e
            #else:
            # logging.error(msg)

[Andreas Hasenack (ahasenack)]

importlocal.py: ok
importppa.py
- note: parse_args() got a new option: --skip-orig
- main(): has commented code. Ideally it should be removed. It can always be brought back if needed.

[Andreas Hasenack (ahasenack)]

lint.py: OK, I just see a few extra checks in the diff

[Andreas Hasenack (ahasenack)]

merge.py: ok
queue.py: ok
remote.py: ok
submit.py: ok
tag.py: ok

[Andreas Hasenack (ahasenack)]

Ah, I see that at least the new review command uses the return value of clone's main():

        repo = gitubuntu.clone.main(package=srcpkg)

[Andreas Hasenack (ahasenack)]

+1

review: Approve

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

PASSED: Continuous integration, rev:6f347d12bf6d133b05e5729f2fa09d5132662d99
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/63/
Executed test runs:
    SUCCESS: Checkout
    SUCCESS: Style Check
    SUCCESS: Unit Tests
    SUCCESS: Integration Tests
    IN_PROGRESS: Declarative: Post Actions

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

review: Approve (continuous-integration)

[Nish Aravamudan (nacc)]

This looks good to land now. I'm going to try and get to some more commits tomorrow that, at least, add docstring for main() in each subcommand.

That should be a noop relative to the CI pass and code review, though.

diff --git a/gitubuntu/__main__.py b/gitubuntu/__main__.py
index 165fc59..edeee43 100644
--- a/gitubuntu/__main__.py
+++ b/gitubuntu/__main__.py
@@ -1,26 +1,29 @@
 #!/usr/bin/env python3
 
+from collections import namedtuple
+TopLevelDefaults = namedtuple(
+    'TopLevelDefaults',
+    [
+        'verbose',
+        'retries',
+        'retry_backoffs',
+        'proto',
+        'parentfile',
+        'pullfile',
+    ],
+)
+top_level_defaults = object()
+
 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:
@@ -32,95 +35,128 @@ def main():
             logging.error('Is %s installed?', pkg)
             sys.exit(1)
 
+        global top_level_defaults
+        top_level_defaults = TopLevelDefaults(
+            verbose=False,
+            retries=3,
+            retry_backoffs = [2 ** i for i in range(3)],
+            proto='https',
+            parentfile=pkg_resources.resource_filename(
+                'gitubuntu',
+                'parent_overrides.txt',
+            ),
+            pullfile=pkg_resources.resource_filename(
+                'gitubuntu',
+                'pull_overrides.txt',
+            ),
+        )
+
         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",
+            default=top_level_defaults.verbose,
+        )
         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=top_level_defaults.retries,
+        )
         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='https'
-                                   )
+            '--proto',
+            metavar='[%s]' % '|'.join(known_protos),
+            choices=known_protos,
+            help="Specify protocol to use for fetch. Default: %(default)s",
+            default=top_level_defaults.proto,
+        )
 
         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
-                                                      )
-                                        )
-        parser.add_argument('-P', '--parentfile', type=str,
-                            help=argparse.SUPPRESS,
-                            default=pkg_resources.resource_filename(
-                                'gitubuntu',
-                                'parent_overrides.txt'
-                                                                   )
-                           )
-        parser.add_argument('-L', '--pullfile', type=str,
-                            help=argparse.SUPPRESS,
-                            default=pkg_resources.resource_filename(
-                                'gitubuntu',
-                                'pull_overrides.txt'
-                                                                   )
-                           )
+            subparsers.help += '\n'.join(
+                textwrap.wrap(
+                    help_text,
+                    subhelp_width,
+                    break_on_hyphens=False,
+                )
+            )
+        parser.add_argument(
+            '-P', '--parentfile',
+            type=str,
+            help=argparse.SUPPRESS,
+            default=top_level_defaults.parentfile,
+        )
+        parser.add_argument(
+            '-L', '--pullfile',
+            type=str,
+            help=argparse.SUPPRESS,
+            default=top_level_defaults.pullfile,
+        )
 
         argcomplete.autocomplete(parser)
         args = parser.parse_args()
@@ -131,22 +167,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)]
@@ -158,26 +194,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 a8f9cf3..d3d292e 100644
--- a/gitubuntu/build.py
+++ b/gitubuntu/build.py
@@ -372,142 +372,152 @@ 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):
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 9a15c9c..a24a1a5 100644
--- a/gitubuntu/clone.py
+++ b/gitubuntu/clone.py
@@ -5,6 +5,7 @@ import re
 import shutil
 from subprocess import CalledProcessError
 import sys
+from gitubuntu.__main__ import top_level_defaults
 from gitubuntu.git_repository import (
     GitUbuntuRepository,
     GitUbuntuRepositoryFetchError,
@@ -18,12 +19,108 @@ 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(package, directory=None, lp_user=None, proto=None):
+    """Entry point to clone subcommand
+
+    @package: Name of source package
+    @directory: directory to clone the repository into
+    @lp_user: user to authenticate to Launchpad as
+    @proto: protocol to use (one of 'http', 'https', 'git')
+
+    If directory is None, a relative directory with the same name as
+    package will be used.
+
+    If lp_user is None, value of `git config gitubuntu.lpuser` will be
+    used.
+
+    If proto is None, the default value from gitubuntu.__main__ will be
+    used (top_level_defaults.proto).
+
+    Returns the resulting GitUbuntuRepository object
+    """
+    directory = (
+        os.path.abspath(directory)
+        if directory
+        else os.path.join(os.path.abspath(os.getcwd()), package)
+    )
+    if os.path.isdir(directory):
+        logging.error('directory %s exists' % directory)
+        sys.exit(1)
+
+    if proto is None:
+        proto = top_level_defaults.proto
+
+    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).'
+        )
+
+    return local_repo
+
+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 +129,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
 
-        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(
+        package=args.package,
+        directory=args.directory,
+        lp_user=lp_user,
+        proto=args.proto,
+    )
 
-        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 cce1999..db08f46 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,1259 +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, dsc, version, dist):
-        """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:
-        dsc - A GitUbuntuRepository object
-        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)
+    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_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)]
+    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:
-            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)
+        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']
+            )
 
-            self.local_repo.clean_repository_state()
+    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,
+        )
 
-    def import_patches_unapplied_tree(self, dsc_pathname):
-        """Imports the patches-unapplied source package and writes the
-        corresponding working tree for a given srcpkg
+    os.chdir(oldcwd)
 
-        Arguments:
-        dsc_pathname - A string path to a DSC file
-        """
+    repo.garbage_collect()
 
-        import_tree_hash = dsc_to_tree_hash(self.local_repo, dsc_pathname)
-        self.local_repo.clean_repository_state()
+    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
+                )
 
-        return import_tree_hash
+    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
+                     ]
+                    )
 
-    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
+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
+        )
 
-        Arguments:
-        dsc_pathname - A string path to a DSC file
-        """
-        oldcwd = os.getcwd()
+    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)
 
-        extract_dir = tempfile.mkdtemp()
-        os.chdir(extract_dir)
+        repo.clean_repository_state()
 
-        run(['dpkg-source', '-x',
-             '--skip-patches',
-             os.path.join(oldcwd, dsc_pathname)
-            ]
-           )
+def import_patches_unapplied_tree(repo, dsc_pathname):
+    """Imports the patches-unapplied source package and writes the
+    corresponding working tree for a given srcpkg
 
-        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',
-            )
+    Arguments:
+    dsc_pathname - A string path to a DSC file
+    """
 
-        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()
+    import_tree_hash = dsc_to_tree_hash(repo, dsc_pathname)
+    repo.clean_repository_state()
 
-    def parse_parentfile(self, parentfile):
-        """Extract parent overrides from a file
+    return import_tree_hash
 
-        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.
+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
 
-        <child version> is the published version to which this override
-        applies.
+    Arguments:
+    dsc_pathname - A string path to a DSC file
+    """
+    oldcwd = os.getcwd()
 
-        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.
+    extract_dir = tempfile.mkdtemp()
+    os.chdir(extract_dir)
 
-        The <changelog parent version> is the prior version in the
-        child publish's debian/changelog.
+    run(['dpkg-source', '-x',
+         '--skip-patches',
+         os.path.join(oldcwd, dsc_pathname)
+        ]
+       )
 
-        Keyword Arguments:
-        parentfile -- Path to parent overrides file
-        """
-        if self.parent_overrides:
-            return
-        parent_overrides = dict()
+    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')):
+        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(
-                GitUbuntuDsc(spi.dsc_pathname),
-                version = str(spi.version),
-                dist = spi.distribution.name.lower(),
-            )
 
-        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),
+                                                                 )
+
+    logging.debug('Tip version is %s', unapplied_tip_version)
 
-        import_tree_versions = self.local_repo.get_all_changelog_versions_from_treeish(
-                                   unapplied_import_tree_hash
-                                                                           )
-        changelog_version = import_tree_versions[0]
+    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
+
+        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
+                        )
 
-        logging.debug('Tip version is %s', 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:
+            upload_parent_commit = str(upload_tag.peel().id)
+            if unapplied_publish_parent_commit is not None:
                 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:
-                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 2ae1f81..da57f53 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,216 @@ 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
-        self.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(self.pkgname, owner, self.namespace)
-        if not args.no_fetch:
+def main(
+    ppa,
+    pkgname,
+    directory,
+    owner,
+    user,
+    pullfile,
+    parentfile,
+    no_clean,
+    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)
+
+    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 = GitUbuntuSourceInformation(ppa, self.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(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. ",
-                            self.pkgname, ppa)
-
-        if not history_found:
-            logging.error("No publication history for '%s' in %s. "
-                          "Wrong source package name?", self.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. ",
-                            self.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()
+
+
+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-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
+    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,
+        dl_cache,
+        args.proto,
+        args.retries,
+        args.retry_backoffs,
+        args.skip_orig,
+    )
diff --git a/gitubuntu/lint.py b/gitubuntu/lint.py
index a67e0f3..ac503b9 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,594 +158,636 @@ 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):
+    repo = GitUbuntuRepository(args.directory)
+    do_lint(
+        repo,
+        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
+    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:
+        success("Verified %s is the same tree 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
+        )
+        ret = False
 
-        return ret
+    return ret
 
-    def print_hunk(self, hunk):
-        for line in hunk.lines:
-            print("%s%s" % (line.origin, line.content.rstrip()))
+def print_hunk(hunk):
+    for line in hunk.lines:
+        print("%s%s" % (line.origin, line.content.rstrip()))
 
-    def print_patch(self, patch):
-        for hunk in patch.hunks:
-            self.print_hunk(hunk)
+def print_patch(patch):
+    for hunk in patch.hunks:
+        print_hunk(hunk)
 
-    def _check_deconstruct_to_logical_patch(self, patch):
-        if "debian/changelog" in patch.delta.new_file.path:
-            self.success("Verified debian/changelog is in diff between "
-                "deconstruct and logical"
-            )
-            return True
-        if "debian/control" in patch.delta.new_file.path:
-            ret = True
-            for hunk in patch.hunks:
-                _ret = True
-                for line in hunk.lines:
-                    if line.origin == " ":
+def _check_deconstruct_to_logical_patch(patch):
+    if "debian/changelog" in patch.delta.new_file.path:
+        success("Verified debian/changelog is in diff between "
+            "deconstruct and logical"
+        )
+        return True
+    if "debian/control" in patch.delta.new_file.path:
+        ret = True
+        for hunk in patch.hunks:
+            _ret = True
+            for line in hunk.lines:
+                if line.origin == " ":
+                    continue
+                content = line.content.strip()
+                if line.origin == "-":
+                    if content.startswith("Maintainer:"):
+                        continue
+                if line.origin == "+":
+                    if (
+                        content.startswith("Maintainer:") and
+                        content.endswith("<[e-mail]>")
+                    ):
+                        continue
+                    if content.startswith("XSBC-Original-Maintainer:"):
                         continue
-                    content = line.content.strip()
-                    if line.origin == "-":
-                        if content.startswith("Maintainer:"):
-                            continue
-                    if line.origin == "+":
-                        if (
-                            content.startswith("Maintainer:") and
-                            content.endswith("<[e-mail]>")
-                        ):
-                            continue
-                        if content.startswith("XSBC-Original-Maintainer:"):
-                            continue
-                    _ret = False
-                if not _ret:
-                    error("unexpected differences between logical "
-                        "and deconstruct tags"
-                    )
-                    self.print_hunk(hunk)
-                ret = _ret and ret
-            if ret:
-                self.success("Verified only update-maintainer changes "
-                    "are in diff between deconstruct and logical to "
-                    "debian/control"
+                _ret = False
+            if not _ret: