Python Analysis.remove_samples方法代码示例

# 需要导入模块: from qiita_db.analysis import Analysis [as 别名]
# 或者: from qiita_db.analysis.Analysis import remove_samples [as 别名]
    def on_message(self, msg):
        # When the websocket receives a message from the javascript client,
        # parse into JSON
        msginfo = loads(msg)
        default = Analysis(self.current_user.default_analysis)

        if 'remove_sample' in msginfo:
            data = msginfo['remove_sample']
            default.remove_samples([data['proc_data']], data['samples'])
        elif 'remove_pd' in msginfo:
            data = msginfo['remove_pd']
            default.remove_samples([data['proc_data']])
        elif 'clear' in msginfo:
            data = msginfo['clear']
            default.remove_samples(data['pids'])
        self.write_message(msg)

# 需要导入模块: from qiita_db.analysis import Analysis [as 别名]
# 或者: from qiita_db.analysis.Analysis import remove_samples [as 别名]

#.........这里部分代码省略.........
    def test_retrieve_mapping_file(self):
        exp = join(self.fp, "1_analysis_mapping.txt")
        obs = self.analysis.mapping_file
        self.assertEqual(obs, exp)
        self.assertTrue(exists(exp))

    def test_retrieve_mapping_file_none(self):
        new = Analysis.create(User("[email protected]"), "newAnalysis",
                              "A New Analysis", Analysis(1))
        obs = new.mapping_file
        self.assertEqual(obs, None)

    # def test_get_parent(self):
    #     raise NotImplementedError()

    # def test_get_children(self):
    #     raise NotImplementedError()

    def test_summary_data(self):
        obs = self.analysis.summary_data()
        exp = {'studies': 1,
               'processed_data': 1,
               'samples': 5}
        self.assertEqual(obs, exp)

    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_remove_samples_both(self):
        self.analysis.remove_samples(proc_data=(1, ),
                                     samples=('1.SKB8.640193', ))
        exp = {1: ['1.SKD8.640184', '1.SKB7.640196', '1.SKM9.640192',
                   '1.SKM4.640180']}
        self.assertEqual(self.analysis.samples, exp)

    def test_remove_samples_samples(self):
        self.analysis.remove_samples(samples=('1.SKD8.640184', ))
        exp = {1: ['1.SKB8.640193', '1.SKB7.640196', '1.SKM9.640192',
                   '1.SKM4.640180']}
        self.assertEqual(self.analysis.samples, exp)

    def test_remove_samples_processed_data(self):
        self.analysis.remove_samples(proc_data=(1, ))
        exp = {}
        self.assertEqual(self.analysis.samples, exp)

    def test_share(self):
        self.analysis.share(User("[email protected]"))
        self.assertEqual(self.analysis.shared_with, ["[email protected]",
                                                     "[email protected]"])

    def test_unshare(self):
        self.analysis.unshare(User("[email protected]"))
        self.assertEqual(self.analysis.shared_with, [])

    def test_get_samples(self):
        obs = self.analysis._get_samples()
        exp = {1: ['1.SKB7.640196', '1.SKB8.640193', '1.SKD8.640184',
                   '1.SKM4.640180', '1.SKM9.640192']}
        self.assertEqual(obs, exp)

# 需要导入模块: from qiita_db.analysis import Analysis [as 别名]
# 或者: from qiita_db.analysis.Analysis import remove_samples [as 别名]
    def post(self):
        user = self.current_user
        action = self.get_argument("action")
        # set required template variables
        results = {}
        meta_headers = []
        counts = {}
        fullcounts = {}
        query = ""
        searchmsg = ""
        selsamples = {}
        selproc_data = {}
        # get analysis and selected samples if exists, or create if necessary
        if action == "create":
            name = self.get_argument('name')
            description = self.get_argument('description')
            analysis = Analysis.create(user, name, description)
            analysis_id = analysis.id
            # set to second step since this page is second step in workflow
            analysis.step = SELECT_SAMPLES
            # fill example studies by running query for specific studies
            search = QiitaStudySearch()
            def_query = 'study_id = 1 OR study_id = 2 OR study_id = 3'
            results, meta_headers = search(def_query, user)
            results, counts, fullcounts = self._parse_search_results(
                results, selsamples, meta_headers)
        else:
            analysis_id = int(self.get_argument("analysis-id"))
            analysis = Analysis(analysis_id)
            check_analysis_access(user, analysis)
            selproc_data, selsamples = self._selected_parser(analysis)

        # run through action requested
        if action == "search":
            search = QiitaStudySearch()
            query = str(self.get_argument("query"))
            try:
                results, meta_headers = search(query, user)
            except ParseException:
                searchmsg = "Malformed search query, please read search help."
            except QiitaDBIncompatibleDatatypeError as e:
                searchmsg = ''.join(e)

            if not results and not searchmsg:
                searchmsg = "No results found."
            else:
                results, counts, fullcounts = self._parse_search_results(
                    results, selsamples, meta_headers)

        elif action == "select":
            analysis.add_samples(self._parse_form_select())

            # rebuild the selected from database to reflect changes
            selproc_data, selsamples = self._selected_parser(analysis)

        elif action == "deselect":
            proc_data, samples = self._parse_form_deselect()
            if proc_data:
                analysis.remove_samples(proc_data=proc_data)
            if samples:
                analysis.remove_samples(samples=samples)
            if not proc_data and not samples:
                searchmsg = "Must select samples to remove from analysis!"

            # rebuild the selected from database to reflect changes
            selproc_data, selsamples = self._selected_parser(analysis)

        self.render('search_studies.html', user=user, aid=analysis_id,
                    results=results, meta_headers=meta_headers,
                    selsamples=selsamples, selproc_data=selproc_data,
                    counts=counts, fullcounts=fullcounts, searchmsg=searchmsg,
                    query=query, availmeta=SampleTemplate.metadata_headers() +
                    get_table_cols("study"))

