def request_login():
#Get info from login input
login_key = core.get_value("login_input")
#Don't login if not connected
if console_client.client.connected != True:
create_error_text(
"You can't login if you're not connected to a server")
return
#Check login key
login_attempt = console_client.client.save_auth_token(login_key)
#If the login succeeded
if login_attempt.success:
login_succeeded()
#If login key failed, say something
else:
#Delete the current error text if it exists
if core.does_item_exist("login_error_text"):
core.delete_item("login_error_text")
#Setup error text
error_text = "There was an error checking your key!"
if login_attempt.message == "file_editing":
error_text = "There was an error editing the key file on disk"
if login_attempt.message == "non_key":
error_text = "The key you entered wasn't a key..."
#Finally, add error
create_error_text(error_text)
def __init__(self, *, name_id: Optional[str] = None, **kwargs: Any):
if name_id is not None:
self._name_id = name_id
else:
self._name_id = _generate_id(self)
if dpgcore.does_item_exist(self.id):
self._setup_preexisting()
else:
# at no point should a Widget object exist for an item that hasn't
# actually been added, so if the item doesn't exist we need to add it now.
# labels are handled specially because they are very common
if 'label' in kwargs and kwargs['label'] is None:
kwargs['label'] = self.id
# subclasses will pass both config values and keywords to _setup_add_widget()
# separate them now
config_props = self._get_config_properties()
config_args = {}
for name, value in list(kwargs.items()):
prop = config_props.get(name)
if prop is not None and not prop.no_init:
config_args[prop] = kwargs.pop(name)
# just keywords left in kwargs
self._setup_add_widget(kwargs)
config_data = {}
for prop, value in config_args.items():
config_data.update(prop.fconfig(self, value))
dpgcore.configure_item(self.id, **config_data)
_register_item(self.id, self)
def show(self) -> None:
if core.does_item_exist(self._win_name):
self.destroy(self._win_name)
obj_name = self._entry.get_object_name()
with simple.window(self._win_name,
label=f"{obj_name}",
on_close=self.destroy,
width=400):
ts = self._entry.get_timestamp_str()
age = self._entry.get_age()
core.add_label_text(self._win_name + "ts",
label=f"Timestamp",
default_value=f"{ts}")
core.add_label_text(self._win_name + "age",
label=f"Age",
default_value=f"{age}")
core.add_label_text(self._win_name + "freq",
label=f"Frequency",
default_value=f"0.0 Hz")
core.add_text("")
core.add_label_text(self._win_name + "content",
default_value=str(self._entry.get_object()),
label="")
self._freq_thread.start()
def open_overlay():
"""
Open the Elo Overlay
But first check if the FACEIT name is set
If the FACEIT name isn't correct return
If changes be made and not saved, return with a warning
"""
global iChanges
faceit_name = config_functions.get_faceit_name_from_db()
if faceit_name:
if core.does_item_exist("Error##ErrorNoFACEITName"):
return
if iChanges == 1:
set_warning("Configuration not saved, press Apply Configuration")
else:
web = webFunctions.get_web()
if web[0]:
overlayWeb.open_browser_and_fill_with_content()
if web[1]:
overlayWeb.open_browser_and_fill_with_content()
open_app_overlay(faceit_name)
if not web[0] and not web[1]:
open_app_overlay(faceit_name)
else:
set_error("No FACEIT Name configured")
def _resolve_sender(sender: str) -> Any:
if dpgcore.does_item_exist(sender):
if sender in _ITEM_LOOKUP:
return _ITEM_LOOKUP[sender]
# warning, this will segfault if sender does not exist!
sender_type = dpgcore.get_item_type(sender)
return _create_item_wrapper(sender, sender_type)
def create_tab(self, sender, data):
tab_name = dpg.get_value("NewTabName")
dpg.delete_item("NewPopup")
if dpg.does_item_exist("inittext"):
dpg.delete_item("inittext")
tab = trackers.Tab(tab_name, "tab_bar_1")
self.tab_tracker.add_tab(tab)
page = Page(f"{tab_name}Page", f"tab{tab.id}")
tab.render(page)
def create_error_text(error):
#Delete the current error text if it exists
if core.does_item_exist("login_error_text"):
core.delete_item("login_error_text")
core.add_text("login_error_text",
default_value=error,
before="login_button",
wrap=0)
def _render_callback(self, sender, data):
self._render_update_cnt += 1
if self._render_update_cnt % 20 == 0:
self._render_update_cnt = 0
# fields that are most probably always updated
for pool_name, pool in self._pools.items():
max_size = str(pool.get_max_size()) if pool.get_max_size() else "inf"
core.set_value(f"Objects_{pool_name}##total", str(pool.length()) + " / " + max_size)
core.set_value(f"Objects_{pool_name}##subscribers", str(pool.n_subscriptions()))
# update table
if core.does_item_exist(f"Objects_{pool_name}##table"):
table_data = self._get_table_data(pool)
for entry in table_data:
obj_name = entry[0].get_object_name()
n_objs = entry[1]
btn_name = f"Button_{pool_name}_{obj_name}"
if not core.does_item_exist(btn_name):
core.add_button(btn_name, label=f"{obj_name} :\t{n_objs}", width=200, parent=f"Objects_{pool_name}##table", callback=self._show_object_details, callback_data=(entry[0], pool_name))
else:
simple.set_item_label(btn_name, f"{obj_name} :\t{n_objs}")
# update details window
for win in self._details_windows:
if win.get_pool_name() == pool_name:
for obj_id, lst in pool.get_queue().items():
if obj_id == win.get_obj_id():
win.update(lst[-1])
continue
win.update_static()
mem_usage_mb = self._pid.memory_info().rss / 1000.0 / 1000.0
core.set_value("Pools##memory", "{:.2f}".format(mem_usage_mb))
core.set_value("Pools##cpu", "{:.2f}".format(self._pid.cpu_percent()))
if not self._ui_dirty:
return
# rebuild UI
self._ui_dirty = False
self._reset()
self._build()
def cancel_workout(self):
if core.does_item_exist("example_image"):
core.delete_item("example_image")
core.delete_item("buttons")
core.delete_item("workout_table")
simple.show_item("workout_composition_group")
if core.get_value("Results successfully saved"):
core.delete_item("Results successfully saved")
if core.get_value("Error happened while saving the result"):
core.delete_item("Results successfully saved")
def run(self):
"""
Cycle function to update the Overlay every minute
"""
global start_threading
while 1:
refresh_rate = config_functions.get_refresh()
sleep(refresh_rate)
try:
name = sqlite3db.TExecSqlReadMany(
DBNAME, """
SELECT name FROM CFG_FACEIT_NAME
""")
if name:
if start_threading == 1:
refreshSymbol = config_functions.get_refresh_sign()
logging.info("Get stats and refresh them")
winLoss = config_functions.get_win_loss()
if winLoss[0][0] == "1":
mode = 0
else:
mode = 1
if refreshSymbol in "True":
core.configure_item("##reload_same_line",
show=True)
core.configure_item("##reload_image", show=True)
self.iElo, self.acEloToday, self.iRank, \
self.acResult, self.acScore, self.acKd, \
self.acMap, self.iStreak, self.iMatches, \
self.iMatchesWon, self.acEloDiff, self.iKills, \
self.iDeath, self.iWin, self.iLoss = faceit_api.get_faceit_data_from_api(mode)
core.set_value("elotoday##", f"{self.acEloToday}")
core.set_value("streak##", f"{self.iStreak}")
core.set_value("map##", f"\t{self.acMap}:")
core.set_value("result##", f"{self.acResult}")
core.set_value("elo##", f"{self.iElo}")
core.set_value("rank##", f"{self.iRank}")
core.set_value("score##", f"{self.acScore}")
core.set_value("matches##", f"{self.iMatches}")
core.set_value("matcheswon##", f"{self.iMatchesWon}")
core.set_value("elodiffmap##", f"{self.acEloDiff}")
core.set_value("kill##", f"{self.iKills}")
core.set_value("death##", f"{self.iDeath}")
core.set_value("kd##", f"{self.acKd}")
core.set_value("Win/LossperDay##",
f"{self.iWin} / {self.iLoss}")
core.set_value("Win/LossperWeek##",
f"{self.iWin} / {self.iLoss}")
if core.does_item_exist("##reload_same_line"):
core.configure_item("##reload_same_line",
show=False)
core.configure_item("##reload_image", show=False)
except:
self.run()
def show_version():
"""Show version of this app.
"""
window_name = 'Version info##version_info_window'
if not core.does_item_exist(window_name):
with simple.window(window_name,
on_close=lambda: core.delete_item(window_name),
autosize=True,
no_resize=True):
core.add_text('##version_info_0',
default_value=f'Password Manager v{VERSION}')
def show_example(self, link):
if core.does_item_exist("example_image"):
core.delete_item("example_image")
response = requests.get(link)
if response.status_code == 200:
open(EXAMPLE_IMAGE_FILE_PATH, "wb").write(response.content)
core.add_image(
"example_image",
EXAMPLE_IMAGE_FILE_PATH,
parent="workout_execution_group",
)
def delete_error():
"""
Error handling ; delete
delete error/warning messages
call reset_error to set the COL_List back
"""
item = core.get_all_items()
for i in item:
if "Error" in i or "Warning" in i:
if core.does_item_exist(i):
reset_error(i)
def __restore_tab(self, data):
try:
if dpg.does_item_exist("inittext"):
dpg.delete_item("inittext")
tab = trackers.Tab(data["pagename"].replace("Page", ""),
"tab_bar_1")
self.tab_tracker.add_tab(tab)
page = Page(data["pagename"], f"tab{tab.id}", data["path"],
data["filename"])
tab.render(page, data)
except Exception as e:
# TODO: Actually do something about this
raise e
def try_get_item_by_id(name: str) -> Optional[Widget]:
"""Retrieve an item using its unique name or ``None``.
Similar to :func:`.get_item_by_id`, but returns ``None`` if the wrapper object could not be retrieved."""
if not dpgcore.does_item_exist(name):
return None
item = _ITEM_LOOKUP.get(name)
if item is not None:
return item
item_type = dpgcore.get_item_type(name) ## WARNING: this will segfault if name does not exist
return _create_item_wrapper(name, item_type)
def __tableRefresh(self):
if core.does_item_exist("table"):
core.delete_item("table")
# build the data model so we can search it
core.add_table("table", self.__headers, parent="panel")
search = core.get_value("filter")
search = re.compile(filter, re.I)
for row in self.__rows:
for cell in row:
if search.search(cell):
core.add_row("table", row)
break
def set_warning(warningTxt):
"""
Warning handling ; set
add a collapsing_header to display the Warning Message
"""
if not core.does_item_exist("Warning##Warning"):
with simple.collapsing_header("Warning##Warning",
parent="##GroupStats",
default_open=True,
closable=False,
bullet=True):
core.add_text("Warning",
default_value=warningTxt,
color=(255, 255, 0, 255))
def __render(self):
for x in ["press", "down", "release"]:
kid = f"{x}-kid"
if core.does_item_exist(kid):
core.delete_item(kid)
with simple.group(kid, parent=x, width=250):
core.add_text(f'{x}-text', default_value=' ')
for k, v in self.__keymap.items():
if v['val'] == 1:
core.add_text(v['name'], parent="press-kid")
if v['val'] == 2:
core.add_text(v['name'], parent="down-kid")
if v['val'] == 4:
core.add_text(v['name'], parent="release-kid")
self.__keymap[k]['val'] = 0
def window_crud_maintenance(sender, data):
log_info(f'Function: CRUD Maintenance Window, {sender}, {data}')
if does_item_exist(f'{data}##window'):
log_info(f'Already exist {data}##window')
pass
else:
if data == 'Key Values':
table_headers = ['Key', 'Value', 'Comment']
elif data == 'Plex Shows':
table_headers = ['Show Name', 'Show Id', 'Cleaned Show Name']
elif data == 'Plex Episodes':
table_headers = [
'Show Name', 'Season', 'Episode', 'Date Watched',
'TVM Updated', 'TVM Update Status'
]
else:
table_headers = ['Unknown']
with window(name=f'{data}##window',
width=2130,
height=650,
x_pos=5,
y_pos=45):
add_input_text(name=f'{data}_input',
no_spaces=True,
multiline=False,
decimal=False,
label=data,
width=200)
add_same_line(spacing=10)
add_button(name=f'Search##{data}',
callback=func_crud_search,
callback_data=data)
if data == 'Key Values' or data == 'Plex Shows':
add_same_line(spacing=10)
add_button(name=f"Add New##{data}")
add_same_line(spacing=10)
add_button(name=f"Edit##{data}")
if data == 'Key Values':
add_same_line(spacing=10)
add_button(name=f"Delete##{data}")
add_same_line(spacing=10)
add_button(name=f"Clear##{data}",
callback=func_crud_clear,
callback_data=f'Table##{data}')
add_separator(name=f'##{data}SEP1')
add_table(name=f'Table##{data}', headers=table_headers)
add_separator(name=f'##{data}SEP1')
def set_rows(self, nrows):
""" "Set the rows in the table
Each row has two columns. The first column is the grid number. The second column is a list
of applications to snap to the grid. We use a table to enable multiselect
"""
dpg_core.log_info(f"Refreshing rows for table {self.id}")
for row in range(1, nrows + 1):
name = f"{self._id}_{row}"
# If the row already exists, we don't need to do anything else
if dpg_core.does_item_exist(name):
continue
with dpg_simple.managed_columns(name,
len(self.HEADER),
parent=self.parent):
# The first column is the grid number
dpg_core.add_input_int(
f"##{self._id}_{row}_number",
default_value=row,
readonly=True,
step=0,
parent=name,
)
# The second column is the table. Wrap in a collapsing header so the screen isn't
# too full the entire time.
with dpg_simple.collapsing_header(f"##{self._id}_{row}_header",
parent=name):
dpg_core.add_table(
f"{self._id}_{row}_table",
[""], # no headers
callback=self.selected,
parent=f"##{self._id}_{row}_header",
)
# populate the table with the names of available windows
for window_name in sorted(self.ACTIVE_WINDOWS):
dpg_core.add_row(f"{self._id}_{row}_table",
[window_name])
# Separate each row with a line
dpg_core.add_separator(name=f"{self._id}_{row}_sep", parent=name)
self._nrows = nrows
dpg_core.log_info(f"Refreshed rows for table {self.id}")
def set_error(errTxt):
"""
Error handling ; set
set the defined Button to Red
add a collapsing_header to display the Error Message
"""
core.set_item_color("Start", mvGuiCol_Button, (255, 0, 0, 255))
core.set_item_color("Start", mvGuiCol_ButtonActive, (255, 0, 0, 255))
core.set_item_color("Start", mvGuiCol_ButtonHovered, (255, 0, 0, 255))
if not core.does_item_exist("Error##ErrorNoFACEITName"):
with simple.collapsing_header("Error##ErrorNoFACEITName",
parent="##GroupStats",
default_open=True,
closable=False,
bullet=True):
core.add_text("ErrorText",
default_value=errTxt,
color=(255, 0, 0, 255))
def get_item_by_id(name: str) -> Widget:
"""Retrieve an item using its unique name.
If the item was created by instantiating a :class:`.Widget` object, this will return that
object. Otherwise, a new wrapper object will be created for that item and returned. Future calls
for the same ID will return the same object.
Raises:
KeyError: if name refers to an item that is invalid (deleted) or does not exist.
"""
if not dpgcore.does_item_exist(name):
raise KeyError(f"'{name}' item does not exist")
item = _ITEM_LOOKUP.get(name)
if item is not None:
return item
item_type = dpgcore.get_item_type(name) ## WARNING: this will segfault if name does not exist
return _create_item_wrapper(name, item_type)
def edit_request():
#Get info from login input
login_key = core.get_value("key_input")
#Check login key
login_attempt = console_client.client.save_auth_token(login_key)
#Delete the current error text if it exists
if core.does_item_exist("key_error_text"):
core.delete_item("key_error_text")
#If the login succeeded
if login_attempt.success:
#Add success text
core.add_text("key_error_text",
default_value="Key successfully changed :)",
before="edit_button",
wrap=0)
#Change token display
core.delete_item("token_display")
core.add_text("token_display",
default_value="Current token: {}...".format(
console_client.client.auth_token[:10]),
before="key_input")
#If login key failed, say something
else:
#Setup error text
error_text = "There was an error checking your key!"
if login_attempt.message == "file_editing":
error_text = "There was an error editing the key file on disk"
if login_attempt.message == "non_key":
error_text = "The key you entered wasn't a key..."
#Finally, add error
core.add_text("key_error_text",
default_value=error_text,
before="edit_button",
wrap=0)
def create_widget():
#If this widget exists, kill it
if core.does_item_exist("edit_token"):
core.delete_item("edit_token")
#Create widget
with simple.window("edit_token"):
core.add_text("Use dis to edit token")
core.add_text("token_display",
default_value="Current token: {}...".format(
console_client.client.auth_token[:10]))
core.add_input_text("key_input",
hint="auth key",
password=True,
label="")
core.add_text("key_error_text",
default_value=" ",
before="edit_button")
core.add_button("edit_button", label="Edit", callback=edit_request)
def remove(self):
if dpg.does_item_exist(self.group):
dpg.delete_item(self.group)
def items_remover(items):
for item in items:
if(core.does_item_exist(item) == True):
core.delete_item(item)
def remove(self):
"""
Remove the Category object from the screen
"""
if dpg.does_item_exist(self.group):
dpg.delete_item(self.group)
def is_valid(self) -> bool:
"""This property is ``False`` if the GUI item has been deleted."""
return dpgcore.does_item_exist(self.id)
def encrypt(sender, data):
pt = str(core.get_value("Input"))
core.configure_item("Cannot Decrypt with plaintext", show=False)
core.configure_item("Input must be < 128 bits and key must be 64 bits", show=False)
# selected plain text
if (core.get_value("RadioButton##widget") == 1):
pt = pt.encode().hex()
# padding
if len(pt) > 16:
while len(pt) < 32:
pt += "0"
pt2 = pt[16:32]
pt = pt[:16]
else:
while len(pt) < 16:
pt += "0"
key = str(core.get_value("Key"))
# selected plain text
if (core.get_value("RadioButton##widget1") == 1):
key = key.encode().hex()
# padding
while len(key) < 16:
key += "0"
if not check_inputs(key, pt):
core.configure_item("Input must be < 128 bits and key must be 64 bits", show=True)
return
if "pt2" in locals():
if not check_inputs(key, pt2):
core.configure_item("Input must be < 128 bits and key must be 64 bits", show=True)
return
window_name = "Encryption"
other_window_name = "Decryption"
window_name2 = "Encryption2"
other_window_name2 = "Decryption2"
if core.does_item_exist(window_name):
core.delete_item(window_name)
if core.does_item_exist(window_name2):
core.delete_item(window_name2)
if core.does_item_exist(other_window_name):
core.delete_item(other_window_name)
if core.does_item_exist(other_window_name2):
core.delete_item(other_window_name2)
key, left, right = get_initial_values(key)
rk, rkb = get_rk_rkb(left, right)
perm_str, round_str, cipher_text = des.encrypt(pt, rkb, rk)
with simple.window(window_name, width=450, height=360, x_pos=351, y_pos=0):
core.add_text(perm_str)
core.add_text("Round # Left Right")
for i in range(len(round_str)):
core.add_text(round_str[i])
core.add_text("Cipher Text (after final permuation): " + cipher_text)
if "pt2" in locals():
perm_str2, round_str2, cipher_text2 = des.encrypt(pt2, rkb, rk)
combined_cipher_text = cipher_text + cipher_text2
with simple.window(window_name2, width=460, height=375, x_pos=801, y_pos=0):
core.add_text(perm_str2)
core.add_text("Round # Left Right")
for i in range(len(round_str2)):
core.add_text(round_str2[i])
core.add_text("Cipher Text2 (after final permuation): " + cipher_text2)
core.add_text("Combined Cipher Text: " + combined_cipher_text)
def decrypt(sender, data):
core.configure_item("Cannot Decrypt with plaintext", show=False)
core.configure_item("Input must be < 128 bits and key must be 64 bits", show=False)
cipher_text = str(core.get_value("Input"))
if (core.get_value("RadioButton##widget") == 1):
core.configure_item("Cannot Decrypt with plaintext", show=True)
return
# padding
if len(cipher_text) > 16:
while len(cipher_text) < 32:
cipher_text += "0"
cipher_text2 = cipher_text[16:32]
cipher_text = cipher_text[:16]
else:
while len(cipher_text) < 16:
cipher_text += "0"
key = str(core.get_value("Key"))
# selected plain text
if (core.get_value("RadioButton##widget1") == 1):
key = key.encode().hex()
# padding
while len(key) < 16:
key += "0"
if not check_inputs(key, cipher_text):
core.configure_item("Input must be < 128 bits and key must be 64 bits", show=True)
return
if "cipher_text2" in locals():
if not check_inputs(key, cipher_text2):
core.configure_item("Input must be < 128 bits and key must be 64 bits", show=True)
return
window_name = "Decryption"
other_window_name = "Encryption"
if core.does_item_exist(window_name):
core.delete_item(window_name)
if core.does_item_exist(other_window_name):
core.delete_item(other_window_name)
window_name2 = "Decryption2"
other_window_name2 = "Encryption2"
if core.does_item_exist(window_name2):
core.delete_item(window_name2)
if core.does_item_exist(other_window_name2):
core.delete_item(other_window_name2)
key, left, right = get_initial_values(key)
rk, rkb = get_rk_rkb(left, right)
rkb_rev = rkb[::-1]
rk_rev = rk[::-1]
perm_str, round_str, text = des.encrypt(cipher_text, rkb_rev, rk_rev)
with simple.window(window_name, width=450, height=380, x_pos=351, y_pos=0):
core.add_text(perm_str)
core.add_text("Round # Left Right")
for i in range(len(round_str)):
core.add_text(round_str[i])
core.add_text("Plain Text in hex (after final permuation): " + text)
plaintext = bytes.fromhex(text.lower()).decode('utf-8', "replace")
core.add_text("Plain Text in clear text (after final permuation): " + plaintext)
if "cipher_text2" in locals():
perm_str2, round_str2, text2 = des.encrypt(cipher_text2, rkb_rev, rk_rev)
with simple.window(window_name2, width=450, height=390, x_pos=801, y_pos=0):
core.add_text(perm_str2)
core.add_text("Round # Left Right")
for i in range(len(round_str2)):
core.add_text(round_str2[i])
core.add_text("Plain Text2 in hex (after final permuation): " + text2)
plaintext2 = bytes.fromhex(text2.lower()).decode('utf-8', "replace")
core.add_text("Plain Text2 in clear text (after final permuation): " + plaintext2)
core.add_text("Combined Plain Text: " + plaintext + plaintext2)
