removing conn_handler from def and calls - 2

Author: antgonza

qiita_db/analysis.py

@@ -655,11 +655,9 @@ def build_files(self, rarefaction_depth=None):
             if rarefaction_depth <= 0:
                 raise ValueError("rarefaction_depth must be greater than 0")
 
-        conn_handler = SQLConnectionHandler()
         samples = self._get_samples()
         self._build_mapping_file(samples)
-        self._build_biom_tables(samples, rarefaction_depth,
-                                conn_handler=conn_handler)
+        self._build_biom_tables(samples, rarefaction_depth)
 
     def _get_samples(self):
         """Retrieves dict of samples to proc_data_id for the analysis"""
@@ -669,8 +667,7 @@ def _get_samples(self):
                "GROUP BY processed_data_id")
         return dict(conn_handler.execute_fetchall(sql, [self._id]))
 
-    def _build_biom_tables(self, samples, rarefaction_depth,
-                           conn_handler=None):
+    def _build_biom_tables(self, samples, rarefaction_depth):
         """Build tables and add them to the analysis"""
         # filter and combine all study BIOM tables needed for each data type
         new_tables = {dt: None for dt in self.data_types}
@@ -700,7 +697,6 @@ def _build_biom_tables(self, samples, rarefaction_depth,
                 new_tables[data_type] = new_tables[data_type].merge(table)
 
         # add the new tables to the analysis
-        conn_handler = SQLConnectionHandler()
         _, base_fp = get_mountpoint(self._table)[0]
         for dt, biom_table in viewitems(new_tables):
             # rarefy, if specified
@@ -712,7 +708,7 @@ def _build_biom_tables(self, samples, rarefaction_depth,
                 biom_table.to_hdf5(f, "Analysis %s Datatype %s" %
                                    (self._id, dt))
             self._add_file("%d_analysis_%s.biom" % (self._id, dt),
-                           "biom", data_type=dt, conn_handler=conn_handler)
+                           "biom", data_type=dt)
 
     def _build_mapping_file(self, samples):
         """Builds the combined mapping file for all samples
@@ -773,10 +769,9 @@ def _build_mapping_file(self, samples):
         merged_map.to_csv(mapping_fp, index_label='#SampleID',
                           na_rep='unknown', sep='\t')
 
-        self._add_file("%d_analysis_mapping.txt" % self._id,
-                       "plain_text", conn_handler=conn_handler)
+        self._add_file("%d_analysis_mapping.txt" % self._id, "plain_text")
 
-    def _add_file(self, filename, filetype, data_type=None, conn_handler=None):
+    def _add_file(self, filename, filetype, data_type=None):
         """adds analysis item to database
 
         Parameters
@@ -785,7 +780,6 @@ def _add_file(self, filename, filetype, data_type=None, conn_handler=None):
             filename to add to analysis
         filetype : {plain_text, biom}
         data_type : str, optional
-        conn_handler : SQLConnectionHandler object, optional
         """
         conn_handler = SQLConnectionHandler()
 

qiita_db/base.py

@@ -226,7 +226,7 @@ def status(self, status):
             "(SELECT {0}_status_id FROM qiita.{0}_status WHERE status = %s) "
             "WHERE {0}_id = %s".format(self._table), (status, self._id))
 
-    def check_status(self, status, exclude=False, conn_handler=None):
+    def check_status(self, status, exclude=False):
         r"""Checks status of object.
 
         Parameters
@@ -236,8 +236,6 @@ def check_status(self, status, exclude=False, conn_handler=None):
         exclude: bool, optional
             If True, will check that database status is NOT one of the statuses
             passed. Default False.
-        conn_handler: SQLConnectionHandler, optional
-            The connection handler object connected to the DB
 
         Returns
         -------

qiita_db/data.py

@@ -139,7 +139,7 @@ def _link_data_filepaths(self, fp_ids, conn_handler):
             "VALUES (%s, %s)".format(self._data_filepath_table,
                                      self._data_filepath_column), values)
 
-    def add_filepaths(self, filepaths, conn_handler=None):
+    def add_filepaths(self, filepaths):
         r"""Populates the DB tables for storing the filepaths and connects the
         `self` objects with these filepaths"""
         # Check that this function has been called from a subclass
@@ -326,7 +326,7 @@ def create(cls, filetype, studies, filepaths=None):
 
         # If file paths have been provided, add them to the raw data object
         if filepaths:
-            rd.add_filepaths(filepaths, conn_handler)
+            rd.add_filepaths(filepaths)
 
         return rd
 
@@ -465,14 +465,9 @@ def prep_templates(self):
                "WHERE raw_data_id = %s ORDER BY prep_template_id")
         return [x[0] for x in conn_handler.execute_fetchall(sql, (self._id,))]
 
-    def _is_preprocessed(self, conn_handler=None):
+    def _is_preprocessed(self):
         """Returns whether the RawData has been preprocessed or not
 
-        Parameters
-        ----------
-        conn_handler : SQLConnectionHandler
-            The connection handler object connected to the DB
-
         Returns
         -------
         bool
@@ -507,7 +502,7 @@ def _remove_filepath(self, fp, conn_handler, queue):
         """
         # If the RawData has been already preprocessed, we cannot remove any
         # file - raise an error
