def my_view_testpage(request): redmine_users = MenRedmine.user.all() users = [] if False: for user in list(redmine_users.values()): users.append(user['firstname']) Fehlerursachen = [ {'name': x["value"], 'farbe':Fehlerursachenfarben[x["value"][0:2]], 'gewicht': Gewichte[x["value"][0:4]]} for x in MenRedmine.custom_field.get(5).possible_values ] FehlerursachenGruppen = [ {'txt': 'Information und Vorgehen', 'name': 'FehlerGruppe_Information_und_Vorgehen', 'Fehlerursachen': [x for x in Fehlerursachen if x["name"][0:2] in ['01', '02']]}, {'txt': 'Herstellungsschritte und Lager', 'name': 'FehlerGruppe_Herstellungsschritte', 'Fehlerursachen': [x for x in Fehlerursachen if x["name"][0:2] in ['03', '05', '06', '07']]}, {'txt': 'Defekte', 'name': 'FehlerGruppe_Defekte', 'Fehlerursachen': [x for x in Fehlerursachen if x["name"][0:2] in ['04']]}, {'txt': 'Organisation und Sonstiges', 'name': 'FehlerGruppe_Organisation_und_Sonstiges', 'Fehlerursachen': [x for x in Fehlerursachen if x["name"][0:2] in ['08', '09', '99']]}, {'txt': 'Alle', 'name': 'FehlerGruppe_Alle', 'Fehlerursachen': Fehlerursachen} ] Gruppen = holeGrupen() try: gruppe = next(item for item in Gruppen if item["id"] == request.matchdict['Linie']) except: return HTTPNotFound("Die Gruppen-ID '{}' ist ungültig.".format(request.matchdict['Linie'])) gruppe.update({'farbe': colorhash.ColorHash(gruppe['name'], lightness=(0.85, 0.9, 0.95), saturation=(0.25, 0.35, 0.5, 0.65, 0.75)).hex}) print(gruppe) return {'Gruppe': gruppe, 'Gruppen': Gruppen, 'Nutzer': users, 'Fehlerursachen': Fehlerursachen, 'FehlerursachenGruppen': FehlerursachenGruppen}
def my_view_testpage2(request): Gruppen = holeGrupen() try: gruppe = next(item for item in Gruppen if item["id"] == request.matchdict['Linie']) except: return HTTPNotFound("Die Gruppen-ID '{}' ist ungültig.".format(request.matchdict['Linie'])) # in Redmine Ticket anlegen: Projektbezug_Gattung = request.params['Projektbezug_Gattung'] Projektbezug_AU = request.params['Projektbezug_AU'] Projektbezug_PA = request.params['Projektbezug_PA'] Projektbezug_Projekt = request.params['Projektbezug_Projekt'] pData = {'KanBan': Projektbezug_PA, 'AU': Projektbezug_AU, 'Projekt': Projektbezug_Projekt} pTemp = {'KanBan': "{KanBan}", 'AU': "{AU}", 'Projekt': "{Projekt}", 'NA': "-"} Projektbezug = pTemp[Projektbezug_Gattung].format(**pData) Baugruppe_Gattung = request.params['Baugruppe_Gattung'] Baugruppe_Baugruppe = request.params['Baugruppe_Baugruppe'] bData = {'Baugruppe': Baugruppe_Baugruppe} bTemp = {'Baugruppe': "{Baugruppe}", 'unbekannt': "-"} Baugruppen = bTemp[Baugruppe_Gattung].format(**bData) FehlerGruppe = request.params['FehlerGruppe'] Fehler = request.params[FehlerGruppe] Thema = request.params['Thema'] Beschreibung = request.params['Beschreibung'] if Beschreibung == "": Beschreibung = "Auf die Beschreibung wurde verzichtet." Bauteil = request.params['Bauteil'] if Bauteil == "-": Bauteil = "" Zeit = float(request.params['Zeit']) Reparaturauftrag = 'Reparaturauftrag' in request.params Sonderfreigabe = 'Sonderfreigabe' in request.params Verursacht_Gattung = request.params['Verursacht_Gattung'] if "Verursacht_Gruppe" in request.params: Verursacht_Gruppe = request.params['Verursacht_Gruppe'] else: Verursacht_Gruppe = None Verursacht_Kreditor = request.params['Verursacht_Kreditor'] Verursacht_Hersteller = request.params['Verursacht_Hersteller'] vData = {'Gruppe': Verursacht_Gruppe, 'Kreditor': Verursacht_Kreditor, 'Hersteller': Verursacht_Hersteller} vTemp = {'Gruppe': "Gruppe:{Gruppe}", 'Kreditor': "Kreditor:{Kreditor}", 'Hersteller': "Hersteller:{Hersteller}", 'unbekannt': "unbekannt"} VerursachtDurch = vTemp[Verursacht_Gattung].format(**vData) if Reparaturauftrag or Sonderfreigabe: tracker_id = tracker_Reparatur['id'] else: tracker_id = tracker_Doku['id'] custom_fields = [ {'id': Feld_MeldendeGruppe['id'], 'value': gruppe['nameOrig']}, {'id': Feld_Fehler['id'], 'value': Fehler}, {'id': Feld_VerursachtDurch['id'], 'value': VerursachtDurch}, {'id': Feld_Projektbezug['id'], 'value': Projektbezug}, {'id': Feld_Baugruppe['id'], 'value': Baugruppen}, {'id': Feld_Bauteil['id'], 'value': Bauteil}, {'id': Feld_Produktgruppe['id'], 'value': "N/A"} ] try: if True: issue = MenRedmine.issue.new() issue.project_id = Config['project_id'] issue.tracker_id = tracker_id issue.subject = Thema issue.description = Beschreibung issue.custom_fields = custom_fields if Sonderfreigabe: issue.status_id = 8 issue.save() ncrid = issue['id'] if Sonderfreigabe: MenRedmine.issue.update(ncrid, notes='Um Sonderfreigabe wird gebeten.\n\nZur Bewilligung das Feld *Status* von "Ungelöst" -> "Erledigt" setzen.') time_entry = MenRedmine.time_entry.new() time_entry.activity_id = 24 # "Lösung" time_entry.issue_id = ncrid time_entry.spent_on = datetime.date.today() time_entry.hours = Zeit time_entry.comments = 'aus Formular' time_entry.save() else: ncrid = None except: print((traceback.format_exc())) ncrid = None # Antwortseite: gruppe.update({'farbe': colorhash.ColorHash(gruppe['name'], lightness=(0.85, 0.9, 0.95), saturation=(0.25, 0.35, 0.5, 0.65, 0.75)).hex}) return {'Gruppe': gruppe, 'NCRID': ncrid, 'RedmineBaseURL': Config['private_url']}
def build_abnormal_task_model_figures(task_df, elapsed_time_col, task_time_models, abnormal_df): abnormal_cols = list( filter( lambda mc: isinstance(mc, (list, tuple)) and mc[-1] == "abn_cont", abnormal_df.columns)) model_feature_map = {} for abnormal_col in abnormal_cols: group_def = abnormal_col[0] value_cols, abnormal_cols = model_feature_map.setdefault( group_def, ([], [])) value_cols.append(abnormal_col[0:-1] + ("value", )) abnormal_cols.append(abnormal_col) model_by_def = {} # model_value = {} model_abnormality = {} for model in task_time_models: model_by_def[model.group_def] = model if model.group_def not in model_feature_map: continue value_cols, abnormal_cols = model_feature_map[model.group_def] model_abnormality[model.group_def] = abnormal_df[abnormal_cols].sum( axis=1) # model_value[model.group_def] = abnormal_df[value_cols].sum(axis=1) model_abnormality_df = pandas.DataFrame(model_abnormality) model_abnormality_df.columns = model_abnormality_df.columns.to_flat_index() def to_tuple(v): if isinstance(v, tuple): return v if isinstance(v, list): return tuple(v) return (v, ) class Comparisons: def __init__(self, task_group_def): self.task_group_def = task_group_def self.model_comparisons = [] task_group_cols = to_tuple(abnormal_df.index.names) all_comparisons = [] for i in range(0, len(abnormal_df)): task_group_def = tuple( zip(task_group_cols, to_tuple(abnormal_df.iloc[i, :].name))) comparisons = Comparisons(task_group_def) all_comparisons.append(comparisons) task_group_task_mask = None for col, value in task_group_def: next_mask = task_df[col] == value task_group_task_mask = (task_group_task_mask & next_mask if task_group_task_mask is not None else next_mask) abnormality_values = model_abnormality_df.iloc[i, :].values ordered_abnormality = sorted(zip(abnormality_values, list(model_abnormality_df.columns)), reverse=True) for abnormality, group_def in ordered_abnormality: model = model_by_def[group_def] model_task_mask = None for col, value in model.group_def: next_mask = task_df[col] == value model_task_mask = (model_task_mask & next_mask if model_task_mask is not None else next_mask) model_task_df = task_df.loc[task_group_task_mask & model_task_mask] if len(model_task_df) == 0: continue comparisons.model_comparisons.append( (abnormality, model, model_task_df)) max_abnormality = max(model_abnormality_df.max()) active_models = list( filter(lambda m: m.group_def in model_feature_map, task_time_models)) AbnormalFigures = namedtuple("AbnormalFigures", ["bullseye", "histogram"]) all_figures = {} for ci, comparisons in enumerate(all_comparisons): def pretty_vals(group_def): return " - ".join(str(v) for k, v in group_def) def pretty_spoke(group_def): return "Task " + "\n".join(str(v) for k, v in group_def) # if pretty_vals(comparisons.task_group_def) != 'protiva': # continue fig = pyplot.figure() comparison_map = dict((comparison[1].group_def, comparison) for comparison in comparisons.model_comparisons) theta = numpy.linspace(0, 2 * numpy.pi, len(active_models), endpoint=False) axs = fig.add_subplot(1, 1, 1, projection="polar") abnormality = numpy.array( list( map( lambda m: comparison_map[m.group_def][0] if m.group_def in comparison_map else 0, active_models, ))) # print("abnormality", abnormality) spoke_labels = list( map(lambda m: pretty_spoke(m.group_def), active_models)) axs.set_thetagrids(numpy.degrees(theta), spoke_labels, weight="bold", size="medium") axs.tick_params(rotation="auto", pad=1.2) # axs.set_varlabels(spoke_labels, weight='bold', size='medium') alpha = (abnormality / max_abnormality) * 0.9 + 0.1 rgb_colors = list( map(lambda m: colorhash.ColorHash(m.group_def).rgb, active_models)) rgba_colors = numpy.zeros((len(abnormality), 4)) rgba_colors[:, 0:3] = numpy.array(rgb_colors) / 255.0 rgba_colors[:, 3] = alpha axs.scatter( theta, abnormality, c=rgba_colors, s=(((abnormality / max_abnormality) * 30.0)**2) * numpy.pi, marker="o", ) axs.set_rlim(0, max_abnormality + 1.0) rgrids = numpy.arange(0, max_abnormality + 1.0, 1.0) axs.set_rgrids(rgrids, labels=[""] * len(rgrids)) axs.set_title( f"Task Completion Time Normality for\n{pretty_vals(comparisons.task_group_def)}\n", weight="bold", size="large", ) for spine in axs.spines.values(): spine.set_edgecolor("lightgray") # fig.subplots_adjust(wspace=0.25, hspace=0.20, top=0.85, bottom=0.05) fig.set_size_inches(8, 8) bullseye = fig fig = pyplot.figure() cols = math.ceil(math.sqrt(len(active_models))) rows = math.ceil(len(active_models) / cols) # for i, comparison in enumerate(comparisons.model_comparisons): for i, model in enumerate(active_models): axs = fig.add_subplot(rows, cols, i + 1) axs_pdf = axs.twinx() comparison = comparison_map.get(model.group_def, None) if comparison is None: continue abnormality, model, model_task_df = comparison # binsize = model.event_resolution # bins = numpy.arange(0, max(model.ppf(0.99), max(model_task_df[elapsed_time_col])) + binsize, binsize) binrange = max(model.ppf(0.99), max(model_task_df[elapsed_time_col])) bins = numpy.linspace(0, binrange, 10) # bins_99 = model.ppf(numpy.linspace(0.01, 0.99, 99)) # last_bin_size = bins_99[-1] - bins_99[-2] # bins = [0] + list(bins_99) + [max(bins_99[-1] + last_bin_size, max(model_task_df[elapsed_time_col]))] rgb_color = numpy.array(colorhash.ColorHash( model.group_def).rgb) / 255.0 # axs.hist(model_task_df[elapsed_time_col], bins=bins, alpha=0.05, color='purple') axs.hist( model_task_df[elapsed_time_col], bins=bins, alpha=(abnormality / max_abnormality) * 0.9 + 0.1, color=rgb_color, ) pdf_range = model.interval(0.99) pdf_x = numpy.linspace(pdf_range[0], pdf_range[1], 100) axs_pdf.plot( pdf_x, model.pdf(pdf_x), alpha=(1.0 - model.expected_err_pct) * 0.9 + 0.1, color="black", linewidth=3.0, ) axs.set_title( f"Task {pretty_vals(model.group_def)}\n{pretty_vals(comparisons.task_group_def)}\n(Ab:{abnormality:.2f} ErrPct:{model.expected_err_pct:.2f})\n" ) axs.set_ylabel("# of Tasks Completed") axs_pdf.set_ylabel("Modeled Probability") axs.set_xlabel("Task Completion Time (mins)") # axs.set_xscale('log') # axs_pdf.set_xscale('log') fig.subplots_adjust(wspace=0.4, hspace=0.25) fig.set_size_inches(5 * cols, 10 * rows) histogram = fig _, task_group_index_values = zip(*comparisons.task_group_def) all_figures[maybe_tuple(task_group_index_values)] = AbnormalFigures( bullseye, histogram) return all_figures
def color_circle(string): hex_color = colorhash.ColorHash(string).hex circle = "<i class='fas fa-circle' style='color:{}'></i>".format(hex_color) return circle
def create_charts(uuids): paths = [Path(c.DEFAULT_PARENT_FOLDER) / uuid for uuid in uuids] html = '' for uuid in uuids: experiment_json = utils.load_experiment_json(uuid) title = experiment_json['title'] if title: html += '{} {} - {}\n<br>'.format(color_circle(uuid), utils.get_short_uuid(uuid), title) else: html += '{} {}\n<br>'.format(color_circle(uuid), utils.get_short_uuid(uuid)) scalar_names = get_all_scalar_names(paths) hover = HoverTool(tooltips=[ ('step', '@x'), ('value', '@y'), ], mode='vline') plots = [] for scalar_name in scalar_names: plot = figure( tools=[hover, 'reset', 'pan', 'wheel_zoom', 'box_zoom'], title=scalar_name, x_axis_label='Step', width=FIGURE_WIDTH, height=FIGURE_HEIGHT, ) for uuid, path in zip(uuids, paths): scalar_file = path / c.SCALARS_FOLDER / '{}.csv'.format( scalar_name) if scalar_file.is_file(): df = pd.read_csv(scalar_file) source = ColumnDataSource(data={ 'x': df['step'], 'y': df['value'], }) color = colorhash.ColorHash(uuid).rgb plot.line( 'x', 'y', source=source, line_color=bokeh.colors.RGB(*color), legend=utils.get_short_uuid(uuid), line_width=2, ) plot.legend.location = "top_left" plot.legend.click_policy = "hide" script, div = components(plot) plots.append('{}\n{}'.format(script, div)) return html + '\n\n'.join(plots)