~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

(jelmer) Use the absolute_import feature everywhere in bzrlib,
 and add a source test to make sure it's used everywhere. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
 
18
17
"""Copying of history from one branch to another.
19
18
 
20
19
The basic plan is that every branch knows the history of everything
23
22
branch.
24
23
"""
25
24
 
 
25
from __future__ import absolute_import
 
26
 
26
27
import operator
27
28
 
28
29
from bzrlib.lazy_import import lazy_import
29
30
lazy_import(globals(), """
30
31
from bzrlib import (
31
 
    graph as _mod_graph,
32
32
    tsort,
33
33
    versionedfile,
 
34
    vf_search,
34
35
    )
35
36
""")
36
37
from bzrlib import (
161
162
        elif self._last_revision == NULL_REVISION:
162
163
            # fetch_spec is None + last_revision is null => empty fetch.
163
164
            # explicit limit of no revisions needed
164
 
            return _mod_graph.EmptySearchResult()
 
165
            return vf_search.EmptySearchResult()
165
166
        elif self._last_revision is not None:
166
 
            return _mod_graph.NotInOtherForRevs(self.to_repository,
 
167
            return vf_search.NotInOtherForRevs(self.to_repository,
167
168
                self.from_repository, [self._last_revision],
168
169
                find_ghosts=self.find_ghosts).execute()
169
170
        else: # self._last_revision is None:
170
 
            return _mod_graph.EverythingNotInOther(self.to_repository,
 
171
            return vf_search.EverythingNotInOther(self.to_repository,
171
172
                self.from_repository,
172
173
                find_ghosts=self.find_ghosts).execute()
173
174
 
389
390
                    "limit is only supported with a source branch set")
390
391
            # Caller hasn't specified any revisions or source branch
391
392
            if self.target_repo_kind == TargetRepoKinds.EMPTY:
392
 
                return _mod_graph.EverythingResult(self.source_repo)
 
393
                return vf_search.EverythingResult(self.source_repo)
393
394
            else:
394
395
                # We want everything not already in the target (or target's
395
396
                # fallbacks).
396
 
                return _mod_graph.EverythingNotInOther(
 
397
                return vf_search.EverythingNotInOther(
397
398
                    self.target_repo, self.source_repo).execute()
398
399
        heads_to_fetch = set(self._explicit_rev_ids)
399
400
        if self.source_branch is not None:
416
417
            # heads_to_fetch will almost certainly be present so this doesn't
417
418
            # matter much.
418
419
            all_heads = heads_to_fetch.union(if_present_fetch)
419
 
            ret = _mod_graph.PendingAncestryResult(all_heads, self.source_repo)
 
420
            ret = vf_search.PendingAncestryResult(all_heads, self.source_repo)
420
421
            if self.limit is not None:
421
422
                graph = self.source_repo.get_graph()
422
423
                topo_order = list(graph.iter_topo_order(ret.get_keys()))
424
425
                ret = self.source_repo.revision_ids_to_search_result(result_set)
425
426
            return ret
426
427
        else:
427
 
            return _mod_graph.NotInOtherForRevs(self.target_repo, self.source_repo,
 
428
            return vf_search.NotInOtherForRevs(self.target_repo, self.source_repo,
428
429
                required_ids=heads_to_fetch, if_present_ids=if_present_fetch,
429
430
                limit=self.limit).execute()