Merge lp:~jelmer/brz-debian/upstream-subpath into lp:brz-debian

[Jelmer Vernooij]

Support merging of upstreams on subpaths

[lp:~jelmer/brz-debian/upstream-subpath]

1591. By Jelmer Vernooij on 2023-01-27

Report formatting-unpreservable diff when possible.

Unmerged revisions

1591. By Jelmer Vernooij on 2023-01-27

Report formatting-unpreservable diff when possible.

1590. By Jelmer Vernooij on 2023-01-22

Support merging upstream with subpath (for build_type==merge)

1589. By Jelmer Vernooij on 2023-01-22

Add specific exception for merging of upstream subpaths not working.

=== modified file '__init__.py'
--- __init__.py	2023-01-12 17:15:19 +0000
+++ __init__.py	2023-01-27 18:04:28 +0000
@@ -34,8 +34,15 @@
     brz_plugin_version as version_info,
 )
 
+from ...directory_service import (
+    AliasDirectory,
+    directories,
+    )
 
 from ...i18n import load_plugin_translations
+from ...tag import tag_sort_methods
+from ...revisionspec import revspec_registry
+
 translation = load_plugin_translations("brz-debian")
 gettext = translation.gettext
 
@@ -66,11 +73,6 @@
 default_result_dir = '..'
 
 
-from ...directory_service import (
-    AliasDirectory,
-    directories,
-    )
-
 directories.register_lazy(
     "apt:", __name__ + '.directory',
     'AptDirectory',
@@ -89,12 +91,10 @@
     "upstream", __name__ + ".directory", "upstream_branch_alias",
     help="upstream branch (for packaging branches)")
 
-from ...tag import tag_sort_methods
 tag_sort_methods.register_lazy(
     "debversion", __name__ + ".tagging", "sort_debversion",
     "Sort like Debian versions.")
 
-from ...revisionspec import revspec_registry
 revspec_registry.register_lazy(
     "package:", __name__ + ".revspec", "RevisionSpec_package")
 revspec_registry.register_lazy(

=== modified file 'cmds.py'
--- cmds.py	2023-01-12 11:16:09 +0000
+++ cmds.py	2023-01-27 18:04:28 +0000
@@ -953,7 +953,8 @@
                         "merge-upstream takes only a single --revision"))
                 upstream_revspec = revision[0]
                 upstream_revisions = {
-                    None: upstream_revspec.as_revision_id(upstream_branch)}
+                    None: (upstream_revspec.as_revision_id(upstream_branch),
+                           subpath)}
             else:
                 upstream_revisions = None
 
