/brz/remove-bazaar : contents of breezy/plugins/gitlab/hoster.py at revision 7526

: (revision 7526)

To get this branch, use:

bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

# Copyright (C) 2018 Breezy Developers
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

"""Support for GitLab."""

import json
import os
import re
import time

from ... import (
    bedding,
    branch as _mod_branch,
    controldir,
    errors,
    urlutils,
    )
from ...git.urls import git_url_to_bzr_url
from ...trace import mutter
from ...transport import get_transport

from ...propose import (
    determine_title,
    Hoster,
    MergeProposal,
    MergeProposalBuilder,
    MergeProposalExists,
    NoSuchProject,
    PrerequisiteBranchUnsupported,
    SourceNotDerivedFromTarget,
    UnsupportedHoster,
    )


_DEFAULT_FILES = ['/etc/python-gitlab.cfg', '~/.python-gitlab.cfg']
DEFAULT_PAGE_SIZE = 50


def mp_status_to_status(status):
    return {
        'all': 'all',
        'open': 'opened',
        'merged': 'merged',
        'closed': 'closed'}[status]


class NotGitLabUrl(errors.BzrError):

    _fmt = "Not a GitLab URL: %(url)s"

    def __init__(self, url):
        errors.BzrError.__init__(self)
        self.url = url


class NotMergeRequestUrl(errors.BzrError):

    _fmt = "Not a merge proposal URL: %(url)s"

    def __init__(self, host, url):
        errors.BzrError.__init__(self)
        self.host = host
        self.url = url


class GitLabUnprocessable(errors.BzrError):

    _fmt = "GitLab can not process request: %(error)s."

    def __init__(self, error):
        errors.BzrError.__init__(self, error=error)


class DifferentGitLabInstances(errors.BzrError):

    _fmt = ("Can't create merge proposals across GitLab instances: "
            "%(source_host)s and %(target_host)s")

    def __init__(self, source_host, target_host):
        self.source_host = source_host
        self.target_host = target_host


class GitLabLoginMissing(errors.BzrError):

    _fmt = ("Please log into GitLab")


class GitlabLoginError(errors.BzrError):

    _fmt = ("Error logging in: %(error)s")

    def __init__(self, error):
        self.error = error


class GitLabConflict(errors.BzrError):

    _fmt = "Conflict during operation: %(reason)s"

    def __init__(self, reason):
        errors.BzrError(self, reason=reason)


class ForkingDisabled(errors.BzrError):

    _fmt = ("Forking on project %(project)s is disabled.")

    def __init__(self, project):
        self.project = project


class MergeRequestConflict(Exception):
    """Raised when a merge requests conflicts."""

    def __init__(self, reason):
        self.reason = reason


class ProjectCreationTimeout(errors.BzrError):

    _fmt = ("Timeout (%(timeout)ds) while waiting for project "
            "%(project)s to be created.")

    def __init__(self, project, timeout):
        self.project = project
        self.timeout = timeout


def default_config_path():
    return os.path.join(bedding.config_dir(), 'gitlab.conf')


def store_gitlab_token(name, url, private_token):
    """Store a GitLab token in a configuration file."""
    import configparser
    config = configparser.ConfigParser()
    path = default_config_path()
    config.read([path])
    config.add_section(name)
    config[name]['url'] = url
    config[name]['private_token'] = private_token
    with open(path, 'w') as f:
        config.write(f)


def iter_tokens():
    import configparser
    config = configparser.ConfigParser()
    config.read(
        [os.path.expanduser(p) for p in _DEFAULT_FILES] +
        [default_config_path()])
    for name, section in config.items():
        yield name, section


def get_credentials_by_url(url):
    for name, credentials in iter_tokens():
        if 'url' not in credentials:
            continue
        if credentials['url'].rstrip('/') == url.rstrip('/'):
            return credentials
    else:
        return None


