def join_game(self, *args):
values = {'login': self.login.text, 'password': self.password.text}
store = DictStore('store')
token = store.get('token')['values']
headers = {'authorization': 'Token {}'.format(token)}
response = requests.post(host+'main/game/join/', data=values, headers=headers)
print(response)
GameListWindow.__init__(self.instance)
store = DictStore('store')
if str(response) == '<Response [200]>':
store.put(key='active_game', values=response.json()['id'])
self.dismiss()
def test_dict_storage(self):
from kivy.storage.dictstore import DictStore
from tempfile import mkstemp
from os import unlink, close
try:
tmpfd, tmpfn = mkstemp('.dict')
close(tmpfd)
self._do_store_test_empty(DictStore(tmpfn))
self._do_store_test_filled(DictStore(tmpfn))
finally:
unlink(tmpfn)
def build(self):
if platform == 'android':
from android import AndroidService
service = AndroidService('irc1\'s service', 'running')
service.start('service started')
self.service = service
osc.init()
oscid = osc.listen(ipAddr='127.0.0.1', port=activityport)
osc.bind(oscid, self.main_api_callback, '/api/main')
Clock.schedule_interval(lambda *x: osc.readQueue(oscid), 0.1)
self.icon = 'data/icon.png'
self.servers = DictStore('servers.db')
self.msg_animation = Animation(opacity=1, transition='out_cubic')
self.screenmain = ScreenMain()
self.running = {}
self.boxes = {}
for name in sorted(dict(self.servers.find()).keys()):
data = self.servers.get(name)
box = ServerBox(name=name)
self.boxes[name] = box
self.screenmain.ids.servers.add_widget(box)
manager = ScreenManager(transition=SlideTransition(duration=0.2))
manager.add_widget(self.screenmain)
return manager
def __init__(self):
self.health = playerhealth
self.money = 0
self.gems = 0
self.upgPathSelectLvl = 5
self.abilities = list()
self.wavenum = 0
self.gameover = False
self.towerSelected = None
self.tbbox = None
self.layout = None
self.wavestart = 999
self.next_wave = False
self.pausetime = 0
self.state = "Start"
self.restart = False
self.score = 0
self.newMoveList = False
self.wavetime = None
self.wavetimeInt = None
self.myDispatcher = EventDispatcher.EventDisp()
self.analytics = Analytics.Analytics()
self.store = DictStore('settings.txt')
if self.store.exists('audio'):
self.soundOn = self.store.get('audio')['soundOn']
self.musicOn = self.store.get('audio')['musicOn']
else:
self.soundOn = True
self.musicOn = True
def update(self, *args):
try:
self.store = DictStore('store')
try:
self.pk = self.store.get('active_game')['values']
self.token = self.store.get('token')['values']
except KeyError:
pass
self.values = {'authorization': 'Token {}'.format(self.token)}
# remove widgets to replace them by updates
for element in self.children:
if element.id is not None:
self.remove_widget(element)
response = requests.get(host+'main/game/{}/'.format(str(self.pk)), headers=self.values)
if str(response) == '<Response [200]>':
self.response = response.json()
try:
if self.response['detail'] == 'Not found.':
pass
else:
self.draw_ui()
except KeyError:
self.draw_ui()
except ConnectionError:
self.add_widget(Label(text='Brak połączenia z serwerem. Sprawdź połączenie z Internetem.'))
def __init__(self, **kwargs):
super(HexGrid, self).__init__(do_rotation=False,
scale_min=.5,
scale_max=3.,
auto_bring_to_front=False)
self.gridsize = kwargs['gridsize']
self.gametype = kwargs['gametype']
self.gui = kwargs['gui']
# Preparem atlas d'imatges pels tiles
self.baseatlas = Atlas('assets/basetiles.atlas')
self.playeratlas = Atlas('assets/playertiles.atlas')
self.uiatlas = Atlas('assets/uitiles.atlas')
# Nomes gridsize inparell
assert (self.gridsize % 2 != 0)
# Preparem store
self.store = DictStore('hexland.dict')
self.grid = []
self.deads = {1: 0, 2: 0}
self.resetScore()
self.setup()
# Si ens construeixen amb estat, el carreguem
if kwargs['state']:
self.loadState(kwargs['state'], True)
self.reloadGridGraphics()
# Si estem vs cpu, creem el jugador CPU
if not self.gametype == GAMETYPE["PVP"]:
self.cpu = CpuPlayer(self.gametype)
def delNote(touch):
#Deleting on Screen
var = sm.current
toNotesright(touch)
#
#
#delete notescreen
for item in sm.children:
if item.name == var:
sm.remove_widget(item)
#delete button
for item in notes.stack.children:
if item.name == var:
notes.stack.remove_widget(item)
#Deleting from shelve
store = DictStore('store13.dat')
#removing index
mylist = store['index']['num']
mylist.remove(var)
store['index']['num'] = mylist
#removing df item
store.delete(var)
def findNotes(touch):
if notes.txt.text != '':
import re
keyword = notes.txt.text
matchlist = []
for x in notes.stack.children:
key = x.name
store = DictStore('store13.dat')
each = store[key]['note']
matchobj = re.search(keyword.lower(), each.lower())
if matchobj:
matchlist.append(key)
children = []
for each in notes.stack.children:
children.append(each.name)
for x in matchlist:
children.remove(x)
purge = children
for each in purge:
for item in notes.stack.children:
if each == item.name:
notes.stack.remove_widget(item)
if len(notes.stack.children) == 0:
nofound = Label(text='No matches were found.',
font_size='20sp',
text_size=(300, 300))
notes.stack.add_widget(nofound)
def create_new_game(self):
if self.password.text != '' and self.login.text != '':
values = {'login': self.login.text, 'password': self.password.text}
store = DictStore('store')
token = store.get('token')['values']
headers = {'authorization': 'Token {}'.format(token)}
requests.post(host+'main/game/', data=values, headers=headers)
self.join_game()
def __init__(self, **kwargs):
self.uiatlas = Atlas('assets/uitiles.atlas')
self.store = DictStore('hexland.dict')
super(Menu, self).__init__(**kwargs)
self.logo_img.size_hint = 0.1, 0.1
Animation(size_hint=(0.8, 0.3), t='out_bounce').start(self.logo_img)
def __init__(self):
super(Analytics, self).__init__()
self.gameTimeStart = 0
self.gameTimeEnd = 0
self.playerData = DictStore('player_data.txt')
if self.playerData.exists('lastgame'):
self.numEnemies = self.playerData.get('lastgame')['numEnemies']
self.gameDamage = self.playerData.get('lastgame')['gameDamage']
self.towersBought = self.playerData.get('lastgame')['towersBought']
self.towersSold = self.playerData.get('lastgame')['towersSold']
self.towerUpgrades = self.playerData.get(
'lastgame')['towerUpgrades']
self.maxTowerLevel = self.playerData.get(
'lastgame')['maxTowerLevel']
self.finalWave = self.playerData.get('lastgame')['finalWave']
self.moneyEarned = self.playerData.get('lastgame')['moneyEarned']
self.moneySpent = self.playerData.get('lastgame')['moneySpent']
self.gameLength = self.playerData.get('lastgame')['gameLength']
self.score = self.playerData.get('lastgame')['score']
else:
self.numEnemies = 0
self.gameDamage = 0
self.towersBought = 0
self.towersSold = 0
self.towerUpgrades = 0
self.maxTowerLevel = 1
self.finalWave = 1
self.moneyEarned = 0
self.moneySpent = 0
self.gameLength = (0, 0)
self.score = 0
if self.playerData.exists('totals'):
self.totalGames = self.playerData.get('totals')['totalGames']
self.totalEnemies = self.playerData.get('totals')['totalEnemies']
self.totalDamage = self.playerData.get('totals')['totalDamage']
self.totalBought = self.playerData.get('totals')['totalBought']
self.totalSold = self.playerData.get('totals')['totalSold']
self.totalUpgraded = self.playerData.get('totals')['totalUpgraded']
self.highestTowerLevel = self.playerData.get(
'totals')['highestTowerLevel']
self.latestWave = self.playerData.get('totals')['latestWave']
self.totalEarned = self.playerData.get('totals')['totalEarned']
self.totalSpent = self.playerData.get('totals')['totalSpent']
self.timePlayed = self.playerData.get('totals')['timePlayed']
else:
self.totalGames = 0
self.totalEnemies = 0
self.totalDamage = 0
self.totalBought = 0
self.totalSold = 0
self.totalUpgraded = 0
self.highestTowerLevel = 1
self.latestWave = 1
self.totalEarned = 0
self.totalSpent = 0
self.timePlayed = {'hours': 0, 'minutes': 0, 'seconds': 0}
def __init__(self, dispatch, resume=True):
self.__dispatch = dispatch
self.__worker = WorkerThread()
self.hist = [Position(initial, 0, (True, True), (True, True), 0, 0)]
self.board = chess.Board()
self.redo = []
self.searcher = Searcher()
self.store = DictStore('fisher.dat')
if resume:
self.load_game()
def __init__(self):
self.__store = DictStore('user.dat')
if self.__store.store_exists('finalDay') and self.__store.get('finalDay')['data']:
self.__startDay = self.__store.get('startDay')['data']
self.__finalDay = self.__store.get('finalDay')['data']
self.__count = self.__store.get('count')['data']
self.__isKontrabas = self.__store.get('isKontrabas')['data']
self.__isNotReady = False
else:
self.reset()
def __init__(self, data_path, refresh_ui):
self.refresh_ui = refresh_ui
self.data_path = data_path
fb_db = DictStore(join(data_path, 'fb.db'))
if not fb_db.exists('data'):
fb_db.put('data')
self.db = fb_db
if self.db['data'].get('token') and not platform in ('ios', 'android'):
self.token = self.db['data']['token']
self.refresh_token()
else:
pass
def do_login(self, *args):
try:
values = {'username': self.username.text, 'password': self.password.text}
response = requests.post(host+'api-token-auth/', data=values)
store = DictStore('store')
try:
store.put(key='token', values=response.json()['token'])
store.put(key='username', values=self.username.text)
except KeyError:
pass
self.dismiss()
GameListWindow.__init__(self.instance)
except ConnectionError:
pass
def send_points(self):
try:
store = DictStore('store')
try:
pk = store.get('active_game')['values']
token = store.get('token')['values']
values = {'authorization': 'Token {}'.format(token)}
points = {'points': self.sum_to_display}
requests.post(host+'main/game/{}/add_points/'.format(str(pk)), headers=values, data=points)
# try to create new round
requests.post(host+'main/game/{}/new_deal/'.format(str(pk)), headers=values)
except KeyError:
pass
except ConnectionError:
pass
def get_store(store_name, subfolder=None, as_backup=False, from_backup=False):
app = App.get_running_app()
# remove .pydict
if store_name.endswith('.pydict'):
store_name.strip('.pydict')
# add _backup if its a backup
if from_backup:
store_name += '_backup'
# always add .pydict (as it was removed if it existed)
store_name += '.pydict'
if not subfolder:
# get the path (straightforward)
store_path = path.join(app.user_data_dir, store_name)
else:
# get the subfolder's path
folder_path = path.join(app.user_data_dir, subfolder)
try:
# try to make the subfolder
mkdir(folder_path)
except:
# if it already exists then simply print the line bellow and do nothing else
print('i guess its already made')
# get the store's path
store_path = path.join(folder_path, store_name)
# return the correct storage type
if as_backup is True:
# if as_backup is simply True, then try to get the store with the same name
# this is a little inefficient but who cares really
store = get_store(store_name, subfolder)
return BackupDictStore(store_path, store)
elif as_backup:
# if as_backup is specified then backup from the specified store
return BackupDictStore(store_path, as_backup)
else: # if not as backup...., just open a normal store
return DictStore(store_path)
def __init__(self, **kwargs):
super(GameListWindow, self).__init__(**kwargs)
try:
try:
self.remove_widget(self.children[-1])
self.remove_widget(self.children[1])
except IndexError:
pass
store = DictStore('store')
try:
token = store.get('token')['values']
except KeyError:
token = ''
values = {'authorization': 'Token {}'.format(token)}
self.response = requests.get(self.http, headers=values)
try:
self.username = store.get('username')['values']
except KeyError:
self.username = ''
grid = GridLayout(id='my_grid', cols=1, pos=(0, 0), size_hint=[self.size_hint_x, .9])
for element in self.response.json()['results']:
grid.add_widget(Button(text=element['login'], on_release=self.game_button))
new_grid = GridLayout(rows=1)
if self.response.json()['previous'] is not None:
new_grid.add_widget(Button(id='previous_button', text='Poprzednie', on_press=self.previous_button))
if self.response.json()['next'] is not None:
new_grid.add_widget(Button(id='next_button', text='Następne', on_press=self.next_button))
grid.add_widget(new_grid)
self.add_widget(grid)
except ConnectionError:
self.add_widget(Label(text='Brak połączenia z serwerem. Sprawdź połączenie z Internetem.'))
def __init__(self, *args):
self.store = DictStore('user.dat')
self.clientCoutnry = 'notSpecified'
self.previousRound = ''
self.intRound = 0
self.dictRounds = {
'0': 'zero',
'1': 'one',
'2': 'two',
'3': 'three',
'4': 'four',
'5': 'five'
}
self.round = 'zero'
self.IP_Adress = 'http://localhost:8080'
self.question = ''
self.questionAddition = ''
self.numberOfQuestion = ''
self.votingResult = {
'zero_yes': 0,
'zero_no': 0,
'one_yes': 0,
'one_no': 0,
'two_yes': 0,
'two_no': 0,
'three_yes': 0,
'three_no': 0,
'four_yes': 0,
'four_no': 0,
'five_yes': 0,
'five_no': 0,
'final_yes': 0,
'final_no': 0
}
if self.store.exists('IP'):
self.IP_Adress = self.store.get('IP')['data']
open_url(url)
def open_new(self, url):
open_url(url)
def open_new_tab(self, url):
open_url(url)
webbrowser.register('android', AndroidBrowser, None, -1)
webbrowser.open(url)
## END hack
cookie_jar = DictStore('cookies.dat')
session = None
autofinger_list = {}
now_time = datetime.datetime.now()
now_stamp = now_time.strftime("%Y-%m-%d %H:%M:%S")
now_filesafe = now_time.strftime("%Y-%m-%d_%H%M%S")
log_file = 'grinnell_plans_{}.txt'.format(now_filesafe)
## TODO: add remember username/password button
def LLOOGG(message):
global now_stamp
global log_file
Logger.info(message)
from kivy.clock import Clock
import threading
import datetime
import os
from ImageDownload import downloadimages
class Program:
def __init__(self, isim, time, kanal):
self.isim = isim
self.time = time
self.kanal = kanal
store = DictStore('data.py')
Programlar = []
Kanallar_settings = [False] * 47
if (store.exists('1')):
print('loading data')
for i in range(0, len(Kanallar_settings)):
Kanallar_settings[i] = store.get(str(i))['state']
class WindowManager(ScreenManager):
pass
class ChooseWindow(Screen):
renklist = ListProperty(None)
import os
import json
import webbrowser
from kivy.network.urlrequest import UrlRequest
from kivy.storage.dictstore import DictStore
from kivy.app import App
from kivy.properties import StringProperty
from kivy.lang import Builder
from kivy.uix.screenmanager import ScreenManager, Screen
BASE_URL = "https://c73e12ff8ac1.ngrok.io"
USER_ID = "user1"
store = DictStore("tempo.dat")
Builder.load_string("""
<HomeScreen>:
BoxLayout:
orientation: "vertical"
Button:
text: "Create order"
on_release: root.create_order()
Button:
text: "start transaction"
on_release: root.start_transaction()
Button:
text: "check if transaction is complete"
on_release: root.is_transaction_complete()
Label:
text: root.status
def test_dict_storage(self):
from kivy.storage.dictstore import DictStore
data = {}
self._do_store_test_empty(DictStore(data))
self._do_store_test_filled(DictStore(data))
class GameWindow(Screen):
store = DictStore('store')
pk = 0
token = ''
values = {'authorization': 'Token {}'.format(token)}
response = ''
def __init__(self, **kwargs):
super(GameWindow, self).__init__(**kwargs)
try:
self.update()
except ConnectionError:
pass
def update(self, *args):
try:
self.store = DictStore('store')
try:
self.pk = self.store.get('active_game')['values']
self.token = self.store.get('token')['values']
except KeyError:
pass
self.values = {'authorization': 'Token {}'.format(self.token)}
# remove widgets to replace them by updates
for element in self.children:
if element.id is not None:
self.remove_widget(element)
response = requests.get(host+'main/game/{}/'.format(str(self.pk)), headers=self.values)
if str(response) == '<Response [200]>':
self.response = response.json()
try:
if self.response['detail'] == 'Not found.':
pass
else:
self.draw_ui()
except KeyError:
self.draw_ui()
except ConnectionError:
self.add_widget(Label(text='Brak połączenia z serwerem. Sprawdź połączenie z Internetem.'))
def draw_ui(self):
grid = GridLayout(id='my_grid', anchor_y='top',
cols=1, pos=(0, 0), size_hint=[self.size_hint_x, self.size_hint_y])
grid_scoreboard = GridLayout(cols=1, anchor_y='top', size_hint=[self.size_hint_x, .32])
grid_scoreboard.add_widget(Label(text='Tablica wyników:'))
for element in self.response['scoreboard']:
grid_scoreboard.add_widget(Label(text='{} {}'.format(element[1], element[0])))
grid_last_round = GridLayout(cols=1, anchor_y='top', size_hint=[self.size_hint_x, .32])
try:
grid_last_round.add_widget(Label(text='Runda nr {}:'.format(self.response['deals'][0]['count'])))
for element in self.response['deals'][0]['points']:
label = Label(text='{} {}'.format(element['points'], element['user']['username']))
grid_last_round.add_widget(label)
except IndexError:
pass
grid_all_rounds = GridLayout(cols=1, anchor_y='top', size_hint=[self.size_hint_x, .6])
for element in self.response['deals'][1:11]:
grid_all_rounds.add_widget(Button(text='Runda {}'.format(element['count']), on_release=self.display_round))
grid.add_widget(Label(pos=(0, 0), text=self.response['login'], size_hint=[self.size_hint_x, .04]))
grid.add_widget(grid_scoreboard)
grid.add_widget(grid_last_round)
grid.add_widget(grid_all_rounds)
self.add_widget(grid)
def display_round(self, instance):
count = int(instance.text[6:])
grid = GridLayout(anchor_y='top', cols=1, size_hint=[self.size_hint_x, self.size_hint_y])
try:
for element in self.response['deals']:
if element['count'] == count:
for i in element['points']:
label = Label(text='{} {}'.format(i['points'], i['user']['username']))
grid.add_widget(label)
except IndexError:
pass
popup = Popup(content=grid, title=instance.text, size=("300dp", "250dp"),
size_hint=(None, None), auto_dismiss=True)
popup.open()
from pathlib import Path
from kivy import platform
from kivy.storage.dictstore import DictStore
file_path = Path('.')
if platform == 'macosx':
file_path = Path('~/Library/Application Support/%s' %
'simple-time-tracker').expanduser()
file_path.mkdir(parents=True, exist_ok=True)
store = DictStore(file_path.joinpath('settings.json'))
def game_button(self, instance):
for element in self.response.json()['results']:
if element['login'] == instance.text:
store = DictStore('store')
store.put(key='active_game', values=element['id'])
def data_retrieve(touch=None):
notes.stack.clear_widgets()
store = DictStore('store13.dat')
if len(store.keys()) <= 1:
pass
else:
index_stamp = store['index']['num']
index_stamp.reverse()
for x in index_stamp:
timestamp = x
notetext = store[x]['note']
notetime = store[x]['notetime']
notecolor_dt = store[x]['color']
#Note
note = Note(notetext[10:], timestamp)
#NoteButton
notebutton = note.button
notebutton.background_color = notecolor_dt
notebutton.name = timestamp
if len(notetext) >= 20:
notebutton.text = notetext[:
20] + '...' + '\n %s' % notetime
else:
notebutton.text = notetext + '\n %s' % notetime
notes.stack.add_widget(notebutton)
#NoteScreen
notescreen = note.notescreen
notescreen.name = timestamp
notescreen.txt.text = notetext
notescreen_color = notebutton.background_color
notescreen_color = list(notescreen_color)
notescreen.dropdown.main.background_color = notescreen_color
sm.add_widget(notescreen)
def delNote(touch):
#Deleting on Screen
var = sm.current
toNotesright(touch)
#
#
#delete notescreen
for item in sm.children:
if item.name == var:
sm.remove_widget(item)
#delete button
for item in notes.stack.children:
if item.name == var:
notes.stack.remove_widget(item)
#Deleting from shelve
store = DictStore('store13.dat')
#removing index
mylist = store['index']['num']
mylist.remove(var)
store['index']['num'] = mylist
#removing df item
store.delete(var)
def note_Update(touch):
curnote = sm.children[0]
newnotetext = curnote.txt.text
notecolor_up_dt = curnote.dropdown.main.background_color
notecolor_up_dt = list(notecolor_up_dt)
if curnote.txt.text != '':
var = sm.current
sm.transition = WipeTransition()
sm.current = 'notes'
store = DictStore('store13.dat')
mylist = store['index']['num']
mylist.remove(var)
store['index']['num'] = mylist
#removing df item
store.delete(var)
#delete notescreen
for item in sm.children:
if item.name == var:
sm.remove_widget(item)
#delete button
for item in notes.stack.children:
if item.name == var:
notes.stack.remove_widget(item)
#adding new note
#working out timestamp
timenow = time.asctime(time.localtime(time.time()))
timenow = str(timenow)
timeraw = timenow[7:19]
strip = timeraw.replace(' ', '')
timemark = strip.replace(':', '')
timestamp = timemark
notetime = 'On ' + timenow[:10] + ' at ' + timenow[
11:19]
#StoreData
if 'index' in store.keys():
card = store['index']['num']
card.append(timestamp)
store['index']['num'] = card
else:
store['index'] = {'num': []}
card = store['index']['num']
card.append(timestamp)
store['index']['num'] = card
store[timestamp] = {
'note': newnotetext,
'notetime': notetime,
'color': notecolor_up_dt
}
#Note
note = Note(newnotetext[10:], timestamp)
#NoteButton
notebutton = note.button
notebutton.background_color = notecolor_up_dt
notebutton.name = timestamp
if len(newnotetext) > 20:
notebutton.text = newnotetext[:
20] + '...' + '\n %s' % notetime
else:
notebutton.text = newnotetext + '\n ' + notetime
notes.stack.add_widget(notebutton,
len(notes.stack.children))
#NoteScreen
notescreen = note.notescreen
notescreen.name = timestamp
notescreen.txt.text = newnotetext
notescreen.dropdown.main.background_color = notecolor_up_dt
sm.add_widget(notescreen)
notescreen.update_button.bind(
on_release=note_Update)
notescreen.actionprevious.bind(
on_release=toNotesright)
notescreen.delete_button.bind(on_release=delNote)
# binding back, delete and update on notescreen
notescreen.actionprevious.bind(on_release=toNotesright)
notescreen.delete_button.bind(on_release=delNote)
notescreen.update_button.bind(on_release=note_Update)
import android
except ImportError:
android = None
from kivy.core.window import Window
W = 333
Window.size = (W, W * 16 / 9)
from plyer import storagepath
if android:
from jnius import autoclass
from plyer.platforms.android import activity
store = DictStore("cryptculatorapp.data")
APK_FILE_PATH = storagepath.get_downloads_dir() + '/cryptculatorapp.apk'
class CustomTextInput(TextInput):
name = StringProperty('')
def on_text(self, instance, text):
store.put(self.name, value=text)
def copy(self, data=''):
Clipboard.copy(self.selection_text)
def cut(self):
Clipboard.copy(self.selection_text)
self.delete_selection()
class Mirror(App):
#configs = DictProperty()
#sys = DictProperty()
mirror_name = StringProperty()
multicast_ip = StringProperty('224.3.29.71')
multicast_port = NumericProperty(11088)
store = DictStore('mirror_config.pckl')
dgram_server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
tcp_server = socket.socket()
# Returns {'Mirror name':[(ip,port),last_edited_time]} to client
def start_dgram_server(self):
# 1. Create datagram socket
self.dgram_server.bind(('', self.multicast_port))
Logger.info('Multicast server created, on ip {}, port {}'.format(
self.multicast_ip, self.multicast_port))
# 2. Add socket to multicast group
multicast_ip = socket.inet_aton(
self.multicast_ip) # Converts ip into packed 32-bit binary'
mreq = struct.pack('4sL', multicast_ip, socket.INADDR_ANY)
self.dgram_server.setsockopt(socket.IPPROTO_IP,
socket.IP_ADD_MEMBERSHIP, mreq)
# 3. Set socket to listening mode
while True:
Logger.info('Awaiting dgram message on ip {}, port {}'.format(
self.multicast_ip, self.multicast_port))
# 4. Receive request from client
data_encoded, address = self.dgram_server.recvfrom(4096)
Logger.info(
'Received {} bytes on datagram server, from ip {}'.format(
len(data_encoded), address))
try:
data, request = pickle.loads(data_encoded)
except:
Logger.error('Failed to unpickle data!')
# 5. Reply to client with name and id of mirror, and when it was last edited
# Packaged in tuple of form: (mirror_id,mirror_name,last_edited)
if request == 'name':
try:
mirror_data = self.store.get(MIRROR_ID)
mirror_name = mirror_data['sys']['mirror_name']
last_edited = mirror_data['sys']['last_edited']
reply = pickle.dumps((MIRROR_ID, mirror_name, last_edited),
protocol=2)
except:
Logger.error(
'Was unable to find and/or pickle mirror data! Failed to reply to multicast.'
)
try:
self.dgram_server.sendto(reply, address)
Logger.info(
'Replied to multicast request from {}'.format(address))
except:
Logger.error('Failed to send reply to multicast!')
Logger.info('Shutting down DGRAM server.')
def start_tcp_server(self):
# 1. Create socket
try:
self.tcp_server.bind(('', 54321))
self.tcp_server.listen(5)
Logger.info('Created TCP server.')
except:
Logger.critical('Failed to create TCP server!')
# 2. Set to listening mode
while True:
Logger.info('Awaiting message on TCP server.')
client, address = self.tcp_server.accept()
Logger.info('Received TCP connection from ip {}.'.format(address))
# 3. Unpack data from client. format is tuple of (data,request)
try:
data_pickled = client.recv(4096)
data, request = pickle.loads(data_pickled)
Logger.info(
'Unpickled {} bytes via TCP connection. Request: {}'.
format(len(data_pickled), request))
except:
Logger.error('Failed to unpack mirror data on TCP server!')
continue
# 4. If request is to update_phone, send mirror info back in tuple (mirror_id,mirror_data)
# mirror_data is packaged in dict of form {'sys': ..., 'config': ...}
if request == 'update_phone':
Logger.info(
'Mirror data was requested from client. Packaging config files...'
)
try:
mirror_configs = self.store.get(MIRROR_ID)
configs_pickled = pickle.dumps((MIRROR_ID, mirror_configs),
protocol=2)
except:
Logger.error(
'Failed to load and/or pickle mirror configs!')
try:
client.send(configs_pickled)
Logger.info(
'Send mirror info back to client. Closing socket.')
except:
Logger.error(
'Failed to send mirror info back to client. Closing socket.'
)
client.close()
continue
# 6. If request is to update_mirror, updates mirror's info with received data
# Received data is of the form {'sys': ...,'configs': ...}
if request == 'update_mirror':
Logger.info('Updating mirror with received config.')
try:
self.store.put(MIRROR_ID,
sys=data['sys'],
configs=data['configs'])
except:
Logger.error('Failed to save new mirror data to storage.')
# Have to schedule these so they're done on the main thread
Clock.schedule_once(self.load_mirror_info, 0)
Clock.schedule_once(self.root.load_mirror, 0)
continue
Logger.info('Shutting down TCP server.')
def generate_widget(self, widget_type, config={}):
# 1. Create default widget
if widget_type == 'Time':
new_widget = TimeWidget()
elif widget_type == 'Weather':
new_widget = WeatherWidget()
elif widget_type == 'Clock':
new_widget = ClockWidget()
else:
Logger.critical("Not implemented yet how'd you get here")
return False
# 2. Load specified configuration
config_keys = config.keys()
new_widget_properties = new_widget.properties(
) # loads ALL kivy properties in list
for key in config_keys:
if key in new_widget_properties: # if key in config file is a kivy property of the widget, update it with that value
setattr(new_widget, key, config[key])
# 3. Initialize new widget to reflect specified config settings
new_widget.initialize()
return new_widget
def on_stop(self):
Logger.info('Application closed. Shutting down TCP and UDP servers.')
self.tcp_server.close()
self.dgram_server.close()
def load_mirror_info(self, *args):
# 1. If no config file exists, create one
if not self.store.keys():
Logger.info(
"Couldn't find anything in mirror_config.pckl. Creating new one."
)
self.store.clear()
self.store.put(MIRROR_ID,
sys=deepcopy(FRESH_CONFIG_FILE['sys']),
configs=deepcopy(FRESH_CONFIG_FILE['configs']))
# 2. Extract mirror info from storage
config_data = self.store.get(MIRROR_ID)
self.sys = config_data['sys']
self.configs = config_data['configs']
Logger.info('Loaded mirror info into memory.')
def load_city_list(self):
ts = time.time()
with open('city_list.json') as f:
self.city_list = json.load(f)
Logger.info('Loaded city list in {} seconds.'.format(time.time() - ts))
def build(self):
#0. Load city list
# Load city list into memory (takes like ~1 s, so does it asynchronously)
self.load_city_list()
#1. Load mirror config info
self.load_mirror_info()
#2. Start multicast server
# This server's only purpose is to listen for a ping and send back its name, id, and last edited
dgram_thread = threading.Thread(target=self.start_dgram_server)
dgram_thread.start()
#3. Start server to listen for TCP data
# This server is used for updating mirror config info from phone
tcp_thread = threading.Thread(target=self.start_tcp_server)
tcp_thread.start()
#4. Intialize and load mirror
r = RootLayout()
return r
app.root.current = "Instructions"
phrase = PHRASES[sm.test_index]
#pass
#app.root.current = "Test"
#if the next trial is a nonpractice phrase, qeue pre-trial Instruction screen
#non practice intrusctions
else:
# finished all tests, take me to done screen
app.root.current = "Done"
class LastWin(Screen):
pass
storage = DictStore('data.csv', [])
#create class which reps transitions between the windows
class WindowManager(ScreenManager):
test_index = 0
tests = storage.get('data')['data'] if storage.exists('data') else []
curr_ptcp_id = None
curr_test_id = None
curr_phrase_id = None
def test_start(self):
self.tests.append([])
self.test_data("")
sm.test_index += 1
