| 
				
			 | 
			
			
				@@ -226,12 +226,14 @@ def search(query, request, selected_engines): 
			 | 
		
	
		
			
			| 
				226
			 | 
			
				226
			 | 
			
			
				     return results, suggestions 
			 | 
		
	
		
			
			| 
				227
			 | 
			
				227
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				228
			 | 
			
				228
			 | 
			
			
				 def get_engines_stats(): 
			 | 
		
	
		
			
			| 
				
			 | 
			
				229
			 | 
			
			
				+    # TODO refactor 
			 | 
		
	
		
			
			| 
				229
			 | 
			
				230
			 | 
			
			
				     pageloads = [] 
			 | 
		
	
		
			
			| 
				230
			 | 
			
				231
			 | 
			
			
				     results = [] 
			 | 
		
	
		
			
			| 
				231
			 | 
			
				232
			 | 
			
			
				     scores = [] 
			 | 
		
	
		
			
			| 
				232
			 | 
			
				233
			 | 
			
			
				     errors = [] 
			 | 
		
	
		
			
			| 
				
			 | 
			
				234
			 | 
			
			
				+    scores_per_result = [] 
			 | 
		
	
		
			
			| 
				233
			 | 
			
				235
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				234
			 | 
			
				
			 | 
			
			
				-    max_pageload = max_results = max_score = max_errors = 0 
			 | 
		
	
		
			
			| 
				
			 | 
			
				236
			 | 
			
			
				+    max_pageload = max_results = max_score = max_errors = max_score_per_result = 0 
			 | 
		
	
		
			
			| 
				235
			 | 
			
				237
			 | 
			
			
				     for engine in engines.values(): 
			 | 
		
	
		
			
			| 
				236
			 | 
			
				238
			 | 
			
			
				         if engine.stats['search_count'] == 0: 
			 | 
		
	
		
			
			| 
				237
			 | 
			
				239
			 | 
			
			
				             continue 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -239,16 +241,19 @@ def get_engines_stats(): 
			 | 
		
	
		
			
			| 
				239
			 | 
			
				241
			 | 
			
			
				         load_times  = engine.stats['page_load_time']/float(engine.stats['search_count']) 
			 | 
		
	
		
			
			| 
				240
			 | 
			
				242
			 | 
			
			
				         if results_num: 
			 | 
		
	
		
			
			| 
				241
			 | 
			
				243
			 | 
			
			
				             score = engine.stats['score_count'] / float(engine.stats['search_count']) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				244
			 | 
			
			
				+            score_per_result = score / results_num 
			 | 
		
	
		
			
			| 
				242
			 | 
			
				245
			 | 
			
			
				         else: 
			 | 
		
	
		
			
			| 
				243
			 | 
			
				
			 | 
			
			
				-            score = 0 
			 | 
		
	
		
			
			| 
				
			 | 
			
				246
			 | 
			
			
				+            score = score_per_result = 0.0 
			 | 
		
	
		
			
			| 
				244
			 | 
			
				247
			 | 
			
			
				         max_results = max(results_num, max_results) 
			 | 
		
	
		
			
			| 
				245
			 | 
			
				248
			 | 
			
			
				         max_pageload = max(load_times, max_pageload) 
			 | 
		
	
		
			
			| 
				246
			 | 
			
				249
			 | 
			
			
				         max_score = max(score, max_score) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				250
			 | 
			
			
				+        max_score_per_result = max(score_per_result, max_score_per_result) 
			 | 
		
	
		
			
			| 
				247
			 | 
			
				251
			 | 
			
			
				         max_errors = max(max_errors, engine.stats['errors']) 
			 | 
		
	
		
			
			| 
				248
			 | 
			
				252
			 | 
			
			
				         pageloads.append({'avg': load_times, 'name': engine.name}) 
			 | 
		
	
		
			
			| 
				249
			 | 
			
				253
			 | 
			
			
				         results.append({'avg': results_num, 'name': engine.name}) 
			 | 
		
	
		
			
			| 
				250
			 | 
			
				254
			 | 
			
			
				         scores.append({'avg': score, 'name': engine.name}) 
			 | 
		
	
		
			
			| 
				251
			 | 
			
				255
			 | 
			
			
				         errors.append({'avg': engine.stats['errors'], 'name': engine.name}) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				256
			 | 
			
			
				+        scores_per_result.append({'avg': score_per_result, 'name': engine.name}) 
			 | 
		
	
		
			
			| 
				252
			 | 
			
				257
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				253
			 | 
			
				258
			 | 
			
			
				     for engine in pageloads: 
			 | 
		
	
		
			
			| 
				254
			 | 
			
				259
			 | 
			
			
				         engine['percentage'] = int(engine['avg']/max_pageload*100) 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -259,6 +264,9 @@ def get_engines_stats(): 
			 | 
		
	
		
			
			| 
				259
			 | 
			
				264
			 | 
			
			
				     for engine in scores: 
			 | 
		
	
		
			
			| 
				260
			 | 
			
				265
			 | 
			
			
				         engine['percentage'] = int(engine['avg']/max_score*100) 
			 | 
		
	
		
			
			| 
				261
			 | 
			
				266
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				
			 | 
			
				267
			 | 
			
			
				+    for engine in scores_per_result: 
			 | 
		
	
		
			
			| 
				
			 | 
			
				268
			 | 
			
			
				+        engine['percentage'] = int(engine['avg']/max_score_per_result*100) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				269
			 | 
			
			
				+ 
			 | 
		
	
		
			
			| 
				262
			 | 
			
				270
			 | 
			
			
				     for engine in errors: 
			 | 
		
	
		
			
			| 
				263
			 | 
			
				271
			 | 
			
			
				         if max_errors: 
			 | 
		
	
		
			
			| 
				264
			 | 
			
				272
			 | 
			
			
				             engine['percentage'] = int(float(engine['avg'])/max_errors*100) 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -269,5 +277,6 @@ def get_engines_stats(): 
			 | 
		
	
		
			
			| 
				269
			 | 
			
				277
			 | 
			
			
				     return [('Page loads (sec)', sorted(pageloads, key=itemgetter('avg'))) 
			 | 
		
	
		
			
			| 
				270
			 | 
			
				278
			 | 
			
			
				            ,('Number of results', sorted(results, key=itemgetter('avg'), reverse=True)) 
			 | 
		
	
		
			
			| 
				271
			 | 
			
				279
			 | 
			
			
				            ,('Scores', sorted(scores, key=itemgetter('avg'), reverse=True)) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				280
			 | 
			
			
				+           ,('Scores per result', sorted(scores_per_result, key=itemgetter('avg'), reverse=True)) 
			 | 
		
	
		
			
			| 
				272
			 | 
			
				281
			 | 
			
			
				            ,('Errors', sorted(errors, key=itemgetter('avg'), reverse=True)) 
			 | 
		
	
		
			
			| 
				273
			 | 
			
				282
			 | 
			
			
				            ] 
			 |