def parse_gitlab_url(url):
    (scheme, user, password, host, port, path) = urlutils.parse_url(
        url)
    if scheme not in ('git+ssh', 'https', 'http'):
        raise NotGitLabUrl(url)
    if not host:
        raise NotGitLabUrl(url)
    path = path.strip('/')
    if path.endswith('.git'):
        path = path[:-4]
    return host, path


def parse_gitlab_branch_url(branch):
    url = urlutils.strip_segment_parameters(branch.user_url)
    host, path = parse_gitlab_url(url)
    return host, path, branch.name


def parse_gitlab_merge_request_url(url):
    (scheme, user, password, host, port, path) = urlutils.parse_url(
        url)
    if scheme not in ('git+ssh', 'https', 'http'):
        raise NotGitLabUrl(url)
    if not host:
        raise NotGitLabUrl(url)
    path = path.strip('/')
    parts = path.split('/')
    if len(parts) < 2:
        raise NotMergeRequestUrl(host, url)
    if parts[-2] != 'merge_requests':
        raise NotMergeRequestUrl(host, url)
    if parts[-3] == '-':
        project_name = '/'.join(parts[:-3])
    else:
        project_name = '/'.join(parts[:-2])
    return host, project_name, int(parts[-1])


def _unexpected_status(path, response):
    raise errors.UnexpectedHttpStatus(
        path, response.status, response.data.decode('utf-8', 'replace'))


class GitLabMergeProposal(MergeProposal):

    def __init__(self, gl, mr):
        self.gl = gl
        self._mr = mr

    def _update(self, **kwargs):
        self.gl._update_merge_request(self._mr['project_id'], self._mr['iid'], kwargs)

    def __repr__(self):
        return "<%s at %r>" % (type(self).__name__, self._mr['web_url'])

    @property
    def url(self):
        return self._mr['web_url']

    def get_description(self):
        return self._mr['description']

    def set_description(self, description):
        self._update(description=description, title=determine_title(description))

    def get_commit_message(self):
        return self._mr.get('merge_commit_message')

    def set_commit_message(self, message):
        raise errors.UnsupportedOperation(self.set_commit_message, self)

    def _branch_url_from_project(self, project_id, branch_name):
        if project_id is None:
            return None
        project = self.gl._get_project(project_id)
        return gitlab_url_to_bzr_url(project['http_url_to_repo'], branch_name)

    def get_source_branch_url(self):
        return self._branch_url_from_project(
            self._mr['source_project_id'], self._mr['source_branch'])

    def get_source_revision(self):
        from breezy.git.mapping import default_mapping
        sha = self._mr['sha']
        if sha is None:
            return None
        return default_mapping.revision_id_foreign_to_bzr(sha.encode('ascii'))

    def get_target_branch_url(self):
        return self._branch_url_from_project(
            self._mr['target_project_id'], self._mr['target_branch'])

    def _get_project_name(self, project_id):
        source_project = self.gl._get_project(project_id)
        return source_project['path_with_namespace']

    def get_source_project(self):
        return self._get_project_name(self._mr['source_project_id'])

    def get_target_project(self):
        return self._get_project_name(self._mr['target_project_id'])

    def is_merged(self):
        return (self._mr['state'] == 'merged')

    def is_closed(self):
        return (self._mr['state'] == 'closed')

    def reopen(self):
        return self._update(state_event='reopen')

    def close(self):
        self._update(state_event='close')

    def merge(self, commit_message=None):
        # https://docs.gitlab.com/ee/api/merge_requests.html#accept-mr
        self._mr.merge(merge_commit_message=commit_message)

    def can_be_merged(self):
        if self._mr['merge_status'] == 'cannot_be_merged':
            return False
        elif self._mr['merge_status'] == 'can_be_merged':
            return True
        elif self._mr['merge_status'] in (
                'unchecked', 'cannot_be_merged_recheck'):
            # See https://gitlab.com/gitlab-org/gitlab/-/commit/7517105303c for
            # an explanation of the distinction between unchecked and
            # cannot_be_merged_recheck
            return None
        else:
            raise ValueError(self._mr['merge_status'])

    def get_merged_by(self):
        user = self._mr.get('merged_by')
        if user is None:
            return None
        return user['username']

    def get_merged_at(self):
        merged_at = self._mr.get('merged_at')
        if merged_at is None:
            return None
        import iso8601
        return iso8601.parse_date(merged_at)

    def post_comment(self, body):
        kwargs = {'body': body}
        self.gl._post_merge_request_note(
            self._mr['project_id'], self._mr['iid'], kwargs)


