class MainScreen(Screen):
usernamev = ObjectProperty(None)
total_scorev = ObjectProperty(None)
stats = ObjectProperty(None)
def on_enter(self, *args):
MainApp().getValues()
self.usernamev.text = player.usernamev
self.total_scorev.text = "ExP = " + player.total_scorev
def __init__(self, **kwargs):
super().__init__(**kwargs)
menu_main = [{
"icon": "",
"text": "Log out"
}, {
"icon": "",
"text": "Change username"
}]
self.menu1 = MDDropdownMenu(caller=self.ids.menubtn,
items=menu_main,
width_mult=4,
callback=self.menu_callbackM)
def menu_callbackM(self, instance):
option_menu = instance.text
print(option_menu)
self.menu1.dismiss()
if option_menu == "Log out":
MainApp().show_LogoutM()
if option_menu == "Change username":
MainApp().show_change()
class UdajeZamestnanec(BoxLayout):
def __init__(self, id, *args, **kwargs):
super().__init__(**kwargs)
if id:
zamestnanec = vars(app.zamestnanci.database.read_zamestnanec_by_id(id))
else:
zamestnanec = {"id":"", "jmeno":"","pozice":"","firma":""}
self.ids.zamestnanec_jmeno.text = zamestnanec['jmeno']
firmy = app.zamestnanci.database.read_firma()
menu_items = [{"viewclass": "OneLineListItem", "text": f"{firma.nazev}", "on_release": lambda x=f"{firma.nazev}": self.set_item(x)} for firma in firmy]
self.menu_firmy = MDDropdownMenu(
caller=self.ids.firma_nazev,
items=menu_items,
position="center",
width_mult=5,
)
self.ids.nazev.set_item(zamestnanec['firma'])
self.ids.pozice.text = zamestnanec['pozice']
def set_item(self, text_item):
self.ids.nazev.set_item(text_item)
self.ids.nazev.text = text_item
# Zavření menu
self.menu_firmy.dismiss()
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
class GameContent(BoxLayout):
def __init__(self, id, *args, **kwargs):
super().__init__(**kwargs)
if id:
game = vars(app.games.database.read_by_id(id))
else:
game = {"id": "", "name": "", "platform1": "Platforma"}
self.ids.game_name.text = game['name']
platforms = app.games.database.read_platforms()
menu_items = [{
"viewclass":
"OneLineListItem",
"text":
f"{platform.name}",
"on_release":
lambda x=f"{platform.name}": self.set_item(x)
} for platform in platforms]
self.menu_platforms = MDDropdownMenu(
caller=self.ids.platform_item,
items=menu_items,
position="center",
width_mult=5,
)
self.ids.platform_item.set_item(game['platform1'])
self.ids.platform_item.text = game['platform1']
def set_item(self, text_item):
self.ids.platform_item.set_item(text_item)
self.ids.platform_item.text = text_item
self.menu_platforms.dismiss()
class HomeScreen(MDScreen):
def __init__(self, **kwargs):
super().__init__(**kwargs)
items = [
"New group",
"New broadcasts",
"WhatsApp Web",
"Starred messages",
"Payments",
"Settings",
]
menu_items = [{
"text":
item,
"viewclass":
"OneLineListItem",
"height":
dp(54),
"divider":
None,
"on_release":
self.menu_callback if item == "Settings" else lambda *args: None,
} for item in items]
self.menu = MDDropdownMenu(
items=menu_items,
width_mult=3,
radius=[
dp(2),
],
)
def open_menu(self, button):
self.menu.caller = button
self.menu.open()
def menu_callback(self):
self.manager.set_screen("settings")
self.menu.dismiss()
def on_tab_switch(self, *args):
if args[3] == "[b]CHATS[/b]":
self.ids.float_btn.icon = "android-messages"
elif args[3] == "[b]STATUS[/b]":
self.ids.float_btn.icon = "camera"
elif args[3] == "[b]CALLS[/b]":
self.ids.float_btn.icon = "phone-plus"
self.toggle_pencil_btn(args[3])
def toggle_pencil_btn(self, current_tab):
if current_tab == "[b]STATUS[/b]":
anim = Animation(d=0.1,
y=self.ids.float_btn.y +
(self.ids.float_btn.height + dp(10)))
self.ids.pencil_btn.disabled = False
else:
anim = Animation(d=0.1, y=self.ids.float_btn.y)
self.ids.pencil_btn.disabled = True
anim.start(self.ids.pencil_btn)
class AddResourcesWindow(Screen):
def load_page(self):
ContentNavigationDrawer.populateNavDrawerValues(self)
self.rsrcmenu = MDDropdownMenu(caller=self.ids['name'],
width_mult=5,
callback=self.set_item,
position="center")
items = [
"Medicine", "Biscuit", "Salt", "Tarpaulin", "Rice", "Daal",
"Baby Food", "Sugar"
]
for i in items:
self.rsrcmenu.items.append({"text": str(i)})
def create_resource(self, name, desc, units, amount):
rname = name.current_item
rdesc = desc.text
runits = units.text
ramount = amount.text
valid_str = ""
if rname == "":
valid_str = "Select an Item"
elif runits == "":
valid_str = "Units is blank"
elif ramount == "":
valid_str = "Cost is blank"
if valid_str != "":
ok_button = MDFlatButton(text='OK', on_release=self.dialog_close)
self.dialog = MDDialog(title='Alert !',
text=valid_str,
size_hint=(0.7, 1),
buttons=[ok_button])
self.dialog.open()
else:
query1 = f'''INSERT INTO RESOURCES(CONTACT_ID, ACTIVITY_ID, NAME, DESC, UNITS, AMOUNT, DATE)
VALUES ({globalvariables.var_userid}, {globalvariables.var_act_id}, '{rname}', '{rdesc}', {runits},
{ramount}, SYSDATE)'''
# run direct SQL
stmt = ibm_db.exec_immediate(connection.conn, query1)
if ibm_db.num_rows(stmt) > 0:
#self.ids['name'].text=""
self.ids['desc'].text = ""
self.ids['units'].text = ""
self.ids['amount'].text = ""
self.snackbar = Snackbar(text="Item Added!")
self.snackbar.show()
def dialog_close(self, obj):
self.dialog.dismiss()
def set_item(self, instance):
self.ids['name'].set_item(instance.text)
self.rsrcmenu.dismiss()
def cancel_resource_creation(self):
self.manager.transition.direction = 'right'
self.manager.current = 'activity_detail_window'
self.manager.get_screen('activity_detail_window').load_page()
class PersonContent(BoxLayout):
def __init__(self, id, *args, **kwargs):
super().__init__(**kwargs)
if id:
person = vars(app.persons.database.read_by_id(id))
else:
person = {
"id": "",
"name": "jméno",
"state_short": "Stát",
"city": "Město"
}
self.ids.person_name.text = person['name']
states = app.persons.database.read_states()
#získání výpisu všech států
menu_items = [{
"viewclass":
"OneLineListItem",
"text":
f"{state.short_name}",
"on_release":
lambda x=f"{state.short_name}": self.set_item(x)
} for state in states]
self.menu_states = MDDropdownMenu(
caller=self.ids.state_item,
items=menu_items,
position="center",
width_mult=5,
)
cities = app.persons.database.read_cities()
#získání výpisů všech měst
me_items = [{
"viewclass": "OneLineListItem",
"text": f"{city.name}",
"on_release": lambda x=f"{city.name}": self.sett_item(x)
} for city in cities]
self.menu_city = MDDropdownMenu(
caller=self.ids.city_item,
items=me_items,
position="center",
width_mult=5,
)
self.ids.city_item.set_item(person['city'])
self.ids.city_item.text = person['city']
self.ids.state_item.set_item(person['state_short'])
self.ids.state_item.text = person['state_short']
#při kliknutí se to zapíše
def set_item(self, text_item):
self.ids.state_item.set_item(text_item)
self.ids.state_item.text = text_item
self.menu_states.dismiss()
def sett_item(self, text_item):
self.ids.city_item.set_item(text_item)
self.ids.city_item.text = text_item
self.menu_city.dismiss()
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'
class BookContent(BoxLayout):
def __init__(self, id, *args, **kwargs):
super().__init__(**kwargs)
if id:
book = vars(app.books.database.read_by_id(id))
else:
book = {
"id": "",
"name": "Název knihy",
"year": "",
"author": "Autor",
"genre": "Žánr"
}
self.ids.book_name.text = book['name']
authors = app.books.database.read_authors()
#genres = app.books.database.read_genres()
menu_items_authors = [{
"viewclass":
"OneLineListItem",
"text":
f"{author.name}",
"on_release":
lambda x=f"{author.name}": self.set_item(x)
} for author in authors]
"""menu_items_genres = [{"viewclass": "OneLineListItem", "text": f"{genre.name}",
"on_release": lambda x=f"{genre.name}": self.set_item(x)} for genre in genres]"""
self.menu_authors = MDDropdownMenu(
caller=self.ids.author_item,
items=menu_items_authors,
position="center",
width_mult=5,
)
self.ids.author_item.set_item(book['author'])
self.ids.author_item.text = book['author']
"""self.menu_genres = MDDropdownMenu(
caller=self.ids.genre_item,
items=menu_items_genres,
position="center",
width_mult=5,
)
self.ids.genre_item.set_item_g(book['genre'])
self.ids.genre_item.text = book['genre']"""
def set_item(self, text_item):
self.ids.author_item.set_item(text_item)
self.ids.author_item.text = text_item
self.menu_authors.dismiss()
"""def set_item(self, text_item):
class GradesRow(MDBoxLayout):
student_id = StringProperty()
name = StringProperty()
date = ObjectProperty()
gtype = StringProperty()
math = StringProperty()
english = StringProperty()
hindi = StringProperty()
key_map = {"monthly": "Monthly", "mid_term": "Mid-Term", "final": "Final"}
def __init__(self, **kwargs):
super().__init__(**kwargs)
menu_items = [
{
"text":
"Monthly",
"viewclass":
"OneLineListItem",
"on_release":
lambda x="monthly": self.menu_callback(self.key_map[x], x),
},
{
"text":
"Mid-Term",
"viewclass":
"OneLineListItem",
"on_release":
lambda x="mid_term": self.menu_callback(self.key_map[x], x),
},
{
"text":
"Final",
"viewclass":
"OneLineListItem",
"on_release":
lambda x="final": self.menu_callback(self.key_map[x], x),
},
]
self.gtype_menu = MDDropdownMenu(
caller=self.ids.gtype,
items=menu_items,
width_mult=4,
)
def menu_callback(self, text, gtype):
self.ids.gtype.text = text
self.gtype = gtype
self.gtype_menu.dismiss()
class DemoApp(MDApp):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.datatype = Builder.load_string(datatype_helper)
x = ("float","uint")
menu_items = [{"text": f"{x[i]}"} for i in range(len(x))]
self.menu = MDDropdownMenu(
caller=self.datatype.ids.field,
items=menu_items,
position="bottom",
callback= self.set_datatype,
width_mult=4,
)
def set_datatype(self, instance):
def set_datatype(terval):
self.datatype.ids.field.text = instance.text
self.menu.dismiss()
Clock.schedule_once(set_datatype, 0.5)
def set_readtype(self, texttype):
def set_readtype(interval):
self.datatype.ids.field.text = texttype.text
self.menu.dismiss()
Clock.schedule_once(set_readtype, 0.5)
def build(self):
self.theme_cls.primary_palette = 'Green'
screen = Builder.load_string(screen_helper)
button = MDRectangleFlatButton(text = 'show',pos_hint = {'center_x': 0.5, 'center_y':0.3},
on_release = self.show_data )
self.slave = Builder.load_string(slave_helper)
self.register = Builder.load_string(register_helper)
screen.add_widget(self.slave)
screen.add_widget(self.register)
screen.add_widget(self.datatype)
## screen.add_widget(self.readtype)
screen.add_widget(button)
return screen
def show_data(self, obj):
print(self.slave.text)
print(self.register.text)
print(self.datatype.ids.field.text)
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 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 SelectBox(MDStackLayout):
"""An html style select box"""
label = StringProperty('Select an option')
value = StringProperty()
options = ListProperty()
dd_item = ObjectProperty()
dropdown = None
def on_dd_item(self, _instance, item):
"""Runs after setting the MDDropDownItem"""
app = MDApp.get_running_app()
print(f"Theme class {app.theme_cls.primary_color}")
self.dropdown = MDDropdownMenu(
caller=item,
items=self.options,
position="auto",
width_mult=4,
callback=self.select_option,
)
item.bind(on_release=self.open_dropdown)
def open_dropdown(self, *_args, **_kwargs):
"""Open the dropdown."""
self.dropdown.open()
def on_options(self, _instance, options):
"""Change the selectbox items."""
if self.dropdown is not None:
self.dropdown.items = options
self.dropdown.create_menu_items()
def on_label(self, _instance, value):
"""When the selectbox label changes, change the button text"""
self.dd_item.text = value
def select_option(self, option):
"""Selected the option of the SelectBox"""
self.dropdown.dismiss()
self.dd_item.set_item(option.text)
self.value = option.text
class MDDropItem(MDScreen):
menu = None
def on_enter(self):
menu_items = [{
"viewclass": "DropListItem",
"icon": "git",
"height": dp(56),
"text": f"Item {i}",
"on_release": lambda x=f"Item {i}": self.set_item(x),
} for i in range(5)]
self.menu = MDDropdownMenu(
caller=self.ids.dropdown_item,
items=menu_items,
position="center",
width_mult=4,
)
def set_item(self, text_item):
self.ids.dropdown_item.set_item(text_item)
self.menu.dismiss()
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 UserInfo(MDBoxLayout):
def __init__(self, *args, **kwargs):
super().__init__(**kwargs)
self.user = None
if (len(args) > 0):
self.user = args[0].get('user', None)
if (self.user == None):
self.user = User(None, '', '', '', UserRole.person.value)
self.ids.username.text = self.user.username
self.ids.fullname.text = self.user.fullname
if (self.user.password == None):
self.ids.password.text = ''
else:
self.ids.password.text = self.user.password
if (self.user.userRole != None):
self.ids.user_role.text = self.user.userRole
self.ids.user_role.current_item = self.user.userRole
role_items = [{"text": str(i.value)} for i in UserRole]
self.role_menu = MDDropdownMenu(
caller=self.ids.user_role,
items=role_items,
position="center",
width_mult=4,
callback=self.set_item,
)
# self.role_menu.bind(on_release=self.set_item)
def set_item(self, instance):
self.ids.user_role.set_item(instance.text)
self.role_menu.dismiss()
def cancel():
pass
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 AnimalContent(BoxLayout):
def __init__(self, id, *args, **kwargs):
super().__init__(**kwargs)
if id:
animal = vars(app.animals.database.read_animal_by_id(id))
else:
animal = {"id": "", "name": "", "typee": "Type"}
self.ids.animal_name.text = animal['name']
types = app.animals.database.read_types()
menu_items = [{
"viewclass":
"OneLineListItem",
"text":
f"{typee.full_name}",
"on_release":
lambda x=f"{typee.full_name}": self.set_item(x)
} for typee in types]
self.menu_types = MDDropdownMenu(
caller=self.ids.type_item,
items=menu_items,
position="center",
width_mult=5,
)
self.ids.type_item.set_item(animal['typee'])
self.ids.type_item.text = animal['typee']
def set_item(self, text_item):
self.ids.type_item.set_item(text_item)
self.ids.type_item.text = text_item
self.menu_types.dismiss()
class ListButtonDropdown(MDDropDownItem):
instance_text = ""
def __init__(self, **kwargs):
super().__init__(**kwargs)
menu_items = [{
"icon": "git",
"text": "Default"
}, {
"icon": "git",
"text": "Router 1"
}]
self.menu = MDDropdownMenu(
caller=self,
items=menu_items,
callback=self.set_item_c,
width_mult=4,
)
dummy_instance.set_instance(self)
def set_item_c(self, instance):
self.set_item(instance.text)
self.menu.dismiss()
self.instance_text = instance.text
class FileManagerTextFieldSearch(ThemableBehavior, MDRelativeLayout):
"""The class implements a text field for searching files.
See rule ``FileManagerTextFieldSearch``
in ``kivymd_extensions/filemanager/filemanager.kv file``.
"""
hint_text = StringProperty()
"""
See :attr:`~kivy.uix.textinput.TextInput.hint_text
"""
background_normal = StringProperty()
"""
See :attr:`~kivy.uix.textinput.TextInput.background_normal
"""
background_active = StringProperty()
"""
See :attr:`~kivy.uix.textinput.TextInput.background_active
"""
type = OptionProperty("name", options=["name", "ext"])
"""
Search files by name or extension. Available options are `'name'`, `'ext'`.
:attr:`icon` is an :class:`~kivy.properties.OptionProperty`
and defaults to `'name'`.
"""
manager = ObjectProperty()
"""
See :class:`FileManager` object.
"""
def __init__(self, **kw):
super().__init__(**kw)
# Signal to interrupt the search process
self.canceled_search = False
# <FileManagerTextFieldSearchDialog object>
self.text_field_search_dialog = None
# <kivymd.uix.menu.MDDropdownMenu object>
self.context_menu_search_field = None
# Whether to search the entire disk or the current directory.
self.search_all_disk = False
self.end_search = False
Clock.schedule_once(self.create_menu)
def on_enter(self, instance, value):
"""Called when the user hits 'Enter' in text field."""
def wait_result(interval):
if self.end_search:
Clock.unschedule(wait_result)
if data_results:
FileManagerFilesSearchResultsDialog(
data_results=data_results,
manager=self.manager).open()
self.manager.dialog_files_search_results_open = True
def start_search(interval):
threading.Thread(
target=get_matching_files,
args=(
"/" if self.search_all_disk else self.manager.path,
value,
),
).start()
def get_matching_files(path, name_file):
for d, dirs, files in os.walk(path):
if self.canceled_search:
break
self.text_field_search_dialog.ids.lbl_dir.text = d
for f in files:
self.text_field_search_dialog.ids.lbl_file.text = f
self.manager.ids.lbl_task.text = (
f"Search in [color="
f"{get_hex_from_color(self.theme_cls.primary_color)}]"
f"{os.path.dirname(d)}:[/color] {f}")
if self.ids.text_field.hint_text == "Search by name":
if name_file in f:
data_results[f] = os.path.join(d, f)
elif self.ids.text_field.hint_text == "Search by extension":
if f.endswith(name_file):
data_results[f] = os.path.join(d, f)
if self.canceled_search:
self.canceled_search = False
self.end_search = True
self.text_field_search_dialog.dismiss()
self.text_field_search_dialog = FileManagerTextFieldSearchDialog(
manager=self.manager)
self.text_field_search_dialog.open()
self.end_search = False
data_results = {}
Clock.schedule_once(start_search, 1)
Clock.schedule_interval(wait_result, 0)
def create_menu(self, interval):
menu = []
for text in (
"Search by extension",
"Search by name",
"All over the disk",
):
menu.append({
"text":
f"[size=14]{text}[/size]",
"viewclass":
"OneLineListItem",
"height":
dp(36),
"top_pad":
dp(4),
"bot_pad":
dp(10),
"divider":
None,
"on_release":
lambda x=f"[size=14]{text}[/size]": self.set_type_search(x),
})
self.context_menu_search_field = MDDropdownMenu(
caller=self.ids.lbl_icon_right,
items=menu,
width_mult=4,
background_color=self.theme_cls.bg_dark,
max_height=dp(240),
)
def set_type_search(self, text_item):
self.context_menu_search_field.dismiss()
self.search_all_disk = False
item_text = re.sub("\[size\s*([^\]]+)\]", "", text_item)
item_text = re.sub("\[/size\s*\]", "", item_text)
if item_text == "Search by extension":
self.type = "ext"
elif item_text == "Search by name":
self.type = "name"
elif item_text == "All over the disk":
self.search_all_disk = True
self.ids.text_field.hint_text += f" {item_text.lower()}"
return
self.ids.text_field.hint_text = item_text
class FilmScreen(Screen):
# Information pulled from database
SOLVENT_NAMES = ListProperty([])
MATERIAL_NAMES = ListProperty([])
# INformation pulled form settings
_SOLUTION_TYPES = ListProperty([])
_SOLUTION_TYPE_DEFAULT = SOLUTION_TYPES[0]
def __init__(self, *args, **kwargs):
super(FilmScreen, self).__init__(*args, **kwargs)
Clock.schedule_once(lambda x: self.prepare(), 0)
def prepare(self):
"""
Bindings to corresponding viewmodel properties
and initialization of widget
"""
app = MDApp.get_running_app()
app.film_view_model.bind(
THICKNESS=lambda x, y: self.show_film_thickness(y),
ERROR=lambda x, y: self.error_popup(y),
SOLVENT_LIST=lambda x, y: self.add_solvents(y),
MATERIAL_LIST=lambda x, y: self.add_materials(y))
# Dropdown construction from settings const.
self.add_solution_types(SOLUTION_TYPES)
# Dropdown construction from viewmodel querying
# that triggers bound method in view 'add_solvents' or 'add_materials'
app.film_view_model.get_solvents()
app.film_view_model.get_materials()
self.create_dropdowns()
def create_dropdowns(self):
self.solvent_menu = MDDropdownMenu(
caller=self.ids.solvent,
items=self.SOLVENT_NAMES,
position="bottom",
callback=self.on_solvent,
width_mult=4,
)
self.material_menu = MDDropdownMenu(
caller=self.ids.material,
items=self.MATERIAL_NAMES,
position="bottom",
callback=self.on_material,
width_mult=4,
)
self.types_menu = MDDropdownMenu(
caller=self.ids.solution_types,
items=self._SOLUTION_TYPES,
position="bottom",
callback=self.on_solution_types,
width_mult=4,
)
def add_solution_types(self, types):
"""Helper for constructing 'solution types' dropdown"""
self._SOLUTION_TYPES = [{
'viewclass': 'MDMenuItem',
'text': type,
'callback': self.on_solution_types
} for type in types]
def add_materials(self, materials):
"""Helper for constructing 'materials' dropdown"""
self.MATERIAL_NAMES = [{
'viewclass': 'MDMenuItem',
'text': material['name'],
'callback': self.on_material
} for material in materials]
def add_solvents(self, solvents):
"""Helper for constructing 'solvents' dropdown"""
self.SOLVENT_NAMES = [{
'viewclass': 'MDMenuItem',
'text': solvent['name'],
'callback': self.on_solvent
} for solvent in solvents]
def on_solvent(self, item):
"""boudn to solvent dropdown selection"""
self.ids.solvent.text = item.text
self.solvent_menu.dismiss()
def on_material(self, item):
"""Boudn to material dropdown selection"""
self.ids.material.text = item.text
self.material_menu.dismiss()
def on_solution_types(self, item):
"""Bound to solution type dropdown selection"""
self.ids.solution_types.text = item.text
self.types_menu.dismiss()
def on_mass(self, text):
"""
Not used, but kept in case I need to set events based
on input state change
"""
# text set automatically for input widgets
pass
def on_concentration(self, text):
"""
Not used, but kept in case I need to set events based
on input state change
"""
# text set automatically for input widgets
pass
def clear(self):
"""Clears all inputs on view UI"""
self.ids.concentration.text = ''
self.ids.volume.text = ''
self.ids.area.text = ''
def calculate_button_pressed(self):
"""
Passes all input parameters from screen to viewmodel
calculate method. These inputs take the form of a dictionary
"""
app = MDApp.get_running_app()
app.film_view_model.calculate({
'solution_type':
self.ids.solution_types.text,
'solvent':
self.ids.solvent.text,
'material':
self.ids.material.text,
'concentration':
self.ids.concentration.text,
'volume':
self.ids.volume.text,
'area':
self.ids.area.text,
})
def error_popup(self, is_error):
"""Bound to 'ERROR' property in volume_view_model"""
if is_error:
self.dialog = MDDialog(
title='Oops! Something went wrong!',
text="Please check that input fields are valid",
size_hint=(0.8, None),
height=dp(200),
on_dismiss=lambda x: self.close_error())
self.dialog.open()
def close_error(self):
"""closes error dialog"""
app = MDApp.get_running_app()
app.film_view_model.close_error()
def show_film_thickness(self, film_thickness):
"""Bound to 'THICKNESS' property in volume_view_model"""
self.ids.result.text = (
f'Film Thickness is approximately [b][color=#ff3300]{film_thickness}[/color][/b]'
)
class HistoryRoot(FloatLayout):
"""Root widget of the history screen."""
speed_dial_buttons = DictProperty()
speed_dial = ObjectProperty()
export_cookbook = export_cookbook
def __init__(self, **kwargs):
self.speed_dial_buttons = self.export_cookbook.to_button_dict()
super().__init__(**kwargs)
Clock.schedule_once(self.__post_init__)
def __post_init__(self, *_):
self.speed_dial.icon = "content-save"
self.dropdown_menu = MDDropdownMenu(
caller=self.ids.history_list,
position="center",
width_mult=4,
items=[
{
"text": "back to queue"
},
{
"text": "delete"
},
{
"text": "edit"
},
],
)
self.dropdown_menu.on_release = self.on_dropdown_item
self.text_input_dialog = TextInputDialog(title="Edit Word:")
self.text_input_dialog.callback = self.text_input_dialog_callback
# self.dropdown_menu.bind(on_release=self.on_dropdown_item)
@staticmethod
def filter(*_):
"""Placeholder-function."""
not_implemented_toast()
@staticmethod
def sort(*_):
"""Placeholder-function."""
not_implemented_toast()
def click_on_item(self, item, *_):
"""Open dropdown menu with ``item`` as caller."""
self.dropdown_menu.caller = item
self.dropdown_menu.open()
def on_dropdown_item(self, item, *_):
"""Call option corresponding to clicked item."""
caller = self.dropdown_menu.caller
if item.text == "delete":
self.delete_item(caller.text)
elif item.text == "edit":
self.edit_item(caller.text)
else:
self.move_back_to_queue(caller.text)
self.dropdown_menu.dismiss()
@staticmethod
def delete_item(item):
"""Delete ``text`` from the current template in the data-base and from ``app.word_state_dict``."""
app = MDApp.get_running_app()
del app.word_state_dict[item]
with db_session:
app.get_current_template_db().get_card(item).delete()
@app_busy
def edit_item(self, item):
"""Open :attr:`text_input_dialog` to edit the word."""
self.text_input_dialog.default_text = item
self.text_input_dialog.open()
@staticmethod
def move_back_to_queue(item):
"""Move item back to queue."""
old_state = MDApp.get_running_app().word_state_dict[item]
new_state = "waiting" if old_state == "error" else "ready"
set_word_state(item, new_state)
def text_input_dialog_callback(self, button_txt, text):
"""If the ``OK``-button is pressed, delete old entry and add edited entry to queue."""
if button_txt == "OK":
self.delete_item(self.text_input_dialog.default_text)
set_word_state(text, "waiting")
class MyFirstApp(MDApp):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.screen = Builder.load_string(KV)
years = [{
"text": f"{i}"
} for i in ['1st Year', '2nd Year', '3rd Year', '4th Year']]
self.YearMenu = MDDropdownMenu(caller=self.screen.ids.year,
items=years,
position="bottom",
callback=self.set_year,
width_mult=100,
border_margin=0)
branches = [{
"text": f"{i}"
} for i in ['CSE', 'ECE', 'Mechanical', 'Civil']]
self.BranchMenu = MDDropdownMenu(
caller=self.screen.ids.branch,
items=branches,
position="bottom",
callback=self.set_branch,
width_mult=4,
)
def set_year(self, instance):
def set_year(interval):
self.screen.ids.year.text = instance.text
self.YearMenu.dismiss()
Clock.schedule_once(set_year, 0.5)
def set_branch(self, instance):
def set_branch(interval):
self.screen.ids.branch.text = instance.text
self.BranchMenu.dismiss()
Clock.schedule_once(set_branch, 0.5)
def build(self):
return self.screen
def ShowEntries(self):
self.root.ids.screen_manager.current = 'ViewEntries'
def ShowInfo(self):
self.root.ids.screen_manager.current = 'EntryInfo'
def ShowDel(self):
self.root.ids.screen_manager.current = 'del'
def ShowGetDetails(self):
self.root.ids.screen_manager.current = 'details'
def AddStudent(self):
name = self.root.ids.name.text
year = self.root.ids.year.text
branch = self.root.ids.branch.text
rollno = self.root.ids.rollno.text
mobile = self.root.ids.mobile.text
if str(mobile) != '':
stu = student(name, year, branch, rollno.lower(), mobile)
sqlite_database.add_student(stu)
Snackbar(text="Student Added").show()
self.root.ids.name.text = ''
self.root.ids.year.text = ''
self.root.ids.branch.text = ''
self.root.ids.rollno.text = ''
self.root.ids.mobile.text = ''
else:
Snackbar(text="Please fill in all the details").show()
def DeleteEntry(self):
del_stu = self.root.ids.del_stu.text
sqlite_database.delete_student(del_stu.lower())
Snackbar(text="Deleted successfully").show()
self.root.ids.del_stu.text = ''
def GetDetails(self):
get_rollno = self.root.ids.get_stu.text
try:
list_details = list(sqlite_database.get_student(get_rollno))
if list_details[0] != '':
name = list_details[0]
year = list_details[1]
branch = list_details[2]
rollno = list_details[3]
mobile = list_details[4]
self.ShowInfo()
self.root.ids.name_text.text = 'Name : ' + name
self.root.ids.year_text.text = 'Year : ' + year
self.root.ids.branch_text.text = 'Branch : ' + branch
self.root.ids.rollno_text.text = 'Roll No. : ' + rollno
self.root.ids.mobile_text.text = 'Phone No. : ' + str(
mobile)
except:
Snackbar(text="Student Not Found").show()
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 Container(BoxLayout):
def __init__(self, change_theme, **kwargs):
super().__init__(**kwargs)
self.flag = True
self.atb_model = None
self.text_view = None
self.audio_view = None
self.change_theme = change_theme
self.theme = 'Green'
self.cur_ref = None
self.vol_popup = self.VolumePopup()
self.vol_popup.bind(volume=self.change_volume)
self.vol_popup.separator_color = [0, 0, 0, 1]
self.vol_popup.background = '../images/back.jpg'
self.vol_popup.title_color = [0, 0, 0, 1]
self.go_to_audio_popup = Popup(title="",
content=self.GoToAudio(func=self.go_to_pos_audio, color=self.get_color),
size_hint=(0.15, 0.15), separator_color=[0, 0, 0, 1], title_size='0')
self.file_popup = None
file_menu_items = [{"icon": "git", "text": f"Import book"}, {"icon": "git", "text": f"Open atb file"}]
self.file_menu = MDDropdownMenu(
caller=self.file_btn,
items=file_menu_items,
callback=self.set_item,
width_mult=4,
)
nav_menu_items = [{"icon": "git", "text": f"Go to begin"}, {"icon": "git", "text": f"Go to end"},
{"icon": "git", "text": f"Go to Page"}]
self.nav_menu = MDDropdownMenu(
caller=self.nav_btn,
items=nav_menu_items,
callback=self.nav_item,
width_mult=4,
)
font_menu_items = [{"icon": "git", "text": f"Font"}, {"icon": "git", "text": f"Font size"}]
self.font_menu = MDDropdownMenu(
caller=self.font_btn,
items=font_menu_items,
callback=self.font_item,
width_mult=4,
)
font_size_menu_items = [{"icon": "git", "text": f"Small"}, {"icon": "git", "text": f"Medium"},
{"icon": "git", "text": f"High"}]
self.font_size_menu = MDDropdownMenu(
caller=self.font_btn,
items=font_size_menu_items,
callback=self.font_size_item,
width_mult=4,
)
font_change_menu_items = [{"icon": "git", "text": f"Roboto"}, {"icon": "git", "text": f"DejaVuSans"}]
self.font_change_menu = MDDropdownMenu(
caller=self.font_btn,
items=font_change_menu_items,
callback=self.font_change_item,
width_mult=4,
)
view_menu_items = [{"icon": "git", "text": f"Theme color"}]
self.view_menu = MDDropdownMenu(
caller=self.view_btn,
items=view_menu_items,
callback=self.view_item,
width_mult=4,
)
theme_menu_items = [{"icon": "git", "text": f"Green"}, {"icon": "git", "text": f"Blue"},
{"icon": "git", "text": f"Dark"}]
self.theme_menu = MDDropdownMenu(
caller=self.view_btn,
items=theme_menu_items,
callback=self.theme_item,
width_mult=4,
)
lang_menu_items = [{"icon": "git", "text": f"English"}, {"icon": "git", "text": f"Русский"}]
self.lang_menu = MDDropdownMenu(
caller=self.view_btn,
items=lang_menu_items,
callback=self.lang_item,
width_mult=4,
)
self.go_to_page_dialog = MDDialog(
title="Enter the number of page",
type="custom",
content_cls=self.GoToPage(),
size_hint=[0.3, 0.5],
buttons=[
MDFlatButton(
text="CANCEL",
on_release=self.dismiss_page_dialog
),
MDRaisedButton(
text="OK",
on_release=self.go_to_page
),
],
)
Clock.schedule_interval(self.file_menu.set_menu_properties, 0.1)
Clock.schedule_interval(self.nav_menu.set_menu_properties, 0.1)
Clock.schedule_interval(self.font_menu.set_menu_properties, 0.1)
Clock.schedule_interval(self.font_size_menu.set_menu_properties, 0.1)
Clock.schedule_interval(self.font_change_menu.set_menu_properties, 0.1)
Clock.schedule_interval(self.view_menu.set_menu_properties, 0.1)
Clock.schedule_interval(self.theme_menu.set_menu_properties, 0.1)
Window.bind(on_resize=self.on_resize_window)
self.msg_dialog = None
self.cur_volume = 100
self.night_mode_on = False
self.event = None
self.mutex = threading.Lock()
self.progress = 0
self.event2 = None
self.cs = [0.117, 0.053, 0.09, 0.042, 0.077, 0.035]
self.font_size = 0
class Music(Sound):
def __init__(self, file, *args, **kwargs):
super().__init__(*args, **kwargs)
self.sound = SoundLoader.load(file)
class VolumePopup(Popup):
pass
class ChooseFile(FloatLayout):
select = ObjectProperty(None)
cancel = ObjectProperty(None)
fb2_is_load = ObjectProperty(False)
mp3_is_load = ObjectProperty(False)
fb2_path = ObjectProperty(None)
theme = ObjectProperty(None)
@staticmethod
def get_path():
return os.path.abspath(os.curdir)
def get_color(self, flag):
if flag:
hue = "600"
else:
hue = "800"
if self.theme == 'Blue':
return get_color_from_hex(colors["Blue"][hue])
if self.theme == 'Green':
return get_color_from_hex(colors["Green"][hue])
if self.theme == 'Dark':
return get_color_from_hex(colors["Gray"][hue])
class FileDialog(BoxLayout):
import_book = ObjectProperty(None)
open_atb = ObjectProperty(None)
class MessagePopup(BoxLayout):
close = ObjectProperty(None)
class LoadingBar(BoxLayout):
close = ObjectProperty(None)
func = ObjectProperty(None)
class GoToAudio(FloatLayout):
func = ObjectProperty(None)
color = ObjectProperty(None)
class GoToPage(BoxLayout):
pass
def change_text_r(self):
if self.text_view:
self.text_view.change_text_r()
def change_text_l(self):
if self.text_view:
self.text_view.change_text_l()
def play_or_stop(self):
if self.audio_view:
self.audio_view.play_or_stop()
def move_pos_audio(self, value):
if self.audio_view:
self.audio_view.move_pos_audio(value)
def next_audio(self):
if self.audio_view:
self.audio_view.next_audio()
def prev_audio(self):
if self.audio_view:
self.audio_view.prev_audio()
def volume_slider_open(self):
self.vol_popup.open()
def change_volume(self, instance, value):
self.cur_volume = value
if value == 0:
self.volume_btn.icon = 'volume-mute'
if 0 < value < 33:
self.volume_btn.icon = 'volume-low'
if 33 <= value < 66:
self.volume_btn.icon = 'volume-medium'
if 66 <= value <= 100:
self.volume_btn.icon = 'volume-high'
if self.audio_view:
self.audio_view.audio_file.sound.volume = value / 100
def ref_press(self, instance, ref):
self.cur_ref = int(ref)
print(ref, self.atb_model.word_list[self.cur_ref])
ind = self.text_view.find_page(self.cur_ref)
if not self.text_view.clean_word(ind):
self.go_to_audio_popup.open()
def go_to_book(self):
if self.atb_model:
# self.audio_file.sound.stop()
word_num = self.atb_model.get_word(self.audio_view.cur_audio,
self.audio_view.audio_file.sound.get_pos())
if not word_num:
return
ind = self.text_view.find_page(word_num)
self.text_view.clean_word(ind)
self.text_view.mark_word(ind, word_num)
if ind % 2 == 0:
self.left_page.text = self.text_view.pages[ind]
self.right_page.text = self.text_view.pages[ind + 1]
self.text_view.cur_page = ind
else:
self.left_page.text = self.text_view.pages[ind - 1]
self.right_page.text = self.text_view.pages[ind]
self.text_view.cur_page = ind - 1
def test_go_to_book(self, dt):
self.go_to_book()
def go_to_pos_audio(self):
self.go_to_audio_popup.dismiss()
pos = self.atb_model.get_sec(self.cur_ref)
if not pos:
return
if pos[0] != self.audio_view.cur_audio:
self.audio_view.audio_file.sound.unload()
self.audio_view.cur_audio = pos[0]
self.audio_view.audio_file = self.Music(self.audio_view.play_list[pos[0]])
self.audio_view.audio_file.sound.seek(pos[1])
self.time_label.text = self.audio_view.get_audio_len()
def import_book(self):
self.file_popup = Popup(title="Select .fb2 file", content=self.ChooseFile(select=self.select_fb2_mp3,
cancel=self.dismiss_popup,
theme=self.theme),
size_hint=(0.5, 0.6), background='../images/back.jpg', title_color=[0, 0, 0, 1],
title_align='center', separator_color=[1, 1, 1, 1])
self.file_popup.content.select_button.text = 'Select .fb2 file'
self.file_popup.open()
self.file_menu.dismiss()
def open_atb_file(self):
self.file_popup = Popup(title="Select .atb file", content=self.ChooseFile(select=self.select_atb,
cancel=self.dismiss_popup,
theme=self.theme),
size_hint=(0.5, 0.6), background='../images/back.jpg', title_color=[0, 0, 0, 1],
title_align='center', separator_color=[1, 1, 1, 1])
self.file_popup.content.select_button.text = 'Select .atb file'
self.file_popup.open()
self.file_menu.dismiss()
def select_atb(self, path, selection):
if selection and selection[0].endswith('.atb'):
self.dismiss_popup()
self.loading_label.size_hint = [0.07, 1]
self.spinner.color = [0, 0, 0, 1]
self.spinner.active = True
x = threading.Thread(target=self.import_atb, args=(selection[0], True))
x.start()
else:
self.show_msg('This is not .atb file')
def select_fb2_mp3(self, path, selection):
if not self.file_popup.content.fb2_is_load:
if selection and selection[0].endswith('.fb2'):
self.file_popup.content.fb2_path = selection[0]
self.file_popup.title = 'Select folder with mp3 files'
self.file_popup.content.select_button.text = 'Select folder'
self.file_popup.content.fb2_is_load = True
self.file_popup.content.filechooser.selection = []
else:
self.show_msg('This is not .fb2 file')
else:
if not selection:
mp3s = []
for fil in listdir(path):
if fil.endswith('.mp3'):
mp3s.append(fil)
if not mp3s:
self.show_msg('No mp3 files')
else:
mp3s.sort()
for i in range(len(mp3s)):
mp3s[i] = path + '/' + mp3s[i]
self.dismiss_popup()
book_path = self.file_popup.content.fb2_path
obj = Model()
obj.import_book(book_path, mp3s)
book_name = book_path.split('/')[-1].replace('.fb2', '')
x = threading.Thread(target=self.load_book,
args=('books/' + book_name + '/' + book_name + '_data' + '.atb',))
x.start()
else:
self.show_msg('This is not a folder')
def load_book(self, path):
self.import_atb(path, False)
#self.make_mapping()
def update_bar(self, dt):
self.mutex.acquire()
self.loading_label.text = 'Sync: ' + str(self.atb_model.get_len_word_sec()) + '%'
self.mutex.release()
def make_mapping(self):
self.event2 = Clock.schedule_interval(self.update_bar, 0.1)
self.atb_model.make_mapping()
self.event2.cancel()
self.loading_label.size_hint = [0.1, 1]
self.spinner.active = False
self.loading_label.text = 'Done!'
def on_resize_window(self, window, width, height):
if self.text_view:
if self.event:
self.event.cancel()
self.event = Clock.schedule_once(self.text_view.change_text, 0.3)
def import_atb(self, path, flag):
self.loading_label.text = "Loading..."
self.loading_label.size_hint = [0.07, 1]
self.spinner.color = [0, 0, 0, 1]
self.spinner.active = True
self.atb_model = Model()
self.atb_model.load(path)
if flag:
self.atb_model.load_map()
self.text_view = TextView(self.atb_model.get_text(), self.left_page, self.right_page)
self.audio_view = AudioView(self.atb_model.get_audio_list(), self.music_button, self.time_label,
self.cur_volume, self.slider)
self.move_slider()
self.cur_ref = 0
if flag:
self.loading_label.size_hint = [0.1, 1]
self.loading_label.text = "Done!"
self.spinner.active = False
def night_mode(self):
if not self.night_mode_on:
self.left_page.background_color = self.get_color('Gray', '800')
self.left_page.color = [1, 1, 1, 1]
self.right_page.background_color = self.get_color('Gray', '800')
self.right_page.color = [1, 1, 1, 1]
self.night_mode_on = True
else:
self.left_page.background_color = [1, 1, 1, 1]
self.left_page.color = [0, 0, 0, 1]
self.right_page.background_color = [1, 1, 1, 1]
self.right_page.color = [0, 0, 0, 1]
self.night_mode_on = False
def move_slider(self):
Clock.schedule_interval(self.audio_view.timer_callback, 1)
return 0
def dismiss_popup(self):
self.file_popup.dismiss()
def show_msg(self, msg):
self.msg_dialog = MDDialog(
title=msg,
size_hint=[0.3, 0.5],
buttons=[
MDRaisedButton(
text="OK",
on_release=self.close_dialog
),
],
)
self.msg_dialog.open()
def close_dialog(self, instance):
self.msg_dialog.dismiss()
def close_loading_bar(self):
self.loading_popup.dismiss()
def run_test_go_to_book(self):
Clock.schedule_interval(self.test_go_to_book, 0.5)
@staticmethod
def get_color(name, num):
return get_color_from_hex(colors[name][num])
def set_item(self, instance):
if instance.text == 'Open atb file':
self.open_atb_file()
else:
self.import_book()
def nav_item(self, instance):
if self.text_view:
if instance.text == 'Go to begin':
self.text_view.cur_page = 0
if len(self.text_view.pages) > 0:
self.left_page.text = self.text_view.pages[0]
if len(self.text_view.pages) > 1:
self.right_page.text = self.text_view.pages[1]
if instance.text == 'Go to end':
if len(self.text_view.pages) % 2 == 0:
self.text_view.cur_page = len(self.text_view.pages) - 2
self.left_page.text = self.text_view.pages[len(self.text_view.pages) - 2]
self.right_page.text = self.text_view.pages[len(self.text_view.pages) - 1]
else:
self.text_view.cur_page = len(self.text_view.pages) - 1
self.left_page.text = self.text_view.pages[len(self.text_view.pages) - 1]
self.right_page.text = ''
if instance.text == 'Go to Page':
self.nav_menu.dismiss()
self.go_to_page_dialog.content_cls.field.text = str(self.text_view.cur_page + 1)
self.go_to_page_dialog.content_cls.label.text = 'of ' + str(len(self.text_view.pages))
self.go_to_page_dialog.open()
def font_item(self, instance):
if instance.text == 'Font':
self.font_menu.dismiss()
self.font_change_menu.open()
else:
self.font_menu.dismiss()
self.font_size_menu.open()
def font_size_item(self, instance):
if instance.text == 'Small':
self.left_page.font_size = '16sp'
self.right_page.font_size = '16sp'
self.change_text(self.cs[0], self.cs[1])
self.font_size = 0
if instance.text == 'Medium':
self.left_page.font_size = '20sp'
self.right_page.font_size = '20sp'
self.change_text(self.cs[2], self.cs[3])
self.font_size = 1
if instance.text == 'High':
self.left_page.font_size = '24sp'
self.right_page.font_size = '24sp'
self.change_text(self.cs[4], self.cs[5])
self.font_size = 2
def font_change_item(self, instance):
if instance.text == 'Roboto':
self.left_page.font_name = 'fonts/Roboto-Regular'
self.right_page.font_name = 'fonts/Roboto-Regular'
self.cs = [0.117, 0.053, 0.09, 0.042, 0.077, 0.035]
self.change_text(self.cs[self.font_size * 2], self.cs[self.font_size * 2 + 1])
else:
self.left_page.font_name = 'fonts/DejaVuSans'
self.right_page.font_name = 'fonts/DejaVuSans'
self.cs = [0.105, 0.053, 0.085, 0.041, 0.07, 0.035]
self.change_text(self.cs[self.font_size * 2], self.cs[self.font_size * 2 + 1])
def change_text(self, c1, c2):
if self.text_view:
self.text_view.const1 = c1
self.text_view.const2 = c2
self.text_view.change_text(0)
def view_item(self, instance):
if instance.text == 'Theme color':
self.view_menu.dismiss()
self.theme_menu.open()
else:
self.view_menu.dismiss()
self.lang_menu.open()
def theme_item(self, instance):
if instance.text == 'Green':
self.change_theme('LightGreen', '300')
self.theme = 'Green'
self.up_bar.md_bg_color = self.get_color('LightGreen', '300')
self.play_layout.md_bg_color = self.get_color('LightGreen', '300')
self.slider.thumb_color_down = [0, 0, 0, 1]
self.vol_popup.slider_id.thumb_color_down = [0, 0, 0, 1]
if instance.text == 'Blue':
self.change_theme('LightBlue', '300')
self.theme = 'Blue'
self.up_bar.md_bg_color = self.get_color('LightBlue', '300')
self.play_layout.md_bg_color = self.get_color('LightBlue', '300')
self.slider.thumb_color_down = [0, 0, 0, 1]
self.vol_popup.slider_id.thumb_color_down = [0, 0, 0, 1]
if instance.text == 'Dark':
self.change_theme('Gray', '500')
self.theme = 'Dark'
self.up_bar.md_bg_color = self.get_color('Gray', '500')
self.play_layout.md_bg_color = self.get_color('Gray', '500')
self.slider.thumb_color_down = [0, 0, 0, 1]
self.vol_popup.slider_id.thumb_color_down = [0, 0, 0, 1]
def lang_item(self, instance):
pass
def go_to_page(self, instance):
page = int(self.go_to_page_dialog.content_cls.field.text) - 1
if page >= len(self.text_view.pages):
return
self.text_view.cur_page = page - (page % 2)
self.left_page.text = self.text_view.pages[self.text_view.cur_page]
if self.text_view.cur_page + 1 < len(self.text_view.pages):
self.right_page.text = self.text_view.pages[self.text_view.cur_page + 1]
else:
self.right_page.text = ''
def dismiss_page_dialog(self, instance):
self.go_to_page_dialog.dismiss()
def close_go_to_page_popup(self):
self.go_to_page_popup.dismiss()
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 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"