@@ -961,7 +962,7 @@
                 # Look up the version from the upstream revision
                 unmangled_version, version = (
                     upstream_branch_source.get_version(
-                        package, current_version, upstream_revisions[None]))
+                        package, current_version, upstream_revisions[None][0]))
             elif version is None and primary_upstream_source is not None:
                 unmangled_version, version = (
                     primary_upstream_source.get_latest_version(
@@ -1016,7 +1017,7 @@
                         % e.path) from e
                 try:
                     conflicts, imported_revids = do_merge(
-                        tree, subpath, tarball_filenames, package, version,
+                        tree, tarball_filenames, package, version,
                         current_version, upstream_branch, upstream_revisions,
                         merge_type, force=force,
                         force_pristine_tar=force_pristine_tar,
@@ -1228,11 +1229,13 @@
             md5sum_filename,
             )
         # TODO: search for similarity etc.
-        branch, _ = Branch.open_containing('.')
+        branch, subpath = Branch.open_containing('.')
         if upstream_branch is None:
             upstream = None
+            upstream_subpath = ""
         else:
-            upstream = Branch.open(upstream_branch)
+            upstream, upstream_subpath = Branch.open_containing(
+                upstream_branch)
         self.add_cleanup(branch.lock_write().unlock)
         tempdir = self.enter_context(tempfile.TemporaryDirectory(
             dir=branch.controldir.root_transport.clone('..')
@@ -1255,10 +1258,13 @@
                 # See bug lp:309682
                 for parent in base_revisions.values():
                     upstream.repository.fetch(branch.repository, parent)
-            db.extract_upstream_tree(base_revisions, tempdir)
+            db.extract_upstream_tree(
+                {comp: (revid, subpath)
+                 for comp, revid in base_revisions.items()},
+                tempdir)
             parents = {}
             for name, base_revid in base_revisions.items():
-                parents[name] = [base_revid]
+                parents[name] = [(base_revid, subpath)]
         else:
             parents = {}
             db.create_empty_upstream_tree(tempdir)
@@ -1276,9 +1282,9 @@
                 ' one revision specifier.'))
         tarballs = [(location, None, md5sum_filename(location))]
         for (component, tag_name, revid,
-             pristine_tar_imported) in db.import_upstream_tarballs(
+             pristine_tar_imported, subpath) in db.import_upstream_tarballs(
                 tarballs, None, version, parents, upstream_branch=upstream,
-                upstream_revisions={None: upstream_revid},
+                upstream_revisions={None: (upstream_revid, upstream_subpath)},
                 force_pristine_tar=force_pristine_tar):
             if component is None:
                 self.outf.write(gettext(

=== modified file 'import_dsc.py'
--- import_dsc.py	2023-01-12 11:16:09 +0000
+++ import_dsc.py	2023-01-27 18:04:28 +0000
@@ -209,15 +209,18 @@
     """Checkout an upstream version from the pristine tar source.
 
     """
-    tree.update(revision=revisions[None])
+    main_revid, main_subpath = revisions[None]
+    if main_subpath:
+        raise Exception("subpaths not yet supported")
+    tree.update(revision=main_revid)
     parent_ids = []
     for component in sorted(revisions.keys()):
-        revid = revisions[component]
+        revid, subpath = revisions[component]
         if component is not None:
             component_tree = tree.branch.repository.revision_tree(revid)
             export_with_nested(
                component_tree, os.path.join(tree.basedir, component),
-               format='dir')
+               format='dir', subdir=subpath)
         parent_ids.append(revid)
     tree.set_parent_ids(parent_ids)
 
@@ -542,8 +545,8 @@
                 pristine_upstream_revids = branch.pristine_upstream_source\
                     .version_as_revisions(
                         package, version, tarballs=upstream_tarballs)
-                for (component, pristine_upstream_revid) in (
-                        pristine_upstream_revids.items()):
+                for (pristine_upstream_revid, pristine_upstream_subpath) in (
+                        pristine_upstream_revids.values()):
                     if not graph.is_ancestor(
                            up_branch.last_revision(), pristine_upstream_revid):
                         return False
@@ -614,7 +617,8 @@
                    str(last_contained_version))
             parents = [
                 (self, last_contained_version,
-                 self.revid_of_version(last_contained_version))]
+                 self.revid_of_version(last_contained_version),
+                 "")]
         else:
             mutter("We don't have any of those versions")
         for branch in (list(reversed(self.get_lesser_branches()))
@@ -623,7 +627,7 @@
                 branch.contained_versions(missing_versions)
             if merged:
                 revid = branch.revid_of_version(merged[0])
-                parents.append((branch, merged[0], revid))
+                parents.append((branch, merged[0], revid, ""))
                 mutter("Adding merge from related branch of %s for version %s",
                        revid, str(merged[0]))
                 # FIXME: should this really be here?
@@ -649,7 +653,8 @@
         pull_revisions = (
                 pull_branch.pristine_upstream_source.version_as_revisions(
                     package, version))
-        for (component, pull_revision) in pull_revisions.items():
+        for (component,
+             (pull_revision, _pull_subpath)) in pull_revisions.items():
             mutter("Fetching upstream part %s of %s from revision %s",
                    component, version, pull_revision)
             assert self.pristine_upstream_tree is not None, \
@@ -753,7 +758,7 @@
                 if parent_pair[1].upstream_version == version.upstream_version:
                     need_upstream_parent = False
                     break
-        real_parents = [p[2] for p in parents]
+        real_parents = [(p[2], p[3]) for p in parents]
         if need_upstream_parent:
             upstream_revids = self.pristine_upstream_source\
                     .version_as_revisions(
@@ -776,7 +781,8 @@
         # Make sure we see any revisions added by the upstream branch
         # since self.tree was locked.
         self.branch.repository.refresh_data()
-        for (component, tag, revid, pristine_tar_imported) in imported_revids:
+        for (component, tag, revid, pristine_tar_imported,
+             subpath) in imported_revids:
             self.branch.fetch(self.pristine_upstream_branch, revid)
         self.pristine_upstream_branch.tags.merge_to(self.branch.tags)
 
@@ -797,8 +803,8 @@
         :param upstream_parents: the parents to give the upstream revision
         :param timestamp: a tuple of (timestamp, timezone) to use for
             the commit, or None to use the current time.
-        :return:
-            list with (component, tag, revid, pristine_tar_imported) tuples
+        :return: list with
+            (component, tag, revid, pristine_tar_imported, subpath) tuples
         """
         # Should we just dump the upstream part on whatever is currently
         # there, or try and pull all of the other upstream versions
@@ -814,9 +820,12 @@
         for (tarball, component, md5) in upstream_tarballs:
             parents = upstream_parents.get(component, [])
             if upstream_revisions is not None:
-                revid = upstream_revisions[component]
+                revid, subpath = upstream_revisions[component]
             else:
                 revid = None
+                subpath = ""
+            if subpath:
+                raise Exception('subpaths are not yet supported')
             upstream_trees = [
                 o.pristine_upstream_branch.basis_tree()
                 for o in other_branches]
@@ -834,7 +843,7 @@
                     revid = fetch_result.revidmap[revid]
                 upstream_branch.tags.merge_to(
                     self.pristine_upstream_branch.tags)
-                parents.append(revid)
+                parents.append((revid, ""))
                 target_tree = (
                     self.pristine_upstream_branch.repository.revision_tree(
                         revid))
@@ -847,9 +856,12 @@
                 self_tree = self.branch.basis_tree()
                 self_tree.lock_read()
             if len(parents) > 0:
-                parent_revid = parents[0]
+                parent_revid, parent_subpath = parents[0]
             else:
                 parent_revid = NULL_REVISION
+                parent_subpath = None
+            if parent_subpath:
+                raise Exception('subpaths are not supported yet')
             self.pristine_upstream_tree.pull(
                 self.pristine_upstream_tree.branch,
                 overwrite=True, stop_revision=parent_revid)
@@ -878,7 +890,7 @@
                     committer=committer, files_excluded=files_excluded,
                     reuse_existing=True))
             self.pristine_upstream_branch.generate_revision_history(revid)
-            ret.append((component, tag, revid, pristine_tar_imported))
+            ret.append((component, tag, revid, pristine_tar_imported, subpath))
             self.branch.fetch(self.pristine_upstream_branch)
             self.branch.tags.set_tag(tag, revid)
         return ret
@@ -900,7 +912,7 @@
           upstream_revisions: Upstream revision ids dictionary
           md5sum: hex digest of the md5sum of the tarball, if known.
         Returns:
-          list with (component, tag, revid, pristine_tar_imported)
+          list with (component, tag, revid, pristine_tar_imported, subpath)
           tuples
         """
         with _extract_tarballs_to_tempdir(tarballs) as tarball_dir:
@@ -933,29 +945,31 @@
         # First we move the branch to the first parent
         if parents:
             if self.branch.last_revision() == NULL_REVISION:
-                parent_revid = parents[0]
+                parent_revid, parent_subpath = parents[0]
+                if parent_subpath:
+                    raise Exception('subpaths are not yet supported')
                 self.tree.pull(
                     self.tree.branch, overwrite=True,
                     stop_revision=parent_revid)
-            elif parents[0] != self.branch.last_revision():
+            elif parents[0][0] != self.branch.last_revision():
                 mutter("Adding current tip as parent: %s",
                        self.branch.last_revision())
-                parents.insert(0, self.branch.last_revision())
+                parents.insert(0, (self.branch.last_revision(), ""))
         elif self.branch.last_revision() != NULL_REVISION:
             # We were told to import with no parents. That's not
             # right, so import with the current parent. Should
             # perhaps be fixed in the methods to determine the parents.
             mutter("Told to import with no parents. Adding current tip "
                    "as the single parent")
-            parents = [self.branch.last_revision()]
+            parents = [(self.branch.last_revision(), "")]
         other_branches = self.get_other_branches()
         debian_trees = [o.branch.basis_tree() for o in other_branches]
         parent_trees = []
         if file_ids_from is not None:
             parent_trees = file_ids_from[:]
-        for parent in parents:
-            parent_trees.append(self.branch.repository.revision_tree(
-                        parent))
+        for parent_revid, parent_subpath in parents:
+            parent_trees.append(
+                self.branch.repository.revision_tree(parent_revid))
         import_dir(
             self.tree, debian_part,
             file_ids_from=parent_trees + debian_trees)
@@ -964,7 +978,8 @@
             os.chmod(rules_path,
                      (stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP |
                       stat.S_IROTH | stat.S_IXOTH))
-        self.tree.set_parent_ids(parents)
+        self.tree.set_parent_ids(
+            [parent_revid for (parent_revid, parent_subpath) in parents])
         changelog_path = os.path.join(
             self.tree.basedir, 'debian', 'changelog')
         if os.path.exists(changelog_path):
@@ -1009,7 +1024,7 @@
         parents = []
         first_parent = self.pristine_upstream_branch.last_revision()
         if first_parent != NULL_REVISION:
-            parents = [first_parent]
+            parents = [(first_parent, "")]
         last_contained_version = self.last_contained_version(versions)
         if last_contained_version is not None:
             # If the last version was native, and was not from the same
@@ -1019,7 +1034,7 @@
                 and not self.pristine_upstream_source.has_version(
                     package, last_contained_version.upstream_version)):
                 revid = self.revid_of_version(last_contained_version)
-                parents.append(revid)
+                parents.append((revid, ""))
                 self.pristine_upstream_branch.fetch(self.branch, revid)
         pull_parents = self.get_parents(versions)
         if ((first_parent == NULL_REVISION and len(pull_parents) > 0)
@@ -1036,13 +1051,12 @@
                         package, pull_version.upstream_version))
                 if list(pull_revids.keys()) != [None]:
                     raise MultipleUpstreamTarballsNotSupported()