def gitlab_url_to_bzr_url(url, name):
    return git_url_to_bzr_url(url, branch=name)


class GitLab(Hoster):
    """GitLab hoster implementation."""

    supports_merge_proposal_labels = True
    supports_merge_proposal_commit_message = False
    supports_allow_collaboration = True
    merge_proposal_description_format = 'markdown'

    def __repr__(self):
        return "<GitLab(%r)>" % self.base_url

    @property
    def base_url(self):
        return self.transport.base

    @property
    def base_hostname(self):
        return urlutils.parse_url(self.base_url)[3]

    def _find_correct_project_name(self, path):
        try:
            resp = self.transport.request(
                'GET', urlutils.join(self.base_url, path),
                headers=self.headers)
        except errors.RedirectRequested as e:
            return urlutils.parse_url(e.target)[-1].strip('/')
        if resp.status != 200:
            _unexpected_status(path, resp)
        return None

    def _api_request(self, method, path, fields=None, body=None):
        return self.transport.request(
            method, urlutils.join(self.base_url, 'api', 'v4', path),
            headers=self.headers, fields=fields, body=body)

    def __init__(self, transport, private_token):
        self.transport = transport
        self.headers = {"Private-Token": private_token}
        self.check()

    def _get_user(self, username):
        path = 'users/%s' % urlutils.quote(str(username), '')
        response = self._api_request('GET', path)
        if response.status == 404:
            raise KeyError('no such user %s' % username)
        if response.status == 200:
            return json.loads(response.data)
        _unexpected_status(path, response)

    def _get_user_by_email(self, email):
        path = 'users?search=%s' % urlutils.quote(str(email), '')
        response = self._api_request('GET', path)
        if response.status == 404:
            raise KeyError('no such user %s' % email)
        if response.status == 200:
            ret = json.loads(response.data)
            if len(ret) != 1:
                raise ValueError('unexpected number of results; %r' % ret)
            return ret[0]
        _unexpected_status(path, response)

    def _get_project(self, project_name, _redirect_checked=False):
        path = 'projects/%s' % urlutils.quote(str(project_name), '')
        response = self._api_request('GET', path)
        if response.status == 404:
            if not _redirect_checked:
                project_name = self._find_correct_project_name(project_name)
                if project_name is not None:
                    return self._get_project(project_name, _redirect_checked=True)
            raise NoSuchProject(project_name)
        if response.status == 200:
            return json.loads(response.data)
        _unexpected_status(path, response)

    def _fork_project(self, project_name, timeout=50, interval=5, owner=None):
        path = 'projects/%s/fork' % urlutils.quote(str(project_name), '')
        fields = {}
        if owner is not None:
            fields['namespace'] = owner
        response = self._api_request('POST', path, fields=fields)
        if response.status == 404:
            raise ForkingDisabled(project_name)
        if response.status == 409:
            resp = json.loads(response.data)
            raise GitLabConflict(resp.get('message'))
        if response.status not in (200, 201):
            _unexpected_status(path, response)
        # The response should be valid JSON, but let's ignore it
        project = json.loads(response.data)
        # Spin and wait until import_status for new project
        # is complete.
        deadline = time.time() + timeout
        while project['import_status'] not in ('finished', 'none'):
            mutter('import status is %s', project['import_status'])
            if time.time() > deadline:
                raise ProjectCreationTimeout(
                    project['path_with_namespace'], timeout)
            time.sleep(interval)
            project = self._get_project(project['path_with_namespace'])
        return project

    def get_current_user(self):
        return self._current_user['username']

    def get_user_url(self, username):
        return urlutils.join(self.base_url, username)

    def _list_paged(self, path, parameters=None, per_page=None):
        if parameters is None:
            parameters = {}
        else:
            parameters = dict(parameters.items())
        if per_page:
            parameters['per_page'] = str(per_page)
        page = "1"
        while page:
            parameters['page'] = page
            response = self._api_request(
                'GET', path + '?' +
                ';'.join(['%s=%s' % item for item in parameters.items()]))
            if response.status == 403:
                raise errors.PermissionDenied(response.text)
            if response.status != 200:
                _unexpected_status(path, response)
            page = response.getheader("X-Next-Page")
            for entry in json.loads(response.data):
                yield entry

    def _list_merge_requests(self, author=None, project=None, state=None):
        if project is not None:
            path = 'projects/%s/merge_requests' % urlutils.quote(str(project), '')
        else:
            path = 'merge_requests'
        parameters = {}
        if state:
            parameters['state'] = state
        if author:
            parameters['author_username'] = urlutils.quote(author, '')
        return self._list_paged(path, parameters, per_page=DEFAULT_PAGE_SIZE)

    def _get_merge_request(self, project, merge_id):
        path = 'projects/%s/merge_requests/%d' % (urlutils.quote(str(project), ''), merge_id)
        response = self._api_request('GET', path)
        if response.status == 403:
            raise errors.PermissionDenied(response.text)
        if response.status != 200:
            _unexpected_status(path, response)
        return json.loads(response.data)

    def _list_projects(self, owner):
        path = 'users/%s/projects' % urlutils.quote(str(owner), '')
        parameters = {}
        return self._list_paged(path, parameters, per_page=DEFAULT_PAGE_SIZE)

    def _update_merge_request(self, project_id, iid, mr):
        path = 'projects/%s/merge_requests/%s' % (
            urlutils.quote(str(project_id), ''), iid)
        response = self._api_request('PUT', path, fields=mr)
        if response.status == 200:
            return json.loads(response.data)
        if response.status == 403:
            raise errors.PermissionDenied(response.text)
        _unexpected_status(path, response)

    def _post_merge_request_note(self, project_id, iid, kwargs):
        path = 'projects/%s/merge_requests/%s/notes' % (
            urlutils.quote(str(project_id), ''), iid)
        response = self._api_request('POST', path, fields=kwargs)
        if response.status == 201:
            json.loads(response.data)
            return
        if response.status == 403:
            raise errors.PermissionDenied(response.text)
        _unexpected_status(path, response)

    def _create_mergerequest(
            self, title, source_project_id, target_project_id,
            source_branch_name, target_branch_name, description,
            labels=None, allow_collaboration=False):
        path = 'projects/%s/merge_requests' % source_project_id
        fields = {
            'title': title,
            'source_branch': source_branch_name,
            'target_branch': target_branch_name,
            'target_project_id': target_project_id,
            'description': description,
            'allow_collaboration': allow_collaboration,
            }
        if labels:
            fields['labels'] = labels
        response = self._api_request('POST', path, fields=fields)
        if response.status == 403:
            raise errors.PermissionDenied(response.text)
        if response.status == 409:
            raise MergeRequestConflict(json.loads(response.data))
        if response.status == 422:
            data = json.loads(response.data)
            raise GitLabUnprocessable(data['error'])
        if response.status != 201:
            _unexpected_status(path, response)
        return json.loads(response.data)

    def get_push_url(self, branch):
        (host, project_name, branch_name) = parse_gitlab_branch_url(branch)
        project = self._get_project(project_name)
        return gitlab_url_to_bzr_url(
            project['ssh_url_to_repo'], branch_name)

    def publish_derived(self, local_branch, base_branch, name, project=None,
                        owner=None, revision_id=None, overwrite=False,
                        allow_lossy=True, tag_selector=None):
        (host, base_project_name, base_branch_name) = parse_gitlab_branch_url(base_branch)
        if owner is None:
            owner = base_branch.get_config_stack().get('fork-namespace')
        if owner is None:
            owner = self.get_current_user()
        base_project = self._get_project(base_project_name)
        if project is None:
            project = base_project['path']
        try:
            target_project = self._get_project('%s/%s' % (owner, project))
        except NoSuchProject:
            target_project = self._fork_project(
                base_project['path_with_namespace'], owner=owner)
        remote_repo_url = git_url_to_bzr_url(target_project['ssh_url_to_repo'])
        remote_dir = controldir.ControlDir.open(remote_repo_url)
        try:
            push_result = remote_dir.push_branch(
                local_branch, revision_id=revision_id, overwrite=overwrite,
                name=name, tag_selector=tag_selector)
        except errors.NoRoundtrippingSupport:
            if not allow_lossy:
                raise
            push_result = remote_dir.push_branch(
                local_branch, revision_id=revision_id, overwrite=overwrite,
                name=name, lossy=True, tag_selector=tag_selector)
        public_url = gitlab_url_to_bzr_url(
            target_project['http_url_to_repo'], name)
        return push_result.target_branch, public_url

    def get_derived_branch(self, base_branch, name, project=None, owner=None):
        (host, base_project, base_branch_name) = parse_gitlab_branch_url(base_branch)
        if owner is None:
            owner = self.get_current_user()
        if project is None:
            project = self._get_project(base_project)['path']
        try:
            target_project = self._get_project('%s/%s' % (owner, project))
        except NoSuchProject:
            raise errors.NotBranchError('%s/%s/%s' % (self.base_url, owner, project))
        return _mod_branch.Branch.open(gitlab_url_to_bzr_url(
            target_project['ssh_url_to_repo'], name))

    def get_proposer(self, source_branch, target_branch):
        return GitlabMergeProposalBuilder(self, source_branch, target_branch)

    def iter_proposals(self, source_branch, target_branch, status):
        (source_host, source_project_name, source_branch_name) = (
            parse_gitlab_branch_url(source_branch))
        (target_host, target_project_name, target_branch_name) = (
            parse_gitlab_branch_url(target_branch))
        if source_host != target_host:
            raise DifferentGitLabInstances(source_host, target_host)
        source_project = self._get_project(source_project_name)
        target_project = self._get_project(target_project_name)
        state = mp_status_to_status(status)
        for mr in self._list_merge_requests(
                project=target_project['id'], state=state):
            if (mr['source_project_id'] != source_project['id'] or
                    mr['source_branch'] != source_branch_name or
                    mr['target_project_id'] != target_project['id'] or
                    mr['target_branch'] != target_branch_name):
                continue
            yield GitLabMergeProposal(self, mr)

    def hosts(self, branch):
        try:
            (host, project, branch_name) = parse_gitlab_branch_url(branch)
        except NotGitLabUrl:
            return False
        return self.base_hostname == host

    def check(self):
        response = self._api_request('GET', 'user')
        if response.status == 200:
            self._current_user = json.loads(response.data)
            return
        if response == 401:
            if json.loads(response.data) == {"message": "401 Unauthorized"}:
                raise GitLabLoginMissing()
            else:
                raise GitlabLoginError(response.text)
        raise UnsupportedHoster(self.base_url)

    @classmethod
    def probe_from_url(cls, url, possible_transports=None):
        try:
            (host, project) = parse_gitlab_url(url)
        except NotGitLabUrl:
            raise UnsupportedHoster(url)
        transport = get_transport(
            'https://%s' % host, possible_transports=possible_transports)
        credentials = get_credentials_by_url(transport.base)
        if credentials is not None:
            return cls(transport, credentials.get('private_token'))
        raise UnsupportedHoster(url)

    @classmethod
    def iter_instances(cls):
        for name, credentials in iter_tokens():
            if 'url' not in credentials:
                continue
            yield cls(
                get_transport(credentials['url']),
                private_token=credentials.get('private_token'))

    def iter_my_proposals(self, status='open', author=None):
        if author is None:
            author = self.get_current_user()
        state = mp_status_to_status(status)
        for mp in self._list_merge_requests(author=author, state=state):
            yield GitLabMergeProposal(self, mp)

    def iter_my_forks(self, owner=None):
        if owner is not None:
            owner = self.get_current_user()
        for project in self._list_projects(owner=owner):
            base_project = project.get('forked_from_project')
            if not base_project:
                continue
            yield project['path_with_namespace']

    def get_proposal_by_url(self, url):
        try:
            (host, project, merge_id) = parse_gitlab_merge_request_url(url)
        except NotGitLabUrl:
            raise UnsupportedHoster(url)
        except NotMergeRequestUrl as e:
            if self.base_hostname == e.host:
                raise
            else:
                raise UnsupportedHoster(url)
        if self.base_hostname != host:
            raise UnsupportedHoster(url)
        project = self._get_project(project)
        mr = self._get_merge_request(project['path_with_namespace'], merge_id)
        return GitLabMergeProposal(self, mr)

    def delete_project(self, project):
        path = 'projects/%s' % urlutils.quote(str(project), '')
        response = self._api_request('DELETE', path)
        if response.status == 404:
            raise NoSuchProject(project)
        if response.status != 202:
            _unexpected_status(path, response)


