fix-query-filter

src/grdb/database/models/raman_file.py

@@ -5,7 +5,9 @@
 from grdb.database import Base
 
 from urllib.request import urlopen
-
+import ssl
+import certifi
+from grdb.server.app import s3
 
 class RamanFile(Base):
     """[summary]
@@ -77,7 +79,11 @@ def read_file(self):
         """
         Fetch the raman file from the url and returns the file in json encodable form
         """
-        file = urlopen(self.url)
+        if(self.url is None):
+            self.url = s3.create_presigned_url(self.s3_object_name)
+            print(self.url,flush=True)
+        context = ssl.create_default_context(cafile=certifi.where())
+        file = urlopen(self.url,context=context)
         data = []
         for line in file:
             line = line.decode('utf-8').split()

src/grdb/database/models/recipe.py

@@ -58,7 +58,7 @@ def maximum_temperature(self):
                 p.furnace_temperature
                 for p in self.preparation_steps
                 if p.furnace_temperature != None
-            ]
+            ], default = None
         )
 
     @maximum_temperature.expression
@@ -78,7 +78,7 @@ def maximum_pressure(self):
                 p.furnace_pressure
                 for p in self.preparation_steps
                 if p.furnace_pressure != None
-            ]
+            ], default = None
         )
 
     @maximum_pressure.expression
@@ -98,7 +98,7 @@ def average_carbon_flow_rate(self):
             for p in self.preparation_steps
             if p.carbon_source_flow_rate != None
         ]
-        return sum(steps) / len(steps)
+        return sum(steps) / len(steps) 
 
     @average_carbon_flow_rate.expression
     def average_carbon_flow_rate(cls):
@@ -110,6 +110,62 @@ def average_carbon_flow_rate(cls):
                 .label("average_carbon_flow_rate")
         )
 
+    @hybrid_property
+    def max_flow_rate(self):
+        steps = [
+            (p.hydrogen_flow_rate or 0)+(p.helium_flow_rate or 0)+(p.argon_flow_rate or 0)
+            for p in self.preparation_steps
+        ]
+        return max(steps, default = None)
+
+    @max_flow_rate.expression
+    def max_flow_rate(cls):
+        PreparationStep = class_registry["PreparationStep"]
+        return (
+            select([func.max((PreparationStep.hydrogen_flow_rate or 0)+(PreparationStep.helium_flow_rate or 0)+(PreparationStep.argon_flow_rate or 0))])
+                .where(PreparationStep.recipe_id == cls.id)
+                .correlate(cls)
+                .label("max_flow_rate")
+        )
+
+    @hybrid_property
+    def growth_duration(self):
+        steps = [
+            p.duration
+            for p in self.preparation_steps
+                if p.name == "Growing" and p.duration!=None
+        ]
+        return max(steps, default = None)
+
+    @growth_duration.expression
+    def growth_duration(cls):
+        PreparationStep = class_registry["PreparationStep"]
+        return (
+            select([func.max(PreparationStep.duration)])
+                .where(PreparationStep.recipe_id == cls.id and PreparationStep.name == "Growing")
+                .correlate(cls)
+                .label("growth_duration")
+        )
+
+    @hybrid_property
+    def carbon_source_flow_rate(self):
+        steps = [
+            p.carbon_source_flow_rate
+            for p in self.preparation_steps
+            if p.name == "Growing" and p.carbon_source_flow_rate != None
+        ]
+        return max(steps, default = None)
+
+    @carbon_source_flow_rate.expression
+    def carbon_source_flow_rate(cls):
+        PreparationStep = class_registry["PreparationStep"]
+        return (
+            select([func.avg(PreparationStep.carbon_source_flow_rate)])
+                .where(PreparationStep.recipe_id == cls.id and PreparationStep.name == "Growing")
+                .correlate(cls)
+                .label("carbon_source_flow_rate")
+        )
+
     # NOTE: This is really the carbon source from the first step.
     # Should there be a contraint that the carbon source is the same for all steps??
     # @hybrid_property
@@ -195,10 +251,18 @@ def uses_hydrogen(cls):
         return exists(s)
 
     def json_encodable(self):
+        # check if necessary
         params = [
             "carbon_source",
             "base_pressure",
-        ]
+            "maximum_temperature",
+            "maximum_pressure",
+            "max_flow_rate",
+            "growth_duration",
+            "carbon_source_flow_rate",
+            "uses_helium",
+            "uses_argon"
+        ] 
         json_dict = {'id': self.id}
         for p in params:
             info = getattr(Recipe, p).info

src/grdb/database/models/substrate.py

@@ -37,7 +37,7 @@ class Substrate(Base):
         String(16),
         info={
             "verbose_name": "Catalyst",
-            "choices": ["Copper", "Palladium", ,"Palladium leaf", "Platinum", "Other"],
+            "choices": ["Copper", "Palladium", "Palladium leaf", "Platinum", "Other"],
             "required": True,
         },
     )
@@ -97,4 +97,4 @@ def json_encodable(self):
                 "value": getattr(self, p),
                 "unit": info["std_unit"] if "std_unit" in info else None,
             }
-        return json_dict
+        return json_dict

src/grdb/server/app/s3/__init__.py

@@ -66,4 +66,4 @@ def is_sem_file(filename):
 
 
 def is_raman_file(filename):
-    return len(filename) >= 5 and filename[:3] == 'raman'
+    return len(filename) >= 5 and filename[:5] == 'raman'

src/grdb/server/app/views/authors.py

@@ -13,6 +13,12 @@
 authors = Blueprint('authors', __name__, url_prefix='/authors')
 CORS(authors)
 
+@authors.route('/<int:id>', methods=['GET'])
+def get_author_id(id):
+    db = read_db.Session()
+    author = db.query(Author).filter_by(id=id).first()
+    db.close()
+    return jsonify(author.json_encodable())
 
 @authors.route('', methods=['GET'])
 def get_author():

src/grdb/server/app/views/experiments.py

@@ -42,6 +42,13 @@ def tool_init():
 
     authors = db.query(Author).order_by(Author.id.desc()).all()
     authors_json = [a.json_encodable() for a in authors]
+
+    catalyst = db.query(Substrate.catalyst).order_by(Substrate.catalyst).distinct()
+    catalyst_list = [c for c in catalyst]
+
+    carbon_source = db.query(Recipe.carbon_source).order_by(Recipe.carbon_source).distinct()
+    carbon_source_list = [c for c in carbon_source if c[0]!=None and c[0]!='']
+
     db.close()
     return {
         'environment_conditions': env_conditions_json,
@@ -50,6 +57,8 @@ def tool_init():
         'recipes': recipes_json,
         'substrates': substrates_json,
         'authors': authors_json,
+        'catalyst': catalyst_list,
+        'carbon_source': carbon_source_list
     }
 
 
@@ -62,9 +71,8 @@ def submit_experiment():
 
     try:
         if data.get('useCustomEnvironmentConditions'):
-            ambient_temperature = data.get('useCustomEnvironmentConditions') \
-                if data.get('useCustomEnvironmentConditions') else None
-            dew_point = data.get('ambientTemperature') if data.get('ambientTemperature') else None
+            ambient_temperature = data.get('ambientTemperature') if data.get('ambientTemperature') else None
+            dew_point = data.get('dewPoint') if data.get('dewPoint') else None
             env_con = EnvironmentConditions(dew_point=dew_point,
                                             ambient_temperature=ambient_temperature)
             db.add(env_con)
@@ -186,9 +194,14 @@ def submit_experiment():
         i = 1
         for filename, file in uploaded_files.items():
             object_name = s3.generate_object_name(filename, i)
-            sem_file = SemFile(s3_object_name=object_name)
-            db.add(sem_file)
-            sem_file.experiment = experiment
+            if object_name.startswith('sem/'):
+                sem_file = SemFile(s3_object_name=object_name)
+                db.add(sem_file)
+                sem_file.experiment = experiment
+            elif object_name.startswith('raman/'):
+                raman_file = RamanFile(s3_object_name=object_name)
+                db.add(raman_file)
+                raman_file.experiment = experiment
             s3.upload_file(file, object_name)
             i += 1
         db.commit()
@@ -218,6 +231,8 @@ def get_experiment(experiment_id):
     for sem_file in sem_files:
         if sem_file.s3_object_name:
             sem_file_urls.append(s3.create_presigned_url(sem_file.s3_object_name))
+        else:
+            sem_file_urls.append(sem_file.url)
 
     db.close()
     data = {
@@ -244,12 +259,12 @@ def query_experiments():
             author_filters.append(filt)
         elif category == 'property':
             property_filters.append(filt)
-        elif category == 'environmentalCondition':
+        elif category == 'environmentCondition':
             environmental_condition_filters.append(filt)
         elif category == 'furnace':
             furnace_filters.append(filt)
-        # elif category == 'recipe': TODO: how to filter recipe?
-        #     recipe_filters.append(filt)
+        elif category == 'recipe': # TODO: how to filter recipe?
+            recipe_filters.append(filt)
         elif category == 'substrate':
             substrate_filters.append(filt)
 
@@ -350,6 +365,66 @@ def extract_first_elem(x):
 
         exp_ids_satisfying_property_filters = extract_first_elem(query.all())
         exp_ids.intersection_update(exp_ids_satisfying_property_filters)
+
+    '''    QUERYING ENVIRONMENT CONDITIONS FILTERS    '''
+    if environmental_condition_filters:
+        query = db.query(Experiment.id).join(EnvironmentConditions)
+        for environmental_condition_filter in environmental_condition_filters:
+            filter_name = environmental_condition_filter['name']
+            if 'Dew Point' in filter_name:
+                query = query \
+                    .filter(and_(EnvironmentConditions.dew_point, EnvironmentConditions.dew_point >= environmental_condition_filter['min'],
+                                 EnvironmentConditions.dew_point <= environmental_condition_filter['max']))
+            elif 'Ambient Temperature' in filter_name:
+                query = query \
+                    .filter(and_(EnvironmentConditions.ambient_temperature, EnvironmentConditions.ambient_temperature >= environmental_condition_filter['min'],
+                                 EnvironmentConditions.ambient_temperature <= environmental_condition_filter['max']))
+        exp_ids_satisfying_environmental_condition_filters = extract_first_elem(query.all())
+        exp_ids.intersection_update(exp_ids_satisfying_environmental_condition_filters)    
+
+    '''    QUERYING RECIPE FILTERS    '''
+    if recipe_filters:
+        query = db.query(Experiment.id).join(Recipe)
+        for recipe_filter in recipe_filters:
+            filter_name = recipe_filter['name']
+            if filter_name == 'Carbon Source' :
+                query = query \
+                    .filter(Recipe.carbon_source == recipe_filter['value'])
+            elif 'Base Pressure' in filter_name:
+                query = query \
+                    .filter(and_(Recipe.base_pressure >= recipe_filter['min'],
+                                 Recipe.base_pressure <= recipe_filter['max']))
+            elif 'Inert Gas' in filter_name:
+                if 'Argon' in recipe_filter['value']:
+                    query = query \
+                        .filter(Recipe.uses_argon == True)
+                elif 'Helium' in recipe_filter['value']:
+                    query = query \
+                        .filter(Recipe.uses_helium == True)
+            elif 'Maximum Temperature' in filter_name:
+                query = query \
+                    .filter(and_(Recipe.maximum_temperature >= recipe_filter['min'],
+                                 Recipe.maximum_temperature <= recipe_filter['max']))
+            elif 'Maximum Pressure' in filter_name:
+                query = query \
+                    .filter(and_(Recipe.maximum_pressure >= recipe_filter['min'],
+                                 Recipe.maximum_pressure <= recipe_filter['max']))
+            elif 'Max Flow Rate' in filter_name:
+                query = query \
+                    .filter(and_(Recipe.max_flow_rate >= recipe_filter['min'],
+                                 Recipe.max_flow_rate <= recipe_filter['max']))
+            elif 'Growth Duration' in filter_name:
+                query = query \
+                    .filter(and_(Recipe.growth_duration >= recipe_filter['min'],
+                                 Recipe.growth_duration <= recipe_filter['max']))
+            elif 'Carbon Source Flow Rate' in filter_name:
+                query = query \
+                    .filter(and_(Recipe.carbon_source_flow_rate >= recipe_filter['min'],
+                                 Recipe.carbon_source_flow_rate <= recipe_filter['max']))
+        #for row in query.all():
+        #    print(row)
+        exp_ids_satisfying_recipe_filters = extract_first_elem(query.all())
+        exp_ids.intersection_update(exp_ids_satisfying_recipe_filters)
 
     db.close()
     res = db.query(Experiment).filter(Experiment.id.in_(exp_ids)).all()