Feature/upload content (#29)

Feature/upload content

Author: uilianries

bintray/bintray.py

@@ -165,8 +165,7 @@ def file_in_download_list(self, subject, repo, file_path, add_or_remove):
 
     def upload_content(self, subject, repo, package, version, remote_file_path, local_file_path,
                        publish=True, override=False, explode=False):
-        """
-        Upload content to the specified repository path, with package and version information (both required).
+        """ Upload content to the specified repository path, with package and version information.
 
         :param subject: username or organization
         :param repo: repository name
@@ -177,7 +176,7 @@ def upload_content(self, subject, repo, package, version, remote_file_path, loca
         :param publish: publish after uploading
         :param override: override remote file
         :param explode: explode remote file
-        :return:
+        :return: Request response
         """
         url = "{}/content/{}/{}/{}/{}/{}".format(Bintray.BINTRAY_URL, subject, repo, package,
                                                  version, remote_file_path)
@@ -191,6 +190,161 @@ def upload_content(self, subject, repo, package, version, remote_file_path, loca
         self._logger.info("Upload successfully: {}".format(url))
         return response
 
+    def maven_upload(self, subject, repo, package, remote_file_path, local_file_path, publish=True,
+                     passphrase=None):
+        """ Upload Maven artifacts to the specified repository path, with package information.
+
+            Version information is resolved from the path, which is expected to follow the Maven
+            layout.
+
+            You may supply a passphrase for signing uploaded files using the X-GPG-PASSPHRASE header
+
+        :param subject: username or organization
+        :param repo: repository name
+        :param package: package name
+        :param remote_file_path: file name to be used on Bintray
+        :param local_file_path: file path to be uploaded
+        :param publish: publish after uploading
+        :param passphrase: GPG passphrase
+        :return: Request response
+        """
+        url = "{}/maven/{}/{}/{}/{}".format(Bintray.BINTRAY_URL, subject, repo, package,
+                                            remote_file_path)
+        parameters = {"publish": bool_to_number(publish)}
+        headers = {"X-GPG-PASSPHRASE": passphrase} if passphrase else None
+
+        with open(local_file_path, 'rb') as file_content:
+            response = self._requester.put(url, params=parameters, data=file_content,
+                                           headers=headers)
+
+        self._logger.info("Upload successfully: {}".format(url))
+        return response
+
+    def debian_upload(self, subject, repo, package, version, remote_file_path, local_file_path,
+                      deb_distribution, deb_component, deb_architecture, publish=True,
+                      override=False, passphrase=None):
+        """ Upload Debian artifacts to the specified repository path, with package information.
+
+            When artifacts are uploaded to a Debian repository using the Automatic index layout,
+            the Debian distribution information is required and must be specified.
+
+        :param subject: username or organization
+        :param repo: repository name
+        :param package: package name
+        :param version: package version
+        :param remote_file_path: file name to be used on Bintray
+        :param local_file_path: file path to be uploaded
+        :param deb_distribution: Debian package distribution e.g. wheezy
+        :param deb_component: Debian package component e.g. main
+        :param deb_architecture: Debian package architecture e.g. i386,amd64
+        :param publish: publish after uploading
+        :param override: override remote file
+        :param passphrase: GPG passphrase
+        :return: Request response
+        """
+        url = "{}/content/{}/{}/{}/{}/{}".format(Bintray.BINTRAY_URL, subject, repo, package,
+                                                 version, remote_file_path)
+        parameters = {"publish": bool_to_number(publish),
+                      "override": bool_to_number(override)}
+        headers = {
+            "X-Bintray-Debian-Distribution": deb_distribution,
+            "X-Bintray-Debian-Component": deb_component,
+            "X-Bintray-Debian-Architecture": deb_architecture
+        }
+        if passphrase:
+            headers["X-GPG-PASSPHRASE"] = passphrase
+
+        with open(local_file_path, 'rb') as file_content:
+            response = self._requester.put(url, params=parameters, data=file_content,
+                                           headers=headers)
+
+        self._logger.info("Upload successfully: {}".format(url))
+        return response
+
+    def _publish_discard_uploaded_content(self, subject, repo, package, version, discard=False,
+                                          publish_wait_for_secs=-1, passphrase=None):
+        """ Asynchronously publishes all unpublished content for a user’s package version. Returns
+            the number of to-be-published files.
+
+            In order to wait for publishing to finish and run this call synchronously, specify a
+            "publish_wait_for_secs" timeout in seconds. To wait for the maximum timeout allowed by
+            Bintray use a wait value of -1 . A wait value of 0 is the default and is the same as
+            running this call asynchronously without waiting.
+
+            Optionally, pass in a "discard" flag to discard any unpublished content, instead of
+            publishing.
+
+            Automatic Signing for Repository Metadata
+
+            For repositories that support automatic calculation of repository metadata (such as
+            Debian and YUM), you may supply signing required information.
+
+        :param subject: username or organization
+        :param repo: repository name
+        :param package: package name
+        :param version: package version
+        :param discard: Discard package
+        :param publish_wait_for_secs: Publishing timeout
+        :param passphrase: GPG passphrase
+        :return: Request response
+        """
+        url = "{}/content/{}/{}/{}/{}/publish".format(Bintray.BINTRAY_URL, subject, repo, package,
+                                                      version)
+        body = {'discard': discard,
+                'publish_wait_for_secs': publish_wait_for_secs}
+        headers = {"X-GPG-PASSPHRASE": passphrase} if passphrase else None
+
+        response = self._requester.post(url, json=body, headers=headers)
+
+        self._logger.info("Publish/Discard successfully: {}".format(url))
+        return response
+
+    def publish_uploaded_content(self, subject, repo, package, version, passphrase=None):
+        """ Asynchronously publishes all unpublished content for a user’s package version.
+
+        :param subject: username or organization
+        :param repo: repository name
+        :param package: package name
+        :param version: package version
+        :param passphrase: GPG passphrase
+        :return: the number of to-be-published files.
+        """
+        return self._publish_discard_uploaded_content(subject, repo, package, version,
+                                                      discard=False, passphrase=passphrase)
+
+    def discard_uploaded_content(self, subject, repo, package, version, passphrase=None):
+        """ Asynchronously discard all unpublished content for a user’s package version.
+
+        :param subject: username or organization
+        :param repo: repository name
+        :param package: package name
+        :param version: package version
+        :param passphrase: GPG passphrase
+        :return: the number of discarded files.
+        """
+        return self._publish_discard_uploaded_content(subject, repo, package, version,
+                                                      discard=True, passphrase=passphrase)
+
+    def delete_content(self, subject, repo, file_path):
+        """ Delete content from the specified repository path,
+
+            Currently supports only deletion of files.
+            For OSS, this action is limited for 180 days from the content’s publish date.
+
+            Security: Authenticated user with 'publish' permission, or read/write entitlement for a
+            repository path
+
+        :param subject: username or organization
+        :param repo: repository name
+        :param file_path: file to be deleted
+        :return: request response
+        """
+        url = "{}/content/{}/{}/{}".format(Bintray.BINTRAY_URL, subject, repo, file_path)
+        response = self._requester.delete(url)
+
+        self._logger.info("Delete successfully: {}".format(url))
+        return response
+
     # Content Downloading
 
     def download_content(self, subject, repo, remote_file_path, local_file_path):

bintray/requester.py

@@ -66,34 +66,39 @@ def download(self, url, params=None):
             self._raise_error("Could not GET", response)
         return self._add_status_code(response), response.content
 
-    def put(self, url, params=None, data=None, json=None):
+    def put(self, url, params=None, data=None, json=None, headers=None):
         """ Forward PUT method
 
         :param url: URL address
         :param params: URL params
         :param data: Data content
         :param json: JSON content
+        :param headers: Request headers
         :return: JSON
         """
         if data and json:
             raise Exception("Only accept 'data' or 'json'")
         if data:
-            response = requests.put(url, auth=self._get_authentication(), params=params, data=data)
+            response = requests.put(url, auth=self._get_authentication(), params=params, data=data,
+                                    headers=headers)
         else:
-            response = requests.put(url, auth=self._get_authentication(), params=params, json=json)
+            response = requests.put(url, auth=self._get_authentication(), params=params, json=json,
+                                    headers=headers)
         if not response.ok:
             self._raise_error("Could not PUT", response)
         return self._add_status_code(response)
 
-    def post(self, url, json=None, params=None):
+    def post(self, url, json=None, params=None, headers=None):
         """ Forward POST method
 
         :param url: URL address
         :param params: URL parameters
         :param json: Data to be posted
+        :param headers: Request headers
         :return: Request response
         """
-        response = requests.post(url, auth=self._get_authentication(), json=json, params=params)
+        response = requests.post(url, auth=self._get_authentication(), json=json, params=params,
+                                 headers=headers)
         if not response.ok:
             self._raise_error("Could not POST", response)
         return self._add_status_code(response)

tests/test_upload_publishing.py

@@ -24,3 +24,49 @@ def test_bad_credentials_for_upload_content():
     assert "Could not PUT (401): 401 Client Error: Unauthorized for url: " \
            "https://api.bintray.com/content/uilianries/generic/statistics/test/test.txt?" \
            "publish=1&override=0&explode=0" == error_message
+
+
+def test_maven_upload():
+    bintray = Bintray()
+    _, temp_path = tempfile.mkstemp()
+    error_message = ""
+    try:
+        bintray.maven_upload("uilianries", "generic", "statistics", "pom.xml",
+                             temp_path, publish=True)
+    except Exception as error:
+        error_message = str(error)
+    assert "Could not PUT (400): 400 Client Error: Bad Request for url:" \
+           " https://api.bintray.com/maven/uilianries/generic/statistics/pom.xml" \
+           "?publish=1" == error_message
+
+
+def test_debian_upload():
+    bintray = Bintray()
+    _, temp_path = tempfile.mkstemp()
+    response = bintray.debian_upload("uilianries", "generic", "statistics", "test", "test.deb",
+                                     temp_path, deb_distribution="wheezy", deb_component="main",
+                                     deb_architecture="i386,amd64", publish=True, override=True)
+    assert {'error': False, 'message': 'success', 'statusCode': 201} == response
+
+
+def test_publish_uploaded_content():
+    bintray = Bintray()
+    response = bintray.publish_uploaded_content("uilianries", "generic", "statistics", "test")
+    assert {'error': False, 'files': 0, 'statusCode': 200} == response
+
+
+def test_discard_uploaded_content():
+    bintray = Bintray()
+    response = bintray.discard_uploaded_content("uilianries", "generic", "statistics", "test")
+    assert {'error': False, 'files': 0, 'statusCode': 200} == response
+
+
+def test_delete_content():
+    bintray = Bintray()
+    _, temp_path = tempfile.mkstemp()
+    response = bintray.upload_content("uilianries", "generic", "statistics", "test", "test.txt",
+                                      temp_path, override=True)
+    assert {'error': False, 'message': 'success', 'statusCode': 201} == response
+
+    response = bintray.delete_content("uilianries", "generic", "test.txt")
+    assert {'error': False, 'message': 'success', 'statusCode': 200} == response