class GitlabMergeProposalBuilder(MergeProposalBuilder):

    def __init__(self, gl, source_branch, target_branch):
        self.gl = gl
        self.source_branch = source_branch
        (self.source_host, self.source_project_name, self.source_branch_name) = (
            parse_gitlab_branch_url(source_branch))
        self.target_branch = target_branch
        (self.target_host, self.target_project_name, self.target_branch_name) = (
            parse_gitlab_branch_url(target_branch))
        if self.source_host != self.target_host:
            raise DifferentGitLabInstances(self.source_host, self.target_host)

    def get_infotext(self):
        """Determine the initial comment for the merge proposal."""
        info = []
        info.append("Gitlab instance: %s\n" % self.target_host)
        info.append("Source: %s\n" % self.source_branch.user_url)
        info.append("Target: %s\n" % self.target_branch.user_url)
        return ''.join(info)

    def get_initial_body(self):
        """Get a body for the proposal for the user to modify.

        :return: a str or None.
        """
        return None

    def create_proposal(self, description, reviewers=None, labels=None,
                        prerequisite_branch=None, commit_message=None,
                        work_in_progress=False, allow_collaboration=False):
        """Perform the submission."""
        # https://docs.gitlab.com/ee/api/merge_requests.html#create-mr
        if prerequisite_branch is not None:
            raise PrerequisiteBranchUnsupported(self)
        # Note that commit_message is ignored, since Gitlab doesn't support it.
        source_project = self.gl._get_project(self.source_project_name)
        target_project = self.gl._get_project(self.target_project_name)
        # TODO(jelmer): Allow setting title explicitly
        title = determine_title(description)
        if work_in_progress:
            title = 'WIP: %s' % title
        # TODO(jelmer): Allow setting milestone field
        # TODO(jelmer): Allow setting squash field
        kwargs = {
            'title': title,
            'source_project_id': source_project['id'],
            'target_project_id': target_project['id'],
            'source_branch_name': self.source_branch_name,
            'target_branch_name': self.target_branch_name,
            'description': description,
            'allow_collaboration': allow_collaboration}
        if labels:
            kwargs['labels'] = ','.join(labels)
        if reviewers:
            kwargs['assignee_ids'] = []
            for reviewer in reviewers:
                if '@' in reviewer:
                    user = self.gl._get_user_by_email(reviewer)
                else:
                    user = self.gl._get_user(reviewer)
                kwargs['assignee_ids'].append(user['id'])
        try:
            merge_request = self.gl._create_mergerequest(**kwargs)
        except MergeRequestConflict as e:
            m = re.fullmatch(
                r'Another open merge request already exists for '
                r'this source branch: \!([0-9]+)',
                e.reason['message'][0])
            if m:
                merge_id = int(m.group(1))
                mr = self.gl._get_merge_request(
                    target_project['path_with_namespace'], merge_id)
                raise MergeProposalExists(
                    self.source_branch.user_url, GitLabMergeProposal(self.gl, mr))
            raise Exception('conflict: %r' % e.reason)
        except GitLabUnprocessable as e:
            if e.error == [
                    "Source project is not a fork of the target project"]:
                raise SourceNotDerivedFromTarget(
                    self.source_branch, self.target_branch)
        return GitLabMergeProposal(self.gl, merge_request)