-                pull_revid = pull_revids[None]
                 mutter("Initialising upstream from %s, version %s",
                        str(pull_branch), str(pull_version))
-                parents.append(pull_revid)
+                parents.append(pull_revids[None])
                 self.pristine_upstream_branch.fetch(
                         pull_branch.pristine_upstream_branch,
-                        pull_revid)
+                        pull_revids[None][0])
                 pull_branch.pristine_upstream_branch.tags.merge_to(
                         self.pristine_upstream_branch.tags)
         # FIXME: What about other versions ?
@@ -1129,7 +1143,7 @@
         if last_contained_version is None:
             parents = []
         else:
-            parents = [self.revid_of_version(last_contained_version)]
+            parents = [(self.revid_of_version(last_contained_version), "")]
         missing_versions = self.missing_versions(versions)
         for branch in (list(reversed(self.get_lesser_branches()))
                        + self.get_greater_branches()):
@@ -1137,12 +1151,12 @@
                 branch.contained_versions(missing_versions)
             if merged:
                 revid = branch.revid_of_version(merged[0])
-                parents.append(revid)
+                parents.append((revid, ""))
                 # FIXME: should this really be here?
                 self._fetch_from_branch(branch, revid)
         if (self.branch.last_revision() != NULL_REVISION
                 and not self.branch.last_revision() in parents):
