removing conn_handler from def and calls - 1

Author: antgonza

qiita_db/analysis.py

@@ -656,12 +656,12 @@ def build_files(self, rarefaction_depth=None):
                 raise ValueError("rarefaction_depth must be greater than 0")
 
         conn_handler = SQLConnectionHandler()
-        samples = self._get_samples(conn_handler=conn_handler)
-        self._build_mapping_file(samples, conn_handler=conn_handler)
+        samples = self._get_samples()
+        self._build_mapping_file(samples)
         self._build_biom_tables(samples, rarefaction_depth,
                                 conn_handler=conn_handler)
 
-    def _get_samples(self, conn_handler=None):
+    def _get_samples(self):
         """Retrieves dict of samples to proc_data_id for the analysis"""
         conn_handler = SQLConnectionHandler()
         sql = ("SELECT processed_data_id, array_agg(sample_id ORDER BY "
@@ -714,7 +714,7 @@ def _build_biom_tables(self, samples, rarefaction_depth,
             self._add_file("%d_analysis_%s.biom" % (self._id, dt),
                            "biom", data_type=dt, conn_handler=conn_handler)
 
-    def _build_mapping_file(self, samples, conn_handler=None):
+    def _build_mapping_file(self, samples):
         """Builds the combined mapping file for all samples
            Code modified slightly from qiime.util.MetadataMap.__add__"""
         conn_handler = SQLConnectionHandler()
@@ -787,11 +787,10 @@ def _add_file(self, filename, filetype, data_type=None, conn_handler=None):
         data_type : str, optional
         conn_handler : SQLConnectionHandler object, optional
         """
-        conn_handler = SQLConnectionHandler() \
-
+        conn_handler = SQLConnectionHandler()
 
-        filetype_id = convert_to_id(filetype, 'filepath_type', conn_handler)
-        _, mp = get_mountpoint('analysis', conn_handler)[0]
+        filetype_id = convert_to_id(filetype, 'filepath_type')
+        _, mp = get_mountpoint('analysis')[0]
         fpid = insert_filepaths([
             (join(mp, filename), filetype_id)], -1, 'analysis', 'filepath',
             conn_handler, move_files=False)[0]

qiita_db/base.py

@@ -113,15 +113,13 @@ def _check_subclass(cls):
             raise IncompetentQiitaDeveloperError(
                 "Could not instantiate an object of the base class")
 
-    def _check_id(self, id_, conn_handler=None):
+    def _check_id(self, id_):
         r"""Check that the provided ID actually exists on the database
 
         Parameters
         ----------
         id_ : object
             The ID to test
-        conn_handler : SQLConnectionHandler
-            The connection handler object connected to the DB
 
         Notes
         -----

qiita_db/data.py

@@ -193,11 +193,11 @@ def get_filepaths(self):
                                  self._data_filepath_table,
                                  self._data_filepath_column), {'id': self.id})
 
-        _, fb = get_mountpoint(self._table, conn_handler)[0]
+        _, fb = get_mountpoint(self._table)[0]
         base_fp = partial(join, fb)
 
-        return [(fpid, base_fp(fp), convert_from_id(fid, "filepath_type",
-                conn_handler)) for fpid, fp, fid in db_paths]
+        return [(fpid, base_fp(fp), convert_from_id(fid, "filepath_type"))
+                for fpid, fp, fid in db_paths]
 
     def get_filepath_ids(self):
         self._check_subclass()
@@ -579,8 +579,7 @@ def clear_filepaths(self):
 
         # Move the files, if they are not used, if you get to this point
         # self.studies should only have one element, thus self.studies[0]
