diff --git a/scripts/analyse_dataset.py b/scripts/analyse_dataset.py index 45824ad..6cf0a02 100644 --- a/scripts/analyse_dataset.py +++ b/scripts/analyse_dataset.py @@ -9,6 +9,7 @@ from lang_main.analysis.graphs import ( save_to_GraphML, ) from lang_main.constants import ( + CYTO_BASE_NETWORK_NAME, PATH_TO_DATASET, SAVE_PATH_FOLDER, SKIP_GRAPH_POSTPROCESSING, @@ -26,7 +27,7 @@ from lang_main.pipelines.predefined import ( build_timeline_pipe, build_tk_graph_pipe, build_tk_graph_post_pipe, - build_tk_graph_rendering_pipe, + build_tk_graph_render_pipe, build_tk_graph_rescaling_pipe, ) from lang_main.types import ( @@ -42,8 +43,14 @@ pipe_target_feat = build_base_target_feature_pipe() pipe_merge = build_merge_duplicates_pipe() pipe_token_analysis = build_tk_graph_pipe() pipe_graph_postprocessing = build_tk_graph_post_pipe() -pipe_graph_rescaling = build_tk_graph_rescaling_pipe() -pipe_static_graph_rendering = build_tk_graph_rendering_pipe() +pipe_graph_rescaling = build_tk_graph_rescaling_pipe( + save_result=True, + exit_point=EntryPoints.TK_GRAPH_ANALYSIS_RESCALED, +) +pipe_static_graph_rendering = build_tk_graph_render_pipe( + with_subgraphs=True, + base_network_name=CYTO_BASE_NETWORK_NAME, +) pipe_timeline = build_timeline_pipe() @@ -98,11 +105,11 @@ def run_graph_edge_rescaling() -> None: load_pickle(entry_point_path), ) tk_graph = loaded_results[0] - ret = cast( + tk_graph_rescaled, tk_graph_rescaled_undirected = cast( tuple[TokenGraph, Graph], pipe_graph_rescaling.run(starting_values=(tk_graph,)) ) - tk_graph_rescaled = ret[0] - tk_graph_rescaled_undirected = ret[1] + # tk_graph_rescaled = ret[0] + # tk_graph_rescaled_undirected = ret[1] tk_graph_rescaled.to_GraphML( SAVE_PATH_FOLDER, filename='TokenGraph-directed-rescaled', directed=False ) diff --git a/scripts/dashboard/cyto.py b/scripts/cyto.py similarity index 100% rename from scripts/dashboard/cyto.py rename to scripts/cyto.py diff --git a/scripts/dashboard/dash_timeline.py b/scripts/dash_timeline.py similarity index 95% rename from scripts/dashboard/dash_timeline.py rename to scripts/dash_timeline.py index fd41bd1..ec6817e 100644 --- a/scripts/dashboard/dash_timeline.py +++ b/scripts/dash_timeline.py @@ -20,13 +20,15 @@ from pandas import DataFrame import lang_main.io from lang_main.analysis import graphs, tokens -from lang_main.constants import SPCY_MODEL -from lang_main.types import ObjectID, TimelineCandidates +from lang_main.constants import SAVE_PATH_FOLDER, SPCY_MODEL +from lang_main.types import EntryPoints, ObjectID, TimelineCandidates # ** data -p_df = Path(r'../results/test_20240619/TIMELINE.pkl').resolve() +# p_df = Path(r'../results/test_20240619/TIMELINE.pkl').resolve() +p_df = lang_main.io.get_entry_point(SAVE_PATH_FOLDER, EntryPoints.TIMELINE) (data,) = cast(tuple[DataFrame], lang_main.io.load_pickle(p_df)) -p_tl = Path(r'../results/test_20240619/TIMELINE_POSTPROCESSING.pkl').resolve() +# p_tl = Path(r'../results/test_20240619/TIMELINE_POSTPROCESSING.pkl').resolve() +p_tl = lang_main.io.get_entry_point(SAVE_PATH_FOLDER, EntryPoints.TIMELINE_POST) cands, texts = cast( tuple[TimelineCandidates, dict[ObjectID, str]], lang_main.io.load_pickle(p_tl) ) @@ -58,9 +60,10 @@ HOVER_DATA: Final[dict[str, Any]] = { } # ** graph -target = '../results/test_20240529/Pipe-Token_Analysis_Step-1_build_token_graph.pkl' -p = Path(target).resolve() -ret = lang_main.io.load_pickle(p) +# target = '../results/test_20240529/Pipe-Token_Analysis_Step-1_build_token_graph.pkl' +# p = Path(target).resolve() +p_tk_graph = lang_main.io.get_entry_point(SAVE_PATH_FOLDER, EntryPoints.TK_GRAPH_POST) +ret = lang_main.io.load_pickle(p_tk_graph) tk_graph = cast(graphs.TokenGraph, ret[0]) tk_graph_filtered = graphs.filter_graph_by_edge_weight(tk_graph, 150, None) tk_graph_filtered = graphs.filter_graph_by_node_degree(tk_graph_filtered, 1, None) diff --git a/scripts/dash_timeline_static.py b/scripts/dash_timeline_static.py new file mode 100644 index 0000000..8dd4be4 --- /dev/null +++ b/scripts/dash_timeline_static.py @@ -0,0 +1,413 @@ +import time +import webbrowser +from pathlib import Path +from threading import Thread +from typing import Any, Final, cast + +# import dash_cytoscape as cyto +import plotly.express as px +from dash import ( + Dash, + Input, + Output, + State, + callback, + dash_table, + dcc, + html, +) +from pandas import DataFrame +from plotly.graph_objects import Figure + +import lang_main.io +from lang_main.analysis import graphs, tokens +from lang_main.constants import SAVE_PATH_FOLDER, SPCY_MODEL +from lang_main.errors import EmptyEdgesError, EmptyGraphError +from lang_main.pipelines.predefined import ( + build_tk_graph_render_pipe, + build_tk_graph_rescaling_pipe, +) +from lang_main.types import EntryPoints, ObjectID, TimelineCandidates + +# ** data +# p_df = Path(r'../results/test_20240619/TIMELINE.pkl').resolve() +p_df = lang_main.io.get_entry_point(SAVE_PATH_FOLDER, EntryPoints.TIMELINE) +(data,) = cast(tuple[DataFrame], lang_main.io.load_pickle(p_df)) +# p_tl = Path(r'../results/test_20240619/TIMELINE_POSTPROCESSING.pkl').resolve() +p_tl = lang_main.io.get_entry_point(SAVE_PATH_FOLDER, EntryPoints.TIMELINE_POST) +cands, texts = cast( + tuple[TimelineCandidates, dict[ObjectID, str]], lang_main.io.load_pickle(p_tl) +) +# ** necessary pipelines +rescaling_pipe = build_tk_graph_rescaling_pipe( + exit_point=EntryPoints.TIMELINE_TK_GRAPH_RESCALED, + save_result=False, +) +BASE_NETWORK_NAME: Final[str] = 'test_timeline' +# RENDER_FOLDER: Final[Path] = Path.cwd() / 'assets/' +graph_render_pipe = build_tk_graph_render_pipe( + with_subgraphs=False, + base_network_name=BASE_NETWORK_NAME, +) +# PTH_RENDERED_GRAPH = f'assets/{BASE_NETWORK_NAME}.svg' +PTH_RENDERED_GRAPH = lang_main.io.get_entry_point( + SAVE_PATH_FOLDER, + BASE_NETWORK_NAME, + file_ext='.svg', +) + + +TABLE_FEATS: Final[list[str]] = [ + 'ErstellungsDatum', + 'ErledigungsDatum', + 'VorgangsTypName', + 'VorgangsBeschreibung', +] +TABLE_FEATS_DATES: Final[list[str]] = [ + 'ErstellungsDatum', + 'ErledigungsDatum', +] + +# ** figure config +MARKERS_OCCURRENCES: Final[dict[str, Any]] = { + 'size': 12, + 'color': 'yellow', + 'line': { + 'width': 2, + 'color': 'red', + }, +} +MARKERS_DELTA: Final[dict[str, Any]] = { + 'size': 8, + 'color': 'red', + 'symbol': 'cross', +} +HOVER_DATA: Final[dict[str, Any]] = { + 'ErstellungsDatum': '|%d.%m.%Y', + 'ErledigungsDatum': '|%d.%m.%Y', + 'VorgangsBeschreibung': True, +} +HOVER_DATA_DELTA: Final[dict[str, Any]] = { + 'ErstellungsDatum': '|%d.%m.%Y', + 'ErledigungsDatum': '|%d.%m.%Y', + 'VorgangsDatum': '|%d.%m.%Y', + 'delta': True, + 'VorgangsBeschreibung': True, +} + +# ** graph +p_tk_graph = lang_main.io.get_entry_point(SAVE_PATH_FOLDER, EntryPoints.TK_GRAPH_POST) +ret = lang_main.io.load_pickle(p_tk_graph) +tk_graph = cast(graphs.TokenGraph, ret[0]) +tk_graph_filtered = graphs.filter_graph_by_edge_weight(tk_graph, 150, None) +tk_graph_filtered = graphs.filter_graph_by_node_degree(tk_graph_filtered, 1, None) + + +graph_layout = html.Div( + [ + dcc.Store(id='graph-store', storage_type='memory'), + # dcc.Store(id='graph-store-cyto-curr_cands', storage_type='memory'), + html.Div(id='output'), + html.Div( + [ + html.H2('Token Graph', style={'margin': 0}), + ], + style={ + 'display': 'flex', + 'marginBottom': '1em', + }, + ), + html.Div( + [ + html.H3('Graph'), + html.Button( + 'Download Bild', + id='bt-reset', + style={ + 'marginLeft': 'auto', + 'width': '300px', + }, + ), + dcc.Download(id='static-graph-download'), + dcc.Loading( + id='loading-graph-render', + children=html.Div( + [ + html.Img( + id='static-graph-img', + alt='static rendered graph', + # style={ + # 'width': 'auto', + # 'height': 'auto', + # }, + ), + html.P(id='info-graph-errors', children=[]), + ], + style={ + 'border': '3px solid black', + 'borderRadius': '25px', + 'marginTop': '1em', + 'marginBottom': '2em', + 'padding': '7px', + }, + ), + ), + ], + style={'marginTop': '1em'}, + ), + ], +) + + +# ** app +external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css'] +app = Dash(__name__, external_stylesheets=external_stylesheets) + + +app.layout = html.Div( + [ + html.H1(children='Demo Zeitreihenanalyse', style={'textAlign': 'center'}), + html.Div( + children=[ + html.H2('Wählen Sie ein Objekt aus (ObjektID):'), + dcc.Dropdown( + list(cands.keys()), + id='selector-obj_id', + placeholder='ObjektID auswählen...', + ), + ] + ), + html.Div( + children=[ + html.H3(id='object-text'), + dcc.Dropdown(id='selector-candidates'), + dcc.Graph(id='figure-occurrences'), + dcc.Graph(id='figure-delta'), + ] + ), + html.Div( + [dash_table.DataTable(id='table-candidates')], style={'marginBottom': '2em'} + ), + graph_layout, + ], + style={'margin': '2em'}, +) + + +# ** selectors of candidates +@callback( + Output('object-text', 'children'), + Input('selector-obj_id', 'value'), + prevent_initial_call=True, +) +def update_obj_text(obj_id): + obj_id = int(obj_id) + obj_text = texts[obj_id] + headline = f'HObjektText: {obj_text}' + return headline + + +@callback( + [ + Output('selector-candidates', 'options'), + Output('selector-candidates', 'value'), + ], + Input('selector-obj_id', 'value'), + prevent_initial_call=True, +) +def update_choice_candidates(obj_id): + obj_id = int(obj_id) + choices = list(range(1, len(cands[obj_id]) + 1)) + return choices, choices[0] + + +# ** helpers to filter DataFrame +def pre_filter_data( + data: DataFrame, + idx: int, + obj_id: ObjectID, +) -> DataFrame: + idx = int(idx) + obj_id = int(obj_id) + # data = data.copy() + cands_for_obj_id = cands[obj_id] + cands_choice = cands_for_obj_id[int(idx) - 1] + # data + data = data.loc[list(cands_choice)].sort_index() # type: ignore + data['delta'] = data['ErledigungsDatum'] - data['ErstellungsDatum'] + data['delta'] = data['delta'].dt.days + + return data + + +# ** figure generation +# TODO check possible storage of pre-filtered result +# TODO change input of ``update_table_candidates`` and ``display_candidates_as_graph`` +# TODO to storage component +@callback( + [ + Output('figure-occurrences', 'figure'), + Output('figure-delta', 'figure'), + ], + Input('selector-candidates', 'value'), + State('selector-obj_id', 'value'), + prevent_initial_call=True, +) +def update_timeline(index, obj_id): + obj_id = int(obj_id) + obj_text = texts[obj_id] + title_occurrences = f'HObjektText: {obj_text}' + title_delta = f'HObjektText: {obj_text}, Differenz Erstellung und Erledigung' + df = pre_filter_data(data, idx=index, obj_id=obj_id) + # figure + fig_occurrences = fig_timeline_occurrences(df, title_occurrences) + fig_delta = fig_timeline_delta(df, title_delta) + + return fig_occurrences, fig_delta + + +def fig_timeline_occurrences( + df: DataFrame, + title: str, +) -> Figure: + fig = px.line( + data_frame=df, + x='ErstellungsDatum', + y='ObjektID', + title=title, + hover_data=HOVER_DATA, + ) + fig.update_traces( + mode='markers+lines', marker=MARKERS_OCCURRENCES, marker_symbol='diamond' + ) + fig.update_xaxes( + tickformat='%B\n%Y', + rangeslider_visible=True, + ) + fig.update_yaxes(type='category') + fig.update_layout(hovermode='x unified') + + return fig + + +def fig_timeline_delta( + df: DataFrame, + title: str, +) -> Figure: + fig = px.scatter( + data_frame=df, + x='ErstellungsDatum', + y='delta', + title=title, + hover_data=HOVER_DATA_DELTA, + ) + fig.update_traces(marker=MARKERS_DELTA) + fig.update_xaxes(tickformat='%B\n%Y') + fig.update_yaxes(dtick=1) + fig.update_layout(hovermode='x unified') + + return fig + + +# ** HTML table +@callback( + [Output('table-candidates', 'data'), Output('table-candidates', 'columns')], + Input('selector-candidates', 'value'), + State('selector-obj_id', 'value'), + prevent_initial_call=True, +) +def update_table_candidates(index, obj_id): + df = pre_filter_data(data, idx=index, obj_id=obj_id) + df = df.filter(items=TABLE_FEATS, axis=1).sort_values( + by='ErstellungsDatum', ascending=True + ) + cols = [{'name': i, 'id': i} for i in df.columns] + # convert dates to strings + for col in TABLE_FEATS_DATES: + df[col] = df[col].dt.strftime(r'%Y-%m-%d') + + table_data = df.to_dict('records') + return table_data, cols + + +# ** graph callbacks +@app.callback( + [ + Output('graph-store', 'data'), + Output('static-graph-img', 'src'), + Output('info-graph-errors', 'children'), + ], + # Input('graph-build-btn', 'n_clicks'), + Input('selector-candidates', 'value'), + State('selector-obj_id', 'value'), + prevent_initial_call=True, +) +def display_candidates_as_graph(index, obj_id): + error_msg = '' + t1 = time.perf_counter() + df = pre_filter_data(data, idx=index, obj_id=obj_id) + t2 = time.perf_counter() + print(f'Time for filtering: {t2 - t1} s') + + t1 = time.perf_counter() + tk_graph_cands, _ = tokens.build_token_graph( + data=df, + model=SPCY_MODEL, + target_feature='VorgangsBeschreibung', + build_map=False, + logging_graph=False, + ) + t2 = time.perf_counter() + print(f'Time for graph building: {t2 - t1} s') + + # ** now start rendering pipeline in Cytoscape + # rescale graph + try: + t1 = time.perf_counter() + _, tk_graph_rescaled_undirected = cast( + tuple[graphs.TokenGraph, graphs.Graph], + rescaling_pipe.run(starting_values=(tk_graph_cands,)), + ) + # render graph in Cytoscape and export image + _ = graph_render_pipe.run(starting_values=(tk_graph_rescaled_undirected,)) + # load image as b64 encoded string + b64_img = lang_main.io.encode_file_to_base64_str(PTH_RENDERED_GRAPH) + static_img = f'data:image/svg+xml;base64,{b64_img}' + graph_to_store = lang_main.io.encode_to_base64_str(tk_graph_cands) + + # place image in browser + t2 = time.perf_counter() + print(f'Time for graph rescaling and rendering: {t2 - t1} s') + except (EmptyGraphError, EmptyEdgesError): + graph_to_store = '' + static_img = '' + error_msg = 'Graph ist leer und konnte nicht generiert werden!' + finally: + return graph_to_store, static_img, error_msg + + +@callback( + Output('static-graph-download', 'data'), + Input('bt-reset', 'n_clicks'), + prevent_initial_call=True, +) +def func(n_clicks): + return dcc.send_file(path=PTH_RENDERED_GRAPH) + + +def _start_webbrowser(): + host = '127.0.0.1' + port = '8050' + adress = f'http://{host}:{port}/' + time.sleep(2) + webbrowser.open_new(adress) + + +def main(): + webbrowser_thread = Thread(target=_start_webbrowser, daemon=True) + webbrowser_thread.start() + app.run(debug=True) + + +if __name__ == '__main__': + main() diff --git a/scripts/dashboard/archive/data.pkl b/scripts/dashboard/archive/data.pkl deleted file mode 100644 index ec76da0..0000000 Binary files a/scripts/dashboard/archive/data.pkl and /dev/null differ diff --git a/scripts/dashboard/archive/map_candidates.pkl b/scripts/dashboard/archive/map_candidates.pkl deleted file mode 100644 index 77c1a48..0000000 Binary files a/scripts/dashboard/archive/map_candidates.pkl and /dev/null differ diff --git a/scripts/dashboard/archive/map_texts.pkl b/scripts/dashboard/archive/map_texts.pkl deleted file mode 100644 index 49bdc55..0000000 Binary files a/scripts/dashboard/archive/map_texts.pkl and /dev/null differ diff --git a/scripts/dashboard/lang_main_config.toml b/scripts/dashboard/lang_main_config.toml deleted file mode 100644 index c694e25..0000000 --- a/scripts/dashboard/lang_main_config.toml +++ /dev/null @@ -1,56 +0,0 @@ -# lang_main: Config file - -[paths] -inputs = './inputs/' -results = './results/test_new2/' -dataset = './01_2_Rohdaten_neu/Export4.csv' -#results = './results/Export7/' -#dataset = './01_03_Rohdaten_202403/Export7_59499_Zeilen.csv' -#results = './results/Export7_trunc/' -#dataset = './01_03_Rohdaten_202403/Export7_trunc.csv' - -[control] -preprocessing = true -preprocessing_skip = false -token_analysis = false -token_analysis_skip = false -graph_postprocessing = false -graph_postprocessing_skip = false -time_analysis = false -time_analysis_skip = false - -#[export_filenames] -#filename_cossim_filter_candidates = 'CosSim-FilterCandidates' - -[preprocess] -filename_cossim_filter_candidates = 'CosSim-FilterCandidates' -date_cols = [ - "VorgangsDatum", - "ErledigungsDatum", - "Arbeitsbeginn", - "ErstellungsDatum", -] -threshold_amount_characters = 5 -threshold_similarity = 0.8 - -[graph_postprocessing] -threshold_edge_weight = 150 - -[time_analysis.uniqueness] -threshold_unique_texts = 4 -criterion_feature = 'HObjektText' -feature_name_obj_id = 'ObjektID' - -[time_analysis.model_input] -input_features = [ - 'VorgangsTypName', - 'VorgangsArtText', - 'VorgangsBeschreibung', -] -activity_feature = 'VorgangsTypName' -activity_types = [ - 'Reparaturauftrag (Portal)', - 'Störungsmeldung', -] -threshold_num_acitivities = 1 -threshold_similarity = 0.8 \ No newline at end of file diff --git a/scripts/dashboard/new/Pipe-TargetFeature_Step-3_remove_NA.pkl b/scripts/dashboard/new/Pipe-TargetFeature_Step-3_remove_NA.pkl deleted file mode 100644 index bba1d89..0000000 Binary files a/scripts/dashboard/new/Pipe-TargetFeature_Step-3_remove_NA.pkl and /dev/null differ diff --git a/scripts/dashboard/new/Pipe-Timeline_Analysis_Step-4_get_timeline_candidates.pkl b/scripts/dashboard/new/Pipe-Timeline_Analysis_Step-4_get_timeline_candidates.pkl deleted file mode 100644 index 5565194..0000000 Binary files a/scripts/dashboard/new/Pipe-Timeline_Analysis_Step-4_get_timeline_candidates.pkl and /dev/null differ diff --git a/scripts/dashboard/test.py b/scripts/dashboard/test.py deleted file mode 100644 index f287ba4..0000000 --- a/scripts/dashboard/test.py +++ /dev/null @@ -1,18 +0,0 @@ -from pathlib import Path -from typing import cast -import statistics - -import lang_main.io -from lang_main.analysis import graphs - -# target = '../results/test_20240529/Pipe-Token_Analysis_Step-1_build_token_graph.pkl' -# p = Path(target).resolve() -# ret = lang_main.io.load_pickle(p) -# tk_graph = cast(graphs.TokenGraph, ret[0]) -# tk_graph_filtered = tk_graph.filter_by_edge_weight(150, None) -# tk_graph_filtered = tk_graph_filtered.filter_by_node_degree(1, None) -# cyto_data_base, weight_data, all_weights = graphs.convert_graph_to_cytoscape(tk_graph_filtered) - - -test = [1, 1, 1, 2, 2, 3, 3, 4, 4, 1000] -print(statistics.mean(test)) diff --git a/src/lang_main/analysis/graphs.py b/src/lang_main/analysis/graphs.py index cbc6097..1935cdf 100644 --- a/src/lang_main/analysis/graphs.py +++ b/src/lang_main/analysis/graphs.py @@ -17,7 +17,7 @@ from lang_main.constants import ( EDGE_WEIGHT_DECIMALS, PROPERTY_NAME_DEGREE_WEIGHTED, ) -from lang_main.errors import EdgePropertyNotContainedError +from lang_main.errors import EdgePropertyNotContainedError, EmptyEdgesError, EmptyGraphError from lang_main.io import load_pickle, save_pickle from lang_main.loggers import logger_graphs as logger from lang_main.types import ( @@ -381,9 +381,12 @@ def normalise_array_linear( npt.NDArray[np.float32] min/max normalised array """ - arr_norm = (array - array.min()) / (array.max() - array.min()) - - return arr_norm.astype(np.float32) + div = array.max() - array.min() + if div != 0: + arr_norm = (array - array.min()) / div + return arr_norm.astype(np.float32) + else: + return np.zeros(shape=array.shape, dtype=np.float32) def weight_scaling( @@ -459,6 +462,8 @@ def rescale_edge_weights( weight_property: str = 'weight', ) -> Graph | DiGraph | TokenGraph: graph = graph.copy() + # check non-emptiness + verify_non_empty_graph(graph, including_edges=True) # check if all edges contain weight property verify_property(graph, property=weight_property) @@ -473,6 +478,33 @@ def rescale_edge_weights( return graph +def verify_non_empty_graph( + graph: DiGraph | Graph, + including_edges: bool = True, +) -> None: + """check if the given graph is empty, presence of nodes is checked first, + then of edges + + Parameters + ---------- + graph : DiGraph | Graph + graph to check for emptiness + including_edges : bool, optional + whether to check for non-existence of edges, by default True + + Raises + ------ + EmptyGraphError + if graph does not contain any nodes and therefore edges + EmptyEdgesError + if graph does not contain any edges + """ + if not tuple(graph.nodes): + raise EmptyGraphError(f'Graph object >>{graph}<< does not contain any nodes.') + elif including_edges and not tuple(graph.edges): + raise EmptyEdgesError(f'Graph object >>{graph}<< does not contain any edges.') + + # ** --------------------------------------- class TokenGraph(DiGraph): def __init__( diff --git a/src/lang_main/cytoscape_config/lang_main.xml b/src/lang_main/cytoscape_config/lang_main.xml index 93adff8..da8b547 100644 --- a/src/lang_main/cytoscape_config/lang_main.xml +++ b/src/lang_main/cytoscape_config/lang_main.xml @@ -1,128 +1,128 @@ - + - - - - - - - - - - - - + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + - - - - + + + - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/lang_main/cytoscape_config/template_test.cys b/src/lang_main/cytoscape_config/template_test.cys index 4cead42..da070f2 100644 Binary files a/src/lang_main/cytoscape_config/template_test.cys and b/src/lang_main/cytoscape_config/template_test.cys differ diff --git a/src/lang_main/errors.py b/src/lang_main/errors.py index ada6563..2292524 100644 --- a/src/lang_main/errors.py +++ b/src/lang_main/errors.py @@ -1,2 +1,12 @@ class EdgePropertyNotContainedError(Exception): """Error raised if a needed edge property is not contained in graph edges""" + + +class EmptyGraphError(Exception): + """Error raised if an operation should be performed on the graph, + but it does not contain any nodes or edges""" + + +class EmptyEdgesError(EmptyGraphError): + """Error raised if action should be performed on a graph's edges, but + it does not contain any""" diff --git a/src/lang_main/io.py b/src/lang_main/io.py index 3ad9b0a..21322cd 100644 --- a/src/lang_main/io.py +++ b/src/lang_main/io.py @@ -71,6 +71,15 @@ def encode_to_base64_str( return b64_bytes.decode(encoding=encoding) +def encode_file_to_base64_str( + path: Path, + encoding: str = 'utf-8', +) -> str: + with open(path, 'rb') as file: + b64_bytes = base64.b64encode(file.read()) + return b64_bytes.decode(encoding=encoding) + + def decode_from_base64_str( b64_str: str, encoding: str = 'utf-8', @@ -83,8 +92,9 @@ def decode_from_base64_str( def get_entry_point( saving_path: Path, filename: str, + file_ext: str = '.pkl', ) -> Path: - entry_point_path = (saving_path / filename).with_suffix('.pkl') + entry_point_path = (saving_path / filename).with_suffix(file_ext) if not entry_point_path.exists(): raise FileNotFoundError( f'Could not find provided entry data under path: >>{entry_point_path}<<' diff --git a/src/lang_main/pipelines/predefined.py b/src/lang_main/pipelines/predefined.py index fc37efd..0951c06 100644 --- a/src/lang_main/pipelines/predefined.py +++ b/src/lang_main/pipelines/predefined.py @@ -1,3 +1,5 @@ +from pathlib import Path + from lang_main.analysis import graphs from lang_main.analysis.preprocessing import ( analyse_feature, @@ -168,39 +170,77 @@ def build_tk_graph_post_pipe() -> Pipeline: return pipe_graph_postprocessing -def build_tk_graph_rescaling_pipe() -> Pipeline: +def build_tk_graph_rescaling_pipe( + save_result: bool, + exit_point: EntryPoints, +) -> Pipeline: pipe_graph_rescaling = Pipeline(name='Graph_Rescaling', working_dir=SAVE_PATH_FOLDER) pipe_graph_rescaling.add( graphs.pipe_rescale_graph_edge_weights, ) pipe_graph_rescaling.add( graphs.pipe_add_graph_metrics, - save_result=True, - filename=EntryPoints.TK_GRAPH_ANALYSIS_RESCALED, + save_result=save_result, + filename=exit_point, + # filename=EntryPoints.TK_GRAPH_ANALYSIS_RESCALED, ) return pipe_graph_rescaling # ** token analysis: rendering -def build_tk_graph_rendering_pipe() -> Pipeline: +def build_tk_graph_render_pipe( + with_subgraphs: bool, + export_folder: Path = SAVE_PATH_FOLDER, + base_network_name: str = CYTO_BASE_NETWORK_NAME, +) -> Pipeline: pipe_graph_rendering = Pipeline( name='Graph_Static-Rendering', working_dir=SAVE_PATH_FOLDER, ) - pipe_graph_rendering.add(cyto.import_to_cytoscape) - pipe_graph_rendering.add(cyto.layout_network) - pipe_graph_rendering.add(cyto.apply_style_to_network) + pipe_graph_rendering.add( + cyto.import_to_cytoscape, + { + 'network_name': base_network_name, + }, + ) + pipe_graph_rendering.add( + cyto.layout_network, + { + 'network_name': base_network_name, + }, + ) + pipe_graph_rendering.add( + cyto.apply_style_to_network, + { + 'network_name': base_network_name, + }, + ) pipe_graph_rendering.add( cyto.export_network_to_image, - {'filename': CYTO_BASE_NETWORK_NAME}, - ) - pipe_graph_rendering.add(cyto.get_subgraph_node_selection) - pipe_graph_rendering.add( - cyto.build_subnetworks, - {'export_image': True}, + { + 'filename': base_network_name, + 'target_folder': export_folder, + 'network_name': base_network_name, + }, ) + if with_subgraphs: + pipe_graph_rendering.add( + cyto.get_subgraph_node_selection, + { + 'network_name': base_network_name, + }, + ) + pipe_graph_rendering.add( + cyto.build_subnetworks, + { + 'export_image': True, + 'target_folder': export_folder, + 'network_name': base_network_name, + }, + ) + return pipe_graph_rendering diff --git a/src/lang_main/render/cytoscape.py b/src/lang_main/render/cytoscape.py index ca45ee1..4df2a0d 100644 --- a/src/lang_main/render/cytoscape.py +++ b/src/lang_main/render/cytoscape.py @@ -1,7 +1,7 @@ import time from collections.abc import Iterable from pathlib import Path -from typing import cast +from typing import Literal, cast import py4cytoscape as p4c from networkx import DiGraph, Graph @@ -55,6 +55,7 @@ def verify_connection(): def import_to_cytoscape( graph: DiGraph | Graph, + network_name: str = CYTO_BASE_NETWORK_NAME, ) -> None: """Cytoscape: import NetworkX graph as new network collection @@ -65,15 +66,49 @@ def import_to_cytoscape( """ logger.debug('Checking Cytoscape connection...') verify_connection() - logger.debug('Importing network to Cytoscape...') + logger.debug('Importing to and analysing network in Cytoscape...') p4c.delete_all_networks() p4c.create_network_from_networkx( graph, - title=CYTO_BASE_NETWORK_NAME, + title=network_name, collection=CYTO_COLLECTION_NAME, ) - p4c.analyze_network(directed=False) - logger.debug('Importing network to Cytoscape successful.') + analyse_network(network_name=network_name) + logger.debug('Import and analysis of network to Cytoscape successful.') + + +def verify_table_property( + property: str, + table_type: Literal['node', 'edge', 'network'] = 'node', + network_name: str = CYTO_BASE_NETWORK_NAME, +) -> bool: + table = p4c.get_table_columns(table=table_type, network=network_name) + + return property in table.columns + + +def analyse_network( + property_degree_weighted: str = PROPERTY_NAME_DEGREE_WEIGHTED, + network_name: str = CYTO_BASE_NETWORK_NAME, +) -> None: + node_table = p4c.get_table_columns(table='node', network=network_name) + net_analyse_possible: bool = True + if len(node_table) < 4: + net_analyse_possible = False + + if net_analyse_possible: + p4c.analyze_network(directed=False) + node_table = p4c.get_table_columns(table='node', network=network_name) + node_table['stress_norm'] = node_table['Stress'] / node_table['Stress'].max() + node_table[CYTO_SELECTION_PROPERTY] = ( + node_table[property_degree_weighted] + * node_table['BetweennessCentrality'] + * node_table['stress_norm'] + ) + else: + node_table[CYTO_SELECTION_PROPERTY] = 1 + + p4c.load_table_data(node_table, data_key_column='name', network=network_name) def reset_current_network_to_base() -> None: @@ -83,6 +118,7 @@ def reset_current_network_to_base() -> None: def export_network_to_image( filename: str, + target_folder: Path = SAVE_PATH_FOLDER, filetype: CytoExportFileTypes = 'SVG', network_name: str = CYTO_BASE_NETWORK_NAME, pdf_export_page_size: CytoExportPageSizes = 'A4', @@ -102,7 +138,6 @@ def export_network_to_image( by default 'A4' """ logger.debug('Exporting image to file...') - target_folder = SAVE_PATH_FOLDER if not target_folder.exists(): target_folder.mkdir(parents=True) file_pth = target_folder / filename @@ -138,7 +173,8 @@ def layout_network( necessarily match the name in the Cytoscape UI), by default CYTO_LAYOUT_NAME layout_properties : CytoLayoutProperties, optional - configuration of parameters for the given layout algorithm, by default CYTO_LAYOUT_PROPERTIES + configuration of parameters for the given layout algorithm, + by default CYTO_LAYOUT_PROPERTIES network_name : str, optional network to apply the layout algorithm on, by default CYTO_BASE_NETWORK_NAME """ @@ -153,6 +189,9 @@ def apply_style_to_network( style_name: str = CYTO_STYLESHEET_NAME, pth_to_stylesheet: Path = CYTO_PATH_STYLESHEET, network_name: str = CYTO_BASE_NETWORK_NAME, + node_size_property: str = 'node_selection', + min_node_size: int = 15, + max_node_size: int = 40, ) -> None: """Cytoscape: apply a chosen Cytoscape style to the defined network @@ -185,14 +224,36 @@ def apply_style_to_network( p4c.import_visual_styles(str(pth_to_stylesheet)) p4c.set_visual_style(style_name, network=network_name) - time.sleep(1) # if not waited image export could be without applied style + # node size mapping, only if needed property is available + # TODO check removal + # size_prop_available = verify_table_property( + # property=node_size_property, + # network_name=network_name, + # ) + # if size_prop_available: + scheme = p4c.scheme_c_number_continuous( + start_value=min_node_size, end_value=max_node_size + ) + node_size_map = p4c.gen_node_size_map( + node_size_property, + number_scheme=scheme, + mapping_type='c', + style_name='lang_main', + default_number=min_node_size, + ) + p4c.set_node_size_mapping(**node_size_map) + # else: + # node_table = p4c.get_table_columns(table='node', network=network_name) + # nodes_SUID = node_table['SUID'].to_list() + # p4c.set_node_size_bypass(nodes_SUID, new_sizes=min_node_size, network=network_name) + # p4c.set_visual_style(style_name, network=network_name) + # time.sleep(1) # if not waited image export could be without applied style p4c.fit_content(selected_only=False, network=network_name) logger.debug('Style application to network successful.') def get_subgraph_node_selection( network_name: str = CYTO_BASE_NETWORK_NAME, - property_degree_weighted: str = PROPERTY_NAME_DEGREE_WEIGHTED, num_subgraphs: int = CYTO_NUMBER_SUBGRAPHS, ) -> list[CytoNodeID]: """Cytoscape: obtain the relevant nodes for iterative subgraph generation @@ -214,14 +275,9 @@ def get_subgraph_node_selection( list containing all relevant Cytoscape nodes """ logger.debug('Selecting nodes for subgraph generation...') - node_table = p4c.get_table_columns(network=network_name) - node_table['stress_norm'] = node_table['Stress'] / node_table['Stress'].max() - node_table[CYTO_SELECTION_PROPERTY] = ( - node_table[property_degree_weighted] - * node_table['BetweennessCentrality'] - * node_table['stress_norm'] - ) + node_table = p4c.get_table_columns(table='node', network=network_name) node_table = node_table.sort_values(by=CYTO_SELECTION_PROPERTY, ascending=False) + p4c.load_table_data(node_table, data_key_column='name', network=network_name) node_table_choice = node_table.iloc[:num_subgraphs, :] logger.debug('Selection of nodes for subgraph generation successful.') @@ -264,6 +320,7 @@ def make_subnetwork( index: int, network_name: str = CYTO_BASE_NETWORK_NAME, export_image: bool = True, + target_folder: Path = SAVE_PATH_FOLDER, ) -> None: """Cytoscape: generate a new subnetwork based on the currently selected nodes and edges @@ -289,7 +346,11 @@ def make_subnetwork( p4c.fit_content(selected_only=False, network=subnetwork_name) if export_image: time.sleep(1) - export_network_to_image(filename=subnetwork_name, network_name=subnetwork_name) + export_network_to_image( + filename=subnetwork_name, + target_folder=target_folder, + network_name=subnetwork_name, + ) logger.debug('Generation of subnetwork with index %d successful.', index) @@ -298,6 +359,7 @@ def build_subnetworks( nodes_to_analyse: Iterable[CytoNodeID], network_name: str = CYTO_BASE_NETWORK_NAME, export_image: bool = True, + target_folder: Path = SAVE_PATH_FOLDER, ) -> None: """Cytoscape: iteratively build subnetworks from a collection of nodes and their respective neighbouring nodes @@ -316,5 +378,10 @@ def build_subnetworks( logger.debug('Generating all subnetworks for node selection...') for idx, node in enumerate(nodes_to_analyse): select_neighbours_of_node(node=node, network_name=network_name) - make_subnetwork(index=idx, network_name=network_name, export_image=export_image) + make_subnetwork( + index=idx, + network_name=network_name, + export_image=export_image, + target_folder=target_folder, + ) logger.debug('Generation of all subnetworks for node selection successful.') diff --git a/src/lang_main/types.py b/src/lang_main/types.py index dfcd371..1d6ebec 100644 --- a/src/lang_main/types.py +++ b/src/lang_main/types.py @@ -33,6 +33,7 @@ ResultHandling: TypeAlias = list[tuple[bool, str | None]] class EntryPoints(enum.StrEnum): TIMELINE = 'TIMELINE' TIMELINE_POST = 'TIMELINE_POSTPROCESSING' + TIMELINE_TK_GRAPH_RESCALED = 'TIMELINE_TK_GRAPH_RESCALED' TK_GRAPH_POST = 'TK-GRAPH_POSTPROCESSING' TK_GRAPH_ANALYSIS = 'TK-GRAPH_ANALYSIS' TK_GRAPH_ANALYSIS_RESCALED = 'TK-GRAPH_ANALYSIS_RESCALED' diff --git a/test-notebooks/lang_main_config.toml b/test-notebooks/lang_main_config.toml index 3c00289..e83d210 100644 --- a/test-notebooks/lang_main_config.toml +++ b/test-notebooks/lang_main_config.toml @@ -2,7 +2,7 @@ [paths] inputs = './inputs/' -results = './results/test_20240619/' +results = '../scripts/results/test_20240619/' dataset = '../data/02_202307/Export4.csv' #results = './results/Export7/' #dataset = './01_03_Rohdaten_202403/Export7_59499_Zeilen.csv' diff --git a/test-notebooks/misc.ipynb b/test-notebooks/misc.ipynb index b9b554b..5fa845c 100644 --- a/test-notebooks/misc.ipynb +++ b/test-notebooks/misc.ipynb @@ -21,7 +21,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2024-07-19 05:54:50 +0000 | io:INFO | Loaded TOML config file successfully.\n" + "2024-07-24 06:14:08 +0000 | io:INFO | Loaded TOML config file successfully.\n" ] }, { @@ -98,7 +98,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2024-07-19 05:54:58 +0000 | io:INFO | Loaded file successfully.\n" + "2024-07-24 06:14:16 +0000 | io:INFO | Loaded file successfully.\n" ] } ], @@ -477,7 +477,7 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 6, "id": "2a3be1eb-b289-46ab-8d70-53110ad2806c", "metadata": {}, "outputs": [], @@ -490,7 +490,7 @@ }, { "cell_type": "code", - "execution_count": 94, + "execution_count": 7, "id": "64d8ba18-b1e2-470d-8bf5-9dd7cfec31de", "metadata": {}, "outputs": [ @@ -498,7 +498,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2024-07-17 07:15:34 +0000 | io:INFO | Loaded file successfully.\n" + "2024-07-24 06:14:31 +0000 | io:INFO | Loaded file successfully.\n" ] } ], @@ -508,7 +508,7 @@ }, { "cell_type": "code", - "execution_count": 95, + "execution_count": 8, "id": "d80522a0-c13a-42d3-af9d-8e10914c7831", "metadata": {}, "outputs": [], @@ -518,7 +518,7 @@ }, { "cell_type": "code", - "execution_count": 96, + "execution_count": 9, "id": "4a19d096-27f8-4626-97ee-31c0f84a294f", "metadata": {}, "outputs": [ @@ -534,7 +534,7 @@ " 'total_memory': 20492}" ] }, - "execution_count": 96, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -999,7 +999,7 @@ }, { "cell_type": "code", - "execution_count": 282, + "execution_count": 10, "id": "70104956-06d4-461b-ab4d-312d868f6e98", "metadata": {}, "outputs": [], @@ -1031,7 +1031,7 @@ }, { "cell_type": "code", - "execution_count": 283, + "execution_count": 11, "id": "2c240f53-0f6c-4de3-adcb-7be4f051ca2a", "metadata": {}, "outputs": [], @@ -1065,7 +1065,7 @@ }, { "cell_type": "code", - "execution_count": 304, + "execution_count": 12, "id": "9759f36d-761f-45fc-a9d2-157aef08c1bf", "metadata": {}, "outputs": [], @@ -1109,6 +1109,437 @@ " make_subnetwork(index=idx, network_name=network_name, export_image=export_image)" ] }, + { + "cell_type": "code", + "execution_count": 21, + "id": "c7dc0828-ea07-4bfe-b8e7-2dc97a5107db", + "metadata": {}, + "outputs": [], + "source": [ + "data = p4c.get_table_columns()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "d7117506-7f2d-4a0d-ac19-cd55996bdfd6", + "metadata": {}, + "outputs": [], + "source": [ + "data['test2'] = data['degree_weighted'] * 1000" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "1e2389d4-283b-458a-a6a0-dfbf5ee1a00e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SUIDshared namenameselectedAverageShortestPathLengthBetweennessCentralityClosenessCentralityClusteringCoefficientDegreeEccentricity...PartnerOfMultiEdgedNodePairsRadialitySelfLoopsStressTopologicalCoefficientiddegree_weightedrow.namestesttest2
257257anschreibenanschreibenFalse1.7500000.0000000.5714290.00000012...00.812500000.000000anschreiben0.2457257245.700002245.700002
259259ErledigungsdatumErledigungsdatumFalse1.7500000.0000000.5714290.00000012...00.812500000.000000Erledigungsdatum0.2457259245.700002245.700002
261261MonatMonatFalse4.9459460.0540540.2021860.00000029...00.7533780720.500000Monat0.4219261421.900004421.900004
263263durchführendurchführenFalse5.9189190.0000000.1689500.000000110...00.692568000.000000durchführen0.2457263245.700002245.700002
265265MotorMotorFalse1.0000000.8333331.0000000.16666741...01.0000000100.500000Motor0.9828265982.800007982.800007
..................................................................
247247SitzSitzFalse3.0000000.0000000.3333330.00000015...00.666667000.000000Sitz0.1580247158.000007158.000007
249249WäscherkontrolleWäscherkontrolleFalse3.4594590.0000000.2890621.00000027...00.846284000.666667Wäscherkontrolle0.4914249491.400003491.400003
251251BetriebsstundeBetriebsstundeFalse1.5000000.0000000.6666670.00000012...00.750000000.000000Betriebsstunde0.2524251252.400011252.400011
253253V-RöhreV-RöhreFalse1.5000000.0000000.6666670.00000012...00.750000000.000000V-Röhre0.2524253252.400011252.400011
255255WechselnWechselnFalse1.0000001.0000001.0000000.00000021...01.000000020.000000Wechseln0.5048255504.800022504.800022
\n", + "

158 rows × 24 columns

\n", + "
" + ], + "text/plain": [ + " SUID shared name name selected \\\n", + "257 257 anschreiben anschreiben False \n", + "259 259 Erledigungsdatum Erledigungsdatum False \n", + "261 261 Monat Monat False \n", + "263 263 durchführen durchführen False \n", + "265 265 Motor Motor False \n", + ".. ... ... ... ... \n", + "247 247 Sitz Sitz False \n", + "249 249 Wäscherkontrolle Wäscherkontrolle False \n", + "251 251 Betriebsstunde Betriebsstunde False \n", + "253 253 V-Röhre V-Röhre False \n", + "255 255 Wechseln Wechseln False \n", + "\n", + " AverageShortestPathLength BetweennessCentrality ClosenessCentrality \\\n", + "257 1.750000 0.000000 0.571429 \n", + "259 1.750000 0.000000 0.571429 \n", + "261 4.945946 0.054054 0.202186 \n", + "263 5.918919 0.000000 0.168950 \n", + "265 1.000000 0.833333 1.000000 \n", + ".. ... ... ... \n", + "247 3.000000 0.000000 0.333333 \n", + "249 3.459459 0.000000 0.289062 \n", + "251 1.500000 0.000000 0.666667 \n", + "253 1.500000 0.000000 0.666667 \n", + "255 1.000000 1.000000 1.000000 \n", + "\n", + " ClusteringCoefficient Degree Eccentricity ... \\\n", + "257 0.000000 1 2 ... \n", + "259 0.000000 1 2 ... \n", + "261 0.000000 2 9 ... \n", + "263 0.000000 1 10 ... \n", + "265 0.166667 4 1 ... \n", + ".. ... ... ... ... \n", + "247 0.000000 1 5 ... \n", + "249 1.000000 2 7 ... \n", + "251 0.000000 1 2 ... \n", + "253 0.000000 1 2 ... \n", + "255 0.000000 2 1 ... \n", + "\n", + " PartnerOfMultiEdgedNodePairs Radiality SelfLoops Stress \\\n", + "257 0 0.812500 0 0 \n", + "259 0 0.812500 0 0 \n", + "261 0 0.753378 0 72 \n", + "263 0 0.692568 0 0 \n", + "265 0 1.000000 0 10 \n", + ".. ... ... ... ... \n", + "247 0 0.666667 0 0 \n", + "249 0 0.846284 0 0 \n", + "251 0 0.750000 0 0 \n", + "253 0 0.750000 0 0 \n", + "255 0 1.000000 0 2 \n", + "\n", + " TopologicalCoefficient id degree_weighted row.names \\\n", + "257 0.000000 anschreiben 0.2457 257 \n", + "259 0.000000 Erledigungsdatum 0.2457 259 \n", + "261 0.500000 Monat 0.4219 261 \n", + "263 0.000000 durchführen 0.2457 263 \n", + "265 0.500000 Motor 0.9828 265 \n", + ".. ... ... ... ... \n", + "247 0.000000 Sitz 0.1580 247 \n", + "249 0.666667 Wäscherkontrolle 0.4914 249 \n", + "251 0.000000 Betriebsstunde 0.2524 251 \n", + "253 0.000000 V-Röhre 0.2524 253 \n", + "255 0.000000 Wechseln 0.5048 255 \n", + "\n", + " test test2 \n", + "257 245.700002 245.700002 \n", + "259 245.700002 245.700002 \n", + "261 421.900004 421.900004 \n", + "263 245.700002 245.700002 \n", + "265 982.800007 982.800007 \n", + ".. ... ... \n", + "247 158.000007 158.000007 \n", + "249 491.400003 491.400003 \n", + "251 252.400011 252.400011 \n", + "253 252.400011 252.400011 \n", + "255 504.800022 504.800022 \n", + "\n", + "[158 rows x 24 columns]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, { "cell_type": "markdown", "id": "facae316-6acb-4094-9eef-19bead44a813", @@ -1214,6 +1645,523 @@ "build_subnetworks(nodes_to_analyse=nodes_to_analyse, export_image=True)" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "39a61348-f2b6-4bf8-bc71-5d77e38bef47", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "fae73cc5-ac29-463d-8ea3-87a1c8072932", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SUIDshared namenameselectediddegree_weightedAverageShortestPathLengthClusteringCoefficientClosenessCentralityIsSingleNode...StressDegreeBetweennessCentralityNeighborhoodConnectivityNumberOfDirectedEdgesNumberOfUndirectedEdgesRadialityTopologicalCoefficientstress_normnode_selection
1638516385FremdkörperFremdkörperFalseFremdkörper0.12571.0000000.01.00False...010.0000001.0011.0000000.00.0000000.000000
1613016130AschenbecherAschenbecherFalseAschenbecher0.71141.3333330.00.75False...420.6666671.5020.8333330.50.0022750.001079
1638816388anfragenanfragenFalseanfragen0.45571.0000000.01.00False...010.0000001.0011.0000000.00.0000000.000000
1613316133leerenleerenFalseleeren0.35572.0000000.00.50False...010.0000002.0010.5000000.00.0000000.000000
1639116391TerminTerminFalseTermin0.45571.0000000.01.00False...010.0000001.0011.0000000.00.0000000.000000
..................................................................
1612116121WasserverbrauchWasserverbrauchFalseWasserverbrauch0.42981.0000000.01.00False...010.0000001.0011.0000000.00.0000000.000000
1637916379SicherstellungSicherstellungFalseSicherstellung0.12571.0000000.01.00False...010.0000001.0011.0000000.00.0000000.000000
1612416124auffüllenauffüllenFalseauffüllen0.71141.3333330.00.75False...420.6666671.5020.8333330.50.0022750.001079
1638216382AusblasöffnungAusblasöffnungFalseAusblasöffnung0.12571.0000000.01.00False...010.0000001.0011.0000000.00.0000000.000000
1612716127DesifektionsmittelDesifektionsmittelFalseDesifektionsmittel0.35572.0000000.00.50False...010.0000002.0010.5000000.00.0000000.000000
\n", + "

158 rows × 23 columns

\n", + "
" + ], + "text/plain": [ + " SUID shared name name selected \\\n", + "16385 16385 Fremdkörper Fremdkörper False \n", + "16130 16130 Aschenbecher Aschenbecher False \n", + "16388 16388 anfragen anfragen False \n", + "16133 16133 leeren leeren False \n", + "16391 16391 Termin Termin False \n", + "... ... ... ... ... \n", + "16121 16121 Wasserverbrauch Wasserverbrauch False \n", + "16379 16379 Sicherstellung Sicherstellung False \n", + "16124 16124 auffüllen auffüllen False \n", + "16382 16382 Ausblasöffnung Ausblasöffnung False \n", + "16127 16127 Desifektionsmittel Desifektionsmittel False \n", + "\n", + " id degree_weighted AverageShortestPathLength \\\n", + "16385 Fremdkörper 0.1257 1.000000 \n", + "16130 Aschenbecher 0.7114 1.333333 \n", + "16388 anfragen 0.4557 1.000000 \n", + "16133 leeren 0.3557 2.000000 \n", + "16391 Termin 0.4557 1.000000 \n", + "... ... ... ... \n", + "16121 Wasserverbrauch 0.4298 1.000000 \n", + "16379 Sicherstellung 0.1257 1.000000 \n", + "16124 auffüllen 0.7114 1.333333 \n", + "16382 Ausblasöffnung 0.1257 1.000000 \n", + "16127 Desifektionsmittel 0.3557 2.000000 \n", + "\n", + " ClusteringCoefficient ClosenessCentrality IsSingleNode ... Stress \\\n", + "16385 0.0 1.00 False ... 0 \n", + "16130 0.0 0.75 False ... 4 \n", + "16388 0.0 1.00 False ... 0 \n", + "16133 0.0 0.50 False ... 0 \n", + "16391 0.0 1.00 False ... 0 \n", + "... ... ... ... ... ... \n", + "16121 0.0 1.00 False ... 0 \n", + "16379 0.0 1.00 False ... 0 \n", + "16124 0.0 0.75 False ... 4 \n", + "16382 0.0 1.00 False ... 0 \n", + "16127 0.0 0.50 False ... 0 \n", + "\n", + " Degree BetweennessCentrality NeighborhoodConnectivity \\\n", + "16385 1 0.000000 1.0 \n", + "16130 2 0.666667 1.5 \n", + "16388 1 0.000000 1.0 \n", + "16133 1 0.000000 2.0 \n", + "16391 1 0.000000 1.0 \n", + "... ... ... ... \n", + "16121 1 0.000000 1.0 \n", + "16379 1 0.000000 1.0 \n", + "16124 2 0.666667 1.5 \n", + "16382 1 0.000000 1.0 \n", + "16127 1 0.000000 2.0 \n", + "\n", + " NumberOfDirectedEdges NumberOfUndirectedEdges Radiality \\\n", + "16385 0 1 1.000000 \n", + "16130 0 2 0.833333 \n", + "16388 0 1 1.000000 \n", + "16133 0 1 0.500000 \n", + "16391 0 1 1.000000 \n", + "... ... ... ... \n", + "16121 0 1 1.000000 \n", + "16379 0 1 1.000000 \n", + "16124 0 2 0.833333 \n", + "16382 0 1 1.000000 \n", + "16127 0 1 0.500000 \n", + "\n", + " TopologicalCoefficient stress_norm node_selection \n", + "16385 0.0 0.000000 0.000000 \n", + "16130 0.5 0.002275 0.001079 \n", + "16388 0.0 0.000000 0.000000 \n", + "16133 0.0 0.000000 0.000000 \n", + "16391 0.0 0.000000 0.000000 \n", + "... ... ... ... \n", + "16121 0.0 0.000000 0.000000 \n", + "16379 0.0 0.000000 0.000000 \n", + "16124 0.5 0.002275 0.001079 \n", + "16382 0.0 0.000000 0.000000 \n", + "16127 0.0 0.000000 0.000000 \n", + "\n", + "[158 rows x 23 columns]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = p4c.get_table_columns()\n", + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "4b1e0799-59ac-431d-9e3f-8752bb0a4be5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "min_val=0.0, max_val=3.008924891341149\n" + ] + } + ], + "source": [ + "min_val = data['node_selection'].min()\n", + "max_val = data['node_selection'].max()\n", + "print(f'{min_val=}, {max_val=}')" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "6d2e939c-7218-4449-a0de-8679f57f43b2", + "metadata": {}, + "outputs": [], + "source": [ + "scheme = p4c.scheme_c_number_continuous(start_value=15, end_value=40)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "17f6c3f1-4584-47ed-b563-2e71b6850184", + "metadata": {}, + "outputs": [], + "source": [ + "node_size_map = p4c.gen_node_size_map('node_selection', number_scheme=scheme, mapping_type='c', style_name='lang_main', default_number=18)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "842b04be-f434-4530-afac-22c892e1fc83", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'table_column': 'node_selection',\n", + " 'table_column_values': [0.0, 1.5044624456705744, 3.008924891341149],\n", + " 'sizes': [15, 27.5, 40],\n", + " 'mapping_type': 'c',\n", + " 'default_size': 18,\n", + " 'style_name': 'lang_main',\n", + " 'network': None,\n", + " 'base_url': 'http://127.0.0.1:1234/v1'}" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_size_map" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "34dd3ada-c65b-4914-a918-e1798ef4e88b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "''" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p4c.set_node_size_mapping(**node_size_map)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d5b6c04b-dfe1-4cfc-bf0a-8251a9367a81", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": 9, @@ -3465,6 +4413,4215 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "markdown", + "id": "52792182-c8bc-4973-9682-36360604705b", + "metadata": {}, + "source": [ + "---\n", + "\n", + "# Find reason that TokenGraph weight sometimes is zero" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7e5c6d2c-2558-4c6a-9e0b-19e36279b4ce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-07-24 14:22:25 +0000 | io:INFO | Loaded TOML config file successfully.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "A:\\Arbeitsaufgaben\\lang-main\\.venv\\Lib\\site-packages\\transformers\\utils\\generic.py:441: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", + " _torch_pytree._register_pytree_node(\n", + "A:\\Arbeitsaufgaben\\lang-main\\.venv\\Lib\\site-packages\\huggingface_hub\\file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n", + " warnings.warn(\n", + "A:\\Arbeitsaufgaben\\lang-main\\.venv\\Lib\\site-packages\\transformers\\utils\\generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", + " _torch_pytree._register_pytree_node(\n", + "A:\\Arbeitsaufgaben\\lang-main\\.venv\\Lib\\site-packages\\transformers\\utils\\generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", + " _torch_pytree._register_pytree_node(\n", + "A:\\Arbeitsaufgaben\\lang-main\\.venv\\Lib\\site-packages\\huggingface_hub\\file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "from lang_main.constants import SAVE_PATH_FOLDER, SPCY_MODEL\n", + "from lang_main.types import EntryPoints\n", + "from lang_main import io\n", + "from lang_main.analysis import tokens, graphs" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f4cad9da-6570-41c5-9adb-032052e34a7d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-07-24 14:22:30 +0000 | io:INFO | Loaded file successfully.\n" + ] + } + ], + "source": [ + "p_df = io.get_entry_point(SAVE_PATH_FOLDER, EntryPoints.TIMELINE)\n", + "(data,) = io.load_pickle(p_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c7c683a5-a6db-42b0-84f0-7806d30bd46f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
VorgangsIDObjektIDHObjektTextObjektArtIDObjektArtTextVorgangsTypIDVorgangsTypNameVorgangsDatumVorgangsStatusIdVorgangsPrioritaetVorgangsBeschreibungVorgangsOrtVorgangsArtTextErledigungsDatumErledigungsArtTextErledigungsBeschreibungMPMelderArbeitsplatzMPAbteilungBezeichnungArbeitsbeginnErstellungsDatum
053244285 C, Webmaschine, SG 220 EMS5Greifer-Webmaschine3Reparaturauftrag (Portal)2019-03-1950Kupplung schleiftNaNKupplung defekt2019-03-20Reparatur UTTNaNWebereiWebereiNaT2019-03-19
158257107, Webmaschine, OM 220 EOS3Luft-Webmaschine3Reparaturauftrag (Portal)2019-03-2150Gegengewicht wieder anbringenNaNGegengewicht an der Webmaschine abgefallen2019-03-21Reparatur UTTSchraube ausgebohrt\\nGegengewicht wieder angeb...WebereiWeberei2019-03-212019-03-21
28113800138, Schärmaschine 9,16Schärmaschine3Reparaturauftrag (Portal)2019-03-2550da ist etwas gebrochen. (Herr Heininger)NaNzentrale Bremsenverstellung linke Gatterseite ...2019-03-25Reparatur UTTBolzen gebrochen. Bolzen neu angefertig und di...VorwerkVorwerk2019-03-252019-03-25
3820Warenschau allgemein0NaN3Reparaturauftrag (Portal)2019-03-2550Klappbügel Portalkran H31 defektWarenschau allgemeinAllgemeine Reparaturarbeiten2019-03-25Reparatur UTTFeder ausgetauschtWarenschauWarenschau2019-03-252019-03-25
4760Neben der Türe0NaN3Reparaturauftrag (Portal)2019-03-2250Schraube nix mer gutNeben der TüreKettbaum2019-03-25Reparatur UTTSchrauben ausgebohrt\\t\\nGewinde nachgeschnitten\\tVorwerkVorwerk2019-03-252019-03-22
\n", + "
" + ], + "text/plain": [ + " VorgangsID ObjektID HObjektText ObjektArtID \\\n", + "0 53 244 285 C, Webmaschine, SG 220 EMS 5 \n", + "1 58 257 107, Webmaschine, OM 220 EOS 3 \n", + "2 81 138 00138, Schärmaschine 9, 16 \n", + "3 82 0 Warenschau allgemein 0 \n", + "4 76 0 Neben der Türe 0 \n", + "\n", + " ObjektArtText VorgangsTypID VorgangsTypName \\\n", + "0 Greifer-Webmaschine 3 Reparaturauftrag (Portal) \n", + "1 Luft-Webmaschine 3 Reparaturauftrag (Portal) \n", + "2 Schärmaschine 3 Reparaturauftrag (Portal) \n", + "3 NaN 3 Reparaturauftrag (Portal) \n", + "4 NaN 3 Reparaturauftrag (Portal) \n", + "\n", + " VorgangsDatum VorgangsStatusId VorgangsPrioritaet \\\n", + "0 2019-03-19 5 0 \n", + "1 2019-03-21 5 0 \n", + "2 2019-03-25 5 0 \n", + "3 2019-03-25 5 0 \n", + "4 2019-03-22 5 0 \n", + "\n", + " VorgangsBeschreibung VorgangsOrt \\\n", + "0 Kupplung schleift NaN \n", + "1 Gegengewicht wieder anbringen NaN \n", + "2 da ist etwas gebrochen. (Herr Heininger) NaN \n", + "3 Klappbügel Portalkran H31 defekt Warenschau allgemein \n", + "4 Schraube nix mer gut Neben der Türe \n", + "\n", + " VorgangsArtText ErledigungsDatum \\\n", + "0 Kupplung defekt 2019-03-20 \n", + "1 Gegengewicht an der Webmaschine abgefallen 2019-03-21 \n", + "2 zentrale Bremsenverstellung linke Gatterseite ... 2019-03-25 \n", + "3 Allgemeine Reparaturarbeiten 2019-03-25 \n", + "4 Kettbaum 2019-03-25 \n", + "\n", + " ErledigungsArtText ErledigungsBeschreibung \\\n", + "0 Reparatur UTT NaN \n", + "1 Reparatur UTT Schraube ausgebohrt\\nGegengewicht wieder angeb... \n", + "2 Reparatur UTT Bolzen gebrochen. Bolzen neu angefertig und di... \n", + "3 Reparatur UTT Feder ausgetauscht \n", + "4 Reparatur UTT Schrauben ausgebohrt\\t\\nGewinde nachgeschnitten\\t \n", + "\n", + " MPMelderArbeitsplatz MPAbteilungBezeichnung Arbeitsbeginn ErstellungsDatum \n", + "0 Weberei Weberei NaT 2019-03-19 \n", + "1 Weberei Weberei 2019-03-21 2019-03-21 \n", + "2 Vorwerk Vorwerk 2019-03-25 2019-03-25 \n", + "3 Warenschau Warenschau 2019-03-25 2019-03-25 \n", + "4 Vorwerk Vorwerk 2019-03-25 2019-03-22 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "aba15410-474a-476d-bad5-c5ded56322be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-07-24 14:22:30 +0000 | io:INFO | Loaded file successfully.\n" + ] + } + ], + "source": [ + "p_tl = io.get_entry_point(SAVE_PATH_FOLDER, EntryPoints.TIMELINE_POST)\n", + "cands, texts = io.load_pickle(p_tl)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6c3d5ae4-d28b-4322-a41b-d0bfc647081b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(7552,\n", + " 8192,\n", + " 119558,\n", + " 647,\n", + " 2310,\n", + " 48781,\n", + " 66323,\n", + " 8214,\n", + " 5405,\n", + " 108961,\n", + " 91173,\n", + " 2985,\n", + " 3881,\n", + " 9917,\n", + " 66751,\n", + " 85442,\n", + " 118602,\n", + " 7243,\n", + " 62416,\n", + " 979,\n", + " 214,\n", + " 103,\n", + " 123111,\n", + " 81133,\n", + " 88558,\n", + " 14319,\n", + " 14834,\n", + " 2424,\n", + " 101497,\n", + " 25341,\n", + " 69375)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cands[1654][1]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "62ef88ef-c1cb-4dc9-b88d-be335984b393", + "metadata": {}, + "outputs": [], + "source": [ + "def pre_filter_data(\n", + " data,\n", + " idx,\n", + " obj_id,\n", + "):\n", + " idx = int(idx)\n", + " obj_id = int(obj_id)\n", + " # data = data.copy()\n", + " cands_for_obj_id = cands[obj_id]\n", + " cands_choice = cands_for_obj_id[int(idx) - 1]\n", + " # data\n", + " data = data.loc[list(cands_choice)].sort_index() # type: ignore\n", + "\n", + " return data" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "0433246a-174b-4e6d-b432-9b3cd8861677", + "metadata": {}, + "outputs": [], + "source": [ + "# filtered = pre_filter_data(data, 2, 1654)\n", + "# filtered = pre_filter_data(data, 1, 1809)\n", + "filtered = pre_filter_data(data, 1, 59)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "7c90c295-c7bc-4c99-ab74-a30f4015cde8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
VorgangsIDObjektIDHObjektTextObjektArtIDObjektArtTextVorgangsTypIDVorgangsTypNameVorgangsDatumVorgangsStatusIdVorgangsPrioritaetVorgangsBeschreibungVorgangsOrtVorgangsArtTextErledigungsDatumErledigungsArtTextErledigungsBeschreibungMPMelderArbeitsplatzMPAbteilungBezeichnungArbeitsbeginnErstellungsDatum
18813936159514 C , Webmaschine, DL 280 EMS Breite 280 Bj....3Luft-Webmaschine3Reparaturauftrag (Portal)2021-09-1650Stab muss getauscht werdenNaNStabbreithalter Reparatur2021-09-15Intern UTT - ReparaturUTT-ReparaturWebereiWeberei2021-09-152021-09-16
609615101759514 C , Webmaschine, DL 280 EMS Breite 280 Bj....3Luft-Webmaschine3Reparaturauftrag (Portal)2022-02-1050Stab wurde getauschtNaNStabbreithalter Reparatur2022-02-10Intern UTT - ReparaturStab wurde getauschtWebereiWeberei2022-02-102022-02-10
1047058765259514 C , Webmaschine, DL 280 EMS Breite 280 Bj....3Luft-Webmaschine3Reparaturauftrag (Portal)2023-06-1350Stab wurde getauschtNaNStabbreithalter Reparatur2023-06-13Intern UTT - ReparaturStab wurde getauschtWebereiWeberei2023-06-132023-06-13
5397426053459514 C , Webmaschine, DL 280 EMS Breite 280 Bj....3Luft-Webmaschine3Reparaturauftrag (Portal)2022-06-1550Stab wurde getauschtNaNStabbreithalter Reparatur2022-06-15Intern UTT - ReparaturStab wurde getauschtWebereiWeberei2022-06-152022-06-15
10754253147359514 C , Webmaschine, DL 280 EMS Breite 280 Bj....3Luft-Webmaschine3Reparaturauftrag (Portal)2023-05-0850Stab wurde getauschtNaNStabbreithalter Reparatur2023-05-08Intern UTT - ReparaturSichtkontrolle durchgeführt\\nstab wurde getaus...WebereiWeberei2023-05-082023-05-08
12241151348959514 C , Webmaschine, DL 280 EMS Breite 280 Bj....3Luft-Webmaschine3Reparaturauftrag (Portal)2023-02-1550Stab wurde getauschtNaNStabbreithalter Reparatur2023-02-15Intern UTT - ReparaturStab wurde getauschtWebereiWeberei2023-02-152023-02-15
\n", + "
" + ], + "text/plain": [ + " VorgangsID ObjektID \\\n", + "188 139361 59 \n", + "6096 151017 59 \n", + "10470 587652 59 \n", + "53974 260534 59 \n", + "107542 531473 59 \n", + "122411 513489 59 \n", + "\n", + " HObjektText ObjektArtID \\\n", + "188 514 C , Webmaschine, DL 280 EMS Breite 280 Bj.... 3 \n", + "6096 514 C , Webmaschine, DL 280 EMS Breite 280 Bj.... 3 \n", + "10470 514 C , Webmaschine, DL 280 EMS Breite 280 Bj.... 3 \n", + "53974 514 C , Webmaschine, DL 280 EMS Breite 280 Bj.... 3 \n", + "107542 514 C , Webmaschine, DL 280 EMS Breite 280 Bj.... 3 \n", + "122411 514 C , Webmaschine, DL 280 EMS Breite 280 Bj.... 3 \n", + "\n", + " ObjektArtText VorgangsTypID VorgangsTypName \\\n", + "188 Luft-Webmaschine 3 Reparaturauftrag (Portal) \n", + "6096 Luft-Webmaschine 3 Reparaturauftrag (Portal) \n", + "10470 Luft-Webmaschine 3 Reparaturauftrag (Portal) \n", + "53974 Luft-Webmaschine 3 Reparaturauftrag (Portal) \n", + "107542 Luft-Webmaschine 3 Reparaturauftrag (Portal) \n", + "122411 Luft-Webmaschine 3 Reparaturauftrag (Portal) \n", + "\n", + " VorgangsDatum VorgangsStatusId VorgangsPrioritaet \\\n", + "188 2021-09-16 5 0 \n", + "6096 2022-02-10 5 0 \n", + "10470 2023-06-13 5 0 \n", + "53974 2022-06-15 5 0 \n", + "107542 2023-05-08 5 0 \n", + "122411 2023-02-15 5 0 \n", + "\n", + " VorgangsBeschreibung VorgangsOrt VorgangsArtText \\\n", + "188 Stab muss getauscht werden NaN Stabbreithalter Reparatur \n", + "6096 Stab wurde getauscht NaN Stabbreithalter Reparatur \n", + "10470 Stab wurde getauscht NaN Stabbreithalter Reparatur \n", + "53974 Stab wurde getauscht NaN Stabbreithalter Reparatur \n", + "107542 Stab wurde getauscht NaN Stabbreithalter Reparatur \n", + "122411 Stab wurde getauscht NaN Stabbreithalter Reparatur \n", + "\n", + " ErledigungsDatum ErledigungsArtText \\\n", + "188 2021-09-15 Intern UTT - Reparatur \n", + "6096 2022-02-10 Intern UTT - Reparatur \n", + "10470 2023-06-13 Intern UTT - Reparatur \n", + "53974 2022-06-15 Intern UTT - Reparatur \n", + "107542 2023-05-08 Intern UTT - Reparatur \n", + "122411 2023-02-15 Intern UTT - Reparatur \n", + "\n", + " ErledigungsBeschreibung \\\n", + "188 UTT-Reparatur \n", + "6096 Stab wurde getauscht \n", + "10470 Stab wurde getauscht \n", + "53974 Stab wurde getauscht \n", + "107542 Sichtkontrolle durchgeführt\\nstab wurde getaus... \n", + "122411 Stab wurde getauscht \n", + "\n", + " MPMelderArbeitsplatz MPAbteilungBezeichnung Arbeitsbeginn \\\n", + "188 Weberei Weberei 2021-09-15 \n", + "6096 Weberei Weberei 2022-02-10 \n", + "10470 Weberei Weberei 2023-06-13 \n", + "53974 Weberei Weberei 2022-06-15 \n", + "107542 Weberei Weberei 2023-05-08 \n", + "122411 Weberei Weberei 2023-02-15 \n", + "\n", + " ErstellungsDatum \n", + "188 2021-09-16 \n", + "6096 2022-02-10 \n", + "10470 2023-06-13 \n", + "53974 2022-06-15 \n", + "107542 2023-05-08 \n", + "122411 2023-02-15 " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "filtered" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "51c14b60-a979-4097-a364-3585cbb00b8b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['VorgangsID', 'ObjektID', 'HObjektText', 'ObjektArtID', 'ObjektArtText',\n", + " 'VorgangsTypID', 'VorgangsTypName', 'VorgangsDatum', 'VorgangsStatusId',\n", + " 'VorgangsPrioritaet', 'VorgangsBeschreibung', 'VorgangsOrt',\n", + " 'VorgangsArtText', 'ErledigungsDatum', 'ErledigungsArtText',\n", + " 'ErledigungsBeschreibung', 'MPMelderArbeitsplatz',\n", + " 'MPAbteilungBezeichnung', 'Arbeitsbeginn', 'ErstellungsDatum'],\n", + " dtype='object')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "filtered.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a70700f3-f872-409b-9f2b-d6e36bed71f1", + "metadata": {}, + "outputs": [], + "source": [ + "filtered['delta'] = filtered['ErledigungsDatum'] - filtered['ErstellungsDatum']\n", + "filtered['delta'] = filtered['delta'].dt.days" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f13099a1-539d-4f92-8c18-315b02a061af", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "65a14689-081d-42ed-be6a-e49731a14f59", + "metadata": {}, + "outputs": [], + "source": [ + "import plotly.express as px" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "03201127-e31f-43a0-9580-f74c52052ac9", + "metadata": {}, + "outputs": [], + "source": [ + "MARKERS = {\n", + " 'size': 8,\n", + " 'color': 'red',\n", + " 'symbol': 'cross',\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "id": "d221446d-6c83-45be-9fcb-fd926ac2a925", + "metadata": {}, + "outputs": [], + "source": [ + "HOVER_DATA_DELTA = {\n", + " 'ErstellungsDatum': '|%d.%m.%Y',\n", + " 'ErledigungsDatum': '|%d.%m.%Y',\n", + " 'VorgangsDatum': '|%d.%m.%Y',\n", + " 'delta': True,\n", + " 'VorgangsBeschreibung': True,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "0990eb39-a5ae-4f05-88d8-1a2624284a2d", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "customdata": [ + [ + "2020-12-14T00:00:00", + "2020-12-10T00:00:00", + "Kettbaum schrauben abgerochen schrauben ausboren" + ], + [ + "2021-12-17T00:00:00", + "2021-12-16T00:00:00", + "Neue Löcher bohren und Gewinde schneiden. Kettbaum liegt vor der Schlosserei" + ], + [ + "2022-06-22T00:00:00", + "2022-06-21T00:00:00", + "Kettbaum Gewinde nach schneiden (liegt vor Schlosserei)" + ], + [ + "2022-12-13T00:00:00", + "2022-12-12T00:00:00", + "Kettbaum Gewinden kaputt, neue Gewinden machen bitte" + ], + [ + "2022-02-03T00:00:00", + "2022-02-03T00:00:00", + "Gewinde schneiden. Kette liegt vor der Schlosserei" + ], + [ + "2022-03-28T00:00:00", + "2022-03-28T00:00:00", + "Kettbaum Schraube defekt. Liegt vor Schlosserei" + ], + [ + "2022-01-26T00:00:00", + "2022-01-26T00:00:00", + "2 Kettbäume Schrauben ausbohren. Kettbäume liegen vor der Schlosserei" + ], + [ + "2021-12-16T00:00:00", + "2021-12-15T00:00:00", + "Kettbaum Schrauben gebrochen bitte rausbohren" + ], + [ + "2023-01-23T00:00:00", + "2023-01-21T00:00:00", + "Schraube abgebrochen! Kettbaum liegt vor der Schlosserei" + ], + [ + "2021-12-13T00:00:00", + "2021-12-12T00:00:00", + "Kettbaum bei seiten Gewinde neu schneiden" + ], + [ + "2020-02-10T00:00:00", + "2020-02-10T00:00:00", + "Kettbäume vor Schlosserei" + ], + [ + "2019-11-18T00:00:00", + "2019-11-13T00:00:00", + "3*Kettbaum Gewinde nachschneiden" + ], + [ + "2019-11-11T00:00:00", + "2019-11-11T00:00:00", + "2X Kettbaum Gewinden nachschneiden" + ], + [ + "2023-01-26T00:00:00", + "2023-01-25T00:00:00", + "Kettbaum Gewinde nach schneiden. Kette liegt vor der Schlosserei." + ], + [ + "2020-03-23T00:00:00", + "2020-03-23T00:00:00", + "Bei allen 3 Kettbäumen Gewinde neu Schneiden. Ketten liegen vor der Schlosserei" + ], + [ + "2020-03-23T00:00:00", + "2020-03-22T00:00:00", + "Neues Gewinde Schneiden. Kette liegt vor der Schlosserei" + ], + [ + "2020-06-24T00:00:00", + "2020-06-24T00:00:00", + "Kettbaum Gewinde defekt" + ], + [ + "2021-01-08T00:00:00", + "2021-01-06T00:00:00", + "Kettbaum gewinde nachschneiden (Kettbaum vor Schlosserei)" + ], + [ + "2022-09-16T00:00:00", + "2022-09-12T00:00:00", + "Kettbaum Schrauben rund 2X liegen vor Schlosserei" + ], + [ + "2020-01-10T00:00:00", + "2020-01-09T00:00:00", + "Gewinde vom Kettbaum nachschneiden (Kette liegt vor Schlosserei)" + ], + [ + "2020-01-13T00:00:00", + "2020-01-10T00:00:00", + "Kettbaum Schrauben prüfen" + ], + [ + "2021-07-08T00:00:00", + "2021-07-06T00:00:00", + "Neues Gewinde am Kettbaum Schneiden. Kette liegt vor der Schlosserei" + ], + [ + "2020-02-20T00:00:00", + "2020-02-20T00:00:00", + "Gewinde defekt. Kette liegt vor der Schlosserei." + ], + [ + "2022-04-01T00:00:00", + "2022-04-01T00:00:00", + "Kettbaum Gewinde Schneiden, liegt vor der Schlosserei. ( Volle Kette) . 471 Wartet auf die Kette zum Andrehen." + ], + [ + "2021-05-05T00:00:00", + "2021-05-05T00:00:00", + "Adabter Scheibe Gewinde schneiden. Liegt in der Schlosserei auf der Werkbank." + ], + [ + "2022-05-24T00:00:00", + "2022-05-23T00:00:00", + "Kettbaum vor der Schlosserei neue Löcher bohren und Gewinde schneiden" + ], + [ + "2022-01-31T00:00:00", + "2022-01-30T00:00:00", + "Gewinde vom Kettbaum defekt. Neue Löcher bohren + Gewinde schneiden" + ], + [ + "2023-03-13T00:00:00", + "2023-03-12T00:00:00", + "Kettbaum-Schrauben abgebrochen !" + ], + [ + "2022-03-24T00:00:00", + "2022-03-24T00:00:00", + "Kettbaum neue Löcher bohren und Gewinde schneiden" + ], + [ + "2022-04-26T00:00:00", + "2022-04-25T00:00:00", + "Kettbaum Gewinde defekt (liegt vor Schlosserei)" + ], + [ + "2023-05-11T00:00:00", + "2023-05-11T00:00:00", + "Gebrochene Kettbaum Scheibe auswechseln. Steht vor der Schlosserei." + ] + ], + "hovertemplate": "ErstellungsDatum=%{x|%d.%m.%Y}
delta=%{y}
ErledigungsDatum=%{customdata[0]|%d.%m.%Y}
VorgangsDatum=%{customdata[1]|%d.%m.%Y}
VorgangsBeschreibung=%{customdata[2]}", + "legendgroup": "", + "marker": { + "color": "red", + "size": 8, + "symbol": "cross" + }, + "mode": "markers", + "name": "", + "orientation": "v", + "showlegend": false, + "type": "scatter", + "x": [ + "2020-12-10T00:00:00", + "2021-12-16T00:00:00", + "2022-06-21T00:00:00", + "2022-12-12T00:00:00", + "2022-02-03T00:00:00", + "2022-03-28T00:00:00", + "2022-01-26T00:00:00", + "2021-12-15T00:00:00", + "2023-01-21T00:00:00", + "2021-12-12T00:00:00", + "2020-02-10T00:00:00", + "2019-11-13T00:00:00", + "2019-11-11T00:00:00", + "2023-01-25T00:00:00", + "2020-03-23T00:00:00", + "2020-03-22T00:00:00", + "2020-06-24T00:00:00", + "2021-01-06T00:00:00", + "2022-09-12T00:00:00", + "2020-01-09T00:00:00", + "2020-01-10T00:00:00", + "2021-07-06T00:00:00", + "2020-02-20T00:00:00", + "2022-04-01T00:00:00", + "2021-05-05T00:00:00", + "2022-05-23T00:00:00", + "2022-01-30T00:00:00", + "2023-03-12T00:00:00", + "2022-03-24T00:00:00", + "2022-04-25T00:00:00", + "2023-05-11T00:00:00" + ], + "xaxis": "x", + "y": [ + 4, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 2, + 1, + 0, + 5, + 0, + 1, + 0, + 1, + 0, + 2, + 4, + 1, + 3, + 2, + 0, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 0 + ], + "yaxis": "y" + } + ], + "layout": { + "autosize": true, + "hovermode": "x unified", + "legend": { + "tracegroupgap": 0 + }, + "margin": { + "t": 60 + }, + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "xaxis": { + "anchor": "y", + "autorange": true, + "domain": [ + 0, + 1 + ], + "range": [ + "2019-08-25 23:47:37.7827", + "2023-07-27 00:12:22.2173" + ], + "tickformat": "%B\n%Y", + "title": { + "text": "ErstellungsDatum" + }, + "type": "date" + }, + "yaxis": { + "anchor": "x", + "autorange": true, + "domain": [ + 0, + 1 + ], + "dtick": 1, + "range": [ + -0.425531914893617, + 5.425531914893617 + ], + "title": { + "text": "delta" + }, + "type": "linear" + } + } + }, + "image/png": "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", + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = px.scatter(filtered, x='ErstellungsDatum', y='delta', hover_data=HOVER_DATA_DELTA)\n", + "#fig = px.timeline(filtered, x_start='ErstellungsDatum', x_end='ErledigungsDatum', y='VorgangsID')\n", + "fig.update_traces(marker=MARKERS)\n", + "fig.update_xaxes(tickformat='%B\\n%Y')\n", + "#fig.update_yaxes(type='category')\n", + "fig.update_yaxes(dtick=1)\n", + "fig.update_layout(hovermode='x unified')" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "id": "cd71b556-592d-4c7e-a401-a66358b3e802", + "metadata": {}, + "outputs": [], + "source": [ + "scatt = go.Scatter(x=filtered['ErstellungsDatum'], y=filtered['delta'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aad3c784-363a-4355-b6e0-3d9caed46bc2", + "metadata": {}, + "outputs": [], + "source": [ + "scatt.update" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "id": "83ff5f68-5bbc-4c5e-aace-c19152ba61cb", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "type": "scatter", + "x": [ + "2020-12-10T00:00:00", + "2021-12-16T00:00:00", + "2022-06-21T00:00:00", + "2022-12-12T00:00:00", + "2022-02-03T00:00:00", + "2022-03-28T00:00:00", + "2022-01-26T00:00:00", + "2021-12-15T00:00:00", + "2023-01-21T00:00:00", + "2021-12-12T00:00:00", + "2020-02-10T00:00:00", + "2019-11-13T00:00:00", + "2019-11-11T00:00:00", + "2023-01-25T00:00:00", + "2020-03-23T00:00:00", + "2020-03-22T00:00:00", + "2020-06-24T00:00:00", + "2021-01-06T00:00:00", + "2022-09-12T00:00:00", + "2020-01-09T00:00:00", + "2020-01-10T00:00:00", + "2021-07-06T00:00:00", + "2020-02-20T00:00:00", + "2022-04-01T00:00:00", + "2021-05-05T00:00:00", + "2022-05-23T00:00:00", + "2022-01-30T00:00:00", + "2023-03-12T00:00:00", + "2022-03-24T00:00:00", + "2022-04-25T00:00:00", + "2023-05-11T00:00:00" + ], + "y": [ + 4, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 2, + 1, + 0, + 5, + 0, + 1, + 0, + 1, + 0, + 2, + 4, + 1, + 3, + 2, + 0, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 0 + ] + } + ], + "layout": { + "autosize": true, + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "xaxis": { + "autorange": true, + "range": [ + "2019-11-11", + "2023-05-11" + ], + "type": "date" + }, + "yaxis": { + "autorange": true, + "range": [ + -0.2777777777777778, + 5.277777777777778 + ], + "type": "linear" + } + } + }, + "image/png": "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", + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = go.Figure()\n", + "fig.add_trace(scatt)\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6825ed5b-3800-4fb7-8ba7-ea4fd6a846eb", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 117, + "id": "06841e37-df70-4d59-8883-2d11161ab47c", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "alignmentgroup": "True", + "base": [ + "2020-12-10T00:00:00", + "2021-12-16T00:00:00", + "2022-06-21T00:00:00", + "2022-12-12T00:00:00", + "2022-02-03T00:00:00", + "2022-03-28T00:00:00", + "2022-01-26T00:00:00", + "2021-12-15T00:00:00", + "2023-01-21T00:00:00", + "2021-12-12T00:00:00", + "2020-02-10T00:00:00", + "2019-11-13T00:00:00", + "2019-11-11T00:00:00", + "2023-01-25T00:00:00", + "2020-03-23T00:00:00", + "2020-03-22T00:00:00", + "2020-06-24T00:00:00", + "2021-01-06T00:00:00", + "2022-09-12T00:00:00", + "2020-01-09T00:00:00", + "2020-01-10T00:00:00", + "2021-07-06T00:00:00", + "2020-02-20T00:00:00", + "2022-04-01T00:00:00", + "2021-05-05T00:00:00", + "2022-05-23T00:00:00", + "2022-01-30T00:00:00", + "2023-03-12T00:00:00", + "2022-03-24T00:00:00", + "2022-04-25T00:00:00", + "2023-05-11T00:00:00" + ], + "hovertemplate": "ErstellungsDatum=%{base}
ErledigungsDatum=%{x}
VorgangsID=%{y}", + "legendgroup": "", + "marker": { + "color": "#636efa", + "pattern": { + "shape": "" + } + }, + "name": "", + "offsetgroup": "", + "orientation": "h", + "showlegend": false, + "textposition": "auto", + "type": "bar", + "x": [ + 345600000, + 86400000, + 86400000, + 86400000, + 0, + 0, + 0, + 86400000, + 172800000, + 86400000, + 0, + 432000000, + 0, + 86400000, + 0, + 86400000, + 0, + 172800000, + 345600000, + 86400000, + 259200000, + 172800000, + 0, + 0, + 0, + 86400000, + 86400000, + 86400000, + 0, + 86400000, + 0 + ], + "xaxis": "x", + "y": [ + 70133, + 146532, + 260631, + 496050, + 149786, + 246447, + 149582, + 146522, + 508696, + 146448, + 35177, + 20810, + 20794, + 508973, + 38567, + 38566, + 46602, + 92682, + 273263, + 30320, + 30347, + 133495, + 35862, + 246860, + 123784, + 259615, + 149651, + 518785, + 246256, + 254123, + 531578 + ], + "yaxis": "y" + } + ], + "layout": { + "autosize": true, + "barmode": "overlay", + "legend": { + "tracegroupgap": 0 + }, + "margin": { + "t": 60 + }, + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "xaxis": { + "anchor": "y", + "autorange": true, + "domain": [ + 0, + 1 + ], + "range": [ + "2019-09-01 01:20", + "2023-07-20 22:40" + ], + "tickformat": "%B\n%Y", + "type": "date" + }, + "yaxis": { + "anchor": "x", + "autorange": true, + "domain": [ + 0, + 1 + ], + "range": [ + -0.5, + 30.5 + ], + "title": { + "text": "VorgangsID" + }, + "type": "category" + } + } + }, + "image/png": "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", + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#fig = px.scatter(filtered, x='ErstellungsDatum', y='delta')\n", + "fig = px.timeline(filtered, x_start='ErstellungsDatum', x_end='ErledigungsDatum', y='VorgangsID')\n", + "fig.update_xaxes(tickformat='%B\\n%Y')\n", + "fig.update_yaxes(type='category')\n", + "#fig.update_yaxes(tickformat=',d', dtick=1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1bd744d-50a6-49c1-8559-3f71b416e18c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81a6d2d2-51c1-4c49-8451-5f38dd39c90a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c07e03d5-b2c7-4c7e-a6ff-2257c586e7ba", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7dbe83c6-a8d6-48d4-a2a4-19f9ddd9f8d3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c22298d2-1260-4959-a1a9-83d8f0973254", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "80fba6825e3e41d0a15729ae8bd16f57", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/6 [00:00