def register_gitlab_instance(shortname, url):
    """Register a gitlab instance.

    :param shortname: Short name (e.g. "gitlab")
    :param url: URL to the gitlab instance
    """
    from breezy.bugtracker import (
        tracker_registry,
        ProjectIntegerBugTracker,
        )
    tracker_registry.register(
        shortname, ProjectIntegerBugTracker(
            shortname, url + '/{project}/issues/{id}'))

0.431.5 by Jelmer Vernooĳ Initial work on gitlab support.	1	# Copyright (C) 2018 Breezy Developers
	2	#
	3	# This program is free software; you can redistribute it and/or modify
	4	# it under the terms of the GNU General Public License as published by
	5	# the Free Software Foundation; either version 2 of the License, or
	6	# (at your option) any later version.
	7	#
	8	# This program is distributed in the hope that it will be useful,
	9	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	# GNU General Public License for more details.
	12	#
	13	# You should have received a copy of the GNU General Public License
	14	# along with this program; if not, write to the Free Software
	15	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	16
0.434.1 by Jelmer Vernooĳ Use absolute_import.	17	"""Support for GitLab."""
0.434.1 by Jelmer Vernooĳ Use absolute_import.	18
7296.10.8 by Jelmer Vernooĳ Remove json attribute from Response object, consistent with urllib3 API.	19	import json
7296.10.1 by Jelmer Vernooĳ Initial work making gitlab just directly use ReST.	20	import os
7490.144.1 by Jelmer Vernooĳ Support providing the actual proposal to MergeProposalExists.	21	import re
7380.1.1 by Jelmer Vernooĳ Several more fixes for git merge proposals.	22	import time
7296.10.1 by Jelmer Vernooĳ Initial work making gitlab just directly use ReST.	23
0.431.6 by Jelmer Vernooĳ Initial gitlab support works.	24	from ... import (
7340.1.1 by Martin Fix use of config_dir in propose plugin	25	bedding,
0.431.33 by Jelmer Vernooĳ Fix URLs from gitlab.	26	branch as _mod_branch,
0.432.5 by Jelmer Vernooĳ Fix publishing to gitlab.	27	controldir,
0.431.6 by Jelmer Vernooĳ Initial gitlab support works.	28	errors,
	29	urlutils,
	30	)
0.432.5 by Jelmer Vernooĳ Fix publishing to gitlab.	31	from ...git.urls import git_url_to_bzr_url
7380.1.2 by Jelmer Vernooĳ Review comments.	32	from ...trace import mutter
7296.10.1 by Jelmer Vernooĳ Initial work making gitlab just directly use ReST.	33	from ...transport import get_transport
0.431.6 by Jelmer Vernooĳ Initial gitlab support works.	34
7408.3.1 by Jelmer Vernooĳ Move propose module into core.	35	from ...propose import (
7445.1.1 by Jelmer Vernooĳ Add Hoster.merge_proposal_description_format and common function for determining title.	36	determine_title,
0.432.2 by Jelmer Vernooĳ Publish command sort of works.	37	Hoster,
0.431.5 by Jelmer Vernooĳ Initial work on gitlab support.	38	MergeProposal,
0.432.2 by Jelmer Vernooĳ Publish command sort of works.	39	MergeProposalBuilder,
0.431.5 by Jelmer Vernooĳ Initial work on gitlab support.	40	MergeProposalExists,