🔀 Switched to python-bitbucket from defunct bitbucket-api lib

* 🚧 switch implementation
* 🚧 updated tests
* 📼 updated cassettes
* ⚠️ missing Fork implementation

Signed-off-by: Guyzmo <guyzmo+github@m0g.net>

Author: guyzmo

git_repo/repo.py

@@ -134,7 +134,7 @@
     print('Please use with python version 3')
     sys.exit(1)
 
-from .exceptions import ArgumentError
+from .exceptions import ArgumentError, ResourceNotFoundError
 from .services.service import RepositoryService
 
 from .kwargparse import KeywordArgumentParser, store_parameter, register_action

git_repo/services/ext/bitbucket.py

@@ -6,144 +6,90 @@
 from ..service import register_target, RepositoryService
 from ...exceptions import ResourceError, ResourceExistsError, ResourceNotFoundError
 
-import bitbucket.bitbucket as bitbucket
-from requests import Request, Session
-import json
+from pybitbucket.bitbucket import Client
+from pybitbucket.auth import BasicAuthenticator
+from pybitbucket.user import User
+from pybitbucket.repository import Repository, RepositoryPayload, RepositoryForkPolicy
+try:
+    from pybitbucket.repository import RepositoryForkPayload
+except ImportError:
+    RepositoryForkPayload = None
 
-'''
-Extension of the bitbucket module implementation to add support for the extra
-features the original implementation lacked. This is a temporary measure, up
-until a PR is crafted for the original code.
-'''
-
-bitbucket.URLS.update({
-    'GET_REPO' : 'repositories/%(username)s/%(repo_slug)s/',
-    'DELETE_REPO' : 'repositories/%(accountname)s/%(repo_slug)s',
-    'FORK_REPO' : 'repositories/%(username)s/%(repo_slug)s/fork',
-})
-
-class Bitbucket(bitbucket.Bitbucket):
-    def __init__(self, *args, **kwarg):
-        super(Bitbucket, self).__init__(self)
-        self.session = Session()
-        # XXX monkey patching of requests within bitbucket module
-        self.requests = self.session
-
-    def get(self, user=None, repo_slug=None):
-        """ Get a single repository on Bitbucket and return it."""
-        username = user or self.username
-        repo_slug = repo_slug or self.repo_slug or ''
-        url = self.url('GET_REPO', username=username, repo_slug=repo_slug)
-        return self.dispatch('GET', url, auth=self.auth)
-
-    def delete(self, user, repo_slug):
-        url = self.url('DELETE_REPO', username=user, accountname=user, repo_slug=repo_slug)
-        return self.dispatch('DELETE', url, auth=self.auth)
-
-    def fork(self, user, repo_slug, new_name=None):
-        url = self.url('FORK_REPO', username=user, repo_slug=repo_slug)
-        new_repo = new_name or repo_slug
-        return self.dispatch('POST', url, name=new_repo, auth=self.auth)
-
-    def dispatch(self, method, url, auth=None, params=None, **kwargs):
-        """ Send HTTP request, with given method,
-            credentials and data to the given URL,
-            and return the success and the result on success.
-        """
-        r = Request(
-            method=method,
-            url=url,
-            auth=auth,
-            params=params,
-            data=kwargs)
-        resp = self.session.send(r.prepare())
-        status = resp.status_code
-        text = resp.text
-        error = resp.reason
-        if status >= 200 and status < 300:
-            if text:
-                try:
-                    return (True, json.loads(text))
-                except TypeError:
-                    pass
-                except ValueError:
-                    pass
-            return (True, text)
-        elif status >= 300 and status < 400:
-            return (
-                False,
-                'Unauthorized access, '
-                'please check your credentials.')
-        elif status == 404:
-            return (False, dict(message='Service not found', reason=error, code=status))
-        elif status == 400:
-            return (False, dict(message='Bad request sent to server.', reason=error, code=status))
-        elif status == 401:
-            return (False, dict(message='Not enough privileges.', reason=error, code=status))
-        elif status == 403:
-            return (False, dict(message='Not authorized.', reason=error, code=status))
-        elif status == 402 or status >= 405:
-            return (False, dict(message='Request error.', reason=error, code=status))
-        elif status >= 500 and status < 600:
-                return (False, dict(message='Server error.', reason=error, code=status))
-        else:
-            return (False, dict(message='Unidentified error.', reason=error, code=status))
 
+from requests import Request, Session
+from requests.exceptions import HTTPError
+import json
 
 @register_target('bb', 'bitbucket')
 class BitbucketService(RepositoryService):
     fqdn = 'bitbucket.org'
 
     def __init__(self, *args, **kwarg):
-        self.bb = Bitbucket()
+        self.bb = Client()
         super(BitbucketService, self).__init__(*args, **kwarg)
 
     def connect(self):
         if not self._privatekey:
             raise ConnectionError('Could not connect to BitBucket. Please configure .gitconfig with your bitbucket credentials.')
         if not ':' in self._privatekey:
             raise ConnectionError('Could not connect to BitBucket. Please setup your private key with login:password')
