API update for timestamp and version showing

Author: dignityc

functions.py

@@ -111,39 +111,47 @@ def CheckItemStatus(target_id):
         return [{'qid': target_id, 'status': 'Not processed yet'}]
 
 
-#1.2. calculate the reference healthy value for an item
+#1.2. calculate the reference score for an item
 #Examples = Q5820 : error/ Q5208 : good/ Q42220 : None.
 def comprehensive_results(target_id):
     response = GetItem(target_id)
     if isinstance(response, list) and len(response) > 0:
         first_item = response[0]
         if isinstance(first_item, dict):
             if 'error' in first_item:
-                return {'Reference score': 'Not processed yet', 
+                return {'Reference_score': 'Not processed yet', 
                         'NOT ENOUGH INFO': 'Not processed yet',
                         'SUPPORTS': 'Not processed yet',
-                        'REFUTES': 'Not processed yet'
+                        'REFUTES': 'Not processed yet',
+                        'algo_version': first_item['algo_version'],
+                        'Requested_time': first_item['start_time']
                         }
             elif 'status' in first_item and first_item['status'] == 'error':
-                return {'Reference score': 'processing error', 
+                return {'Reference_score': 'processing error', 
                         'NOT ENOUGH INFO': 'processing error',
                         'SUPPORTS': 'processing error',
-                        'REFUTES': 'processing error'
+                        'REFUTES': 'processing error',
+                        'algo_version': first_item['algo_version'],
+                        'Requested_time': first_item['start_time']
                         }
             elif response[1].get('Result') == 'No available URLs':
-                return {'Reference score': 'No external URLs', 
+                return {'Reference_score': 'No external URLs', 
                         'NOT ENOUGH INFO': 'No external URLs',
                         'SUPPORTS': 'No external URLs',
-                        'REFUTES': 'No external URLs'
+                        'REFUTES': 'No external URLs',
+                        'algo_version': first_item['algo_version'],
+                        'Requested_time': first_item['start_time']
                         }
             else:
                 details =  pd.DataFrame(response[1:])
                 chekck_value_counts = details['result'].value_counts() 
                 health_value = (chekck_value_counts.get('SUPPORTS', 0) - chekck_value_counts.get('REFUTES', 0)) / chekck_value_counts.sum()
-                return {'Reference score': health_value, 
+                return {'Reference_score': health_value, 
                         'REFUTES': details[details['result']=='REFUTES'].to_dict(), 
                         'NOT ENOUGH INFO': details[details['result']=='NOT ENOUGH INFO'].to_dict(),
-                        'SUPPORTS': details[details['result']=='SUPPORTS'].to_dict()
+                        'SUPPORTS': details[details['result']=='SUPPORTS'].to_dict(),
+                        'algo_version': first_item['algo_version'],
+                        'Requested_time': first_item['start_time']
                         }
 
 

reference_checking.py

@@ -212,7 +212,7 @@ def limit_sentence_length(sentence: str, max_length: int) -> str:
         return sentence_relevance_df
 
     def textEntailment(self, evidence_df):
-        SCORE_THRESHOLD=self.config['evidence_selection']['score_threshold']
+        SCORE_THRESHOLD = self.config['evidence_selection']['score_threshold']
         textual_entailment_df = evidence_df.copy()
         te_module = TextualEntailmentModule()
 
@@ -234,9 +234,9 @@ def process_row(row):
                 # checking the empty evidence or the error in the evidence
                 if evidence_size == 0 or any('Error: HTTP status code' in e['sentence'] for e in evidence):
                     results[key] = {
-                        'evidence_TE_prob': [],
-                        'evidence_TE_labels': ['REFUTES'] * evidence_size,
-                        'evidence_TE_prob_weighted': [],
+                        'evidence_TE_prob': [[0, 1, 0]], 
+                        'evidence_TE_labels': ['REFUTES'],
+                        'evidence_TE_prob_weighted': [[0, 1, 0]], 
                         'claim_TE_prob_weighted_sum': [0, 1, 0],
                         'claim_TE_label_weighted_sum': 'REFUTES',
                         'claim_TE_label_malon': 'REFUTES'
@@ -255,23 +255,25 @@ def process_row(row):
                     if ev['score'] > SCORE_THRESHOLD
                 ]
 
-                claim_TE_prob_weighted_sum = np.sum(evidence_TE_prob_weighted, axis=0) if evidence_TE_prob_weighted else [0, 0, 0]
+                if not evidence_TE_prob_weighted:
+                    evidence_TE_prob_weighted = [[0, 1, 0]]  
 
-                claim_TE_label_weighted_sum = te_module.get_label_from_scores(claim_TE_prob_weighted_sum) if evidence_TE_prob_weighted else 'NOT ENOUGH INFO'
+                claim_TE_prob_weighted_sum = np.sum(evidence_TE_prob_weighted, axis=0)
 
-                claim_TE_label_malon = te_module.get_label_malon(
-                    [probs for probs, ev in zip(evidence_TE_prob, evidence) if ev['score'] > SCORE_THRESHOLD]
-                )
+                claim_TE_label_weighted_sum = te_module.get_label_from_scores(claim_TE_prob_weighted_sum)
+
+                claim_TE_label_malon = te_module.get_label_malon(evidence_TE_prob)
 
                 results[key] = {
                     'evidence_TE_prob': evidence_TE_prob,
                     'evidence_TE_labels': evidence_TE_labels,
                     'evidence_TE_prob_weighted': evidence_TE_prob_weighted,
-                    'claim_TE_prob_weighted_sum': claim_TE_prob_weighted_sum,
+                    'claim_TE_prob_weighted_sum': claim_TE_prob_weighted_sum.tolist(),
                     'claim_TE_label_weighted_sum': claim_TE_label_weighted_sum,
                     'claim_TE_label_malon': claim_TE_label_malon
                 }
             return results
+
         for i, row in tqdm(textual_entailment_df.iterrows(), total=textual_entailment_df.shape[0]):
             result_sets = process_row(row)
             for key in keys:
@@ -374,7 +376,10 @@ def TableMaking(self, verbalised_claims_df_final, result):
             aResult = pd.DataFrame(row['nlp_sentences_TOP_N'])[['sentence','score']]
             aResult.rename(columns={'score': 'Relevance_score'}, inplace=True)
             aResult = pd.concat([aResult, pd.DataFrame(row["evidence_TE_labels_all_TOP_N"], columns=['TextEntailment'])], axis=1)
-            aResult = pd.concat([aResult, pd.DataFrame(np.max(row["evidence_TE_prob_all_TOP_N"], axis=1), columns=['Entailment_score'])], axis=1)
+            
+            entailment_scores = [max(prob) for prob in row["evidence_TE_prob_all_TOP_N"]]
+            
+            aResult = pd.concat([aResult, pd.DataFrame(entailment_scores, columns=['Entailment_score'])], axis=1)
             aResult = aResult.reindex(columns=['sentence', 'TextEntailment', 'Entailment_score','Relevance_score'])
             aBox = pd.DataFrame({'triple': [row["triple"]], 'property_id' : row['property_id'], 'url': row['url'],'Results': [aResult]})
             all_result = pd.concat([all_result,aBox], axis=0)