def run(self):
def open_button_path_fun(path):
return path
tk.Label(self.window, text='File Size Inspector', font=font.Font(family='Helvetica', size=14, weight='bold')).grid(row=0, column=0)
tk.Label(self.window, text='').grid(row=1, column=0)
frame = tk.Frame(self.window)
tk.Label(frame, text=f'Current path: {Path(self.data_prepare_object.current_path).shorten_path_if_necessary()}', font=font.Font(family='Helvetica', size=12, weight='normal')).grid(row=0, column=0)
tk.Label(frame, text=' ').grid(row=0, column=1)
tk.Button(frame, text='CHANGE', command=lambda: [self.change_button_function()]).grid(row=0, column=2)
frame.grid(row=2, column=0)
tk.Label(self.window, text='').grid(row=3, column=0)
sf = ScrolledFrame(self.window, width=520, height=425)
sf.grid(row=5, column=0)
sf.bind_arrow_keys(self.window)
sf.bind_scroll_wheel(self.window)
sf.focus()
inner_frame = sf.display_widget(tk.Frame)
frame = tk.Frame(inner_frame)
i = 0
for header_name in list(self.fields_width_dictionary.keys()):
l_box = tk.Listbox(frame, bg=self.window['bg'], justify=tk.CENTER, relief=tk.GROOVE, width=self.fields_width_dictionary[header_name], height=1, font=font.Font(family='Helvetica', size=10, weight='bold'))
l_box.insert(0, header_name)
l_box.grid(row=0, column=i)
i += 1
frame.grid(row=5, column=0, sticky='W')
if len(list(self.data_prepare_object.selected_elements_dictionary.keys())) > self.max_number_of_elements_on_screen:
tk.Label(self.window, text=f'Showing {self.max_number_of_elements_on_screen} largest elements from this directory.', fg='#e67300', font=font.Font(family='Helvetica', size=10, weight='normal')).grid(row=4, column=0)
i = 0
paths = list(self.data_prepare_object.selected_elements_dictionary.keys())
for entry_path in paths:
frame = tk.Frame(inner_frame)
content_dictionary = dict(zip(self.fields, [self.data_prepare_object.selected_elements_dictionary[entry_path].name,
self.data_prepare_object.selected_elements_dictionary[entry_path].type,
f'{self.data_prepare_object.selected_elements_dictionary[entry_path].size} {self.data_prepare_object.selected_elements_dictionary[entry_path].size_unit}']))
j = 0
for column_name in list(content_dictionary.keys()):
l_box_name = tk.Listbox(frame, width=self.fields_width_dictionary[column_name], height=1, font=font.Font(family='Helvetica', size=10, weight='normal'))
l_box_name.insert(0, content_dictionary[column_name])
l_box_name.grid(row=0, column=j)
j += 1
if self.data_prepare_object.selected_elements_dictionary[entry_path].can_open:
button = tk.Button(frame, text='OPEN', command=lambda c=i: [self.move_function(partial(open_button_path_fun, paths[c]).args[0])])
button.grid(row=0, column=i+3)
frame.grid(row=i+7, column=0, sticky='W')
i += 1
if i > self.max_number_of_elements_on_screen:
break
previous_location = Path(self.data_prepare_object.current_path).get_path_previous_location()
if previous_location is not None:
tk.Button(self.window, text='BACK', font=10, command=lambda: [self.move_function(previous_location)]).grid(row=i+8, column=0)
self.window_on_top_update()
self.adjust_window_position()
self.window.mainloop()
class CoronaDB:
def __init__(self, master):
self.master = master
self.createWidgets()
def createWidgets(self):
style = ttk.Style()
style.theme_use("clam")
style.configure(
"LightText.TFrame",
background=COLOUR_SECONDARY,
foreground=COLOUR_LIGHT_TEXT,
)
style.configure(
"LightText.TLabel",
background=COLOUR_PRIMARY,
foreground=COLOUR_LIGHT_TEXT,
)
style.configure(
"Button.TButton",
background=COLOUR_SECONDARY,
foreground=COLOUR_PRIMARY,
)
self.corona_label = ttk.Label(self.master, text='Corona Virus Data Calculator', style="LightText.TLabel", font=('helvetica', 20))
self.corona_label.grid(row=0, sticky='N', padx=50, pady=25)
self.button = ttk.Button(text='Show(Country)', command=self.getcorona, style="Button.TButton")
self.button.grid(row=2, sticky='W', padx=50, pady=5)
self.button1 = ttk.Button(text='Show(All)', command=self.allcompare, style="Button.TButton")
self.button1.grid(row=2, sticky='E', padx=50, pady=5)
# self.corona_frame = ttk.Frame(self.master, borderwidth = 5, width=500, height=250, relief='groove', style="LightText.TFrame")
# self.corona_frame.grid_propagate(False)
# self.corona_frame.grid(row=3, sticky='w', padx=50, pady=5)
self.corona_frame = ScrolledFrame(self.master, borderwidth = 5, width=400, height=220, bg='black')
self.corona_frame.grid(row=4, sticky='w', padx=50, pady=5)
# Bind the arrow keys and scroll wheel
self.corona_frame.bind_arrow_keys(self.master)
self.corona_frame.bind_scroll_wheel(self.master)
self.inner_frame = self.corona_frame.display_widget(Frame)
options = [
"World",
"Czech Republic",
"India",
"United States of America",
"Spain",
"Italy",
"France",
"Germany",
"China",
"United Kingdom",
"Turkey",
"Belgium",
"Switzerland",
"Netherlands",
"Canada",
"Brazil",
"Portugal",
"Austria",
"Pakistan",
]
self.clicked = StringVar()
self.clicked.set(options[0])
self.drop = OptionMenu(self.master, self.clicked, *options)
self.drop.config(bg = "#808080")
self.drop["menu"].config(bg="white")
self.drop.grid(row=1, sticky='W', padx=50, pady=5)
def allcompare(self):
if self.inner_frame.grid_slaves():
self.clearContents()
endpoint = "https://api.covid19api.com/summary"
response = requests.get(endpoint)
corona = response.json()
dict = {}
for data in corona['Countries']:
new_dict = {**dict, **{data['Country']: data['TotalConfirmed']}}
dict = new_dict
sorted_data = sorted(dict.items(), key=operator.itemgetter(1),reverse=True)
i = 1
for item in sorted_data:
text_val1 = item[0]
text_val2 = item[1]
ttk.Label(self.inner_frame,
borderwidth = 3,
width = 20,
text=text_val1,
font=('helvetica', 16),
style="Button.TButton",
wraplength=500).grid(row=i, column=2)
ttk.Label(self.inner_frame,
borderwidth = 3,
width = 20,
text=text_val2,
font=('helvetica', 16),
style="Button.TButton",
wraplength=500).grid(row=i, column=4)
i = i + 1
def getcorona(self):
if self.inner_frame.grid_slaves():
self.clearContents()
endpoint = "https://api.covid19api.com/summary"
response = requests.get(endpoint)
corona = response.json() # corona data in json format
dd_clicked = self.clicked.get()
keys = {'NewConfirmed': 'New Confirmed', 'TotalConfirmed': 'Total Cases', 'NewDeaths': 'New Deaths', 'TotalDeaths': 'Total Deaths', 'NewRecovered': 'New Recovered', 'TotalRecovered': 'Total Recovered'}
if dd_clicked != "World":
for country_data in corona['Countries']:
if country_data['Country'] == dd_clicked:
i = 1
for item in keys:
text_val1 = keys[item]
text_val2 = str(country_data[item])
ttk.Label(self.inner_frame,
borderwidth = 3,
width = 20,
text=text_val1,
font=('helvetica', 16),
style="Button.TButton",
wraplength=500).grid(row=i, column=2)
ttk.Label(self.inner_frame,
borderwidth = 3,
width = 20,
text=text_val2,
font=('helvetica', 16),
style="Button.TButton",
wraplength=500).grid(row=i, column=4)
i = i + 1
else:
i = 1
for item in keys:
text_val1 = keys[item]
text_val2 = str(corona['Global'][item])
ttk.Label(self.inner_frame,
borderwidth = 3,
width = 20,
text=text_val1,
font=('helvetica', 16),
style="Button.TButton",
wraplength=500).grid(row=i, column=2)
ttk.Label(self.inner_frame,
borderwidth = 3,
width = 20,
text=text_val2,
font=('helvetica', 16),
style="Button.TButton",
wraplength=500).grid(row=i, column=4)
i = i + 1
def clearContents(self):
for widget in self.inner_frame.grid_slaves():
widget.destroy()
def person_query_ins(df):
global person_data_list, person_sf, person_frame, person_first_search, person_sel_row
#if the query returns more than 100 matches show a warnign message
if df.shape[0] == 100:
message("", 1)
#if a movie search was already performed destroy the previously created scrollbar
if person_first_search == 0:
person_sf.destroy()
person_frame.destroy()
person_sel_row = []
if df.shape[0] > 15:
person_sf = ScrolledFrame(person_results_frame,
width=698,
height=350,
scrollbars="vertical",
relief="flat")
person_sf.grid(row=1, sticky="w", padx=(13, 0))
person_frame = person_sf.display_widget(tk.Canvas)
else:
person_sf = ScrolledFrame(person_results_frame,
width=698,
height=350,
scrollbars="neither",
relief="flat")
person_sf.grid(row=1, sticky="w", padx=(13, 0))
person_frame = tk.Frame(person_results_frame)
person_frame.grid(row=1, sticky="nw", padx=(14, 0))
person_data_list = [["" for y in range(4)] for x in range(df.shape[0])]
#this part of the code populates the on-screen grid with informations
for x in range(df.shape[0]):
person_data_list[x][0] = tk.Label(person_frame,
width=40,
text=df.iloc[x][1],
bg="white")
person_data_list[x][0].grid(row=x, column=0, padx=1, pady=1)
person_data_list[x][0].bind(
"<1>", lambda event: handle_click(event, "person"))
if df.iloc[x][2] != None:
person_data_list[x][1] = tk.Label(person_frame,
width=15,
text=re.search(
r"\d{4}",
str(df.iloc[x][2]))[0],
bg="white")
else:
person_data_list[x][1] = tk.Label(person_frame,
width=15,
text=df.iloc[x][2],
bg="white")
person_data_list[x][1].grid(row=x, column=1, padx=1, pady=1)
person_data_list[x][1].bind(
"<1>", lambda event: handle_click(event, "person"))
person_data_list[x][2] = tk.Label(person_frame,
width=20,
text=df.iloc[x][3],
bg="white")
person_data_list[x][2].grid(row=x, column=2, padx=1, pady=1)
person_data_list[x][2].bind(
"<1>", lambda event: handle_click(event, "person"))
person_data_list[x][3] = tk.Label(person_frame,
width=20,
text=df.iloc[x][4],
bg="white")
person_data_list[x][3].grid(row=x, column=3, padx=1, pady=1)
person_data_list[x][3].bind(
"<1>", lambda event: handle_click(event, "person"))
for i in range(4):
person_data_list[x][i].extra = (x * 4 + i) // 4
person_first_search = 0
class DataView(View):
def __init__(self, parent):
super().__init__(parent)
self['text'] = 'Data'
# self['bg'] = 'green'
h = self.parent.winfo_reqheight()
w = self.parent.winfo_reqwidth()
self.grid()
# self.grid_propagate(False)
self.rowconfigure(0, weight=1)
self.rowconfigure(1, weight=1)
# self.rowconfigure(2, weight=1)
# self.columnconfigure(0, pad=15)
self.columnconfigure(0, weight=1)
# Last existing output
self._data_last = Frame(self, height=int(h*0.3), highlightbackground='gray', highlightthickness=1)
self._data_last.grid(row=0, column=0, padx=PADX, pady=PADY_S, sticky=W + E + N + S)
self._data_last.columnconfigure(0, weight=1)
self._data_last.rowconfigure(0, weight=1)
self._data_last.grid_propagate(False)
# self._last_view = Label(self._data_last, name='last image')
# Setup canvas inside the frame
# self._canvas_data_last = Canvas(self._data_last, bg='green')
# self._canvas_data_last.grid(row=0, column=0, padx=PADX_S, pady=PADY_S, sticky=W + E + N + S)
#Add PIL image to the Canvas
# canvas.create_image(10,10,anchor=NW,image=img)
# Preview content will be scrolable
self.content = ScrolledFrame(self, height=int(h*0.3), use_ttk=True)
# Bind the arrow keys and scroll wheel
# self.content.bind_arrow_keys(self)
# self.content.bind_scroll_wheel(self)
self.content.grid(row=1, column=0, padx=PADX, pady=PADY_S, sticky=W + E + N + S)
# Create the preview frame within the ScrolledFrame
self.preview_view = self.content.display_widget(Frame)
# self.data_actions = Frame(self, height=int(h*0.2), highlightbackground='gray', highlightthickness=1)
# self.data_actions.grid(row=2, column=0, padx=PADX, pady=PADY_S, sticky=W + E + S)
# self.data_actions.columnconfigure(0, weight=1)
# self.data_actions.columnconfigure(1, weight=1)
# self.data_actions.columnconfigure(2, weight=1)
# self.data_actions.columnconfigure(3, weight=1)
# self.data_actions.columnconfigure(4, weight=1)
# self._preview_height = DEFAULT_VIEW_SIZE
# self._preview_width = DEFAULT_VIEW_SIZE
# self.scale_frame = LabelFrame(self.data_actions, text='Preview size:')
# self.scale_frame.grid(row=0, column=0, columnspan=4, padx=PADX_S, pady=PADY_S, sticky=W+E)
# self.scale_frame.columnconfigure(0, weight=1)
# self.scale_frame.columnconfigure(1, weight=1)
# self.scale_frame.columnconfigure(2, weight=1)
# self.scale_frame.columnconfigure(3, weight=1)
# self.var_h = IntVar()
# self.var_h.set(self._preview_height)
# self.scale_h = Scale(self.scale_frame, from_=50, to=500, resolution=50, variable=self.var_h, orient=HORIZONTAL, length=400)
# self.scale_h.grid(row=0, column=0, columnspan=3, padx=PADX_S, pady=PADY_S, sticky=W+E)
# self.scale_h.bind("<ButtonRelease-1>", self._set_h)
# self.var_fixed_size = BooleanVar()
# self.fixed_size = Checkbutton(self.scale_frame, variable=self.var_fixed_size, text='Fixed size', onvalue=True, offvalue=False, command=self._fix_size)
# self.fixed_size.grid(row=0, column=3, padx=PADX_S, pady=PADY_S, sticky=W+E)
# self.btn_save = Button(self.data_actions, text='Save', width=BTNW_S, command=self._save)
# self.btn_save.grid(row=0, column=4, padx=PADX, pady=PADY)
self._out = None
self._idx_map :Dict = {}
self._grid_rows: List[Widget] = []
self._storage: FlowStorage = None
self._last_view = None
return
@property
def storage(self) -> FlowStorage:
return self._storage
@storage.setter
def storage(self, storage) -> None:
self._storage = storage
return
def clear_view(self) -> None:
self._out = None
self._idx_map = {}
for row in self._grid_rows:
row.grid_remove()
self._grid_rows.clear()
self.content.scroll_to_top()
if self._last_view is not None:
self._last_view.grid_remove()
return
def default(self) -> None:
# if self.var_fixed_size.get():
# return
self._preview_height = DEFAULT_VIEW_SIZE
self._preview_width = DEFAULT_VIEW_SIZE
# self.var_h.set(self._preview_height)
self._preview()
return
def _preview_size(self, image) -> Tuple[int,int]:
(h, w) = image.shape[:2]
ratio = w/h
if h > self._preview_height:
h = self._preview_height
w = int(h*ratio)
elif w > self._preview_width:
w = self._preview_width
h = int(w/ratio)
elif h < self._preview_height and w < self._preview_width:
h = self._preview_height
w = int(h*ratio)
else:
pass
return (w, h)
def _fit_image(self, image):
dim = self._preview_size(image)
image = cv2.resize(image, dim, interpolation=cv2.INTER_NEAREST)
return image
def _preview_image_list(self, parent, image: List[np.ndarray], name: str) -> Widget:
image = cv2.hconcat(image)
return self._preview_image(parent, image, name)
def _preview_image(self, parent, image: np.ndarray, name: str) -> Widget:
preview = self._fit_image(image)
pil_image = Image.fromarray(preview)
photo = ImageTk.PhotoImage(pil_image)
view = Label(parent, name=name, image=photo)
view.image = photo
return view
def _preview_object(self, parent, data: any, name: str) -> Widget:
view = Label(parent, name=name, border=1)
# text = json.dumps(data, indent = 3)
# df = pd.DataFrame(data)
view.config(text = data)
return view
def _get_preview(self, ref_type: FlowDataType) -> Callable:
views = {
FlowDataType.NP_ARRAY: self._preview_image,
FlowDataType.LIST_NP_ARRAYS: self._preview_image_list
}
return views.get(ref_type, self._preview_object)
def _clear_preview(self, idx: int) -> None:
if len(self._grid_rows) > 0:
self._out = None
# map idx to preview idx
row_idx = self._get_row_idx(f'{idx}')
if row_idx == WITHOUT_PREVIEW_DATA:
return
row_idx = max(len(self._idx_map)-1, self._get_row_idx(f'{idx}'))
try:
# remove idx mapping for the idx
self._idx_map.pop(f'{row_idx}')
# remove existing preview item with the idx
res = self._grid_rows.pop(row_idx)
res.grid_remove()
except IndexError:
pass
return
def update_result(self, idx: int, state_id: str) -> None:
self._show_last(state_id)
self. _clear_preview(idx)
return
def _create_row_output_container(self, row_idx: int, title: str) -> Widget:
state_frame = LabelFrame(self.preview_view, name=f'--{row_idx}--', text=title)
state_frame.grid(row=row_idx, column=0, sticky=W)
state_frame.rowconfigure(0, pad=15)
state_frame.columnconfigure(0, weight=1)
state_frame.columnconfigure(0, pad=15)
# state_frame.columnconfigure(1, weight=1)
# state_frame.columnconfigure(1, pad=15)
return state_frame
def _create_preview(self, row_idx, title, out_data, out_refs) -> None:
preview_frame = self._create_row_output_container(row_idx, title)
# previews for a state outputs
for i, ref in enumerate(out_refs):
(ref_extr, ref_intr, ref_type) = ref
data = out_data.get(ref_intr)
if data is None:
continue
preview = self._get_preview(ref_type)
# convert to a conventional format (without '.')
name = ref_extr.replace('.', '-')
widget = preview(preview_frame, data, name)
widget.grid(row=i, column=0, sticky=W)
widget.bind('<Button-1>', self._on_click)
try:
# remove existing item with the row_idx
self._grid_rows.pop(row_idx)
except IndexError:
pass
# set new one
self._grid_rows.insert(row_idx, preview_frame)
# Scroll view if need
self.update_idletasks()
h = preview_frame.winfo_height()
self.content.focus_set()
self.content.yview(SCROLL, h, UNITS)
return
def _get_row_idx(self, state_id: str) -> int:
row_idx = self._idx_map.get(state_id, WITHOUT_PREVIEW_DATA)
return row_idx
@staticmethod
def _parse_out_refs(refs) -> Tuple[str, str]:
parts =refs[0][0].split('-')
state_id = parts[0]
title = '-'.join(parts[0:len(parts)-1])
return state_id, title
def _show_last(self, state_id: str) -> None:
out_data = self._storage.get_state_output_data(state_id)
refs = self._storage.get_state_output_refs(state_id)
if out_data is None or refs is None:
return
out_refs = [(ref.ext_ref, ref.int_ref, ref.data_type) for ref in refs]
if len(out_refs) > 0:
ref = out_refs[0]
(ref_extr, ref_intr, ref_type) = ref
data = out_data.get(ref_intr)
if data.dtype == np.dtype('uint8'):
pil_image = Image.fromarray(data)
photo = ImageTk.PhotoImage(pil_image)
self._last_view = Label(self._data_last, name='last image', image=photo)
self._last_view.image = photo
self._last_view.grid(row=0, column=0, padx=PADX_S, pady=PADY_S, sticky=W + E + N + S)
else:
self._last_view.grid_remove()
# self._canvas_data_last.create_image(x1=10, y1=10, anchor=NW, image=photo)
return
def _preview(self) -> None:
if self._out is None:
return
(out_refs, out_data) = self._out
if len(out_refs) > 0:
state_id, title = self._parse_out_refs(out_refs)
row_idx = self._get_row_idx(state_id)
self._create_preview(row_idx, title, out_data, out_refs)
return
def _map_idx_to_row_idx(self, idx: int) -> None:
preview_row = len(self._idx_map)
(out_refs, out_data) = self._out
if len(out_refs) == 0 and len(out_data) == 0:
# No data for preview
self._idx_map[f'{idx}'] = WITHOUT_PREVIEW_DATA
return
# map idx to row_idx
self._idx_map[f'{idx}'] = min(idx, preview_row)
return
def _show_preview(self, idx: int, state_id: str) -> None:
out_data = self._storage.get_state_output_data(state_id)
refs = self._storage.get_state_output_refs(state_id)
if out_data is None or refs is None:
return
out_refs = [(ref.ext_ref, ref.int_ref, ref.data_type) for ref in refs]
self._out = (out_refs, out_data)
self._map_idx_to_row_idx(idx)
self._preview()
return
def show_result(self, idx: int, state_id: str) -> None:
self._show_preview(idx, state_id)
self._show_last(state_id)
return
def _on_click(self, event) -> None:
event.widget.focus_set()
active_widget_name = event.widget._name
print(active_widget_name)
for row in self._grid_rows:
for child in row.children:
if child == active_widget_name:
self._plot(child)
return
def _plot(self, name: str) -> None:
parts = name.split('-')
state_id = parts[0] + '-' + parts[2]
key = parts[3]
data_dict = self._storage.get_state_output_data(state_id)
data = data_dict.get(key)
plot_dlg = PlotDialog(self, name, data)
return
def _set_h(self, event) -> None:
self._preview_height = self.scale_h.get()
self._preview()
return
def _fix_size(self) -> None:
# self.scale_h['state'] = NORMAL
# if self.var_fixed_size.get() == True:
# self.scale_h['state'] = DISABLED
return
def _save(self) -> None:
print('save')
return
# TODO:
# https://stackoverflow.com/questions/28005591/how-to-create-a-scrollable-canvas-that-scrolls-without-a-scroll-bar-in-python
def _move(self, preview_frame):
deltay = self._preview_height
deltax = self._preview_width
# make sure we don't move beyond our scrollable region
(x0,y0,x1,y1) = self.content._canvas.coords()
deltay = 0 if (deltay > 0 and y1 >= 400) else deltay
deltay = 0 if (deltay < 0 and y0 <= -400) else deltay
deltax = 0 if (deltax > 0 and x1 >= 400) else deltax
deltax = 0 if (deltax < 0 and x0 <= -400) else deltax
# move the item, then scroll it into view
self.content._canvas.move(preview_frame, deltax, deltay)
self._make_visible(preview_frame)
def _make_visible(self, preview_frame) -> None:
# determine the bounding box of the visible area of the screen
(cx0,cy0) = (self.content._canvas.canvasx(0), self.content._canvas.canvasy(0))
(cx1,cy1) = (self.content._canvas.canvasx(self.content._canvas.cget("width")),
self.content._canvas.canvasy(self.content._canvas.cget("height")))
# determine the bounding box of the thing to be made visible
(x0,y0,x1,y1) = self.content._canvas.coords(preview_frame)
# determine how far off the screen the object is
deltax = x0-cx0 if x0 <= cx0 else x1-cx1 if x1 >= cx1 else 0
deltay = y0-cy0 if y0 <= cy0 else y1-cy1 if y1 >= cy1 else 0
# scroll the canvas to make the item visible
self.canvas.xview("scroll", int(deltax), "units")
self.canvas.yview("scroll", int(deltay), "units")
return
def movie_query_ins(df):
global movie_data_list, movie_sf, movie_frame, movie_first_search, movie_sel_row
#if the query returns more than 100 matches show a warnign message
if df.shape[0] == 100:
message("", 1)
#if a movie search was already performed destroy the previously created scrollbar
if movie_first_search == 0:
movie_sf.destroy()
movie_frame.destroy()
movie_sel_row = []
if df.shape[0] > 14:
movie_sf = ScrolledFrame(movie_results_frame,
width=700,
height=320,
scrollbars="vertical",
relief="flat")
movie_sf.grid(row=1)
movie_frame = movie_sf.display_widget(tk.Canvas)
else:
movie_sf = ScrolledFrame(movie_results_frame,
width=700,
height=320,
scrollbars="neither",
relief="flat")
movie_sf.grid(row=1, sticky="w", padx=(13, 0))
movie_frame = tk.Frame(movie_results_frame)
movie_frame.grid(row=1, sticky="nw", padx=(14, 0))
movie_data_list = [["" for y in range(6)] for x in range(df.shape[0])]
#this part of the code populates the on-screen grid with informations
for x in range(df.shape[0]):
movie_data_list[x][0] = tk.Label(movie_frame,
width=5,
text=df.iloc[x][1],
bg="white")
movie_data_list[x][0].grid(row=x, column=0, padx=1, pady=1)
movie_data_list[x][0].bind("<1>",
lambda event: handle_click(event, "movie"))
if len(df.iloc[x][2]) > 43:
movie_data_list[x][1] = tk.Label(movie_frame,
width=35,
text=df.iloc[x][2][:43] + ".",
bg="white")
else:
movie_data_list[x][1] = tk.Label(movie_frame,
width=35,
text=df.iloc[x][2],
bg="white")
movie_data_list[x][1].grid(row=x, column=1, padx=1, pady=1)
movie_data_list[x][1].bind("<1>",
lambda event: handle_click(event, "movie"))
movie_data_list[x][2] = tk.Label(movie_frame,
width=7,
text=df.iloc[x][3],
bg="white")
movie_data_list[x][2].grid(row=x, column=2, padx=1, pady=1)
movie_data_list[x][2].bind("<1>",
lambda event: handle_click(event, "movie"))
movie_data_list[x][3] = tk.Label(movie_frame,
width=10,
text=re.search(
r"\w+[^,]", df.iloc[x][4])[0],
bg="white")
movie_data_list[x][3].grid(row=x, column=3, padx=1, pady=1)
movie_data_list[x][3].bind("<1>",
lambda event: handle_click(event, "movie"))
if df.shape[1] == 6:
movie_data_list[x][4] = tk.Label(movie_frame,
width=20,
text="",
bg="white")
movie_data_list[x][5] = tk.Label(movie_frame,
width=16,
text="",
bg="white")
else:
movie_data_list[x][4] = tk.Label(movie_frame,
width=20,
text=df.iloc[x][5],
bg="white")
movie_data_list[x][5] = tk.Label(movie_frame,
width=16,
text=df.iloc[x][6],
bg="white")
movie_data_list[x][4].grid(row=x, column=4, padx=1, pady=1)
movie_data_list[x][4].bind("<1>",
lambda event: handle_click(event, "movie"))
movie_data_list[x][5].grid(row=x, column=5, padx=1, pady=1)
movie_data_list[x][5].bind("<1>",
lambda event: handle_click(event, "movie"))
for i in range(6):
movie_data_list[x][i].extra = (x * 6 + i) // 6
movie_first_search = 0
listbox_ip.grid(row=1, column=0, columnspan=1, sticky='n')
listbox_ip.bind("<Button-1>", ip_auto_fill)
listbox_ip.bind("<Return>", ip_search)
Scrollbar(frame_ip, command=listbox_ip.yview,
orient=VERTICAL).grid(row=1, column=2, sticky='ns')
for i, v in enumerate(all_ip_tup):
listbox_ip.insert(
'end',
str(i + 1) + '.) ' + v[0] + " " + v[1] + " " + str(v[2]) + " " +
str(v[3]))
#plot################################################
# Create a ScrolledFrame widget
sf = ScrolledFrame(root, width=1500, height=750)
sf.grid(row=1, column=0, columnspan=3)
# Bind the arrow keys and scroll wheel
sf.bind_scroll_wheel(root)
# Create a frame within the ScrolledFrame
inner_frame = sf.display_widget(Frame)
frame_plot = Frame(inner_frame)
frame_plot.grid(row=0, column=0)
tog() #toggsearch
######IP##################
##########ip
fig = plt.Figure(figsize=(6, 5), dpi=75)
pl = fig.add_subplot(111, title="Top 10 IP", xlabel="IP", ylabel="Records")
try:
class LinksView(View):
def __init__(self, parent):
super().__init__(parent)
self['text'] = 'Links'
self.update_idletasks()
h = self.parent.winfo_reqheight()
w = self.parent.winfo_reqwidth()
self._flow = None
self._grid_rows_descr: List[Dict] = []
self._possible_input: List[str] = []
self._active_wd_idx = -1
self.grid()
self.rowconfigure(0, weight=1)
self.rowconfigure(1, weight=1)
self._infovar = StringVar()
self._info_entry = Entry(self,
name='flow_info',
textvariable=self._infovar,
width=35)
self._info_entry.grid(row=0,
column=0,
padx=PADX,
pady=PADY,
sticky=N + W + E)
self._info_desr = {
'getter': self._infovar.get,
'setter': self._infovar.set,
'wd': self._info_entry
}
# Content will be scrolable
self._content = ScrolledFrame(self,
use_ttk=True,
height=int(h / 5),
width=int((w / 2)))
self._content.grid(row=1,
column=0,
padx=PADX,
pady=PADY_S,
sticky=W + E)
# Create the params frame within the ScrolledFrame
self._links_view = self._content.display_widget(Frame)
return
@property
def descriptors(self) -> List[Dict]:
return self._grid_rows_descr
@property
def info_descr(self) -> str:
return self._info_desr
def get_active_item_link_descriptors(self) -> List[List[Widget]]:
if self._active_wd_idx < 0:
return None
descriptors = self._grid_rows_descr[self._active_wd_idx]
return descriptors
def clear(self) -> None:
self._infovar.set('')
for child in self._links_view.winfo_children():
child.grid_remove()
self._grid_rows_descr.clear()
self._content.scroll_to_top()
self._possible_input.clear()
self._active_wd_idx = -1
return
def build(self, flow: FlowModel) -> None:
self._flow = flow
self._infovar.set(flow.info)
items = copy.deepcopy(flow.items)
for i, item in enumerate(items):
item_links_frame = self._create_item_links_container(i + 1, item)
item_links_frame.grid(row=i + 1, column=0, padx=PADX, sticky=W + E)
item_links_frame.columnconfigure(0, weight=1)
item_links_frame.columnconfigure(1, weight=1)
item_links_descr = self._create_item_links_widgets(
item_links_frame, i, item)
self._grid_rows_descr.append(item_links_descr)
self._disable_all()
self._active_wd_idx = 0
self._hightlighte_active_wd(True)
self._set_active_wd_state(True)
return
def _create_item_links_container(self, idx: int,
item: FlowItemModel) -> Widget:
i_n = item.name.replace('.', '-')
name = f'--{idx}-{i_n}--'
item_links_frame = LabelFrame(self._links_view, name=name)
return item_links_frame
def _create_item_links_widgets(self, container: LabelFrame, idx: int,
item: FlowItemModel) -> Dict:
item_links_descr = []
title = f'{idx}-{item.name}'
i_n = item.name.replace('.', '-')
name = f'--{idx}-{i_n}--'
item_label = Label(container, name=name, text=title)
item_label.grid(row=0, column=0, padx=PADX_S, pady=PADY_S, sticky=W)
item_links_descr.append({
'name': item_label.winfo_name(),
'getter': None,
'setter': None,
'wd': item_label
})
infovar = StringVar()
infovar.set(item.title)
info_entry = Entry(container, textvariable=infovar, width=38)
info_entry.grid(row=0, column=1, padx=PADX_S, pady=PADY_S, sticky=E)
item_links_descr.append({
'name': info_entry.winfo_name(),
'getter': infovar.get,
'setter': None,
'wd': info_entry
})
inrefs_def = item.inrefs_def
outrefs_def = item.outrefs_def
for i, outref_def in enumerate(outrefs_def):
outref_name = outref_def.get('name')
self._possible_input.append(f'{title}-{outref_name}')
links = item.links
if len(inrefs_def) > 0:
for i, inref_def in enumerate(inrefs_def):
inref_name = inref_def.get('name')
getter, inref_lbl, inref_combo = self._create_link_widget(
container, inref_name, links)
inref_lbl.grid(row=i + 1,
column=0,
padx=PADX_S,
pady=PADY_S,
sticky=W)
inref_combo.grid(row=i + 1,
column=1,
columnspan=2,
padx=PADX_S,
pady=PADY_S,
sticky=E)
item_links_descr.append({
'name': inref_name,
'getter': getter,
'setter': None,
'wd': inref_combo
})
return item_links_descr
def _create_link_widget(
self, container: LabelFrame, inref_name: str,
links: Dict[str, str]) -> Tuple[Callable, Widget, Widget]:
def get():
return inref_combo.get()
text = f'{inref_name}:'
inref_lbl = Label(container,
text=text,
anchor=W,
justify=LEFT,
width=10)
var = StringVar()
inref_combo = Combobox(container,
name=inref_name,
justify=LEFT,
width=35)
inref_combo['values'] = copy.deepcopy(
self._possible_input[:len(self._possible_input) - 2])
# Assign current value
if len(links) > 0:
link = links.get(inref_name)
if link is not None:
inref_combo.set(link)
inref_combo.textvariable = var
return get, inref_lbl, inref_combo
def set_active_wd(self, idx: int) -> None:
self._hightlighte_active_wd()
self._set_active_wd_state()
self._active_wd_idx = idx
self._hightlighte_active_wd(True)
self._set_active_wd_state(True)
return
def _set_active_wd_state(self, active: bool = False) -> None:
state = DISABLED
if active:
state = NORMAL
descriptors = self._grid_rows_descr[self._active_wd_idx]
for descr in descriptors:
widget = descr.get('wd')
widget['state'] = state
return
def _disable_all(self) -> None:
for descriptors in self._grid_rows_descr:
for descr in descriptors:
widget = descr.get('wd')
widget['state'] = DISABLED
return
# UI methods
def _hightlighte_active_wd(self, active: bool = False) -> None:
fg_color = 'black'
bg_color = 'SystemButtonFace'
if active:
fg_color = 'white'
bg_color = 'RoyalBlue'
descriptors = self._grid_rows_descr[self._active_wd_idx]
for descr in descriptors:
widget = descr.get('wd')
name = widget.winfo_name()
if name.startswith('--'):
widget['fg'] = fg_color
widget['bg'] = bg_color
break
return
class LinksDialog(Toplevel):
def __init__(self, parent, flow: CurrentFlowModel, callback: Callable):
super().__init__(parent)
self._flow = flow
self._callback = callback
# Do the dialog modal
self.transient(parent)
self.grab_set()
# Define the dialog size
self.title('Configure:')
self.geometry("550x845+%d+%d" %
(parent.winfo_rootx() + 920, parent.winfo_rooty() + 30))
self.resizable(height=FALSE, width=FALSE)
self.grid()
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
self.rowconfigure(1, weight=20)
self.rowconfigure(2, weight=1)
self._info = LabelFrame(self)
self._info.columnconfigure(0, weight=1)
self._info.columnconfigure(1, weight=5)
self._info_lbl = Label(self._info, text='flow info:')
self._info_lbl.grid(row=0, column=0, sticky=W)
self._info_name_var = StringVar()
self._info_name_var.set(flow.flow.info)
self._info_entry = Entry(self._info,
width=50,
textvariable=self._info_name_var)
self._info_entry.grid(row=0,
column=1,
padx=PADX,
pady=PADY,
sticky=W + E + N + S)
self._info.grid(row=0,
column=0,
columnspan=2,
padx=PADX,
pady=PADY,
sticky=W + E + N + S)
# Content will be scrolable
self.content = ScrolledFrame(self)
# Bind the arrow keys and scroll wheel
self.content.bind_arrow_keys(self)
self.content.bind_scroll_wheel(self)
# Create the ContentView frame within the ScrolledFrame
self.content_view = self.content.display_widget(ContentView)
self.content_view.init_content(flow)
self.content.grid(row=1,
column=0,
padx=PADX,
pady=PADY,
sticky=W + E + N + S)
self.actions_frame = LdActionsFrame(self)
self.actions_frame.grid(row=2,
column=0,
padx=PADX,
pady=PADY,
sticky=W + E + N + S)
return
def apply(self) -> None:
self.content_view.update_flow()
self._flow.flow = copy.deepcopy(self.content_view.tmp_flow)
self._flow.flow.info = self._info_name_var.get()
self._callback()
self.destroy()
return
def cancel(self) -> None:
self.destroy()
return
class ParamsView(View):
def __init__(self, parent):
super().__init__(parent)
self['text'] = 'Parameters'
self._factory = ParamWidgetFactory()
self.update_idletasks()
h = self.parent.winfo_reqheight()
self._flow = None
self._grid_rows_descr: List[Dict] = []
self._active_wd_idx = -1
self.grid()
self.rowconfigure(0, weight=1)
self.rowconfigure(1, weight=1)
# Content will be scrolable
self._content = ScrolledFrame(self, use_ttk=True, height=int(h * 0.65))
self._content.grid(row=0,
column=0,
padx=PADX,
pady=PADY_S,
sticky=N + S + W + E)
# Create the params frame within the ScrolledFrame
self._params_view = self._content.display_widget(Frame)
# Setup param actions view
self._params_actions_frame = Frame(self,
highlightbackground='gray',
highlightthickness=1)
self.btn_params_reset = Button(self._params_actions_frame,
text='Reset',
width=BTNW_S)
self.btn_params_default = Button(self._params_actions_frame,
text='Default',
width=BTNW_S)
self.btn_params_io = Button(self._params_actions_frame,
text='I/O',
width=BTNW_S)
self.btn_params_reset.grid(row=0,
column=0,
padx=PADX,
pady=PADY_S,
sticky=W + N)
self.btn_params_default.grid(row=0,
column=1,
padx=PADX,
pady=PADY_S,
sticky=W + N)
self.btn_params_io.grid(row=0,
column=2,
padx=PADX,
pady=PADY_S,
sticky=W + N)
self._params_actions_frame.grid(row=1,
column=0,
padx=PADX,
pady=PADY_S,
sticky=W + E + S)
self._activate_params_buttons()
return
# API
@property
def descriptors(self) -> List[Dict]:
return self._grid_rows_descr
def get_active_item_params_widgets(self) -> List[Widget]:
if self._active_wd_idx < 0:
return None
descriptors = self._grid_rows_descr[self._active_wd_idx]
widgets = []
for descr in descriptors:
widget = descr.get('wd')
widgets.append(widget)
return widgets
def get_item_name(self, idx: int) -> str:
descriptors = self._grid_rows_descr[idx]
widget_0 = descriptors[0].get('wd')
parent_name = widget_0.winfo_parent()
idx_s = parent_name.index('--')
p_n: str = parent_name[idx_s + 2:len(parent_name) - 2]
idx_point = p_n.find('-', 3)
p_n = p_n[:idx_point] + '.' + p_n[idx_point + 1:]
return p_n
def get_item_params(self, idx: int) -> Dict:
params = {}
descriptors = self._grid_rows_descr[idx]
for descr in descriptors:
widget = descr.get('wd')
name = widget.winfo_name()
if name.startswith('--'):
continue
getter = descr.get('getter')
value = getter()
params[name] = value
return params
def set_item_params(self, idx: int, params) -> None:
if self._active_wd_idx < 0:
return None
descriptors = self._grid_rows_descr[idx]
for descr in descriptors:
widget = descr.get('wd')
name = widget.winfo_name()
if name.startswith('--'):
continue
setter = descr.get('setter')
setter(params.get(name))
return
def clear(self) -> None:
for child in self._params_view.winfo_children():
child.grid_remove()
self._grid_rows_descr.clear()
self._content.scroll_to_top()
self._active_wd_idx = -1
self._activate_params_buttons()
return
# Build
def build(self, flow: FlowModel) -> None:
self._flow = flow
items = copy.deepcopy(flow.items)
for i, item in enumerate(items):
item_params_frame = self._create_item_params_container(i, item)
item_params_frame.grid(row=i, column=0, padx=PADX, sticky=W + E)
self._factory.container = item_params_frame
item_params_descr = self._create_item_params_widgets(i, item)
self._grid_rows_descr.append(item_params_descr)
self._disable_all()
self._active_wd_idx = 0
self._hightlighte_active_wd(True)
self._set_active_wd_state(True)
self._activate_params_buttons(True)
return
def _create_item_params_container(self, idx: int,
item: FlowItemModel) -> Widget:
i_n = item.name.replace('.', '-')
name = f'--{idx}-{i_n}--'
item_params_frame = LabelFrame(self._params_view, name=name)
return item_params_frame
def _create_item_params_widgets(self, idx: int,
item: FlowItemModel) -> Dict:
item_params_descr = []
title = f'{idx}-{item.name}'
i_n = item.name.replace('.', '-')
name = f'--{idx}-{i_n}--'
item_label = Label(self._factory.container, name=name, text=title)
item_label.grid(row=0,
column=0,
columnspan=3,
padx=PADX_S,
pady=PADY_S,
sticky=W)
item_params_descr.append({
'name': item_label.winfo_name(),
'getter': None,
'setter': None,
'wd': item_label
})
params, params_def = self._merge_curent_params_with_params_ws(item)
for i, param_def in enumerate(params_def):
name = param_def.get('name')
comment = param_def.get('comment')
pvalue = params.get(name, None)
if pvalue is not None:
param_def['default'] = pvalue
getter, setter, param_widget = self._factory.create(param_def)
param_widget.grid(row=i + 1,
column=1,
padx=PADX_S,
pady=PADY_S,
sticky=W)
param_label = Label(self._factory.container, text=f'{name}')
param_label.grid(row=i + 1,
column=0,
padx=PADX_S,
pady=PADY_S,
sticky=W)
param_descr = Label(self._factory.container, text=f'{comment}')
param_descr.grid(row=i + 1,
column=2,
padx=PADX_S,
pady=PADY_S,
sticky=W)
item_params_descr.append({
'name': param_widget.winfo_name(),
'getter': getter,
'setter': setter,
'wd': param_widget
})
return item_params_descr
@staticmethod
def _merge_curent_params_with_params_ws(
item: FlowItemModel) -> Tuple[Dict, Dict]:
# merge curent params with params_ws
params = item.params # Dict
params_ws = item.params_ws # Dict
params_def = item.params_def # List[Dict]
for k in params_ws.keys():
if k in params:
continue
params[k] = params_ws.ket(k)
return params, params_def
def set_active_wd(self, idx: int) -> None:
self._hightlighte_active_wd()
if self._active_wd_idx > idx:
# disable, when move backward
self._set_active_wd_state()
self._active_wd_idx = idx
self._hightlighte_active_wd(True)
self._set_active_wd_state(True)
self._set_button_io_state(idx)
return
def _set_active_wd_state(self, active: bool = False) -> None:
state = DISABLED
if active:
state = NORMAL
descriptors = self._grid_rows_descr[self._active_wd_idx]
for descr in descriptors:
widget = descr.get('wd')
widget['state'] = state
return
def _disable_all(self) -> None:
for descriptors in self._grid_rows_descr:
for descr in descriptors:
widget = descr.get('wd')
widget['state'] = DISABLED
return
# UI methods
def _hightlighte_active_wd(self, active: bool = False) -> None:
fg_color = 'black'
bg_color = 'SystemButtonFace'
if active:
fg_color = 'white'
bg_color = 'RoyalBlue'
descriptors = self._grid_rows_descr[self._active_wd_idx]
for descr in descriptors:
widget = descr.get('wd')
name = widget.winfo_name()
if name.startswith('--'):
widget['fg'] = fg_color
widget['bg'] = bg_color
break
return
def _activate_params_buttons(self, activate=False) -> None:
state = DISABLED
if activate:
state = NORMAL
self.btn_params_reset['state'] = state
self.btn_params_default['state'] = state
self.btn_params_io['state'] = state
return
def _set_button_io_state(self, idx: int) -> None:
flow_item = self._flow.get_item(idx)
params_def = flow_item.params_def
self.btn_params_io['state'] = DISABLED
for param_def in params_def:
if param_def.get('name') == 'path':
self.btn_params_io['state'] = NORMAL
break
return