# 需要导入模块: from qiita_db.analysis import Analysis [as 别名]
# 或者: from qiita_db.analysis.Analysis import remove_samples [as 别名]

#.........这里部分代码省略.........
    def test_retrieve_mapping_file(self):
        exp = join(self.fp, "1_analysis_mapping.txt")
        obs = self.analysis.mapping_file
        self.assertEqual(obs, exp)
        self.assertTrue(exists(exp))

    def test_retrieve_mapping_file_none(self):
        new = Analysis.create(User("[email protected]"), "newAnalysis",
                              "A New Analysis", Analysis(1))
        obs = new.mapping_file
        self.assertEqual(obs, None)

    # def test_get_parent(self):
    #     raise NotImplementedError()

    # def test_get_children(self):
    #     raise NotImplementedError()

    def test_summary_data(self):
        obs = self.analysis.summary_data()
        exp = {'studies': 1,
               'processed_data': 1,
               'samples': 5}
        self.assertEqual(obs, exp)

    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_remove_samples_both(self):
        self.analysis.remove_samples(proc_data=(1, ),
                                     samples=('1.SKB8.640193', ))
        exp = {1: ['1.SKD8.640184', '1.SKB7.640196', '1.SKM9.640192',
                   '1.SKM4.640180']}
        self.assertEqual(self.analysis.samples, exp)

    def test_remove_samples_samples(self):
        self.analysis.remove_samples(samples=('1.SKD8.640184', ))
        exp = {1: ['1.SKB8.640193', '1.SKB7.640196', '1.SKM9.640192',
                   '1.SKM4.640180']}
        self.assertEqual(self.analysis.samples, exp)

    def test_remove_samples_processed_data(self):
        self.analysis.remove_samples(proc_data=(1, ))
        exp = {}
        self.assertEqual(self.analysis.samples, exp)

    def test_share(self):
        self.analysis.share(User("[email protected]"))
        self.assertEqual(self.analysis.shared_with, ["[email protected]",
                                                     "[email protected]"])

    def test_unshare(self):
        self.analysis.unshare(User("[email protected]"))
        self.assertEqual(self.analysis.shared_with, [])

    def test_get_samples(self):
        obs = self.analysis._get_samples()
        exp = {1: ['1.SKB7.640196', '1.SKB8.640193', '1.SKD8.640184',
                   '1.SKM4.640180', '1.SKM9.640192']}
        self.assertEqual(obs, exp)

# 需要导入模块: from qiita_db.analysis import Analysis [as 别名]
# 或者: from qiita_db.analysis.Analysis import remove_samples [as 别名]