-            parents.insert(0, self.branch.last_revision())
+            parents.insert(0, (self.branch.last_revision(), ""))
         return parents
 
     def _import_native_package(self, package, version, versions, debian_part,
@@ -1225,8 +1239,10 @@
         assert list(upstream_tips.keys()) == [None], \
             "Upstream tips: %r" % list(upstream_tips.keys())
         # TODO(jelmer): Use colocated branches rather than creating a copy.
+        if upstream_tips[None][1]:
+            raise Exception("subpaths are not yet supported")
         dir_to = source_branch.controldir.sprout(
-            to_location, revision_id=upstream_tips[None],
+            to_location, revision_id=upstream_tips[None][0],
             accelerator_tree=self.tree)
         try:
             self.pristine_upstream_tree = dir_to.open_workingtree()
@@ -1287,7 +1303,8 @@
         graph = self.branch.repository.get_graph(
             other_repository=upstream_repository)
         return all(graph.is_ancestor(upstream_revision, this_revision)
-                   for upstream_revision in upstream_revisions.values())
+                   for upstream_revision, upstream_subpath
+                   in upstream_revisions.values())
 
     def merge_upstream(self, tarball_filenames, package, version,
                        previous_version, upstream_branch=None,
@@ -1310,7 +1327,7 @@
             if upstream_branch is not None:
                 if upstream_revisions is None:
                     upstream_revisions = {
-                        None: upstream_branch.last_revision()}
+                        None: (upstream_branch.last_revision(), "")}
                 if (not force and
                         self.has_merged_upstream_revisions(
                             self.branch.last_revision(),
@@ -1327,7 +1344,9 @@
                 if (self.pristine_upstream_branch.last_revision()
                         != NULL_REVISION):
                     parents = {
-                        None: [self.pristine_upstream_branch.last_revision()]}
+                        None: [
+                            (self.pristine_upstream_branch.last_revision(), "")
+                        ]}
                 imported_revids = self.import_upstream(
                     tarball_dir, package, version, parents,
                     upstream_tarballs=upstream_tarballs,
@@ -1348,8 +1367,11 @@
                     # Use the previous upstream import as the from revision
                     if len(parents[None]) == 0:
                         from_revision = NULL_REVISION
+                        from_subpath = ""
                     else:
-                        from_revision = parents[None][0]
+                        from_revision, from_subpath = parents[None][0]
+                    if from_subpath:
+                        raise Exception('subpath not yet supported')
                     conflicts = self.tree.merge_from_branch(
                         self.pristine_upstream_branch,
                         merge_type=merge_type, from_revision=from_revision)

=== modified file 'import_uncommitted.py'
--- import_uncommitted.py	2023-01-19 10:51:00 +0000
+++ import_uncommitted.py	2023-01-27 18:04:28 +0000
@@ -575,9 +575,10 @@
     except MalformedTransform as e:
         report_fatal('malformed-transform', str(e))
         return 1
-    except ConflictsInTree as e:
+    except ConflictsInTree:
         report_fatal(
-            'merge-conflicts', "Merging uncommitted changes resulted in conflicts.",
+            'merge-conflicts',
+            "Merging uncommitted changes resulted in conflicts.",
             transient=False)
         return 1
 

=== modified file 'merge_package.py'
--- merge_package.py	2023-01-12 11:16:09 +0000
+++ merge_package.py	2023-01-27 18:04:28 +0000
@@ -80,8 +80,8 @@
         None, uver)
     if list(upstream_revids.keys()) != [None]:
         raise MultipleUpstreamTarballsNotSupported()
-    upstream_revid = upstream_revids[None]
-    return (Version(uver), upstream_revid)
+    upstream_revid, upstream_subpath = upstream_revids[None]
+    return (Version(uver), upstream_revid, upstream_subpath)
 
 
 def fix_ancestry_as_needed(tree, source, source_revid=None):
@@ -137,10 +137,14 @@
         with tree.lock_write():
             # "Unpack" the upstream versions and revision ids for the merge
             # source and target branch respectively.
-            (us_ver, us_revid) = _upstream_version_data(source, source_revid)
-            (ut_ver, ut_revid) = _upstream_version_data(
+            (us_ver, us_revid, us_subpath) = _upstream_version_data(
+                source, source_revid)
+            (ut_ver, ut_revid, ut_subpath) = _upstream_version_data(
                 target, target.last_revision())
 
+            if us_subpath or ut_subpath:
+                raise Exception("subpaths not yet supported")
+
             # Did the upstream branches of the merge source/target diverge?
             graph = source.repository.get_graph(target.repository)
             upstreams_diverged = (len(graph.heads([us_revid, ut_revid])) > 1)
@@ -156,7 +160,8 @@
                     dir=os.path.join(tree.basedir, '..')) as tempdir:
                 # Extract the merge target's upstream tree into a temporary
                 # directory.
-                db.extract_upstream_tree({None: ut_revid}, tempdir)
+                db.extract_upstream_tree(
+                    {None: (ut_revid, ut_subpath)}, tempdir)
                 tmp_target_utree = db.pristine_upstream_tree
 
                 # Merge upstream branch tips to obtain a shared upstream

=== modified file 'merge_upstream.py'
--- merge_upstream.py	2022-10-16 17:18:34 +0000
+++ merge_upstream.py	2023-01-27 18:04:28 +0000
@@ -108,7 +108,7 @@
       committer: Committer string to use
       files_excluded: Files to exclude
     Returns:
-      list with (component, tag, revid, pristine_tar_imported)
+      list with (component, tag, revid, pristine_tar_imported, subpath)
       tuples
     """
     db = DistributionBranch(tree.branch, tree.branch, tree=tree)
@@ -142,7 +142,7 @@
 
 
 def do_merge(
-        tree, subpath, tarball_filenames, package, version,
+        tree, tarball_filenames, package, version,
         current_version, upstream_branch, upstream_revisions, merge_type=None,
         force=False, force_pristine_tar=False, committer=None,
         files_excluded=None):
@@ -242,12 +242,12 @@
 def get_existing_imported_upstream_revids(
         upstream_source, package, new_upstream_version):
     imported_revids = []
-    for component, revid in upstream_source.version_as_revisions(
-        package, new_upstream_version
-    ).items():
+    for (component,
+         (revid, subpath)) in upstream_source.version_as_revisions(
+             package, new_upstream_version).items():
         upstream_tag = upstream_source.tag_name(
             new_upstream_version, component
         )
         imported_revids.append(
-            (component, upstream_tag, revid, None))
+            (component, upstream_tag, revid, None, subpath))
     return imported_revids

=== modified file 'move_orphaned.py'
--- move_orphaned.py	2023-01-12 11:16:09 +0000
+++ move_orphaned.py	2023-01-27 18:04:28 +0000
@@ -19,6 +19,7 @@
 import json
 import logging
 import os
+import sys
 from urllib.parse import urlparse
 
 import breezy.bzr  # noqa: F401
@@ -372,6 +373,8 @@
         report_fatal(
             "formatting-unpreservable",
             "unable to preserve formatting while editing %s" % e.path)
+        if hasattr(e, 'diff'):
+            sys.stderr.writelines(e.diff())
         return 1
     except (ChangeConflict, GeneratedFile) as e:
         report_fatal(
@@ -409,5 +412,4 @@
 
 
 if __name__ == '__main__':
-    import sys
     sys.exit(main(sys.argv[1:]))

=== modified file 'new_upstream.py'
--- new_upstream.py	2023-01-12 11:16:09 +0000
+++ new_upstream.py	2023-01-27 18:04:28 +0000
@@ -259,6 +259,10 @@
         self.new_upstream_version = new_upstream_version
 
 
+class MergingUpstreamSubpathUnsupported(Exception):
+    """Merging an upstream branch with subpath is not yet supported."""
+
+
 RELEASE_BRANCH_NAME = "new-upstream-release"
 SNAPSHOT_BRANCH_NAME = "new-upstream-snapshot"
 DEFAULT_DISTRIBUTION = "unstable"
@@ -417,16 +421,16 @@
 
 def find_new_upstream(  # noqa: C901
     tree,
-    subpath,
+    subpath: str,
     config,
     package,
-    location=None,
+    location: Optional[str] = None,
     old_upstream_version=None,
     new_upstream_version=None,
-    trust_package=False,
+    trust_package: bool = False,
     version_kind: str = "release",
-    allow_ignore_upstream_branch=False,
-    top_level=False,
+    allow_ignore_upstream_branch: bool = False,
+    top_level: bool = False,
     create_dist=None,
     include_upstream_history: Optional[bool] = None,
     force_big_version_jump: bool = False,
@@ -474,16 +478,14 @@
         upstream_subpath = None  # noqa: F841
 
     if upstream_branch is not None:
-        if upstream_subpath:
-            raise Exception(
-                'merging from upstream with subpath not yet supported')
         try:
             upstream_branch_source = UpstreamBranchSource.from_branch(
                 upstream_branch,
                 config=config,
                 local_dir=tree.controldir,
                 create_dist=create_dist,
-                version_kind=version_kind
+                version_kind=version_kind,
+                subpath=upstream_subpath,
             )
         except InvalidHttpResponse as e:
             raise UpstreamBranchUnavailable(upstream_branch_location, str(e))
@@ -961,7 +963,6 @@
             try:
                 conflicts, imported_revids = do_merge(
                     tree,
-                    subpath,
                     tarball_filenames,
                     package,
                     str(new_upstream_version),
@@ -1506,6 +1507,10 @@
                 upstream_version=e.new_upstream_version, transient=False
             )
             return 1
+        except MergingUpstreamSubpathUnsupported as e:
+            report_fatal(
+                "unsupported-merging-upstream-with-subpath",
+                str(e), transient=False)
         except WatchSyntaxError as e:
             report_fatal('watch-syntax-error', str(e), transient=False)
             return 1

=== modified file 'revspec.py'
--- revspec.py	2022-10-15 11:52:18 +0000
+++ revspec.py	2023-01-27 18:04:28 +0000
@@ -109,7 +109,7 @@
             get_pristine_tar_source(tree, branch),
             ])
         try:
-            revision_id = upstream_source.version_as_revisions(
+            revision_id, subpath = upstream_source.version_as_revisions(
                 cl.package, version_spec)[None]
             return RevisionInfo.from_revision_id(
                 branch, revision_id)

=== modified file 'tests/blackbox/test_merge_upstream.py'
--- tests/blackbox/test_merge_upstream.py	2023-01-12 11:16:09 +0000
+++ tests/blackbox/test_merge_upstream.py	2023-01-27 18:04:28 +0000
@@ -99,7 +99,7 @@
             [(self.tar.tarball, None, md5sum_filename(self.tar.tarball))],
             "foo",
             str(self.tar.version),
-            {None: [tree.branch.last_revision()]})
+            {None: [(tree.branch.last_revision(), "")]})
         package_builder = SourcePackageBuilder(
             "foo", str(self.tar.version)+"-1")
         package_builder.add_default_control()

=== modified file 'tests/test_config.py'
--- tests/test_config.py	2023-01-12 14:05:53 +0000
+++ tests/test_config.py	2023-01-27 18:04:28 +0000
@@ -23,7 +23,6 @@
 from ..config import (
     BUILD_TYPE_MERGE,
     DebBuildConfig,
-    UpstreamMetadataSyntaxError,
     )
 from . import TestCaseWithTransport
 

=== modified file 'tests/test_import_dsc.py'
--- tests/test_import_dsc.py	2023-01-12 11:16:09 +0000
+++ tests/test_import_dsc.py	2023-01-27 18:04:28 +0000
@@ -264,7 +264,7 @@
         self.assertEqual(
             db.pristine_upstream_source.version_as_revisions(
                 "package", version),
-            {None: revid})
+            {None: (revid, "")})
 
     def test_contained_versions(self):
         db = self.db1
@@ -337,7 +337,7 @@
         db.tag_version(version1)
         self.assertEqual(
             db.get_parents([version2, version1]),
-            [(db, version1, revid1)])
+            [(db, version1, revid1, "")])
 
     def test_get_parents_merge_from_lesser(self):
         """Merge with same upstream version gives merged as second parent."""
@@ -352,8 +352,8 @@
         # test is that revid1 is second parent
         self.assertEqual(
             self.db2.get_parents(versions),
-            [(self.db2, version2, revid2),
-             (self.db1, version1, revid1)])
+            [(self.db2, version2, revid2, ""),
+             (self.db1, version1, revid1, "")])
 
     def test_get_parents_merge_from_greater(self):
         """Merge from greater is same as merge from lesser."""
@@ -368,8 +368,8 @@
         # test is that revid2 is second parent
         self.assertEqual(
             self.db1.get_parents(versions), [
-                (self.db1, version1, revid1),
-                (self.db2, version2, revid2)])
+                (self.db1, version1, revid1, ""),
+                (self.db2, version2, revid2, "")])
 
     def test_get_parents_merge_from_two_lesser(self):
         """Should use greatest lesser when two candidates."""
@@ -386,8 +386,8 @@
         # test is that revid2 and not revid1 is second parent
         self.assertEqual(
             self.db3.get_parents(versions),
-            [(self.db3, version2, revid3),
-             (self.db2, version1, revid2)])
+            [(self.db3, version2, revid3, ""),
+             (self.db2, version1, revid2, "")])
 
     def test_get_parents_merge_from_two_greater(self):
         """Should use least greater when two candidates."""
@@ -404,8 +404,8 @@
         # test is that revid2 and not revid3 is second parent
         self.assertEqual(
                 self.db1.get_parents(versions),
-                [(self.db1, version1, revid1),
-                 (self.db2, version2, revid2)])
+                [(self.db1, version1, revid1, ""),
+                 (self.db2, version2, revid2, "")])
 
     def test_get_parents_merge_multiple_from_greater(self):
         """More than two parents correctly ordered."""
@@ -423,8 +423,9 @@
         # test is that revid2 is second, revid3 is third
         self.assertEqual(
             self.db1.get_parents(versions),
-            [(self.db1, version1, revid1), (self.db2, version2, revid2),
-             (self.db3, version3, revid3)])
+            [(self.db1, version1, revid1, ""),
+             (self.db2, version2, revid2, ""),
+             (self.db3, version3, revid3, "")])
 
     def test_get_parents_sync_when_diverged(self):
         version1 = Version("0.1-1")
@@ -442,8 +443,8 @@
         # and the Debian upload as the second parent.
         self.assertEqual(
             self.db2.get_parents(versions),
-            [(self.db2, version2, revid2),
-             (self.db1, version3, revid3)])
+            [(self.db2, version2, revid2, ""),
+             (self.db1, version3, revid3, "")])
 
     def test_get_parents_skipped_version(self):
         version1 = Version("0.1-1")
@@ -456,7 +457,7 @@
         versions = [version3, version2, version1]
         self.assertEqual(
             self.db2.get_parents(versions),
-            [(self.db2, version2, revid2)])
+            [(self.db2, version2, revid2, "")])
 
     def test_get_parents_with_upstream_first_version(self):
         db = self.db1
@@ -466,14 +467,14 @@
         self.assertEqual(
             db.get_parents_with_upstream(
                 "package", version1, [version1], None),
-            [up_revid])
+            [(up_revid, "")])
         db = self.db2
         self.up_tree2.pull(self.up_tree1.branch)
         self.tag_upstream_version(db, version1.upstream_version)
         self.assertEqual(
             db.get_parents_with_upstream(
                 "package", version1, [version1], None),
-            [up_revid])
+            [(up_revid, "")])
 
     def test_get_parents_with_upstream_second_version(self):
         db = self.db1
@@ -485,7 +486,7 @@
         self.tag_upstream_version(db, version1.upstream_version)
         # No upstream parent
         self.assertEqual(db.get_parents_with_upstream(
-            "package", version2, [version2, version1], None), [revid1])
+            "package", version2, [version2, version1], None), [(revid1, "")])
 
     def test_get_parents_with_upstream_merge_from_lesser(self):
         version1 = Version("0.1-1")
@@ -502,7 +503,7 @@
         versions = [version3, version1, version2]
         # No upstream parent
         self.assertEqual(self.db2.get_parents_with_upstream(
-            "package", version3, versions, None), [revid2, revid1])
+            "package", version3, versions, None), [(revid2, ""), (revid1, "")])
 
     def test_get_parents_with_upstream_merge_from_greater(self):
         version1 = Version("0.1-1")
@@ -519,7 +520,7 @@
         versions = [version3, version2, version1]
         # No upstream parent
         self.assertEqual(self.db1.get_parents_with_upstream(
-            "package", version3, versions, None), [revid1, revid2])
+            "package", version3, versions, None), [(revid1, ""), (revid2, "")])
 
     def test_get_parents_with_upstream_new_upstream_import(self):
         version1 = Version("0.1-1")
@@ -535,7 +536,8 @@
         versions = [version2, version1]
         # Upstream parent as it is new upstream version
         self.assertEqual(self.db2.get_parents_with_upstream(
-            "package", version2, versions, None), [revid1, up_revid2])
+            "package", version2, versions, None),
+            [(revid1, ""), (up_revid2, "")])
 
     def test_get_parents_merge_new_upstream_from_lesser(self):
         version1 = Version("0.1-1")
@@ -559,7 +561,7 @@
         versions = [version4, version3, version2, version1]
         # no upstream parent as the lesser branch has already merged it
         self.assertEqual(self.db2.get_parents_with_upstream(
-            "package", version4, versions, None), [revid2, revid3])
+            "package", version4, versions, None), [(revid2, ""), (revid3, "")])
 
     def test_get_parents_with_upstream_force_upstream(self):
         version1 = Version("0.1-1")
@@ -575,7 +577,7 @@
         # upstream parent, but we are requiring one.
         self.assertEqual(self.db2.get_parents_with_upstream(
             "package", version2, versions, None, force_upstream_parent=True),
-            [revid1, up_revid2])
+            [(revid1, ""), (up_revid2, "")])
 
     def test_get_parents_with_upstream_sync_when_diverged(self):
         version1 = Version("0.1-1")
@@ -595,7 +597,7 @@
         # This is a sync but we are diverged so we should get two
         # parents
         self.assertEqual(self.db2.get_parents_with_upstream(
-            "package", version3, versions, None), [revid2, revid3])
+            "package", version3, versions, None), [(revid2, ""), (revid3, "")])
 
     def test_get_parents_with_upstream_sync_new_upstream(self):
         version1 = Version("0.1-1")
@@ -618,7 +620,7 @@
         # parents. There should be no upstream as the synced
         # version will already have it.
         self.assertEqual(self.db2.get_parents_with_upstream(
-            "package", version3, versions, None), [revid2, revid3])
+            "package", version3, versions, None), [(revid2, ""), (revid3, "")])
 
     def test_get_parents_with_upstream_sync_new_upstream_force(self):
         version1 = Version("0.1-1")
@@ -646,7 +648,7 @@
         # TODO: should the upstream parent be second or third?
         self.assertEqual(self.db2.get_parents_with_upstream(
             "package", version3, versions, None, force_upstream_parent=True),
-                [revid2, up_revid3, revid3])
+                [(revid2, ""), (up_revid3, ""), (revid3, "")])
 
     def test_branch_to_pull_version_from(self):
         """Test the check for pulling from a branch.
@@ -774,7 +776,7 @@
         self.assertEqual(self.db2.revid_of_version(version), revid)
         self.assertEqual(
             self.db2.pristine_upstream_source.version_as_revisions(
-                "package", version.upstream_version), {None: up_revid})
+                "package", version.upstream_version), {None: (up_revid, "")})
 
     def test_pull_from_lesser_branch_with_upstream(self):
         version = Version("0.1-1")
