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 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)
def __filechooser_pressed(name, spec, changed, initpath, *args): fm = MDFileManager() fm.exit_manager = partial(exit_filemanager, fm) fm.select_path = partial(handle_selection, name, changed, spec, fm) if initpath is None: initpath = str(Path.home()) fm.show(initpath)
def choose_dir(self, *args):
''' create filemanager and open in user's home directory
'''
fm = MDFileManager()
fm.exit_manager = partial(self.exit_filemanager, fm)
fm.select_path = partial(self.handle_selection, fm)
fm.show(str(Path.home()))
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 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()
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 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
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
self.manager = ModalView(size_hint=(1, 1), auto_dismiss=False)
self.file_manager = MDFileManager(
exit_manager=self.exit_manager,
select_path=self.select_path,
previous=previous,
)
self.manager.add_widget(self.file_manager)
self.file_manager.show(os.environ["KITCHEN_SINK_ASSETS"])
self.manager_open = True
self.manager.open()
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.dismiss()
self.manager_open = False
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 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 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 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 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()
def show_filemanager_add_help_location(self):
"""
Show a dialog to ask the name of the new help.
:return:
"""
mode = False
modal_view = ModalView(size_hint=(1, 1), auto_dismiss=False)
file_manager = MDFileManager(
exit_manager=lambda *args: self.on_cancel_filemanager(
modal_view, *args),
select_path=lambda *args: self.on_selected_path_filemanager(
modal_view, *args),
previous=
mode # Very special naming convention, False means listview-mode, True means Thumbnail mode
)
modal_view.add_widget(file_manager)
file_manager.show(
str(
pl.Path(CU.tfs.dic['tf_workspace_path'].value /
CU.tfs.dic['RAW_MIDI_DIR_NAME'].value)))
modal_view.open()
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 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')
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):
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 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 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"
