def report_resources(user, report): if all(x is not None for x in [report.wall_time, report.cpu_time, report.memory]): return { 'wall_time': HumanizedValue(report.wall_time, user=user).timedelta, 'cpu_time': HumanizedValue(report.cpu_time, user=user).timedelta, 'memory': HumanizedValue(report.memory, user=user).memory } return None
def __unsafes_data(self): unsafes_ids = list(report.pk for report in self.page) cnt = (self.page.number - 1) * self.paginator.per_page + 1 columns = ['number'] columns.extend(self.view['columns']) attributes = {} for r_id, a_name, a_value in ReportAttr.objects.filter(report_id__in=unsafes_ids).order_by('id')\ .values_list('report_id', 'name', 'value'): if a_name not in attributes: columns.append(a_name) attributes[a_name] = {} attributes[a_name][r_id] = a_value verdicts_dict = dict(UNSAFE_VERDICTS) with_confirmed = 'hidden' not in self.view or 'confirmed_marks' not in self.view['hidden'] values_data = [] for report in self.page: values_row = [] for col in columns: val = '-' href = None color = None if col in attributes: val = attributes[col].get(report.pk, '-') elif col == 'number': val = cnt href = reverse('reports:unsafe', args=[report.trace_id]) elif col == 'marks_number': if with_confirmed: val = '{0} ({1})'.format(report.cache.marks_confirmed, report.cache.marks_total) else: val = str(report.cache.marks_total) elif col == 'report_verdict': val = verdicts_dict[report.cache.verdict] color = UNSAFE_COLOR[report.cache.verdict] elif col == 'tags': if len(report.cache.tags): tags_values = [] for tag in sorted(report.cache.tags): if report.cache.tags[tag] > 1: tags_values.append('{0} ({1})'.format(tag, report.cache.tags[tag])) else: tags_values.append(tag) val = ', '.join(tags_values) elif col == 'verifiers:cpu': val = HumanizedValue(report.cpu_time, user=self.user).timedelta elif col == 'verifiers:wall': val = HumanizedValue(report.wall_time, user=self.user).timedelta elif col == 'verifiers:memory': val = HumanizedValue(report.memory, user=self.user).memory values_row.append({'value': val, 'color': color, 'href': href}) values_data.append(values_row) cnt += 1 return Header(columns, REP_MARK_TITLES).struct, values_data
def get_progress_ts(self, instance): progress = self.__calculate_progress(instance.total_ts, instance.solved_ts, instance.failed_ts) if instance.status == DECISION_STATUS[2][0]: progress = progress or _('Estimating progress') if not progress: return None value = { 'progress': progress, 'start': HumanizedValue(instance.start_ts, user=self._user).date, 'finish': HumanizedValue(instance.finish_ts, user=self._user).date, } if instance.status == DECISION_STATUS[2][0]: value['expected_time'] = self.__get_expected_time( instance.expected_time_ts, instance.gag_text_ts) return value
def marks_data(self): cnt = (self.page.number - 1) * self.paginator.per_page + 1 columns = ['checkbox', 'number'] columns.extend(self.view['columns']) # We collecting attributes from separate request to ensure the order of attributes columns is right attr_columns, attributes = self.__get_attrs() columns.extend(attr_columns) values_data = [] for mark_version in self.page: mark_id = mark_version.mark_id values_row = [] for col in columns: val = '-' href = None color = None if col == 'checkbox': values_row.append({'checkbox': mark_id}) continue elif col in attributes: val = attributes[col].get(mark_id, '-') elif col == 'number': val = cnt href = reverse('marks:{}'.format(self.mark_type), args=[mark_id]) elif col == 'num_of_links': val = mark_version.num_of_links elif col == 'tags': if mark_version.mark.cache_tags: val = ', '.join( x.split(' - ')[-1] for x in mark_version.mark.cache_tags) elif col == 'author' and mark_version.author: val = mark_version.author.get_full_name() href = reverse('users:show-profile', args=[mark_version.author_id]) elif col == 'change_date': val = mark_version.change_date if self.user.data_format == 'hum': val = HumanizedValue.get_templated_text( '{% load humanize %}{{ date|naturaltime }}', date=val) elif col == 'source': val = mark_version.mark.get_source_display() elif col == 'identifier': val = str(mark_version.mark.identifier) else: val, href, color = self.get_value(col, mark_version) values_row.append({'value': val, 'color': color, 'href': href}) values_data.append(values_row) cnt += 1 return columns, values_data
def get_progress_sj(self, instance): if instance.total_sj is None and instance.start_sj is None: # Seems like the decision doesn't have subjobs return None progress = self.__calculate_progress(instance.total_sj, instance.solved_sj, instance.failed_sj) if instance.status == DECISION_STATUS[2][0]: progress = progress or _('Estimating progress') if not progress: return None value = { 'progress': progress, 'start': HumanizedValue(instance.start_sj, user=self._user).date, 'finish': HumanizedValue(instance.finish_sj, user=self._user).date, } if instance.status == DECISION_STATUS[2][0]: value['expected_time'] = self.__get_expected_time( instance.expected_time_sj, instance.gag_text_sj) return value
def __collect_decision_data(self): prodress_data = ProgressSerializerRO( instance=self._decisions_qs, many=True, context={'user': self.view.user} ).data for progress in prodress_data: if 'total_ts' in progress: self._values_data[progress['id']]['tasks:total_ts'] = cell_value(progress['total_ts']) if 'total_sj' in progress: self._values_data[progress['id']]['subjobs:total_sj'] = cell_value(progress['total_sj']) decision_progress = {'start_date': progress['start_date'], 'finish_date': progress['finish_date']} if 'progress_ts' in progress: decision_progress['tasks:progress_ts'] = progress['progress_ts']['progress'] decision_progress['tasks:start_ts'] = progress['progress_ts']['start'] decision_progress['tasks:finish_ts'] = progress['progress_ts']['finish'] if 'expected_time' in progress['progress_ts']: decision_progress['tasks:expected_time_ts'] = progress['progress_ts']['expected_time'] if 'progress_sj' in progress: decision_progress['tasks:progress_sj'] = progress['progress_sj']['progress'] decision_progress['tasks:start_sj'] = progress['progress_sj']['start'] decision_progress['tasks:finish_sj'] = progress['progress_sj']['finish'] if 'expected_time' in progress['progress_sj']: decision_progress['tasks:expected_time_sj'] = progress['progress_sj']['expected_time'] for column, value in decision_progress.items(): self._values_data[progress['id']][column] = cell_value(value) for decision in self._decisions_qs: countable_data = { 'tasks:total': decision.tasks_total, 'tasks:cancelled': decision.tasks_cancelled, 'tasks:error': decision.tasks_error, 'tasks:finished': decision.tasks_finished, 'tasks:processing': decision.tasks_processing, 'tasks:pending': decision.tasks_pending, 'tasks:solutions': decision.solutions } for column, value in countable_data.items(): self._values_data[decision.id][column] = cell_value(value) self._values_data[decision.id]['priority'] = cell_value(decision.get_priority_display()) if decision.finish_date is not None: solution_wall = HumanizedValue( int((decision.finish_date - decision.start_date).total_seconds() * 1000), user=self.view.user ).timedelta self._values_data[decision.id]['solution_wall_time'] = cell_value(solution_wall) if decision.operator: self._values_data[decision.id]['operator'] = cell_value( decision.operator.get_full_name(), url=reverse('users:show-profile', args=[decision.operator_id]) )
def __get_info(self): resource_data = [] total_resources = {'wall_time': 0, 'cpu_time': 0, 'memory': 0} for component in sorted(self._data): component_data = { 'component': component, 'wall_time': '-', 'cpu_time': '-', 'memory': '-', 'instances': '{}/{}'.format(self._data[component]['finished'], self._data[component]['total']) } if self._data[component]['finished'] and component in self._data: component_data['wall_time'] = HumanizedValue( self._data[component]['wall_time'], user=self.user).timedelta component_data['cpu_time'] = HumanizedValue( self._data[component]['cpu_time'], user=self.user).timedelta component_data['memory'] = HumanizedValue( self._data[component]['memory'], user=self.user).memory total_resources['wall_time'] += self._data[component][ 'wall_time'] total_resources['cpu_time'] += self._data[component][ 'cpu_time'] total_resources['memory'] = max( total_resources['memory'], self._data[component]['memory']) resource_data.append(component_data) if 'hidden' not in self.view or 'resource_total' not in self.view[ 'hidden']: if total_resources['wall_time'] or total_resources[ 'cpu_time'] or total_resources['memory']: resource_data.append({ 'component': 'total', 'instances': '-', 'wall_time': HumanizedValue(total_resources['wall_time'], user=self.user).timedelta, 'cpu_time': HumanizedValue(total_resources['cpu_time'], user=self.user).timedelta, 'memory': HumanizedValue(total_resources['memory'], user=self.user).memory }) return resource_data
def __get_job_values_row(self, job): values_row = [] for col in self._values_collector.columns: if col == 'identifier': value = cell_value(str(job.identifier)) elif col == 'role': value = cell_value(self._job_roles[job.id]) elif col == 'author': author_val = author_url = None if job.author: author_val = job.author.get_full_name() author_url = reverse('users:show-profile', args=[job.author_id]) value = cell_value(author_val, url=author_url) elif col == 'creation_date': value = cell_value(HumanizedValue(job.creation_date, user=self.view.user).date) else: value = cell_value('') values_row.append(value) return values_row
def __collect_resources(self): total_resources = {} for cache_obj in DecisionCache.objects.filter(decision_id__in=self._decisions_ids).select_related('decision'): value = "{} {} {}".format( HumanizedValue(cache_obj.wall_time, user=self.view.user).timedelta, HumanizedValue(cache_obj.cpu_time, user=self.view.user).timedelta, HumanizedValue(cache_obj.memory, user=self.view.user).memory, ) column = 'resource:{}'.format(self.slugify(cache_obj.component)) self._values_data[cache_obj.decision_id][column] = cell_value(value) total_resources.setdefault(cache_obj.decision_id, [0, 0, 0]) total_resources[cache_obj.decision_id][0] += cache_obj.wall_time total_resources[cache_obj.decision_id][1] += cache_obj.cpu_time total_resources[cache_obj.decision_id][2] = max(total_resources[cache_obj.decision_id][2], cache_obj.memory) for d_id in total_resources: value = "{} {} {}".format( HumanizedValue(total_resources[d_id][0], user=self.view.user).timedelta, HumanizedValue(total_resources[d_id][1], user=self.view.user).timedelta, HumanizedValue(total_resources[d_id][2], user=self.view.user).memory, ) self._values_data[d_id]['resource:total'] = cell_value(value)
def get_finish_date(self, instance): return HumanizedValue(instance.finish_date, user=self._user).date
def get_start_date(self, instance): return HumanizedValue(instance.start_date, user=self._user).date
def __get_expected_time(self, db_value, default_text): return HumanizedValue(db_value * 1000 if db_value else None, user=self._user, default=default_text or _('Estimating time')).timedelta