-        move_filepaths_to_upload_folder(self.studies[0], filepaths,
-                                        conn_handler=conn_handler)
+        move_filepaths_to_upload_folder(self.studies[0], filepaths)
 
     def remove_filepath(self, fp):
         """Removes the filepath from the RawData
@@ -614,7 +613,7 @@ def remove_filepath(self, fp):
         self._set_link_filepaths_status("idle")
 
         # Delete the files, if they are not used anywhere
-        purge_filepaths(conn_handler)
+        purge_filepaths()
 
     def status(self, study):
         """The status of the raw data within the given study
@@ -753,7 +752,7 @@ def create(cls, study, preprocessed_params_table, preprocessed_params_id,
             data_type = prep_template.data_type(ret_id=True)
         else:
             # only data_type, so need id from the text
-            data_type = convert_to_id(data_type, "data_type", conn_handler)
+            data_type = convert_to_id(data_type, "data_type")
 
         # Check that the preprocessed_params_table exists
         if not exists_dynamic_table(preprocessed_params_table, "preprocessed_",
@@ -1278,7 +1277,7 @@ def create(cls, processed_params_table, processed_params_id, filepaths,
                     "You must provide either a preprocessed_data, a "
                     "data_type, or both")
             else:
-                data_type = convert_to_id(data_type, "data_type", conn_handler)
+                data_type = convert_to_id(data_type, "data_type")
 
         # We first check that the processed_params_table exists
         if not exists_dynamic_table(processed_params_table,
@@ -1524,8 +1523,7 @@ def status(self, status):
 
         conn_handler = SQLConnectionHandler()
 
-        status_id = convert_to_id(status, 'processed_data_status',
-                                  conn_handler=conn_handler)
+        status_id = convert_to_id(status, 'processed_data_status')
 
         sql = """UPDATE qiita.{0} SET processed_data_status_id = %s
                  WHERE processed_data_id=%s""".format(self._table)

qiita_db/job.py

@@ -110,7 +110,7 @@ def exists(cls, datatype, command, options, analysis,
         """
         conn_handler = SQLConnectionHandler()
         # check passed arguments and grab analyses for matching jobs
-        datatype_id = convert_to_id(datatype, "data_type", conn_handler)
+        datatype_id = convert_to_id(datatype, "data_type")
         sql = "SELECT command_id FROM qiita.command WHERE name = %s"
         command_id = conn_handler.execute_fetchone(sql, (command, ))[0]
         opts_json = params_dict_to_json(options)
@@ -238,7 +238,7 @@ def create(cls, datatype, command, options, analysis,
                     "analysis: %s" % (datatype, command, options, analysis.id))
 
         # Get the datatype and command ids from the strings
-        datatype_id = convert_to_id(datatype, "data_type", conn_handler)
+        datatype_id = convert_to_id(datatype, "data_type")
         sql = "SELECT command_id FROM qiita.command WHERE name = %s"
         command_id = conn_handler.execute_fetchone(sql, (command, ))[0]
         opts_json = params_dict_to_json(options)
@@ -297,7 +297,7 @@ def options(self):
                "job_id = %s)".format(self._table))
         db_comm = conn_handler.execute_fetchone(sql, (self._id, ))
         out_opt = loads(db_comm[1])
-        basedir = get_db_files_base_dir(conn_handler)
+        basedir = get_db_files_base_dir()
         join_f = partial(join, join(basedir, "job"))
         for k in out_opt:
             opts[k] = join_f("%s_%s_%s" % (self._id, db_comm[0], k.strip("-")))
@@ -422,7 +422,7 @@ def add_results(self, results):
         conn_handler = SQLConnectionHandler()
         self._lock_job(conn_handler)
         # convert all file type text to file type ids
-        res_ids = [(fp, convert_to_id(fptype, "filepath_type", conn_handler))
+        res_ids = [(fp, convert_to_id(fptype, "filepath_type"))
                    for fp, fptype in results]
         file_ids = insert_filepaths(res_ids, self._id, self._table,
                                     "filepath", conn_handler, move_files=False)
@@ -485,7 +485,7 @@ def get_commands_by_datatype(cls, datatypes=None):
         conn_handler = SQLConnectionHandler()
         # get the ids of the datatypes to get commands for
         if datatypes is not None:
-            datatype_info = [(convert_to_id(dt, "data_type", conn_handler), dt)
+            datatype_info = [(convert_to_id(dt, "data_type"), dt)
                              for dt in datatypes]
         else:
             datatype_info = conn_handler.execute_fetchall(

qiita_db/metadata_template/base_metadata_template.py

@@ -195,7 +195,7 @@ def _get_categories(self, conn_handler):
             The set of all available metadata categories
         """
         # Get all the columns
-        cols = get_table_cols(self._dynamic_table, conn_handler)
+        cols = get_table_cols(self._dynamic_table)
         # Remove the sample_id column as this column is used internally for
         # data storage and it doesn't actually belong to the metadata
         cols.remove('sample_id')
@@ -489,7 +489,7 @@ class MetadataTemplate(QiitaObject):
     _id_column = None
     _sample_cls = None
 
-    def _check_id(self, id_, conn_handler=None):
+    def _check_id(self, id_):
         r"""Checks that the MetadataTemplate id_ exists on the database"""
         self._check_subclass()
 
@@ -1013,7 +1013,7 @@ def to_dataframe(self):
             The metadata in the template,indexed on sample id
         """
         conn_handler = SQLConnectionHandler()
-        cols = sorted(get_table_cols(self._table_name(self._id), conn_handler))
+        cols = sorted(get_table_cols(self._table_name(self._id)))
         # Get all metadata for the template
         sql = "SELECT {0} FROM qiita.{1}".format(", ".join(cols),
                                                  self._table_name(self.id))
@@ -1071,7 +1071,7 @@ def get_filepaths(self, conn_handler=None):
                             info={self.__class__.__name__: self.id})
             raise e
 
-        _, fb = get_mountpoint('templates', conn_handler)[0]
+        _, fb = get_mountpoint('templates')[0]
         base_fp = partial(join, fb)
 
         return [(fpid, base_fp(fp)) for fpid, fp in filepath_ids]

qiita_db/metadata_template/prep_template.py

@@ -117,10 +117,9 @@ def create(cls, md_template, raw_data, study, data_type,
         # Check if the data_type is the id or the string
         if isinstance(data_type, (int, long)):
             data_type_id = data_type
-            data_type_str = convert_from_id(data_type, "data_type",
-                                            conn_handler)
+            data_type_str = convert_from_id(data_type, "data_type")
         else:
-            data_type_id = convert_to_id(data_type, "data_type", conn_handler)
+            data_type_id = convert_to_id(data_type, "data_type")
             data_type_str = data_type
 
         pt_cols = PREP_TEMPLATE_COLUMNS

qiita_db/parameters.py

@@ -116,15 +116,13 @@ def values(self):
         del result['param_set_name']
         return result
 
-    def _check_id(self, id_, conn_handler=None):
+    def _check_id(self, id_):
         r"""Check that the provided ID actually exists in the database
 
         Parameters
         ----------
         id_ : object
             The ID to test
-        conn_handler : SQLConnectionHandler
-            The connection handler object connected to the DB
 
         Notes
         -----

qiita_db/reference.py

@@ -70,24 +70,21 @@ def create(cls, name, version, seqs_fp, tax_fp=None, tree_fp=None):
         conn_handler = SQLConnectionHandler()
 
         seq_id = insert_filepaths([(seqs_fp, convert_to_id("reference_seqs",
-                                                           "filepath_type",
-                                                           conn_handler))],
+                                                           "filepath_type"))],
                                   "%s_%s" % (name, version), "reference",
                                   "filepath", conn_handler)[0]
 
         # Check if the database has taxonomy file
         tax_id = None
         if tax_fp:
-            fps = [(tax_fp, convert_to_id("reference_tax", "filepath_type",
-                                          conn_handler))]
+            fps = [(tax_fp, convert_to_id("reference_tax", "filepath_type"))]
             tax_id = insert_filepaths(fps, "%s_%s" % (name, version),
                                       "reference", "filepath", conn_handler)[0]
 
         # Check if the database has tree file
         tree_id = None
         if tree_fp:
-            fps = [(tree_fp, convert_to_id("reference_tree", "filepath_type",
-                                           conn_handler))]
+            fps = [(tree_fp, convert_to_id("reference_tree", "filepath_type"))]
             tree_id = insert_filepaths(fps, "%s_%s" % (name, version),
                                        "reference", "filepath",
                                        conn_handler)[0]
@@ -129,15 +126,15 @@ def name(self):
         return conn_handler.execute_fetchone(
             "SELECT reference_name FROM qiita.{0} WHERE "
             "reference_id = %s".format(self._table), (self._id,))[0]
-        _, basefp = get_mountpoint('reference', conn_handler=conn_handler)[0]
+        _, basefp = get_mountpoint('reference')[0]
 
     @property
     def version(self):
         conn_handler = SQLConnectionHandler()
         return conn_handler.execute_fetchone(
             "SELECT reference_version FROM qiita.{0} WHERE "
             "reference_id = %s".format(self._table), (self._id,))[0]
-        _, basefp = get_mountpoint('reference', conn_handler=conn_handler)[0]
+        _, basefp = get_mountpoint('reference')[0]
 
     @property
     def sequence_fp(self):
@@ -146,7 +143,7 @@ def sequence_fp(self):
             "SELECT f.filepath FROM qiita.filepath f JOIN qiita.{0} r ON "
             "r.sequence_filepath=f.filepath_id WHERE "
             "r.reference_id=%s".format(self._table), (self._id,))[0]