#.........这里部分代码省略.........
                              "A New Analysis", Analysis(1))
        self.assertEqual(new.pmid, None)

    def test_set_pmid(self):
        self.analysis.pmid = "11211221212213"
        self.assertEqual(self.analysis.pmid, "11211221212213")

    def test_retrieve_mapping_file(self):
        exp = join(get_db_files_base_dir(), "analysis",
                   "1_analysis_mapping.txt")
        obs = self.analysis.mapping_file
        self.assertEqual(obs, exp)
        self.assertTrue(exists(exp))

    def test_retrieve_mapping_file_none(self):
        new = Analysis.create(User("[email protected]"), "newAnalysis",
                              "A New Analysis", Analysis(1))
        obs = new.mapping_file
        self.assertEqual(obs, None)

    # def test_get_parent(self):
    #     raise NotImplementedError()

    # def test_get_children(self):
    #     raise NotImplementedError()

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

    def test_remove_samples_both(self):
        self.analysis.remove_samples(proc_data=(1, ),
                                     samples=('SKB8.640193', ))
        exp = {1: ['SKD8.640184', 'SKB7.640196', 'SKM9.640192', 'SKM4.640180']}
        self.assertEqual(self.analysis.samples, exp)

    def test_remove_samples_samples(self):
        self.analysis.remove_samples(samples=('SKD8.640184', ))
        exp = {1: ['SKB8.640193', 'SKB7.640196', 'SKM9.640192', 'SKM4.640180']}
        self.assertEqual(self.analysis.samples, exp)

    def test_remove_samples_processed_data(self):
        self.analysis.remove_samples(proc_data=(1, ))
        exp = {}
        self.assertEqual(self.analysis.samples, exp)

    def test_share(self):
        self.analysis.share(User("[email protected]"))
        self.assertEqual(self.analysis.shared_with, ["[email protected]",
                                                     "[email protected]"])

    def test_unshare(self):
        self.analysis.unshare(User("[email protected]"))
        self.assertEqual(self.analysis.shared_with, [])

    def test_get_samples(self):
        obs = self.analysis._get_samples()
        exp = {1: ['SKB7.640196', 'SKB8.640193', 'SKD8.640184', 'SKM4.640180',
                   'SKM9.640192']}
        self.assertEqual(obs, exp)

    def test_build_mapping_file(self):
        map_fp = join(get_db_files_base_dir(), "analysis",

# 需要导入模块: from qiita_db.analysis import Analysis [as 别名]
# 或者: from qiita_db.analysis.Analysis import remove_samples [as 别名]
class TestAnalysis(TestCase):
    def setUp(self):
        self.analysis = Analysis(1)

    def test_lock_check(self):
        self.analysis.status = "public"
        with self.assertRaises(QiitaDBStatusError):
            self.analysis._lock_check(self.conn_handler)

    def test_lock_check_ok(self):
        self.analysis.status = "queued"
        self.analysis._lock_check(self.conn_handler)

    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_create_parent(self):
        new = Analysis.create(User("[email protected]"), "newAnalysis",
                              "A New Analysis", Analysis(1))
        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]])

        sql = "SELECT * FROM qiita.analysis_chain WHERE child_id = 3"
        obs = self.conn_handler.execute_fetchall(sql)
        self.assertEqual(obs, [[1, 3]])

    def test_retrieve_owner(self):
        self.assertEqual(self.analysis.owner, "[email protected]")

    def test_retrieve_name(self):
        self.assertEqual(self.analysis.name, "SomeAnalysis")

    def test_retrieve_description(self):
        self.assertEqual(self.analysis.description, "A test analysis")

    def test_set_description(self):
        self.analysis.description = "New description"
        self.assertEqual(self.analysis.description, "New description")

    def test_retrieve_samples(self):
        exp = {1: ['SKB8.640193', 'SKD8.640184', 'SKB7.640196',
                   'SKM9.640192', 'SKM4.640180']}
        self.assertEqual(self.analysis.samples, exp)

    def test_retrieve_shared_with(self):
        self.assertEqual(self.analysis.shared_with, ["[email protected]"])

    def test_retrieve_biom_tables(self):
        self.assertEqual(self.analysis.biom_tables, [7])

    def test_retrieve_biom_tables_none(self):
        new = Analysis.create(User("[email protected]"), "newAnalysis",
                              "A New Analysis", Analysis(1))
        self.assertEqual(new.biom_tables, None)

    def test_retrieve_jobs(self):
        self.assertEqual(self.analysis.jobs, [1, 2])

    def test_retrieve_jobs_none(self):
        new = Analysis.create(User("[email protected]"), "newAnalysis",
                              "A New Analysis", Analysis(1))
        self.assertEqual(new.jobs, None)

    def test_retrieve_pmid(self):
        self.assertEqual(self.analysis.pmid, "121112")

    def test_retrieve_pmid_none(self):
        new = Analysis.create(User("[email protected]"), "newAnalysis",
                              "A New Analysis", Analysis(1))
        self.assertEqual(new.pmid, None)

    def test_set_pmid(self):
        self.analysis.pmid = "11211221212213"
        self.assertEqual(self.analysis.pmid, "11211221212213")

    # def test_get_parent(self):
    #     raise NotImplementedError()

    # def test_get_children(self):
    #     raise NotImplementedError()

    def test_add_samples(self):
        new = Analysis.create(User("[email protected]"), "newAnalysis",
                              "A New Analysis")
        new.add_samples([(1, 'SKB8.640193')])

    def test_remove_samples(self):
        self.analysis.remove_samples([(1, 'SKB8.640193'), (1, 'SKD8.640184')])

    def test_add_biom_tables(self):
        new = Analysis.create(User("[email protected]"), "newAnalysis",
#.........这里部分代码省略.........