merge upstream/master

Author: squirrelo

.travis.yml

@@ -16,7 +16,7 @@ install:
   - pip install coveralls
   - pip install .
 script:
-  - qiita_db make_test_env
+  - qiita_env make_test_env
   - nosetests --with-doctest
   - pep8 qiita_db qiita_core qiita_pet setup.py
   # we need to run the test suite from setup.py for coveralls to grab the info

INSTALL.md

@@ -15,6 +15,9 @@ Qiita is a python package, with support for python 2.7 and 3.2, that depends on
 * [NumPy](https://github.com/numpy/numpy)
 * [Pandas](http://pandas.pydata.org/)
 * [QIIME development version](https://github.com/biocore/qiime)
+* [future](http://python-future.org/)
+* [bcrypt](https://github.com/pyca/bcrypt/)
+* [redis](https://github.com/andymccurdy/redis-py)
 
 And on the following packages:
 
@@ -35,7 +38,7 @@ Once you have [PostgresSQL](http://www.postgresql.org/download/) and [redis](htt
 echo "export QIITA_CONFIG_FP=$QIITA_DIR/qiita_core/support_files/config_demo.txt" >> ~/.bashrc
 source ~/.bashrc
 pip install https://github.com/biocore/qiita/archive/master.zip
-qiita_db make_demo_env
+qiita_env make_demo_env
 ```
 ## If using other operating systems that are not Ubuntu
 
@@ -48,4 +51,4 @@ createuser -s postgres -d
 If you receive the following error, you can ignore this step and continue with the qiita installation:
 ```bash
 createuser: creation of new role failed: ERROR:  role "postgres" already exists
-```
+```

qiita_db/commands.py

@@ -0,0 +1,57 @@
+from functools import partial
+try:
+    # Python 2
+    from ConfigParser import ConfigParser
+except ImportError:
+    # Python 3
+    from configparser import ConfigParser
+
+from qiita_db.study import Study, StudyPerson
+from qiita_db.user import User
+
+
+def make_study_from_cmd(owner, title, info):
+
+    # Parse the configuration file
+    config = ConfigParser()
+    config.readfp(info)
+
+    optional = dict(config.items('optional'))
+    get_optional = lambda name: optional.get(name, None)
+    get_required = partial(config.get, 'required')
+    required_fields = ['timeseries_type_id', 'mixs_compliant',
+                       'number_samples_collected', 'number_samples_promised',
+                       'portal_type_id', 'reprocess', 'study_alias',
+                       'study_description', 'study_abstract',
+                       'metadata_complete']
+    optional_fields = ['funding', 'most_recent_contact', 'spatial_series',
+                       'vamps_id']
+    infodict = {}
+    for value in required_fields:
+        infodict[value] = get_required(value)
+
+    for value in optional_fields:
+        optvalue = get_optional(value)
+        if optvalue is not None:
+            infodict[value] = optvalue
+
+    emp_person_name_email = get_optional('emp_person_name')
+    if emp_person_name_email is not None:
+        emp_name, emp_email = emp_person_name_email.split(',')
+        infodict['emp_person_id'] = StudyPerson.create(emp_name.strip(),
+                                                       emp_email.strip())
+    lab_name_email = get_optional('lab_person')
+    if lab_name_email is not None:
+        lab_name, lab_email = lab_name_email.split(',')
+        infodict['lab_person_id'] = StudyPerson.create(lab_name.strip(),
+                                                       lab_email.strip())
+    pi_name_email = get_required('principal_investigator')
+    pi_name, pi_email = pi_name_email.split(',')
+    infodict['principal_investigator_id'] = StudyPerson.create(
+        pi_name.strip(), pi_email.strip())
+    # this will eventually change to using the Experimental Factory Ontolgoy
+    # names
+    efo_ids = get_required('efo_ids')
+    efo_ids = [x.strip() for x in efo_ids.split(',')]
+
+    Study.create(User(owner), title, efo_ids, infodict)

qiita_db/job.py

@@ -97,10 +97,11 @@ def create(cls, datatype, command, options, analysis):
         Job object
             The newly created job
         """
-        if cls.exists(datatype, command, options):
-            raise QiitaDBDuplicateError(
-                "Job", "datatype: %s, command: %s, options: %s"
-                % (datatype, command, options))
+        # IGNORING EXISTS FOR DEMO
+        # if cls.exists(datatype, command, options):
+        #     raise QiitaDBDuplicateError(
+        #         "Job", "datatype: %s, command: %s, options: %s"
+        #         % (datatype, command, options))
 
         # Get the datatype and command ids from the strings
         conn_handler = SQLConnectionHandler()
@@ -114,8 +115,8 @@ def create(cls, datatype, command, options, analysis):
         sql = ("INSERT INTO qiita.{0} (data_type_id, job_status_id, "
                "command_id, options) VALUES "
                "(%s, %s, %s, %s) RETURNING job_id").format(cls._table)
-        job_id = conn_handler.execute_fetchone(sql, (datatype_id, command_id,
-                                               1, opts_json))[0]
+        job_id = conn_handler.execute_fetchone(sql, (datatype_id, 1,
+                                               command_id, opts_json))[0]
 
         # add job to analysis
         sql = ("INSERT INTO qiita.analysis_job (analysis_id, job_id) VALUES "

qiita_db/study.py

@@ -551,22 +551,21 @@ def create(cls, name, email, address=None, phone=None):
         -------
         New StudyPerson object
 
-        Raises
-        ------
-        QiitaDBDuplicateError
-            Person already exists
         """
         if cls.exists(name, email):
-            raise QiitaDBDuplicateError(
-                "StudyPerson", "name: %s, email: %s" % (name, email))
+            sql = ("SELECT study_person_id from qiita.{0} WHERE name = %s and"
+                   " email = %s".format(cls._table))
+            conn_handler = SQLConnectionHandler()
+            spid = conn_handler.execute_fetchone(sql, (name, email))
 
         # Doesn't exist so insert new person
-        sql = ("INSERT INTO qiita.{0} (name, email, address, phone) VALUES"
-               " (%s, %s, %s, %s) RETURNING "
-               "study_person_id".format(cls._table))
-        conn_handler = SQLConnectionHandler()
-        spid = conn_handler.execute_fetchone(sql, (name, email, address,
-                                                   phone))
+        else:
+            sql = ("INSERT INTO qiita.{0} (name, email, address, phone) VALUES"
+                   " (%s, %s, %s, %s) RETURNING "
+                   "study_person_id".format(cls._table))
+            conn_handler = SQLConnectionHandler()
+            spid = conn_handler.execute_fetchone(sql, (name, email, address,
+                                                       phone))
         return cls(spid[0])
 
     # Properties

qiita_db/test/test_commands.py

@@ -0,0 +1,76 @@
+from unittest import TestCase, main
+from future.utils.six import StringIO
+try:
+    # Python 2
+    from ConfigParser import NoOptionError
+except ImportError:
+    # Python 3
+    from configparser import NoOptionError
+
+from qiita_db.commands import make_study_from_cmd
+from qiita_db.study import StudyPerson
+from qiita_db.user import User
+from qiita_core.util import qiita_test_checker
+
+
+@qiita_test_checker()
+class TestMakeStudyFromCmd(TestCase):
+    def setUp(self):
+        StudyPerson.create('SomeDude', 'somedude@foo.bar',
+                           '111 fake street', '111-121-1313')
+        User.create('test@test.com', 'password')
+        self.config1 = CONFIG_1
+        self.config2 = CONFIG_2
+
+    def test_make_study_from_cmd(self):
+        fh = StringIO(self.config1)
+        make_study_from_cmd('test@test.com', 'newstudy', fh)
+        sql = ("select study_id from qiita.study where email = %s and "
+               "study_title = %s")
+        study_id = self.conn_handler.execute_fetchone(sql, ('test@test.com',
+                                                            'newstudy'))
+        self.assertTrue(study_id is not None)
+
+        fh2 = StringIO(self.config2)
+        with self.assertRaises(NoOptionError):
+            make_study_from_cmd('test@test.com', 'newstudy2', fh2)
+
+CONFIG_1 = """[required]
+timeseries_type_id = 1
+metadata_complete = True
+mixs_compliant = True
+number_samples_collected = 50
+number_samples_promised = 25
+portal_type_id = 3
+principal_investigator = SomeDude, somedude@foo.bar
+reprocess = False
+study_alias = 'test study'
+study_description = 'test study description'
+study_abstract = 'study abstract'
+efo_ids = 1,2,3,4
+[optional]
+lab_person = SomeDude, somedude@foo.bar
+funding = 'funding source'
+vamps_id = vamps_id
+"""
+
+CONFIG_2 = """[required]
+timeseries_type_id = 1
+metadata_complete = True
+number_samples_collected = 50
+number_samples_promised = 25
+portal_type_id = 3
+principal_investigator = SomeDude, somedude@foo.bar
+reprocess = False
+study_alias = 'test study'
+study_description = 'test study description'
+study_abstract = 'study abstract'
+efo_ids = 1,2,3,4
+[optional]
+lab_person = SomeDude, somedude@foo.bar
+funding = 'funding source'
+vamps_id = vamps_id
+"""
+
+if __name__ == "__main__":
+    main()

qiita_db/test/test_job.py

@@ -52,13 +52,14 @@ def test_exists_not_there(self):
 
     def test_create(self):
         """Makes sure creation works as expected"""
-        new = Job.create("18S", "Beta Diversity",
+        # make first job
+        new = Job.create("18S", "Alpha Diversity",
                          self.options, Analysis(1))
         self.assertEqual(new.id, 4)
         # make sure job inserted correctly
         obs = self.conn_handler.execute_fetchall("SELECT * FROM qiita.job "
                                                  "WHERE job_id = 4")
-        exp = [[4, 2, 2, 1, '{"option1":false,"option2":25,"option3":"NEW"}',
+        exp = [[4, 2, 1, 3, '{"option1":false,"option2":25,"option3":"NEW"}',
                 None]]
         self.assertEqual(obs, exp)
         # make sure job added to analysis correctly
@@ -68,12 +69,29 @@ def test_create(self):
         exp = [[1, 4]]
         self.assertEqual(obs, exp)
 
-    def test_create_exists(self):
-        """Makes sure creation doesn't duplicate a job"""
-        with self.assertRaises(QiitaDBDuplicateError):
-            Job.create("16S", "Summarize Taxa",
-                       {'option1': True, 'option2': 12, 'option3': 'FCM'},
-                       Analysis(1))
+        # make second job with diff datatype and command to test column insert
+        new = Job.create("16S", "Beta Diversity",
+                         self.options, Analysis(1))
+        self.assertEqual(new.id, 5)
+        # make sure job inserted correctly
+        obs = self.conn_handler.execute_fetchall("SELECT * FROM qiita.job "
+                                                 "WHERE job_id = 5")
+        exp = [[5, 1, 1, 2, '{"option1":false,"option2":25,"option3":"NEW"}',
+                None]]
+        self.assertEqual(obs, exp)
+        # make sure job added to analysis correctly
+        obs = self.conn_handler.execute_fetchall("SELECT * FROM "
+                                                 "qiita.analysis_job WHERE "
+                                                 "job_id = 5")
+        exp = [[1, 5]]
+        self.assertEqual(obs, exp)
+
+    # def test_create_exists(self):
+    #     """Makes sure creation doesn't duplicate a job"""
+    #     with self.assertRaises(QiitaDBDuplicateError):
+    #         Job.create("16S", "Summarize Taxa",
+    #                    {'option1': True, 'option2': 12, 'option3': 'FCM'},
+    #                    Analysis(1))
 
     def test_retrieve_datatype(self):
         """Makes sure datatype retriveal is correct"""

qiita_db/test/test_study.py

@@ -9,8 +9,7 @@
 from qiita_db.study import Study, StudyPerson
 from qiita_db.investigation import Investigation
 from qiita_db.user import User
-from qiita_db.exceptions import (QiitaDBDuplicateError, QiitaDBColumnError,
-                                 QiitaDBStatusError)
+from qiita_db.exceptions import QiitaDBColumnError, QiitaDBStatusError
 
 # -----------------------------------------------------------------------------
 # Copyright (c) 2014--, The Qiita Development Team.
@@ -36,8 +35,9 @@ def test_create_studyperson(self):
                          '111 fake street', '111-121-1313']])
 
     def test_create_studyperson_already_exists(self):
-        with self.assertRaises(QiitaDBDuplicateError):
-            StudyPerson.create('LabDude', 'lab_dude@foo.bar')
+        obs = StudyPerson.create('LabDude', 'lab_dude@foo.bar')
+        self.assertEqual(obs.name, 'LabDude')
+        self.assertEqual(obs.email, 'lab_dude@foo.bar')
 
     def test_retrieve_name(self):
         self.assertEqual(self.studyperson.name, 'LabDude')