/brz/remove-bazaar

from __future__ import absolute_import

 

from . import errors

 

    cleanup,

    fetch,

from .decorators import (

    needs_read_lock,

    needs_write_lock,

    only_raises,

    )

from .sixish import (

    BytesIO,

    viewitems,

    )

from .trace import mutter, mutter_callsite, note, is_quiet

        self._tags_bytes = None

        if self._partial_revision_history_cache[-1] == _mod_revision.NULL_REVISION:

        control = controldir.ControlDir.open(base,

            possible_transports=possible_transports, _unsupported=_unsupported)

        return control.open_branch(unsupported=_unsupported,

            possible_transports=None):

        control = controldir.ControlDir.open_from_transport(transport, _unsupported)

        return control.open_branch(name=name, unsupported=_unsupported,

        If there is one and it is either an unrecognised format or an unsupported

        format, UnknownFormatError or UnsupportedFormatError are raised.

        If there is one, it is returned, along with the unused portion of url.

        control, relpath = controldir.ControlDir.open_containing(url,

                                                         possible_transports)

    def _get_config(self):

        """Get the concrete config for just the config in this branch.

 

        This is not intended for client use; see Branch.get_config for the

        public API.

 

        Added in 1.14.

 

        :return: An object supporting get_option and set_option.

        """

        raise NotImplementedError(self._get_config)

 

    @needs_read_lock

    def _get_tags_bytes(self):

        """Get the bytes of a serialised tags dict.

 

        Note that not all branches support tags, nor do all use the same tags

        logic: this method is specific to BasicTags. Other tag implementations

        may use the same method name and behave differently, safely, because

        of the double-dispatch via

        format.make_tags->tags_instance->get_tags_dict.

 

        :return: The bytes of the tags file.

        :seealso: Branch._set_tags_bytes.

        """

        if self._tags_bytes is None:

            self._tags_bytes = self._transport.get_bytes('tags')

        return self._tags_bytes

 

                    "falling back to local nick.\n " + str(e))

        while (current_rev_id in parents_map and

               len(parents_map[current_rev_id]) > 0):

    @needs_read_lock

        rev_id = self._do_dotted_revno_to_revision_id(revno)

        if _cache_reverse:

            self._partial_revision_id_to_revno_cache[rev_id] = revno

        return rev_id

            return self.get_rev_id(revno[0])

                        in viewitems(revision_id_to_revno)

    @needs_read_lock

        return self._do_revision_id_to_dotted_revno(revision_id)

    @needs_read_lock

        if self._revision_id_to_revno_cache is not None:

            mapping = self._revision_id_to_revno_cache

        else:

            mapping = self._gen_revno_map()

            self._cache_revision_id_to_revno(mapping)

        # TODO: jam 20070417 Since this is being cached, should we be returning

        #       a copy?

        # I would rather not, and instead just declare that users should not

        # modify the return value.

        return mapping

        revision_id_to_revno = dict((rev_id, revno)

            for rev_id, depth, revno, end_of_merge

             in self.iter_merge_sorted_revisions())

    @needs_read_lock

            stop_revision_id=None, stop_rule='exclude', direction='reverse'):

            * 'with-merges-without-common-ancestry' - filter out revisions 

        # Note: depth and revno values are in the context of the branch so

        # we need the full graph to get stable numbers, regardless of the

        # start_revision_id.

        if self._merge_sorted_revisions_cache is None:

            last_revision = self.last_revision()

            known_graph = self.repository.get_known_graph_ancestry(

                [last_revision])

            self._merge_sorted_revisions_cache = known_graph.merge_sort(

                last_revision)

        filtered = self._filter_merge_sorted_revisions(

            self._merge_sorted_revisions_cache, start_revision_id,

            stop_revision_id, stop_rule)

        # Make sure we don't return revisions that are not part of the

        # start_revision_id ancestry.

        filtered = self._filter_start_non_ancestors(filtered)

        if direction == 'reverse':

            return filtered

        if direction == 'forward':

            return reversed(list(filtered))

        else:

            raise ValueError('invalid direction %r' % direction)

        start_revision_id, stop_revision_id, stop_rule):

                if (not reached_stop_revision_id or

                        rev_id in revision_id_whitelist):

                       node.end_of_merge)

        first = next(rev_iter)

        If lock_write doesn't return a token, then this method is not supported.

        If lock_write doesn't return a token, then this method is not supported.

    def set_reference_info(self, file_id, tree_path, branch_location):

        """Set the branch location to use for a tree reference."""

        raise errors.UnsupportedOperation(self.set_reference_info, self)

 

    def get_reference_info(self, file_id):

        """Get the tree_path and branch_location for a tree reference."""

        raise errors.UnsupportedOperation(self.get_reference_info, self)

 

    @needs_write_lock

    def fetch(self, from_branch, last_revision=None, limit=None):

        :param last_revision: What revision to stop at (None for at the end

        return InterBranch.get(from_branch, self).fetch(last_revision, limit=limit)

            represented, when pushing to a foreign VCS 

        return self.repository.get_commit_builder(self, parents, config_stack,

            timestamp, timezone, committer, revprops, revision_id,

            lossy)

    def print_file(self, file, revision_id):

        """Print `file` to stdout."""

        raise NotImplementedError(self.print_file)

 

    @needs_write_lock

    @needs_write_lock

        graph = self.repository.get_graph()

        (last_revno, last_revid) = self.last_revision_info()

        known_revision_ids = [

            (last_revid, last_revno),

            (_mod_revision.NULL_REVISION, 0),

            ]

        if last_rev is not None:

            if not graph.is_ancestor(last_rev, revision_id):

                # our previous tip is not merged into stop_revision

                raise errors.DivergedBranches(self, other_branch)

        revno = graph.find_distance_to_null(revision_id, known_revision_ids)

        self.set_last_revision_info(revno, revision_id)

    @needs_write_lock

            if isinstance(url, unicode):

                    url = url.encode('ascii')

                    raise urlutils.InvalidURL(url,

                        "Urls must be 7-bit ascii, "

        self._set_parent_location(url)

    @needs_write_lock

            raise errors.UnstackableBranchFormat(self._format, self.user_url)

        # XXX: Changing from one fallback repository to another does not check

        # that all the data you need is present in the new fallback.

        # Possibly it should.

        self._check_stackable_repo()

        if not url:

            try:

                old_url = self.get_stacked_on_url()

            except (errors.NotStacked, errors.UnstackableBranchFormat,

                errors.UnstackableRepositoryFormat):

                return

            self._unstack()

        else:

            self._activate_fallback_location(url,

                possible_transports=[self.controldir.root_transport])

        # write this out after the repository is stacked to avoid setting a

        # stacked config that doesn't work.

        self._set_config_location('stacked_on_location', url)

        pb = ui.ui_factory.nested_progress_bar()

        try:

            # repository into a new repository object without the fallbacks. 

                raise AssertionError("can't cope with fallback repositories "

                    "of %r (fallbacks: %r)" % (old_repository,

                        old_repository._fallback_repositories))

                raise AssertionError("didn't expect %r to have "

                    "fallback_repositories"

            for i in range(old_lock_count-1):

            old_repository.lock_read()

            try:

                fetch_spec = vf_search.NotInOtherForRevs(self.repository,

                    old_repository, required_ids=[self.last_revision()],

            finally:

                old_repository.unlock()

        finally:

            pb.finished()

 

    def _set_tags_bytes(self, bytes):

        """Mirror method for _get_tags_bytes.

 

        :seealso: Branch._get_tags_bytes.

        """

        op = cleanup.OperationWithCleanups(self._set_tags_bytes_locked)

        op.add_cleanup(self.lock_write().unlock)

        return op.run_simple(bytes)

 

    def _set_tags_bytes_locked(self, bytes):

        self._tags_bytes = bytes

        return self._transport.put_bytes('tags', bytes)

        self._tags_bytes = None

    @needs_read_lock

        if self._last_revision_info_cache is None:

            self._last_revision_info_cache = self._read_last_revision_info()

        return self._last_revision_info_cache

    @needs_read_lock

        if revno == 0:

            return _mod_revision.NULL_REVISION

        last_revno, last_revid = self.last_revision_info()

        if revno == last_revno:

            return last_revid

        if revno <= 0 or revno > last_revno:

            raise errors.NoSuchRevision(self, revno)