@@ -791,7 +793,7 @@
         self.assertEqual(self.db2.revid_of_version(version), revid)
         self.assertEqual(
             self.db2.pristine_upstream_source.version_as_revisions(
-                "package", version.upstream_version), {None: up_revid})
+                "package", version.upstream_version), {None: (up_revid, "")})
 
     def test_pull_upstream_from_branch(self):
         version = "0.1"
@@ -804,7 +806,7 @@
         self.assertEqual(
             self.db2.pristine_upstream_source.version_as_revisions(
                 "package", version),
-            {None: up_revid})
+            {None: (up_revid, "")})
 
     def check_changes(self, changes, added=[], removed=[], modified=[],
                       renamed=[]):
@@ -874,7 +876,7 @@
         self.assertEqual(revno, 1)
         self.assertEqual(
             self.db1.pristine_upstream_source.version_as_revisions(
-                "package", version.upstream_version), {None: rev_id})
+                "package", version.upstream_version), {None: (rev_id, "")})
         rev = branch.repository.get_revision(rev_id)
         self.assertEqual(
             rev.message,
@@ -909,7 +911,7 @@
         write_to_file(os.path.join(basedir, "NEWS"), b"")
         self.db1.import_upstream(
             basedir, "package", version2.upstream_version,
-            {None: [self.up_tree1.branch.last_revision()]},
+            {None: [(self.up_tree1.branch.last_revision(), "")]},
             [(None, None, None)])
         tree = self.up_tree1
         branch = tree.branch
@@ -918,7 +920,7 @@
         self.assertEqual(
             self.db1.pristine_upstream_source.version_as_revisions(
                 "package", version2.upstream_version),
-            {None: rev_id})
+            {None: (rev_id, "")})
         rev = branch.repository.get_revision(rev_id)
         self.assertEqual(
             rev.message,
@@ -955,7 +957,7 @@
         self.assertEqual(revno, 1)
         self.assertEqual(
             self.db1.pristine_upstream_source.version_as_revisions(
-                "package", version.upstream_version), {None: rev_id})
+                "package", version.upstream_version), {None: (rev_id, "")})
         rev = branch.repository.get_revision(rev_id)
         self.assertEqual(
             rev.message,
@@ -987,7 +989,7 @@
         self.assertEqual(revno, 1)
         self.assertEqual(
             self.db1.pristine_upstream_source.version_as_revisions(
-                "package", version.upstream_version), {None: rev_id})
+                "package", version.upstream_version), {None: (rev_id, "")})
         rev = branch.repository.get_revision(rev_id)
         self.assertEqual(
             rev.message,
@@ -1037,7 +1039,7 @@
         self.assertEqual(revno, 1)
         self.assertEqual(
             self.db1.pristine_upstream_source.version_as_revisions(
-                "package", version.upstream_version), {None: rev_id})
+                "package", version.upstream_version), {None: (rev_id, "")})
         rev = branch.repository.get_revision(rev_id)
         self.assertEqual(
             rev.message,
@@ -1491,7 +1493,7 @@
         self.assertEqual(
             self.db1.pristine_upstream_source.version_as_revisions(
                 "package", version1.upstream_version),
-            {None: up_rh1[0]})
+            {None: (up_rh1[0], "")})
         self.tree1.lock_read()
         self.addCleanup(self.tree1.unlock)
         self.assertFalse(self.db1.is_version_native(version1))