-        if self._is_preprocessed(conn_handler):
+        if self._is_preprocessed():
             msg = ("Cannot clear all the filepaths from raw data %s, it has "
                    "been already preprocessed" % self._id)
             self._set_link_filepaths_status("failed: %s" % msg)
@@ -525,7 +520,7 @@ def _remove_filepath(self, fp, conn_handler, queue):
             raise QiitaDBError(msg)
 
         # Get the filpeath id
-        fp_id = get_filepath_id(self._table, fp, conn_handler)
+        fp_id = get_filepath_id(self._table, fp)
         fp_is_mine = conn_handler.execute_fetchone(
             "SELECT EXISTS(SELECT * FROM qiita.{0} WHERE filepath_id=%s AND "
             "{1}=%s)".format(self._data_filepath_table,
@@ -803,7 +798,7 @@ def create(cls, study, preprocessed_params_table, preprocessed_params_id,
             conn_handler.execute_queue(q)
 
         # Add the filepaths to the database and connect them
-        ppd.add_filepaths(filepaths, conn_handler)
+        ppd.add_filepaths(filepaths)
         return ppd
 
     @classmethod
@@ -1320,7 +1315,7 @@ def create(cls, processed_params_table, processed_params_id, filepaths,
             "(%s, %s)".format(cls._study_processed_table),
             (study_id, pd_id))
 
-        pd.add_filepaths(filepaths, conn_handler)
+        pd.add_filepaths(filepaths)
         return cls(pd_id)
 
     @classmethod

qiita_db/metadata_template/base_metadata_template.py

@@ -1025,7 +1025,7 @@ def to_dataframe(self):
 
         return df
 
-    def add_filepath(self, filepath, conn_handler=None, fp_id=None):
+    def add_filepath(self, filepath, fp_id=None):
         r"""Populates the DB tables for storing the filepath and connects the
         `self` objects with this filepath"""
         # Check that this function has been called from a subclass
@@ -1050,7 +1050,7 @@ def add_filepath(self, filepath, conn_handler=None, fp_id=None):
                             info={self.__class__.__name__: self.id})
             raise e
 
-    def get_filepaths(self, conn_handler=None):
+    def get_filepaths(self):
         r"""Retrieves the list of (filepath_id, filepath)"""
         # Check that this function has been called from a subclass
         self._check_subclass()

qiita_db/metadata_template/prep_template.py

@@ -495,7 +495,7 @@ def create_qiime_mapping_file(self):
 
         # adding the fp to the object
         self.add_filepath(
-            filepath, conn_handler=conn_handler,
+            filepath,
             fp_id=convert_to_id("qiime_map", "filepath_type"))
 
         return filepath

qiita_db/parameters.py

@@ -138,8 +138,9 @@ def _check_id(self, id_):
                 self._table, self._column_id),
             (id_, ))[0]
 
-    def _get_values_as_dict(self, conn_handler):
+    def _get_values_as_dict(self):
         r""""""
+        conn_handler = SQLConnectionHandler()
         return dict(conn_handler.execute_fetchone(
                     "SELECT * FROM qiita.{0} WHERE {1}=%s".format(
                         self._table, self._column_id), (self.id,)))
@@ -152,11 +153,10 @@ def to_str(self):
         str
             The string with all the parameters
         """
-        conn_handler = SQLConnectionHandler()
         table_cols = get_table_cols_w_type(self._table)
         table_cols.remove([self._column_id, 'bigint'])
 
-        values = self._get_values_as_dict(conn_handler=conn_handler)
+        values = self._get_values_as_dict()
 
         result = []
         for p_name, p_type in sorted(table_cols):
@@ -212,8 +212,7 @@ def to_file(self, f):
             File-like object to write the parameters. Should support the write
             operation
         """
-        conn_handler = SQLConnectionHandler()
-        values = self._get_values_as_dict(conn_handler)
+        values = self._get_values_as_dict()
 
         # Remove the id column
         del values[self._column_id]

qiita_db/test/test_analysis.py

@@ -237,8 +237,7 @@ def test_retrieve_dropped_samples(self):
 
         samples = {1: ['1.SKB8.640193', '1.SKD8.640184', '1.SKB7.640196'],
                    2: ['2.SKB8.640193', '2.SKD8.640184']}
-        self.analysis._build_biom_tables(samples, 10000,
-                                         conn_handler=self.conn_handler)
+        self.analysis._build_biom_tables(samples, 10000)
         exp = {1: {'1.SKM4.640180', '1.SKM9.640192'},
                2: {'2.SKB7.640196'}}
         self.assertEqual(self.analysis.dropped_samples, exp)
@@ -423,8 +422,7 @@ def test_build_mapping_file_duplicate_samples(self):
     def test_build_biom_tables(self):
         new_id = get_count('qiita.filepath') + 1
         samples = {1: ['1.SKB8.640193', '1.SKD8.640184', '1.SKB7.640196']}
