adding a delete_file_from_central method, which does NOT delete when in https mode

Author: sjanssen2

qiita_client/qiita_client.py

@@ -820,20 +820,23 @@ def fetch_file_from_central(self, filepath, prefix=None):
                  "configuration is NOT defined.") % self._plugincoupling)
 
     def push_file_to_central(self, filepath):
-        """Pushs filecontent to Qiita's central BASE_DATA_DIR directory.
+        """Pushs file- or directory content  to Qiita's central BASE_DATA_DIR
+           directory.
 
         By default, plugin and Qiita's central BASE_DATA_DIR filesystems are
         identical. In this case, no files are touched and the filepath is
         directly returned.
         If however, plugincoupling is set to 'https', the content of the file
-        is sent via https POST to Qiita's master/worker, which has to receive
-        and store in an appropriate location.
+        (or content of recursively all files in the given directory) is sent
+        via https POST to Qiita's master/worker, which has to receive and store
+        in an appropriate location.
 
         Parameters
         ----------
         filepath : str
-            The filepath of the files whos content shall be send to Qiita's
-            central BASE_DATA_DIR
+            The filepath of the file(s) whos content shall be send to Qiita's
+            central BASE_DATA_DIR.
+            Can be a path to a directory as well.
 
         Returns
         -------
@@ -872,3 +875,31 @@ def push_file_to_central(self, filepath):
         raise ValueError(
             ("File communication protocol '%s' as defined in plugins "
              "configuration is NOT defined.") % self._plugincoupling)
+
+    def delete_file_from_central(self, filepath):
+        """Deletes a file in Qiita's central BASE_DATA_DIR directory.
+
+        I currently (2025-09-25) assess this operation to be too dangerous for
+        protocols other than "filesystem", i.e. on "https" the files are NOT
+        deleted.
+        However, this might change in the future and since I don't want to
+        touch every plugin's code again, I am adding this function here already
+        and use it in according plugin code locations, e.g. function _gzip_file
+        in qtp-sequencing.
+
+        Parameters
+        ----------
+        filepath : str
+            The filepath of the file that shall be deletes in Qiita's
+            central BASE_DATA_DIR
+
+        Returns
+        -------
+        The given filepath - to be transparent in plugin code.
+        """
+        if self._plugincoupling == 'filesystem':
+            os.remove(filepath)
+        elif self._plugincoupling == 'https':
+            pass
+
+        return filepath

qiita_client/tests/test_qiita_client.py

@@ -9,7 +9,7 @@
 from unittest import TestCase, main
 import filecmp
 from os import remove, close, makedirs
-from os.path import basename, exists, expanduser, join, isdir
+from os.path import basename, exists, expanduser, join, isdir, dirname
 from tempfile import mkstemp
 from json import dumps
 import pandas as pd
@@ -488,6 +488,43 @@ def test_push_file_to_central_dir(self):
         # As we don't necessarily know the QIITA_BASE_DIR, we cannot fetch one
         # of the files to double check for it's content
 
+    def test_delete_file_from_central(self):
+        # obtain current filepaths to infer QIITA_BASE_DIR
+        ainfo = self.tester.get("/qiita_db/artifacts/%s/" % 1)
+        cwd = dirname(ainfo['files']['raw_forward_seqs'][0]['filepath'])
+
+        for protocol in ['filesystem', 'https']:
+            self.qclient._plugincoupling = protocol
+
+            # deposit a test file
+            fp_test = join(cwd, 'deletme_%s.txt' % protocol)
+            makedirs(cwd, exist_ok=True)
+            with open(fp_test, 'w') as f:
+                f.write('This is a testfile content\n')
+            self.clean_up_files.append(fp_test)
+            self.qclient.push_file_to_central(fp_test)
+
+            # sanity check that test file has been deposited correctly
+            fp_obs = self.qclient.fetch_file_from_central(fp_test)
+            self.assertTrue(exists(fp_obs))
+
+            # delete file and test if it is gone
+            fp_deleted = self.qclient.delete_file_from_central(fp_test)
+            if protocol == 'filesystem':
+                # all three fp should point to the same filepath
+                self.assertFalse(exists(fp_obs))
+                self.assertFalse(exists(fp_test))
+                self.assertFalse(exists(fp_deleted))
+            elif protocol == 'https':
+                # as of 2025-09-26, I don't allow deletion of qiita main files
+                # through API endpoints. Thus, the file is NOT deleted!
+                # local version of the file
+                self.assertTrue(exists(fp_test))
+                # qiita main filepath
+                self.assertTrue(exists(fp_obs))
+                # qiita main filepath, returned by delete_file_from_central
+                self.assertTrue(exists(fp_deleted))
+
 
 if __name__ == '__main__':
     main()