-        self.bb.username, self.bb.password = self._privatekey.split(':')
-        self.username = self.bb.username
-        result, _ = self.bb.get_user()
-        if not result:
-            raise ConnectionError('Could not connect to BitBucket. Not authorized, wrong credentials.')
+        self.bb.config = BasicAuthenticator(*self._privatekey.split(':')+['z+git-repo+pub@m0g.net'])
+        self.bb.session = self.bb.config.session
+        try:
+            User.find_current_user(client=self.bb)
+        except HTTPError as err:
+            raise ConnectionError('Could not connect to BitBucket. Not authorized, wrong credentials.') from err
 
     def create(self, user, repo, add=False):
-        success, result = self.bb.repository.create(repo, scm='git', public=True)
-        if not success and result['code'] == 400:
-            raise ResourceExistsError('Project {} already exists on this account.'.format(repo))
-        elif not success:
-            raise ResourceError("Couldn't complete creation: {message} (error #{code}: {reason})".format(**result))
-        if add:
-            self.add(user=user, repo=repo, tracking=self.name)
+        try:
+            repo = Repository.create(
+                    payload=RepositoryPayload(dict(
+                        fork_policy=RepositoryForkPolicy.ALLOW_FORKS,
+                        is_private=False)),
+                    repository_name=repo,
+                    owner=user,
+                    client=self.bb
+            )
+            if add:
+                self.add(user=user, repo=repo, tracking=self.name)
+        except HTTPError as err:
+            if err.response.status_code == 400:
+                raise ResourceExistsError('Project {} already exists on this account.'.format(repo)) from err
+            raise ResourceError("Couldn't complete creation: {}".format(err)) from err
 
     def fork(self, user, repo):
-        success, result = self.bb.fork(user, repo)
-        if not success:
-            raise ResourceError("Couldn't complete fork: {message} (error #{code}: {reason})".format(**result))
-        return '/'.join([result['owner'], result['slug']])
+        if not RepositoryForkPayload:
+            raise NotImplementedError('Feature not yet supported by the underlying library.')
+        try:
+            result = Repository.find_repository_by_name_and_owner(repo, owner=user, client=self.bb).fork(
+                    payload=RepositoryForkPayload(dict(
+                        name=repo,
+                        fork_policy=RepositoryForkPolicy.ALLOW_FORKS,
+                        is_private=False
+                    )),
+                    repository_name=repo,
+                    owner=user,
+                    client=self.bb
+            )
+        except HTTPError as err:
+            raise ResourceError("Couldn't complete creation: {}".format(err)) from err
+        return '/'.join([result.owner, result.slug])
 
     def delete(self, repo, user=None):
         if not user:
             user = self.user
-        success, result = self.bb.delete(user, repo)
-        if not success and result['code'] == 404:
-            raise ResourceNotFoundError("Cannot delete: repository {}/{} does not exists.".format(user, repo))
-        elif not success:
-            raise ResourceError("Couldn't complete deletion: {message} (error #{code}: {reason})".format(**result))
+        try:
+            Repository.find_repository_by_name_and_owner(repo, owner=user, client=self.bb).delete()
+        except HTTPError as err:
+            if err.response.status_code == 404:
+                raise ResourceNotFoundError("Cannot delete: repository {}/{} does not exists.".format(user, repo)) from err
+            raise ResourceError("Couldn't complete creation: {}".format(err)) from err
 
     def get_repository(self, user, repo):
-        if user != self.user:
-            result, repo_list = self.bb.repository.public(user)
-        else:
-            result, repo_list = self.bb.repository.all()
-        if not result:
-            raise ResourceError("Couldn't list repositories: {message} (error #{code}: {reason})".format(**repo_list))
-        for r in repo_list:
-            if r['name'] == repo:
-                return r
-        #raise ResourceNotFoundError('Cannot retrieve repository: {}/{} does not exists.'.format(user, repo))
+        try:
+            return Repository.find_repository_by_name_and_owner(repo, owner=user, client=self.bb)
+        except HTTPError as err:
+            raise ResourceNotFoundError('Cannot retrieve repository: {}/{} does not exists.'.format(user, repo))
 
     @classmethod
     def get_auth_token(cls, login, password, prompt=None):
@@ -152,9 +98,9 @@ def get_auth_token(cls, login, password, prompt=None):
 
     @property
     def user(self):
-        ret, user = self.bb.get_user()
-        if ret:
-            return user['username']
-        raise ResourceError("Could not retrieve username: {message} (error #{code}: {reason}".format(**result))
+        try:
+            return User.find_current_user(client=self.bb).username
+        except HTTPError as err:
+            raise ResourceError("Couldn't complete creation: {}".format(err)) from err
 
 

git_repo/services/service.py

@@ -11,7 +11,7 @@
 
 from subprocess import call
 
-from ..exceptions import ArgumentError
+from ..exceptions import ArgumentError, ResourceError
 
 '''select open command'''
 

requirements.txt

@@ -4,4 +4,4 @@ GitPython>=2.1.0
 uritemplate.py==2.0.0
 github3.py==0.9.5
 python-gitlab>=0.13
-bitbucket-api
+-e git+https://github.com/guyzmo/pybitbucket.git@master#egg=pybitbucket-0.11.2