-        self.analysis._build_biom_tables(samples, 100,
-                                         conn_handler=self.conn_handler)
+        self.analysis._build_biom_tables(samples, 100)
         obs = self.analysis.biom_tables
 
         self.assertEqual(obs, {'18S': self.biom_fp})

qiita_db/test/test_base.py

@@ -87,46 +87,27 @@ def test_status(self):
     def test_check_status_single(self):
         """check_status works passing a single status"""
         self.assertTrue(self.tester.check_status(["in_construction"]))
-        self.assertTrue(self.tester.check_status(["in_construction"],
-                        conn_handler=self.conn_handler))
         self.assertFalse(self.tester.check_status(["queued"]))
-        self.assertFalse(self.tester.check_status(["queued"],
-                         conn_handler=self.conn_handler))
 
     def test_check_status_exclude_single(self):
         """check_status works passing a single status and the exclude flag"""
         self.assertTrue(self.tester.check_status(["public"], exclude=True))
-        self.assertTrue(self.tester.check_status(["public"], exclude=True,
-                        conn_handler=self.conn_handler))
         self.assertFalse(self.tester.check_status(["in_construction"],
                          exclude=True))
-        self.assertFalse(self.tester.check_status(["in_construction"],
-                         exclude=True, conn_handler=self.conn_handler))
 
     def test_check_status_list(self):
         """check_status work passing a list of status"""
         self.assertTrue(self.tester.check_status(
             ["in_construction", "queued"]))
-        self.assertTrue(self.tester.check_status(
-            ["in_construction", "queued"],
-            conn_handler=self.conn_handler))
         self.assertFalse(self.tester.check_status(
             ["public", "queued"]))
-        self.assertFalse(self.tester.check_status(
-            ["public", "queued"], conn_handler=self.conn_handler))
 
     def test_check_status_exclude_list(self):
         """check_status work passing a list of status and the exclude flag"""
         self.assertTrue(self.tester.check_status(
             ["public", "queued"], exclude=True))
-        self.assertTrue(self.tester.check_status(
-            ["public", "queued"], exclude=True,
-            conn_handler=self.conn_handler))
         self.assertFalse(self.tester.check_status(
             ["in_construction", "queued"], exclude=True))
-        self.assertFalse(self.tester.check_status(
-            ["in_construction", "queued"], exclude=True,
-            conn_handler=self.conn_handler))
 
     def test_check_status_unknown_status(self):
         """check_status raises an error if an invalid status is provided"""
@@ -136,13 +117,6 @@ def test_check_status_unknown_status(self):
         with self.assertRaises(ValueError):
             self.tester.check_status(["foo"], exclude=True)
 
-        with self.assertRaises(ValueError):
-            self.tester.check_status(["foo"], conn_handler=self.conn_handler)
-
-        with self.assertRaises(ValueError):
-            self.tester.check_status(["foo"], exclude=True,
-                                     conn_handler=self.conn_handler)
-
     def test_check_status_unknown_status_list(self):
         """check_status raises an error if an invalid status list is provided
         """
@@ -152,13 +126,5 @@ def test_check_status_unknown_status_list(self):
         with self.assertRaises(ValueError):
             self.tester.check_status(["foo", "bar"], exclude=True)
 
-        with self.assertRaises(ValueError):
-            self.tester.check_status(["foo", "bar"],
-                                     conn_handler=self.conn_handler)
-
-        with self.assertRaises(ValueError):
-            self.tester.check_status(["foo", "bar"], exclude=True,
-                                     conn_handler=self.conn_handler)
-
 if __name__ == '__main__':
     main()

qiita_db/test/test_study.py

@@ -175,8 +175,7 @@ def setUp(self):
     def _change_processed_data_status(self, new_status):
         # Change the status of the studies by changing the status of their
         # processed data
-        id_status = convert_to_id(new_status, 'processed_data_status',
-                                  self.conn_handler)
+        id_status = convert_to_id(new_status, 'processed_data_status')
         self.conn_handler.execute(
             "UPDATE qiita.processed_data SET processed_data_status_id = %s",
             (id_status,))

qiita_db/test/test_util.py

@@ -446,12 +446,12 @@ def test_move_filepaths_to_upload_folder(self):
     def test_get_filepath_id(self):
         _, base = get_mountpoint("raw_data")[0]
         fp = join(base, '1_s_G1_L001_sequences.fastq.gz')
-        obs = get_filepath_id("raw_data", fp, self.conn_handler)
+        obs = get_filepath_id("raw_data", fp)
         self.assertEqual(obs, 1)
 
     def test_get_filepath_id_error(self):
         with self.assertRaises(QiitaDBError):
-            get_filepath_id("raw_data", "Not_a_path", self.conn_handler)
+            get_filepath_id("raw_data", "Not_a_path")
 
     def test_get_mountpoint(self):
         exp = [(5, join(get_db_files_base_dir(), 'raw_data', ''))]