@@ -1542,11 +1544,11 @@
         self.assertEqual(
             self.db1.pristine_upstream_source.version_as_revisions(
                 "package", version1.upstream_version),
-            {None: up_rh1[0]})
+            {None: (up_rh1[0], "")})
         self.assertEqual(
             self.db1.pristine_upstream_source.version_as_revisions(
                 "package", version3.upstream_version),
-            {None: up_rh1[1]})
+            {None: (up_rh1[1], "")})
         self.tree1.lock_read()
         self.addCleanup(self.tree1.unlock)
         self.assertFalse(self.db1.is_version_native(version1))
@@ -1596,11 +1598,11 @@
         self.assertEqual(
             self.db1.pristine_upstream_source.version_as_revisions(
                 "package", version1.upstream_version),
-            {None: up_rh1[0]})
+            {None: (up_rh1[0], "")})
         self.assertEqual(
             self.db1.pristine_upstream_source.version_as_revisions(
                 "package", version3.upstream_version),
-            {None: up_rh1[1]})
+            {None: (up_rh1[1], "")})
         self.tree1.lock_read()
         self.addCleanup(self.tree1.unlock)
         self.assertFalse(self.db1.is_version_native(version1))
@@ -1707,7 +1709,7 @@
         conflicts, imported_revids = db.merge_upstream(
             [(tarball_filename, None)], "foo", "0.2", "0.1",
             upstream_branch=upstream_tree.branch,
-            upstream_revisions={None: upstream_rev})
+            upstream_revisions={None: (upstream_rev, "")})
         self.assertFalse(conflicts)
 
     def test_merge_upstream_initial_with_removed_debian(self):
@@ -1745,7 +1747,7 @@
         conflicts, imported_revids = db.merge_upstream(
             [(tarball_filename, None)], "foo", "0.2", "0.1",
             upstream_branch=upstream_tree.branch,
-            upstream_revisions={None: upstream_rev})
+            upstream_revisions={None: (upstream_rev, "")})
         # ./debian conflicts.
         self.assertEqual(3, len(conflicts))
 
@@ -1789,7 +1791,7 @@
             [(builder.tar_name(), None)], "package", str(version2),
             version1.upstream_version,
             upstream_branch=upstream_tree.branch,
-            upstream_revisions={None: upstream_rev})
+            upstream_revisions={None: (upstream_rev, "")})
         revno1, rev_id1 = tree.branch.last_revision_info()
         self.assertEqual(2, revno1)
         packaging_upstream_tip = tree.get_parent_ids()[1]
@@ -1866,7 +1868,7 @@
             version2.upstream_version,
             version1.upstream_version,
             upstream_branch=upstream_tree.branch,
-            upstream_revisions={None: upstream_rev2})
+            upstream_revisions={None: (upstream_rev2, "")})
         self.assertEqual(b"a-id", tree.path2id("b"))
 
     def test_merge_upstream_rename_on_top(self):
@@ -1904,7 +1906,7 @@
             version2.upstream_version,
             version1.upstream_version,
             upstream_branch=upstream_tree.branch,
-            upstream_revisions={None: upstream_rev2})
+            upstream_revisions={None: (upstream_rev2, "")})
         self.assertEqual(b"a-id", tree.path2id("b"))
 
     def test_merge_upstream_rename_in_packaging_branch(self):

=== modified file 'tests/test_upstream.py'
--- tests/test_upstream.py	2023-01-12 11:16:09 +0000
+++ tests/test_upstream.py	2023-01-27 18:04:28 +0000
@@ -489,10 +489,10 @@
             config=config)
         revid2 = self.tree.commit("msg")
         self.assertEqual(
-            revid2,
+            (revid2, ""),
             source.version_as_revision("foo", "2.1+bzr2"))
         self.assertEqual(
-            {None: revid1}, source.version_as_revisions("foo", "2.1"))
+            {None: (revid1, "")}, source.version_as_revisions("foo", "2.1"))
 
     def test_version_as_revision(self):
         revid1 = self.tree.commit("msg")