-        _, basefp = get_mountpoint('reference', conn_handler=conn_handler)[0]
+        _, basefp = get_mountpoint('reference')[0]
         return join(basefp, rel_path)
 
     @property
@@ -156,7 +153,7 @@ def taxonomy_fp(self):
             "SELECT f.filepath FROM qiita.filepath f JOIN qiita.{0} r ON "
             "r.taxonomy_filepath=f.filepath_id WHERE "
             "r.reference_id=%s".format(self._table), (self._id,))[0]
-        _, basefp = get_mountpoint('reference', conn_handler=conn_handler)[0]
+        _, basefp = get_mountpoint('reference')[0]
         return join(basefp, rel_path)
 
     @property
@@ -166,5 +163,5 @@ def tree_fp(self):
             "SELECT f.filepath FROM qiita.filepath f JOIN qiita.{0} r ON "
             "r.tree_filepath=f.filepath_id WHERE "
             "r.reference_id=%s".format(self._table), (self._id,))[0]
-        _, basefp = get_mountpoint('reference', conn_handler=conn_handler)[0]
+        _, basefp = get_mountpoint('reference')[0]
         return join(basefp, rel_path)

qiita_db/study.py

@@ -707,8 +707,7 @@ def environmental_packages(self, values):
             raise TypeError('Environmental packages should be a list')
 
         # Get all the environmental packages
-        env_pkgs = [pkg[0] for pkg in get_environmental_packages(
-            conn_handler=conn_handler)]
+        env_pkgs = [pkg[0] for pkg in get_environmental_packages()]
 
         # Check that all the passed values are valid environmental packages
         missing = set(values).difference(env_pkgs)

qiita_db/support_files/patches/python_patches/15.py

@@ -14,7 +14,7 @@
 
 # retrieve relative filepaths as dictionary for matching
 mountpoints = {m[1].rstrip('/\\'): m[0] for m in get_mountpoint(
-    'analysis', conn_handler=conn_handler, retrieve_all=True)}
+    'analysis', retrieve_all=True)}
 
 for filepath in filepaths:
     filename = basename(filepath['filepath'])