class MyScreen(Singleton): def __init__(self): self.screenMgr = ScreenManager(size=WH) self.name = "Root Screen" self.transition = WipeTransition() # or self.transition = SlideTransition(direction="down") self.emptyScreen = Screen(name="empty screen") #self.emptyScreen.add_widget(Label(text="empty.screen")) self.add_screen(self.emptyScreen) self.current_screen(self.emptyScreen) def prev_screen(self): prev_screen = self.screenMgr.previous() if prev_screen: self.screenMgr.current = prev_screen def add_screen(self, screen): if screen.name not in self.screenMgr.screen_names: self.screenMgr.add_widget(screen) def current_screen(self, screen): if True or self.screenMgr.current != screen.name and self.screenMgr.has_screen( screen.name): self.screenMgr.current = screen.name def remove_screen(self, screen): if screen.name in self.screenMgr.screen_names: self.screenMgr.remove_widget(screen) self.prev_screen() def get_current_screen(self): return self.screenMgr.current
class MyScreen(Singleton): def __init__(self): self.screenMgr = ScreenManager(size=WH) self.name = "Root Screen" self.transition = WipeTransition() # or self.transition = SlideTransition(direction="down") self.emptyScreen = Screen(name = "empty screen") #self.emptyScreen.add_widget(Label(text="empty.screen")) self.add_screen(self.emptyScreen) self.current_screen(self.emptyScreen) def prev_screen(self): prev_screen = self.screenMgr.previous() if prev_screen: self.screenMgr.current = prev_screen def add_screen(self, screen): if screen.name not in self.screenMgr.screen_names: self.screenMgr.add_widget(screen) def current_screen(self, screen): if self.screenMgr.current != screen.name: if not self.screenMgr.has_screen(screen.name): self.add_screen(screen) self.screenMgr.current = screen.name def remove_screen(self, screen): if screen.name in self.screenMgr.screen_names: self.screenMgr.remove_widget(screen) self.prev_screen() def get_current_screen(self): return self.screenMgr.current_screen
class AudiowallSet(BoxLayout): def __init__(self, **kwargs): super(AudiowallSet, self).__init__(**kwargs) self.pages = [] self.active_page = 1 self._container = BoxLayout(orientation='vertical') self.add_widget(self._container) self._sm = ScreenManager() self._sm.transition = SlideTransition() self._sm.transition.duration = 0.3 self._container.add_widget(self._sm) self._buttons = BoxLayout(orientation='horizontal', size_hint=(1,0.25)) self._container.add_widget(self._buttons) self.previous = Button(text='<<') self.previous.bind(on_press=self.on_previous) self._buttons.add_widget(self.previous) self.pages_label = Label() self._buttons.add_widget(self.pages_label) self.next = Button(text='>>') self.next.bind(on_press=self.on_next) self._buttons.add_widget(self.next) def add_page(self, id, name): screen = Screen() screen.name = id page = AudiowallPage() page.name = name screen.add_widget(page) self._sm.add_widget(screen) self.pages.append(page) self.pages_label.text = 'Page %i of %i' % (self.active_page, len(self.pages)) def on_previous(self, *largs): self._sm.transition.direction = 'right' self._sm.current = self._sm.previous() self.active_page -= 1 if(self.active_page == 0): self.active_page = len(self.pages) self.pages_label.text = 'Page %i of %i' % (self.active_page, len(self.pages)) def on_next(self, *largs): self._sm.transition.direction = 'left' self._sm.current = self._sm.next() self.active_page += 1 if(self.active_page > len(self.pages)): self.active_page = 1 self.pages_label.text = 'Page %i of %i' % (self.active_page, len(self.pages))
class TestApp(App): title = "My Test App" def __init__(self, **kwargs): super().__init__(**kwargs) self.sm = ScreenManager(transition=SlideTransition()) self.sm.add_widget(BaseScreen(name=PageNames.BACKGROUND.name)) self.sm.add_widget(HomeScreen(name=PageNames.HOME_PAGE.name)) self.sm.add_widget( ConfigurationScreen(name=PageNames.CONFIGURATION.name)) self._popup_exit = None # Window.bind(on_keyboard=self.on_key) def build(self): self.icon = MyPath.Paths.RABO_ICON.value Window.clearcolor = (0.25, 0.25, 0.25, 1) Window.bind(on_keyboard=self.on_key) Window.bind(on_request_close=self.on_request_close) self.sm.current = PageNames.BACKGROUND.name return self.sm def on_key(self, window, key, *args): if key in [276] and self.sm.current != PageNames.HOME_PAGE.name: self.sm.transition.direction = 'right' self.sm.current = self.sm.previous() def on_request_close(self, *args, **kwargs): if kwargs.get("source") != 'keyboard': self.textpopup(title='Exit', text='Do you want to close the app?') return True def textpopup(self, title='', text=''): box = GridLayout(cols=1, size_hint_x=0.25) box.add_widget(Label(text=text)) button_grid = GridLayout(cols=2, size_hint_x=0.5, size_hint_y=0.35) ok_button = Button(text='YES', size_hint=(0.25, 0.3)) ok_button.bind(on_release=self.stop) button_grid.add_widget(ok_button) cancel_button = Button(text="NO", size_hint=(0.25, 0.3)) cancel_button.bind(on_release=lambda *args: self._popup_exit.dismiss()) button_grid.add_widget(cancel_button) box.add_widget(button_grid) self._popup_exit = Popup(title=title, content=box, size_hint=(0.3, 0.4)) self._popup_exit.open()
class DescargarApp(App): # Desactiva el cuadro de configuración genérico de Kivy use_kivy_settings = False # Para que no se cierre al cambiar de aplicación en Android def on_pause(self): return True def build(self): self.download_thread = None self.store = JsonStore("descargar-aragontv.json") if not self.store.exists("target_folder"): if self.get_platform_name()=="android": from jnius import autoclass Environment = autoclass('android.os.Environment') download_folder = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS) self.store.put("target_folder",value=download_folder.getAbsolutePath() ) else: self.store.put("target_folder",value=os.path.expanduser("~") ) if not self.store.exists("source_url"): self.store.put("source_url",value="http://alacarta.aragontelevision.es/programas/chino-chano/por-la-sierra-de-armantes-28022016-1452") self.screen_manager = ScreenManager(transition=FadeTransition()) self.paso1 = Paso1(name='Paso 1') self.paso1.ids.target_folder.text = self.store.get("target_folder")["value"] self.paso1.ids.page_url.text = self.store.get("source_url")["value"] self.paso2 = Paso2(name='Paso 2') self.paso3 = Paso3(name='Paso 3') self.screen_manager.add_widget(self.paso1) self.screen_manager.add_widget(self.paso2) self.screen_manager.add_widget(self.paso3) return self.screen_manager def dismiss_popup(self): self._popup.dismiss() def target_selected(self, path, filename): self._popup.dismiss() self.paso1.ids.target_folder.text = path self.store.put("target_folder",value=self.paso1.ids.target_folder.text) def target_selection(self): content = LoadDialog(load=self.target_selected, cancel=self.dismiss_popup) content.ids.filechooser.path = self.paso1.ids.target_folder.text self._popup = Popup(title="Elige destino", content=content, size_hint=(0.9, 0.9)) self._popup.open() def message(self,title,body): content = MessageDialog() content.ids.message_body.text = body self._popup = Popup(title=title, content=content, size_hint=(0.8, 0.8)) self._popup.open() def url_ready(self,page_url): print "url_ready" print self.paso1.ids.page_url.text if not self.paso1.ids.page_url.text.startswith("http://") and not self.paso1.ids.page_url.text.startswith("https://"): self.message("Hay un problema...","La URL que has introducido no es válida") return self.store.put("target_folder",value=self.paso1.ids.target_folder.text) self.store.put("source_url",value=self.paso1.ids.page_url.text) from core.item import Item item = Item(url=self.paso1.ids.page_url.text) from channels import aragontv item = aragontv.detalle_episodio(item) self.video_title = item.title self.media_url = item.media_url if self.media_url=="": self.message("Hay un problema...","No se puede encontrar un vídeo en esa URL") return self.screen_manager.current = self.screen_manager.next() self.paso2.ids.description.text = "[b]"+item.title+"[/b]\n\n"+item.plot def start_download(self): print "start_download" self.paso3.resultado = "Descargando "+self.media_url+"\n\n" self.screen_manager.current = self.screen_manager.next() # Start download in background from core import downloadtools clean_file_name = downloadtools.limpia_nombre_caracteres_especiales(self.video_title.decode("utf-8"))+".flv" #print "clean_file_name="+clean_file_name self.target_file = os.path.join( self.paso1.ids.target_folder.text , clean_file_name ) #print "target_file="+self.target_file if self.get_platform_name()=="win": self.target_file = self.target_file.encode("utf-8") # get_platform_name es: win, linux, android, macosx, ios or unknown folder_platform = os.path.join( os.getcwd() , "rtmpdump" , self.get_platform_name() ) print "folder_platform="+folder_platform if self.get_platform_name()=="win": rtmpdump = os.path.join(folder_platform,"rtmpdump.exe") elif self.get_platform_name()=="linux": rtmpdump = "rtmpdump" else: rtmpdump = os.path.join(folder_platform,"rtmpdump") # En Android hay que darle antes expresamente permisos de ejecución al binario de rtmpdump if self.get_platform_name()=="android": subprocess.Popen(["chmod","0755",rtmpdump], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) exe = [rtmpdump] exe.append("-r") exe.extend(self.media_url.replace("app=","--app ").replace("playpath=","--playpath ").split(" ")) #exe.append("--live") exe.append("-o") exe.append(self.target_file) self.paso3.ids.cargando.opacity=1 self.download_thread = DownloadThread(exe,self.paso3) self.download_thread.start() Clock.schedule_interval(self.check_output_size, 0.5) def abort_download(self): print "abort_download" self.download_thread.abort() self.screen_manager.current = self.screen_manager.previous() def check_output_size(self,value): #print "check_output_size" if os.path.exists(self.target_file): statinfo = os.stat(self.target_file) self.paso3.tamanyo = human_size(statinfo.st_size) def on_stop(self): print "on_stop!" if self.download_thread is not None: self.download_thread.abort() def get_platform_name(self): from kivy import platform platform_name = str(platform) print "platform_name="+platform_name return platform_name
class DownloaderApp(App): use_kivy_settings = False def on_pause(self): return True def paste(self): ''' try: from kivy.core.clipboard import Clipboard self.main_screen.ids.page_url.text = Clipboard.paste() except: logger.error("Could not be pasted to clipboard!") pass ''' pass def copy(self,text): try: from kivy.core.clipboard import Clipboard Clipboard.copy(text) except: logger.error("Could not be copied to clipboard: "+text) pass def build(self): self.store = JsonStore("data/store.json") self.download_thread = None self.screen_manager = ScreenManager(transition=FadeTransition()) self.main_screen = StartScreen(name='Welcome Screen') self.download_screen = DownloadScreen(name="Download Screen") self.screen_manager.add_widget(self.main_screen) self.screen_manager.add_widget(self.download_screen) return self.screen_manager def target_selected(self, path, filename): self._popup.dismiss() self.main_screen.ids.target_folder.text = path self.store.put("target_folder",value=self.main_screen.ids.target_folder.text) def target_selection(self): content = LoadDialog(load=self.target_selected, cancel=self.dismiss_popup) content.ids.filechooser.path = self.main_screen.ids.target_folder.text self._popup = Popup(title="Choose destination", content=content, size_hint=(0.9, 0.9)) self._popup.open() def dismiss_popup(self): self._popup.dismiss() def url_ready(self,page_url): if not self.main_screen.ids.page_url.text.startswith("http://") and not self.main_screen.ids.page_url.text.startswith("https://"): self.message("There is a problem...","URL is not accepted, needs an http/s url") return self.store.put("target_folder",value=self.main_screen.ids.target_folder.text) self.store.put("source_url",value=self.main_screen.ids.page_url.text) self.media_url = self.main_screen.ids.page_url.text self.video_title = self.media_url self.screen_manager.current = self.screen_manager.next() self.start_download() def start_download(self): logger.debug("start_download called") self.download_screen.result = "downloading "+self.media_url+"\n\n" self.target_file = os.path.join( self.main_screen.ids.target_folder.text , self.video_title.decode("utf-8") ) self.target_folder = self.main_screen.ids.target_folder.text self.download_screen.ids.loading.opacity=1 self.download_screen.ids.label_text_message.text="decoding:\n\n"+self.media_url progressDialog = self.download_screen.ids.progress_bar_download progressDialoglabel = self.download_screen.ids.label_text_message self.download_thread = DownloadThread(self.media_url,self.target_folder,self.download_screen,progressDialog,progressDialoglabel) self.download_thread.start() def abort_download(self): logger.debug("abort_download") try: self.download_thread.abort() except: pass self.screen_manager.current = self.screen_manager.previous() def message(self,title,body): content = MessageDialog() content.ids.message_body.text = body self._popup = Popup(title=title, content=content, size_hint=(0.8, 0.8)) self._popup.open() def on_stop(self): logger.debug("on_stop event called: goodbye!")
class Gilbert(App): """Main class.""" def build(self): """ Build and return the root widget. """ # The line below is optional. You could leave it out or use one of the # standard options, such as SettingsWithSidebar, SettingsWithSpinner # etc. self.settings_cls = SettingsWithTabbedPanel # The ScreenManager controls moving between screens self.screen_manager = ScreenManager() # Add the screens to the manager and then supply a name # that is used to switch screens self.screen_manager.add_widget(MenuScreen(name="menu_screen")) self.screen_manager.add_widget(StudyScreen(name="study_screen")) self.screen_manager.add_widget(QuizScreen(name="quiz_screen")) self.screen_manager.add_widget(OhmScreen(name="ohm_screen")) self.screen_manager.add_widget(AboutScreen(name="about_screen")) # We apply the saved configuration settings or the defaults #root = Builder.load_string(kv) #MenuScreenButton = root.ids.MenuScreenButton #label.text = self.config.get('My Label', 'text') #MenuScreenButton.font_size = float(self.config.get('MenuScreenButton', 'font_size')) #return root # Bind to catch the "back" Android button. self.bind(on_start=self.post_build_init) return self.screen_manager def post_build_init(self, event): """Hook the keyboard to listen to its behavior.""" EventLoop.window.bind(on_keyboard=self.hook_keyboard) def hook_keyboard(self, window, key, *largs): """Capture behavior for the "back" button in Android.""" # Key 27 is "Esc" in the Keyboard, or "Back" on Android. if key == 27: print(self.screen_manager.current) if self.screen_manager.current == 'menu_screen': Gilbert.get_running_app().stop() self.screen_manager.transition.direction = "right" if isinstance(self.screen_manager.previous, str): self.screen_manager.current = self.screen_manager.previous else: self.screen_manager.current = self.screen_manager.previous() return_value = True else: return_value = False return return_value def build_config(self, config): """ Set the default values for the configs sections. """ config.setdefaults('MenuScreenButton', {'font_size': "15sp"}) def build_settings(self, settings): """ Add our custom section to the default configuration object. """ # We use the string defined above for our config JSON, but it could also be # loaded from a file as follows: # settings.add_json_panel('My Label', self.config, 'settings.json') settings.add_json_panel('Configuración', self.config, data=CONFIG) def on_config_change(self, config, section, key, value): """ Respond to changes in the configuration. """ Logger.info("main.py: App.on_config_change: %s, %s, %s, %s,", config, section, key, value) if section == "MenuScreenButton": if key == 'font_size': #self.MenuScreenButton.font_size = float(value) SettingsButton.font_size = float(value) def close_settings(self, settings=None): """ The settings panel has been closed. """ Logger.info("main.py: App.close_settings: %s", settings) super(Gilbert, self).close_settings(settings)
class DoorMonitorApp(MDApp): """ Frontend for CatchScanner configuration """ connection = ObjectProperty() current_user = StringProperty() access_level = NumericProperty(0) access = ObjectProperty(None) gui = ObjectProperty() api_response = ObjectProperty() timer_cnt = BoundedNumericProperty(5, min=0, max=ACCESS_TIMEOUT) timer = None _mqttc = mqtt.Client def __init__(self, cfg: dict) -> None: super().__init__() bell_config = MqttStringConfig(**cfg['bell']) door_list = [] for door, d_cfg in cfg['doors'].items(): print(f"new_door: {door}") new_door = Door(door_id=door, name=d_cfg['name'], command_topic=d_cfg['command_topic'], state_topic=d_cfg['state_topic']) # new_door.set_relay() door_list.append(new_door) doors_config = DoorsConfig(doors=door_list) print(cfg['garage']) garage_config = MqttStringConfig(**cfg['garage']) mode_config = MqttStringConfig(**cfg['mode']) self.kelvin = kelvin_rgb_to_kivy() self.azure = get_color_from_hex('#f0ffff') self.theme_cls = ThemeManager() self.theme_cls.primary_palette = "Blue" self.theme_cls.primary_hue = "500" self.theme_cls.accent_palette = "Yellow" self.theme_cls.accent_palette_hue = "500" self.theme_cls.theme_style = "Light" self.doors_config = doors_config self.bell_config = bell_config self.garage_config = garage_config self.mode_config = mode_config self.backlight = Backlight() ## GUI ## self.gui = ScreenManager(transition=NoTransition()) try: self.screens = config.screens except AttributeError: self.screens = None else: for screen in self.screens: print(f'New screen: {screen}') try: import_statemet = self.screens[screen][ "import"] + ' as NewScreen' print(import_statemet) exec(import_statemet) except Exception as e: print(e) else: screen_kwargs = {} screen_kwargs.update({'name': screen}) # screen_kwargs.update({'controller':self}) # screen_kwargs.update({'sub':self.screens[screen].get("sub", None)}) # screen_kwargs.update({'memory':kwargs.get(screen,None)}) print(f'SCREEN NAME IS: {screen}') print(f'with kwargs: {screen_kwargs}') self.screens[screen]["object"] = eval('NewScreen')( **screen_kwargs) self.gui.add_widget(self.screens[screen]["object"]) self.change_screen(self.gui.screen_names[0]) def presence_out_of_bounds(self, am: AccessModel): print(f"USER OUT OF BOUNDS {am}") def presence_detected(self, am: AccessModel): print(f"presence_detected {am}") if am.name: self.current_user = am.name toast(f"Velkommen {am.name}") if am.access_level > 0: self.access_level = am.access_level self.change_screen('Control') self.screens['DoorBell']["object"].login_feedback(True) # def detected_beacon_response(self, request, result): # if result is not None: # try: # self.access_level = result # if self.access_level > 0: # self.change_screen('Control') # self.screens['DoorBell']["object"].login_feedback(True) # else: # print("Login failed") # self.screens['DoorBell']["object"].login_feedback(False) # except ValueError as e: # print(f"result: {result}") # print(e) # else: # print(f"result: {result}") # # def detected_beacon(self, devices_discovered, address, packet_type): # # print(f'found: {devices_discovered} with address {address} aand packet type {packet_type}') # def detected_beacon(self, uuid, rssi): # print(f'found uuid: {uuid} with rssi {rssi}') # detected_beacon(on_success=self.detected_beacon_response,uuid=uuid, rssi=rssi) def get_door_name(self, door_id, *args): print(door_id) door = self.doors_config.get_by_id(door_id) if door is not None: return door.name else: return "" # @property # def access_level(self): # print(f"current access level: {self.access_level}") # return self.access_level def on_door_states(self, *args): print("on_door_states") def on_start(self): self.make_client() # def try_pin(self, pin): # """" # Log in. # Log in to sw with user and password. Hardcoded for now. Should interact with DB. # Args: # user: Username # password: Password # """ # success = False # success = self.api.authenticate_pin(pin) def next_screen(self): self.gui.next_screen() def prev_screen(self): self.gui.prev_screen() def on_enter_view(self, *args): pass def build(self): """ Kivy build. Function to return Kivy Layout from App class. Returns: Widget containing GUI """ return self.gui def try_login_response(self, request, result): self.access_level = result if result > 0: self.change_screen('Control') self.screens['DoorBell']["object"].login_feedback(True) else: print("Login failed") self.screens['DoorBell']["object"].login_feedback(False) def log_out(self, *args): self.access_level = 0 self.change_screen("DoorBell") print(f"Log out, access level is: {self.access_level}") # def setaccess_level(self, level): # self.access_level = level # print(f"access level is: {self.access_level}") def start_log_out_timer(self): if self.access_level > 0: print(f"access timeout set") # self.acccess_timeout = Clock.schedule_once(self.acccess_timeout, ACCESS_TIMEOUT) self.timer_cnt = ACCESS_TIMEOUT self.timer = Clock.schedule_interval(self.tic, 1) def cancel_log_out_timer(self): self.timer.cancel() def tic(self, dt): self.timer_cnt -= 1 def on_timer_cnt(self, *args): if self.timer_cnt == 0: self.cancel_log_out_timer() self.log_out() def extend_log_out_timer(self): self.timer_cnt = ACCESS_TIMEOUT # def acccess_timeout(self, dt): # self.log_out() # print(f"access level timeout") # self.acccess_timeout.cancel() def try_login(self, pin, *args): try_login(pin=pin, on_success=self.try_login_response) #### MQTT STUFF #### def make_client(self): # parameters = {'self': self} self._mqttc = mqtt.Client(MQTT_CLIENT_ID) # self._mqttc = mqtt.Client(MQTT_CLIENT_ID, userdata = parameters) self._mqttc.on_message = self.mqtt_on_message self._mqttc.on_connect = self.mqtt_on_connect self._mqttc.on_publish = self.mqtt_on_publish self._mqttc.on_subscribe = self.mqtt_on_subscribe self.mqttc_connect_to_broker() self.mqttc_subscribe() self.mqttc_run() def mqtt_on_connect(self, mqttc, obj, flags, rc): print("rc: " + str(rc)) print(f"flag: {flags}") def mqtt_on_message(self, mqttc, obj, msg): print(msg.topic + " " + str(msg.qos) + " " + str(msg.payload)) topic = msg.topic payload = msg.payload.decode("utf-8") door = self.doors_config.get_by_state_topic(topic) if door is not None: print(f"state received") if payload == DOORLOCK_STATUS_PAYLOAD.LOCKED: door.state = "LOCKED" self.screens['Control']["object"].update_door_states( door.door_id, True) elif payload == DOORLOCK_STATUS_PAYLOAD.UNLOCKED: door.state = "UNLOCKED" self.screens['Control']["object"].update_door_states( door.door_id, False) elif topic == self.mode_config.command_topic: print(f"mode received: {payload}") self.mode_config.state = payload def mqtt_on_publish(self, mqttc, obj, mid): print("mid: " + str(mid)) def mqtt_on_subscribe(self, mqttc, obj, mid, granted_qos): print("Subscribed: " + str(mid) + " " + str(granted_qos)) def mqtt_on_log(self, mqttc, obj, level, string): print(string) def tls_set(self): #TODO: sett ssl and cert for encrypt pass def mqttc_connect_to_broker(self): print(f"connecting to broker {MQTT_BROKER} as {MQTT_CLIENT_ID}") # broker_parsed = urllib.parse.urlparse(MQTT_BROKER) self._mqttc.username_pw_set(MQTT_USERNAME, password=MQTT_PASSWORD) self._mqttc.connect(MQTT_BROKER, port=MQTT_PORT, keepalive=60) def mqttc_subscribe(self): for door in self.doors_config.doors: self._mqttc.subscribe(door.state_topic, qos=0) self._mqttc.subscribe(self.mode_config.command_topic, qos=0) def mqttc_run(self): self._mqttc.loop_start() def ring_bell(self): print('ringing that bell') print(f'self.mode_config.state: {self.mode_config.state}') self._mqttc.publish(self.bell_config.command_topic, payload=BELL_COMMAND_PAYLOAD.DO) if self.mode_config.state == MODE_COMMAND_PAYLOAD.NORMAL: pass elif self.mode_config.state == MODE_COMMAND_PAYLOAD.HALLOWEEN: self.change_screen('Scary') def toggle_door(self, door, locked, *args): if locked: for d in self.doors_config.doors: if d.name == door: print(f"mqtt unlock door {door}") self._mqttc.publish( d.command_topic, payload=DOORLOCK_COMMAND_PAYLOAD.UNLOCK) else: for d in self.doors_config.doors: if d.name == door: print(f"mqtt lock door {door}") self._mqttc.publish(d.command_topic, payload=DOORLOCK_COMMAND_PAYLOAD.LOCK) def garage_open(self, *args): self._mqttc.publish(self.garage_config.command_topic, payload=GARAGE_COMMAND_PAYLOAD.OPEN) def garage_close(self, *args): self._mqttc.publish(self.garage_config.command_topic, payload=GARAGE_COMMAND_PAYLOAD.CLOSE) def garage_stop(self, *args): self._mqttc.publish(self.garage_config.command_topic, payload=GARAGE_COMMAND_PAYLOAD.STOP) def next_screen(self): self.change_screen(self.gui.next()) def prev_screen(self): self.change_screen(self.gui.previous()) def change_screen(self, screen_name): print(f"entering screen {screen_name}") # if screen_name == self.ids['sm'].screen_names[0]: # print(f"screen is first") # self.ids['sm'].current_screen.content.is_first() # else: # print(f"screen is inbetween") # # self.ids['sm'].current_screen.content.override_allow_prev(True) # if screen_name == self.ids['sm'].screen_names[-1]: # print(f"screen is last") # self.ids['sm'].current_screen.content.is_last() self.gui.current = screen_name
class NeuralNetworkDemoApp(App): # Application properties # See https://kivy.org/docs/api-kivy.properties.html # for available kinds of properties. # The dataset dataset_name = OptionProperty("POFA", options=["CAFE", "POFA"]) dataset_cache = {} def _load_dataset(self): if self.dataset_name not in NeuralNetworkDemoApp.dataset_cache.keys(): filename = 'data/%s.pkl' % self.dataset_name.lower() import pickle Logger.info('Loading data from %s' % filename) with open(filename, 'r') as f: NeuralNetworkDemoApp.dataset_cache[self.dataset_name] = pickle.load(f) return NeuralNetworkDemoApp.dataset_cache[self.dataset_name] dataset = AliasProperty(_load_dataset, None, bind=['dataset_name']) maximum_pca_components = AliasProperty(lambda self: min(self.dataset['data'].shape), None, bind=['dataset']) # PCA transformed data pca_data = AliasProperty(lambda self: PCAData(self.dataset['data']), None, bind=['dataset']) # PCA components (the max will be controlled by the maximum_pca_components) pca_components = BoundedNumericProperty(10, min=1) # PCA transformer pca_transformer = AliasProperty(lambda self: PCATransformer(self.pca_data, self.pca_components), None, bind=['pca_data', 'pca_components']) # train inputs num_hidden_units = BoundedNumericProperty(10, min=1) num_valid_input = BoundedNumericProperty(0, min=0) num_test_data = BoundedNumericProperty(0.2, min=0, max=1.0) hidden_units_learning_rate = BoundedNumericProperty(0.1, min=0.001, max=1.0) output_units_learning_rate = BoundedNumericProperty(0.2, min=0.001, max=1.0) momentum = BoundedNumericProperty(0.2, min=0, max=1.0) epochs = BoundedNumericProperty(1000, min=1, max=10000) minimum_rmse = BoundedNumericProperty(0, min=0.0, max=1.0) # the categories of training target_name = OptionProperty('Expression', options=['Gender', 'Expression', 'Identity']) training_target = OptionProperty('epochs', options=['epochs', 'rmse']) # # Main Kivy code for building the application UI. # def build(self): '''Build the application UI.''' self.manager = ScreenManager() for i, screen_cls in enumerate(ALL_SCREENS): self.manager.add_widget(screen_cls(name='Screen %d' % (i + 1))) self.manager.current = 'Screen 1' # Dispatch all events in order to initialize UIs for property_name in self.properties(): Logger.info('Initializing UI for %s' % property_name) self.property(property_name).dispatch(self) return self.manager # Manage the screen transitions def go_next(self): '''Go to the next screen.''' self.manager.transition.direction = 'left' Logger.info('Moving to ' + self.manager.next()) self.manager.current = self.manager.next() def go_back(self): '''Go back one screen.''' self.manager.transition.direction = 'right' Logger.info('Moving to ' + self.manager.previous()) self.manager.current = self.manager.previous()