/brz/remove-bazaar

see breezy.bzrdir.BzrDir.

from .lazy_import import lazy_import

from breezy import (

    branch as _mod_branch,

from breezy.transport import local

from breezy.push import (

from breezy.i18n import gettext

from . import (

    errors,

    registry,

    )

 

 

class MustHaveWorkingTree(errors.BzrError):

 

    _fmt = "Branching '%(url)s'(%(format)s) must create a working tree."

 

    def __init__(self, format, url):

        errors.BzrError.__init__(self, format=format, url=url)

 

 

class BranchReferenceLoop(errors.BzrError):

 

    _fmt = "Can not create branch reference that points at branch itself."

 

    def __init__(self, branch):

        errors.BzrError.__init__(self, branch=branch)

        return list(self.get_branches().values())

 

            return {"": self.open_branch()}

            return {}

        return self._format.is_control_filename(filename)

        :param name: Name of the branch to destroy, None for the

                           accelerator_tree=None, hardlink=False):

        :param from_branch: override controldir branch

               source_branch=None, create_tree_if_local=True,

               lossy=False):

    def push_branch(self, source, revision_id=None, overwrite=False,

                    remember=False, create_prefix=False, lossy=False):

            br_to = source.sprout(self, revision_id=revision_id, lossy=lossy)

                push_result.branch_push_result = source.push(

                    br_to, overwrite, stop_revision=revision_id, lossy=lossy)

                push_result.branch_push_result = source.push(

                    br_to, overwrite, stop_revision=revision_id, lossy=lossy)

                push_result.workingtree_updated = None  # Not applicable

                with tree_to.lock_write():

                        tree_to.branch, overwrite, stop_revision=revision_id,

                        lossy=lossy)

                           force_new_repo=False, preserve_stacking=False, stacked_on=None,

                           create_prefix=False, use_existing_dir=True, no_tree=False):

    def find_controldirs(klass, transport, evaluate=None, list_current=None):

            except (errors.NotBranchError, errors.PermissionDenied,

                    errors.UnknownFormatError):

        for branches, repo in klass.find_controldirs(

                                                  force_new_repo=True,

                                                  format=format).controldir

                                         _unsupported=_unsupported)

 

                                                           probers=probers)

                transport.base, e.permanently, redirected_transport.base))

            except errors.NotBranchError:

            except urlutils.InvalidURLJoin:

                                       possible_transports=None):

                                                    possible_transports=possible_transports)

                                 "default format, not one of %r" % klass)

        hooks.Hooks.__init__(self, "breezy.controldir", "ControlDir.hooks")

                      "Invoked before attempting to open a ControlDir with the transport "

                      "that the open will use.", (1, 14))

                      "Invoked after a repository has been initialized. "

                      "post_repo_init is called with a "

                      "breezy.controldir.RepoInitHookParams.",

                      (2, 2))

 

                             basedir=None):

        """Return getters for extra formats, not usable in meta directories."""

        return [getter.get_obj for getter in self._extra_formats]

 

    def _get_all_lazy(self):

        """Return getters for all formats, even those not usable in metadirs."""

        result = [self._dict[name].get_obj for name in self.keys()]

        result.extend(self._get_extra())

        """Return all formats, even those not usable in metadirs."""

        for getter in self._get_all_lazy():

            fmt = getter()

        return result

        self.count += 1

        This returns a breezy.controldir.Converter object.

                             basedir=None):

                target_format.rich_root_data)

        return klass._probers

        result = []

            result.extend(prober_kls.known_formats())

            probers = sorted(

                klass.all_probers(),

                key=lambda prober: prober.priority(transport))

                                   create_prefix=False, force_new_repo=False, stacked_on=None,

                                   stack_on_pwd=None, repo_format_name=None, make_working_trees=None,

                                   shared_repo=False, vfs_only=False):

    @classmethod

    def is_control_filename(klass, filename):

        """True if filename is the name of a path which is reserved for

        controldirs.

 

        :param filename: A filename within the root transport of this

            controldir.

 

        This is true IF and ONLY IF the filename is part of the namespace reserved

        for bzr control dirs. Currently this is the '.bzr' directory in the root

        of the root_transport. it is expected that plugins will need to extend

        this in the future - for instance to make bzr talk with svn working

        trees.

        """

        raise NotImplementedError(self.is_control_filename)

 

    See BzrProber and RemoteBzrProber in breezy.bzrdir for the

    Probers should be registered using the register_prober methods on

    ControlDirFormat.

    @classmethod

    def priority(klass, transport):

        """Priority of this prober.

 

        A lower value means the prober gets checked first.

 

        Other conventions:

 

        -10: This is a "server" prober

        0: No priority set

        10: This is a regular file-based prober

        100: This is a prober for an unsupported format

        """

        return 0

 

                 hidden=False, experimental=False):

                                   ControlDirFormatInfo(native, deprecated, hidden, experimental))

    def register_alias(self, key, target, hidden=False):

        """Register a format alias.

 

        :param key: Alias name

        :param target: Target format

        :param hidden: Whether the alias is hidden

        """

        info = self.get_info(target)

        registry.Registry.register_alias(self, key, target,

                                         ControlDirFormatInfo(

                                             native=info.native, deprecated=info.deprecated,

                                             hidden=hidden, experimental=info.experimental))

 

                      deprecated=False, hidden=False, experimental=False):

                                        help, ControlDirFormatInfo(native, deprecated, hidden, experimental))

        self.register_alias('default', key)

    def make_controldir(self, key):

                                     textwrap.fill(help, initial_indent='    ',

                                                   subsequent_indent='    ',

                                                   break_long_words=False))

            "\nSee :doc:`formats-help` for more about storage formats."

        self.controldir = controldir