def favorite(self, id, topic):
store = JsonStore('favorite.json')
for x in store:
self.s.append(store.get(x).get('id'))
if id in self.s:
try:
store.delete(topic)
self.iconButton.text_color = rgba('#000000')
print('Removed')
if len(store) == 0:
os.remove('favorite.json')
MDApp.get_running_app(
).root.ids.main.ids.main_star.text_color = 0, 0, 0, 0
print('<<<< File was removed >>>')
except KeyError as keyerr:
print('>>>>> Error <<<<<: ', keyerr)
store.put(topic, id=id)
self.iconButton.text_color = rgba('#E91E63')
MDApp.get_running_app(
).root.ids.main.ids.main_star.text_color = 1, 1, 1, 1
except FileNotFoundError as fileerr:
print('<<< Error>>> : ', fileerr)
else:
store.put(topic, id=id)
self.iconButton.text_color = rgba('#E91E63')
print('Added to favorite')
if len(store) == 1:
MDApp.get_running_app(
).root.ids.main.ids.main_star.text_color = 1, 1, 1, 1
self.s = []
class Factors():
def __init__(self):
self.datastore = JsonStore('data.json')
def add_new_factor(self, secret_2FA, label_2FA):
mac = hmac.new(bytes.fromhex(secret_2FA), "id_2FA".encode('utf-8'),
sha1)
id_2FA_20b = mac.hexdigest()
id_2FA = sha256(mac.digest()).hexdigest()
mac = hmac.new(bytes.fromhex(secret_2FA), "key_2FA".encode('utf-8'),
sha1)
key_2FA = mac.hexdigest()[0:32] # keep first 16 bytes out of 20
idreply_2FA = sha256(id_2FA.encode('utf-8')).hexdigest()
self.datastore.put(id_2FA,
secret_2FA=secret_2FA,
key_2FA=key_2FA,
label_2FA=label_2FA,
idreply_2FA=idreply_2FA,
id_2FA_20b=id_2FA_20b)
Logger.info("Satochip: \nAdded new factor on " + str(datetime.now()) +
"\n" + "label: " + label_2FA + "\n" + "id_2FA: " + id_2FA +
"\n" + "idreply_2FA: " + idreply_2FA)
#Logger.debug("Satochip: secret_2FA"+ secret_2FA)
#Logger.debug("Satochip: key_2FA: "+ key_2FA)
def remove_factor(self, id):
if self.datastore.exists(id):
self.datastore.delete(id)
def proceed_remove_from_collection(self, button):
self.remove_popup.dismiss()
if os.path.isfile(self.CUSTOM_PATHS_PATH):
store = JsonStore(self.CUSTOM_PATHS_PATH)
store.delete(button.text)
self.ids.board.remove_widget(button)
app.root.bar.ping()
def delete(self, *args):
if self.user == "Pat":
User = JsonStore("jsondb/patron.json")
else:
User = JsonStore("jsondb/librarian.json")
if self.accesscode.text != "":
if User.exists(self.accesscode.text):
User.delete(self.accesscode.text)
Dialog().display_user(self.accesscode, "deleted")
def delete(self, *args):
mat = JsonStore("jsondb/material.json")
if self.mat_id.text != "":
if mat.exists(self.mat_id.text):
mat.delete(self.mat_id.text)
Dialog().display_mat("Material", self.mat_id.text, "deleted")
else:
Dialog().no_display_user(
"the material with the id %s" % self.mat_id.text,
"does not exist")
def resetear(self):
Store = JsonStore(
os.path.join(App.get_running_app().data_folder, 'data.json'))
keys = []
for key in Store.keys():
keys.append(key)
for key in keys:
if not key == 'Alumnos':
Store.delete(key)
def __init__(self, **kwargs):
"""Initializes auth screen, checks if there's a credentials.json and if so, signs in"""
super(AuthScreen, self).__init__(**kwargs)
credential_store = JsonStore('credentials.json')
if credential_store.exists('tokens'):
try:
Auth.sign_in_with_tokens(**credential_store.get('tokens'))
except Exception as error:
print(error)
print("Deleting credentials.json since it may be corrupted")
credential_store.delete('tokens')
class JsonModel(Model):
def __init__(self, name, path_prefix='storage/'):
super(JsonModel, self).__init__(name)
self.store = JsonStore(path_prefix + name + '.json')
def get(self, id):
if self.store.exists(id):
return self.store[id]
return None
def _set(self, id, data):
if not data:
self.store.delete(id)
else:
self.store[id] = data
class TrackerLayout(GridLayout):
time_data = ObjectProperty(None)
def __init__(self, **kwargs):
super(TrackerLayout, self).__init__(**kwargs)
# basic setting
self.cols = 1
self.size_hint = (0.7, 1)
self.pos_hint = {'x': 0.15}
self.padding = [0, dp(60), 0, dp(40)]
self.spacing = [0, dp(50)]
self.row_default_height = dp(45)
self.row_force_default = True
# store temparary in_time data in json file
self.time_data = JsonStore(App.get_running_app().user_data_dir +
'/time_data.json')
for i in range(1, 6):
""" Create grade 9-12 dropdown list. """
self.ids[f'grade_dropdown_{i}'] = DropDown()
for j in range(9, 13):
btn = Button(size_hint_y=None,
text=str(j),
height=dp(40),
font_size=dp(18))
btn.bind(on_release=partial(self._select_grade, index=i))
self.ids[f'grade_dropdown_{i}'].add_widget(btn)
def _select_grade(self, event, index):
self.ids[f'grade_dropdown_{index}'].select(event.text)
self.ids[f'grade_btn_{index}'].text = event.text
def change_page(self, event):
app = App.get_running_app()
app.root.current = 'login'
pass
def _open_grade_dropdown(self, widget, index):
self.ids[f'grade_dropdown_{index}'].open(widget)
def _update(self, index):
if self.ids[f'check_btn_{index}'].text == 'Check in':
if (self.ids[f'first_name_{index}'].text == ''
or self.ids[f'last_name_{index}'].text == ''
or self.ids[f'grade_btn_{index}'].text == 'Grade'):
# popup that notifies user for invalid input
danger_popup = Popup(title='Error Message',
title_color=[1, 1, 0, 1],
title_align='center',
title_size=dp(20),
content=Label(
text='Please fill out every field.',
color=[1, 0, 0, 1],
font_size=dp(18)),
size_hint=(None, None),
size=(dp(300), dp(300)),
pos_hint={
'center_x': 0.5,
'center_y': 0.5
})
danger_popup.open()
else:
# save the "get in time" to json
current = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
self.time_data.put(
f"{self.ids[f'first_name_{index}'].text}{self.ids[f'last_name_{index}'].text}",
in_time=current)
self.ids[f'check_btn_{index}'].text = 'Check out'
else:
""" Write 'first_name,last_name,grade,in_time,out_time' to csv file. """
current = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
handler = open(App.get_running_app().user_data_dir + '/report.csv',
'a')
name = f"{self.ids[f'first_name_{index}'].text},{self.ids[f'last_name_{index}'].text}"
in_time = self.time_data.get(name.replace(',', ''))['in_time']
msg = f"{name},{self.ids[f'grade_btn_{index}'].text},{in_time},{str(current)}\n"
handler.write(msg)
handler.close()
# reset current row's input fields
self.ids[f'check_btn_{index}'].text = 'Check in'
self.ids[f'first_name_{index}'].text = ''
self.ids[f'last_name_{index}'].text = ''
self.ids[f'grade_btn_{index}'].text = 'Grade'
# remove data from json file
self.time_data.delete(name.replace(',', ''))
class NameProvider(object):
update_callback = None
def __init__(self):
self.name_store = None
self.rating_store = None
self.current_query = None
self.cache = None
self.index = 0
def get_rst(self, name, name_data):
text = "**Sprache**\n\n %s\n\n" % name_data["language"]
if name_data["meaning"] != "-":
text += "**Bedeutung**\n\n %s \n\n" % name_data["meaning"]
if name_data["origin"] != "-":
text += "**Herkunft**\n\n %s\n\n" % name_data["origin"]
if name_data["words"] != "-":
text += u"**Wörter**\n\n %s\n\n" % name_data["words"]
variants = [x for x in name_data["variants"] if x != name]
if variants:
text += "**Varianten**\n\n %s\n\n" % ', '.join(variants)
return text
def get_by_name(self, name):
if not self.name_store:
self.name_store = JsonStore("names.json")
try:
return name, self.name_store.get(name)
except KeyError:
pass
return None
def _update_cache(self, gender, starts_with, ends_with, min_len, max_len,
langs):
self.cache = []
self.index = 0
if not self.rating_store:
self.rating_store = JsonStore("ratings.json")
add_to_cache = self.cache.append
gender_letter = gender[0]
has_gender = gender_letter in ("m", "w")
rating_store_exists = self.rating_store.exists
min_len = int(min_len)
max_len = int(max_len)
if not self.name_store:
self.name_store = JsonStore("names.json")
if not self.rating_store:
self.rating_store = JsonStore("ratings.json")
for name, data in self.name_store.find():
try:
if has_gender and not data["gender"].startswith(gender_letter):
continue
if data["length"] < min_len or data["length"] > max_len:
continue
if rating_store_exists(name):
continue
if langs[make_lang_key(data["language"])] != u'1':
continue
name_lc = name.lower()
if starts_with != "" and not name_lc.startswith(starts_with):
continue
if ends_with != "" and not name_lc.endswith(ends_with):
continue
add_to_cache(name)
except TypeError:
pass
except KeyError:
pass
def get_next_unrated_name(self, gender, starts_with, ends_with, min_len,
max_len, langs):
query = (gender, starts_with, ends_with, min_len, max_len, langs)
if cmp(query, self.current_query) != 0:
self._update_cache(*query)
self.current_query = query
if self.cache:
#next_name = random.choice(self.cache)
next_name = self.cache[self.index]
self.index = (self.index + 1) % len(self.cache)
return self.get_by_name(next_name), len(self.cache)
return None, 0
def rate(self, current_name, rating):
if not self.rating_store:
self.rating_store = JsonStore("ratings.json")
self.cache.remove(current_name[0])
self.rating_store.put(current_name[0],
gender=current_name[1]["gender"],
rating=rating)
def change_rating(self, name, gender, rating):
if not self.rating_store:
self.rating_store = JsonStore("ratings.json")
self.rating_store.put(name, gender=gender, rating=rating)
def get_favorites(self):
if not self.rating_store:
self.rating_store = JsonStore("ratings.json")
return sorted([(x, y["gender"])
for x, y in self.rating_store.find(rating=1)])
def delete_con_rating(self):
if not self.rating_store:
self.rating_store = JsonStore("ratings.json")
cons = [x for x, _ in self.rating_store.find(rating=0)]
for name in cons:
self.rating_store.delete(name)
self._update_cache(*self.current_query)
store = JsonStore("src/names.json")
with open("data_det.txt", "r") as f:
detailed = [x.strip().split('\t') for x in f.readlines()]
with open("data.txt", "r") as f:
variants = [x.strip().split('\t') for x in f.readlines()]
print detailed[-1]
langs = Counter()
names = []
for entry in detailed:
if store.exists(entry[0]):
store.delete(entry[0])
tmp_var = []
for g, v, b in variants:
if b == entry[0]:
tmp_var.append(v)
language = format_lang(entry[-1])
length = len(entry[0].decode("utf-8"))
names.append((entry[0], language))
store.put(entry[0],
gender=entry[2],
language=language,
variants=tmp_var,
words=entry[-2],
origin=entry[1],
# salvando valores
store.put('tito', name='Mathieu', org='kivy')
store.put('tshirtman', name='Gabriel', age=27)
# subistituindo valor
store.put('tito', name='Mathieu', age=30)
# recuperando valor
print('tito is', store.get('tito')['age'])
# verificanco se existe
if store.exists('tito'):
print('tite exists:', store.get('tito'))
# deletando valor
store.delete('tito')
# trz todas ocorrencia em que nome é igual Gabriel
for item in store.find(name='Gabriel'):
print('tshirtmans index key is', item[0])
print('his key value pairs are', str(item[1]))
entries = list(
store.find(name='Mathieu')) #pode ser usado convertido em uma lista
store.clear() # Limpe todo o armazenamento.
store.count() # Retorna o número de entradas armazenadas.
store.keys() #Retorna uma lista com todas as chaves armazenadas.
# ==========================================================
# ASSINCRONA
class DataBase:
url = 'https://ospapp-53708.firebaseio.com/.json?auth='
admin_passwd = ''
def __init__(self, path, heroes_path, passwd_path):
self.path = path
self.store = JsonStore(path)
with open("secret", 'r') as file:
data = file.read().split("\n")
self.url = self.url + data[0]
self.firebase_patch_all()
try:
string = str(requests.get(self.url).json()['heroes'])
if string:
with open(heroes_path, 'w') as file:
file.write(string)
except Exception as e:
print(str(e))
try:
with open(heroes_path, 'r') as file:
self.heroes = json.loads(str(file.read()).replace("'", '"'))
except Exception as e:
print(str(e))
self.heroes = ["brak strażaków w bazie"]
try:
string = str(requests.get(self.url).json()['passwd'])
if string:
with open(passwd_path, 'w') as file:
file.write(string)
except Exception as e:
print(str(e))
try:
with open(passwd_path, 'r') as file:
global admin_passwd
admin_passwd = file.readline()
except Exception as e:
print(str(e))
def put_report(self, uuid_num, id_number, dep_date, dep_time, spot_time,
location, type_of_action, section_com, action_com, driver,
perpetrator, victim, section, details, return_date,
end_time, home_time, stan_licznika, km_location, completed):
if uuid_num == "":
uuid_num = str(uuid.uuid1())
if section_com == "Dowódca sekcji":
section_com = ""
if action_com == "Dowódca akcji":
action_com = ""
if driver == "Kierowca":
driver = ""
self.store.put(uuid_num,
innerID=id_number,
depDate=dep_date,
depTime=dep_time,
spotTime=spot_time,
location=location,
type=type_of_action,
sectionCom=section_com,
actionCom=action_com,
driver=driver,
perpetrator=perpetrator,
victim=victim,
section=section,
details=details,
returnDate=return_date,
endTime=end_time,
homeTime=home_time,
stanLicznika=stan_licznika,
KM=km_location,
modDate=self.get_date(),
ready=completed)
try:
string = "{'" + uuid_num + "': " + str(
self.store.get(uuid_num)) + "}"
to_database = json.loads(string.replace("'", '"'))
requests.patch(url=self.url, json=to_database)
except Exception as e:
print(str(e))
def delete_report(self, uuid_num):
if self.store.exists(uuid_num):
try:
# requests.delete(url=self.url[:-5] + id_number + ".json")
string = '{"deleted-' + uuid_num + '": "true"}'
to_database = json.loads(string)
requests.patch(url=self.url, json=to_database)
except Exception as e:
Factory.deletePopout().open()
print(str(e))
else:
self.store.delete(uuid_num)
else:
return -1
def get_heroes(self):
return self.heroes
def firebase_patch_all(self):
try:
with open(self.path, 'r') as file:
data = file.read()
to_database = json.loads(data)
requests.patch(url=self.url, json=to_database)
except Exception as e:
print(str(e))
def delete_all(self):
string_all = ""
try:
for key in self.store.keys():
# requests.delete(url=self.url[:-5] + key + ".json")
string = '{"deleted-' + key + '": "true"}'
string_all = string_all + string
to_database = json.loads(string)
requests.patch(url=self.url, json=to_database)
except Exception as e:
Factory.deletePopout().open()
print(str(e))
else:
self.store.clear()
def get_report(self, id_number):
for item in self.store.find(innerID=id_number):
dane = self.store.get(item[0])
id_number = dane['innerID']
dep_date = dane['depDate']
dep_time = dane['depTime']
spot_time = dane['spotTime']
location = dane['location']
type_of_action = dane['type']
section_com = dane['sectionCom']
action_com = dane['actionCom']
driver = dane['driver']
perpetrator = dane['perpetrator']
victim = dane['victim']
section = dane['section']
details = dane['details']
return_date = dane['returnDate']
end_time = dane['endTime']
home_time = dane['homeTime']
stan_licznika = dane['stanLicznika']
km_location = dane['KM']
date = dane['modDate']
completed = dane['ready']
return [
item[0], id_number, dep_date, dep_time, spot_time, location,
type_of_action, section_com, action_com, driver, perpetrator,
victim, section, details, return_date, end_time, home_time,
stan_licznika, km_location, date, completed
]
else:
return -1
def get_all_friendly(self):
result = []
for item in self.store.keys():
data = self.store.get(item)
result.append(data["innerID"] + " " + data["location"])
return result
def find_inner_id(self, id_number):
for _ in self.store.find(innerID=id_number):
return True
return False
@staticmethod
def get_date():
return str(datetime.datetime.now()).split(".")[0]
def get_passwd(self):
global admin_passwd
return admin_passwd
class DataBase:
base_url = 'https://osptest-3ddc5.firebaseio.com/'
url = ''
secret = ''
admin_password = ''
def __init__(self, path, heroes_path, password_path, trucks_path, version):
self.version = version
self.heroes_path = heroes_path
self.password_path = password_path
self.trucks_path = trucks_path
self.path = path
self.store = JsonStore(path)
with open("login_data/login", 'r') as file:
self.user = file.read().split("\n")[0]
with open("login_data/secret", 'r') as file:
self.secret = file.read().split("\n")[0]
self.url = self.base_url + self.user + self.secret
self.firebase_patch_all()
self.update_osp_data()
def update_osp_data(self):
try:
string = str(requests.get(self.url).json()['heroes'])
if string:
with open(self.heroes_path, 'w') as file:
file.write(string)
except Exception as connection_error:
Logger.exception(str(connection_error))
try:
with open(self.heroes_path, 'r') as file:
self.heroes = json.loads(str(file.read()).replace("'", '"'))
except Exception as no_heroes_in_db:
Logger.exception(str(no_heroes_in_db))
self.heroes = ["brak strażaków w bazie"]
try:
string = str(requests.get(self.url).json()['trucks'])
if string:
with open(self.trucks_path, 'w') as file:
file.write(string)
except Exception as connection_error:
Logger.exception(str(connection_error))
try:
with open(self.trucks_path, 'r') as file:
self.trucks = json.loads(str(file.read()).replace("'", '"'))
except Exception as no_trucks_in_db:
Logger.exception(str(no_trucks_in_db))
self.trucks = ["brak zastepów w bazie"]
try:
string = str(requests.get(self.url).json()['passwd'])
if string:
with open(self.password_path, 'w') as file:
file.write(string)
except Exception as no_password_in_db:
Logger.exception(str(no_password_in_db))
try:
with open(self.password_path, 'r') as file:
self.admin_password = file.readline()
except Exception as no_password_file:
Logger.exception(str(no_password_file))
def update_reports_data(self):
result = self.firebase_patch_all()
if result == -1:
Factory.connectionPopout().open()
else:
self.update_osp_data()
Factory.updateOK().open()
def put_report(self, uuid_num, id_number, dep_date, dep_time, spot_time,
location, type_of_action, section_com, action_com, driver,
perpetrator, victim, section, details, return_date,
end_time, home_time, meter_reading, km_location, completed,
truck_num):
if uuid_num == "":
uuid_num = str(uuid.uuid1())
if section_com == "Dowódca sekcji":
section_com = ""
if action_com == "Dowódca akcji":
action_com = ""
if driver == "Kierowca":
driver = ""
if truck_num == "Zastęp":
truck_num = ""
self.store.put(uuid_num,
innerID=id_number,
depDate=dep_date,
depTime=dep_time,
spotTime=spot_time,
location=location,
type=type_of_action,
sectionCom=section_com,
actionCom=action_com,
driver=driver,
perpetrator=perpetrator,
victim=victim,
section=section,
details=details,
returnDate=return_date,
endTime=end_time,
homeTime=home_time,
stanLicznika=meter_reading,
KM=km_location,
modDate=self.get_date(),
ready=completed,
truck=truck_num)
try:
string = "{'" + uuid_num + "': " + str(
self.store.get(uuid_num)) + "}"
to_database = json.loads(string.replace("'", '"'))
requests.patch(url=self.url, json=to_database)
return 0
except Exception as connection_error:
Logger.exception(str(connection_error))
return -1
def delete_report(self, uuid_num):
if self.store.exists(uuid_num):
try:
# requests.delete(url=self.url[:-5] + id_number + ".json")
string = '{"deleted-' + uuid_num + '": "true"}'
to_database = json.loads(string)
requests.patch(url=self.url, json=to_database)
self.store.delete(uuid_num)
except Exception as connection_error:
Factory.deletePopout().open()
Logger.exception(str(connection_error))
else:
return -1
def get_heroes(self):
return self.heroes.get("all")
def get_driver(self):
return self.heroes.get("driver")
def get_section_comm(self):
return self.heroes.get("section")
def get_action_comm(self):
return self.heroes.get("action")
def get_trucks(self):
return self.trucks
def firebase_patch_all(self):
try:
with open(self.path, 'r') as file:
data = file.read()
to_database = json.loads(data)
requests.patch(url=self.url, json=to_database)
to_database = json.loads('{"' + self.user + '": "' + self.version +
'"}')
requests.patch(url=self.base_url + "mobileVersion/" + self.secret,
json=to_database)
return 0
except Exception as connection_error:
Logger.exception(str(connection_error))
return -1
def delete_all(self):
string_all = ""
try:
for key in self.store.keys():
# requests.delete(url=self.url[:-5] + key + ".json")
string = '{"deleted-' + key + '": "true"}'
string_all = string_all + string
to_database = json.loads(string)
requests.patch(url=self.url, json=to_database)
self.store.clear()
except Exception as connection_error:
Factory.deletePopout().open()
Logger.exception(str(connection_error))
def get_report(self, id_number):
for item in self.store.find(innerID=id_number):
dane = self.store.get(item[0])
id_number = dane['innerID']
dep_date = dane['depDate']
dep_time = dane['depTime']
spot_time = dane['spotTime']
location = dane['location']
type_of_action = dane['type']
section_com = dane['sectionCom']
action_com = dane['actionCom']
driver = dane['driver']
perpetrator = dane['perpetrator']
victim = dane['victim']
section = dane['section']
details = dane['details']
return_date = dane['returnDate']
end_time = dane['endTime']
home_time = dane['homeTime']
meter_reading = dane['stanLicznika']
km_location = dane['KM']
date = dane['modDate']
completed = dane['ready']
truck_num = dane['truck']
return [
item[0], id_number, dep_date, dep_time, spot_time, location,
type_of_action, section_com, action_com, driver, perpetrator,
victim, section, details, return_date, end_time, home_time,
meter_reading, km_location, date, completed, truck_num
]
else:
return -1
def get_all_friendly(self):
result = []
for item in self.store.keys():
data = self.store.get(item)
result.append(data["innerID"] + " " + data["location"])
return result
def find_inner_id(self, id_number):
for _ in self.store.find(innerID=id_number):
return True
return False
@staticmethod
def get_date():
return str(datetime.datetime.now()).split(".")[0]
def get_user(self):
return self.user
def get_password(self):
return self.admin_password
def change_osp(self, user, password):
with open("login_data/login", 'r') as file:
old_user = file.read().split("\n")[0]
if user != old_user:
try:
user_password = str(
requests.get(self.base_url + "passwd/" + user +
self.secret).json())
to_database = json.loads('{"' + user + '": "' + self.version +
'"}')
requests.patch(url=self.base_url + "mobileVersion/" +
self.secret,
json=to_database)
except Exception as connection_error:
Logger.exception(str(connection_error))
return -2 # no connection
if user_password == "UPDATE":
return -3 # update neeeded
if user_password == "None" or password != user_password:
return -1 # wrong password
self.url = self.base_url + user + self.secret
try:
string = str(requests.get(self.url).json()['heroes'])
with open(self.heroes_path, 'w') as file:
file.write(string)
except Exception as connection_error:
Logger.exception(str(connection_error))
with open(self.heroes_path, 'w') as file:
file.write("")
try:
with open(self.heroes_path, 'r') as file:
self.heroes = json.loads(
str(file.read()).replace("'", '"'))
except Exception as no_heroes_in_db:
Logger.exception(str(no_heroes_in_db))
self.heroes = ["brak strażaków w bazie"]
try:
string = str(requests.get(self.url).json()['trucks'])
with open(self.trucks_path, 'w') as file:
file.write(string)
except Exception as connection_error:
Logger.exception(str(connection_error))
try:
with open(self.trucks_path, 'r') as file:
self.trucks = json.loads(
str(file.read()).replace("'", '"'))
except Exception as no_trucks_in_db:
Logger.exception(str(no_trucks_in_db))
self.trucks = ["brak zastepów w bazie"]
try:
string = str(requests.get(self.url).json()['passwd'])
with open(self.password_path, 'w') as file:
file.write(string)
except Exception as connection_error:
Logger.exception(str(connection_error))
self.url = self.base_url + self.user + self.secret
return -2
try:
with open(self.password_path, 'r') as file:
self.admin_password = file.readline()
except Exception as no_password:
Logger.exception(str(no_password))
self.store.clear()
self.user = user
with open("login_data/login", 'w') as file:
file.write(user)
return 0
class MainApp(MDApp):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.theme_cls.theme_style = "Light"
self.theme_cls.primary_palette = "Teal"
self.storage = JsonStore('../store.json')
self.emails = JsonStore('../emails.json')
self.view_stock_widgets = []
self.manage_items_widgets = []
self.add_remove_stock_widgets = []
self.edit_item_widgets = []
self.send_data_widgets = []
self.low_stock_widgets = []
def add_item(self, name, stock_type, stock_level, stock_units,
low_threshold, pop_weighting):
inputs = [
name, stock_type, stock_level, stock_units, low_threshold,
pop_weighting
]
if '' not in inputs:
self.storage.put(name,
name=name,
stock_type=stock_type,
stock_level=int(stock_level),
stock_units=stock_units,
low_threshold=int(low_threshold),
pop_weighting=int(pop_weighting))
else:
toast('Some fields were left blank...')
def remove_item(self, name):
self.storage.delete(name)
def remove_email(self, email):
self.emails.delete(email)
def update_stock_level(self, name, stock_level_change):
item = self.storage.get(name)
item['stock_level'] += stock_level_change
if item['stock_level'] < 0:
item['stock_level'] = 0
self.storage.put(name,
name=name,
stock_type=item['stock_type'],
stock_level=item['stock_level'],
stock_units=item['stock_units'],
low_threshold=item['low_threshold'],
pop_weighting=item['pop_weighting'])
def apply_stock_changes(self):
for widget in self.add_remove_stock_widgets:
try:
if widget.ids.plus_minus.active == True:
sign = '+'
else:
sign = '-'
except AttributeError:
continue
if len(widget.ids.stock.text) > 0:
stock_change = sign + widget.ids.stock.text
self.update_stock_level(widget.ids.name.text,
int(stock_change))
widget.ids.stock.text = ''
self.load_add_remove_stock_screen()
self.load_low_stock_screen()
toast('Update Successful')
def apply_edit_changes(self, name, stock_type, stock_level, stock_units,
low_threshold, pop_weighting):
self.storage.delete(self.editing_item)
self.storage.put(name,
name=name,
stock_type=stock_type,
stock_level=int(stock_level),
stock_units=stock_units,
low_threshold=int(low_threshold),
pop_weighting=int(pop_weighting))
self.load_manage_items_screen()
self.load_view_stock_screen()
self.load_add_remove_stock_screen()
self.load_low_stock_screen()
self.editing_item = None
toast('Changes Applied')
def delete_item(self, item):
screen = self.root.ids.screen_manager.current
if screen == 'manage_items':
self.remove_item(item)
self.root.ids.screen_manager.current = 'manage_items'
self.load_manage_items_screen()
self.load_view_stock_screen()
self.load_add_remove_stock_screen()
self.load_low_stock_screen()
elif screen == 'send_data':
self.remove_email(item)
self.root.ids.screen_manager.current = 'send_data'
self.load_send_data_screen()
toast('Deleted')
def load_manage_items_screen(self):
for widget in self.manage_items_widgets:
self.root.ids.manage_items_list.remove_widget(widget)
keys = sorted(self.storage.keys())
stock_types = []
for key in self.storage:
item = self.storage.get(key)
if item['stock_type'] not in stock_types:
stock_types.append(item['stock_type'])
stock_types.sort()
for stock_type in stock_types:
widget = Subtitle_Widget(stock_type)
self.root.ids.manage_items_list.add_widget(widget)
self.manage_items_widgets.append(widget)
for key in keys:
item = self.storage.get(key)
if item['stock_type'] == stock_type:
name = item['name']
widget = Manage_Items_Swipe_Card(name)
self.root.ids.manage_items_list.add_widget(widget)
self.manage_items_widgets.append(widget)
def load_view_stock_screen(self):
for widget in self.view_stock_widgets:
self.root.ids.view_stock_list.remove_widget(widget)
keys = sorted(self.storage.keys())
stock_types = []
for key in self.storage:
item = self.storage.get(key)
if item['stock_type'] not in stock_types:
stock_types.append(item['stock_type'])
stock_types.sort()
for stock_type in stock_types:
widget = Subtitle_Widget(stock_type)
self.root.ids.view_stock_list.add_widget(widget)
self.view_stock_widgets.append(widget)
for key in keys:
item = self.storage.get(key)
if item['stock_type'] == stock_type:
name = item['name']
stock_level = item['stock_level']
units = item['stock_units']
low_threshold = item['low_threshold']
if stock_level <= low_threshold:
low = True
else:
low = False
stock_level_string = str(stock_level) + ' ' + str(units)
widget = View_Stock_Card(name, stock_level_string, low)
self.root.ids.view_stock_list.add_widget(widget)
self.view_stock_widgets.append(widget)
def load_add_remove_stock_screen(self):
for widget in self.add_remove_stock_widgets:
self.root.ids.add_remove_stock_list.remove_widget(widget)
self.add_remove_stock_widgets = []
keys = sorted(self.storage.keys())
stock_types = []
for key in self.storage:
item = self.storage.get(key)
if item['stock_type'] not in stock_types:
stock_types.append(item['stock_type'])
stock_types.sort()
for stock_type in stock_types:
widget = Subtitle_Widget(stock_type)
self.root.ids.add_remove_stock_list.add_widget(widget)
self.add_remove_stock_widgets.append(widget)
for key in keys:
item = self.storage.get(key)
if item['stock_type'] == stock_type:
name = item['name']
widget = Add_Remove_Stock_Card(name)
self.root.ids.add_remove_stock_list.add_widget(widget)
self.add_remove_stock_widgets.append(widget)
widget = MDCard(size_hint_y=None, height='50dp')
self.root.ids.add_remove_stock_list.add_widget(widget)
self.add_remove_stock_widgets.append(widget)
def load_edit_item_screen(self, key):
for widget in self.edit_item_widgets:
self.root.ids.edit_item_layout.remove_widget(widget)
self.edit_item_widgets = []
item = self.storage.get(key)
widget = Edit_Item_Dialog_Content()
widget.ids.item_name.text = str(item['name'])
widget.ids.item_type.text = str(item['stock_type'])
widget.ids.stock_level.text = str(item['stock_level'])
widget.ids.stock_units.text = str(item['stock_units'])
widget.ids.low_threshold.text = str(item['low_threshold'])
widget.ids.pop_weighting.text = str(item['pop_weighting'])
self.root.ids.edit_item_layout.add_widget(widget)
self.edit_item_widgets.append(widget)
self.editing_item = item['name']
def load_send_data_screen(self):
for widget in self.send_data_widgets:
self.root.ids.emails_list.remove_widget(widget)
self.send_data_widgets = []
keys = sorted(self.emails.keys())
for key in keys:
email = self.emails.get(key)
widget = Email_Contact_Card(email['email'])
self.root.ids.emails_list.add_widget(widget)
self.send_data_widgets.append(widget)
def load_low_stock_screen(self):
for widget in self.low_stock_widgets:
self.root.ids.low_stock_layout.remove_widget(widget)
self.low_stock_widgets = []
keys = sorted(self.storage.keys())
stock_types = []
for key in self.storage:
item = self.storage.get(key)
if item['stock_type'] not in stock_types:
stock_types.append(item['stock_type'])
stock_types.sort()
for stock_type in stock_types:
widget = Subtitle_Widget(stock_type)
self.root.ids.low_stock_layout.add_widget(widget)
self.low_stock_widgets.append(widget)
for key in keys:
item = self.storage.get(key)
if item['stock_type'] == stock_type and item[
'stock_level'] <= item['low_threshold']:
widget = Low_Stock_Item_Card(item['name'])
self.root.ids.low_stock_layout.add_widget(widget)
self.low_stock_widgets.append(widget)
def open_add_item_popup(self):
content = Add_Item_Dialog_Content()
self.popup = MDDialog(
type='custom',
content_cls=content,
auto_dismiss=False,
)
self.popup.open()
def confirm_delete_dialog(self, item):
content = Confirm_Delete_Dialog_Content(item)
self.popup = MDDialog(
type='custom',
content_cls=content,
auto_dismiss=False,
)
self.popup.open()
def open_add_email_popup(self):
content = Add_Email_Content()
self.popup = MDDialog(
type='custom',
content_cls=content,
auto_dismiss=False,
)
self.popup.open()
def add_contact(self, email):
self.emails.put(email, email=email, sent=False)
self.load_send_data_screen()
def send_email(self, email):
address = self.emails.get(email)
self.emails.put(email, email=email, sent=True)
#customise frm and password to send emails from your account for testing purposes.
frm = '*****@*****.**'
password = ''
to = email
subject = 'Stock Level Data'
server = smtplib.SMTP(host='smtp.gmail.com', port=587)
server.starttls()
server.login(frm, password)
msg = MIMEMultipart()
msg['From'] = frm
msg['to'] = to
msg['subject'] = subject
body = ""
keys = self.storage.keys()
keys.sort()
stock_types = []
for key in keys:
stock_type = self.storage.get(key)['stock_type']
if stock_type not in stock_types:
stock_types.append(stock_type)
for stock_type in stock_types:
body += '%s\n' % stock_type.upper()
for key in keys:
item = self.storage.get(key)
if item['stock_type'] == stock_type:
body += '%s: %s %s\n' % (item['name'], item['stock_level'],
item['stock_units'])
body += '\n'
msg.attach(MIMEText(body, 'plain'))
server.sendmail(frm, to, msg.as_string())
toast('Sent to: %s' % email)
def set_screen(self, screen):
self.root.ids.screen_manager.current = screen
def build(self):
self.title = 'WTF Stock Take'
return MainLayout()
def on_start(self):
self.load_manage_items_screen()
self.load_view_stock_screen()
self.load_add_remove_stock_screen()
self.load_send_data_screen()
self.load_low_stock_screen()
class MainApp(App):
def build(self): # build() returns an instance
self.store = JsonStore("streak.json") # file that stores the streaks:
Clock.schedule_interval(self.check_streak,
1 / 30.) # used to call functions dynamicaly
Clock.schedule_interval(self.score_gone, 1 / 30.)
Clock.schedule_interval(self.update_high, 1 / 30.)
return presentation
# used to see if streak is early, ontime, or late, then changes the color of button
def check_streak(self, dt):
for child in reversed(self.root.screen_two.ids.streak_zone.children):
name = child.id
with open("streak.json", "r") as read_file:
data = json.load(read_file)
for key in data.keys():
if key == name:
delay = data.get(key, {}).get(
'delay') # get value of nested key 'delay'
self.honey = data[key]['delta']
float(self.honey)
if delay > time.time() < self.honey: # early (yellow)
child.background_normal = ''
child.background_color = [1, 1, 0, .95]
child.unbind(on_press=self.add_score)
child.bind(on_press=self.display_streak)
child.bind(on_press=self.early_click)
child.unbind(on_press=self.draw_streak)
child.unbind(on_press=self.late_click)
elif delay > time.time() > self.honey: # on time (green)
child.background_normal = ''
child.background_color = [0, 1, 0, .95]
child.unbind(on_press=self.early_click)
child.bind(on_press=self.add_score)
child.bind(on_press=self.display_streak)
child.bind(on_press=self.draw_streak)
child.unbind(on_press=self.late_click)
elif delay < time.time() > self.honey: # late (red)
child.background_normal = ''
child.background_color = [1, 0, 0, .95]
child.unbind(on_press=self.add_score)
child.bind(on_press=self.display_streak)
child.unbind(on_press=self.early_click)
child.unbind(on_press=self.draw_streak)
child.bind(on_press=self.late_click)
# when button is early or yellow
def early_click(self, obj):
early_text = ("you're too early wait %s minute(s)" % (round(
(self.honey - time.time()) / 60)))
pop_early = Popup(title="Early!",
content=Label(text=early_text),
size_hint=(None, None),
size=(300, 100))
pop_early.open()
# when button is late or red
def late_click(self, obj):
late_text = "Its too late, delete streak and start over :("
pop_late = Popup(title="Late!",
content=Label(text=late_text),
size_hint=(None, None),
size=(300, 300))
pop_late.open()
self.third_screen()
# displays third screen
def third_screen(self, *args):
self.root.current = 'three'
# displays second screen and buttons
def change_screen(self, *args):
self.root.current = 'two'
# clears page of all widgets
def restart(self):
self.root.screen_two.ids.streak_zone.clear_widgets()
self.root.screen_two.ids.high_label.clear_widgets()
# display the names of the streaks in a list on PageTwo
def display_btn(self):
no_data = "You have no stored streaks!"
popup_2 = Popup(title="No Streaks!",
content=Label(text=no_data),
size_hint=(None, None),
size=(300, 100))
try:
with open("streak.json", "r") as read_file:
data = json.load(read_file)
for value in data.values():
if value['delta'] is not None:
print(
f"action={value['action']}, delta={value['delta']}, grace={value['delay']}"
)
streak_button = StreakButton(
id=(value['action']),
text=(value['action'] + " " + "[" +
str(value['score']) + "]"),
color=(0, 0, 0, 1),
size=(400, 50),
size_hint=(None, None))
self.root.screen_two.ids.streak_zone.add_widget(
streak_button)
# turns key of highest streak and its value into tuple
try:
self.highest = max((int(value['score']), key)
for key, value in data.items())
self.high_string = "Highest Streak: \"%s\", with a streak of %s" % (
self.highest[1], self.highest[0])
self.root.screen_two.ids.high_label.add_widget(
Label(text=self.high_string,
size_hint=(None, None),
font_size=16))
except ValueError as error:
popup_2.open()
self.root.current = 'one'
except (json.decoder.JSONDecodeError, FileNotFoundError) as error:
popup_2.open()
self.root.current = 'one'
# update text that says the highest streak and its score
def update_high(self, dt):
for child in reversed(self.root.screen_two.ids.high_label.children):
if child.text != self.high_string:
self.root.screen_two.ids.high_label.remove_widget(child)
elif child.text == self.high_string:
pass
# add 1 to score and store in json file
def add_score(self, obj):
name = obj.id
with open("streak.json", "r") as file:
read = json.load(file)
for key in read.keys():
if key == name:
with open("streak.json", "r+") as f:
data = json.load(f)
data[key]['score'] += 1
grace_sec = data.get(key, {}).get('grace_sec')
new_delay = time.time() + grace_sec
data[key]['delay'] = new_delay
seconds = data.get(key, {}).get('seconds')
new_delta = time.time() + seconds
data[key]['delta'] = new_delta
f.seek(0)
json.dump(data, f, indent=4)
f.truncate()
# change score to 0 and stores in json file
def score_gone(self, dt):
for child in self.root.screen_two.ids.streak_zone.children:
name = child.id
color = child.background_color
if color == [1, 0, 0, .95]: # red
with open("streak.json", "r") as file:
read = json.load(file)
if read[name]['score'] != 0: #stops slow down from Clock
with open("streak.json",
"r+") as f: # fix score not reseting to 0
data = json.load(f)
data[name]['score'] = 0
f.seek(0)
json.dump(data, f, indent=4)
f.truncate()
elif read[name]['score'] == 0: #stops slow down from Clock
pass
# displays the streak that was clicked on in screen two
def display_streak(self, obj):
self.third_screen()
name = obj.id
bottle = self.root.get_screen('three')
can = self.root.get_screen('two')
with open("streak.json", "r") as file:
read = json.load(file)
if read[name]['score'] == 0:
bottle.ids.selected_streak.add_widget(
Label(id=name,
text=(name + " " + "[" + str(read[name]['score']) + "]"),
size_hint=(None, None),
font_size=18))
else:
bottle.ids.selected_streak.add_widget(
Label(id=name,
text=(name + " " + "[" +
str(int(read[name]['score'] + 1)) + "]"),
size_hint=(None, None),
font_size=18))
bottle.ids.del_space.add_widget(
Button(id=name,
text="Delete",
size=(60, 25),
size_hint=(None, None),
font_size=18,
on_press=self.del_button))
def draw_streak(self, obj):
name = obj.id
with open("streak.json", "r") as file:
read = json.load(file)
for key in read.keys():
if key == name:
with open("streak.json", "r+") as f:
data = json.load(f)
get_score = data.get(key, {}).get('score')
root = App.get_running_app().root
can = root.get_screen('three')
new_pos = can.pos
new_pos[1] = root.height - 120 # below label
for x in range(
-1,
get_score): # had to use -1 to get correct amount of shapes
if get_score <= 70:
with can.ids.my_box.canvas:
Color(0, 1, 0, .75, mode='rgba')
rect = Ellipse(pos=new_pos, size=(40, 40))
new_pos[0] += rect.size[0] * 2 # x coordinate
if new_pos[0] >= (root.width - rect.size[0]):
new_pos[0] = 0
new_pos[1] -= rect.size[0] * 2 # y coordinate
# following code makes rectangles smaller to fit the screen
elif 70 < get_score < 260:
with can.ids.my_box.canvas:
Color(0, 1, 0, .75, mode='rgba')
rect = Ellipse(pos=new_pos, size=(20, 20))
new_pos[0] += rect.size[0] * 2 # x coordinate
if new_pos[0] >= (root.width - rect.size[0]):
new_pos[0] = 0
new_pos[1] -= rect.size[0] * 2 # y coordinate
elif 260 > get_score > 70:
with can.ids.my_box.canvas:
Color(0, 1, 0, .75, mode='rgba')
rect = Ellipse(pos=new_pos, size=(10, 10))
new_pos[0] += rect.size[0] * 2 # x coordinate
if new_pos[0] >= (root.width - rect.size[0]):
new_pos[0] = 0
new_pos[1] -= rect.size[0] * 2 # y coordinate
elif get_score >= 1000:
with can.ids.my_box.canvas:
Color(0, 1, 0, .75, mode='rgba')
rect = Ellipse(pos=new_pos, size=(5, 5))
new_pos[0] += rect.size[0] * 2 # x coordinate
if new_pos[0] >= (root.width - rect.size[0]):
new_pos[0] = 0
new_pos[1] -= rect.size[0] * 2 # y coordinate
# deletes streaks
def del_button(self, object):
self.store = JsonStore("streak.json")
name = object.id
self.store.delete(name)
self.change_screen()
def update_label(self, dt):
if self.root.current == "two":
pass
# creates the Streak object
def create(self):
self.store = JsonStore("streak.json")
obj = self.root.get_screen('one') # get info from ScreenOne
self.streak = Streak(obj.ids.action_entry.text,
obj.ids.delay_entry.text, obj.ids.day_entry.text,
obj.ids.hour_entry.text,
obj.ids.minute_entry.text)
empty_error = "Make sure to fill out all boxes!" # not in use yet
popup = Popup(title="Not filled",
content=Label(text=empty_error),
size_hint=(None, None),
size=(300, 100))
# error handling and calculating total seconds
parsed = False
try:
total = (
(int(self.streak.day) * 86400) +
(int(self.streak.hour) * 3600) + (int(self.streak.minute) * 60)
) # convert into seconds
self.current_time = time.time()
self.count = self.current_time + total
grace = (int(self.streak.delay) * 60) + self.count # aka delay
grace_sec = (int(self.streak.delay) * 60) + total
parsed = True
# delete later just used to test
print("[seconds:", total, ']', "[action:", self.streak.action, ']',
"[grace:", grace, ']')
# store streak attributes inside "streak.json"
self.store.put(self.streak.action,
action=self.streak.action,
delay=grace,
seconds=total,
score=1,
delta=self.count,
grace_sec=grace_sec)
self.change_screen(self)
except ValueError as error:
popup.open()
def __init__(self, **kwargs):
# Get employee details from google and populate the app. If unable to connect,
# get the details from local storage.
# TODO: Check that the last saved version from google is the same as the local storage.
super(EmployeeList, self).__init__(**kwargs)
connected = True
employees = []
failedAttempts = 0
# Try to open the google worksheet to load employee data.
try:
employeeSheet = self.get_google_sheet(
config.GOOGLE_CONFIG['employeeSheet'])
except:
print "Error connecting to the google server"
connected = False
if connected:
# Get employees from google and sort into alphabetical order (by Surname)
employeeImport = employeeSheet.get_all_records()
# Create local storage for the employees
store = JsonStore('employees.json')
for e in store:
store.delete(e)
for e in employeeImport:
# Convert yes/no fields to bool. Remove inactive users.
e['active'] = str2bool(e['active'])
if e['active']:
e['signedIn'] = str2bool(e['signedIn'])
# Add employee to local storage.
store.put(e['employeeNo'],
name=e['name'],
surname=e['surname'],
signedIn=e['signedIn'],
timeIn=e['timeIn'],
timeOut=e['timeOut'])
# Convert time string to datetime objects
if e['timeIn'] != "":
e['timeIn'] = datetime.datetime.strptime(
e['timeIn'], "%Y-%m-%d %X")
if e['timeOut'] != "":
e['timeOut'] = datetime.datetime.strptime(
e['timeOut'], "%Y-%m-%d %X")
# Create the data clean element
e['clean'] = True
# Add record to the employees
employees.append(e)
else:
# If the employee is inactive, remove from the list.
# employees.remove(e)
print "{} {} is DELETED".format(e['name'], e['surname'])
else:
# If unable to connect to google server, connect to local.
print('Failed to connect to Google Server')
store = JsonStore('employees.json')
for e in store:
# Check and convert time
if store.get(e)['timeIn'] != "":
timeInString = datetime.datetime.strptime(
store.get(e)['timeIn'], "%Y-%m-%d %X")
else:
timeInString = ""
if store.get(e)['timeOut'] != "":
timeOutString = datetime.datetime.strptime(
store.get(e)['timeOut'], "%Y-%m-%d %X")
else:
timeOutString = ""
# Generate entry
entry = {
'employeeNo': e,
'name': store.get(e)['name'],
'surname': store.get(e)['surname'],
'signedIn': store.get(e)['signedIn'],
'timeIn': timeInString,
'timeOut': timeOutString,
}
employees.append(entry)
# Sort employee and set data
self.data = sorted(employees, key=itemgetter('surname'))
class CalcPyApp(App):
def build(self):
self.store = JsonStore('scripts.json')
self.appview = NavigationDrawer()
self.appview.anim_type = 'reveal_below_anim'
side_panel = BoxLayout(orientation='vertical')
title = Label(text='Pycalc')
title.size = self.appview.width, 30
title.size_hint_y = None
side_panel.add_widget(title)
new_btn = Button(text='New Script')
new_btn.size = self.appview.width, 50
new_btn.size_hint_y = None
new_btn.bind(on_press=lambda _: self.new_script())
side_panel.add_widget(new_btn)
s_in = TextInput()
s_in.multiline = False
s_in.size = self.appview.width, 50
s_in.size_hint_y = None
def show_s_in():
s_in.height, s_in.opacity, s_in.disabled = 50, 1, False
save_btn.height, save_btn.opacity, save_btn.disabled = 0, 0, True
def focus():
s_in.focus = True
Clock.schedule_once(lambda dt: focus(), 0.1)
def hide_s_in(x=False):
if x:
return
s_in.height, s_in.opacity, s_in.disabled = 0, 0, True
save_btn.height, save_btn.opacity, save_btn.disabled = 50, 1, False
save_btn = Button(text='Save Script')
save_btn.size = self.appview.width, 50
save_btn.size_hint_y = None
save_btn.bind(on_press=lambda _: show_s_in())
side_panel.add_widget(save_btn)
s_in.bind(on_text_validate=lambda instance: self.save_script(
instance.text.strip()))
s_in.bind(focused=lambda _, x: hide_s_in(x))
hide_s_in()
side_panel.add_widget(s_in)
load_btn = Button(text='Load Script')
load_btn.size = self.appview.width, 50
load_btn.size_hint_y = None
load_btn.bind(on_press=lambda _: self.load_script())
side_panel.add_widget(load_btn)
self.appview.add_widget(side_panel)
self.main_panel = ScrollableText()
self.appview.add_widget(self.main_panel)
return self.appview
def new_script(self):
global state
global lexer
state = State()
lexer.state = state
self.main_panel.layout.clear_widgets()
self.main_panel.add_new_codeline()
def save_script(self, name):
lines = []
for wid in reversed(self.main_panel.layout.children):
if isinstance(wid, CodeInput) and len(wid.text) > 0:
lines.append(wid.text)
if len(lines) > 0:
self.store.put(name, data=lines)
def load_script(self):
popup = Popup(title='Load script')
def want_delete(btn, choice_callback, _):
def delete(name):
self.store.delete(name)
btn.height, btn.opacity, btn.disabled = 0, 0, True
saved_text = btn.text
callback = lambda _: delete(saved_text)
def lost_focus(_):
btn.text = saved_text
btn.color = (1, 1, 1, 1)
btn.unbind(on_press=callback)
btn.bind(on_release=choice_callback)
btn.text = 'delete?'
btn.color = (1, 0, 0, 1)
btn.bind(on_press=callback)
Clock.schedule_once(lost_focus, 2)
btn.unbind(on_release=choice_callback)
def create_clock(widget, touch, choice_callback, *args):
if not isinstance(widget, Button):
return
if not widget.collide_point(*touch.pos):
return
callback = partial(want_delete, widget, choice_callback)
Clock.schedule_once(callback, 0.5)
touch.ud['event'] = callback
def delete_clock(widget, touch, *args):
if not isinstance(widget, Button):
return
if 'event' in touch.ud:
Clock.unschedule(touch.ud['event'])
del touch.ud['event']
def choice(name):
self.new_script()
data = self.store.get(name)['data']
for line in data:
codeinput = self.main_panel.layout.children[0]
codeinput.text = line
self.main_panel.code_interpret(codeinput)
popup.dismiss()
scroll_content = ScrollView()
content = BoxLayout(orientation='vertical', size_hint_y=None)
content.bind(minimum_height=content.setter('height'))
scroll_content.add_widget(content)
for item in self.store:
btn = Button(text=item)
btn.size = content.width, 50
btn.size_hint_y = None
choice_callback = lambda _: choice(item)
btn.bind(on_touch_down=partial(create_clock,
choice_callback=choice_callback),
on_touch_up=delete_clock)
btn.bind(on_release=choice_callback)
content.add_widget(btn)
close_btn = Button(text='Cancel')
close_btn.size_hint = 0.3, None
close_btn.height = 50
close_btn.bind(on_press=popup.dismiss)
content.add_widget(close_btn)
popup.content = scroll_content
popup.open()
