def set_leds(self, red, green, blue, white):
print "turned off:", self.turned_off
App.get_running_app().do_color_change \
( self.send_coap
, self.idx
, red, green, blue, white, self.status
)
def build(self):
self.settings_cls = SettingsWithSidebar
game = PlanetGame(do_rotation=False,do_translation=False)
# Settings come in as unicode!
sunmass = float(App.get_running_app().config.get('planetapp','defaultsunmass'))
game.sunmass = sunmass
game.gravity = float(App.get_running_app().config.get('planetapp','gravity'))
game.planetmass = float(App.get_running_app().config.get('planetapp','planetmass'))
game.resetmass = float(App.get_running_app().config.get('planetapp','resetmass'))
game.add_planet(True, (100,100), (0,0), sunmass, 10, (1,1,1))
Clock.schedule_interval(game.update, 1.0 / 120.0)
self.root = PlanetGameLayout()
self.root.add_widget(game)
b = Button(text="Reset",size_hint=(.3,.05),pos_hint={'x':.7,'y':0})
b.bind(on_press=self.root.clear_planets)
self.root.add_widget(b)
b2 = SettingsButton(text="Settings",size_hint=(.3,.05),pos_hint={'x':.4,'y':0})
self.root.add_widget(b2)
b3 = Button(text="Next",size_hint=(.3,.05),pos_hint={'x':.1,'y':0})
b3.bind(on_press=self.root.next_trajectory)
self.root.add_widget(b3)
self.root.reset_game()
def save_notes(self):
App.get_running_app().tog.next()
Window.release_all_keyboards()
self.data2['user']=self.user.text
self.data2['pass']=self.passwor.text
Clock.schedule_once(self.login_m,1)
def on_touch_down(self, touch):
"""An override of ScatterPlane's on_touch_down.
Used to determine the current selected widget and also emits,
on_show_edit event.
"""
if super(ScatterPlane, self).collide_point(*touch.pos) and not self.keyboard:
win = EventLoop.window
self.keyboard = win.request_keyboard(self._keyboard_released, self)
self.keyboard.bind(on_key_down=self._on_keyboard_down)
if super(ScatterPlane, self).collide_point(*touch.pos):
if not self.dragging:
self.touch = touch
Clock.schedule_once(self.start_widget_dragging, 0.5)
x, y = self.to_local(*touch.pos)
target = self.find_target(x, y, self.root)
self.selected_widget = target
App.get_running_app().focus_widget(target)
self.clicked = True
self.dispatch("on_show_edit", Playground)
return True
if self.parent.collide_point(*touch.pos):
super(Playground, self).on_touch_down(touch)
return False
def on_back_pressed( self , *args ) : """ :return: """ App.get_running_app().logger.info( 'on_back' )
def run(self, startPoint = None):
self.startPoint = startPoint
self.regist(startPoint)
# start method
if hasattr(startPoint, "start"):
self.startAppList.append(startPoint)
App.run(self)
def _event_filter(self, action):
from kivy.app import App
if action == 'app_terminating':
EventLoop.quit = True
self.close()
elif action == 'app_lowmemory':
self.dispatch('on_memorywarning')
elif action == 'app_willenterbackground':
from kivy.base import stopTouchApp
app = App.get_running_app()
if not app:
Logger.info('WindowSDL: No running App found, exit.')
stopTouchApp()
return 0
if not app.dispatch('on_pause'):
Logger.info('WindowSDL: App doesn\'t support pause mode, stop.')
stopTouchApp()
return 0
self._pause_loop = True
elif action == 'app_didenterforeground':
# on iOS, the did enter foreground is launched at the start
# of the application. in our case, we want it only when the app
# is resumed
if self._pause_loop:
self._pause_loop = False
app = App.get_running_app()
app.dispatch('on_resume')
return 0
def enter_gallery(self, instance):
galleryinfo = [instance.gallery_id, instance.gallery_token,
instance.pagecount, instance.gallery_name,
instance.gallery_tags, instance.gallery_thumb, instance.filesize]
existgallery = db.query(Gallery).filter_by(
gallery_id=instance.gallery_id).first()
if existgallery:
pass
else:
gallery = Gallery(gallery_id=instance.gallery_id,
gallery_token=instance.gallery_token,
pagecount=instance.pagecount,
gallery_name=instance.gallery_name,
gallery_thumb=instance.gallery_thumb,
filesize=instance.filesize)
db.add(gallery)
db.commit()
for tag in instance.gallery_tags:
gallerytag = GalleryTags(galleryid=gallery.id, tag=tag)
db.add(gallerytag)
db.commit()
preview_screen = App.get_running_app(
).root.ids.sadpanda_screen_manager.get_screen("gallery_preview_screen")
preview_screen.gallery_id = instance.gallery_id
App.get_running_app().root.next_screen("gallery_preview_screen")
def on_leave(self):
'''write setting to logic and save to file'''
for key in self.logic.settings:
if key in self.setting_items:
self.logic.settings[key] = self.setting_items[key].value
self.logic.apply_settings()
App.get_running_app().settings.save()
def update_file_layout(self):
auth_token='S2_xUq0_iNAAAAAAAAAACYNG1zf1GAzKpVWVfmLcZLA-FIiSlGxMvmxBkAtspuWQ'
client = dropbox.client.DropboxClient(auth_token)
self.clear_widgets()
b=BoxLayout(orientation='vertical')
file_system = FileSystemLocal()
root_dir= App.get_running_app().user_data_dir+'/';result_dir=root_dir+'results'
file_list=file_system.listdir(root_dir) # this returns a list of files in dir
if os.path.exists(result_dir):file_list.extend(file_system.listdir(App.get_running_app().user_data_dir+'/'+'results'+'/'))
file_list=[x for x in file_list if x[-4:]=='.csv']
b.add_widget(Label(text='Select Files to Upload',bold=True,font_size=sp(25),size_hint_y= 0.1))
file_system = FileSystemLocal()
file_list=file_system.listdir(App.get_running_app().user_data_dir+'/') # this returns a list of files in dir
file_list=[x for x in file_list if x[-4:]=='.csv']
s=ScrollView(size_hint_y=0.75)
g=GridLayout(cols=2,size_hint_y=None)
for file_1 in file_list:
c=CheckBox(active=False)
l=Label(bold= True,font_size=sp(20),text=file_1,size_hint_y= None,height=70)
self.check_boxes[c]=file_1
g.add_widget(l);g.add_widget(c)
g.bind(minimum_height=g.setter('height'))
s.add_widget(g)
b.add_widget(s)
g_options=GridLayout(cols=2,size_hint_y= 0.1,orientation='horizontal')
g_options.add_widget(Button(text="Send",on_press=self.upload,font_size=sp(25)))
g_options.add_widget(Button(text="Back",on_press=self.return_back,font_size=sp(25)))
b.add_widget(g_options)
self.add_widget(b)
def allowed_target_for(self, target, widget):
'''This function is used to determine if widget could be added to
target.
'''
# stop on complex widget
t = target if widget else target.parent
if isinstance(t, FileChooserListView):
return False
if isinstance(t, FileChooserIconView):
return False
# stop on custom widget but not root widget
class_rules = App.get_running_app().root.\
project_loader.class_rules
root_widget = App.get_running_app().root.\
project_loader.root_rule.widget
# if we don't have widget, always return true
if widget is None:
return True
is_widget_layout = isinstance(widget, Layout)
is_target_layout = isinstance(target, Layout)
if is_widget_layout and is_target_layout:
return True
if is_target_layout or isinstance(target, Carousel):
return True
return False
def do_paste(self):
'''Paste the selected widget to the current widget
'''
parent = self.selected_widget
if parent and self.widget_to_paste:
class_rules = App.get_running_app().root.\
project_loader.class_rules
root_widget = App.get_running_app().root.\
project_loader.root_rule.widget
is_child_custom = False
for rule in class_rules:
if rule.name == type(parent).__name__:
is_child_custom = True
break
# find appropriate parent to add widget_to_paste
while parent:
if isinstance(parent, Layout) and (not is_child_custom
or root_widget == parent):
break
parent = parent.parent
is_child_custom = False
for rule in class_rules:
if rule.name == type(parent).__name__:
is_child_custom = True
break
if parent is not None:
self.add_widget_to_parent(self.widget_to_paste,
parent,
kv_str=self._widget_str_to_paste)
self.widget_to_paste = None
def on_touch_move(self, touch):
if touch.grab_current is not self:
return False
handled = super(DwellOnScatter, self).on_touch_move(touch)
if handled:
if self.ignore_dwell is not True:
#if self.collide_point(touch.x, touch.y): # check dwell on myself, not the kids (todo: refine?)
if self.dwell_started_by_touch != touch:
self.dwell_started_counter = 0
if self.dwell_started_by_touch is not None:
root = App.get_running_app().root
root.canvas.remove_group(self.dwell_started_by_touch.ud['dwell'])
self.dwell_started_by_touch = None
Clock.unschedule(self.process_dwell)
else:
# rather than base the calculation on the last touch frame, which means the user might be so slow, that a dwell follows them
# base it on the original touch position, with the dwell_jitter_distance essentially mimicing a radius
# around which a point can be within for the dwell to not be cancelled out
diff = [abs(i-j) for i, j in zip(self.dwell_started_by_touch.opos,self.dwell_started_by_touch.pos)]
#if abs(self.dwell_started_by_touch.dx) >= self.dwell_jitter_distance_ignore or abs(self.dwell_started_by_touch.dy) >= self.dwell_jitter_distance_ignore:
if diff[0] >= self.dwell_jitter_distance_ignore or diff[1] >= self.dwell_jitter_distance_ignore:
self.dwell_started_counter = 0
if self.dwell_started_by_touch is not None:
root = App.get_running_app().root
root.canvas.remove_group(self.dwell_started_by_touch.ud['dwell'])
self.dwell_started_by_touch = None
Clock.unschedule(self.process_dwell)
else:
pass # ignore little movements
return handled
def run(self):
con_error_cnt = 0
while self.keep_running:
print 'connecting to weather'
try:
owm_is_online = self.link.is_API_online()
except: # api_call_error.APICallError
con_error_cnt += 1
print 'connection to OWM API failed'
if con_error_cnt < 10:
print 'will try again in 2 seconds'
time.sleep(2) # wait 2 seconds before trying it again
continue
else:
# quit if connection could not be est. 10 times in a row
print 'OWM API seems to be offline, quitting'
break
con_error_cnt = 0 # reset connection error counter if connection was successful
if owm_is_online:
obs = self.link.weather_at_place(location_str)
App.get_running_app().owm_thread_weather = obs.get_weather()
else:
App.get_running_app().owm_thread_weather = None
print('OWM service is offline')
time.sleep(owm_fetch_sleep_time) # should be last statement in while loop
def logfile_end_and_save(self, temp, pres):
t = time.localtime(App.get_running_app().root.ph.processStart)[0:6]
t_string = self.get_pretty_print_time(t[3], t[4], t[5], "-")
date = self.get_pretty_print_time(t[0], t[1], t[2], ".")
profile_name = App.get_running_app().root.ph.profile.name
file = open(self.get_log_directory()+"/"+ date + "_" + t_string + "_" + profile_name + ".txt", "w")
# put logged data into file when process has finished
for entity in self.logdata:
file.write(entity)
if len(temp) > 0:
time_string = "Time: ["
temp_string = "Temperature: ["
pres_string = "Presssure: ["
for i in range(0, len(temp)-1):
temp_string = temp_string + str(round(temp[i][1], 2)) + ","
pres_string = pres_string + str(round(pres[i][1], 2)) + ","
time_string = time_string + str(round(temp[i][0], 2)) + ","
temp_string = temp_string + str(temp[-1][1]) + "]"
pres_string = pres_string + str(pres[-1][1]) + "]"
time_string = time_string + str(temp[-1][0]) + "]"
file.write("\n")
file.write("Logged Temperature and Pressure Data")
file.write("\n")
file.write(time_string)
file.write("\n")
file.write(temp_string)
file.write("\n")
file.write(pres_string)
file.close()
# clear logdata
self.logdata = []
pass
def __init__(self, **kwargs): if hasattr(App.get_running_app(), 'theme_cls'): self._theme_cls = App.get_running_app().theme_cls else: self._theme_cls = ThemeManager() super(ThemeBehaviour, self).__init__(**kwargs) self._rip_color = self._theme_cls.ripple_color
def __init__(self, **kwargs):
super(BTCommunicator, self).__init__(**kwargs)
self.register_event_type('on__connected')
self.register_event_type('on_dis_connected')
self.register_event_type('on_command_sent')
self.register_event_type('on_response')
self.register_event_type('on_error')
self.register_event_type('on_unknown')
App.get_running_app().bind(on_stop=self.stop_reader_stream)
curdir = dirname(__file__)
try:
with open(join(curdir, 'lang', '{}.json'.format(self.language))) as lang_file:
self._lang = json.load(lang_file)
except Exception as e:
raise BTCommunicatorException("Couldn't load {}/lang/{}.json\nError: {}".format(curdir, self.language, e.message))
if platform == 'android':
self.BluetoothAdapter = jnius.autoclass('android.bluetooth.BluetoothAdapter')
self.BluetoothDevice = jnius.autoclass('android.bluetooth.BluetoothDevice')
self.BluetoothSocket = jnius.autoclass('android.bluetooth.BluetoothSocket')
self.InputStreamReader = jnius.autoclass('java.io.InputStreamReader')
self.BufferedReader = jnius.autoclass('java.io.BufferedReader')
self.IOException = jnius.autoclass('java.io.IOException')
self.UUID = jnius.autoclass('java.util.UUID')
return
def hook_keyboard(self, window, key, *largs):
if key == 27:
if FlashcardAppManager.s_manager.current != 'menu':
FlashcardAppManager.s_manager.current = 'menu'
else:
App.get_running_app().stop()
return True
def run_project(self, project):
config = ConfigParser()
config.read('config.ini')
config.set('Project', 'open_project', project)
with open('config.ini', 'wb') as configfile:
config.write(configfile)
App.get_running_app().stop()
def on_keyboard_down(self, keyboard, keycode, text, modifiers):
key = keycode[1]
print 'keyboard screen manager', key, text
# general key bindings
if key == 'q':
App.get_running_app().stop()
return True
# key binding for the wall
elif self.current == 'Wall screen':
if ((key == 'up' and self.current_active_post_index > 0) or
(key == 'down' and self.current_active_post_index < self.number_of_posts - 1))\
and not self.movement_flag:
next_index = self.current_active_post_index + 1 if key == 'down' else self.current_active_post_index - 1
self.ids['pw'].scroll_wall(next_index)
return True
elif key == 'enter':
self.ids['pc'].index = self.current_active_post_index
self.current = 'Carousel screen'
return True
# key bindings for the carousel
elif self.current == 'Carousel screen':
if key == 'up' and self.current_active_post_index > 0 and not self.movement_flag:
self.ids['pc'].load_previous()
self.current_active_post_index -= 1
elif key == 'down' and self.current_active_post_index < self.number_of_posts - 1 and not self.movement_flag:
self.ids['pc'].load_next()
self.current_active_post_index += 1
elif key == 'backspace':
self.ids['pw'].move_wall_to_index(self.current_active_post_index)
self.current = 'Wall screen'
return True
def update_tab_value(self, callback):
if self.balance_input.text.isnumeric():
App.get_running_app().man.customer_handler.update_tab_value(self.customer, float(self.balance_input.text))
self.customer_layout.ids.balance_label.text = str(float(self.balance_input.text))
self.dismiss()
else:
self.info_label.text = "Not valid number"
def __init__(self):
"""
:return:
"""
App.__init__(self)
# Connection
self.connection = "DUMMY"
self.proxy = Proxy(self.connection)
self.proxy.start()
# Model
self.robot = SimulatedRobot(self.proxy)
self.robot.cell_size = 0.3
self.robot.x = 0.3
self.robot.y = 0.3
self.map_model = Map(self.robot, 3.0, 0.3)
self.state = State.default
self.brush = "start"
self.planning_algorithm = GridNav(self.map_model)
self.planner = Planner(self.robot, self.map_model, self.planning_algorithm, self.proxy)
# View
self.map_widget = None
self.panel_widget = None
self.toolbar_widget = None
self.horizontal_layout = None
self.vertical_layout = None
self.popup = None
self.plan()
def __init__(self):
App.__init__(self)
self.STACK= ExdStack()
self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
self._keyboard.bind(on_key_down=self._on_keyboard_down)
self.keyEvents = {}
def search_tag(self, instance):
tag = instance.text
search = Search(searchterm=tag)
db.add(search)
db.commit()
App.get_running_app().root.next_screen("front_screen")
def on_touch_move(self, touch):
if touch.grab_current is not self:
return
touch.push()
touch.apply_transform_2d(self.to_local)
ud = touch.ud
# typecasting-problems during cross-compiling
# leads to this ugly construction like in calc_hillbodies
foo = App.get_running_app().config.get('planetapp','showtrajectorymode')
trajectorylength = int(App.get_running_app().config.get('planetapp',
'trajectorylength'))
if foo == u'0':
ud['lines'][0].points = (ud['firstpos'][0],ud['firstpos'][1],
touch.x,touch.y)
else:
velocity = ((ud['firstpos'][0] - touch.x) / -50,
(ud['firstpos'][1] - touch.y) / - 50)
planetpos = (ud['firstpos'][0], ud['firstpos'][1])
sunpos = (self.width/2,self.height/2)
trajectory = self.calc_trajectory(planetpos, velocity,
self.planetmass, sunpos,
self.sunmass, 1,
trajectorylength)
ud['lines'][0].points = trajectory
touch.pop()
def upload_to_drive():
google_client = DriveClient()
google_client.upload_file(csv_name)
App.get_running_app().settings.update_settings(update_time=time_str)
os.remove(csv_name)
InformationPopup('File uploaded')
Logger.info('CustomerHandler: upload thread finished')
def __init__(self):
App.__init__(self)
self.connected = True
self.Connect((HOST, PORT))
self.count = 0
self.time = 0
def leave_game(self):
"""
Ends the game by stopping the app
:return:
"""
# Exit the application, clean up
App.get_running_app().stop()
def make_board_match_view_mode(self, name):
board = self.get_screen(name)
if self.view_mode[:6] == 'tablet':
if not isinstance(board.children[0], TabletBoardView):
print 'REFRESHING -> tbv'
board = self.get_screen(name)
self.close_board(name)
board = board.children[0]
board.board.save_sgf()
filen = board.board.collectionsgf.filen
reconstruction_path = board.board.get_reconstruction()
new_pbv = self.new_board(from_file=filen, mode='Navigate')
new_pbv.board.reconstruct_from(reconstruction_path)
new_pbv.board.comment_pre_text = 'This [b]tablet mode[/b] is currently experimental. It should work fine, but is still being tested and will be subject to change (more efficient layout etc.) and speed optimisation before being finalised.\n-----\n'
App.get_running_app().manager.refresh_open_games()
else:
if not isinstance(board.children[0], PhoneBoardView):
print 'REFRESHING -> pbv'
board = self.get_screen(name)
self.close_board(name)
board = board.children[0]
board.board.save_sgf()
filen = board.board.collectionsgf.filen
reconstruction_path = board.board.get_reconstruction()
new_pbv = self.new_board(from_file=filen, mode='Navigate')
new_pbv.board.reconstruct_from(reconstruction_path)
App.get_running_app().manager.refresh_open_games()
def submitGUI(self):
""" Submit the GUI
Get all settings, confirm they are valid, save new settings file
"""
## Error Check All GUI SETTINGS
errorCheckPassed = self.check_GUI_settings()
# write GUI settings to file
if errorCheckPassed:
# Convery the GUI_settings from kivy dictproperty to a regular ol'
# python dict (and do some reformatting along the way)
allSettings = {}
for k in self.GUI_settings.keys():
# convert text inputs to integers
if k in ['pynealScannerPort', 'resultsServerPort', 'numTimepts']:
allSettings[k] = int(self.GUI_settings[k])
else:
allSettings[k] = self.GUI_settings[k]
# write the settings as the new config yaml file
with open(setupConfigFile, 'w') as outputFile:
yaml.dump(allSettings, outputFile, default_flow_style=False)
# Close the GUI
global submitButtonPressed
submitButtonPressed = True
App.get_running_app().stop()
EventLoop.exit()
def setUVBackground(self):
self.uvBackground = App.get_running_app().Obs['UVIndex'][3]
def no(self):
App.get_running_app().stop() # exit the application
def on_enter(self):
play_stim_set(
[App.get_running_app().stimulus,
App.get_running_app().probe])
def on_enter(self): # This code will run when exit screen is entered!
print('in exit screen')
print(
App.get_running_app().response
) # Note this reference to the app class is an easy way to point to these properties!
def messages_checker(self, dt):
while True:
if App.get_running_app().is_connected == False:
break
else:
# getting oraclesinfo for active room
oracles_info = rpclib.oracles_info(
App.get_running_app().rpc_connection,
App.get_running_app().active_room_id)
if App.get_running_app().active_room_id == '':
print("Seems messages grabbing works")
break
else:
# flushing it to not print previous messages
baton_returned = {}
# getting batons to print on each iteration
data_to_print = {}
# getting dictionary with current batontxid for each publisher
for entry in oracles_info["registered"]:
baton_returned[entry["publisher"]] = entry["batontxid"]
# updating batons for all publishers in app array
for publisher in baton_returned:
if publisher in App.get_running_app().current_baton:
# if publisher already here updating baton and adding it to print queue
if baton_returned[publisher] != App.get_running_app(
).current_baton[publisher]:
App.get_running_app().current_baton[
publisher] = baton_returned[publisher]
try:
data_to_print[
publisher] = rpclib.oracles_samples(
App.get_running_app(
).rpc_connection,
App.get_running_app(
).active_room_id,
baton_returned[publisher],
"1")['samples'][0][0]
except IndexError:
break
# if baton is the same as before there is nothing to update
else:
break
# if publisher not here adding it with latest baton and adding baton to print queue
else:
App.get_running_app().current_baton[
publisher] = baton_returned[publisher]
try:
data_to_print[
publisher] = rpclib.oracles_samples(
App.get_running_app().rpc_connection,
App.get_running_app().active_room_id,
baton_returned[publisher],
"1")['samples'][0][0]
except IndexError:
break
# finally printing messages
try:
for publisher in data_to_print:
message_list = ast.literal_eval(
data_to_print[publisher].replace('\r',
'\\r').replace(
'\n', '\\n'))
kvsearch_result = rpclib.kvsearch(
App.get_running_app().rpc_connection, publisher)
if 'value' in kvsearch_result:
addr = str(
P2PKHBitcoinAddress.from_pubkey(x(publisher)))
signature = kvsearch_result['value'][:88]
value = kvsearch_result['value'][88:]
verifymessage_result = rpclib.verifymessage(
App.get_running_app().rpc_connection, addr,
signature, value)
if verifymessage_result:
message_to_print = datetime.utcfromtimestamp(
message_list[0]).strftime(
'%D %H:%M') + '[' + kvsearch_result[
'value'][88:] + '-' + publisher[
0:10] + ']:' + message_list[1]
else:
message_to_print = 'IMPROPER SIGNATURE' + datetime.utcfromtimestamp(
message_list[0]).strftime(
'%D %H:%M') + '[' + kvsearch_result[
'value'][88:] + '-' + publisher[
0:10] + ']:' + message_list[1]
else:
message_to_print = datetime.utcfromtimestamp(
message_list[0]).strftime(
'%D %H:%M') + '[' + publisher[
0:10] + ']:' + message_list[1]
App.get_running_app().messages.append(message_to_print)
App.get_running_app(
).root.ids.messagesview.adapter.data = App.get_running_app(
).messages
break
except bitcoinrpc.authproxy.JSONRPCException as e:
print(App.get_running_app().active_room_id)
print(e)
break
def send_message(instance, inputid):
new_message = chatlib.message_sending(
App.get_running_app().rpc_connection,
App.get_running_app().active_room_id, str(inputid.text))
print(new_message)
inputid.text = ''
def subscribe_room(self, utxos_amount):
chatlib.room_subscription(App.get_running_app().rpc_connection,
str(App.get_running_app().active_room_id),
utxos_amount)
def create_nickname(self, nickname, password):
new_nickname = chatlib.set_nickname(
App.get_running_app().rpc_connection, nickname, password)
print(new_nickname)
def load_selected(self, selected):
if not selected:
return
root = App.get_running_app().root
root.set_namehash(selected)
root.ids["convershash"].text = selected
def load_direct(self):
root = App.get_running_app().root
root.set_namehash(self.entry[1])
root.ids["convershash"].text = self.entry[1]
def delete_friend_afterask(self):
root = App.get_running_app().root
ret = root.requester.requester.do_request("/client/delentity",
{"name": self.text})
if logcheck(ret):
root.load_friends()
def add_friend_after(self, name):
root = App.get_running_app().root
self.entry[3] = name
d = {"name": name, "hash": self.entry[1], "type": "client"}
root.requester.requester.do_request("/client/addhash", d, {})
self.update_friend()
def on_parent(self, instance, value):
if value:
app = App.get_running_app()
self._back = _back = partial(self.ids.back.dispatch, 'on_release')
def show_error(self, msg):
app = App.get_running_app()
Clock.schedule_once(lambda dt: app.show_error(msg))
def on_dismiss(self):
app = App.get_running_app()
if app.wallet is None and not self._on_release:
app.stop()
def on_parent(self, instance, value):
if value:
app = App.get_running_app()
self._back = _back = partial(app.dispatch, 'on_back')
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._shadow = App.get_running_app().theme_cls.round_shadow
#coding: utf-8
from kivy.app import App
from kivy.uix.label import Label
def build():
lbl_text = Label()
lbl_text.text = 'Curso de Python e Kivy'
lbl_text.italic = True
lbl_text.font_size = 50
return lbl_text
iniciar = App()
iniciar.build = build
iniciar.run()
def setBarometerArrow(self):
self.barometerArrow = App.get_running_app().Obs['Pres'][2]
def execute_run(self):
valuation_home = self.manager.parent.parent.manager.get_screen(
'valuation_home')
ss = self.manager.get_screen('selection_summary')
# Parse selection summary for arguments to pass to ValOp handler.
wiz_selections = ss.wiz_selections
iso = wiz_selections['iso']
node = wiz_selections['node']
nodeid = wiz_selections['nodeid']
data_manager = App.get_running_app().data_manager
rev_streams = data_manager.get_valuation_revstreams(
iso, nodeid)[wiz_selections['rev_streams']]['market type']
hist_data = wiz_selections['selected_data']
device = wiz_selections['device']
handler_requests = {}
handler_requests['iso'] = iso
handler_requests[
'market type'] = rev_streams # need this as string, not list
handler_requests['months'] = [(entry['month'], entry['year'])
for entry in hist_data]
handler_requests['node id'] = nodeid
handler_requests['param set'] = [{
param.desc['attr name']: param.param_slider.value
for param in device
}]
# Send requests to ValOp handler.
valop_handler = valuation_home.handler
valop_handler.solver_name = App.get_running_app().config.get(
'optimization', 'solver')
self.solved_ops, handler_status = valop_handler.process_requests(
handler_requests)
# If no optimizations were solved successfully, bail out.
if not self.solved_ops:
popup = WizardCompletePopup()
popup.title = "Hmm..."
popup.popup_text.text = "Unfortunately, none of the models were able to be solved. This is likely due to no data being available for the node selected. Try selecting another pricing node next time. (You selected {0}.)".format(
node)
popup.results_button.text = "Take me back"
popup.bind(on_dismiss=lambda x: self.manager.parent.parent.manager.
nav_bar.go_up_screen()) # Go back to Valuation Home
popup.open()
return
# Save selection summary details to pass to report generator.
deviceSelectionButtons = self.manager.get_screen(
'device_select').device_select.children
selectedDeviceName = [
x.text for x in deviceSelectionButtons if x.state == "down"
][0]
self.report_attributes = {
'market area':
iso,
'pricing node':
node,
'selected device':
selectedDeviceName,
'dates analyzed':
' to '.join([
' '.join([
calendar.month_name[int(hist_data[0]['month'])],
hist_data[0]['year']
]),
' '.join([
calendar.month_name[int(hist_data[-1]['month'])],
hist_data[-1]['year']
]),
]),
'revenue streams':
wiz_selections['rev_streams'],
'market type':
rev_streams,
}
for param in device:
self.report_attributes[
param.desc['attr name']] = param.param_slider.value
popup = WizardCompletePopup()
if not handler_status:
popup.title = "Success!*"
popup.popup_text.text = "All calculations finished. Press 'OK' to proceed to the results.\n\n*At least one model (month) had issues being built and/or solved. Any such model will be omitted from the results."
popup.bind(on_dismiss=self._next_screen)
popup.open()
def setLightningBoltIcon(self):
if App.get_running_app().Obs['StrikeDeltaT'][4] != '-':
if App.get_running_app().Obs['StrikeDeltaT'][4] < 360:
self.lightningBoltIcon = 'lightningBoltStrike'
else:
self.lightningBoltIcon = 'lightningBolt'
def __init__(self, **kwargs):
super(BarometerPanel, self).__init__(**kwargs)
App.get_running_app().BarometerPanel = self
self.setBarometerArrow()
def __init__(self, **kwargs):
super(RainfallPanel, self).__init__(**kwargs)
App.get_running_app().RainfallPanel = self
Clock.schedule_once(self.Clock)
self.animateRainRate()
def __init__(self, **kwargs):
super(LightningPanel, self).__init__(**kwargs)
App.get_running_app().LightningPanel = self
self.setLightningBoltIcon()
def on_pre_enter(self):
self.lbl.value = 1
App.get_running_app().response_made = False
def __init__(self, **kwargs):
super(MoonPhasePanel, self).__init__(**kwargs)
App.get_running_app().MoonPhasePanel = self
def __init__(self, **kwargs):
super(WindSpeedPanel, self).__init__(**kwargs)
App.get_running_app().WindSpeedPanel = self
self.setWindIcons()
def setWindIcons(self):
self.windDirIcon = App.get_running_app().Obs['WindDir'][2]
self.windSpdIcon = App.get_running_app().Obs['WindSpd'][3]
def slide_response(self, *args):
App.get_running_app().response = round(args[1], 1)
App.get_running_app().response_made = True
def __init__(self, **kwargs):
super(SunriseSunsetPanel, self).__init__(**kwargs)
App.get_running_app().SunriseSunsetPanel = self
self.setUVBackground()
