class KitchenSinkFileManager(Screen): manager_open = False file_manager = None def file_manager_open(self): def open_file_manager(text_item): preview = False if text_item == "List" else True if not self.file_manager: self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, preview=preview, ) self.file_manager.preview = preview if manager_type_dialog.allow_multiple_selection: self.file_manager.selector = "multi" else: self.file_manager.selector = "any" self.file_manager.show(MDApp.get_running_app().user_data_dir) self.manager_open = True manager_type_dialog = KitchenSinkFileFileManagerTypeDialog() MDDialog( title="Kitchen Sink", type="custom", size_hint=(0.8, 0.4), content_cls=manager_type_dialog, buttons=[ MDFlatButton(text="List", on_release=lambda x: open_file_manager("List")), MDFlatButton( text="Preview", on_release=lambda x: open_file_manager("Preview"), ), ], ).open() 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() if type(path) == str: toast(path) else: toast(", ".join(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()
class Example(MDApp): def __init__(self, **kwargs): super().__init__(**kwargs) Window.bind(on_keyboard=self.events) self.manager_open = False self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, # previous=True, ) def build(self): return Builder.load_string(KV) def file_manager_open(self): self.file_manager.show('/') # output manager to the screen self.manager_open = True def select_path(self, path): self.exit_manager() toast(path) def exit_manager(self, *args): self.manager_open = False self.file_manager.close() def events(self, instance, keyboard, keycode, text, modifiers): if keyboard in (1001, 27, 8): if self.manager_open: self.file_manager.back() return True
class FileApp(MDApp): def __init__(self, **kwargs): super().__init__(**kwargs) self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, ) self.file_manager.ext = ['.csv', '.CSV', '.xlsx', '.XLSX'] 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 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() self.root.get_screen(self.root.current).ids.file_chooser.text = path self.filePath = path def file_manager_open(self): self.file_manager.show('/') # output manager to the screen self.manager_open = True def build(self): return Builder.load_string(kv)
class AddSourceDialogContent(MDBoxLayout): fileManager = None fileManagerStartingFolder = '/Users\\Edvein\\Downloads' imagePath = StringProperty() sourceName = StringProperty() def chooseImage(self): self.createFileManager() self.fileManager.show(self.fileManagerStartingFolder) def createFileManager(self): if not self.fileManager: self.fileManager = MDFileManager( exit_manager=self.onFileManagerExit, select_path=self.onFileManagerSelectPath, # preview=True # I HATE KIVYMD # https://github.com/kivymd/KivyMD/issues/531 ) def onFileManagerExit(self, *args): self.fileManager.close() def onFileManagerSelectPath(self, path): self.onFileManagerExit() # TODO Check if path is image and file at all print(path) self.imagePath = path self.ids.imageField.icon = '' self.ids.imageField.source = path
class MyApp(MDApp): def __init__(self): super().__init__() self.manager_open = False self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, preview=False, ) def file_manager_open(self): self.file_manager.show('.') self.manager_open = True def select_path(self, path): self.exit_manager() toast(path) def exit_manager(self, *args): print(args) self.manager_open = False self.file_manager.close() def build(self): return Builder.load_string(KV)
class KitchenSinkFileManager(Screen): manager_open = False file_manager = None def file_manager_open(self): from kivymd.app import MDApp from kivymd.uix.filemanager import MDFileManager from kivymd.uix.dialog import MDDialog from kivymd.uix.button import MDFlatButton def open_file_manager(text_item): preview = False if text_item == "List" else True if not self.file_manager: self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, preview=preview, ) self.file_manager.preview = preview self.file_manager.show(MDApp.get_running_app().user_data_dir) self.manager_open = True MDDialog( title="Kitchen Sink", size_hint=(0.8, 0.4), text="Open manager with 'list' or 'previous' mode?", buttons=[ MDFlatButton(text="List", on_release=lambda x: open_file_manager("List")), MDFlatButton( text="Previous", on_release=lambda x: open_file_manager("Preview"), ), ], ).open() 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; """ from kivymd.toast import toast self.exit_manager() toast(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()
class MainApp(MDApp): def build(self): manager = ScreenManager() manager.add_widget(Login(name='login_window')) manager.add_widget(Registration(name='register_window')) manager.add_widget(HomeWindow(name='home_window')) manager.add_widget(SettingsWindow(name='settings')) manager.add_widget(GroupWindow(name='group_window')) manager.add_widget(NewGroupWindow(name='new_group_window')) manager.add_widget(ActivityWindow(name='activity_window')) manager.add_widget(NewActivityWindow(name='new_activity_window')) manager.add_widget(JoinGroupWindow(name='join_group_window')) manager.add_widget(ActivityDetailWindow(name='activity_detail_window')) manager.add_widget(PaymentWindow(name='payment_window')) manager.add_widget(MyTransactionWindow(name='my_transaction_window')) manager.add_widget(ApprovalsWindow(name='approvals_window')) manager.add_widget(AddResourcesWindow(name='new_resource_window')) self.theme_cls.primary_palette = 'Blue' self.theme_cls.theme_style = "Light" self.title="Aaksathe" return manager # Below all functions are used to handle file manager def __init__(self, **kwargs): super().__init__(**kwargs) Window.bind(on_keyboard=self.events) self.manager_open = False self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, #previous=True, ) 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; ''' print(path) self.exit_manager() toast(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
class Example(MDApp): dialog = None def __init__(self, **kwargs): super().__init__(**kwargs) Window.bind(on_keyboard=self.events) self.manager_open = False self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, # previous=True, ) def build(self): return Builder.load_string(KV) 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() toast(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): """Called when buttons are pressed on the mobile device.""" if keyboard in (1001, 27): if self.manager_open: self.file_manager.back() return True def navigation_draw(self): self.dialog = MDDialog( title="Fake detector is an app that helps you detect fake currency", size_hint=(0.7, 1)) self.dialog.open()
class Recetas(MDBoxLayout): def __init__(self, **kwargs): super().__init__(**kwargs) Window.bind(on_keyboard=self.events) # my_path = str(storagepath.get_pictures_dir()) self.manager_open = False self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, preview=True, ) 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() toast(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 def btn(self): print(str(storagepath.get_pictures_dir())) self.ids.fotos_label.text = str(storagepath.get_pictures_dir()) pass
class MainApp(MDApp): def __init__(self=None, **kwargs): self.title = "FLOW OF THOUGHTS" self.theme_cls.theme_style = "Light" self.theme_cls.primary_palette = "Indigo" super().__init__(**kwargs) con = sql.connect(blog_db) cur = con.cursor() cur.execute(create_content_query) cur.execute(create_users_query) cur.execute(first_user_query, (admin_email, admin_password, 1)) cur.execute(create_log_query) con.commit() con.close() self.manager_open = False self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, previous=True, ) def on_checkbox_active(self, checkbox, value): global isprivate if value: isprivate = 1 else: isprivate = 0 def file_manager_open(self): self.file_manager.show('/') self.manager_open = True def select_path(self, path): global blob_path blob_path = path self.exit_manager() toast(path) def exit_manager(self): self.manager_open = False self.file_manager.close() def events(self, instance, keyboard, keycode, text, modifiers): if keyboard in (1001, 27): if self.manager_open: self.file_manager.back() return True
class KitchenSinkFileManager(Screen): manager_open = False file_manager = None def file_manager_open(self): from kivymd.uix.filemanager import MDFileManager from kivymd.uix.dialog import MDDialog def open_file_manager(text_item, dialog): previous = False if text_item == "List" else True if not self.file_manager: self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, ) self.file_manager.previous = previous self.file_manager.show(os.getcwd()) self.manager_open = True MDDialog( title="Kitchen Sink", size_hint=(0.8, 0.4), text_button_ok="List", text="Open manager with 'list' or 'previous' mode?", text_button_cancel="Previous", events_callback=open_file_manager, ).open() 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; """ from kivymd.toast import toast self.exit_manager() toast(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()
class VChat(MDApp): def __init__(self, **kwargs): super().__init__(**kwargs) Window.bind(on_keyboard=self.events) self.manager_open = False self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, ) self.file_manager.ext = [] def build(self): return Builder.load_string(KV) 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() print(path) toast(path) path = "D:" + path self.start_music(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 def start_music(self, path): sound = SoundLoader.load(path) if sound: sound.play()
class GincellApp(MDApp): path_label = ObjectProperty(None) def __init__(self, **kwargs): super().__init__(**kwargs) Window.bind(on_keyboard=self.events) self.manager_open = False self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, previous=False, ) self.file_manager.ext = ['.xlsx'] def confirm_text(self): toast("Staks in progress...") def file_manager_open(self): self.file_manager.show( '/home/sveta/programming/git') #('/data/media/0') self.manager_open = True def select_path(self, path): self.t = str(path) self.exit_manager() toast(self.t) self.path_label.text = self.t def exit_manager(self, *args): self.manager_open = False self.file_manager.close() def events(self, instance, keyboard, keycode, text, modifiers): if keyboard in (1001, 27): if self.manager_open: self.file_manager.back() return True def build(self): self.theme_cls.theme_style = "Dark" self.theme_cls.primary_palette = "Orange" screen = Builder.load_string(KV) return screen
class PdfApp(MDApp): selected_imgs_path_list = [] def __init__(self, **kwargs): super().__init__(**kwargs) # Window.bind(on_keyboard=self.events) self.theme_cls.primary_palette = "Green" self.manager_open = False self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, preview=True, ) def build(self): return def open_filemanager(self): self.file_manager.show("/") self.manager_open = True def select_path(self, list_path): self.jay = list_path print(self.jay) def exit_manager(self, list=None, *args): if "selection_done" in args: self.select_path(list) self.manager_open = False self.file_manager.close() def change_screen(self, name, *args): if "is_drawer_call" in args: self.root.ids.manager.transition.direction = "right" self.root.ids.manager.current = name # self.root.ids.nav_drawer.set_state('close') else: self.root.ids.manager.transition.direction = "right" self.root.ids.manager.current = name
class ParseScreen(ThemableBehavior, Screen): title = StringProperty() def __init__(self, **kwargs): super().__init__(**kwargs) self.groups_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] self.selected = 3 self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, ) for group in self.groups_data: self.ids.group_list.add_widget( AppTwoLineLeftIconItem( text=str(group) + ' User name', icon='settings', secondary_text='Face', on_release=lambda widget=self, _group=group: self. set_active_group(widget, _group))) def set_active_group(self, widget, group): self.selected = group for child in self.ids.group_list.children: child.bg_color = [0, 0, 0, 0] widget.bg_color = [0, 0, 0, 0.3] self.ids.group_label.text = 'Group ' + str(group) def save_scv(self): self.file_manager.show(expanduser("~")) def select_path(self, path): self.exit_manager() if type(path) == str: toast(path) else: toast(",".join(path)) def exit_manager(self, **args): self.file_manager.close()
class Screen1(Screen): def __init__(self, *args, **kwargs): super(Screen1, self).__init__(**kwargs) entries = os.listdir('codigo/Empresas') for i in [*entries]: self.ids.wig.add_widget(Lista(i)) Window.bind(on_keyboard=self.events) self.manager_open = False self.file_manager = MDFileManager( exit_manager=self. exit_manager, # function called when the user reaches directory tree root select_path=self.select_path, ext=[".py", "kv"], ) self.file_manager.ext = [".json"] def file_manager_open(self): self.file_manager.show('/') # output manager to the screen self.manager_open = True def select_path(self, path): self.exit_manager() shutil.copy(path, 'codigo/Empresas') self.ids.wig.clear_widgets() entries = os.listdir('codigo/Empresas') for i in [*entries]: self.ids.wig.add_widget(Lista(i)) toast(path) def exit_manager(self, *args): self.manager_open = False self.file_manager.close() def events(self, instance, keyboard, keycode, text, modifiers): if keyboard in (1001, 27): if self.manager_open: self.file_manager.back() return True
class ImageFilePicker: def __init__(self, **kwargs): super(ImageFilePicker, self).__init__(**kwargs) self.path = '/' self.filePath = "" self.acceptableFiles = (".png", ".jpg", ".jpeg", ".bmp", ".gif") self.file_manager = MDFileManager( exit_manager=lambda *args: self.file_manager.close(), select_path=self.select_path, ext=self.acceptableFiles, ) self.pictureButton = Builder.load_string(standard_icon_button) # type: MDRoundFlatIconButton self.pictureButton.bind(on_press=lambda instance: self.file_manager.show(self.path)) def select_path(self, *args): if args[0].endswith(self.acceptableFiles): self.filePath = args[0] self.pictureButton.icon = self.filePath else: self.path = args[0] self.file_manager.close()
class MainApp(MDApp): def __init__(self, **kwargs): self.title = "STEGANOGRAPHY" self.theme_cls.primary_palette = "Green" super().__init__(**kwargs) Window.bind(on_keyboard=self.events) self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, ) def build(self): self.root = Factory.AppUI() def file_manager_open(self): self.file_manager.show('/') self.manager_open = True def select_path(self, path): self.exit_manager() toast(path) def exit_manager(self, *args): self.manager_open = False self.file_manager.close() def events(self, instance, keyboard, keycode, text, modifiers): if keyboard in (1001, 27): if self.manager_open: self.file_manager.back() return True def process(self): ''' PROCESS VIET O DAY ''' pass
class HomeScreen(Screen): users_all = ListProperty(users) keys_all = ListProperty(keys) userid = StringProperty(EmailID) print(userid) def upload(self): path = '/' # path to the directory that will be opened in the file manager self.file_manager = MDFileManager( exit_manager=self. exit_manager_function, # function called when the user reaches directory tree root select_path=self. select_path_function # function called when selecting a file/directory ) self.file_manager.show(path) toast('Uploading May Take A few Seconds. Please Keep Patience') def exit_manager_function(self, obj): self.file_manager.close() def select_path_function(self, path): global FileNumber print( f'https://firebasestorage.googleapis.com/v0/b/memories-e4f33.appspot.com/o/Uploads%2F{EmailID}%2Ff{FileNumber}?alt=media' ) while True: try: urlopen( f'https://firebasestorage.googleapis.com/v0/b/memories-e4f33.appspot.com/o/Uploads%2F{EmailID}%2Ff{FileNumber}?alt=media' ) FileNumber += 1 except: break storage.child(f"Uploads/{EmailID}/f{FileNumber}").put(f"{path}") FileNumber += 1 toast(text='Photo Uploaded Successfully')
def show_filemanager_add_songs_location(self): """ Show a dialog to ask the name of the new song. :return: """ mode = False file_manager = MDFileManager( # ext=["mid", "midi"], search="all", exit_manager=lambda *args, **kwargs: (toast(f"Canceled"), file_manager.close()), select_path=lambda *args, **kwargs: (self.on_selected_path_filemanager(args, kwargs), file_manager.close()), previous=mode # Very special naming convention, False means listview-mode, True means Thumbnail mode ) file_manager.ext = CU.tfs.dic['MIDI_FILE_EXTENSIONS'].value file_manager.show(str(pl.Path(CU.tfs.dic['tf_workspace_path'].value / CU.tfs.dic['RAW_MIDI_DIR_NAME'].value)))
class ImportText(Screen): # For Android: # primary_ext_storage = data_dir imported_text = StringProperty('') text = None manager_open = False file_manager = None instructions_dialog = None text_loading_dialog = None new_text = None text_loading = None pdf_page_count = 0 import_progress = StringProperty('0%') def __init__(self, **kw): super().__init__(**kw) self.clear_temp_database() Window.bind(on_keyboard=self.android_back_button) def import_from_file(self): self.file_manager = MDFileManager(exit_manager=self.exit_manager, select_path=self.select_path) self.file_manager.ext = [ '.txt', '.pdf', '.mobi', '.epub', '.TXT', '.PDF', '.MOBI', '.EPUB' ] # For PC: self.file_manager.show('/') # For Android: # self.file_manager.show(self.primary_ext_storage) self.manager_open = True def select_path(self, path): self.exit_manager() text_file_path = path toast(text_file_path) if re.search(r'\S+.txt|\S+.pdf|\S+.mobi|\S+.epub', text_file_path, re.IGNORECASE): self.show_text_loading() else: return self.show_instructions( 'Wrong file type selected. Please choose another one.') try: thread_count = len(os.sched_getaffinity(0)) - 1 if len( os.sched_getaffinity(0)) > 3 else 3 except (AttributeError, NotImplementedError): thread_count = os.cpu_count() - 1 if os.cpu_count() > 3 else 3 executor = ThreadPoolExecutor(thread_count) executor.submit(partial(self.determine_file_type, text_file_path)) def exit_manager(self, *args): self.manager_open = False self.file_manager.close() def determine_file_type(self, text_file_path): if re.search(r'\S+.txt', text_file_path, re.IGNORECASE): self.import_txt_file(text_file_path) elif re.search(r'\S+.pdf', text_file_path, re.IGNORECASE): self.import_pdf_file(text_file_path) elif re.search(r'\S+.mobi', text_file_path, re.IGNORECASE): self.import_mobi_file(text_file_path) elif re.search(r'\S+.epub', text_file_path, re.IGNORECASE): self.import_epub_file(text_file_path) def import_txt_file(self, text_file_path): with open(text_file_path, encoding='utf-8-sig') as file: new_text = file.readlines() MDApp.get_running_app().root.get_screen( "importtext" ).ids.imported_text_field.text = f'{new_text[:1000]} ... ' self.text_loading_dialog.dismiss() self.save_temp_data(new_text) def import_pdf_file(self, text_file_path, obj=None): pdf_page_count = len(pdfplumber.open(text_file_path).pages) with pdfplumber.open(text_file_path) as pdf: for counter, page in enumerate(pdf.pages, start=1): import_progress = '{:.2f}'.format(counter / pdf_page_count * 100) counter += 1 self.text_loading.import_progress = f'Imported - {import_progress}%' new_text = str(page.extract_text()).replace('\n', ' ') self.save_temp_data(new_text) # We want to flush cache every loop to save as much RAM as possible. page.flush_cache() self.text_loading_dialog.dismiss() self.update_text_preview() def import_mobi_file(self, text_file_path): tempdir, filepath = mobi.extract(text_file_path) # If extracted MOBI file has extension TXT or HTML that means that everything worked properly. if re.search(r'\S+.txt|\S+.html', filepath, re.IGNORECASE): file = open(filepath, 'r', errors='ignore') content = file.read() new_text = html2text.html2text(content.replace('\\n', '')) self.save_temp_data(new_text) shutil.rmtree(tempdir, ignore_errors=True) # In other case (for example extracted file has EPUB format) that means that MOBI file was encrypted and # content will be corrupted. else: self.text_loading_dialog.dismiss() self.show_instructions( 'Something went wrong :( The file provided cannot be processed. Please try another one.' ) self.update_text_preview() self.text_loading_dialog.dismiss() def import_epub_file(self, text_file_path): book = epub.read_epub(text_file_path) epub_page_count = len(book.items) for counter, item in enumerate(book.get_items(), start=1): import_progress = '{:.2f}'.format(counter / epub_page_count * 100) counter += 1 self.text_loading.import_progress = f'Imported - {import_progress}%' if item.get_type() == ebooklib.ITEM_DOCUMENT: new_text = html2text.html2text( str(item.get_content()).replace('\\n', '')) self.save_temp_data(new_text) self.update_text_preview() self.text_loading_dialog.dismiss() def save_new_text(self): text_title = MDApp.get_running_app().root.get_screen( 'importtext').ids.imported_text_title_field.text text_author = MDApp.get_running_app().root.get_screen( 'importtext').ids.imported_text_author_field.text text_body_preview = MDApp.get_running_app().root.get_screen( 'importtext').ids.imported_text_field.text if text_title == '': return self.show_instructions('Please add title.') if text_body_preview == ' (import text to see preview ...)' or text_body_preview == '': return self.show_instructions('Please add text.') try: text_type = MDApp.get_running_app().root.get_screen( 'importtext').imported_text_type except AttributeError: return self.show_instructions('Please select text type.') connection = sqlite3.connect( os.path.join(getattr(MDApp.get_running_app(), 'user_data_dir'), 'read_runner.db')) cursor = connection.cursor() cursor.execute( 'INSERT INTO texts (text_body) SELECT text_body FROM temp_data') last_row_id = cursor.lastrowid cursor.execute( 'UPDATE texts SET text_position=0, text_progress=0, text_type=(?), text_title=(?), ' 'text_author=(?) WHERE text_id = (?)', (text_type, text_title, text_author, last_row_id)) connection.commit() connection.close() self.go_back() self.clear_temp_database() def show_instructions(self, warning_text): self.instructions_dialog = MDDialog( text=warning_text, pos_hint={ 'center_x': 0.5, 'center_y': 0.5 }, size_hint=(0.9, 0.8), buttons=[ MDFlatButton(text='CANCEL', on_release=self.close_instructions_dialog) ]) self.instructions_dialog.open() def close_instructions_dialog(self, obj): self.instructions_dialog.dismiss() def show_text_loading(self): self.text_loading = TextLoading() self.text_loading_dialog = MDDialog(type='custom', content_cls=self.text_loading, auto_dismiss=False) self.text_loading_dialog.open() def android_back_button(self, window, key, *largs): if key == 27: self.go_back() return True @staticmethod def import_from_clipboard(): imported_text = Clipboard.paste() MDApp.get_running_app().root.get_screen( "importtext" ).ids.imported_text_field.text = f'{imported_text[:1000]} ... ' @staticmethod def update_text_preview(): connection = sqlite3.connect( os.path.join(getattr(MDApp.get_running_app(), 'user_data_dir'), 'read_runner.db')) cursor = connection.cursor() cursor.execute('SELECT * from temp_data') new_text_preview = cursor.fetchone()[0][:1000] MDApp.get_running_app().root.get_screen( 'importtext' ).ids.imported_text_field.text = f'{new_text_preview} ... ' @staticmethod def save_temp_data(text_body): connection = sqlite3.connect( os.path.join(getattr(MDApp.get_running_app(), 'user_data_dir'), 'read_runner.db')) cursor = connection.cursor() cursor.execute( 'CREATE TABLE IF NOT EXISTS temp_data (text_body text, id integer primary key )' ) cursor.execute( 'INSERT INTO temp_data(text_body, id) VALUES (?, 1) ON CONFLICT (id) DO UPDATE SET text_body = text_body || (?)', (text_body, text_body)) connection.commit() @staticmethod def clear_temp_database(): connection = sqlite3.connect( os.path.join(getattr(MDApp.get_running_app(), 'user_data_dir'), 'read_runner.db')) cursor = connection.cursor() cursor.execute('DROP TABLE IF EXISTS temp_data') connection.commit() @staticmethod def go_back(): MDApp.get_running_app().root.get_screen( 'importtext').manager.transition.direction = 'right' MDApp.get_running_app().root.get_screen( 'importtext').manager.current = 'mainscreen' MDApp.get_running_app().root.get_screen( 'importtext').ids.imported_text_title_field.text = '' MDApp.get_running_app().root.get_screen( 'importtext').ids.imported_text_author_field.text = '' MDApp.get_running_app().root.get_screen( 'importtext' ).ids.imported_text_field.text = ' (import text to see preview ...)'
class MainApp(MDApp): entity = {} areas = [] def __init__(self, **kwargs): super().__init__(**kwargs) self.manager_open = False self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, preview=True, ) def build(self): self.title = 'GuazuApp' Window.size = ( 360, 640 ) # more common dimensions for mobiles, delete this for building screen = Builder.load_file('content.kv') # screen.current = "add_area" return screen def set_entity(self): entity_name = self.root.screens[0].ids.entity_name.text id_name = self.root.screens[0].ids.id_name.text if entity_name and id_name: self.entity['entity_name'] = entity_name self.entity['id_name'] = id_name self.root.current = "add_area" return show_dialog() def set_areas(self): add_area_screen = self.root.screens[1] area_name = add_area_screen.ids.area_name.text area_container_layout = add_area_screen.ids.area_container_layout area_container = add_area_screen.ids.area_container card_cointainer = add_area_screen.ids.card_area_cointainer card_cointainer.bind(minimum_width=card_cointainer.setter('width')) if area_name: self.areas.append(area_name) add_area_screen.ids.area_name.text = '' area_container_layout.size_hint = [1, .2] area_container.size_hint_y = .9 area_item = CardItem(label_text=area_name) area_item.id = uuid.uuid1() card_cointainer.add_widget(area_item) return show_dialog(msg='Please insert a name') def edit_area(self, area_id): print('Edited area was #' + str(area_id)) def delete_area(self, area_id): add_area_screen = self.root.screens[1] area_container = add_area_screen.ids.area_container card_cointainer = add_area_screen.ids.card_area_cointainer area_name = None # for child in card_cointainer.children: if child.id == area_id: area_name = child.label_text card_cointainer.remove_widget(child) if area_name: self.areas.remove(area_name) if len(self.areas) < 1: area_container.size_hint = [0, .2] def validate_areas(self): areas = self.areas if len(areas) < 1: show_dialog(msg='Please add at least one Area') return self.root.current = "add_whatsapp" def validate_phone(self): add_whatsapp_screen = self.root.screens[2] country_code = add_whatsapp_screen.ids.country_code.text whatsapp_number = add_whatsapp_screen.ids.whatsapp_number.text if country_code and whatsapp_number: self.root.current = "validate_whatsapp" return show_dialog() def show_more_options(self): new_entity_screen = self.root.screens[0] more_options_button = new_entity_screen.ids.more_options_button # more_options_container = new_entity_screen.ids.more_options_container publish_button = new_entity_screen.ids.publish_button create_group_button = new_entity_screen.ids.create_group_button add_areas_button = new_entity_screen.ids.add_areas_button # create_entity_button = new_entity_screen.ids.create_entity_button # new_entity_float_layout = new_entity_screen.ids.new_entity_float_layout # more_options_container.size_hint_y = 1 more_options_container.opacity = 1 more_options_button.size_hint_y = 0 more_options_button.text = "" publish_button.disabled = False create_group_button.disabled = False add_areas_button.disabled = False # new_entity_float_layout.height += 400 create_entity_button.pos_hint = {'center_x': 0.5, 'center_y': .23} # #### FileManager #### # def upload_image(self, touch, image): """ Be careful! To use the / path on Android devices, you need special permissions. Therefore, you are likely to get an error. """ if not image.collide_point(*touch.pos): return path = "" operative_system = platform if operative_system == "win": path = 'C:/Users/PC/Downloads/' if operative_system == "linux": path = '/' if operative_system == "android": path = '/' self.file_manager.show(path) # 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; """ new_entity_screen = self.root.screens[0] image_thumbnail = new_entity_screen.ids.image_thumbnail image_thumbnail.source = path self.exit_manager() self.manager_open = False toast(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 def close_app(self): self.get_running_app().stop()
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 TesseractOnlineController(Controller): """ Controller class to manage image selector screen """ def __init__(self, screen): super().__init__(screen) self.screen = screen self.psms = [ ' 0 Orientation and script detection (OSD) only.', ' 1 Automatic page segmentation with OSD.', ' 2 Automatic page segmentation, but no OSD, or OCR. (not implemented)', ' 3 Fully automatic page segmentation, but no OSD. (Default)', ' 4 Assume a single column of text of variable sizes.', ' 5 Assume a single uniform block of vertically aligned text.', ' 6 Assume a single uniform block of text.', ' 7 Treat the image as a single text line.', ' 8 Treat the image as a single word.', ' 9 Treat the image as a single word in a circle.', ' 10 Treat the image as a single character.', ' 11 Sparse text. Find as much text as possible in no particular order.', ' 12 Sparse text with OSD.', ' 13 Raw line. Treat the image as a single text line, bypassing hacks that are Tesseract-specific.' ] self.init_dropdown() self.tessprofile_menu = screen.tessprofile_menu self.output_manager = MDFileManager( exit_manager=self.exit_output_manager, select_path=self.select_output, ext=[""], ) self.selected_output_folder = None self.screen.recognize_button.bind(on_release=self.recognize_thread) self.screen.jobs_button.bind(on_release=self.switch_jobs) self.screen.model.bind( on_release=get_app().image_selection_online_controller.get_model) #elf.modelinfos = get_modelinfos() self.print_on_screen = False self.ocr_event = None self.ocr_stop = False self.last_rec_time = time.time() # Context menu self.screen.context_menu.ids.recognize_ctx.bind( on_release=self.recognize_single_thread) # Load default settings self.load_default_settings() def load_default_settings(self): for profile, profileparam in get_app().tessprofiles_online.items(): if profileparam['default'] == True: self.load_tessprofile(profileparam) def stop_rec(self, instance): """ Unschedule progress event and log total execution time """ if self.ocr_event: self.ocr_stop = True logger.info(f'Recognizer: Canceled!') def init_dropdown(self): screen = self.screen # Init dropdownsettingsmenu self.psm_menu = self.create_dropdown( screen.psm, [{ "viewclass": "OneLineListItem", 'text': 'PSM: ' + psm, 'on_release': partial(self.set_psm, 'PSM: ' + psm) } for psm in self.psms]) def disable_rec(self, instance, *args): self.screen.recognize_button.disabled = True def enable_rec(self, instance, *args): self.screen.recognize_button.disabled = False def recognize_thread(self, instance, *args, file_list=None, profile=None): self.disable_rec(instance, *args) self.ocr_event = threading.Thread(target=self.recognize, args=(instance, args), kwargs={ 'file_list': file_list, 'profile': profile }) self.ocr_event.setDaemon(True) self.ocr_event.start() return self.ocr_event def recognize_single_thread(self, instance, *args, file_list=None, profile=None): self.disable_rec(instance, *args) instance.parent.hide() self.ocr_single_event = threading.Thread( target=self.recognize, args=(instance, args), kwargs={ 'file_list': instance.selected_image.original_source, 'profile': profile }) self.ocr_single_event.setDaemon(True) self.ocr_single_event.start() return self.ocr_single_event def recognize(self, instance, *args, file_list=None, profile=None): """ Recognize image with tesseract """ if profile is None: profile = {} if file_list is None: file_list = get_app().image_selection_online_controller.file_list if not file_list: alert(f'Select images to recognize') self.enable_rec(instance) return logger.info(f'Main: Recognize {len(file_list)} images') model = profile.get( "model", "eng" if self.screen.model.current_item == '' else self.screen.model.current_item.split(": ")[1].strip()) psm = profile.get( "psm", "3" if self.screen.psm.current_item == '' else self.screen.psm.current_item.split(": ")[1].strip().split( ' ', 1)[0]) outputformats = ';'.join( profile.get("outputformats", self.active_outputformats())) if isinstance(file_list, str): print_on_screen = profile.get( "print_on_screen", self.screen.print_on_screen_chk.active) create_online_threadprocess("Start recognize online", ocr_image, file_list, model=model, psm=psm, outputformats=outputformats, print_on_screen=print_on_screen) else: jobname = profile.get( "jobname", "Job_01" if self.screen.jobname.text == '' else self.screen.jobname.text) jobname = re.sub(r"[\s,\.,!,/,\\]", "_", jobname) create_online_threadprocess( f"{jobname}: Upload images", ocr_bulk_of_images, jobname, file_list, model=model, psm=psm, outputformats=outputformats, overwrite=str(self.screen.overwrite_job_chk.active)) self.enable_rec(instance) def active_outputformats(self): return [ outputformat for outputformat in ['txt', 'hocr', 'alto', 'pdf', 'tsv'] if self.screen[outputformat].state == 'down' ] def on_tesssettings_click(self, *args): self.tessprofile_menu.show(*get_app().root_window.mouse_pos) def search_tessprofile(self): get_app().tessprofiles_controller.set_profiles() get_app().switch_screen('tessprofiles') def load_tessprofile(self, tessprofileparams): self.screen.model.set_item( f"Model: {tessprofileparams.get('model', 'eng')}") self.screen.psm.set_item( f"PSM: {self.psms[int(tessprofileparams['psm'])]}") for outputformat in ['txt', 'hocr', 'alto', 'pdf', 'tsv']: if outputformat in tessprofileparams['outputformat']: self.screen[outputformat.strip()].state = 'down' else: self.screen[outputformat.strip()].state = 'normal' self.screen.print_on_screen_chk.active = True if tessprofileparams[ 'print_on_screen'] == "True" else False return def save_tessprofile_dialog(self): def close_dialog(instance, *args): instance.parent.parent.parent.parent.dismiss() dialog = MDDialog( title="Name of the profile", type='custom', auto_dismiss=False, content_cls=MDTextField(text="", mode="rectangle"), buttons=[ MDFlatButton(text="SAVE", on_release=self.save_tessprofile), MDFlatButton(text="DISCARD", on_release=close_dialog), ], ) if get_app()._platform not in ['win32', 'win64']: # TODO: Focus function seems buggy in win dialog.content_cls.focused = True dialog.open() def save_tessprofile(self, instance): tessprofilename = instance.parent.parent.parent.parent.content_cls.text if tessprofilename != '': get_app().tessprofiles_online[tessprofilename] = { "model": self.screen.model.current_item.split(" ")[1] if self.screen.model.current_item.split(" ")[0] == "Model:" else "eng", "psm": "".join( [char for char in self.screen.psm.text if char.isdigit()]), "outputformat": self.active_outputformats(), "print_on_screen": str(self.screen.print_on_screen_chk.active), "default": False } write_tessprofiles(get_app().tessprofiles_online, online=True) instance.parent.parent.parent.parent.dismiss() def reset_settings(self): # TODO: Rework resetting self.reset_text(self.screen.model) self.reset_text(self.screen.psm) self.reset_ouputformat() self.screen.print_on_screen_chk.active = False def reset_text(self, instance): instance.text = instance.text + '!' instance.set_item('') instance.text = instance.text[:-1] def reset_ouputformat(self): self.screen.txt.state = 'normal' self.screen.alto.state = 'normal' self.screen.hocr.state = 'normal' self.screen.pdf.state = 'normal' self.screen.tsv.state = 'normal' def create_dropdown(self, caller, item): menu = MDDropdownMenu(caller=caller, items=item, position='bottom', width_mult=20) menu.bind() return menu def set_psm(self, text): self.screen.psm.set_item(text) self.psm_menu.dismiss() def select_output(self, path=None): '''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; ''' if path is None: return self.selected_output_folder = path self.screen.output.text = f"Selected output directory: {path}" self.exit_output_manager() def select_output_folder(self): self.output_manager.show("/") def exit_output_manager(self, *args): '''Called when the user reaches the root of the directory tree.''' self.output_manager.close() @staticmethod def switch_jobs(instance): get_app().jobs_controller.update_jobdata() get_app().switch_screen('jobs')
class ProjectApp(MDApp): def __init__(self, **kwargs): super().__init__(**kwargs) self.theme_cls.primary_palette = "Teal" self.dialog_change_theme = None self.toolbar = None self.data_screens = {} self.recording = False self.loading = True # Initialize file manager status self.manager_open = False self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, ) # Detect only .mp4 extensions self.file_manager.ext = [".mp4"] # Load the .kv file def build(self): Window.bind(on_request_close=self.on_request_close) Builder.load_file( f"{os.environ['PROJECT_ROOT']}/libs/kv/list_items.kv") return Builder.load_file( f"{os.environ['PROJECT_ROOT']}/libs/kv/start_screen.kv") # Executed after first rendering def on_start(self): """Creates a list of items with examples on start screen.""" # Select components that we would further manipulate self.video_player = self.root.ids["backdrop_front_layer"].ids[ "video_player"] self.display_manager = self.root.ids["backdrop_front_layer"].ids[ "display_manager"] self.slider = self.root.ids["backdrop_front_layer"].ids["slider"] self.slider.bind(value=self.on_value) # Create tmp directory if it does not yey exist if not os.path.exists('tmp'): os.makedirs('tmp') Builder.load_file( f"{os.environ['PROJECT_ROOT']}/libs/kv/dialog_change_theme.kv") # Executed when the app is closed def on_request_close(self, *args): print("on request close") folder = f"{os.environ['PROJECT_ROOT']}/tmp/" # Delete all files in tmp/ folder for filename in os.listdir(folder): file_path = os.path.join(folder, filename) try: if os.path.isfile(file_path) or os.path.islink(file_path): os.unlink(file_path) elif os.path.isdir(file_path): shutil.rmtree(file_path) except Exception as e: print('Failed to delete %s. Reason: %s' % (file_path, e)) self.stop() return True # ---------------------------------------------------------------------------- # # Preload videos functionality # # ---------------------------------------------------------------------------- # # Open file manager to select video def file_manager_open(self): self.file_manager.show( f"{os.environ['PROJECT_ROOT']}") # output manager to the screen self.manager_open = True # Select path for video 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() toast(path) # Set video path self.source_video_path = path # Select video player and display manager classes self.video_player.source = "" # Set default screen to loading screen self.display_manager.current = "loading_screen" self.loading = True # Render videos with different vocal percentages self.render_videos() # Call subprocess to prerender MV def render_videos(self): # Create process that preloads videos self.preloading_process = subprocess.Popen([ sys.executable, "-u", f"{os.environ['PROJECT_ROOT']}/utils/preload_videos.py" ], stdin=subprocess.PIPE, bufsize=1, universal_newlines=True) self.preloading_process.stdin.write(f"{self.source_video_path}\n") # Thread that checks if subprocess has ended check_preloading_process_thread = threading.Thread( target=self.set_video_path) check_preloading_process_thread.start() 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 callback_for_menu_items(self, *args): toast(args[0]) # Try to set video path after preloading subprocess has ended def set_video_path(self): # Check if preloading process has ended poll = self.preloading_process.poll() while poll == None: time.sleep(4) print("polling!!") poll = self.preloading_process.poll() print("set video source") # Set default to 0 self.video_player.source = f"{os.environ['PROJECT_ROOT']}/tmp/mixed_0.mp4" # Set display to video self.display_manager.current = "video_screen" self.loading = False # Change video based on slider def on_value(self, instance, percentage): if not self.loading: self.video_player.source = f"{os.environ['PROJECT_ROOT']}/tmp/mixed_{int(percentage)}.mp4" # ---------------------------------------------------------------------------- # # Web cam recording functionality # # ---------------------------------------------------------------------------- # # Recording button is pressed def button_record(self): if self.recording: print("stop recording") self.recording = False self.stop_record() else: print("start recording") self.recording = True self.record() # Starts our recording process def record(self): self.recording_process = subprocess.Popen([ sys.executable, "-u", f"{os.environ['PROJECT_ROOT']}/utils/video.py" ], stdin=subprocess.PIPE, bufsize=1, universal_newlines=True) self.recording_process.stdin.write("Start Recording!!\n") # Terminates our recording process def stop_record(self): self.recording_process.stdin.write("end\n") print("finish writing end to child") # ---------------------------------------------------------------------------- # # Top expansion panel functionality # # ---------------------------------------------------------------------------- # # Top expansion panel def add_expansion_panel(self, card): content = ProjectExpansionPanelContent() card.add_widget( MDExpansionPanel( icon=f"{os.environ['PROJECT_ASSETS']}avatar.png", content=content, panel_cls=MDExpansionPanelOneLine( text=f"KivyMD {__version__}"), )) # Show the dialog where user can change themes def show_dialog_change_theme(self): if not self.dialog_change_theme: self.dialog_change_theme = ProjectDialogChangeTheme() self.dialog_change_theme.set_list_colors_themes() self.dialog_change_theme.open() # Swich between dark and light themes def switch_theme_style(self): self.theme_cls.theme_style = ("Light" if self.theme_cls.theme_style == "Dark" else "Dark") self.root.ids.backdrop.ids._front_layer.md_bg_color = [0, 0, 0, 0] # Clicked on to return to home screen def back_to_home_screen(self): self.root.ids.screen_manager.current = "home"
class Navigation_Screen(Screen): username = StringProperty() calendar_time = StringProperty() date = ObjectProperty() first_input = ObjectProperty() second_input = ObjectProperty() third_input = ObjectProperty() avt_draw = ObjectProperty() avt_prev = ObjectProperty() tlist = ObjectProperty() taskNumber = NumericProperty(1) #Calendar Function` #With DataBase def open_calendar(self, *args): pd = self.date if len(self.calendar_time) > 0: try: MDDatePicker(self.set_previous_date, year=int(self.calendar_time[0:4]), month=int(self.calendar_time[5:7]), day=int(self.calendar_time[8:10])).open() except AttributeError: MDDatePicker(self.set_previous_date).open() elif len(self.calendar_time) == 0: MDDatePicker(self.set_previous_date).open() def set_previous_date(self, date_obj): self.date = date_obj store.put('Selection', last_date=str(date_obj)) self.calendar_time = str(store.get("Selection")['last_date']) #Goals show up def anime_run(self, widget1, widget2, widget3, *args): anim = Animation(third_pos=.6) anim2 = Animation(first_pos=.85) anim3 = Animation(second_pos=.7) anim.start(widget1) anim2.start(widget2) anim3.start(widget3) try: self.first_input.text = str(store.get('first_input')['text']) self.second_input.text = str(store.get('second_input')['text']) self.third_input.text = str(store.get('third_input')['text']) except: pass self.update_text = Clock.schedule_interval(self.update_json, 20) def update_json(self, *args): if self.ids.screenmanager.current != "Goals_System": self.update_text.cancel() else: store.put("third_input", text=str(self.third_input.text)) store.put("second_input", text=str(self.second_input.text)) store.put("first_input", text=str(self.first_input.text)) def __init__(self, **kwargs): super().__init__(**kwargs) Window.bind(on_keyboard=self.events) self.manager_open = False self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, #previous=True, ) def file_manager_open(self): self.file_manager.show('/') self.manager_open = True def select_path(self, path): self.exit_manager() try: self.crop_pic(path) self.update_avatar() toast("Avatar selected!") except: toast("Failed! Incorrect format!") def exit_manager(self, *args): 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 def crop_pic(self, path): im = pl.Image.open(path) new_size = im.resize((110, 110)) npImage = np.array(new_size) h, w = new_size.size alpha = pl.Image.new('L', new_size.size, 0) draw = ImageDraw.Draw(alpha) draw.pieslice([0, 0, h, w], 0, 360, fill=255) # Convert alpha Image to numpy array npAlpha = np.array(alpha) # Add alpha layer to RGB npImage = np.dstack((npImage, npAlpha)) # Save with alpha pl.Image.fromarray(npImage).save("avatar.png") def update_avatar(self, *args): self.avt_prev.reload() self.avt_draw.reload() def Add_Task(self, taskname, *args): if len(taskname) == 0: self.tlist.add_widget( Task_Widget(text="Task {}".format(self.taskNumber))) self.text = "Task {}".format(self.taskNumber) self.save_task() else: self.tlist.add_widget(Task_Widget(text=taskname)) self.text = taskname self.save_task() self.taskNumber += 1 self.set_name.dismiss() def save_task(self, *args): x = "Task{}".format(self.taskNumber) store.put(x, name=self.text) store.put('taskNumber', num=self.taskNumber) time_pressed = NumericProperty(0) def load_checkpoint(self, *args): if self.time_pressed == 0: try: num = store.get('taskNumber')['num'] self.taskNumber = num + 1 for i in [x for x in range(num + 1) if x != 0]: self.tlist.add_widget( Task_Widget(text=store.get("Task" + str(i))['name'])) self.time_pressed += 1 except: pass else: pass def show_set_name(self, *args): self.set_name = MDDialog( title="Configure your task!", type="custom", size_hint=[.6, .5], content_cls=Name_Conifigure(), ) self.set_name.open() def remove_item(self, instance, name): self.tlist.remove_widget(instance) for item in store.find(name=name.text): self.new = (item[0]) store.delete(self.new) store.put('taskNumber', num=store.get('taskNumber')['num'] - 1) def change_name_dialog(self, instance): self.new = instance self.name_change = MDDialog( title="Configure your task!", type="custom", size_hint=[.6, .5], content_cls=Change_Name(), ) self.name_change.open() def change_name(self, taskname, *agrs): if len(taskname.strip()) == 0: pass else: for item in store.find(name=self.new.text): self.name = (item[0]) store.put(self.name, name=taskname) self.new.text = taskname self.name_change.dismiss()
class TesseractController(Controller): """ Controller class to manage image selector screen """ def __init__(self, screen): super().__init__(screen) self.screen = screen self.psms = [' 0 Orientation and script detection (OSD) only.', ' 1 Automatic page segmentation with OSD.', ' 2 Automatic page segmentation, but no OSD, or OCR. (not implemented)', ' 3 Fully automatic page segmentation, but no OSD. (Default)', ' 4 Assume a single column of text of variable sizes.', ' 5 Assume a single uniform block of vertically aligned text.', ' 6 Assume a single uniform block of text.', ' 7 Treat the image as a single text line.', ' 8 Treat the image as a single word.', ' 9 Treat the image as a single word in a circle.', ' 10 Treat the image as a single character.', ' 11 Sparse text. Find as much text as possible in no particular order.', ' 12 Sparse text with OSD.', ' 13 Raw line. Treat the image as a single text line, bypassing hacks that are Tesseract-specific.'] self.oems = [' 0 Legacy engine only.', ' 1 Neural nets LSTM engine only.', ' 2 Legacy + LSTM engines.', ' 3 Default, based on what is available.'] self.init_dropdown() self.tessprofile_menu = screen.tessprofile_menu self.output_manager = MDFileManager( exit_manager=self.exit_output_manager, select_path=self.select_output, ext=[""], ) self.selected_output_folder = None self.screen.recognize_button.bind(on_release=self.recognize_thread) self.screen.pause_button.bind(on_press=self.stop_rec) self.screen.model.bind(on_release=get_app().image_selection_controller.get_model) self.models = self.get_models() self.print_on_screen = False self.ocr_event = None self.ocr_stop = False self.last_rec_time = time.time() # Context menu self.screen.context_menu.ids.recognize_ctx.bind(on_release=self.recognize_single_thread) # Load default settings self.load_default_settings() def load_default_settings(self): for profile, profileparam in get_app().tessprofiles.items(): if profileparam['default'] == True: self.load_tessprofile(profileparam) def get_models(self): tesscmd = get_app().tesspath if get_app().tesspath != "" else "tesseract" try: return check_output([tesscmd, "--tessdata-dir", get_app().tessdatadir, "--list-langs"]).decode( 'utf-8').splitlines()[1:] except: return [] def stop_rec(self, instance): """ Unschedule progress event and log total execution time """ if self.ocr_event: self.ocr_stop = True logger.info(f'Recognizer: Canceled!') def init_dropdown(self): screen = self.screen # Init dropdownsettingsmenu self.psm_menu = self.create_dropdown(screen.psm, [{'text': 'PSM: ' + psm} for psm in self.psms], self.set_psm) self.oem_menu = self.create_dropdown(screen.oem, [{'text': 'OEM: ' + oem} for oem in self.oems], self.set_oem) def disable_rec(self, instance, *args): self.screen.recognize_button.disabled = True self.screen.pause_button.disabled = False def enable_rec(self, instance, *args): self.screen.recognize_button.disabled = False self.screen.pause_button.disabled = True def recognize_thread(self, instance, *args): self.disable_rec(instance, *args) self.ocr_event = threading.Thread(target=self.recognize, args=(instance, args)) self.ocr_event.setDaemon(True) self.ocr_event.start() def recognize_single_thread(self, instance, *args): self.disable_rec(instance, *args) threading.Thread(target=self.recognize, args=(instance, args), kwargs={'file_list': [instance.selected_image.original_source]}).start() def recognize(self, instance, *args, file_list=None): """ Recognize image with tesseract """ if file_list is None: file_list = get_app().image_selection_controller.file_list if not file_list: alert(f'Select images to recognize') self.enable_rec(instance) return if instance._ButtonBehavior__touch_time < self.last_rec_time: self.enable_rec(instance) return logger.info(f'Main: Recognize {len(file_list)} images') # metadata_settings = get_app().metadata # TODO: Handle write errors (like file locked) and show dialog # file_list = get_app().image_selection_controller model = "eng" if self.screen.model.current_item == '' else self.screen.model.current_item.split(": ")[1].strip() psm = "3" if self.screen.psm.current_item == '' else self.screen.psm.current_item.split(": ")[1].strip() oem = "3" if self.screen.oem.current_item == '' else self.screen.oem.current_item.split(": ")[1].strip() outputformats = self.active_outputformats() print_on_screen = self.screen.print_on_screen_chk.active groupfolder = self.screen.groupfolder.text subfolder = self.screen.subfolder_chk.active proc_files, outputnames = recognize(file_list, model=model, psm=psm, oem=oem, tessdatadir=get_app().tessdatadir, output_folder=self.selected_output_folder, outputformats=outputformats, print_on_screen=print_on_screen, subfolder=subfolder, groupfolder=groupfolder) toast(f'{proc_files} images recognized') self.last_rec_time = time.time() + 2 get_app().image_selection_controller.file_chooser._update_files() self.enable_rec(instance) # Update image previews with new metadata # previews = {img.metadata.image_path: img for img in get_app().image_selection_controller.image_previews.children} # for metadata in all_metadata: # previews[metadata.image_path].metadata = metadata def active_outputformats(self): return [outputformat for outputformat in ['txt', 'hocr', 'alto', 'pdf', 'tsv'] if self.screen[outputformat].state == 'down'] def on_tesssettings_click(self, *args): self.tessprofile_menu.show(*get_app().root_window.mouse_pos) def search_tessprofile(self): get_app().tessprofiles_controller.set_profiles() get_app().switch_screen('tessprofiles') def load_tessprofile(self, tessprofileparams): self.screen.model.set_item(f"Model: {tessprofileparams.get('model', 'eng')}") self.screen.psm.set_item(f"PSM: {self.psms[int(tessprofileparams['psm'])]}") self.screen.oem.set_item(f"OEM: {self.oems[int(tessprofileparams['oem'])]}") for outputformat in ['txt', 'hocr', 'alto', 'pdf', 'tsv']: if outputformat in tessprofileparams['outputformat']: self.screen[outputformat.strip()].state = 'down' else: self.screen[outputformat.strip()].state = 'normal' self.screen.print_on_screen_chk.active = True if tessprofileparams['print_on_screen'] == "True" else False if tessprofileparams['outputdir'] != "": self.screen.output.set_item(f"Selected output directory: {tessprofileparams['outputdir']}") else: self.screen.output.text = '' self.screen.output.set_item('') self.screen.output.text = f"Select output directory (default: input folder)" self.screen.subfolder_chk.active = True if tessprofileparams['subfolder'] == "True" else False self.screen.groupfolder.text = tessprofileparams['groupfolder'] return def save_tessprofile_dialog(self): def close_dialog(instance, *args): instance.parent.parent.parent.parent.dismiss() dialog = MDDialog(title="Name of the profile", type='custom', auto_dismiss=False, content_cls=MDTextField(text=""), buttons=[ MDFlatButton( text="SAVE", on_release=self.save_tessprofile ), MDFlatButton( text="DISCARD", on_release=close_dialog ), ], ) dialog.content_cls.focused = True dialog.open() def save_tessprofile(self, instance): tessprofilename = instance.parent.parent.parent.parent.content_cls.text if tessprofilename != '': get_app().tessprofiles[tessprofilename] = { "model": self.screen.model.current_item.split(" ")[1] if self.screen.model.current_item.split(" ")[ 0] == "Model:" else "eng", "psm": "".join([char for char in self.screen.psm.text if char.isdigit()]), "oem": "".join([char for char in self.screen.oem.text if char.isdigit()]), "outputformat": self.active_outputformats(), "print_on_screen": str(self.screen.print_on_screen_chk.active), "outputdir": "" if self.screen.output.text.split(" ")[0] != "Selected" else self.screen.output.text.split(" ")[3], "groupfolder": self.screen.groupfolder.text, "subfolder": str(self.screen.subfolder_chk.active), "default": False } write_tessprofiles(get_app().tessprofiles) instance.parent.parent.parent.parent.dismiss() def reset_settings(self): # TODO: Rework resetting self.reset_text(self.screen.model) self.reset_text(self.screen.psm) self.reset_text(self.screen.oem) self.reset_ouputformat() self.screen.print_on_screen_chk.active = False self.selected_output_folder = None self.screen.output.text = '' self.screen.output.set_item('') self.screen.output.text = f"Select output directory (default: input folder)" self.screen.subfolder_chk.active = False self.screen.groupfolder.text = '' def reset_text(self, instance): instance.text = instance.text + '!' instance.set_item('') instance.text = instance.text[:-1] def reset_ouputformat(self): self.screen.txt.state = 'normal' self.screen.alto.state = 'normal' self.screen.hocr.state = 'normal' self.screen.pdf.state = 'normal' self.screen.tsv.state = 'normal' def create_dropdown(self, caller, item, callback): menu = MDDropdownMenu(caller=caller, items=item, position='bottom', width_mult=20) menu.bind(on_release=callback) return menu def set_psm(self, menu, instance, *args): self.screen.psm.set_item(instance.text) self.psm_menu.dismiss() def set_oem(self, menu, instance, *args): self.screen.oem.set_item(instance.text) self.oem_menu.dismiss() def select_output(self, path=None): '''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; ''' if path is None: return self.selected_output_folder = path self.screen.output.text = f"Selected output directory: {path}" self.exit_output_manager() def select_output_folder(self): self.output_manager.show("/") def exit_output_manager(self, *args): '''Called when the user reaches the root of the directory tree.''' self.output_manager.close()
class Mark2MarketApp(MDApp): processing = BooleanProperty(defaultValue=False) analytics = BooleanProperty(defaultValue=True) stock_fetch = BooleanProperty(defaultValue=True) color = (0, 0, 0, 1) def __init__(self, **kwargs): super().__init__(**kwargs) start = time.time() self.updated = False self.processing = True self.screen_manager = ScreenManager() self.current = "Main" self.manager_open = False self.filePath = "" self.symbol = [] self.qty = [] self.cost = [] self.side = [] Window.bind(on_keyboard=self.events) self.file_manager = MDFileManager( exit_manager=self.exit_manager, select_path=self.select_path, ) self.file_manager.ext = ['.csv', '.CSV', '.xlsx', '.XLSX'] self.popup = self.get_popup() self.no_data_popup = self.no_data_popup() end = time.time() print('elapsed time for startup is %d seconds ' % (end - start)) self.processing = False def on_processing(self, instance, value): pass def on_analytics(self, instance, value): pass def on_stock_fetch(self, instance, value): pass def help(self): HelpScreen().open() def exit(self): Window.close() def on_state(self, instance, value): pass def get_popup(self): pop = Popup(title='Transaction status', auto_dismiss=False) lbl = Label() lbl.text = 'Update successful' btn = MDIconButton() lbl.pos_hint = {'center_x': .5, 'center_y': .5} btn.icon = 'home' btn.bind(on_press=self.go_home) btn.md_bg_color = (1, 1, 1, 1) btn.pos_hint = {'center_x': .5, 'center_y': 0.1} from kivy.uix.floatlayout import FloatLayout layout = FloatLayout() layout.add_widget(lbl) layout.add_widget(btn) pop.content = layout pop.size_hint = .6, .6 return pop def no_data_popup(self): pop = Popup(title='Data status', auto_dismiss=False) lbl = Label() lbl.text = 'No Data!. Add some transactions' btn = MDIconButton() lbl.pos_hint = {'center_x': .5, 'center_y': .5} btn.icon = 'home' btn.bind(on_press=self.go_home) btn.md_bg_color = (1, 1, 1, 1) btn.pos_hint = {'center_x': .5, 'center_y': 0.1} layout = FloatLayout() layout.add_widget(lbl) layout.add_widget(btn) pop.content = layout pop.size_hint = .8, .6 return pop def go_nav(self): if not os.path.exists('csv/pandb.csv'): self.no_data_popup.open() return self.processing = True Clock.schedule_once(self.nav_delegate, 1) def add_nav_widget(self): pnl = PnLScreen(self.screen_manager, name='NAV', updated=self.updated) self.updated = False self.screen_manager.add_widget(pnl) def nav_delegate(self, dt): try: pnl = self.screen_manager.get_screen('NAV') if self.updated or len(tryout.product_dict) == 0: self.screen_manager.remove_widget(pnl) self.add_nav_widget() except ScreenManagerException: self.add_nav_widget() print('prod dict length = ', len(tryout.product_dict)) if len(tryout.product_dict) == 0: self.no_data_popup.open() else: self.screen_manager.current = "NAV" self.processing = False def upload_screen(self): self.screen_manager.current = 'Upload' def entry_screen(self): self.screen_manager.current = 'Entry' def trading_screen(self): self.screen_manager.current = 'Trade' def gain_loss(self): if not os.path.exists('csv/pandb.csv'): self.no_data_popup.open() return self.processing = True Clock.schedule_once(self.gain_loss_delegate, 1) def gain_loss_delegate(self, dt): self.processing = True try: self.screen_manager.get_screen('GainLoss') except ScreenManagerException: gl = GainLossScreen(self.screen_manager, name='GainLoss', updated=self.updated) self.screen_manager.add_widget(gl) if len(tryout.product_dict) == 0: self.no_data_popup.open() else: self.screen_manager.current = 'GainLoss' self.processing = False def charts(self): if not os.path.exists('csv/pandb.csv'): self.no_data_popup.open() return self.processing = True Clock.schedule_once(self.chart_delegate, 3) def chart_delegate(self, dt): try: analysis = self.screen_manager.get_screen('Charts') except ScreenManagerException: analysis = Analysis(self.screen_manager, name='Charts', updated=self.updated) # analysis.add_widgets() self.screen_manager.add_widget(analysis) if len(tryout.product_dict) > 0: self.screen_manager.current = 'Charts' else: self.no_data_popup.open() self.processing = False def on_text(self): symbol = self.root.get_screen("Entry").ids.symbol.text self.symbol.append(symbol) qty = self.root.get_screen("Entry").ids.quantity.text self.qty.append(qty) cost = self.root.get_screen("Entry").ids.cost.text self.cost.append(cost) side = self.root.get_screen("Entry").ids.side.text self.side.append(side) def open_url(self, instance): tryout.open_url(instance.text) def on_submit(self): self.processing = True Clock.schedule_once(self.submit_delegate, 1) def submit_delegate(self, dt): symbol = self.symbol.pop().upper() qty = float(self.qty.pop().upper()) cost = float(self.cost.pop().upper()) side = self.side.pop().upper() print(symbol, qty, cost, side) success = tryout.update_portfolio(symbol, qty, cost, side) if success: self.screen_manager.get_screen('Entry').ids.symbol.text = '' self.screen_manager.get_screen('Entry').ids.quantity.text = '' self.screen_manager.get_screen('Entry').ids.cost.text = '' self.screen_manager.get_screen('Entry').ids.side.text = '' self.updated = True self.processing = False self.popup.open() def home(self): self.screen_manager.current = 'Main' def go_home(self, instance): self.screen_manager.current = 'Main' self.popup.dismiss() self.no_data_popup.dismiss() def file_manager_open(self): self.file_manager.show('/') # output manager to the screen self.manager_open = True def process_file(self, instance): self.processing = True Clock.schedule_once(self.process_file_delegate, 1) def process_file_delegate(self, dt): if len(self.filePath) == 0: toast('You must select a transaction file') return csvFile = self.filePath extn = self.filePath[-4:].upper() if extn.__contains__('XLS'): csvFile = convert_to_csv(self.filePath) tryout.init() tryout.make_product_dict_from_csv(csv_file=csvFile) self.go_nav() tryout.nav_name = 'NAV' self.processing = False self.root.get_screen( self.root.current ).ids.file_chooser.text = 'Choose a transaction file' 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() self.root.get_screen(self.root.current).ids.file_chooser.text = path self.filePath = path # self.process_file() def set_error_message(self, instance_textfield): name = self.screen_manager.current screen = self.root.get_screen(name) screen.ids.input = True def back(self): self.screen_manager.current = 'Main' 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() elif self.screen_manager.current == 'Main': self.exit() else: self.screen_manager.current = 'Main' return True def build(self): Builder.load_file('RootWidget.kv') addMainScreen(self.screen_manager, self) self.screen_manager.current = "Main" return self.screen_manager
class MainApp(MDApp): conn = None cursor = None icons_item = { "home": ["Home", "home_screen"], "corn": ["Vegetables", "veggie_screen"], "pig-variant": ["Meat & Eggs", "meat_screen"], "rice": ["Rice & Grains", "grain_screen"], "bowl": ["Beans & Lentils", "bean_screen"], "fish": ["Seafood", "fish_screen"], "camera": ["Credits", "credit_screen"] } dial_items = { "corn": "Vegetables", "pig-variant": "Meat & Eggs", "rice": "Rice & Grains", "bowl": "Beans & Lentils", "fish": "Seafood" } def build(self): self.theme_cls.primary_palette = 'Red' self.theme_cls.primary_hue = '800' self.theme_cls.accent_palette = 'Gray' self.theme_cls.accent_hue = '800' self.icon = 'logo_no_txt2.png' Window.softinput_mode = 'below_target' # create file manager for adding ingredients 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=True, icon_folder='images/newfolder.png', icon='check') # set file manager check button color fm_float_btn = self.file_manager.children[0].children[0] fm_float_btn.text_color = [1, 1, 1, 1] self.sm = self.root.ids.screen_manager def on_start(self): # start SQLite connection here self.conn = sqlite3.connect('ppcs.db') self.cursor = self.conn.cursor() icons_item = self.icons_item # create nav_drawer self.root.ids.content_drawer.create_drawer(icons_item) # create main and standard screens self.sm.create_screens(icons_item) # populate standard screens for screen in self.sm.screens[1:-2]: screen.populate_screen() # ref to photo_card on new food page self.photo_card = self.sm.screens[-1].ids self.crop_layout = CropLayout() self.delete_btn = DeleteButton() def on_stop(self): # close SQLite connection self.conn.close() 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; ''' # retrieve image name if '\\' in path: img_name = path.split('\\')[-1] else: img_name = path.split('/')[-1] # add cropping layout to new food screen self.photo_card.card.add_widget(self.crop_layout) self.crop_layout.path = path self.photo_card.card.img_name = img_name self.photo_card.card._no_ripple_effect = True self.exit_manager() toast(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() elif self.sm.current == 'home_screen': self.stop() elif self.sm.current == 'new_food_screen': self.sm.current_screen.ids.cancel_btn.show_discard_dialog() else: self.sm.go_back() return True
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