@@ -506,8 +506,9 @@
             config=config)
         revid2 = self.tree.commit("msg")
         self.assertEqual(
-            revid2, source.version_as_revision("foo", "2.1+bzr2"))
-        self.assertEqual(revid1, source.version_as_revision("foo", "2.1"))
+            (revid2, ""), source.version_as_revision("foo", "2.1+bzr2"))
+        self.assertEqual(
+            (revid1, ""), source.version_as_revision("foo", "2.1"))
 
     def test_version_as_revision_no_revspec(self):
         # There is no relevant revspec known
@@ -635,8 +636,9 @@
         self.assertIs(None, source._upstream_branch)
         revid2 = self.tree.commit("msg")
         self.assertEqual(
-            revid2, source.version_as_revision("foo", "2.1+bzr2"))
-        self.assertEqual(revid1, source.version_as_revision("foo", "2.1"))
+            (revid2, ""), source.version_as_revision("foo", "2.1+bzr2"))
+        self.assertEqual(
+            (revid1, ""), source.version_as_revision("foo", "2.1"))
         self.assertIsNot(None, source._upstream_branch)
 
 
@@ -1073,14 +1075,14 @@
         revid1 = self.tree.commit("msg")
         self.tree.branch.tags.set_tag("upstream-2.1", revid1)
         self.assertEqual(
-            {None: revid1},
+            {None: (revid1, "")},
             self.source.version_as_revisions(None, "2.1"))
 
     def test_version_component_as_revision(self):
         revid1 = self.tree.commit("msg")
         self.tree.branch.tags.set_tag("upstream-2.1/lib", revid1)
         self.assertEqual(
-            revid1,
+            (revid1, ""),
             self.source.version_component_as_revision(None, "2.1", "lib"))
 
     # git doesn't support subtags
@@ -1091,7 +1093,7 @@
         self.tree.branch.tags.set_tag("upstream-2.1", revid1)
         self.tree.branch.tags.set_tag("upstream-2.1/lib", revid2)
         self.assertEqual(
-            {None: revid1, "lib": revid2},
+            {None: (revid1, ""), "lib": (revid2, "")},
             self.source.version_as_revisions(None, "2.1", [
                 ("upstream_2.1.orig.tar.gz", None, "somemd5sum"),
                 ("upstream_2.1.orig-lib.tar.gz", "lib", "othermd5sum")]))
@@ -1177,14 +1179,14 @@
         revid1 = self.tree.commit("msg")
         self.tree.branch.tags.set_tag("upstream-2.1", revid1)
         self.assertEqual(
-            {None: revid1},
+            {None: (revid1, "")},
             self.source.version_as_revisions(None, "2.1"))
 
     def test_version_component_as_revision(self):
         revid1 = self.tree.commit("msg")
         self.tree.branch.tags.set_tag("upstream-2.1/lib", revid1)
         self.assertEqual(
-            revid1,
+            (revid1, ""),
             self.source.version_component_as_revision(None, "2.1", "lib"))
 
     def test_version_as_revisions(self):
@@ -1193,7 +1195,7 @@
         self.tree.branch.tags.set_tag("upstream-2.1", revid1)
         self.tree.branch.tags.set_tag("upstream-2.1/lib", revid2)
         self.assertEqual(
-            {None: revid1, "lib": revid2},
+            {None: (revid1, ""), "lib": (revid2, "")},
             self.source.version_as_revisions(None, "2.1", [
                 ("upstream_2.1.orig.tar.gz", None, "somemd5sum"),
                 ("upstream_2.1.orig-lib.tar.gz", "lib", "othermd5sum")]))

=== modified file 'upstream/__init__.py'
--- upstream/__init__.py	2023-01-12 11:16:09 +0000
+++ upstream/__init__.py	2023-01-27 18:04:28 +0000
@@ -105,7 +105,7 @@
 
     def version_as_revisions(
             self, package: str, version: str,
-            tarballs=None) -> dict[Optional[str], RevisionID]:
+            tarballs=None) -> dict[Optional[str], tuple[RevisionID, str]]:
         """Lookup the revision ids for a particular version.
 
         :param package: Package name

=== modified file 'upstream/branch.py'
--- upstream/branch.py	2023-01-12 11:16:09 +0000
+++ upstream/branch.py	2023-01-27 18:04:28 +0000
@@ -51,7 +51,7 @@
     )
 from ....memorybranch import MemoryBranch
 from ..repack_tarball import get_filetype, repack_tarball
-from ....revision import NULL_REVISION
+from ....revision import NULL_REVISION, RevisionID
 from ....revisionspec import RevisionSpec
 from ....trace import note, mutter, warning
 from ....tree import Tree
@@ -409,7 +409,7 @@
 
     def __init__(self, upstream_branch, upstream_revision_map=None,
                  config=None, actual_branch=None, create_dist=None,
-                 other_repository=None, version_kind="auto"):
+                 other_repository=None, version_kind="auto", subpath=None):
         self.upstream_branch = upstream_branch
         self._actual_branch = actual_branch or upstream_branch
         self.create_dist = create_dist
@@ -417,13 +417,16 @@
         self.version_kind = version_kind
         self.other_repository = other_repository
         self.upstream_revision_map = {}
+        if subpath is None:
+            subpath = ""
+        self.subpath = subpath
         if upstream_revision_map is not None:
             self.upstream_revision_map.update(upstream_revision_map.items())
 
     @classmethod
     def from_branch(cls, upstream_branch, upstream_revision_map=None,
                     config=None, local_dir=None, create_dist=None,
-                    version_kind="auto"):
+                    version_kind="auto", subpath: Optional[str] = None):
         """Create a new upstream branch source from a branch.
 
         This will optionally fetch into a local directory.
@@ -449,7 +452,8 @@
             actual_branch=actual_branch, create_dist=create_dist,
             version_kind=version_kind)
 
-    def version_as_revision(self, package, version, tarballs=None):
+    def version_as_revision(
+            self, package, version, tarballs=None) -> tuple[RevisionID, str]:
         if version in self.upstream_revision_map:
             revspec = self.upstream_revision_map[version]
         else:
@@ -458,7 +462,7 @@
         if revspec is not None:
             try:
                 return RevisionSpec.from_string(
-                    revspec).as_revision_id(self.upstream_branch)
+                    revspec).as_revision_id(self.upstream_branch), self.subpath
             except (InvalidRevisionSpec, NoSuchTag) as e:
                 raise PackageVersionNotPresent(package, version, self) from e
         else:
@@ -466,17 +470,16 @@
                 note(gettext('No upstream upstream-revision format '
                              'specified, trying %s') % revspec)
                 try:
-                    return RevisionSpec.from_string(
-                        revspec).as_revision_id(self.upstream_branch)
+                    return RevisionSpec.from_string(revspec)\
+                        .as_revision_id(self.upstream_branch), self.subpath
                 except (InvalidRevisionSpec, NoSuchTag):
                     pass
-            else:
-                raise PackageVersionNotPresent(package, version, self)
+            raise PackageVersionNotPresent(package, version, self)
         raise PackageVersionNotPresent(package, version, self)
 
     def revision_tree(self, package, version):
