class ModalEdit(ModalView):
def __init__(self, root):
super(ModalEdit, self).__init__()
menu_items = [{
"text": str(i[1])
} for i in root.DB.type_name_db.select_all()]
self.root_app = root
self.menu = MDDropdownMenu(
caller=self.ids.p_type,
items=menu_items,
position="bottom",
width_mult=4,
)
self.menu.bind(on_release=self.set_item)
def ok_sw(self, root_app):
name = self.ids.name.text
p_type = self.ids.p_type.text
about = self.ids.about.text
price = self.ids.price.text
root_app.DB.product_db.insert_date(
('name', 'p_type', 'about', 'price'), (name, p_type, about, price))
self.dismiss()
def set_item(self, instance_menu, instance_menu_item):
def set_item(interval):
assert interval == interval
self.ids.p_type.text = instance_menu_item.text
instance_menu.dismiss()
Clock.schedule_once(set_item, 0.5)
class Test(MDApp):
submenu = None
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.screen = Builder.load_string(KV)
menu_items = [{
"icon": "git",
"text": f"Item {i}" if i != 3 else "Open submenu",
} for i in range(5)]
self.menu = CustomDrop(caller=self.screen.ids.button,
items=menu_items,
width_mult=4,
selected_color=self.theme_cls.bg_darkest)
self.menu.bind(on_enter=self.check_item)
def check_item(self, menu, item):
if item.text == "Open submenu" and not self.submenu:
menu_items = [{"text": f"Item {i}"} for i in range(5)]
self.submenu = MDDropdownMenu(
caller=item,
items=menu_items,
width_mult=4,
selected_color=self.theme_cls.bg_darkest,
)
self.submenu.bind(on_dismiss=self.set_state_submenu)
self.submenu.open()
def set_state_submenu(self, *args):
self.submenu = None
def build(self):
return self.screen
def create_dropdown(self, caller, item):
menu = MDDropdownMenu(caller=caller,
items=item,
position='bottom',
width_mult=20)
menu.bind()
return menu
class Consulta(Screen):
data_tables: MDDataTable
def __init__(self, **kwargs):
super(Consulta, self).__init__()
def menu_p(self):
menu_items = [{
"text": "Ingreso Movimientos"
}, {
"text": "Consulta de Movimientos"
}, {
"text": "Salir"
}]
self.menu = MDDropdownMenu(caller=self.ids.button,
items=menu_items,
width_mult=5,
callback=self.menu_callback)
self.menu.bind(on_release=self.menu_callback)
self.menu.open()
def menu_callback(self, instance):
opcion = instance
if opcion.text == "Ingreso Movimientos":
self.manager.current = 'Ingresos'
else:
print("Opcion seleccionada es :", opcion.text)
def habre_md_table(self):
Fun_Consultas.md_table(self)
class MainApp(MDApp):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.screen = Builder.load_file("test.kv")
menu_items = [{
"viewclass": "MDDropDownItem",
"icon": "git",
"text": f"Item {i}",
"height": dp(56),
"on_release": lambda x=f"Item {i}": self.set_item(x),
} for i in range(5)]
self.menu = MDDropdownMenu(
caller=self.screen.ids.from_currency,
items=menu_items,
position="center",
width_mult=4,
)
self.menu.bind()
def set_item(self, text_item):
self.screen.ids.from_currency.set_item(text_item)
self.menu.dismiss()
def build(self):
self.theme.cls.primary_palette = "BlueGray"
self.theme.cls.theme_style = "Dark"
return self.screen
def create_dropdown(self, caller, item, callback):
menu = MDDropdownMenu(caller=caller,
items=item,
position="center",
width_mult=20)
menu.bind(on_release=callback)
return menu
class SettingsScreen(MDBottomNavigationItem):
'''Contains content for choosing a theme and interface language'''
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.theme_colors = {}
for name_theme in palette:
self.theme_colors[name_theme] = get_color_from_hex(
colors[name_theme]['500'])
self.language_menu = None
self.languages = [{
'icon': 'images/rus.png',
'text': 'Русский'
}, {
'icon': 'images/eng.png',
'text': 'English'
}, {
'icon': 'images/deu.png',
'text': 'Deutsch'
}]
self.app = MDApp.get_running_app()
def create_language_menu(self):
'''Creates a language selection menu'''
self.language_menu = MDDropdownMenu(caller=self.lang_chooser,
items=self.languages,
width_mult=4)
self.language_menu.bind(on_release=self.set_language)
def set_language(self, menu_instance, item_instance):
'''Sets the selected interface language'''
if item_instance.text == 'Русский':
self.app.change_language(0)
elif item_instance.text == 'English':
self.app.change_language(1)
elif item_instance.text == 'Deutsch':
self.app.change_language(2)
self.lang_chooser.set_item(item_instance.text)
menu_instance.dismiss()
def create_dev_dialog(self):
'''Opens developer dialog by clicking developer button'''
dialog = DeveloperDialog()
dialog.dialog_title.text = languages[self.app.language]['developer']
dialog.developer_name.text = languages[self.app.language]['kirill']
dialog.open()
def feedback(self, link):
'''Opens feedback link by clicking feedback button'''
webbrowser.open(link)
def create_share_dialog(self):
'''TODO: release in Play Market'''
toast('Coming soon in Play Market')
def create_rate_dialog(self):
'''TODO: release in Play Market'''
toast('Coming soon in Play Market')
class CompanyScreen(Screen):
menu = MDDropdownMenu
error_banner = ObjectProperty(MDBanner)
def __init__(self, **kwargs):
super().__init__(**kwargs)
Clock.schedule_once(self.event_binding)
def event_binding(self, dt):
companies_selection = []
try:
response = requests.get(
'https://developer.mercaditu.com/api/authenticated/my/organizations',
headers={
'Authorization':
'Bearer 5|bWbmJ2bfFsDLOIcQ5rHKZCvmzrYY2uez0SpP82Sr',
'Accept': 'application/json',
'Content-type': 'application/json'
})
companies = response.json()
if len(companies) != 0:
for company in companies:
companies_selection.append({
"icon":
"account-box",
"text":
company["following"]["handle"]
})
self.menu = MDDropdownMenu(caller=self.ids.company_text,
items=companies_selection,
position="bottom",
width_mult=4,
callback=self.set_item)
self.menu.bind(on_release=self.set_item)
self.menu.set_menu_properties(0)
else:
raise Exception('La Empresa no se encuentra')
except Exception as e:
self.error_banner.text = [str(e)]
self.error_banner.right_action = [
"CLOSE", lambda x: self.error_banner.hide()
]
self.error_banner.show()
def set_item(self, *args):
self.ids.company_text.text = args[0].text
self.menu.dismiss()
def go_to_scan_page(self):
self.manager.transition.direction = 'left'
self.manager.current = 'scanner_screen'
def open_context_menu(self, entry_object, type_chooser):
"""Opens a context menu on right-clicking on a file or folder."""
menu = MDDropdownMenu(
caller=entry_object,
items=self.get_menu_right_click(entry_object, type_chooser),
width_mult=4,
background_color=self.theme_cls.bg_dark,
max_height=dp(240),
)
menu.bind(on_dismiss=self.context_menu_dismiss, )
menu.open()
self.context_menu_open = True
def create_menu(self, text, instance):
#Change icons and give importance
menu_items = [{
"icon": "help",
"text": "About"
}, {
"icon": "application-settings",
"text": "Settings"
}]
#tweak this for width
menu = MDDropdownMenu(caller=instance, items=menu_items, width_mult=5)
menu.bind(on_release=self.menu_callback)
return menu
class MDDropItem(Screen):
menu = None
def on_enter(self):
menu_items = [{"icon": "git", "text": f"Item {i}"} for i in range(5)]
self.menu = MDDropdownMenu(
caller=self.ids.dropdown_item,
items=menu_items,
position="center",
width_mult=4,
)
self.menu.bind(on_release=self.set_item)
def set_item(self, instance_menu, instance_menu_item):
self.ids.dropdown_item.set_item(instance_menu_item.text)
instance_menu.dismiss()
def create_pagination_menu(self, interval):
menu_items = [{
"text": f"{i}"
} for i in range(self.rows_num,
len(self.row_data) // 2, self.rows_num)]
pagination_menu = MDDropdownMenu(
caller=self.pagination.ids.drop_item,
items=menu_items,
use_icon_item=False,
position=self.pagination_menu_pos,
max_height=self.pagination_menu_height,
callback=self.table_data.set_number_displayed_lines,
width_mult=2,
)
pagination_menu.bind(on_dismiss=self.table_data.close_pagination_menu)
self.table_data.pagination_menu = pagination_menu
class MyDropdown(MDDropDownItem):
def __init__(self, list_items, icon, first_item_chosen=None, **kwargs):
super(MyDropdown, self).__init__(**kwargs)
menu_items = [{"icon": icon, "text": str(item)} for item in list_items]
self.menu = MDDropdownMenu(caller=self,
items=menu_items, position="auto",
width_mult=5)
self.menu.bind(on_release=self.set_item_dropdown)
self.bind(on_release=lambda _: self.menu.open())
if first_item_chosen is None:
first_item_chosen = str(list_items[0])
self.set_item(first_item_chosen)
def set_item_dropdown(self, _instance_menu, instance_menu_item):
selected_item = instance_menu_item.text
self.menu.dismiss()
self.set_item(selected_item)
class Menu(MDFloatLayout):
#menu = MDDropdownMenu()
Num = 4
def __init__(self, **kwargs):
#super().__init__(**kwargs)
self.menu_items = [{
"text":
f"Item {i}",
"viewclass":
"OneLineListItem",
'font_name':
"./font/FangZhengHeiTiJianTi-1",
"on_release":
lambda x=f"Item {i}": self.menu_callback(x)
} for i in range(self.Num)]
self.menu = MDDropdownMenu(
#caller=self.screen.ids.button,
caller=None,
items=self.menu_items,
width_mult=4,
)
self.menu.bind(on_release=self.menu_callback)
print(123)
#return self.menu
#
def menu_callback(self, instance_menu_item):
print("instance_menu", instance_menu_item)
#self.page_callback()
self.test = "Change Page"
print(self.test)
self.menu.dismiss()
def page_callback(self):
self.test = "Change Page"
print(self.test)
# let's start
def pop(self):
self.menu.open()
class TESTSCREEN(BoxLayout):
def __init__(self, master, **kwargs):
super().__init__(**kwargs)
self.master = master
icons = iter([
"../manga_nelo_icon.png", "../rawdevart_logo.png",
"../kissmanga_logo.png", "../manga_nelo_icon.png"
])
menu_items = [{
"right_content_cls": RightContentCls(site),
"icon": next(icons),
"text": site
} for site in ["manganelo", "rawart", "kissmanga", "idk"]]
self.btn = MDRaisedButton(text="press me",
pos_hint={
"center_x": .5,
"center_y": .5
})
self.btn.bind(on_press=lambda x: self.menu.open())
self.menu = MDDropdownMenu(caller=self.btn,
items=menu_items,
width_mult=4)
self.menu.bind(on_release=self.menu_callback)
self.add_widget(self.btn)
# Had to install dev version for callback to work
def menu_callback(self, instance_menu, instance_menu_item):
#print(instance_menu, instance_menu_item.text)
for i in instance_menu_item.children:
for j in i.children:
for k in j.children:
print(k, type(k))
if isinstance(k, MangaCheckBox):
if not k.active:
k.active = True
toast(
f"Manga will be searched on the site: {instance_menu_item.text}"
)
else:
k.active = False
class PriorityChooser(MDDropDownItem):
primary_color_hex = StringProperty()
def __init__(self, **kwargs):
super().__init__(**kwargs)
# set primary color
self.primary_color_hex = colors[self.theme_cls.primary_palette][self.theme_cls.primary_hue]
# content for menu
priority_menu_items = [
{'text': f'[color={self.primary_color_hex}] low [/color]', },
{'text': f'[color={self.primary_color_hex}] normal [/color]', },
{'text': f'[color={self.primary_color_hex}] high [/color]'},
{'text': f'[color={self.primary_color_hex}] very high [/color]'}
]
# created menu as dropdown menu
self.priority_menu = MDDropdownMenu(
caller=self,
items=priority_menu_items,
width_mult=2.5,
selected_color=self.theme_cls.primary_dark_hue,
)
# pressing triggeres task_menu_call
self.priority_menu.bind(on_release=self.priority_menu_call)
def priority_menu_call(self, instance_menu, instance_menu_item, *args):
# change MDDropDownItem text to chosen priority
# additional code for color removed via rstrip and slicing
self.text = instance_menu_item.text.rstrip('[/color]')[15:-1]
self.priority_menu.dismiss()
def on_text(self, instance, value):
# sets text of label to value with primary color as text_color
self.ids.label_item.text = value
self.ids.label_item.color = self.theme_cls.primary_color
class Content(BoxLayout):
def __init__(self, id, *args, **kwargs):
super().__init__(**kwargs)
if id:
person = next(
(obj for obj in app.persons.person_list if obj['id'] == id),
None)
else:
person = {
"id":
app.persons.person_list[len(app.persons.person_list) - 1]["id"]
+ 1,
"name":
"",
"state":
"Stát"
}
print(person)
self.ids.person_name.text = person['name']
STATES = [
'CAN', 'CZE', 'FIN', 'GBR', 'GER', 'JAP', 'NOR', 'POL', 'RUS',
'SVK', 'SWE', 'USA'
]
menu_items = [{"icon": "git", "text": f"{state}"} for state in STATES]
self.menu = MDDropdownMenu(
caller=self.ids.state_item,
items=menu_items,
position="center",
width_mult=4,
)
self.ids.state_item.set_item(person['state'])
self.menu.bind(on_release=self.set_item)
def set_item(self, instance_menu, instance_menu_item):
self.ids.state_item.set_item(instance_menu_item.text)
self.ids.state_item.text = instance_menu_item.text
self.menu.dismiss()
class Main(Screen):
menu = None
def open_menu(self, instance_button):
menu_items = [{"icon": "git", "text": f"Item {i}"} for i in range(5)]
if self.menu == None:
self.menu = MDDropdownMenu(
caller=instance_button,
items=menu_items,
position="auto",
width_mult=4,
)
self.menu.bind(on_release=self.set_item)
self.menu.open()
def set_item(self, instance_menu, instance_menu_item):
self.ids.label.text = instance_menu_item.text
self.menu.dismiss()
def slider_move(self, instance_slider, mouse_motion):
self.ids.label.text = str(instance_slider.value/100)
instance_slider.size_hint_y = instance_slider.value/100
self.ids.label.size_hint_y = 1-instance_slider.value/100
class ScreenSetting(MDScreen):
def __init__(self, **kwargs):
super().__init__(**kwargs)
menu_items = [{
"icon": "database",
"text": "SQLite"
}, {
"icon": "database",
"text": "MySQL"
}]
self.menu = MDDropdownMenu(
items=menu_items,
position="center",
width_mult=4,
)
self.menu.bind(on_release=self.set_item)
Clock.schedule_once(self.on_screen_paint)
def on_screen_paint(self, *args):
self.menu.caller = self.ids.db_backend
setting = Setting()
self.ids.db_backend.set_item(setting.backend)
self.ids.txt_uname.text = setting.username
self.ids.txt_pass.text = setting.password
if setting.backend == "SQLite":
self.ids.txt_dbname.text = setting.dbfile
else:
self.ids.txt_dbname.text = setting.dbname
def set_item(self, instance_menu, instance_menu_item):
self.ids.db_backend.set_item(instance_menu_item.text)
self.menu.dismiss()
setting = Setting()
setting.backend = instance_menu_item.text
setting.save_setting()
def btn_theme_click(self):
theme = App.get_running_app().theme_cls
setting = Setting()
if theme.theme_style == "Dark":
theme.theme_style = "Light"
setting.theme = "Light"
else:
theme.theme_style = "Dark"
setting.theme = "Dark"
setting.save_setting()
def btn_change_click(self):
dialog = Dialog()
dialog.title = "Error!"
setting = Setting()
if self.ids.txt_dbname.text == "":
dialog.text = "DataBase Name Or Path Can't Empty"
dialog.open()
return None
else:
acsii_letter = string.ascii_letters + string.digits
file_path, file_name = os.path.split(self.ids.txt_dbname.text)
if os.path.isdir(file_path):
setting.dbfile = self.ids.txt_dbname.text
name = ""
for i in self.ids.txt_dbname.text:
if i in acsii_letter:
name += i
self.ids.txt_dbname.text = name
setting.set_dbname(name)
if self.ids.db_backend.current_item == "MySQL":
username = self.ids.txt_uname.text
password = self.ids.txt_pass.text
if username and password:
setting.username = self.ids.txt_uname.text
setting.password = self.ids.txt_pass.text
else:
dialog.text = "Username or Password can,t be Empty"
dialog.open()
return None
setting.save_setting()
App.get_running_app().root.ids.scr.current = 'screendb'
class MainApp(MDApp):
dialog = None
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.screen = Builder.load_file(root_kv)
self.title = "Strings Manipulation"
Window.maximize()
Window.bind(on_keyboard=self.events)
self.manager_open = False
self.file_manager = MDFileManager(
exit_manager=self.exit_manager,
select_path=self.select_path,
preview=False,
)
menu_items = []
self.menu = MDDropdownMenu(
caller=self.screen.ids.dropdown_item,
items=menu_items,
width_mult=3,
)
self.menu.bind()
self.menu2 = MDDropdownMenu(
caller=self.screen.ids.dropdown_item2,
items=menu_items,
width_mult=3,
)
self.menu2.bind() # declencher les evenements
self.menu3 = MDDropdownMenu(
caller=self.screen.ids.dropdown_item3,
items=menu_items,
width_mult=3,
)
self.menu3.bind()
self.menu4 = MDDropdownMenu(
caller=self.screen.ids.dropdown_item4,
items=menu_items,
width_mult=3,
)
self.menu4.bind()
def build(self):
return self.screen
###### gestionnaire de fichier
def file_manager_open(self):
self.file_manager.show(os.path.dirname(
os.path.abspath(__file__))) # output manager to the screen
self.manager_open = True
def select_path(self, path):
'''It will be called when you click on the file name
or the catalog selection button.
:type path: str;
:param path: path to the selected directory or file;
'''
self.exit_manager()
file_name = path.split('/')[-1]
file_extend = file_name.split('.')
if ((file_extend[-1]).lower()) != 'csv':
self.show_confirmation_dialog("Veuillez charger un .csv")
else:
global df
df = pd.read_csv(path)
NumRows = df.shape[0]
self.screen.ids.box.clear_widgets()
self.screen.ids.montexte.text = ""
self.screen.ids.numPartition.text = ""
self.screen.ids.MyImageGenerateStr.source = ""
self.screen.ids.MyImageGenerateStr.reload()
self.screen.ids.montextesortie.text = ""
self.screen.ids.longueur.text = ""
print(df)
print("******* \n")
print("nombre d'exemples: ", len(df))
def exit_manager(self, *args):
'''Called when the user reaches the root of the directory tree.'''
self.manager_open = False
self.file_manager.close()
def events(self, instance, keyboard, keycode, text, modifiers):
'''Called when buttons are pressed on the mobile device.'''
if keyboard in (1001, 27):
if self.manager_open:
self.file_manager.back()
return True
#### gestion de la page d'accueil du botton SubSrting
def PrintDataItem(self):
if len(df) == 0:
self.show_confirmation_dialog("Veuillez charger votre fichier")
else:
try:
NumRows = df.shape[0]
menu_items = [{
"text":
f"Example {i}",
"viewclass":
"OneLineListItem",
"on_release":
lambda x=f"Example {i}": self.set_item(x),
} for i in range(NumRows)]
self.menu = MDDropdownMenu(
caller=self.screen.ids.dropdown_item,
items=menu_items,
width_mult=3,
)
self.menu.bind()
except Exception as e:
self.show_confirmation_dialog("Veuillez charger votre fichier")
def PrintDataItem2(self):
if len(df) == 0:
self.show_confirmation_dialog("Veuillez charger votre fichier")
else:
try:
NumRows = df.shape[0]
menu_items = [{
"text":
f"Example {i}",
"viewclass":
"OneLineListItem",
"on_release":
lambda x=f"Example {i}": self.set_item2(x),
} for i in range(NumRows)]
self.menu2 = MDDropdownMenu(
caller=self.screen.ids.dropdown_item2,
items=menu_items,
width_mult=3,
)
self.menu2.bind()
except Exception as e:
self.show_confirmation_dialog("Veuillez charger votre fichier")
""" def PrintDataItem3(self):
if len(df) == 0:
self.show_confirmation_dialog("Veuillez charger votre fichier")
else:
try:
NumRows = len(PartitionResult)
menu_items = [
{
"text": f"Sub set {i}",
"viewclass": "OneLineListItem",
"on_release": lambda x=f"Sub set{i}": self.set_item3(x),
} for i in range( NumRows)
]
self.menu3 = MDDropdownMenu(
caller=self.screen.ids.dropdown_item3,
items=menu_items,
width_mult=3,
)
self.menu3.bind()
except Exception as e:
self.show_confirmation_dialog("Veuillez charger votre fichier") """
""" def PrintDataItem4(self):
if len(PartitionResult) == 0:
self.show_confirmation_dialog("Veuillez creer les partitions avant de classifier")
else:
try:
NumRows = len(PartitionResult)
menu_items = [
{
"text": f"Classifier {i}",
"viewclass": "OneLineListItem",
"on_release": lambda x=f"Classifier {i}": self.set_item4(x),
} for i in range( NumRows)
]
self.menu4 = MDDropdownMenu(
caller=self.screen.ids.dropdown_item4,
items=menu_items,
width_mult=3,
)
self.menu4.bind()
except Exception as e:
self.show_confirmation_dialog("Veuillez creer les partitions avant de classifier") """
##### gestion de la liste deroulante pour le cas de Substring
def set_item(self, text_item):
self.screen.ids.dropdown_item.set_item(text_item)
self.menu.dismiss() # masquer le menu
def set_item2(self, text_item):
self.screen.ids.dropdown_item2.set_item(text_item)
self.menu2.dismiss()
def set_item3(self, text_item):
self.screen.ids.dropdown_item3.set_item(text_item)
self.menu3.dismiss()
def set_item4(self, text_item):
self.screen.ids.dropdown_item4.set_item(text_item)
self.menu4.dismiss()
def show_confirmation_dialog(self, text_to_print):
if not self.dialog:
self.dialog = MDDialog(
title=text_to_print,
md_bg_color=self.theme_cls.error_color,
type="custom",
) #text_color = selft
self.dialog.open()
def GenerateSubstring2(self, item):
#entree,s = BuildExample(item)
if len(df) == 0:
self.show_confirmation_dialog("Veuillez charger votre fichier")
else:
entree = {}
indice = item.split(" ")
exemple = dict(df.iloc[int(indice[-1])])
# construction de l'entree(dictionnaire sigma)
listheads = list(df.columns)
s = str(exemple[listheads[-1]])
i = 0
for elt in range(len(listheads) - 1):
elt1 = "v" + str(i)
entree[elt1] = str(exemple[listheads[i]])
result = version1.GenerateSubstring(entree, s)
result = list(result)
if result != []:
for elt in result:
self.screen.ids.box.add_widget(OneLineListItem(text=elt))
elt = "entree = " + str(entree)
self.screen.ids.montexte.text = elt
elt = "s = " + s
self.screen.ids.montextesortie.text = elt
elt = str(len(result)) + " manieres d'extraire s dans entree"
self.screen.ids.longueur.text = elt
else:
self.screen.ids.box.clear_widgets()
elt = "entree = " + str(entree)
self.screen.ids.montexte.text = elt
elt = "s = " + s
self.screen.ids.montextesortie.text = elt
elt = " 0 " + " maniere d'extraire s dans entree"
self.screen.ids.longueur.text = elt
def PrintDag2(self, item):
if len(df) == 0:
self.show_confirmation_dialog("Veuillez charger votre fichier")
else:
entree = {}
indice = item.split(" ")
exemple = dict(df.iloc[int(indice[-1])])
# construction de l'entree(dictionnaire sigma)
listheads = list(df.columns)
s = str(exemple[listheads[-1]])
i = 0
for elt in range(len(listheads) - 1):
elt1 = "v" + str(i)
entree[elt1] = str(exemple[listheads[i]])
w, EtaTilda = version1.GenerateStr(entree, s)
try:
os.remove("GenerateStr.gv.png")
os.remove("GenerateStr.gv")
version1.PrintDag(EtaTilda, w, entree, s)
self.screen.ids.MyImageGenerateStr.source = "GenerateStr.gv.png"
self.screen.ids.MyImageGenerateStr.reload()
except OSError:
version1.PrintDag(EtaTilda, w, entree, s)
self.screen.ids.MyImageGenerateStr.source = "GenerateStr.gv.png"
self.screen.ids.MyImageGenerateStr.reload()
def PrintPartition(self, item):
if len(PartitionResult) == 0:
self.show_confirmation_dialog(
"Veuillez au prealable effectuer le partitionnement")
else:
indice = item.split(" ")
if type(PartitionResult[int(indice[-1])][0]) == list:
self.screen.ids.partition.text = str(
set(
list(
version1.flatten(PartitionResult[int(
indice[-1])][0]))))
else:
self.screen.ids.partition.text = str(PartitionResult[int(
indice[-1])][0])
def PrintClassifier(self, item):
if len(PartitionResult) == 0:
self.show_confirmation_dialog(
"Veuillez au prealable effectuer le partitionnement")
else:
indice = item.split(" ")
if type(PartitionResult[int(indice[-1])][0]) == list:
self.screen.ids.classifier.text = str(BoolClassifierResult[str(
set(
list(
version1.flatten(PartitionResult[int(
indice[-1])][0]))))])
else:
self.screen.ids.classifier.text = str(BoolClassifierResult[str(
set([PartitionResult[int(indice[-1])][0]]))])
def GeneratePartition2(self):
if len(df) == 0:
self.show_confirmation_dialog("Veuillez charger votre fichier")
else:
global Examples
# pour structurer les exemples
T = [] # pour le resultat de GenerateStr
entree = {}
listheads = list(df.columns)
for i in range(len(df)):
s = str(df.iloc[i][listheads[-1]])
entree = {}
for elt in range(len(listheads) - 1):
elt1 = "v" + str(elt)
entree[elt1] = str(df.iloc[i][listheads[elt]])
Examples.append((entree, s))
for elt in Examples:
dag = version1.GenerateStr(elt[0], elt[1])
T.append((json.dumps(elt[0]), dag))
global PartitionResult
PartitionResult = []
PartitionResult = version1.GeneratePartition(T)
if (len(PartitionResult)) == 0:
print("tous les exemples forment une unique partition")
else:
NumRows = len(PartitionResult)
menu_items = [{
"text":
f"Sub set {i}",
"viewclass":
"OneLineListItem",
"on_release":
lambda x=f"Sub set {i}": self.set_item3(x),
} for i in range(NumRows)]
self.menu3 = MDDropdownMenu(
caller=self.screen.ids.dropdown_item3,
items=menu_items,
width_mult=3,
)
self.menu3.bind()
elt = str(len(PartitionResult)) + " Partitions"
self.screen.ids.numPartition.text = elt
def PrintStringProgramme(self):
if len(BoolClassifierResult) == 0:
self.show_confirmation_dialog(
"Veuillez faire BoolClassifier D'abord")
else:
StringProgram = ""
StringProgram = StringProgram + "Switch("
for elt in BoolClassifierResult:
for elt2 in PartitionResult:
newSetForme2 = set()
if type(elt2[0]) == list:
newSetForme2 = newSetForme2.union(
set(list(version1.flatten(elt2[0]))))
else:
newSetForme2 = newSetForme2.union(set([elt2[0]]))
if str(newSetForme2) == elt:
break
if BoolClassifierResult[elt] != 'FAIL':
StringProgram = StringProgram + "(" + version1.MathStringexpression(
BoolClassifierResult[elt]
) + "," + version1.ListOfCancatenateExpression(
elt2[1]) + "),"
else:
StringProgram = StringProgram + "(" + version1.MathStringexpressionCaseFail(
list(newSetForme2)
[0]) + "," + version1.ListOfCancatenateExpression(
elt2[1]) + "),"
StringProgram = StringProgram[0:len(StringProgram) - 1] + ")"
self.screen.ids.PrincipalProgram.text = StringProgram
def BoolClassifier(self):
if len(PartitionResult) == 0:
self.show_confirmation_dialog(
"Veuillez au prealable effectuer le partitionnement")
else:
global Examples
global BoolClassifierResult
SigmaSet = set()
entree = {}
listheads = list(df.columns)
for i in range(len(df)):
s = str(df.iloc[i][listheads[-1]])
entree = {}
for elt in range(len(listheads) - 1):
elt1 = "v" + str(elt)
entree[elt1] = str(df.iloc[i][listheads[elt]])
Examples.append((entree, s))
for elt in Examples:
SigmaSet = SigmaSet.union(set([json.dumps(elt[0])]))
for elt in PartitionResult:
newSetForme = set()
if type(elt[0]) == list:
newSetForme = newSetForme.union(
set(list(version1.flatten(elt[0]))))
else:
newSetForme = newSetForme.union(set([elt[0]]))
SigmaMoins = SigmaSet - newSetForme
valeureDeRetour = version1.GenerateBoolClassifier(
newSetForme, SigmaMoins)
if valeureDeRetour == 'FAIL':
BoolClassifierResult[str(newSetForme)] = 'FAIL'
else:
BoolClassifierResult[str(newSetForme)] = list(
version1.flatten(valeureDeRetour))
entrees = [
] # ensembles des entrees dans l'ensemble du fichier
elt = str(len(PartitionResult)) + " Clasifiers"
self.screen.ids.numClassifier.text = elt
NumRows = len(PartitionResult)
menu_items = [{
"text":
f"Classifier {i}",
"viewclass":
"OneLineListItem",
"on_release":
lambda x=f"Classifier {i}": self.set_item4(x),
} for i in range(NumRows)]
self.menu4 = MDDropdownMenu(
caller=self.screen.ids.dropdown_item4,
items=menu_items,
width_mult=3,
)
self.menu4.bind()
class OneUIBrowserRulesListItem(OneLineAvatarIconListItem):
rule = ObjectProperty()
edit = ObjectProperty(force_dispatch=True)
delete = ObjectProperty(force_dispatch=True)
copy = ObjectProperty(force_dispatch=True)
favorite = ObjectProperty(force_dispatch=True)
menu = None
def __init__(self, **kwargs):
super(OneUIBrowserRulesListItem, self).__init__(**kwargs)
self.menu = MDDropdownMenu(caller=self.ids.rule_item,
items=self.menu_items,
width_mult=3,
selected_color=[0, 0, 0, .3])
self.menu.bind(on_release=self.menu_callback)
@property
def style(self):
return {
"height": "40dp",
"top_pad": "12dp",
"bot_pad": "12dp",
"divider": None,
"font_style": 'Caption'
}
@property
def menu_items(self):
return [
{
"text": "Edit",
"icon": "pencil",
**self.style
},
{
"text": "Delete",
"icon": "trash-can",
**self.style
},
{
"text": "Copy",
"icon": "content-copy",
**self.style
},
{
"text": "Favorite",
"icon": "bookmark",
**self.style
},
]
def menu_callback(self, instance_menu, instance_menu_item):
if instance_menu_item.text.lower() == "edit":
self.edit = self.rule
elif instance_menu_item.text.lower() == "delete":
self.delete = self.rule
elif instance_menu_item.text.lower() == "copy":
Clipboard.copy(json.dumps(asdict(self.rule)))
toast('Copied !!!')
elif instance_menu_item.text.lower() == "favorite":
self.favorite = self.rule
instance_menu.dismiss()
def on_rule(self, _, val):
self.text = val.name
def release_edit(self):
self.edit = self.rule
class MainApp(MDApp):
# APP
storage_url = "https://farmzon-abdcb.appspot.com"
database_url = "https://farmzon-abdcb.firebaseio.com/.json"
data = {"uu": {"Joe Tilsed": "me"}}
auth_key = "sBlt6fzvguYnrGl2FlXRK3k4vRxSfZJBV2P7yIRv"
size_x = NumericProperty(0)
size_y = NumericProperty(0)
menu = ObjectProperty(None)
count = NumericProperty(0)
loggin_count = NumericProperty(0)
count_update = NumericProperty(0)
dialog = None
dialog_phone = None
dialog_last = None
setter = None
counter_image = NumericProperty(0)
spin_active = BooleanProperty(False)
menu_text = StringProperty("Your Location")
loading = StringProperty("")
# Business
product_name = StringProperty("")
phone_number = StringProperty("")
location = StringProperty("")
quantity = StringProperty("")
total_amount = NumericProperty(0)
order_number = StringProperty("0")
category_tp = StringProperty("")
# MATH
calculator = StringProperty("0")
calculator2 = StringProperty("0")
# XXX-------ADMIN LOGIN VAR-------XXX
admin_name = StringProperty("")
admin_phone = StringProperty("")
customer_phone = StringProperty("")
admin_password = StringProperty("")
admin_true = BooleanProperty(False)
admin_product_description = StringProperty("")
admin_product_image = StringProperty("images/picture.png")
admin_product_name = StringProperty("")
admin_product_price = StringProperty("")
admin_product_id = StringProperty("")
admin_product_url = StringProperty("")
# ADS
app_id = "ca-app-pub-9270156272717443~8633598837"
interstitial = "ca-app-pub-9270156272717443/2248347409"
# DATABASE
def stream_handler(self, message):
if True:
print("hello")
return notification.notify(title='New order', message='you have new order!')
def notifi(self, phone):
try:
import firebase_admin
firebase_admin._apps.clear()
from firebase_admin import credentials, initialize_app, db
id = datetime.datetime.now()
cred = credentials.Certificate("credential/farmzon-abdcb-c4c57249e43b.json")
initialize_app(cred, {'databaseURL': 'https://farmzon-abdcb.firebaseio.com/'})
if phone != "0788204327":
my_stream = db.reference("Yummy").child("Admin").child(phone).child("Orders").listen(
self.stream_handler)
else:
my_stream = db.reference("Yummy").child("Orders").listen(
self.stream_handler)
except:
print("poor me")
def remember_me_admin(self, user, password, name):
with open("credential/admin.txt", "w") as fl:
fl.write(user + "\n")
fl.write(password)
with open("credential/admin_info.txt", "w") as ui:
ui.write(name)
fl.close()
ui.close()
def admin_memory(self):
if self.loggin_count == 0:
self.loggin_count = 1 + self.loggin_count
self.admin_true = True
file1 = open('credential/admin.txt', 'r')
file2 = open("credential/admin_info.txt")
Lines = file1.readlines()
Lines2 = file2.readlines()
# Strips the newline character
self.admin_phone = Lines[0].strip()
self.admin_password = Lines[1].strip()
self.admin_name = Lines2[0]
self.count += 1
thread = threading.Thread(self.notifi(self.admin_phone))
thread = threading.Thread(self.listen_db(self.admin_phone))
thread.start()
else:
sm = self.root
sm.current = "admin_main"
self.spin_active = False
def actively_reg(self):
if self.spin_active:
self.spin_active = False
toast("Successfully Registered!")
def permision_req(self):
if utils.platform == 'android':
from android.permissions import request_permissions, Permission # todo
request_permissions([Permission.WRITE_EXTERNAL_STORAGE, Permission.READ_EXTERNAL_STORAGE])
def notifier(self):
notification.notify(title="Welcome", message="you can also sell and buy!")
def on_start(self):
m = self.root
m.current = "one"
identity = self.root.ids.drop_item_one
self.menu_fun(identity)
self.keyboard_hooker()
def menu_fun(self, identity):
vimbweta = [
"vimbweta vya uwanjani",
"vimbweta vya stationary",
"vimbweta vya girls hostel",
"vimbweta vya boys hostel",
"vimbweta nyuma ya ndege",
"vimbweta vya block 16",
"vimbweta vya adminstration",
"class one",
"class two",
"class three",
"Aviation classes"
]
self.menu = MDDropdownMenu(
caller=identity,
width_mult=9,
position="auto",
callback=self.menu_callback
)
for i in range(vimbweta.__len__()):
self.menu.items.append(
{
"text": vimbweta[i]
}
)
for i in range(22):
if i == 0:
pass
else:
self.menu.items.append(
{
"text": "Block " + "" + str(i)
}
)
self.menu.bind(
on_release=self.menu_callback
)
self.setter = identity
self.setter.set_item(self.menu_text)
def show_alert_dialog(self):
if not self.dialog:
self.dialog = MDDialog(
title="Do you real want to quit?",
buttons=[
MDFlatButton(
text="CANCEL", text_color=self.theme_cls.primary_color, on_release=self.kill
),
MDRaisedButton(
text="QUIT!", text_color=self.theme_cls.primary_color,
on_release=lambda x: toast("Please press the home button!", 5)
),
],
)
self.dialog.open()
def phone_number_dialog(self):
if not self.dialog_phone:
self.dialog_phone = phone_dialog(
title="Enter Your phone number",
auto_dismiss=False,
buttons=[
MDFlatButton(
text="Cancel", text_color=self.theme_cls.primary_color, on_release=self.kill_phone
),
MDRaisedButton(
text="Submit", text_color=self.theme_cls.primary_color,
on_release=lambda x: self.phone_number_check(self.phone_number)
),
],
)
self.dialog_phone.open()
def last_step_dialog(self):
if not self.dialog_last:
self.dialog_last = MDDialog(
title="Confirm",
type="custom",
auto_dismiss=False,
content_cls=last_dialog(),
buttons=[
MDFlatButton(
text="Cancel",
text_color=self.theme_cls.primary_color,
on_release=lambda x: self.adver()
),
MDRaisedButton(
text="Ok",
on_release=lambda x: self.adver(),
theme_text_color="Custom",
md_bg_color=[243 / 255, 189 / 255, 106 / 255, 1]
),
],
)
self.dialog_last.md_bg_color = 245 / 255, 0 / 255, 72 / 255, 1
self.dialog_last.open()
def phone_number_check(self, phone):
new_number = ""
if phone != "":
for i in range(phone.__len__()):
if i == 0:
pass
else:
new_number = new_number + phone[i]
number = "+255" + new_number
if not carrier._is_mobile(number_type(phonenumbers.parse(number))):
toast("Please check your phone number!", 1)
return False
else:
self.phone_number = phone
thread = threading.Thread(target=self.Business(self.product_name, self.quantity, self.phone_number))
thread.start()
self.kill_phone()
return True
else:
toast("check your number")
def phone_number_check_admin(self, phone):
new_number = ""
if phone != "":
for i in range(phone.__len__()):
if i == 0:
pass
else:
new_number = new_number + phone[i]
number = "+255" + new_number
if not carrier._is_mobile(number_type(phonenumbers.parse(number))):
toast("Please check your phone number!", 1)
return False
else:
return True
else:
toast("enter phone number!")
def kill(self, *kwargs):
self.dialog.dismiss()
def kill_phone(self, *kwargs):
self.ads.request_interstitial()
self.dialog_phone.dismiss()
self.ads.show_interstitial()
def kill_adver(self):
self.dialog_last.dismiss()
def Business(self, product, quantity, phone):
self.last_step_dialog()
print("location:", self.location, '\n'
"Product name:", product, '\n'
"quantity:", quantity, '\n'
"Total amount:",
self.total_amount, '\n'
"Phone number:", phone)
if self.category_tp != "admin":
from helped import connection_status as CS
if CS.Network.internet(CS.Network()):
self.spin_active = True
thread = threading.Thread(target=DB.upload_data,
args=(
DB(), self.customer_phone, phone, self.location, quantity,
self.total_amount,
product))
thread.start()
thread.join()
toast("Ordered successfully!", 10)
self.spin_active = False
else:
self.spin_active = False
toast("Sorry try again!", 5)
else:
from helped import connection_status as CS
if CS.Network.internet(CS.Network()):
self.spin_active = True
thread = threading.Thread(target=DB.upload_data_admin,
args=(
DB(), self.customer_phone, phone, self.location, quantity,
self.total_amount,
product))
thread.start()
thread.join()
toast("Ordered successfully!", 10)
self.spin_active = False
else:
self.spin_active = False
toast("Sorry try again!", 5)
def keyboard_hooker(self):
EventLoop.window.bind(on_keyboard=self.hook_keyboard)
def hook_keyboard(self, window, key, *largs):
sm = self.root
print(key, self.count)
if key == 27 and self.count == 1 or self.count <= -1:
sm.current = "one"
print("change", self.count)
self.count = self.count - 1
print("current>>", self.count)
return True
elif key == 27 and self.count == 0:
# Window.on_close()
self.show_alert_dialog()
return True
def menu_callback(self, menu):
self.menu_text = menu.text
self.setter.set_item(menu.text)
self.menu.dismiss()
print(menu.text)
self.location = menu.text
def callculator_rim(self, mingapi, price):
identity = self.root.ids.quantity
self.calculator = mingapi + "0"
if mingapi == "":
pass
elif mingapi == '.':
identity.text = "1"
else:
self.total_amount = self.calculator = str(float(mingapi) * int(price))
def callback(self, button):
self.menu.caller = button
self.menu.open()
food_count = 0
def order_spinner2(self):
if self.front_shop_count == 0:
self.spin_active = True
try:
toast("loading please wait...", 10)
self.loading = "Loading..."
# Clock.schedule_once(lambda x: self.front_shop(), 4)
thread = threading.Thread(target=self.front_shop())
thread.start()
except:
toast("no internet!")
self.loading = ""
self.spin_active = False
def order_spinner3(self):
if self.other_shops == 0:
self.spin_active = True
try:
toast("loading please wait...", 10)
Clock.schedule_once(lambda x: self.other_shop(), 4)
# thread = threading.Thread(target=self.other_shop)
# thread.start()
except:
toast("no internet!")
self.spin_active = False
def order_spinner1(self):
sm = self.root
file_size = os.path.getsize("credential/admin.txt")
if file_size == 0:
sm.current = "login"
else:
self.spin_active = True
sm.current = "admin_main"
thread = threading.Thread(target=self.admin_memory)
thread.start()
thread.join()
self.spin_active = False
def add_order(self):
try:
if self.food_count == 0:
self.food_count = self.food_count + 1
food = self.root.ids.food_cat
import firebase_admin
firebase_admin._apps.clear()
from firebase_admin import credentials, initialize_app, db
if not firebase_admin._apps:
cred = credentials.Certificate("credential/farmzon-abdcb-c4c57249e43b.json")
initialize_app(cred, {'databaseURL': 'https://farmzon-abdcb.firebaseio.com/'})
store = db.reference("Yummy").child("Orders")
stores = store.get()
count = 0
for y, x in stores.items():
food_categories = category()
del_btn = MDIconButton(icon="delete", on_release=self.remove_widgets,
pos_hint={"center_x": .9, "center_y": .3}, theme_text_color="Custom",
text_color={60 / 255, 66 / 255, 75 / 255}, user_font_size="26sp")
count += 1
# food_categories.md_bg_color = 245 / 255, 0 / 255, 72 / 255, 1
food_categories.id = y
del_btn.id = y
food_categories.md_bg_color = 121 / 255, 174 / 255, 141 / 255, 1
food_categories.add_widget(Labels(text="Admin-phone:" + " " + str(x['Admin phone'])))
food_categories.add_widget(Labels(text="Phone:" + " " + y))
food_categories.add_widget(MDSeparator(height="5dp"))
food_categories.add_widget(Labels(text="Amount:" + " " + " " + str(x['amount'])))
food_categories.add_widget(Labels(text="Location:" + " " + " " + str(x['location'])))
food_categories.add_widget(Labels(text="Product-Name:" + " " + " " + str(x['product name'])))
food_categories.add_widget(Labels(text="Quantity:" + " " + " " + str(x['quantity'])))
food_categories.add_widget(Labels(text="Time-Ordered:" + " " + " " + str(x['time'])))
food_categories.add_widget(del_btn)
food.add_widget(food_categories)
self.spin_active = False
self.order_number = str(count)
else:
pass
except:
toast("no internet")
self.spin_active = False
def resize_bottom_tabs(self):
# bottom_nav
bv = self.root.ids.bottom_nav
bv.on_resize()
def add_order_admin(self):
try:
if self.food_count == 0:
print("num>", self.admin_phone)
self.food_count = self.food_count + 1
food = self.root.ids.food_cat
import firebase_admin
firebase_admin._apps.clear()
from firebase_admin import credentials, initialize_app, db
if not firebase_admin._apps:
cred = credentials.Certificate("credential/farmzon-abdcb-c4c57249e43b.json")
initialize_app(cred, {'databaseURL': 'https://farmzon-abdcb.firebaseio.com/'})
if self.admin_phone != "0788204327":
store = db.reference("Yummy").child("Admin").child(self.admin_phone).child("Orders")
stores = store.get()
print(stores)
count = 0
for y, x in stores.items():
print(x)
food_categories = category()
del_btn = MDIconButton(icon="delete", on_release=self.remove_widgets,
pos_hint={"center_x": .9, "center_y": .3}, theme_text_color="Custom",
text_color={60 / 255, 66 / 255, 75 / 255}, user_font_size="26sp")
count += 1
# food_categories.md_bg_color = 245 / 255, 0 / 255, 72 / 255, 1
food_categories.id = y
del_btn.id = y
food_categories.md_bg_color = 121 / 255, 174 / 255, 141 / 255, 1
food_categories.add_widget(Labels(text="Admin-phone:" + " " + str(x['Phone number'])))
food_categories.add_widget(Labels(text="Phone:" + " " + y))
food_categories.add_widget(MDSeparator(height="5dp"))
food_categories.add_widget(Labels(text="Amount:" + " " + " " + str(x['amount'])))
food_categories.add_widget(Labels(text="Location:" + " " + " " + str(x['location'])))
food_categories.add_widget(
Labels(text="Product-Name:" + " " + " " + str(x['product name'])))
food_categories.add_widget(Labels(text="Quantity:" + " " + " " + str(x['quantity'])))
food_categories.add_widget(Labels(text="Time-Ordered:" + " " + " " + str(x['time'])))
food_categories.add_widget(del_btn)
food.add_widget(food_categories)
self.spin_active = False
self.order_number = str(count)
else:
self.add_order()
else:
pass
except:
toast("no internet")
self.spin_active = False
all_products = {}
front_products = {}
front_shop_count = 0
other_shops = 0
def other_shop(self):
if True:
try:
if self.other_shops == 0:
self.other_shops = self.other_shops + 1
import firebase_admin
firebase_admin._apps.clear()
from firebase_admin import credentials, initialize_app, db
if not firebase_admin._apps:
shop = self.root.ids.other_shop
cred = credentials.Certificate("credential/farmzon-abdcb-c4c57249e43b.json")
initialize_app(cred, {'databaseURL': 'https://farmzon-abdcb.firebaseio.com/'})
store = db.reference("Yummy").child("Products")
stores = store.get()
from retrive_data import Retrieve as RE
RE.other_shop(RE(), stores)
self.all_products = stores
for y, x in stores.items():
self.admin_product_name = x["product_name"]
self.customer_phone = x["admin_phone"]
self.admin_product_url = x["image_url"]
self.admin_product_price = x["product_price"]
self.admin_product_description = x["product_description"]
other_shops = Shops(on_release=self.selling_other)
other_shops.add_widget(Labels(text=self.admin_product_name))
other_shops.add_widget(Shop_image(source=self.admin_product_url))
other_shops.add_widget(Labels(text=self.admin_product_price))
other_shops.id = y
shop.add_widget(other_shops)
self.spin_active = False
except:
self.spin_active = False
toast("no internet!")
def other_shop_offline(self):
filename = "helped/other.json"
try:
file_size = os.path.getsize(filename)
if file_size > 0:
shop = self.root.ids.front_shop
with open(filename) as file:
line = json.load(file)
print(line)
for y, x in line.items():
self.admin_product_name = x["product_name"]
self.customer_phone = x["admin_phone"]
self.admin_product_url = x["image_url"]
self.admin_product_price = x["product_price"]
self.admin_product_description = x["product_description"]
other_shops = Shops(on_release=self.selling_other)
other_shops.add_widget(Labels(text=self.admin_product_name))
other_shops.add_widget(Shop_image(source=self.admin_product_url))
other_shops.add_widget(Labels(text=self.admin_product_price))
other_shops.id = y
shop.add_widget(other_shops)
self.spin_active = False
except:
self.spin_active = False
self.order_spinner3()
def other_shop_comparison(self):
filename = "helped/other.json"
try:
file_size = os.path.getsize(filename)
if file_size != 0:
with open(filename) as file:
line = json.load(file)
local_len = len(line)
import firebase_admin
firebase_admin._apps.clear()
from firebase_admin import credentials, initialize_app, db
if not firebase_admin._apps:
cred = credentials.Certificate("credential/farmzon-abdcb-c4c57249e43b.json")
initialize_app(cred, {'databaseURL': 'https://farmzon-abdcb.firebaseio.com/'})
store = db.reference("Yummy").child("Products")
stores = store.get()
online_len = len(stores)
print(local_len, online_len)
if local_len == online_len:
print(local_len, online_len)
else:
self.refresh_other()
else:
self.refresh_other()
except:
toast("something is wrong!")
def other_shop_faster(self):
filename = "helped/other.json"
try:
if self.other_shops == 0:
self.other_shops = self.other_shops + 1
file_size = os.path.getsize(filename)
thread = threading.Thread(target=self.other_shop_comparison)
thread.start()
if file_size != 0:
shop = self.root.ids.other_shop
with open(filename) as file:
line = json.load(file)
print(line)
self.all_products = line
for y, x in line.items():
self.admin_product_name = x["product_name"]
self.customer_phone = x["admin_phone"]
self.admin_product_url = x["image_url"]
self.admin_product_price = x["product_price"]
self.admin_product_description = x["product_description"]
other_shops = Shops(on_release=self.selling_other)
other_shops.add_widget(Labels(text=self.admin_product_name))
other_shops.add_widget(Shop_image(source=self.admin_product_url))
other_shops.add_widget(Labels(text=self.admin_product_price + "/Tsh"))
other_shops.id = y
shop.add_widget(other_shops)
self.spin_active = False
else:
self.other_shops = 0
self.order_spinner3()
except:
self.other_shops = 0
self.order_spinner3()
def selling_other(self, instance):
print(instance.id)
# self.count = self.count + 1
product = instance.id
self.customer_phone = self.all_products[product]["admin_phone"]
self.admin_product_url = self.all_products[product]["image_url"]
self.admin_product_name = self.all_products[product]["product_name"]
self.admin_product_price = self.all_products[product]["product_price"]
self.admin_product_description = self.all_products[product]["product_description"]
sm = self.root
sm.current = "selling_other"
def summon(self):
sm = self.root
sm.current = "other_shops"
if self.other_shops == 0:
self.spin_active = True
def front_shop(self):
if True:
try:
print("ok")
if self.front_shop_count == 0:
self.front_shop_count = self.front_shop_count + 1
print("yess..")
import firebase_admin
firebase_admin._apps.clear()
from firebase_admin import credentials, initialize_app, db
if not firebase_admin._apps:
shop = self.root.ids.front_shop
cred = credentials.Certificate("credential/farmzon-abdcb-c4c57249e43b.json")
initialize_app(cred, {'databaseURL': 'https://farmzon-abdcb.firebaseio.com/'})
store = db.reference("Yummy").child("Products_admin")
print("nice")
stores = store.get()
from retrive_data import Retrieve as RE
thread = threading.Thread(target=RE.front_shop, args=(RE(), stores))
thread.start()
print("good")
self.front_products = stores
for y, x in stores.items():
self.admin_product_name = x["product_name"]
self.customer_phone = x["admin_phone"]
self.admin_product_url = x["image_url"]
self.admin_product_price = x["product_price"]
front_shops = Front_shop(on_release=self.selling_front)
layout = FloatLayout()
layout.add_widget(Labels(text=self.admin_product_name,
pos_hint={"center_x": .5, "center_y": .2},
halign="center"))
layout.add_widget(Cool(source=self.admin_product_url))
front_shops.add_widget(layout)
front_shops.id = y
shop.add_widget(front_shops)
time.sleep(2)
self.spin_active = False
self.loading = ""
else:
print("f**k!")
except:
toast("no internet!")
self.front_shop_offline()
def front_shop_offline(self):
filename = "helped/admin.json"
try:
file_size = os.path.getsize(filename)
if file_size > 0:
shop = self.root.ids.front_shop
with open(filename) as file:
line = json.load(file)
print(line)
for y, x in line.items():
self.admin_product_name = x["product_name"]
self.customer_phone = x["admin_phone"]
self.admin_product_url = x["image_url"]
self.admin_product_price = x["product_price"]
front_shops = Front_shop(on_release=self.selling_front)
layout = FloatLayout()
layout.add_widget(Labels(text=self.admin_product_name,
pos_hint={"center_x": .5, "center_y": .2},
halign="center"))
layout.add_widget(Cool(source=self.admin_product_url))
front_shops.add_widget(layout)
front_shops.id = y
shop.add_widget(front_shops)
time.sleep(2)
self.spin_active = False
self.loading = ""
except:
button = MDTextButton(text="Retry", pos_hint={"center_x": .5, "center_y": .5},
on_release=lambda x: self.refresh_front())
button.id = "you"
button.custom_color = 40 / 255, 123 / 255, 222 / 255, 1
shop = self.root.ids.front_shop
shop.add_widget(button)
self.loading = ""
self.spin_active = False
def front_shop_comparison(self):
filename = "helped/admin.json"
try:
file_size = os.path.getsize(filename)
if file_size != 0:
with open(filename) as file:
line = json.load(file)
local_len = len(line)
import firebase_admin
firebase_admin._apps.clear()
from firebase_admin import credentials, initialize_app, db
if not firebase_admin._apps:
cred = credentials.Certificate("credential/farmzon-abdcb-c4c57249e43b.json")
initialize_app(cred, {'databaseURL': 'https://farmzon-abdcb.firebaseio.com/'})
store = db.reference("Yummy").child("Products_admin")
stores = store.get()
online_len = len(stores)
if local_len == online_len:
pass
else:
self.refresh_front()
else:
self.refresh_front()
except:
toast("something is wrong!")
def front_shop_faster(self):
filename = "helped/admin.json"
try:
if self.front_shop_count == 0:
self.notifier()
self.front_shop_count = self.front_shop_count + 1
file_size = os.path.getsize(filename)
thread = threading.Thread(target=self.front_shop_comparison)
thread.start()
if file_size != 0:
shop = self.root.ids.front_shop
with open(filename) as file:
line = json.load(file)
print(line)
self.front_products = line
for y, x in line.items():
self.admin_product_name = x["product_name"]
self.customer_phone = x["admin_phone"]
self.admin_product_url = x["image_url"]
self.admin_product_price = x["product_price"]
front_shops = Front_shop(on_release=self.selling_front)
layout = FloatLayout()
layout.add_widget(Labels(text=self.admin_product_name,
pos_hint={"center_x": .5, "center_y": .2},
halign="center"))
layout.add_widget(Cool(source=self.admin_product_url))
front_shops.add_widget(layout)
front_shops.id = y
shop.add_widget(front_shops)
self.spin_active = False
self.loading = ""
else:
self.front_shop_count = 0
self.order_spinner2()
except:
self.front_shop_count = 0
self.order_spinner2()
def selling_front(self, instance):
print(instance.id)
self.count = self.count + 1
self.category_tp = "admin"
product = instance.id
self.customer_phone = self.front_products[product]["admin_phone"]
self.admin_product_url = self.front_products[product]["image_url"]
self.admin_product_name = self.front_products[product]["product_name"]
self.admin_product_price = self.front_products[product]["product_price"]
sm = self.root
sm.current = "selling"
def success(self, *kwargs):
self.refresh()
def refresh(self):
parent = self.root.ids.food_cat
all_childs = parent.children
identity = []
self.food_count = 0
for child in all_childs:
identity.append(child.id)
self.order_number = str(identity.__len__())
for i in identity:
self.remove_wide(i)
if self.admin_phone == "0788204327":
self.add_order()
else:
self.add_order_admin()
def refresh_front(self):
parent = self.root.ids.front_shop
all_childs = parent.children
identity = []
self.front_shop_count = 0
for child in all_childs:
identity.append(child.id)
for i in identity:
print(i)
self.remove_wide_front(i)
self.spin_active = True
self.order_spinner2()
def refresh_other(self):
parent = self.root.ids.other_shop
all_childs = parent.children
identity = []
self.other_shops = 0
for child in all_childs:
identity.append(child.id)
for i in identity:
print(i)
self.remove_wide_other(i)
self.spin_active = True
self.order_spinner3()
def remove_wide_front(self, name):
parent = self.root.ids.front_shop
for child in parent.children:
if name == child.id:
parent.remove_widget(child)
def remove_wide_other(self, name):
parent = self.root.ids.other_shop
for child in parent.children:
if name == child.id:
parent.remove_widget(child)
def remove_wide(self, name):
parent = self.root.ids.food_cat
for child in parent.children:
if name == child.id:
parent.remove_widget(child)
def remove_widgets(self, instance):
name = instance.id
parent = self.root.ids.food_cat
for child in parent.children:
if name == child.id:
parent.remove_widget(child)
self.del_entity(child.id)
def del_entity(self, name):
import firebase_admin
firebase_admin._apps.clear()
from firebase_admin import credentials, initialize_app, db
if not firebase_admin._apps:
cred = credentials.Certificate("credential/farmzon-abdcb-c4c57249e43b.json")
initialize_app(cred, {'databaseURL': 'https://farmzon-abdcb.firebaseio.com/'})
if self.admin_phone == "0788204327":
db.reference("Yummy").child("Orders").child(name).delete()
else:
db.reference("Yummy").child("Admin").child(self.admin_phone).child("Orders").child(name).delete()
def validate_user(self, phone, password):
if phone == "" and phone.Isdigit():
toast("please enter your phone number correctly")
elif password == "":
toast("please enter your password")
else:
self.spin_active = True
thread = threading.Thread(target=self.Signing_in_admin_function, args=(phone, password))
thread.start()
def Signing_in_admin(self, phone, password):
# thread = threading.Thread(target=self.Signing_in_admin_function, args=(phone, password))
# thread.start()
self.Signing_in_admin_function(phone, password)
@mainthread
def Signing_in_admin_function(self, phone, password):
if DB.Signing_in_admin(DB(), phone, password):
self.admin_name = DB.name_admin
self.remember_me_admin(phone, password, self.admin_name)
if not self.admin_true:
self.listen_db(phone)
sm = self.root
sm.current = "admin_main"
else:
if self.admin_true:
toast("no internet connection")
self.spin_active = False
else:
self.spin_active = False
toast("oops! phone number or password in correct or internet connection")
# XXX---------CUSTOMER--------------XXX
def id_generator(self):
not_allowed = ".-:"
date1 = datetime.datetime.now()
date, time = id = str(date1).split(" ")
self.admin_product_id = date + time
product_id = ""
for i in range(len(self.admin_product_id)):
if self.admin_product_id[i] not in not_allowed:
product_id = self.admin_product_id[i] + product_id
id = self.admin_product_id = product_id
print(id)
return self.admin_product_id
def get_info(self, phone, phone_other, name, price, product_name, image_path, password, category, description):
if phone != "" and self.phone_number_check_admin(phone):
if name != "" and name.isalpha() and price != "" and password != "":
self.customer_phone = phone
self.admin_password = password
self.admin_name = name
self.admin_product_image = image_path
self.admin_product_price = price
self.admin_product_name = product_name
self.admin_product_id = self.id_generator()
cate = category
print(phone, name, price, product_name, image_path, password, self.admin_product_id)
try:
thread = threading.Thread(target=self.transporter, args=(
phone, phone_other, name, price, product_name, image_path, password, self.admin_product_id,
cate, description))
thread.start()
except:
toast("no internet")
else:
toast("check your info well")
self.spin_active = False
else:
toast("check your mobile number")
self.spin_active = False
def transporter(self, phone, phone_other, name, price, product_name, image_path, password, id, cate, description):
thread = threading.Thread(target=DB.upload_product_image, args=(
DB(), cate, image_path, phone, phone_other, name, price, product_name, password, id, description))
thread.start()
thread.join()
self.actively_reg()
def listen_db(self, phone):
try:
import firebase_admin
firebase_admin._apps.clear()
from firebase_admin import credentials, initialize_app, db
id = datetime.datetime.now()
cred = credentials.Certificate("credential/farmzon-abdcb-c4c57249e43b.json")
initialize_app(cred, {'databaseURL': 'https://farmzon-abdcb.firebaseio.com/'})
self.admin_phone = phone
if phone != "0788204327":
print("i am listening......")
my_stream = db.reference("Yummy").child("Admin").child(phone).child("Orders").listen(self.success)
else:
print("i am listening......")
my_stream = db.reference("Yummy").child("Orders").listen(self.success)
except:
print("poor you")
def Permission(self, android=None):
if self.counter_image <= 0:
if utils.platform == 'android':
if self.count_update == 0:
from gallary import Gambler as GA
Clock.schedule_once(GA.user_select_image, 0)
self.admin_product_image = GA.path_of_picture
img = self.root.ids.product_image
img.source = GA.path_of_picture
self.count_update += self.count_update + 1
else:
from gallary import Gambler as GA
self.count_update = self.count_update - 1
self.admin_product_image = GA.path_of_picture
img = self.root.ids.product_image
img.source = GA.path_of_picture
else:
self.counter_image = self.counter_image + 1
for root, dirs, files in os.walk("/home/alpha9060/Downloads", topdown=False):
for file_ in files:
full_file_path = os.path.join(root, file_)
if full_file_path.endswith(('.png', '.jpg', '.jpeg')):
print(full_file_path)
image = full_file_path
cat_class = category_gal()
cat_class.add_widget(category_ga(source=image))
img = self.root.ids.images_added
img.add_widget(cat_class)
else:
pass
ads = KivMob(TestIds.INTERSTITIAL)
def adver(self):
self.kill_adver()
self.ads.show_interstitial()
def build(self):
self.ads.new_interstitial(TestIds.INTERSTITIAL)
self.theme_cls.theme_style = "Light"
self.theme_cls.primary_palette = "DeepOrange"
self.theme_cls.accent = "Brown"
# Window.size = (360, 640)
self.size_x, self.size_y = Window.size
self.title = "yummy"
class Ytube(MDApp):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.theme_cls.colors = 'Red'
self.theme_cls.primary_palette = "Red"
self.root = Builder.load_string(kv)
menu_items = [
{"icon": "application-settings",
"text": "Setting"},
{"icon": "account",
'text': "About"},
]
open_position = self.root.get_screen('main').ids.right_button
self.menu = MDDropdownMenu(caller=open_position, items=menu_items, width_mult=3)
self.menu.bind(on_release = self.menu_callback)
Window.bind(on_keyboard=self.events)
self.manager_open = False
self.file_manager = MDFileManager(
exit_manager=self.exit_manager,
select_path=self.select_path,
)
# ------------------------------------ file manager -------------------------------------
def file_manager_open(self):
self.file_manager.show('/') # output manager to the screen
self.manager_open = True
def select_path(self, path):
'''It will be called when you click on the file name
or the catalog selection button.
:type path: str;
:param path: path to the selected directory or file;
'''
self.exit_manager()
return self.show_message(path)
def exit_manager(self, *args):
'''Called when the user reaches the root of the directory tree.'''
self.manager_open = False
self.file_manager.close()
def events(self, instance, keyboard, keycode, text, modifiers):
'''Called when buttons are pressed on the mobile device.'''
if keyboard in (1001, 27):
if self.manager_open:
self.file_manager.back()
return True
# ------------------------------- File manager end ----------------------------------------
def menu_callback(self, instance_menu, instance_menu_items):
print(instance_menu)
if instance_menu_items.text == 'Setting':
self.root.current = 'setting'
self.menu.dismiss()
else:
self.root.current = 'about'
self.menu.dismiss()
def start_downloading(self):
user_input = self.root.get_screen('main').ids.url_input.text
# video = YouTube(user_input)
# print(type(video))
if user_input != '' and re.search(r'^(https?\:\/\/)?(www\.)?(youtube\.com|youtu\.?be)\/.+$', user_input):
self.root.current = 'progress'
screen_id = self.root.get_screen('progress').ids.video_list
for num in range(1):
main_layout = MDFloatLayout()
flip_card = MDCard(size_hint=(.9, .9), pos_hint={'center_x':.5, 'center_y': .5})
box_1 = MDBoxLayout(orientation='vertical',)
box_2 = MDBoxLayout(orientation='vertical', )
box_3 = MDBoxLayout(orientation='vertical', padding=20)
img = AsyncImage(source=video.thumbnail_url, size_hint=(.9, .9), pos_hint={'center_x': .5, 'center_y': .5})
box_3.add_widget(img)
box_3.add_widget(
MDLabel(
text=video.title, halign='center', font_style='Body2'
)
)
box_2.add_widget(box_3)
box_2.add_widget(MDRaisedButton(text='Download', pos_hint={'center_x': .5, 'center_y': .5}, size_hint=(.6, .1), on_release = self.quality_check,))
box_1.add_widget(box_2)
advertisement_box = MDBoxLayout(orientation='vertical', size_hint=(1, .2))
advertisement_box.add_widget(MDLabel(text='Advertisement', halign='center'))
advertisement_box.add_widget(MDProgressBar(pos_hint={"center_x": .5, }))
box_1.add_widget(advertisement_box)
flip_card.add_widget(box_1)
main_layout.add_widget(flip_card)
screen_id.add_widget(main_layout)
else:
self.show_message('Invalid URL!')
def home(self):
output = self.root.current = 'main'
return output
def show_message(self, text):
snackbar = Snackbar(
text=f"{text}",
)
return snackbar.show()
def callback_for_bottom_sheet(self, *args):
self.show_message(args[0])
def quality_check(self, obj):
bottom_sheet = MDGridBottomSheet()
data = {
"Audio": "file",
"144p": "quality-low",
"240p": "quality-low",
"360p": "quality-medium",
"480p": "quality-medium",
"720p": "quality-high",
"1080p": "quality-high",
}
for items in data.items():
bottom_sheet.add_item(
items[0],
lambda x, y=items[0]: self.callback_for_bottom_sheet(y),
icon_src = items[1]
)
return bottom_sheet.open()
def on_start(self):
#self.theme_cls.theme_style = "Dark"
pass
def build(self):
return self.root
class Application(MDApp):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.INTERFACE = Builder.load_file('main.kv')
self.database = Database()
menu_items = [{"text":f"item {i}"} for i in range(50)]
self.menu = MDDropdownMenu(
caller=self.INTERFACE.ids.refCommande,
items=menu_items,
position="center",
width_mult=8,
)
self.menu.bind(on_release=self.set_item)
def build(self):
self.theme_cls.primary_palette = "Teal"
self.items = [f"test {i}" for i in range(5)]
return self.INTERFACE
def set_item(self, instance_menu, instance_menu_item):
def set_item(interval):
self.INTERFACE.ids.refCommande.text = instance_menu_item.text
instance_menu.dismiss()
Clock.schedule_once(set_item, 0.5)
# fonction Field du Date de livraison
def show_datePicker(self):
dialogDate = MDDatePicker(callback=self.get_date)
dialogDate.open()
def get_date(self, date):
self.INTERFACE.ids.dateLivraison.text = date.__str__()
def validateCommande(self, **kwargs):
""" Fonction Screen COMMANDE """
champs = [
self.INTERFACE.ids.refCommande,
self.INTERFACE.ids.quantite,
self.INTERFACE.ids.adresse,
self.INTERFACE.ids.contact,
self.INTERFACE.ids.dateLivraison
]
if not kwargs.get('validate_'):
# verification des champs vides
for val in champs:
if val.text.strip() == '':
return MDDialog(
title="Erreur de validation",
text=f"Le champ {val.hint_text} est obligatoire"
).open()
self.dialogCommande = MDDialog(
title="Confirmation",
text="Enregistrer la commande ?",
buttons=[
MDFlatButton(
text="Continuer",
text_color=self.theme_cls.primary_color,
on_release=lambda f: self.validateCommande(validate_=True)
)
]
)
self.dialogCommande.open()
else:
self.dialogCommande.dismiss()
for i in range(len(champs)): champs[i] = champs[i].text
champs.append(self.INTERFACE.ids.nomClient.text)
champs.append(date.today().__str__())
ret = self.database.insertCommande(*champs)
if ret[0]:
MDDialog(
title="Succes",
text="Commande effectué",
radius=[20, 7, 20, 7],
).open()
else:
MDDialog(
title="Erreur",
text=str(ret[1]),
radius=[20, 7, 20, 7],
).open()
class EuApp(MDApp):
terrainmenu = ObjectProperty()
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.eu = euhandler.euhandler()
self.screen = Builder.load_string(KV)
self.terrainmenu = MDDropdownMenu(
caller=self.screen.ids.lndscr.ids.terrainButton,
items=[{
"viewclass": "MDMenuItem",
"text": "Clear"
}, {
"viewclass": "MDMenuItem",
"text": "Mount."
}, {
"viewclass": "MDMenuItem",
"text": "Forest"
}, {
"viewclass": "MDMenuItem",
"text": "Marsh"
}],
width_mult=4,
opening_time=0)
self.terrainmenu.bind(on_release=self.terrainmenu_item_selected)
self.attackertechmenu = MDDropdownMenu(
caller=self.screen.ids.lndscr.ids.attackerTechButton,
position="bottom",
items=[{
"viewclass": "MDMenuItem",
"text": "MED"
}, {
"viewclass": "MDMenuItem",
"text": "REN"
}, {
"viewclass": "MDMenuItem",
"text": "ARQ"
}, {
"viewclass": "MDMenuItem",
"text": "MOU"
}, {
"viewclass": "MDMenuItem",
"text": "BAR"
}, {
"viewclass": "MDMenuItem",
"text": "MAN"
}, {
"viewclass": "MDMenuItem",
"text": "DEN"
}],
width_mult=3,
opening_time=0)
self.attackertechmenu.bind(
on_release=self.attackertechmenu_item_selected)
self.defendertechmenu = MDDropdownMenu(
caller=self.screen.ids.lndscr.ids.defenderTechButton,
items=[{
"viewclass": "MDMenuItem",
"text": "MED"
}, {
"viewclass": "MDMenuItem",
"text": "REN"
}, {
"viewclass": "MDMenuItem",
"text": "ARQ"
}, {
"viewclass": "MDMenuItem",
"text": "MOU"
}, {
"viewclass": "MDMenuItem",
"text": "BAR"
}, {
"viewclass": "MDMenuItem",
"text": "MAN"
}, {
"viewclass": "MDMenuItem",
"text": "DEN"
}],
width_mult=3,
opening_time=0)
self.defendertechmenu.bind(
on_release=self.defendertechmenu_item_selected)
self.attackernavaltechmenu = MDDropdownMenu(
caller=self.screen.ids.navscr.ids.attackerNavalTechButton,
items=[{
"viewclass": "MDMenuItem",
"text": "GA"
}, {
"viewclass": "MDMenuItem",
"text": "CAR"
}, {
"viewclass": "MDMenuItem",
"text": "GLN"
}, {
"viewclass": "MDMenuItem",
"text": "LS"
}, {
"viewclass": "MDMenuItem",
"text": "BA"
}, {
"viewclass": "MDMenuItem",
"text": "VE"
}, {
"viewclass": "MDMenuItem",
"text": "T-D"
}],
width_mult=3,
opening_time=0)
self.attackernavaltechmenu.bind(
on_release=self.attackernavaltechmenu_item_selected)
self.defendernavaltechmenu = MDDropdownMenu(
caller=self.screen.ids.navscr.ids.defenderNavalTechButton,
items=[{
"viewclass": "MDMenuItem",
"text": "GA"
}, {
"viewclass": "MDMenuItem",
"text": "CAR"
}, {
"viewclass": "MDMenuItem",
"text": "GLN"
}, {
"viewclass": "MDMenuItem",
"text": "LS"
}, {
"viewclass": "MDMenuItem",
"text": "BA"
}, {
"viewclass": "MDMenuItem",
"text": "VE"
}, {
"viewclass": "MDMenuItem",
"text": "T-D"
}],
width_mult=3,
opening_time=0)
self.defendernavaltechmenu.bind(
on_release=self.defendernavaltechmenu_item_selected)
def terrainmenu_item_selected(self, instance_menu, instance_menu_item):
self.screen.ids.lndscr.ids.terrainButton.set_item(
instance_menu_item.text)
terrconv = {
'Clear': 'clear',
'Mount.': 'mountain',
'Forest': 'forest',
'Marsh': 'marsh'
}
self.eu.terrain = terrconv[instance_menu_item.text]
self.update()
self.terrainmenu.dismiss()
def attackernavaltechmenu_item_selected(self, instance_menu,
instance_menu_item):
self.screen.ids.navscr.ids.attackerNavalTechButton.set_item(
instance_menu_item.text)
self.eu.attacker['ntech'] = instance_menu_item.text
self.update()
self.attackernavaltechmenu.dismiss()
def defendernavaltechmenu_item_selected(self, instance_menu,
instance_menu_item):
self.screen.ids.navscr.ids.defenderNavalTechButton.set_item(
instance_menu_item.text)
self.eu.defender['ntech'] = instance_menu_item.text
self.update()
self.defendernavaltechmenu.dismiss()
def attackertechmenu_item_selected(self, instance_menu,
instance_menu_item):
self.screen.ids.lndscr.ids.attackerTechButton.set_item(
instance_menu_item.text)
self.eu.attacker['ltech'] = instance_menu_item.text
self.update()
self.attackertechmenu.dismiss()
def defendertechmenu_item_selected(self, instance_menu,
instance_menu_item):
self.screen.ids.lndscr.ids.defenderTechButton.set_item(
instance_menu_item.text)
self.eu.defender['ltech'] = instance_menu_item.text
self.update()
self.defendertechmenu.dismiss()
def roll_slider_change(self, att_or_def, value):
rounded = math.ceil(value)
if att_or_def == 'att':
self.screen.ids.lndscr.ids.att_roll_label.text = str(rounded)
self.screen.ids.navscr.ids.att_roll_label.text = str(rounded)
self.eu.attacker['roll'] = rounded
elif att_or_def == 'def':
self.screen.ids.lndscr.ids.def_roll_label.text = str(rounded)
self.screen.ids.navscr.ids.def_roll_label.text = str(rounded)
self.eu.defender['roll'] = rounded
self.update()
def assaultselected(self, instance, value):
if value:
self.eu.assault = value
self.screen.ids.lndscr.ids.defenderPursuing.active = False
self.screen.ids.lndscr.ids.attackerPursuing.active = False
if dbug:
print('Assault is ', value)
else:
self.eu.assault = value
if dbug:
print('Assault is ', value)
self.update()
def defenderpursuingselected(self, instance, value):
if value:
self.eu.defender_pursuing = value
self.screen.ids.lndscr.ids.combatTypeSelector.active = True
self.screen.ids.lndscr.ids.attackerPursuing.active = False
self.screen.ids.navscr.ids.combatTypeSelector.active = True
self.screen.ids.navscr.ids.attackerPursuing.active = False
self.screen.ids.lndscr.ids.assaultSelector.active = False
if dbug:
print('Defender pursuing is ', value)
else:
self.eu.defender_pursuing = value
if dbug:
print('Defender pursuing is ', value)
self.update()
def breachselected(self, instance, value):
if value:
self.eu.breach = True
else:
self.eu.breach = False
self.update()
def attackerpursuingselected(self, instance, value):
if value:
self.eu.attacker_pursuing = value
self.screen.ids.lndscr.ids.combatTypeSelector.active = True
self.screen.ids.lndscr.ids.defenderPursuing.active = False
self.screen.ids.navscr.ids.combatTypeSelector.active = True
self.screen.ids.navscr.ids.defenderPursuing.active = False
self.screen.ids.lndscr.ids.assaultSelector.active = False
if dbug:
print('Attacker pursuing is ', value)
else:
self.eu.attacker_pursuing = value
if dbug:
print('Attacker pursuing is ', value)
self.update()
def combatselected(self, instance, value):
self.screen.ids.lndscr.ids.combatTypeSelector.active = value
self.screen.ids.navscr.ids.combatTypeSelector.active = value
if value:
self.eu.type_of_combat = 'shock'
if dbug:
print('shock phase')
else:
self.eu.type_of_combat = 'fire'
self.screen.ids.lndscr.ids.defenderPursuing.active = False
self.screen.ids.lndscr.ids.attackerPursuing.active = False
self.screen.ids.navscr.ids.defenderPursuing.active = False
self.screen.ids.navscr.ids.attackerPursuing.active = False
if dbug:
print('fire phase')
self.update()
def textfield_change(self, textfield, att_or_def, unit):
if textfield.text.isdigit():
if int(textfield.text) < 0:
textfield.text = '0'
if dbug:
print(att_or_def, ' ', textfield.text, ' ',
textfield.hint_text)
if att_or_def == 'att':
self.eu.attacker[unit] = int(textfield.text)
else:
self.eu.defender[unit] = int(textfield.text)
else:
#Field is not a positive digit set values to 0
if att_or_def == 'att':
self.eu.attacker[unit] = 0
else:
self.eu.defender[unit] = 0
self.update()
def increment(self, buttonInstance, screen, unit, att_or_def):
#Define the id of the text field that needs to be changed
textId = 'txt_field_' + unit + '_' + att_or_def
#Get the current value of the field
if not self.screen.ids[screen].ids[textId].text.isdigit():
value = 0
else:
value = int(self.screen.ids[screen].ids[textId].text)
#Read the text of the button to decide how to change
if buttonInstance.text == '+':
value += 1
elif buttonInstance.text == '-':
value += -1
elif buttonInstance.text == '+10':
value += 10
elif buttonInstance.text == '-10':
value += -10
if value < 0:
value = 0
self.screen.ids[screen].ids[textId].text = str(value)
def update(self):
self.eu.updateall()
base_string = '{0} pow table {1}: [{2}%, -{3}] : cause {4} loss'
att_string = base_string.format(self.eu.results['attstr'],
self.eu.results['tblatt'],
self.eu.results['attresult'],
self.eu.results['ainflictmorale'],
self.eu.results['ainflict'])
self.screen.ids.lndscr.ids['att_results'].text = att_string
def_string = base_string.format(self.eu.results['defstr'],
self.eu.results['tbldef'],
self.eu.results['defresult'],
self.eu.results['dinflictmorale'],
self.eu.results['dinflict'])
self.screen.ids.lndscr.ids['def_results'].text = def_string
if dbug:
self.eu.fancyprint()
att_navstring = base_string.format(self.eu.results['attstr_n'],
self.eu.results['tblatt_n'],
self.eu.results['attresult_n'],
self.eu.results['ainflictmorale_n'],
self.eu.results['ainflict_n'])
self.screen.ids.navscr.ids['att_results'].text = att_navstring
def_navstring = base_string.format(self.eu.results['defstr_n'],
self.eu.results['tbldef_n'],
self.eu.results['defresult_n'],
self.eu.results['dinflictmorale_n'],
self.eu.results['dinflict_n'])
self.screen.ids.navscr.ids['def_results'].text = def_navstring
self.screen.ids.navscr.ids.att_wind_gauge_modifier_text.text = self.eu.results[
'attwindgauge']
self.screen.ids.navscr.ids.def_wind_gauge_modifier_text.text = self.eu.results[
'defwindgauge']
def get_id(self, instance):
for id, widget in instance.parent.ids.items():
if widget.__self__ == instance:
return id
def build(self):
return self.screen
class NasaScreen(Screen):
def from_get_date(self, date, *args):
print(date)
print(type(date))
self.ids.fromd.text = str(date)
def from_show_date_picker(self, *args):
date_dialog = MDDatePicker(
callback=self.from_get_date,
year=2016,
month=random.randint(1, 12),
day=random.randint(1, 28),
)
date_dialog.open()
def to_get_date(self, date, *args):
print(date)
print(type(date))
self.ids.to.text = str(date)
def to_show_date_picker(self, *args):
date_dialog = MDDatePicker(
callback=self.to_get_date,
year=2017,
month=random.randint(1, 12),
day=random.randint(1, 28),
)
date_dialog.open()
def on_enter(self):
global screensArr
screensArr.append(self.manager.current)
print(self.manager.current, screensArr)
self.ids.fromd.text = "2016-01-01"
self.ids.to.text = "2016-12-31"
try:
self.remove_widget(spinner)
self.remove_widget(label)
except:
pass
ele_menu_items = [{"icon": "thermometer", "text": "Temperature"},
{"icon": "water", "text": "Moisture"},
{"icon": "weather-windy", "text": "Wind"}
]
self.ele_menu = MDDropdownMenu(
caller=self.ids.ele_drop_item,
items=ele_menu_items,
position="bottom",
width_mult=4,
)
self.ele_menu.bind(on_release=self.ele_set_item)
per_menu_items = [{"icon": "calendar-today", "text": "Daily"},
{"icon": "calendar-clock", "text": "Interannual"}
]
self.per_menu = MDDropdownMenu(
caller=self.ids.per_drop_item,
items=per_menu_items,
position="bottom",
width_mult=4,
)
self.per_menu.bind(on_release=self.per_set_item)
def ele_set_item(self, instance_menu, instance_menu_item):
self.ids.ele_drop_item.set_item(instance_menu_item.text)
global ele_data
ele_data = instance_menu_item.text
self.ids.ele_drop_item.text = instance_menu_item.text
print(self.ids.ele_drop_item.text)
self.ele_menu.dismiss()
def per_set_item(self, instance_menu, instance_menu_item):
self.ids.per_drop_item.set_item(instance_menu_item.text)
global per_data
per_data = instance_menu_item.text
self.ids.per_drop_item.text = instance_menu_item.text
print(self.ids.per_drop_item.text)
self.per_menu.dismiss()
def fetchData(self, *args):
global lat, lon
spinner = MDSpinner(
size_hint=(None, None),
size=(46, 46),
pos_hint={'center_x': .5, 'center_y': .2},
active=True,
)
self.add_widget(spinner)
label = MDLabel(
pos_hint={'center_y': 0.1},
text="This may take a while",
halign="center",
)
self.add_widget(label)
def graphPlot(category, parameter, *args):
def snk(*args):
Snackbar(text = "Getting Data...").open()
Clock.schedule_once(snk, 0.1)
cat = ''
para = ''
if category == 'Interannual':
cat = "INTERANNUAL"
url = "https://power.larc.nasa.gov/cgi-bin/v1/DataAccess.py?&request=execute&identifier=SinglePoint¶meters=" + parameter + "&startDate=" + self.ids.fromd.text[:4].replace('-','') + "&endDate=" + self.ids.to.text[:4].replace('-','') +"&userCommunity=AG&tempAverage=" + cat + "&outputList=JSON&lat=" + str(lat) + "&" + "lon=" + str(lon)
else:
cat = "DAILY"
url = "https://power.larc.nasa.gov/cgi-bin/v1/DataAccess.py?&request=execute&identifier=SinglePoint¶meters=" + parameter + "&startDate=" + self.ids.fromd.text.replace('-','') + "&endDate=" + self.ids.to.text.replace('-','') +"&userCommunity=AG&tempAverage=" + cat + "&outputList=JSON&lat=" + str(lat) + "&" + "lon=" + str(lon)
if parameter == 'T2M_RANGE':
para = 'Temperature (C)'
elif parameter == 'RH2M':
para = 'Moisture (%)'
else:
para = 'Wind Speed (m/s)'
print(url)
try:
response = requests.get(url)
print(response)
data = response.json()
data = data['features'][0]['properties']['parameter'][parameter]
dates = []
values = []
for key, value in data.items():
if category == 'Interannual':
if key[-2:] != '13' and value >= 0:
dates.append(key)
values.append(value)
print(key + " " + str(value))
else:
dates.append(key)
values.append(value)
print(key + " " + str(value))
import matplotlib.pyplot as plt
plt.figure(figsize=(17,10))
plt.plot(dates, values)
plt.title(para + ' Vs Year')
plt.xlabel('Year')
plt.ylabel(para)
plt.xticks(rotation=90)
#my_path = os.path.dirname(os.path.realpath(__file__))
global graphName
graphName = 'graphs/graph_' + str(int(time.time())) + '.png'
print(graphName)
plt.savefig(graphName, bbox_inches='tight')
#self.manager.current = 'graph'
def changeScreen(*args):
self.manager.current = 'ndata'
Clock.schedule_once(changeScreen, 1)
except Exception as e:
try:
self.remove_widget(spinner)
self.remove_widget(label)
except:
pass
print("Error")
print(e)
self.manager.current = "nasa"
Snackbar(text="Can't get data from Nasa!").open()
print(self.ids.ele_drop_item.text)
print(self.ids.per_drop_item.text)
if self.ids.ele_drop_item.text == 'Temperature':
graphPlot(self.ids.per_drop_item.text, 'T2M_RANGE')
elif self.ids.ele_drop_item.text == 'Moisture':
graphPlot(self.ids.per_drop_item.text, 'RH2M')
elif self.ids.ele_drop_item.text == 'Wind':
graphPlot(self.ids.per_drop_item.text, 'WS2M')
else:
Snackbar(text="Select Search Topic and Period first!").open()
class Advanced(MDScreen):
mask_menu = scaler_menu = compression_menu = video_codec_menu = audio_codec_menu = None
video_codec_menu_items = [{
"text": i
} for i in [
"default", "libx264 (.mp4)", "mpeg4 (.mp4)", "rawvideo (.avi)",
"png (.avi)", "libvorbis (.ogv)", "libvpx (.webm)"
]]
audio_codec_menu_items = [{
"text": i
} for i in [
"default", "libmp3lame (.mp3)", "libvorbis (.ogg)",
"libfdk_aac (.m4a)", "pcm_s16le (.wav)", "pcm_s32le (.wav)"
]]
compression_menu_items = [{
"text": i
} for i in [
"ultrafast", "superfast", "veryfast", "faster", "fast", "medium",
"slow", "slower", "veryslow", "placebo"
]]
scaler_menu_items = [{
"text": i
} for i in [
"fast_bilinear", "bilinear", "bicubic", "experimental", "neighbor",
"area", "bicublin", "gauss", "sinc", "lanczos", "spline"
]]
mask_menu_items = [{"text": i} for i in ["A.I.", "Video/Image"]]
tempdir = tempfile.mkdtemp()
frame_filename = os.path.join(tempdir, "temp_preview.jpg")
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.video_codec_menu = MDDropdownMenu(
caller=self.ids.video_codec_button,
items=self.video_codec_menu_items,
width_mult=4,
)
self.video_codec_menu.bind(on_release=self.video_codec_menu_callback)
self.audio_codec_menu = MDDropdownMenu(
caller=self.ids.audio_codec_button,
items=self.audio_codec_menu_items,
width_mult=4,
)
self.audio_codec_menu.bind(on_release=self.audio_codec_menu_callback)
self.compression_menu = MDDropdownMenu(
caller=self.ids.compression_button,
items=self.compression_menu_items,
width_mult=4,
)
self.compression_menu.bind(on_release=self.compression_menu_callback)
self.scaler_menu = MDDropdownMenu(
caller=self.ids.scaler_button,
items=self.scaler_menu_items,
width_mult=4,
)
self.scaler_menu.bind(on_release=self.scaler_menu_callback)
self.mask_menu = MDDropdownMenu(
caller=self.ids.mask_button,
items=self.mask_menu_items,
width_mult=4,
)
self.mask_menu.bind(on_release=self.mask_menu_callback)
def on_enter(self, *args):
MyThread(target=self.preview_queue).start()
MyThread(target=self.time_queue).start()
def video_codec_menu_callback(self, instance_menu, instance_menu_item):
if "default" in instance_menu_item.text:
app.ctrl.video_codec = None
else:
app.ctrl.video_codec = instance_menu_item.text.split()[0]
instance_menu.caller.text = instance_menu_item.text
instance_menu.dismiss()
def audio_codec_menu_callback(self, instance_menu, instance_menu_item):
if "default" in instance_menu_item.text:
app.ctrl.audio_codec = None
else:
app.ctrl.audio_codec = instance_menu_item.text.split()[0]
instance_menu.caller.text = instance_menu_item.text
instance_menu.dismiss()
def compression_menu_callback(self, instance_menu, instance_menu_item):
app.ctrl.compression = instance_menu.caller.text = instance_menu_item.text
instance_menu.dismiss()
def scaler_menu_callback(self, instance_menu, instance_menu_item):
app.ctrl.scaler = instance_menu.caller.text = instance_menu_item.text
app.ctrl.do_again(1)
instance_menu.dismiss()
def mask_menu_callback(self, instance_menu, instance_menu_item):
if instance_menu_item.text == "A.I.":
app.ctrl.mask = ""
instance_menu.caller.text = "A.I."
else:
app.file_manager_open()
app.go_to = ["advanced"]
app.ctrl.do_again(1)
instance_menu.dismiss()
def threads_button(self, up):
if up:
app.ctrl.threads = app.ctrl.p.var("threads", int) + 1
else:
app.ctrl.threads = app.ctrl.p.var("threads", int) - 1
self.ids.threads_label.text = f'{app.ctrl.p.var("threads", int)} threads'
def preview_queue(self):
while app.sm.current == "advanced":
sleep(1)
if self.ids.preview_spinner.active:
self.first_step_preview()
def time_queue(self):
while app.sm.current == "advanced":
sleep(1)
if not self.ids.time_bar.value:
self.first_step_time()
def first_step_preview(self):
app.ctrl.call(2)
app.ctrl.lock_wait("done", 2)
self.update_preview_slider()
self.second_step_preview()
def second_step_preview(self):
tim = app.ctrl.fake_get_frame / app.ctrl.p.final_clip.fps
app.ctrl.p.processes(3,
False,
output=self.frame_filename,
get_frame_from_time=tim)
app.ctrl.do_lock.release()
self.update_preview_image()
print("Image preview updated")
def first_step_time(self):
app.ctrl.call(2)
app.ctrl.lock_wait("done", 2)
self.second_step_time()
def second_step_time(self):
txt = self.ids.video_codec_button.text
ext = "mp4" if txt == "default" else txt.split(".")[-1].split(")")[0]
filename = os.path.join(self.tempdir, f"temp_video.{ext}")
app.ctrl.p.processes(3, False, output=filename, logger=MyLogger())
app.ctrl.do_lock.release()
@mainthread
def update_preview_spinner(self, _bool):
if _bool:
if self.ids.preview_slider.value:
self.ids.preview_spinner.active = True
else:
self.ids.preview_spinner.active = False
@mainthread
def update_preview_slider(self):
self.ids.preview_slider.max = app.ctrl.p.final_clip.fps
@mainthread
def update_preview_image(self):
self.ids.preview_image.reload()
self.update_preview_spinner(False)
@mainthread
def update_time(self, bar, label):
self.ids.time_bar.value = bar
self.ids.time_label.text = label
class AddServiceScreen(Screen):
dialog = None
# with self.root.canvas:
# Color(rgba=(.5, .5, .5))
# return self.root
def create_service(self):
services = ["Laundry", "Dry Cleaning", "Ironing"]
menu_items = [{"text": str(i)} for i in services]
self.menu = MDDropdownMenu(
caller=self.ids['client_services'],
items=menu_items,
width_mult=4,
)
self.menu.open()
self.menu.bind(on_release=self.set_item)
def set_item(self, instance_menu, instance_menu_item):
print('inside menu callback')
# self.ids['client_services'].hint_text = ''
self.ids['client_services'].text = instance_menu_item.text
instance_menu.dismiss()
def select_date(self):
print('inside select date')
# date_dialog = MDDatePicker(
# callback=self.on_save,
# min_date=datetime.date(2021, 2, 1),
# max_date=datetime.date(2022, 12, 31),
# )
# To make the MDDatePicker work and the MDDropDown work install the
# pip3 install https://github.com/kivymd/KivyMD/archive/master.zip
date_dialog = MDDatePicker()
date_dialog.bind(on_save=self.on_save, on_cancel=self.on_cancel)
date_dialog.open()
def on_save(self, instance, value, date_range):
self.ids['client_date'].text = str(value)
def on_cancel(self, instance, value):
instance.dismiss()
def set_slot_item(self, instance_menu, instance_menu_item):
self.ids['client_slot'].text = instance_menu_item.text
instance_menu.dismiss()
def available_slots(self):
print('available slots are')
time_slots = [
"9 AM - 10 AM", "10:30 - 11:30", "12 PM - 2 PM", " 3 PM - 5 PM"
]
menu_items = [{"text": str(i)} for i in time_slots]
self.menu = MDDropdownMenu(
caller=self.ids['client_slot'],
items=menu_items,
width_mult=4,
)
self.menu.open()
self.menu.bind(on_release=self.set_slot_item)
def select_time(self):
time_dialog = MDTimePicker()
time_dialog.bind(time=self.set_time)
time_dialog.open()
def set_time(self, instance, time):
self.ids['client_time'].text = str(time)
return time
def add_service(self):
print('add service')
client_name = self.ids['client_name'].text
client_phone = self.ids['client_phone'].text
service_type = self.ids['client_services'].text
service_dt = self.ids['client_date'].text
service_time = self.ids['client_slot'].text
desc = self.ids['client_desc'].text
print(client_name, client_phone, service_type, service_dt,
service_time, desc)
try:
receiver_email_id = "*****@*****.**"
s = smtplib.SMTP('smtp.gmail.com', 587)
s.starttls()
s.login("*****@*****.**", "Arun@alf")
# print(data)
data = "Client Name : " + client_name + "\n" + "Client Phone: " + client_phone + "\n"
data = data + "Service Type: " + service_type + "\n" + "Client Address: " + desc + "\n"
data = data + "Service Date: " + service_dt + "\n" + "Service Time: " + service_time
print(data)
message = 'Subject: {}\n\n{}'.format("New Service Request", data)
print('preparing to send email')
s.sendmail("*****@*****.**", receiver_email_id, message)
s.quit()
print('Mail Sent.................')
self.clear_data()
self.show_dialog()
except:
print('error connecting email')
def spin(self):
btn = self.ids['submit']
btn.add_widget(
MDSpinner(
active=True,
pos_hint="'center_x': .5, 'center_y': .5",
))
def show_dialog(self):
self.dialog = MDDialog(
title="Success!",
text="Service request placed Successfully!",
buttons=[
MDFlatButton(
text="OK",
pos_hint={
"center_x": 0.5,
"center_y": 0.5
},
on_release=self.close_dialog,
),
],
)
self.dialog.open()
# If registration successful return to login screen
self.manager.current = 'login_screen'
def close_dialog(self, inst):
self.dialog.dismiss()
def clear_data(self):
self.ids['client_name'].text = ""
self.ids['client_phone'].text = ""
self.ids['client_services'].text = "Select Service Type *"
self.ids['client_desc'].text = ""
def show_datetime_picker(self):
# min_date = datetime.strptime("2020:02:15", '%Y:%m:%d').date()
# max_date = datetime.strptime("2020:05:30", '%Y:%m:%d').date()
date_dialog = MDDatePicker(
callback=self.got_date,
min_date=datetime.date(2020, 2, 15),
max_date=datetime.date(2022, 3, 27),
)
# date_dialog.bind(on_save=self.on_save, on_cancel=self.on_cancel)
date_dialog.open()
def show_time_picker(self):
time_dialog = MDTimePicker()
time_dialog.bind(time=self.get_time)
time_dialog.open()
def get_time(self, instance, time):
print(instance, time)
self.ids['service_time'].text = str(time)
return time
def got_date(self, the_date):
print(the_date)
self.ids['service_dt'].text = str(the_date)
def go_home(self):
self.manager.current = 'home_screen'
class MyApp(MDApp):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.store = JsonStore('data.json')
self.buffer_item = None
self.auto_clear = False
self.active_data_items = []
self.history_data_items = []
self.screen = Builder.load_file('app.kv')
self.menu = MDDropdownMenu(caller=self.screen.ids.button,
items=[{
"text": 'Settings'
}, {
"text": 'About project'
}],
width_mult=4)
self.menu.bind(on_release=self.callback_menu_toolbar)
self.dialog_new_item = MDDialog(
title="Add new item:",
type="custom",
md_bg_color=[1, 1, 1, 1.0],
content_cls=Content(),
buttons=[
MDFlatButton(text="CANCEL",
text_color=self.theme_cls.primary_color,
on_release=self.dialog_new_item_close),
MDFlatButton(text="OK",
text_color=self.theme_cls.primary_color,
on_release=self.dialog_new_item_ok),
],
)
self.dialog_complete = MDDialog(
title="Complete item",
text=
"Do you want the item to move into the history?\n(If auto clear enable, item will be deleted)",
md_bg_color=[1, 1, 1, 1.0],
buttons=[
MDFlatButton(text="NO",
text_color=self.theme_cls.primary_color,
on_release=self.dialog_complete_no),
MDFlatButton(text="YES",
text_color=self.theme_cls.primary_color,
on_release=self.dialog_complete_yes),
],
)
self.dialog_delete = MDDialog(
title="Delete item",
text=
"Are you sure you want to delete this item?\nYou will not restore them after delete",
md_bg_color=[1, 1, 1, 1.0],
buttons=[
MDFlatButton(text="NO",
text_color=self.theme_cls.primary_color,
on_release=self.dialog_delete_no),
MDFlatButton(text="YES",
text_color=self.theme_cls.primary_color,
on_release=self.dialog_delete_yes),
],
)
self.but_add = MDFloatingActionButton(icon="plus",
pos_hint={
"center_x": .9,
"center_y": .1
},
md_bg_color=[
0.11372549019607843,
0.9137254901960784,
0.7137254901960784, 1.0
],
on_release=self.click_but_add)
self.screen.ids.screen_manager.get_screen('main').add_widget(
self.but_add)
def click_but_add(self, *args):
self.dialog_new_item.content_cls.ids.item.text = ''
self.dialog_new_item.content_cls.ids.number.text = ''
self.dialog_new_item.content_cls.ids.details.text = ''
self.dialog_new_item.open()
def dialog_complete_yes(self, *args):
self.dialog_complete.dismiss()
self.screen.ids.screen_manager.get_screen(
'main').ids.scroll_active.remove_widget(self.buffer_item)
self.active_data_items.remove({
'text':
self.buffer_item.text,
'secondary_text':
self.buffer_item.secondary_text
})
if not self.auto_clear:
self.buffer_item = TwoLineAvatarIconListItem(
text=self.buffer_item.text,
secondary_text=self.buffer_item.secondary_text,
on_release=self.click_on_history_list_item)
self.screen.ids.screen_manager.get_screen(
'main').ids.scroll_history.add_widget(self.buffer_item)
self.history_data_items.append({
'text':
self.buffer_item.text,
'secondary_text':
self.buffer_item.secondary_text
})
self.buffer_item = None
def dialog_complete_no(self, *args):
self.dialog_complete.dismiss()
self.buffer_item = None
def dialog_delete_no(self, *args):
self.dialog_delete.dismiss()
self.buffer_item = None
def dialog_delete_yes(self, *args):
self.dialog_delete.dismiss()
self.history_data_items.remove({
'text':
self.buffer_item.text,
'secondary_text':
self.buffer_item.secondary_text
})
self.screen.ids.screen_manager.get_screen(
'main').ids.scroll_history.remove_widget(self.buffer_item)
self.buffer_item = None
def click_on_active_list_item(self, item):
self.buffer_item = item
self.dialog_complete.open()
def click_on_history_list_item(self, item):
self.buffer_item = item
self.dialog_delete.open()
def dialog_new_item_ok(self, *args):
item = self.dialog_new_item.content_cls.ids.item.text
number = self.dialog_new_item.content_cls.ids.number.text
details = self.dialog_new_item.content_cls.ids.details.text
self.screen.ids.screen_manager.get_screen(
'main').ids.scroll_active.add_widget(
TwoLineAvatarIconListItem(
text=item + ' ' + number,
secondary_text=details,
on_release=self.click_on_active_list_item))
self.active_data_items.append({
'text': item + ' ' + number,
'secondary_text': details
})
self.dialog_new_item.dismiss()
def dialog_new_item_close(self, *args):
self.dialog_new_item.dismiss()
def switch_clear_mode(self, switch, value):
self.auto_clear = value
def switch_color_mode(self, switch, value):
if value:
self.theme_cls.theme_style = 'Dark'
self.dialog_new_item.md_bg_color = [0.15, 0.15, 0.15, 1.0]
self.dialog_complete.md_bg_color = [0.15, 0.15, 0.15, 1.0]
self.dialog_delete.md_bg_color = [0.15, 0.15, 0.15, 1.0]
else:
self.theme_cls.theme_style = 'Light'
self.dialog_new_item.md_bg_color = [1, 1, 1, 1.0]
self.dialog_complete.md_bg_color = [1, 1, 1, 1.0]
self.dialog_delete.md_bg_color = [1, 1, 1, 1.0]
def change_screen(self, name_screen):
self.root.ids.screen_manager.current = name_screen
def callback_menu_toolbar(self, instance_menu, instance_menu_item):
if instance_menu_item.text == 'Settings':
self.change_screen('settings')
if instance_menu_item.text == 'About project':
self.change_screen('about')
instance_menu.dismiss()
def on_stop(self):
self.store.put(
'settings',
auto_clear=self.auto_clear,
color_mode=self.theme_cls.theme_style,
switch_color_mode_value=self.screen.ids.screen_manager.get_screen(
'settings').ids.color_mode.active,
switch_clear_mode_value=self.screen.ids.screen_manager.get_screen(
'settings').ids.clear_mode.active)
self.store.put('items_data',
active=self.active_data_items,
history=self.history_data_items)
def on_start(self):
settings = self.store.get('settings')
self.auto_clear = settings['auto_clear']
self.theme_cls.theme_style = settings['color_mode']
self.screen.ids.screen_manager.get_screen(
'settings'
).ids.color_mode.active = settings['switch_color_mode_value']
self.screen.ids.screen_manager.get_screen(
'settings'
).ids.clear_mode.active = settings['switch_clear_mode_value']
self.active_data_items = self.store['items_data']['active']
self.history_data_items = self.store['items_data']['history']
for item in self.active_data_items:
self.screen.ids.screen_manager.get_screen(
'main').ids.scroll_active.add_widget(
TwoLineAvatarIconListItem(
text=item['text'],
secondary_text=item['secondary_text'],
on_release=self.click_on_active_list_item))
for item in self.history_data_items:
self.screen.ids.screen_manager.get_screen(
'main').ids.scroll_history.add_widget(
TwoLineAvatarIconListItem(
text=item['text'],
secondary_text=item['secondary_text'],
on_release=self.click_on_history_list_item))
def build(self):
return self.screen
class SignupScreen(Screen):
def get_date(self, date, *args):
print(date)
print(type(date))
self.ids.date.text = str(date)
def show_date_picker(self, *args):
date_dialog = MDDatePicker(
callback=self.get_date,
year=random.randint(1997, 2005),
month=random.randint(1, 12),
day=random.randint(1, 28),
)
date_dialog.open()
def on_enter(self, *args):
menu_items = [{
"icon": "gender-male",
"text": "Male"
}, {
"icon": "gender-female",
"text": "Female"
}, {
"icon": "gender-non-binary",
"text": "Other"
}, {
"icon": "face",
"text": "Prefer not to say"
}]
self.menu = MDDropdownMenu(
caller=self.ids.gender,
items=menu_items,
position="bottom",
width_mult=4,
)
self.menu.bind(on_release=self.set_item)
def set_item(self, instance_menu, instance_menu_item):
def set_item(interval):
self.ids.gender.text = instance_menu_item.text
instance_menu.dismiss()
Clock.schedule_once(set_item, 0.5)
def signup(self, *args):
errors = 0
import string
def isEnglish(s):
try:
s.encode(encoding='utf-8').decode('ascii')
except UnicodeDecodeError:
return False
else:
return True
# Check full name
self.ids.flname.error = False
self.ids.flname.helper_text = ""
if isEnglish(self.ids.flname.text) == True:
for char in self.ids.flname.text:
if char in string.punctuation and char not in ['_', '.', ' ']:
self.ids.flname.error = True
self.ids.flname.helper_text = "Punctuations other than '.' and '_' aren't allowed!"
errors = 3
else:
self.ids.flname.error = False
else:
self.ids.flname.error = True
self.ids.flname.helper_text = "Non-English characters aren't allowed!"
errors = 4
# Check date
from datetime import datetime
date_obj = ''
self.ids.date.error = False
self.ids.date.helper_text = ""
try:
date_obj = datetime.strptime(self.ids.date.text, '%Y-%m-%d')
except:
self.ids.date.error = True
self.ids.date.helper_text = "Incorrect date!"
errors = 5
# Check gender
self.ids.gender.error = False
self.ids.gender.helper_text = ""
self.ids.gender.helper_text_mode = "on_focus"
if self.ids.gender.text == 'Prefer not to say':
self.ids.gender.text = 'Undefined'
if self.ids.gender.text not in [
'Male', 'Female', 'Other', 'Undefined'
]:
self.ids.gender.error = True
self.ids.gender.helper_text = "Incorrect gender!"
errors = 6
# Check Email
import re
self.ids.email.error = False
self.ids.email.helper_text = ""
regex = r'^[a-z0-9]+[\._]?[a-z0-9]+[@]\w+[.]\w{2,3}$'
print(self.ids.email.text)
if not (re.search(regex, self.ids.email.text)):
self.ids.email.error = True
self.ids.email.helper_text = "Incorrect email format!"
errors = 7
# Check Password
# self.ids.passw.error = False
# self.ids.passw.helper_text = ""
# if isEnglish(self.ids.passw.text) == False:
# self.ids.passw.error = True
# self.ids.passw.helper_text = "Non-English letters aren't allowed!"
# errors = 8
# # Check Confirm Password
# self.ids.conf_pass.error = False
# self.ids.conf_pass.helper_text = ""
# if isEnglish(self.ids.conf_pass.text) == False:
# self.ids.conf_pass.error = True
# self.ids.conf_pass.helper_text = "Non-English letters aren't allowed!"
# errors = 9
# Check if password does't match
self.ids.passw.error = False
self.ids.conf_pass.error = False
self.ids.passw.helper_text = ""
self.ids.conf_pass.helper_text = ""
if (self.ids.passw.text != self.ids.conf_pass.text):
self.ids.passw.error = True
self.ids.conf_pass.error = True
self.ids.passw.helper_text = "Passwords do not match!"
self.ids.conf_pass.helper_text = "Passwords do not match!"
errors = 10
# Upload to firebase
print("Signing up...")
print(str(errors))
if errors == 0:
print("No errors")
toast('Creating account...')
def go(self, *args):
data = {
'fullname': self.ids.flname.text,
'bdate': self.ids.date.text,
'gender': self.ids.gender.text,
'email': self.ids.email.text,
'points': 0,
'rank': 'Newbie',
'pic': 'not_uploaded'
}
import pyrebase
from .fbconfig import users_firebaseConfig
firebase = pyrebase.initialize_app(users_firebaseConfig)
auth = firebase.auth()
email = self.ids.email.text
password = self.ids.passw.text
try:
signup = auth.create_user_with_email_and_password(
email, password)
print(signup)
print(signup['localId'])
db = firebase.database()
db.child("users").child(signup['localId']).set(data)
Snackbar(text="Account created successfully!").open()
global userdata
userdata = data
self.manager.current = 'login'
except requests.exceptions.HTTPError as e:
error_json = e.args[1]
error = json.loads(error_json)['error']['message']
print(error)
if error == "EMAIL_EXISTS":
print("Email already exists!")
Snackbar(text="Email already exists!").open()
elif error == "WEAK_PASSWORD":
print("Enter a stronger password!")
Snackbar(text="Enter a stronger password!").open()
else:
print(error)
Snackbar(text=error).open()
threading.Thread(target=go, args=(self, *args)).start()
