Python analysis.Analysis类代码示例

    def post(self, analysis_id):
        analysis_id = int(analysis_id.split("/")[0])
        analysis_id_sent = int(self.get_argument('analysis_id'))
        action = self.get_argument('action')

        if analysis_id != analysis_id_sent or action != 'delete_analysis':
            raise QiitaPetAuthorizationError(
                self.current_user.id,
                'analysis/results/%d-delete' % analysis_id)

        analysis = Analysis(analysis_id)
        analysis_name = analysis.name
        check_analysis_access(self.current_user, analysis)

        try:
            Analysis.delete(analysis_id)
            msg = ("Analysis <b><i>%s</i></b> has been deleted." % (
                analysis_name))
            level = "success"
        except Exception as e:
            e = str(e)
            msg = ("Couldn't remove <b><i>%s</i></b> analysis: %s" % (
                analysis_name, e))
            level = "danger"
            LogEntry.create('Runtime', "Couldn't remove analysis ID %d: %s" %
                            (analysis_id, e))

        self.redirect(u"/analysis/show/?level=%s&message=%s" % (level, msg))

 def post(self):
     analysis = Analysis(int(self.get_argument('analysis-id')))
     # set to third step since this page is third step in workflow
     analysis.step = SELECT_COMMANDS
     data_types = analysis.data_types
     commands = Command.get_commands_by_datatype()
     self.render('select_commands.html',
                 commands=commands, data_types=data_types, aid=analysis.id)

    def test_delete(self):
        # successful delete
        total_analyses = get_count("qiita.analysis")
        Analysis.delete(1)
        self.assertEqual(total_analyses - 1, get_count("qiita.analysis"))

        # no possible to delete
        with self.assertRaises(QiitaDBUnknownIDError):
            Analysis.delete(total_analyses + 1)

    def test_check_portal(self):
        """Correctly checks if object is accessable in portal given"""
        qiita_config.portal = 'QIITA'
        tester = Analysis(1)
        self.assertTrue(tester._check_portal(1))
        qiita_config.portal = 'EMP'
        self.assertFalse(tester._check_portal(1))

        self.assertTrue(self.tester._check_portal(1))

    def test_remove_portal(self):
        Portal.create("NEWPORTAL", "SOMEDESC")
        # Select some samples on a default analysis
        qiita_config.portal = "NEWPORTAL"
        a = Analysis(User("[email protected]").default_analysis)
        a.add_samples({1: ['1.SKB8.640193', '1.SKD5.640186']})

        Portal.delete("NEWPORTAL")
        obs = self.conn_handler.execute_fetchall(
            "SELECT * FROM qiita.portal_type")
        exp = [[1, 'QIITA', 'QIITA portal. Access to all data stored '
                'in database.'],
               [2, 'EMP', 'EMP portal']]
        self.assertItemsEqual(obs, exp)

        obs = self.conn_handler.execute_fetchall(
            "SELECT * FROM qiita.analysis_portal")
        exp = [[1, 1], [2, 1], [3, 1], [4, 1], [5, 1], [6, 1], [7, 2], [8, 2],
               [9, 2], [10, 2]]
        self.assertItemsEqual(obs, exp)

        with self.assertRaises(QiitaDBLookupError):
            Portal.delete("NOEXISTPORTAL")
        with self.assertRaises(QiitaDBError):
            Portal.delete("QIITA")

        Portal.create("NEWPORTAL2", "SOMEDESC")
        # Add analysis to this new portal and make sure error raised
        qiita_config.portal = "NEWPORTAL2"
        Analysis.create(User("[email protected]"), "newportal analysis", "desc")
        qiita_config.portal = "QIITA"
        with self.assertRaises(QiitaDBError):
            Portal.delete("NEWPORTAL2")

        # Add study to this new portal and make sure error raised
        info = {
            "timeseries_type_id": 1,
            "metadata_complete": True,
            "mixs_compliant": True,
            "number_samples_collected": 25,
            "number_samples_promised": 28,
            "study_alias": "FCM",
            "study_description": "Microbiome of people who eat nothing but "
                                 "fried chicken",
            "study_abstract": "Exploring how a high fat diet changes the "
                              "gut microbiome",
            "emp_person_id": StudyPerson(2),
            "principal_investigator_id": StudyPerson(3),
            "lab_person_id": StudyPerson(1)
        }
        Portal.create("NEWPORTAL3", "SOMEDESC")
        qiita_config.portal = "NEWPORTAL3"
        Study.create(User('[email protected]'), "Fried chicken microbiome",
                     [1], info)
        qiita_config.portal = "QIITA"
        with self.assertRaises(QiitaDBError):
            Portal.delete("NEWPORTAL3")

 def test_exists(self):
     qiita_config.portal = 'QIITA'
     self.assertTrue(Analysis.exists(1))
     new_id = get_count("qiita.analysis") + 1
     self.assertFalse(Analysis.exists(new_id))
     qiita_config.portal = 'EMP'
     self.assertFalse(Analysis.exists(1))
     new_id = get_count("qiita.analysis") + 1
     self.assertFalse(Analysis.exists(new_id))

    def test_create_nonqiita_portal(self):
        new_id = get_count("qiita.analysis") + 1
        qiita_config.portal = "EMP"
        Analysis.create(User("[email protected]"), "newAnalysis",
                        "A New Analysis")

        # make sure portal is associated
        obs = self.conn_handler.execute_fetchall(
            "SELECT * from qiita.analysis_portal WHERE analysis_id = %s",
            [new_id])
        self.assertEqual(obs, [[new_id, 2], [new_id, 1]])

    def test_get_by_status(self):
        qiita_config.portal = 'QIITA'
        self.assertEqual(Analysis.get_by_status('public'), set([]))
        qiita_config.portal = 'EMP'
        self.assertEqual(Analysis.get_by_status('public'), set([]))

        self.analysis.status = "public"
        qiita_config.portal = 'QIITA'
        self.assertEqual(Analysis.get_by_status('public'), {1})
        qiita_config.portal = 'EMP'
        self.assertEqual(Analysis.get_by_status('public'), set([]))

 def test_create_exists_return_existing(self):
     """Makes sure creation doesn't duplicate a job by returning existing"""
     Analysis.create(User("[email protected]"), "new", "desc")
     self.conn_handler.execute(
         "INSERT INTO qiita.analysis_sample (analysis_id, "
         "processed_data_id, sample_id) VALUES (3,1,'SKB8.640193'), "
         "(3,1,'SKD8.640184'), (3,1,'SKB7.640196'), (3,1,'SKM9.640192'),"
         "(3,1,'SKM4.640180')")
     new = Job.create("18S", "Beta Diversity",
                      {"--otu_table_fp": 1, "--mapping_fp": 1},
                      Analysis(3), return_existing=True)
     self.assertEqual(new.id, 2)

 def test_set_step(self):
     new = Analysis.create(User("[email protected]"), "newAnalysis",
                           "A New Analysis", Analysis(1))
     new.step = 2
     sql = "SELECT * FROM qiita.analysis_workflow WHERE analysis_id = 3"
     obs = self.conn_handler.execute_fetchall(sql)
     self.assertEqual(obs, [[3, 2]])

 def test_add_samples(self):
     new = Analysis.create(User("[email protected]"), "newAnalysis",
                           "A New Analysis")
     new.add_samples({1: ['1.SKB8.640193', '1.SKD5.640186']})
     obs = new.samples
     self.assertEqual(obs.keys(), [1])
     self.assertItemsEqual(obs[1], ['1.SKB8.640193', '1.SKD5.640186'])

    def test_delete_study(self):
        # as samples have been submitted to EBI, this will fail
        job = self._create_job('delete_study', {'study': 1})
        private_task(job.id)
        self.assertEqual(job.status, 'error')
        self.assertIn("Cannot delete artifact 2: Artifact 2 has been "
                      "submitted to EBI", job.log.msg)
        # making sure the analysis, first thing to delete, still exists
        self.assertTrue(Analysis.exists(1))

        # delete everything from the EBI submissions and the processing job so
        # we can try again: test success (with tags)
        with TRN:
            sql = """DELETE FROM qiita.ebi_run_accession"""
            TRN.add(sql)
            sql = """DELETE FROM qiita.artifact_processing_job"""
            TRN.add(sql)
            TRN.execute()

            # adding tags
            Study(1).update_tags(self.user, ['my new tag!'])

            job = self._create_job('delete_study', {'study': 1})
            private_task(job.id)

            self.assertEqual(job.status, 'success')
            with self.assertRaises(QiitaDBUnknownIDError):
                Study(1)

 def test_create(self):
     new = Analysis.create(User("[email protected]"), "newAnalysis",
                           "A New Analysis")
     self.assertEqual(new.id, 3)
     sql = "SELECT * FROM qiita.analysis WHERE analysis_id = 3"
     obs = self.conn_handler.execute_fetchall(sql)
     self.assertEqual(obs, [[3, '[email protected]', 'newAnalysis',
                             'A New Analysis', 1, None]])

 def test_lock_check(self):
     for status in ["queued", "running", "public", "completed",
                    "error"]:
         new = Analysis.create(User("[email protected]"), "newAnalysis",
                               "A New Analysis")
         new.status = status
         with self.assertRaises(QiitaDBStatusError):
             new._lock_check(self.conn_handler)

    def post(self):
        name = self.get_argument('name')
        desc = self.get_argument('description')
        analysis = Analysis.create(self.current_user, name, desc,
                                   from_default=True)

        self.redirect(u"%s/analysis/description/%s/"
                      % (qiita_config.portal_dir, analysis.id))