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)