-        revid = self.version_as_revision(package, version)
-        return self.upstream_branch.repository.revision_tree(revid)
+        revid, subpath = self.version_as_revision(package, version)
+        return self.upstream_branch.repository.revision_tree(revid), subpath
 
     def version_as_revisions(self, package, version, tarballs=None):
         # FIXME: Support multiple upstream locations if there are multiple
@@ -536,7 +539,7 @@
             graph = self.upstream_branch.repository.get_graph()
             if since_version is not None:
                 try:
-                    since_revision = self.version_as_revision(
+                    since_revision, _subpath = self.version_as_revision(
                         package, since_version)
                 except PackageVersionNotPresent as e:
                     raise PreviousVersionTagMissing(
@@ -574,9 +577,9 @@
              getattr(self, '_actual_branch', self.upstream_branch).user_url)
         with self.upstream_branch.lock_read():
             if revisions is not None:
-                revid = revisions[None]
+                revid, subpath = revisions[None]
             else:
-                revid = self.version_as_revision(package, version)
+                revid, subpath = self.version_as_revision(package, version)
                 if revid is None:
                     raise PackageVersionNotPresent(package, version, self)
             if self.other_repository is not None:
@@ -590,17 +593,19 @@
                 rev_tree = self.upstream_branch.repository.revision_tree(revid)
             if self.create_dist is not None:
                 with tempfile.TemporaryDirectory() as td:
-                    fn = self.create_dist(rev_tree, package, version, td)
+                    fn = self.create_dist(
+                        rev_tree, package, version, td, subpath=subpath)
                     if fn:
                         nfn = new_tarball_name(package, version, fn)
                         repack_tarball(os.path.join(td, fn), nfn, target_dir)
                         return [os.path.join(target_dir, nfn)]
-            tarball_base = "{}-{}".format(package, version)
+            tarball_base = f"{package}-{version}"
             target_filename = self._tarball_path(
                 package, version, None, target_dir)
             try:
                 export_with_nested(
-                    rev_tree, target_filename, format='tgz', root=tarball_base)
+                    rev_tree, target_filename, format='tgz', root=tarball_base,
+                    subdir=subpath)
             except UnsupportedOperation as e:
                 note('Not exporting revision from upstream branch: %s', e)
                 raise PackageVersionNotPresent(package, version, self) from e
@@ -621,13 +626,16 @@
 
     def __init__(self, upstream_branch_url, upstream_revision_map=None,
                  config=None, create_dist=None, other_repository=None,
-                 version_kind="snapshot"):
+                 version_kind="snapshot", subpath=None):
         self.upstream_branch_url = upstream_branch_url
         self.version_kind = version_kind
         self._upstream_branch = None
         self.config = config
         self.create_dist = create_dist
         self.other_repository = other_repository
+        if subpath is None:
+            subpath = ""
+        self.subpath = subpath
         if upstream_revision_map is None:
             self.upstream_revision_map = {}
         else:

=== modified file 'upstream/pristinetar.py'
--- upstream/pristinetar.py	2023-01-12 11:16:09 +0000
+++ upstream/pristinetar.py	2023-01-27 18:04:28 +0000
@@ -58,7 +58,7 @@
     NoSuchTag,
     NotBranchError,
     )
-from ....revision import NULL_REVISION
+from ....revision import NULL_REVISION, RevisionID
 from ....trace import (
     mutter,
     note,
@@ -360,7 +360,8 @@
 
     def version_component_as_revision(
             self, package: Optional[str], version: str,
-            component: Optional[str], md5: Optional[str] = None):
+            component: Optional[str],
+            md5: Optional[str] = None) -> tuple[RevisionID, str]:
         with self.branch.lock_read():
             for tag_name in self.possible_tag_names(
                     package, version, component=component):
@@ -370,14 +371,14 @@
                     continue
                 else:
                     if self._has_revision(revid, md5=md5):
-                        return revid
+                        return revid, ""
             # Note that we don't check *all* possible revids here,
             # since some of them are branch-local (such as revno:)
             (git_id, git_date) = git_snapshot_data_from_version(version)
             if git_id:
                 try:
                     revspec = RevisionSpec.from_string('git:%s' % git_id)
-                    return revspec.as_revision_id(self.branch)
+                    return revspec.as_revision_id(self.branch), ""
                 except (InvalidRevisionSpec, NoSuchTag):
                     pass
             revid = self._search_for_upstream_version(
@@ -388,9 +389,9 @@
                     "Upstream import of %s lacks a tag. Set one by running: "
                     "brz tag -rrevid:%s %s", version, revid.decode('utf-8'),
                     tag_name)
-                return revid
+                return revid, ""
             try:
-                return self.branch.tags.lookup_tag(tag_name)
+                return self.branch.tags.lookup_tag(tag_name), ""
             except NoSuchTag as e:
                 raise PackageVersionNotPresent(package, version, self) from e
 
@@ -509,12 +510,16 @@
             timestamp = timestamp[0]
         if len(parent_ids) == 0:
             base_revid = _mod_revision.NULL_REVISION
+            base_subpath = ""
         else:
-            base_revid = parent_ids[0]
+            base_revid, base_subpath = parent_ids[0]
+        if base_subpath:
+            raise Exception('subpaths are not yet supported')
         basis_tree = tree.branch.repository.revision_tree(base_revid)
         with tree.lock_write():
             builder = tree.branch.get_commit_builder(
-                    parents=parent_ids, revprops=revprops, timestamp=timestamp,
+                    parents=[revid for revid, subpath in parent_ids],
+                    revprops=revprops, timestamp=timestamp,
                     timezone=timezone, committer=committer)
             try:
                 changes = [c for c in tree.iter_changes(basis_tree) if
@@ -534,7 +539,9 @@
         return tag_name, revid, delta is not None
 
     def fetch_component_tarball(self, package, version, component, target_dir):
-        revid = self.version_component_as_revision(package, version, component)
+        revid, subpath = self.version_component_as_revision(
+            package, version, component)
+        assert subpath == ""
         try:
             rev = self.branch.repository.get_revision(revid)
         except NoSuchRevision as e:
@@ -798,8 +805,11 @@
             timestamp = timestamp[0]
         if len(parent_ids) == 0:
             base_revid = _mod_revision.NULL_REVISION
+            base_subpath = ""
         else:
-            base_revid = parent_ids[0]
+            base_revid, base_subpath = parent_ids[0]
+        if base_subpath:
+            raise Exception('subpaths not yet supported')
         basis_tree = tree.branch.repository.revision_tree(base_revid)
         with tree.lock_write():
             builder = tree.branch.get_commit_builder(
@@ -937,12 +947,13 @@
             (dest_filename, delta_bytes, delta_id,
              delta_sig) = self.get_pristine_tar_delta(package, version)
         except PristineTarDeltaAbsent:
-            revid = self.version_component_as_revision(
+            revid, subpath = self.version_component_as_revision(
                 package, version, component)
             tree = self.branch.repository.revision_tree(revid)
             dest_filename = self._tarball_path(
                 package, version, component, target_dir, format='gz')
-            export_with_nested(tree, dest_filename, per_file_timestamps=True)
+            export_with_nested(
+                tree, dest_filename, per_file_timestamps=True, subdir=subpath)
             return dest_filename
         else:
             dest_filename = os.path.join(target_dir, dest_filename)