class WeatherRoot(BoxLayout):
carousel = ObjectProperty()
current_weather = ObjectProperty()
forecast = ObjectProperty()
locations = ObjectProperty()
add_location_form = ObjectProperty()
def __init__(self, **kwargs):
super(WeatherRoot, self).__init__(**kwargs)
self.store = JsonStore("weather_store.json")
if self.store.exists('locations'):
current_location = self.store.get("locations")["current_location"]
self.show_current_weather(current_location)
def show_current_weather(self, location=None):
self.clear_widgets()
if self.current_weather is None:
self.current_weather = CurrentWeather()
if self.locations is None:
self.locations = Factory.Locations()
if (self.store.exists('locations')):
locations = self.store.get("locations")['locations']
self.locations.locations_list.adapter.data.extend(locations)
if location is not None:
self.current_weather.location = location
if location not in self.locations.locations_list.adapter.data:
self.locations.locations_list.adapter.data.append(location)
self.locations.locations_list._trigger_reset_populate()
self.store.put("locations",
locations=list(self.locations.locations_list.adapter.data),
current_location=location)
self.current_weather.update_weather()
self.add_widget(self.current_weather)
def show_forecast(self, location=None):
self.clear_widgets()
if self.forecast is None:
self.forecast = Factory.Forecast()
if location is not None:
self.forecast.location = location
self.forecast.update_weather()
self.add_widget(self.forecast)
# BEGIN SHOW_MODAL_VIEW
def show_add_location_form(self):
self.add_location_form = AddLocationForm()
self.add_location_form.open()
# END SHOW_MODAL_VIEW
def show_locations(self):
self.clear_widgets()
self.add_widget(self.locations)
class MbtMergeManager(object):
"""
Keeps track mbtiles merging state (merged vs not merged)
and handles merging.
"""
def __init__(self):
json_store_path = App.get_running_app().json_store_path
self.store = JsonStore(json_store_path)
def merge_not_merged(self):
"""
Merges not merged files.
"""
mbtmerge = MbtMerge()
sources = self.not_merged()
destination = App.get_running_app().main_mbtiles_path
mbtmerge.merge(sources, destination)
for source in sources:
self.add_to_merged(source)
def not_merged(self):
"""
Returns the list of not merged files.
"""
merged_list = self.merged()
not_merged_list = App.get_running_app().mbtiles_paths
for merged in merged_list:
not_merged_list.remove(merged)
return not_merged_list
def merged(self):
"""
Returns the list of merged files.
"""
try:
merged = self.store.get('merged_mbtiles')['list']
except KeyError:
merged = []
return merged
def add_to_merged(self, mbtiles_path):
"""
Adds the mbtiles to the merged list.
"""
merged = self.merged()
merged.append(mbtiles_path)
self.store.put('merged_mbtiles', list=merged)
def remove_from_merged(self, mbtiles_path):
"""
Removes the mbtiles from the merged list.
"""
merged = self.merged()
merged.remove(mbtiles_path)
self.store.put('merged_mbtiles', list=merged)
def storeformdata(self):
store = JsonStore('forms.json')
store.put('forms',
walletname=self.input_name.text,
sendtoaddress=self.input_address.text,
amount=self.input_amount.text,
mixin=self.input_mixin.text,
paymentid=self.input_paymentid.text,
mineraddress=self.minerurl_input.text,
mineruser=self.mineruser_input.text,
minerpw=self.minerpw_input.text,
minerthreads=self.minerthreads_input.text)
class ScoreBar(BoxLayout):
score = NumericProperty()
hi_score = NumericProperty()
game_id = StringProperty()
players = NumericProperty()
active_player = NumericProperty()
def __init__(self,**kwargs):
super(ScoreBar,self).__init__(**kwargs)
self.store = JsonStore(os.path.join(get_user_path(),'scores.json'))
self.bind(score = self.score_changed)
self.set_game_id()
def set_game_id(self, game_id = 'default', multiplayer = False):
self.players = int(multiplayer) + 1
self.active_player = 1
self.game_id = game_id
if self.players == 1:
if self.store.exists(game_id):
data = self.store.get(game_id)
self.hi_score = data['high_score']
else:
self.hi_score = 0
def score_changed(self, *args):
if self.players == 2:
return
if self.game_id != 'default':
date = uspac.fromutc(datetime.datetime.utcnow())
game_id = 'd%i%i%i'%(date.year, date.month, date.day)
if self.game_id != game_id:
#daily challenge has finished, the game reverts to default type so we only update the default high score table
self.set_game_id()
else:
#store the high score in the default table as well as in the daily table
hi_score = 0
if self.store.exists('default'):
data = self.store.get('default')
hi_score = data['high_score']
if self.score > hi_score:
self.store.put('default',high_score=int(self.score))
if self.score > self.hi_score:
self.hi_score = self.score
self.store.put(self.game_id,high_score=int(self.score))
if platform == 'android' and self.players == 1:
if self.score > 600:
App.get_running_app().gs_achieve('achievement_score_of_600')
if self.score > 800:
App.get_running_app().gs_achieve('achievement_score_of_800')
if self.score > 1000:
App.get_running_app().gs_achieve('achievement_score_of_1000')
if self.score > 1200:
App.get_running_app().gs_achieve('achievement_score_of_1200')
class UrbanRoot(BoxLayout):
urbansearch = ObjectProperty()
urbandict = ObjectProperty()
def __init__(self, **kwargs):
super(UrbanRoot, self).__init__(**kwargs)
self.store = JsonStore("dictionary.json")
self.update_urbandict()
def add_to_dictionary(self, word, definition, example):
current = self.store.get('dictionary')['dictionary'] if self.store.exists('dictionary') else []
d = {
'word' : word.encode('utf-8'),
'definition' : definition.encode('utf-8'),
'example' : example.encode('utf-8')
}
if d not in current:
current.append(d)
self.store.put('dictionary', dictionary = list(current))
self.update_urbandict()
Popup(size_hint=(0.8,0.2),title='Success', content = Label(text = 'Word has been added into dictionary')).open()
def update_urbandict(self):
current = self.store.get('dictionary')['dictionary'] if self.store.exists('dictionary') else []
self.urbandict.urbandictcontainer.clear_widgets()
for d in current:
item = Factory.UrbanItemDict()
item.word = d['word'].encode('utf-8')
item.definition = d['definition'].replace('\r','').replace('\t','').encode('utf-8')
item.example = d['example'].replace('\r','').replace('\t','').encode('utf-8')
self.urbandict.urbandictcontainer.add_widget(item)
def remove_from_dict(self, word, definition, example):
current = self.store.get('dictionary')['dictionary'] if self.store.exists('dictionary') else []
d = {
'word' : word.encode('utf-8'),
'definition' : definition.encode('utf-8'),
'example' : example.encode('utf-8')
}
if d in current:
current.remove(d)
self.store.put('dictionary', dictionary = list(current))
print 'removed'
self.update_urbandict()
class MainApp(App):
#create the application screens
def build(self):
data_dir = getattr(self, 'user_data_dir') #get a writable path to save our score
self.store = JsonStore(join(data_dir, 'score.json')) # create a JsonScore file in the available location
if(not self.store.exists('score')): # if there is no file, we need to save the best score as 1
self.store.put('score', best=1)
if platform() == 'android': # if we are on Android, we can initialize the ADs service
revmob.start_session('54c247f420e1fb71091ad44a')
self.screens = {} # list of app screens
self.screens['menu'] = MenuScreen(self) #self the MainApp instance, so others objects can change the screen
self.screens['game'] = GameScreen(self)
self.root = FloatLayout()
self.open_screen('menu')
self.sound = SoundLoader.load('res/background.mp3') # open the background music
# kivy support music loop, but it was not working on Android. I coded in a different way to fix it
# but if fixed, we can just set the loop to True and call the play(), so it'll auto repeat
# self.sound.loop = True It # was not working on android, so I wrote the following code:
self.sound.play() # play the sound
Clock.schedule_interval(self.check_sound, 1) #every second force the music to be playing
return self.root
# play the sound
def check_sound(self, dt = None):
self.sound.play()
# when the app is minimized on Android
def on_pause(self):
self.sound.stop() # the stop the sound
Clock.unschedule(self.check_sound)
if platform() == 'android': #if on android, we load an ADs and show it
revmob.show_popup()
return True
# when the app is resumed
def on_resume(self):
self.sound.play() # we start the music again
Clock.schedule_interval(self.check_sound, 1)
# show a new screen.
def open_screen(self, name):
self.root.clear_widgets() #remove the current screen
self.root.add_widget(self.screens[name]) # add a new one
self.screens[name].run() # call the run method from the desired screen
def get_public_key():
if DataMode.communication in KivyLogger.base_mode:
# get from communication
pub_pem = KivyLogger.socket.recv(1024)
else:
private_key = RSA.generate(2048, e=65537)
prv_pem = private_key.exportKey("PEM")
store = JsonStore(KivyLogger.filename + '.enc')
store.put('private_key', pem=prv_pem)
pub_pem = private_key.publickey().exportKey("PEM")
KivyLogger.public_key = RSA.importKey(pub_pem)
pass
def on_pre_leave(self, *args):
if len(self.haberadi.text)<3 and len(self.takmaadi.text)<3:
return
js=JsonStore("UmutRss.json")
fst=True
url_str="{"
for k,v in self.urls.items():
if fst:
url_str +=k+":"+v
fst=False
else:
url_str += ","+k + ":" + v
url_str +="}"
js.put(self.haberadi.text,title=self.takmaadi.text,url=url_str)
class WeatherRoot(BoxLayout):
current_weather = ObjectProperty()
locations = ObjectProperty()
# BEGIN LOAD_CURRENT
def __init__(self, **kwargs):
super(WeatherRoot, self).__init__(**kwargs)
self.store = JsonStore("weather_store.json")
if self.store.exists('locations'):
current_location = self.store.get("locations")["current_location"]
self.show_current_weather(current_location)
# END LOAD_CURRENT
def show_current_weather(self, location=None):
self.clear_widgets()
if self.current_weather is None:
self.current_weather = CurrentWeather()
if self.locations is None:
self.locations = Factory.Locations()
if (self.store.exists('locations')):
locations = self.store.get("locations")['locations']
self.locations.locations_list.adapter.data.extend(locations)
# BEGIN PUT_CURRENT
if location is not None:
self.current_weather.location = location
if location not in self.locations.locations_list.adapter.data:
self.locations.locations_list.adapter.data.append(location)
self.locations.locations_list._trigger_reset_populate()
self.store.put("locations",
locations=list(self.locations.locations_list.adapter.data),
current_location=location)
# END PUT_CURRENT
self.current_weather.update_weather()
self.add_widget(self.current_weather)
def show_add_location_form(self):
self.clear_widgets()
self.add_widget(AddLocationForm())
def show_locations(self):
self.clear_widgets()
self.add_widget(self.locations)
class WeatherRoot(BoxLayout):
carousel = ObjectProperty()
current_weather = ObjectProperty()
forecast = ObjectProperty()
locations = ObjectProperty()
add_location_form = ObjectProperty()
# BEGIN INIT
def __init__(self, **kwargs):
super(WeatherRoot, self).__init__(**kwargs)
self.store = JsonStore("weather_store.json")
if self.store.exists('locations'):
locations = self.store.get('locations')
self.locations.locations_list.adapter.data.extend(locations['locations'])
current_location = locations["current_location"]
self.show_current_weather(current_location)
else:
Clock.schedule_once(lambda dt: self.show_add_location_form())
# END INIT
# BEGIN SHOW_CURRENT_WEATHER
def show_current_weather(self, location):
if location not in self.locations.locations_list.adapter.data:
self.locations.locations_list.adapter.data.append(location)
self.locations.locations_list._trigger_reset_populate()
self.store.put("locations",
locations=list(self.locations.locations_list.adapter.data),
current_location=location)
self.current_weather.location = location
self.forecast.location = location
self.current_weather.update_weather()
self.forecast.update_weather()
self.carousel.load_slide(self.current_weather)
if self.add_location_form is not None:
self.add_location_form.dismiss()
# END SHOW_CURRENT_WEATHER
def show_add_location_form(self):
self.add_location_form = AddLocationForm()
self.add_location_form.open()
class ReGalData(object):
servertypes = [
import_module('regallery.servers.piwigo').ReGalServerPiwigo
]
@staticmethod
def get_servertypes():
'''Returns a list with all valids server types'''
return [cls.name for cls in ReGalData.servertypes]
@staticmethod
def get_sever(_type, url, user, pw):
'''
Get new instance of a server
_type - type from get_servertypes()
url - base url for server
user - username
pw - password
'''
for cls in ReGalData.servertypes:
if cls.name == _type:
return cls(url, user, pw)
raise LookupError()
def __init__(self):
self._app = App.get_running_app()
serverconfig = os.path.join(self._app.user_data_dir, 'servers.json')
self._servers = JsonStore(serverconfig)
def add_server(self, url, name, username, password):
self._servers.put(name, url=url, username=username, password=password)
def get_servers(self):
servers = {}
for name in self._servers:
servers[name] = self._servers.get(name)
return servers
class ClockApp(App):
clearcolor = (0,0,0,1)
def __init__(self,**kwargs):
super(ClockApp,self).__init__(**kwargs)
from os.path import join
self.store = JsonStore(join(self.user_data_dir,"clockalarm.json"))
def build(self):
root = ClockWidget()
root.init_alarms()
self.root=root
return self.root
def on_pause(self):
return True
def on_resume(self):
pass
def get_alarm_from_store(self,id):
if self.store.exists("alarms"):
try:
return self.store.get("alarms")["a{}".format(id)]
except:
return None
def set_alarm_to_store(self,id,alarm):
allAlarms = {}
for i in range(1,5):
if i == int(id):
allAlarms["{}".format(i)]=alarm
else:
allAlarms["{}".format(i)]=app.get_alarm_from_store("{}".format(i))
self.store.put("alarms",a1=allAlarms["1"],a2=allAlarms["2"],a3=allAlarms["3"],a4=allAlarms["4"])
class Settings(object):
MIN_TOASTING_TIME = 10
MAX_TOASTING_TIME = 600
FILENAME = 'sofatech_toaster_storage'
SETTINGS_KEY = 'settings'
def __init__(self):
self._ip = '127.0.0.1'
self._port = 50007
self._store = JsonStore(Settings.FILENAME)
@property
def ip(self):
return self._ip
@ip.setter
def ip(self, value):
self._ip = value
@property
def port(self):
return self._port
@port.setter
def port(self, value):
self._port = value
def load(self):
if self._store.exists(Settings.SETTINGS_KEY):
settings_dict = self._store.get(Settings.SETTINGS_KEY)
self._ip = settings_dict['ip']
self._port = settings_dict['port']
def save(self):
self._store.put(Settings.SETTINGS_KEY, ip=self._ip, port=self._port)
class addStory(object):
'''
This class is used for adding story to the game
Syntax for the story is a key based dictionary, these keys are hexadacimal numbers
that will be used to track progress. Starting point is 1, so if scenario 1 had 3
possible options then there would be 11, 12, and 13. If 13 had 2 options then it would
be 131, and 132. This will continue until there is a string of 16 characters
basic syntax: {key
'''
def __init__(self):
self.File = raw_input("Which story would you like to edit?\n\n").lower()
self.data = JsonStore(self.File + '.json')
self.start = 1 #default start code
if self.data.count(): #If file has been started
print '\nLooking for where you left off...\n'
keys = self.data.keys()
leftOff = int(keys[len(keys) - 1])
print ('It seems like you left off at event number'
' %d, so let\'s move on to number %d.'
% (leftOff, leftOff + 1)
)
self.start = leftOff
self.addToDBLoop(self.start)
def addToDBLoop(self, number):
event = raw_input('What is event number %d?\n' % number).lower()
optionsStr = raw_input(('What are the available options for player?\n'
'If none just type \'none\'.\n')).lower().split()
c = 0
options = {}
for o in optionsStr:
c += 1
options[o] = str(number) + str(c)
self.data.put(str(number), event = event, options = options)
class LoginScreen(Screen):
store=''
username=''
def __init__(self,**kwargs):
super(LoginScreen, self).__init__(**kwargs)
Clock.schedule_once(self.update_layout,1/60)
def update_layout(self,btn):
data_dir= App.get_running_app().user_data_dir+'/'
self.store = JsonStore(join(data_dir, 'storage.json'))
try:
self.username=self.store.get('credentials')['username']
exp_data.set_username(self.username)
self.parent.current = 'ExperimentSelectScreen'
except KeyError:
box=BoxLayout(orientation= 'vertical',padding=(100,100,100,100))
#l=Label(size_hint_y=0.25)
#box.add_widget(l)
box.add_widget(Label(text="Enter email",font_size= sp(30),size_hint_y=.5))
self.t=TextInput(font_size= sp(30),size_hint_y=0.5)
box.add_widget(self.t)
box.add_widget(Button(text="Okay",on_press=self.change_screen,font_size=sp(25),size_hint_y=.25))
#box.add_widget(l)
self.add_widget(box)
# #AppScreen.store.put('credentials', username=username, password=password)
def change_screen(self,btn):
if len(self.t.text) == 0: #deal with exception here of not selecting a single experiment
error_popup=Popup(title='Error',content=Label(text="Email cannot be left blank")\
,size_hint=(.75,.75),auto_dismiss=True)
error_popup.open()
Clock.schedule_interval(error_popup.dismiss, 3)
else:
self.store.put('credentials', username=self.t.text)
self.username=self.store.get('credentials')['username']
exp_data.set_username(self.username)
self.parent.current = 'ExperimentSelectScreen'
def __int__(self, **kwargs):
super().__init__(**kwargs)
store = JsonStore('hello.json')
#put some values
store.put('tito', name='Mathieu', org='kivy')
store.put('tshirtman', name='Gabriel', age=27)
store.put('tito', name='Mathieu', age=30)
print('tito is', store.get('tito')['age'])
def storefilepath(self, instance):
pathstore = JsonStore("pathstore.json")
pathstore.put("path", path=instance.selection)
print instance.selection
self.manager.current="category_screen"
class WeatherRoot(BoxLayout):
current_weather = ObjectProperty()
locations = ObjectProperty()
forecast = ObjectProperty()
def __init__(self, **kwargs):
super(WeatherRoot, self).__init__(**kwargs)
self.store = JsonStore("weather_store.json")
if self.store.exists('locations'):
current_location = self.store.get("locations")["current_location"]
self.show_current_weather(current_location)
def show_current_weather(self, location=None):
self.clear_widgets()
if self.current_weather is None:
self.current_weather = CurrentWeather()
if self.locations is None:
self.locations = Factory.Locations()
if self.store.exists('locations'):
locations = self.store.get("locations")['locations']
self.locations.locations_list.adapter.data.extend(locations)
if location is not None:
self.current_weather = CurrentWeather(location=location)
adapter_data = self.locations.locations_list.adapter.data
if location not in adapter_data:
adapter_data.append(location)
self.locations.locations_list._trigger_reset_populate()
self.store.put("locations", locations=list(adapter_data),
current_location=location)
self.current_weather.update_weather()
self.add_widget(self.current_weather)
def show_add_location_form(self):
self.clear_widgets()
self.add_widget(AddLocationForm())
def show_locations(self):
self.clear_widgets()
self.add_widget(self.locations)
def show_forecast(self, location=None):
self.clear_widgets()
if self.forecast is None:
self.forecast = Factory.Forecast()
if location is not None:
self.forecast.location = location
self.forecast.update_weather()
self.add_widget(self.forecast)
@staticmethod
def format_location(location):
return "{} ({})".format(*location)
def on_add_filtered_list(self, instance, device_name):
print("[StartingScreen] on_add_filtered_list")
store = JsonStore("devices_list.json")
if store.exists(device_name) is not True:
print("Adding new device to the .json file...")
store.put(device_name, name=device_name)
class DataBase:
base_url = 'https://osptest-3ddc5.firebaseio.com/'
url = ''
secret = ''
admin_password = ''
def __init__(self, path, heroes_path, password_path, trucks_path, version):
self.version = version
self.heroes_path = heroes_path
self.password_path = password_path
self.trucks_path = trucks_path
self.path = path
self.store = JsonStore(path)
with open("login_data/login", 'r') as file:
self.user = file.read().split("\n")[0]
with open("login_data/secret", 'r') as file:
self.secret = file.read().split("\n")[0]
self.url = self.base_url + self.user + self.secret
self.firebase_patch_all()
self.update_osp_data()
def update_osp_data(self):
try:
string = str(requests.get(self.url).json()['heroes'])
if string:
with open(self.heroes_path, 'w') as file:
file.write(string)
except Exception as connection_error:
Logger.exception(str(connection_error))
try:
with open(self.heroes_path, 'r') as file:
self.heroes = json.loads(str(file.read()).replace("'", '"'))
except Exception as no_heroes_in_db:
Logger.exception(str(no_heroes_in_db))
self.heroes = ["brak strażaków w bazie"]
try:
string = str(requests.get(self.url).json()['trucks'])
if string:
with open(self.trucks_path, 'w') as file:
file.write(string)
except Exception as connection_error:
Logger.exception(str(connection_error))
try:
with open(self.trucks_path, 'r') as file:
self.trucks = json.loads(str(file.read()).replace("'", '"'))
except Exception as no_trucks_in_db:
Logger.exception(str(no_trucks_in_db))
self.trucks = ["brak zastepów w bazie"]
try:
string = str(requests.get(self.url).json()['passwd'])
if string:
with open(self.password_path, 'w') as file:
file.write(string)
except Exception as no_password_in_db:
Logger.exception(str(no_password_in_db))
try:
with open(self.password_path, 'r') as file:
self.admin_password = file.readline()
except Exception as no_password_file:
Logger.exception(str(no_password_file))
def update_reports_data(self):
result = self.firebase_patch_all()
if result == -1:
Factory.connectionPopout().open()
else:
self.update_osp_data()
Factory.updateOK().open()
def put_report(self, uuid_num, id_number, dep_date, dep_time, spot_time,
location, type_of_action, section_com, action_com, driver,
perpetrator, victim, section, details, return_date,
end_time, home_time, meter_reading, km_location, completed,
truck_num):
if uuid_num == "":
uuid_num = str(uuid.uuid1())
if section_com == "Dowódca sekcji":
section_com = ""
if action_com == "Dowódca akcji":
action_com = ""
if driver == "Kierowca":
driver = ""
if truck_num == "Zastęp":
truck_num = ""
self.store.put(uuid_num,
innerID=id_number,
depDate=dep_date,
depTime=dep_time,
spotTime=spot_time,
location=location,
type=type_of_action,
sectionCom=section_com,
actionCom=action_com,
driver=driver,
perpetrator=perpetrator,
victim=victim,
section=section,
details=details,
returnDate=return_date,
endTime=end_time,
homeTime=home_time,
stanLicznika=meter_reading,
KM=km_location,
modDate=self.get_date(),
ready=completed,
truck=truck_num)
try:
string = "{'" + uuid_num + "': " + str(
self.store.get(uuid_num)) + "}"
to_database = json.loads(string.replace("'", '"'))
requests.patch(url=self.url, json=to_database)
return 0
except Exception as connection_error:
Logger.exception(str(connection_error))
return -1
def delete_report(self, uuid_num):
if self.store.exists(uuid_num):
try:
# requests.delete(url=self.url[:-5] + id_number + ".json")
string = '{"deleted-' + uuid_num + '": "true"}'
to_database = json.loads(string)
requests.patch(url=self.url, json=to_database)
self.store.delete(uuid_num)
except Exception as connection_error:
Factory.deletePopout().open()
Logger.exception(str(connection_error))
else:
return -1
def get_heroes(self):
return self.heroes.get("all")
def get_driver(self):
return self.heroes.get("driver")
def get_section_comm(self):
return self.heroes.get("section")
def get_action_comm(self):
return self.heroes.get("action")
def get_trucks(self):
return self.trucks
def firebase_patch_all(self):
try:
with open(self.path, 'r') as file:
data = file.read()
to_database = json.loads(data)
requests.patch(url=self.url, json=to_database)
to_database = json.loads('{"' + self.user + '": "' + self.version +
'"}')
requests.patch(url=self.base_url + "mobileVersion/" + self.secret,
json=to_database)
return 0
except Exception as connection_error:
Logger.exception(str(connection_error))
return -1
def delete_all(self):
string_all = ""
try:
for key in self.store.keys():
# requests.delete(url=self.url[:-5] + key + ".json")
string = '{"deleted-' + key + '": "true"}'
string_all = string_all + string
to_database = json.loads(string)
requests.patch(url=self.url, json=to_database)
self.store.clear()
except Exception as connection_error:
Factory.deletePopout().open()
Logger.exception(str(connection_error))
def get_report(self, id_number):
for item in self.store.find(innerID=id_number):
dane = self.store.get(item[0])
id_number = dane['innerID']
dep_date = dane['depDate']
dep_time = dane['depTime']
spot_time = dane['spotTime']
location = dane['location']
type_of_action = dane['type']
section_com = dane['sectionCom']
action_com = dane['actionCom']
driver = dane['driver']
perpetrator = dane['perpetrator']
victim = dane['victim']
section = dane['section']
details = dane['details']
return_date = dane['returnDate']
end_time = dane['endTime']
home_time = dane['homeTime']
meter_reading = dane['stanLicznika']
km_location = dane['KM']
date = dane['modDate']
completed = dane['ready']
truck_num = dane['truck']
return [
item[0], id_number, dep_date, dep_time, spot_time, location,
type_of_action, section_com, action_com, driver, perpetrator,
victim, section, details, return_date, end_time, home_time,
meter_reading, km_location, date, completed, truck_num
]
else:
return -1
def get_all_friendly(self):
result = []
for item in self.store.keys():
data = self.store.get(item)
result.append(data["innerID"] + " " + data["location"])
return result
def find_inner_id(self, id_number):
for _ in self.store.find(innerID=id_number):
return True
return False
@staticmethod
def get_date():
return str(datetime.datetime.now()).split(".")[0]
def get_user(self):
return self.user
def get_password(self):
return self.admin_password
def change_osp(self, user, password):
with open("login_data/login", 'r') as file:
old_user = file.read().split("\n")[0]
if user != old_user:
try:
user_password = str(
requests.get(self.base_url + "passwd/" + user +
self.secret).json())
to_database = json.loads('{"' + user + '": "' + self.version +
'"}')
requests.patch(url=self.base_url + "mobileVersion/" +
self.secret,
json=to_database)
except Exception as connection_error:
Logger.exception(str(connection_error))
return -2 # no connection
if user_password == "UPDATE":
return -3 # update neeeded
if user_password == "None" or password != user_password:
return -1 # wrong password
self.url = self.base_url + user + self.secret
try:
string = str(requests.get(self.url).json()['heroes'])
with open(self.heroes_path, 'w') as file:
file.write(string)
except Exception as connection_error:
Logger.exception(str(connection_error))
with open(self.heroes_path, 'w') as file:
file.write("")
try:
with open(self.heroes_path, 'r') as file:
self.heroes = json.loads(
str(file.read()).replace("'", '"'))
except Exception as no_heroes_in_db:
Logger.exception(str(no_heroes_in_db))
self.heroes = ["brak strażaków w bazie"]
try:
string = str(requests.get(self.url).json()['trucks'])
with open(self.trucks_path, 'w') as file:
file.write(string)
except Exception as connection_error:
Logger.exception(str(connection_error))
try:
with open(self.trucks_path, 'r') as file:
self.trucks = json.loads(
str(file.read()).replace("'", '"'))
except Exception as no_trucks_in_db:
Logger.exception(str(no_trucks_in_db))
self.trucks = ["brak zastepów w bazie"]
try:
string = str(requests.get(self.url).json()['passwd'])
with open(self.password_path, 'w') as file:
file.write(string)
except Exception as connection_error:
Logger.exception(str(connection_error))
self.url = self.base_url + self.user + self.secret
return -2
try:
with open(self.password_path, 'r') as file:
self.admin_password = file.readline()
except Exception as no_password:
Logger.exception(str(no_password))
self.store.clear()
self.user = user
with open("login_data/login", 'w') as file:
file.write(user)
return 0
class BrickanoidLogic():
# all the bricks
_bricks = []
# all the balls
_balls = []
# the pad
_pad = None
# for performance counting
_starting_time = None
# # of lives
_lives = 3
# gam eover status
_game_over = False
# score
_score = 0
# hiscore
_hiscore = 0
#current level
_level = 0
# max level reached
_hilevel = 1
# process a fire event
_process_fire = False
# waiting for next level
_level_clear = True
#paused
_pause = False
#true if animation for new level must start
_starting_new_level = True
# game properties from gfx
_unitary_width = 0
_unitary_height = 0
_screen_top = 0
_screen_right = 0
_screen_width = 0
_game_screen = None
_boundaries_line_bottom = None
_boundaries_line_top = None
_lives_lbl = None
_score_lbl = None
# level mgmt
_level_loader = None
def __init__(self, game_screen):
self._game_screen = game_screen
self._level_loader = brickanoid_levels.load_levels(self)
def game_start(self):
self._starting_time = perf_counter()
self._unitary_width = self._game_screen.gfx_properties['unitary_width']
self._unitary_height = self._game_screen.gfx_properties[
'unitary_height']
self._screen_top = self._game_screen.gfx_properties['screen_top']
self._screen_right = self._game_screen.gfx_properties['screen_right']
self._screen_width = self._game_screen.gfx_properties['screen_width']
self._boundaries_line_bottom = self._game_screen.gfx_properties[
'boundaries_line_bottom']
self._boundaries_line_top = self._game_screen.gfx_properties[
'boundaries_line_top']
self._lives_lbl = self._game_screen.gfx_properties['lives_lbl']
self._score_lbl = self._game_screen.gfx_properties['score_lbl']
self._level_lbl = self._game_screen.gfx_properties['level_lbl']
self._score_lbl_menu = self._game_screen.gfx_properties[
'score_lbl_menu']
self._hiscore_lbl_menu = self._game_screen.gfx_properties[
'hiscore_lbl_menu']
self._level_lbl_menu = self._game_screen.gfx_properties[
'level_lbl_menu']
self._level_spinner_menu = self._game_screen.gfx_properties[
'level_spinner_menu']
self._game_screen = self._game_screen.gfx_properties['game_screen']
self._menu_screen = self._game_screen.menu_screen
self._lives = 3
self._game_over = False
self._score = 0
self._level = int(self._level_spinner_menu.text)
self._process_fire = False
self._level_clear = True
self._pause = False
self._bricks = []
self._balls = []
self._pad = None
self._level_matrix = LevelMatrix(16, 16)
self._has_touch_down = False
self._starting_new_level = True
self._moving_left = False
self._moving_right = False
self._store = JsonStore('brickanoid.json')
try:
store = self._store.get('hiscore')
self._hiscore = int(store['value'])
store = self._store.get('hilevel')
self._hilevel = int(store['value'])
except KeyError:
self._store.put('hiscore', value=0)
self._store.put('hilevel', value=1)
#self._store.put('hilevel', 1)
self._hiscore = 0
self._hilevel = 1
# his = list(self._store.find(name='hiscore'))
# if len(his) > 0:
# self._hiscore = his[0][1]['value']
self._hiscore_lbl_menu.text = str(self._hiscore)
self._update_level_spinner()
def _update_level_spinner(self):
level_values = []
for i in range(1, self._hilevel + 1):
level_values.append(str(i))
self._level_spinner_menu.values = level_values
#self._check_end_level()
# add a brick to level at column i (starting from left) and row j (starting from top)
# uses next space avialable depending on previous bricks
# if i = j = -1 simply find next space available
def add_brick_to_screen(self, brick, i=-1, j=-1):
if i == -1 or j == -1:
for y, x in np.ndindex(
(self._level_matrix.columns, self._level_matrix.rows)):
if self._level_matrix.is_free(x, y, brick.bwidth,
brick.bheight):
brick.pos = (self._screen_right +
(x * self._unitary_width),
self._screen_top - (y * self._unitary_height))
self._level_matrix.occupy(x, y, brick.bwidth,
brick.bheight)
self._bricks.append(brick)
return True
else:
brick.pos = (self._screen_right + (i * self._unitary_width),
self._screen_top - (j * self._unitary_height))
self._level_matrix.occupy(i, j, brick.bwidth, brick.bheight)
self._bricks.append(brick)
return True
return False
def _create_random_ball(self):
ball = brickanoid_elements.BallAnoid()
# put it at center of pad
ball.pos = (self._pad.pos[0] + self._pad.widget.width / 2 - ball.radius, \
self._pad.pos[1] + self._pad.widget.height)
ball.velocity = (0, 0)
self._balls.append(ball)
def _fire_balls(self):
for ball in self._balls:
if ball.is_idle():
rr = randint(-15, +15)
ball.velocity = Vector(
(0, self._unitary_height / 4)).rotate(rr)
print("vector: (%d) %s" % (rr, repr(ball.velocity)))
def _check_collision_balls_bricks(self):
bricks_to_remove = []
for ball in self._balls:
if ball.is_idle():
continue
for brick in self._bricks:
# horizontal collision from left
if brick.widget.collide_point((ball.pos[0] + 2 * ball.radius),
(ball.pos[1] + ball.radius)):
print(
"collisione LEFT in %d, %d - %d, %d" %
(ball.pos[0], ball.pos[1], brick.pos[0], brick.pos[1]))
vx, vy = ball.velocity
ball.velocity = -vx, vy
ball.pos[0] -= 2
self._game_screen.play_sound('brick_hit')
if brick.collided():
bricks_to_remove.append(brick)
self._score += brick.points
# horizontal collision from right
elif brick.widget.collide_point((ball.pos[0]),
(ball.pos[1] + ball.radius)):
#if ball.widget.collide_widget(brick.widget):
print(
"collisione RIGHT in %d, %d - %d, %d" %
(ball.pos[0], ball.pos[1], brick.pos[0], brick.pos[1]))
vx, vy = ball.velocity
ball.velocity = -vx, vy
ball.pos[0] += 2
self._game_screen.play_sound('brick_hit')
if brick.collided():
bricks_to_remove.append(brick)
self._score += brick.points
# vertical collision from bottom
elif brick.widget.collide_point(
(ball.pos[0] + ball.radius),
(ball.pos[1] + 2 * ball.radius)):
print(
"collisione BOTTOM in %d, %d - %d, %d" %
(ball.pos[0], ball.pos[1], brick.pos[0], brick.pos[1]))
vx, vy = ball.velocity
ball.velocity = vx, -vy
ball.pos[1] -= 2
self._game_screen.play_sound('brick_hit')
if brick.collided():
bricks_to_remove.append(brick)
self._score += brick.points
#vertical collision from top
elif brick.widget.collide_point((ball.pos[0] + ball.radius),
(ball.pos[1])):
print(
"collisione TOP in %d, %d - %d, %d" %
(ball.pos[0], ball.pos[1], brick.pos[0], brick.pos[1]))
vx, vy = ball.velocity
ball.velocity = vx, -vy
ball.pos[1] += 2
self._game_screen.play_sound('brick_hit')
if brick.collided():
bricks_to_remove.append(brick)
self._score += brick.points
return bricks_to_remove
def _check_collision_balls_border(self):
deadballs = []
for ball in self._balls:
vx, vy = ball.velocity
# right border
if (ball.pos[0]) <= self._screen_right:
vx *= -1
ball.pos[0] += 1
print("collisione X in %d, %d" % (ball.pos[0], ball.pos[1]))
# right border
elif (ball.pos[0] + 2 * ball.radius
) >= self._screen_width - (2 * self._screen_right):
vx *= -1
ball.pos[0] -= 1
print("collisione X in %d, %d" % (ball.pos[0], ball.pos[1]))
# top bar
elif ball.widget.collide_widget(self._boundaries_line_top):
vy *= -1
ball.pos[1] -= 1
print("collisione Y in %d, %d" % (ball.pos[0], ball.pos[1]))
# bottom
elif ball.widget.collide_widget(self._boundaries_line_bottom):
print("morte Y in %d, %d" % (ball.pos[0], ball.pos[1]))
deadballs.append(ball)
ball.velocity = vx, vy
return deadballs
def _check_collision_balls_pad(self):
for ball in self._balls:
if ball.is_idle():
continue
vx, vy = ball.velocity
# if somehow the ball is going up, ignore this event
if vy > 0.:
continue
# check if collision happens only from top
# if self._pad.widget.collide_point(ball.pos[0] + ball.radius, ball.pos[1]) and \
# not self._pad.widget.collide_point(ball.pos[0], ball.pos[1] + ball.radius) and \
# not self._pad.widget.collide_point(ball.pos[0] + 2 * ball.radius, ball.pos[1] + ball.radius):
if self._pad.widget.collide_widget(ball.widget) and \
(self._pad.pos[1] + self._pad.widget.height) - ball.pos[1] < 10:
print("preso pad in %d, %d" % (ball.pos[0], ball.pos[1]))
vy *= -1
offset = self._pad.pos[0] + (self._pad.widget.width /
2) - (ball.pos[0] + ball.radius)
ball.velocity = vx - offset / 4, vy
self._game_screen.play_sound('pad_hit')
def _check_end_life(self):
if len(self._balls) == 0:
print("MORTO!")
self._game_screen.play_sound('game_over')
if self._lives > 0:
self._create_random_ball()
self._lives -= 1
return True
def _check_end_level(self):
# count only non-indestructible bricks
actbricks = [brick for brick in self._bricks if brick.strength > 0]
if len(actbricks) == 0 and not self._pause:
# no more bricks
print("VITTORIA!")
self._level_matrix = LevelMatrix(16, 16)
self._game_screen.clear_gfx()
self._balls = []
self._bricks = []
self._pad = None
self._level_clear = True
self._level += 1
self._starting_new_level = True
return True
return False
def pause(self):
self._pause = True
def continue_level(self):
self._pause = False
if self._game_over:
self.game_start()
elif not self._level_clear:
return
self._game_screen.clear_gfx()
if self._level == 0:
self._level = 1
self._level_loader.load_level(self._level)
self._pad = brickanoid_elements.PadYellow_2()
self._pad.pos = (self._screen_width // 2 -
self._pad._widget.width // 2,
self._screen_top - (24.5 * self._unitary_height))
self._create_random_ball()
self._level_clear = False
def _check_fire(self):
if self._process_fire:
self._fire_balls()
self._process_fire = False
def touch_move(self, x, y):
if not self._pad:
return
newx, newy = self._pad.pos
newx = x - self._pad.widget.width / 2
if newx < 0:
newx = 0
elif newx + self._pad.widget.width > self._screen_width:
newx = self._screen_width - self._pad.widget.width
self._pad.pos = (newx, newy)
self._has_touch_down = False
# see if any ball is stick to the pad and in case move it
for ball in self._balls:
if ball.is_idle():
ball.pos = (newx + self._pad.widget.width / 2 - ball.radius, \
ball.pos[1])
def touch_down(self, x, y):
self._has_touch_down = True
def touch_up(self, x, y):
# touched and released.... a tap?
if self._has_touch_down:
self.fire()
def move_left(self):
self._moving_left = True
self._moving_right = False
def move_right(self):
self._moving_left = False
self._moving_right = True
def stop_left(self):
self._moving_left = False
def stop_right(self):
self._moving_right = False
def fire(self):
self._process_fire = True
def game_update(self):
'''
1. muovo palline (secondo posizione e velocità) OK
3. verifico collisione pad-pallina OK
4. verifico collissione pallina-bricks OK
5. verifica collisione pallina-nemici
6. verifica collisione proiettili-bricks
7. verifica collisione proiettili-nemici
8. verifica collisione potenziamento-pad
6. disegna sfondo
7. disegna bricks OK
8. disegna nemici
9. disegna pad OK
10. disegna proiettili
11. verifica perdita vita OK
11. verifica fine vite OK
12. verifica vittoria livello OK
'''
#secs = int(perf_counter() - _starting_time)
#game_screen.count_lbl.text = str(secs)
#game_screen.score_lbl.text = str(secs*123)
# game_screen.clear_gfx()
if self._game_over:
self._game_screen.to_menu()
return
self._score_lbl_menu.text = str(self._score)
self._level_lbl_menu.text = str(self._level)
# if self._game_screen.is_showing_banner():
# return
if self._level == 0:
self._check_end_level()
if self._starting_new_level:
self.continue_level()
self._game_screen.show_banner("Level %d" % self._level)
self._game_screen.play_sound('game_start')
self._starting_new_level = False
return
elif self._check_end_level():
#self._game_screen.to_menu()
self._score += (self._level - 1) * 100
#self.pause()
self._starting_new_level = True
if self._level > self._hilevel:
self._hilevel = self._level
self._store.put('hilevel', value=self._hilevel)
self._update_level_spinner()
self._game_screen.show_banner("Level %d clear" % (self._level - 1))
return
if self._pause:
return
self._check_fire()
# move every ball
for elem in self._balls:
elem.move()
# move te pad accoringly to its speed
if self._pad:
self._pad.move()
if self._moving_left:
self.touch_move(
self._pad.pos[0] - 5 + self._pad.widget.width / 2,
self._pad.pos[1])
elif self._moving_right:
self.touch_move(
self._pad.pos[0] + 5 + self._pad.widget.width / 2,
self._pad.pos[1])
# check collision with bricks. Check if some brick has to be removed
deadbricks = self._check_collision_balls_bricks()
if len(deadbricks) > 0:
for brick in deadbricks:
self._game_screen.remove_gfx(brick.widget)
self._bricks.remove(brick)
# check if a ball reached bottom. If no balls remained it is Gave Over
deadballs = self._check_collision_balls_border()
if len(deadballs) > 0:
for ball in deadballs:
self._game_screen.remove_gfx(ball.widget)
self._balls.remove(ball)
if self._check_end_life():
if self._lives == 0:
self._game_screen.show_banner("Game Over")
self._game_over = True
self._check_collision_balls_pad()
# show # of lives and score
self._lives_lbl.text = str(self._lives)
self._score_lbl.text = str(self._score)
self._level_lbl.text = str(self._level)
if self._score > self._hiscore:
self._hiscore = self._score
self._hiscore_lbl_menu.text = str(self._hiscore)
self._store.put('hiscore', value=self._hiscore)
# draw bricks, balls and the pad
for elem in self._bricks:
self._game_screen.draw_gfx(elem.widget)
for elem in self._balls:
self._game_screen.draw_gfx(elem.widget)
if self._pad:
self._game_screen.draw_gfx(self._pad.widget)
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 PonumiPerformer(App):
osc_ip_address = StringProperty(_default_osc_ip_address)
osc_port = StringProperty(_default_osc_port)
auto_generate_rhythm = BooleanProperty(_default_auto_generate_rhythm)
osc_indicator = ObjectProperty(None)
input_focus = ObjectProperty(None)
poem_position = NumericProperty(0)
rhythm_position = NumericProperty(0)
def __init__(self, **kwargs):
super(PonumiPerformer, self).__init__(**kwargs)
data_dir = getattr(self, 'user_data_dir')
self.config_store = JsonStore(join(data_dir, 'ponumiperformer.json'))
self.rhythm = _default_rhythm
self.initialise_osc()
def initialise_osc(self):
oscAPI.init()
oscid = oscAPI.listen(ipAddr='127.0.0.1', port=osc_listen_port)
oscAPI.bind(oscid, self.poem_position_changed, osc_poem_position)
oscAPI.bind(oscid, self.rhythm_position_changed, osc_rhythm_position)
self.osc_poll = Clock.schedule_interval(lambda *x: oscAPI.readQueue(oscid), 0.01)
send_osc_message('/osc/respond_to', [osc_listen_port])
send_osc_message(osc_poem_position, [0.0001], typehint=1.0)
send_osc_message(osc_rhythm_position, [0.0001], typehint=1.0)
def shutdown_osc(self):
self.osc_poll.cancel()
oscAPI.dontListen()
def poem_position_changed(self, msg, *args):
self.poem_position = int(msg[2])
def rhythm_position_changed(self, msg, *args):
self.rhythm_position = int(msg[2])
def build(self):
self.load_config()
rootscreen = RootScreen()
navbar = NavBar()
self.osc_indicator = navbar.osc_indicator
rootscreen.add_widget(navbar)
self.screen_manager = PonumiPerformerScreenManager()
rootscreen.add_widget(self.screen_manager)
return rootscreen
def save_config(self):
self.config_store.put('config',
osc_ip_address=self.osc_ip_address,
osc_port=self.osc_port)
def load_config(self):
if self.config_store.exists('config'):
config = self.config_store.get('config')
if 'osc_ip_address' in config: self.osc_ip_address = config['osc_ip_address']
if 'osc_port' in config: self.osc_port = config['osc_port']
def load_default_config(self):
self.osc_ip_address = _default_osc_ip_address
self.osc_port = _default_osc_port
def on_stop(self):
self.shutdown_osc()
class HomePage(Screen, Widget):
def __init__(self, **kwargs):
super(HomePage, self).__init__(**kwargs)
#References the json file called local.json
self.store = JsonStore('local.json')
print("whether previous exist = " + repr(self.store.exists('numEntries')))
#Determines if the server initiation is correct (should only be a one time thing)
isSuccessful = True
path = "/Users/ryan04px2021/Desktop/SAS/High_School/Junior_(11)/Afterschool_Activities/2020Summer/ActualSummer/CallForCode/CallForCode_COVID-19_Project/Kivy/Tutorials/11Test"
client.init(path + "/sth.log", 10)
#Checks if there is a file. If there is not, initiate all 4 necessary parts
if (not self.store.exists('numEntries')):
print("enter")
self.store.put("selfMac", value = "a2:4f:43:92:25:2e")
tempSecret = client.initSelf(self.store.get("selfMac")["value"])
if (tempSecret == 2):
tempBut = Button(text = "Server Error, Please quit the app and try again (2)", font_size = 40)
self.add_widget(tempBut)
isSuccessful = False
elif (tempSecret == 3):
tempBut = Button(text = "User already initiated (3)", font_size = 40)
self.add_widget(tempBut)
isSuccessful = False
elif (tempSecret == 4):
tempBut = Button(text = "Invalid Mac Address, Please quit the app and try again (4)", font_size = 40)
self.add_widget(tempBut)
isSuccessful = False
else:
self.store.put("secretKey", value = tempSecret)
self.store.put("numEntries", value = 0)
self.store.put("macDict", value = dict())
self.store.put("recentTen", value = list())
self.store.put("prevNetwork", value = dict())
if (isSuccessful):
self.options = ObjectProperty(None)
#macClass variable is just used as a reference to be able to call the getMac class
self.macClass = GetMacAdd()
self.actualMac = self.macClass.getMac()
self.status = "You are safe!"
def coronaCatcherButtonClicked(self):
print("coronaCatcherButton clicked")
returnVal = client.queryMyMacAddr(self.store.get("selfMac")["value"], self.store.get("secretKey")["value"])
if (returnVal == -1):
self.status = "Checked by " + str(datetime.datetime.now()) + ", you have contacted someone with the virus. Please quarantine"
print("You are infected")
elif (returnVal == 0):
self.status = "Checked by " + str(datetime.datetime.now()) + ", you are still safe!"
elif (returnVal == 2):
self.status = "Checked by " + str(datetime.datetime.now()) + ", Server Error, please quit the app and retry (2)"
elif (returnVal == 3):
self.status = "Checked by " + str(datetime.datetime.now()) + ", Incorrect secret key, you're kinda screwed (3)"
elif (returnVal == 4):
self.status = "Checked by " + str(datetime.datetime.now()) + ", Invalid mac address, you're kinda screwed (4)"
else:
self.status = "1 returned"
#This method is used when we click the button to check our current network mac
def calculateMac(self):
self.actualMac = self.macClass.getMac()
self.coronaCatcherButtonClicked()
return self.actualMac
#This calculates the offset accordingly (topLeftH and topLeftW are both in terms of proportions)
def findCoordinates(self, percentage, topLeftWidth, topLeftHeight):
smallDim = min(Window.size)
offSet = smallDim * percentage
xCoor = topLeftWidth * Window.size[1] + offSet#Windows: (Height, Width)
yCoor = topLeftHeight * Window.size[0] - self.options.size[0] - offSet
print(xCoor / Window.size[1])
print(yCoor / Window.size[0])
return (xCoor / Window.size[1], yCoor / Window.size[0])
pass
class MyRoot(ScreenManager):
def __init__(self, debug, **kwargs):
super(MyRoot, self).__init__(**kwargs)
self.debug = True
if self.debug:
print('MyRoot debug enabled')
self.data_store = JsonStore('./dat.json')
self.feedDict = {}
self.feedDict = self.get_rss_urls()
self.entries = self.get_feed_entries()
def build_rss_title_key(self, d):
title = re.sub('[^0-9a-zA-Z]+', '_', d.feed.title).lower()
return title
def get_rss_urls(self):
try:
feeds = self.data_store.get('feeds')
return feeds
except:
self.add_rss_feed("https://talkpython.fm/episodes/rss")
self.get_rss_urls
def get_feed_entries(self):
try:
entries = json.loads(self.data_store.get('feeds')['entries'])
#print entries
return entries
except:
return '[Fail] could not parse entries at get_feed_entries'
def add_rss_feed(self, url):
self.url = url
self.post_dict_list = []
try:
d = feedparser.parse(self.url)
self.status = d.status
self.headers = d.headers
self.title= d.feed.title
self.rights= d.feed.rights
self.subtitle= d.feed.subtitle
for post in d.entries:
self.post_dict_list.append({'published': str(datetimeparse(post.published)),
'title': post.title,
'link': post.link,
'id': post.id,})
except:
if self.debug:
message = '[Fail] add_rss_feed:', self.url
else:
message = '[Success] add_rss_feed', self.url
return message
try:
feeds = self.data_store.get('feeds')[self.title]
if self.debug:
print '[success] found existing feeds', feeds
except:
if self.debug:
print '[info] no feeds, adding default', self.title, self.url
self.data_store.put('feeds',
status= self.status,
headers= self.headers,
title=self.title,
subtitle= self.subtitle,
url=self.url,
rights = self.rights,
entries=json.dumps(self.post_dict_list))
class Player(Widget):
enmy_1 = ObjectProperty(None) # enemy_1 refference
enmy_2 = ObjectProperty(None) # enemy_2 reference
enmy_3 = ObjectProperty(None) # enemy_3 refernce
game_over = BooleanProperty(False) #makes the gun not shootable
countdown_going_on = BooleanProperty(True)
#parent = ObjectProperty(None)
put_limit_to_countdown_timer = BooleanProperty(False)
sound = ObjectProperty(None, allownone=True)
enemies = ListProperty([])
image_1 = ObjectProperty(None) # player ship body
image_2 = ObjectProperty(None) # ships bullet
go = ObjectProperty() # this will make ship move
score = ObjectProperty(None) # this will display score on screen
popup = ObjectProperty(None)
bullet_speed = ListProperty([0, 50]) # the speed of bullet
velocity = ListProperty([5, 10]) # the movement speed of player
time_count = NumericProperty()
points = NumericProperty() # point earned
check_if_ship_collide = BooleanProperty(
False) # check to see if ourship collides with rocks
check_if_ship_collide_timer = ObjectProperty(None)
l_enabled = BooleanProperty(False) # if left is pressed,bcomes True
r_enabled = BooleanProperty(False) # if right is pressed,becomes True
moving = BooleanProperty(False) # if the player is moving,bcomes True
shooting = BooleanProperty(False) # if it is shooting,becomes True
# makes sure that this runs no matter what happens
def __init__(self, **kwargs):
super(Player, self).__init__(**kwargs)
#register the keyboard
self._keyboard = Window.request_keyboard(self._keyboard_closed, self,
'text')
if self._keyboard.widget:
pass
self._keyboard.bind(on_key_down=self._on_keyboard_down,
on_key_up=self._on_key_up)
# add the score display to the screen
self.score = Score()
self.add_widget(self.score)
# points counter
self.points = 0
self.score.text = str(self.points)
#get set go
self.timer = Label(text='')
self.timer.font_size = '80sp'
self.timer.x = 100
self.timer.y = 300
self.add_widget(self.timer)
self.put_limit_to_countdown_timer = True
if self.put_limit_to_countdown_timer == True:
#update time
self.timer_schedule = Clock.schedule_interval(
self.timer_update, 1.0)
# this will update timer
def timer_update(self, *args):
self.time_count += 1
self.timer.text = str(self.time_count)
if self.time_count >= 4:
self.timer.font_size = '100sp'
self.timer.text = str('GO!')
if self.time_count >= 5:
self.countdown_going_on = False
if self.sound == None:
self.sound = SoundLoader.load('shoot.wav')
#self.parent = Game()
#print "done............ "
Clock.unschedule(self.timer_schedule)
self.remove_widget(self.timer)
# add the enemy_1 to the screen
self.enmy_1 = Enmy_1()
self.add_widget(self.enmy_1)
# start the enemy movement
self.enmy_1.run = Clock.schedule_interval(self.enmy_1.update,
1.0 / 60.0)
self.enemies.append(self.enmy_1)
# add the enemy_2 to the screen
self.enmy_2 = Enmy_2()
self.add_widget(self.enmy_2)
# start the enemy movement
self.enmy_2.run = Clock.schedule_interval(self.enmy_2.update,
1.0 / 60.0)
self.enemies.append(self.enmy_2)
# add the enemy_2 to the screen
self.enmy_3 = Enmy_3()
self.add_widget(self.enmy_3)
# start the enemy movement
self.enmy_3.run = Clock.schedule_interval(self.enmy_3.update,
1.0 / 60.0)
self.enemies.append(self.enmy_3)
self.check_if_ship_collide_timer = Clock.schedule_interval(
self.check_ship_collide, 1.0 / 60.0)
#print 'countdown timer strted'
# checks to see if ship collide with rocks
def check_ship_collide(self, *args):
for self.enmy in self.enemies:
if self.image_1.collide_widget(self.enmy):
Clock.unschedule(self.enmy_1.run)
Clock.unschedule(self.enmy_2.run)
Clock.unschedule(self.enmy_3.run)
self.game_over = True # makes it true so that we cannot shoot
self.score.text = 'GAME OVER'
self.Score_count()
break # break out of loop
# this will save the score
def Score_count(self):
self.old_points = self.points
self.score = JsonStore("score.json")
if not self.score:
self.score.put("score", score=self.old_points)
else:
if self.points >= self.score.get('score')['score']:
self.old_points = self.points
self.score.put("score", score=self.old_points)
#self.menu.score_points.text = self.menu.score_points.text
# check keyboard closed event
def _keyboard_closed(self):
#print "keyboard is closed"
self._keyboard.unbind(on_key_down=self._on_keyboard_down)
self._keyboard.unbind(on_key_up=self._on_key_up)
self._keyboard = None
# if key is pressed on keyboard then do the folowing...
def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
#if left is pressed and right is not presed
if keycode[1] == "left" and self.r_enabled is False:
#if the ship is not moving & it is not shooting...
if self.moving == False and self.shooting == False:
self.moving = True # makes it true so that right cannot be pressed
#move the player
self.go = Clock.schedule_interval(self.go_left, 1.0 / 60.0)
else:
pass
#print "you cant move left"
if keycode[1] == "right" and self.l_enabled is False:
if self.moving == False and self.shooting == False:
self.moving = True
self.go = Clock.schedule_interval(self.go_right, 1.0 / 60.0)
else:
pass
#print "You cant move right"
if keycode[1] == "spacebar" and self.countdown_going_on == False:
if self.shooting == False and self.moving == False:
if self.game_over == False:
self.moving = True
if self.sound == None:
self.sound = SoundLoader.load('shoot.wav')
if self.sound.status != 'stop':
self.sound.stop()
self.sound.play()
Clock.schedule_once(self.shoot, 1.0 / 60.0)
#if the key is just pressed and released then do the following...
def _on_key_up(self, keyboard, keycode, *args):
if self.moving == True: # if movng is True,
Clock.unschedule(self.go) # stop the player movement
self.moving = False # make it false
if self.go: # if any movement then stop it
Clock.unschedule(self.go)
if self.l_enabled is True: # if left_pressed is true
self.l_enabled = False # then make it false
if self.r_enabled is True: # same as just above
self.r_enabled = False
# move the player to the right
def go_right(self, dt):
self.x += self.velocity[0]
if self.x >= 255:
Clock.unschedule(self.go)
# move plater to the left
def go_left(self, dt):
self.x -= self.velocity[0]
if self.x <= -35:
Clock.unschedule(self.go)
# make it shoot
def shoot(self, dt):
self.bullet_move = Clock.schedule_interval(self.move_bullet,
1.0 / 60.0)
# make the bullet move
def move_bullet(self, dt):
self.image_2.y += self.bullet_speed[1]
self.shooting = True
self.check_collision()
# check if it collides with enemy or boundary
def check_collision(self):
if self.enmy_1 in self.children:
if self.image_2.collide_widget(
self.enmy_1): # if it collides with enemy_1
self.points += 1 # increment the score
self.score.text = str(self.points)
Clock.unschedule(self.bullet_move) # stop the bullet movement
self.remove_widget(self.image_2) # remove the bullet
Clock.unschedule(self.enmy_1.run) # stop the enemy movement
#self.children.remove(self.enmy_1)
self.remove_widget(self.enmy_1) # remove the enemy
self.shooting = False # make the shooting false
#self.enmy_1.reload()
#print "reloaded....."
self.add_bullet() # add the bullet again
if self.enmy_2 in self.children:
if self.image_2.collide_widget(
self.enmy_2): # if it collides with enemy_1
self.points += 1 # increment the score
self.score.text = str(self.points)
Clock.unschedule(self.bullet_move) # stop the bullet movement
self.remove_widget(self.image_2) # remove the bullet
Clock.unschedule(self.enmy_2.run) # stop the enemy movement
#self.children.remove(self.enmy_1)
self.remove_widget(self.enmy_2) # remove the enemy
self.shooting = False # make the shooting false
#self.enmy_1.reload()
#print "reloaded....."
self.add_bullet() # add the bullet again
if self.enmy_3 in self.children:
if self.image_2.collide_widget(
self.enmy_3): # if it collides with enemy_1
self.points += 1 # increment the score
self.score.text = str(self.points)
Clock.unschedule(self.bullet_move) # stop the bullet movement
self.remove_widget(self.image_2) # remove the bullet
Clock.unschedule(self.enmy_3.run) # stop the enemy movement
#self.children.remove(self.enmy_1)
self.remove_widget(self.enmy_3) # remove the enemy
self.shooting = False # make the shooting false
#self.enmy_1.reload()
#print "reloaded....."
self.add_bullet() # add the bullet again
if self.image_2.y >= 600: # if bullet goes out of boundary
#print "beyond 600"
Clock.unschedule(self.bullet_move) # stop the movement
self.remove_widget(self.image_2) # remove the bullet
self.shooting = False # make shooting false
self.add_bullet() # add bullet
# function to add the bullet
def add_bullet(self):
self.add_widget(self.image_2) # add the bullet
self.x += 0.1 # update it
if not self.enmy_1 in self.children: # if there is no enemy_1
self.add_widget(self.enmy_1) # add it
self.enmy_1.x = randint(50, 250)
self.enmy_1.y = randint(550, 600)
self.enmy_1.run = Clock.schedule_interval(self.enmy_1.update,
1.0 / 60.0)
if not self.enmy_2 in self.children: # if there is no enemy_1
self.add_widget(self.enmy_2) # add it
self.enmy_2.x = randint(50, 250)
self.enmy_2.y = randint(550, 600)
self.enmy_2.run = Clock.schedule_interval(self.enmy_2.update,
1.0 / 60.0)
if not self.enmy_3 in self.children: # if there is no enemy_1
self.add_widget(self.enmy_3) # add it
self.enmy_3.x = randint(50, 250)
self.enmy_3.y = randint(550, 600)
self.enmy_3.run = Clock.schedule_interval(self.enmy_3.update,
1.0 / 60.0)
def stop(self):
Background().stop()
from kivy.storage.jsonstore import JsonStore
store = JsonStore('hello.json')
# put some values
store.put('tito', name='Mathieu', org='kivy')
store.put('tshirtman', name='Gabriel', age=27)
# using the same index key erases all previously added key-value pairs
store.put('tito', name='Mathieu', age=30)
# get a value using a index key and key
print('tito is', store.get('tito')['age'])
# or guess the key/entry for a part of the key
for item in store.find(name='Gabriel'):
print('tshirtmans index key is', item[0])
print('his key value pairs are', str(item[1]))
class MainApp(App):
"""
_DEF_EX = exchange (for now hard coded to 'Binance')
_DEF_SYM = symbol (for now default is 'btcusdt')
_DARK_MODE_RGB = RGB for dark mode
_LIGHT_MODE_RGB = RGB for light mode
_DEF_MODE = default view mode
_DEFAULT_NEWS_MODE = default status for displaying news
_DEF_CUM_PNL = default cumulative pnl
_DEFAULT_FEES = default user fees
_PNL_PERC = decimal percision for pnl display
_DEF_DATAJSON_NAME = json filename for user settings
current_position - current position being held (1 for long, -1 for short, 0 for none)
entry_price - entry price for current position
last_price
zero_pnl - macro string used to reset PnL
cumulative_pnl - PnL of all positions
current_pnl - PnL of current position being held
position_mapping - convert from int to str representation of position type
display_mode_mapping - convert from integer to str representation of display mode
_GIT_URL - the developer's GITHUB url
about_info - the text to be displayed in the about window
"""
_DARK_MODE_RGB = (0, 0, 0)
_TEXT_COLOR_DARKMODE = get_color_from_hex("#ffffff")
_LIGHT_MODE_RGB = (227 / 255, 214 / 255, 177 / 255)
_TEXT_COLOR_LIGHTMODE = get_color_from_hex("#000000")
_DEF_EX = "Binance"
_DEF_SYM = "BTCUSDT"
_DEF_DISP_MODE = 0
_DEFAULT_NEWS_MODE = True
_DEF_CUM_PNL = 0.0
_DEFAULT_FEES = 0.0
_PNL_PERC = 2
_DEF_DATAJSON_NAME = "user_data"
_GREEN_HEX = "#00b82b"
_RED_HEX = "#b80000"
price_fetcher = Fetcher(_DEF_EX)
current_position = int()
entry_price = float()
last_price = float()
zero_pnl = "0.00%"
current_pnl = 0.0
position_mapping = {1: 'Long', 0: 'Neutral', -1: 'Short'}
display_mode_mapping = {0: 'Dark Mode', 1: 'Light Mode'}
_GIT_URL = "https://github.com/adanikel"
about_info = f'This is an open source game designed to ' \
f'simulate real-life trading by fetching a live price feed ' \
f'from top crypto exchanges (currently only Binance is supported).' \
f'\n\n\n' \
f'Made by [ref={_GIT_URL}][color=0000ff]adanikel[/color][/ref]'
def build(self):
"""
main_layout (used as class attr)
symbol_label - see current symbol
price_label - live price feed
pnl_label - live PnL of current position
entry_price_status_layout
pos_str_label - string representation of current position
entry_price_label - entry price of current position
news_label - news flash
options_layout - to add padding to the button
button_refresh - a refresh button for the cumulative PnL
button_settings - a button to open settings menu
popup_settings - a popup window for settings
symbols_list - dropdown list for symbols
button_display_mode - toggle view mode (dark or light)
button_news - turn on / off newsflash
button_fees - popup page to fees
fees_label - display fees
fees_up_button - increment fees
fees_down_button - decrement fees
button_about - display about
cum_pnl_label
position_buttons_layout
button_buy
button_sell
"""
self.store = JsonStore(f'{self._DEF_DATAJSON_NAME}.json')
self.load_user_data()
self.main_layout = BoxLayout(orientation="vertical")
self.main_layout.add_widget(Pulser.bg_pulser)
with self.main_layout.canvas:
Rectangle(source="icons/lightning.png",
size=(1450, 1450),
pos=(0, 550))
self.symbol_label = Label(text='',
bold=True,
size_hint=(.5, .5),
font_size=100,
pos_hint={
'center_x': .5,
'center_y': 1
},
color=(237 / 255, 142 / 255, 43 / 255, 0.4))
self.main_layout.add_widget(self.symbol_label) # add price label
self.price_label = Label(text='0.0',
bold=True,
size_hint=(.8, .8),
font_size=250,
pos_hint={
'center_x': .5,
'center_y': .9
})
self.main_layout.add_widget(self.price_label) # add price label
self.pnl_label = Label(text=self.zero_pnl,
bold=True,
size_hint=(.5, .5),
font_size=100,
pos_hint={
'center_x': .5,
'center_y': .9
})
self.main_layout.add_widget(self.pnl_label) # add price label
entry_price_status_layout = BoxLayout(orientation='horizontal')
self.pos_str_label = Label(text='',
bold=True,
size_hint=(.5, .5),
font_size=60,
pos_hint={
'center_x': .5,
'center_y': .9
})
entry_price_status_layout.add_widget(
self.pos_str_label) # add price label
self.entry_price_label = Label(text='0.00',
italic=True,
size_hint=(.5, .5),
font_size=60,
pos_hint={
'center_x': .5,
'center_y': .9
})
entry_price_status_layout.add_widget(
self.entry_price_label) # add price label
self.main_layout.add_widget(entry_price_status_layout)
self.news_label = Label(text='',
size_hint=(.5, .5),
font_size=60,
pos=(0, 0))
self.main_layout.add_widget(self.news_label)
options_layout = BoxLayout(
orientation="horizontal",
# padding=[200, 100, 100, 100],
pos_hint={
'center_x': 0.6,
'center_y': 0.5
},
spacing=100)
self.button_settings = Button(text='',
size_hint=(None, None),
size=(170, 170),
pos_hint={
'center_x': .5,
'center_y': .5
})
self.button_settings.bind(on_press=self.on_press_settings)
options_layout.add_widget(self.button_settings)
self.button_refresh = Button(text='',
size_hint=(None, None),
size=(170, 170),
pos_hint={
'center_x': .5,
'center_y': .5
})
self.button_refresh.bind(on_press=self.on_press_refresh)
options_layout.add_widget(self.button_refresh)
self.cum_pnl_label = Label(text='',
bold=True,
size_hint=(.5, .5),
font_size=140,
pos_hint={
'center_x': .5,
'center_y': .5
})
options_layout.add_widget(self.cum_pnl_label)
self.main_layout.add_widget(options_layout)
position_buttons_layout = BoxLayout(orientation="horizontal",
size_hint=(1, 0.5))
button_buy = Button(text='Buy',
bold=True,
size_hint=(.8, .8),
pos_hint={
'center_x': .5,
'center_y': .8
},
background_color=get_color_from_hex("#3de03a"))
button_buy.bind(on_press=self.on_press_buy)
position_buttons_layout.add_widget(button_buy)
button_sell = Button(text='Sell',
bold=True,
size_hint=(.8, .8),
pos_hint={
'center_x': .5,
'center_y': .8
},
background_color=get_color_from_hex("#eb3838"))
button_sell.bind(on_press=self.on_press_sell)
position_buttons_layout.add_widget(button_sell)
self.main_layout.add_widget(position_buttons_layout)
self.start_ticker(self.current_symbol)
self.popup_settings = Popup(
title='Settings',
size_hint=(0.5, 0.5),
background='icons/secondary_background.png',
background_color=[1, 1, 1, .5],
on_dismiss=self.save_user_data)
self.settings_buttons = BoxLayout(orientation="vertical",
padding=[0, 0, 0,
700]) # in pc, use 100
self.symbols_dropdown = DropDown(max_height=650)
for symbol in self.price_fetcher.get_all_symbols():
symbol_button = Button(text=symbol.upper(),
size_hint_y=None,
height=125)
symbol_button.bind(on_release=lambda symbol_button: self.
symbols_dropdown.select(symbol_button.text))
self.symbols_dropdown.add_widget(symbol_button)
self.main_symbol_button = Button(text=self.current_symbol.upper(),
pos_hint={
'center_x': .5,
'center_y': .8
})
self.main_symbol_button.bind(on_release=self.symbols_dropdown.open)
self.symbols_dropdown.bind(on_select=self.change_ticker)
self.settings_buttons.add_widget(self.main_symbol_button)
self.button_display_mode = Button(text='',
pos_hint={
'center_x': .5,
'center_y': .5
})
self.button_display_mode.bind(on_press=self.set_display_mode)
self.settings_buttons.add_widget(self.button_display_mode)
self.about_label = Label(text=self.about_info,
markup=True,
on_ref_press=self.on_ref_press,
pos_hint={
'center_x': .5,
'center_y': 1
})
self.about_label.bind(size=lambda s, w: s.setter('text_size')
(s, w)) # to limit text into popup
self.about_window = Popup(title='About',
size_hint=(0.5, 0.5),
background_color=[1, 1, 1, .5],
content=self.about_label)
self.news_fetcher = NewsFetcher()
self.button_news = Button(text=self.generate_news_button_text(),
pos_hint={
'center_x': .5,
'center_y': .5
})
self.button_news.bind(on_press=self.on_press_news)
self.settings_buttons.add_widget(self.button_news)
if self.news_status:
self.start_news_flasher()
self.fees_layout = BoxLayout(orientation='horizontal',
padding=[10, 0, 10, 0])
self.fees_label = Label(text='',
pos_hint={
'center_x': .9,
'center_y': .9
},
size_hint=(0.1, 0.1))
self.update_fees_label()
self.fees_layout.add_widget(self.fees_label)
self.fees_up = Button(text='+',
pos_hint={
'center_x': .9,
'center_y': .9
},
size_hint=(0.03, 0.1))
self.fees_up.bind(on_press=self.on_press_fees_up)
self.fees_layout.add_widget(self.fees_up)
self.fees_down = Button(text='-',
pos_hint={
'center_x': .9,
'center_y': .9
},
size_hint=(0.03, 0.1))
self.fees_down.bind(on_press=self.on_press_fees_down)
self.fees_layout.add_widget(self.fees_down)
self.fees_window = Popup(title='Fees',
size_hint=(0.5, 0.5),
background_color=[1, 1, 1, .5],
content=self.fees_layout)
self.button_fees = Button(text='Fees',
pos_hint={
'center_x': .5,
'center_y': .5
})
self.button_fees.bind(on_press=self.on_press_fees)
self.settings_buttons.add_widget(self.button_fees)
self.button_about = Button(text='About',
pos_hint={
'center_x': .5,
'center_y': .5
})
self.button_about.bind(on_press=self.on_press_about)
self.settings_buttons.add_widget(self.button_about)
self.popup_settings.add_widget(self.settings_buttons)
self.set_display_mode(None, load_up=True)
self.reset_pnl() # for display mode text
self.update_symbol_label() # set up label
return self.main_layout
def load_user_data(self):
"""
loads caches user data from last run
"""
if self.store.exists(self._DEF_DATAJSON_NAME):
try:
data = self.store.get(self._DEF_DATAJSON_NAME)
self._DEF_SYM = data['_SYM']
self._DEF_DISP_MODE = data['_DEF_DISP_MODE']
self._DEFAULT_NEWS_MODE = data['_DEFAULT_NEWS_MODE']
self._DEFAULT_FEES = data['_DEFAULT_FEES']
self._DEF_CUM_PNL = data['cum_pnl']
except KeyError:
pass # no data will be loaded
self.apply_user_data()
def apply_user_data(self):
"""
applies default / loaded settings to current run
"""
self.current_symbol = self._DEF_SYM
self.current_display_mode = self._DEF_DISP_MODE
self.news_status = self._DEFAULT_NEWS_MODE
self.user_fees = self._DEFAULT_FEES
self.cumulative_pnl = self._DEF_CUM_PNL
def save_user_data(self, *args):
"""
save current data
"""
self.store.put(self._DEF_DATAJSON_NAME,
_SYM=self.current_symbol,
_DEF_DISP_MODE=self.current_display_mode,
_DEFAULT_NEWS_MODE=self.news_status,
_DEFAULT_FEES=self.user_fees,
cum_pnl=self.cumulative_pnl)
def start_news_flasher(self):
"""
will be triggered upon button press and at launch
"""
Thread(target=self.news_fetcher.news_manager,
args=(self.flash_news, self.news_status),
daemon=True).start()
def reset_news_label(self):
"""
set back to empty text after newsflash is over
"""
self.news_label.text = ''
def flash_news(self, text):
"""
display a newsflash
"""
def_y_pos = self.news_label.pos[1]
pos = 5000
counter = 2 * pos
self.news_label.pos = (pos, def_y_pos)
self.news_label.text = text
while counter > 0 and self.news_status:
pos -= 1.5
counter -= 1
self.news_label.pos = (pos, def_y_pos)
sleep(0.01)
self.reset_news_label()
def set_display_mode(self, instance, load_up=False):
"""
sets 0 for dark mode, 1 for light mode
"""
if not load_up:
self.current_display_mode = 0 if self.current_display_mode else 1
self.button_display_mode.text = self.display_mode_mapping[
self.current_display_mode]
with self.main_layout.canvas.before:
if self.current_display_mode == 1:
Color(self._LIGHT_MODE_RGB)
self.button_refresh.background_normal = 'icons/light_mode/refresh_icon_light.png'
self.button_refresh.background_down = 'icons/light_mode/refresh_icon_light.png'
self.button_settings.background_normal = 'icons/light_mode/settings_icon_light.png'
self.button_settings.background_down = 'icons/light_mode/settings_icon_light.png'
Rectangle(size=(9999, 9999))
else:
Color(self._DARK_MODE_RGB)
self.button_refresh.background_normal = 'icons/dark_mode/refresh_icon_dark.png'
self.button_refresh.background_down = 'icons/dark_mode/refresh_icon_dark.png'
self.button_settings.background_normal = 'icons/dark_mode/settings_icon_dark.png'
self.button_settings.background_down = 'icons/dark_mode/settings_icon_dark.png'
self.main_layout.canvas.before.clear()
self.entry_price_label.color = self._TEXT_COLOR_LIGHTMODE if self.current_display_mode else \
self._TEXT_COLOR_DARKMODE
self.news_label.color = self._TEXT_COLOR_LIGHTMODE if self.current_display_mode else \
self._TEXT_COLOR_DARKMODE
if self.pnl_label.text == self.zero_pnl: # if zero pnl
self.pnl_label.color = self._TEXT_COLOR_LIGHTMODE if self.current_display_mode else \
self._TEXT_COLOR_DARKMODE
self.update_cum_pnl_label()
self.update_position_label()
def start_ticker(self, symbol: str):
"""
start a new ticker on a new thread
* fetches all tickers and verifies symbol exists
* passes `self.on_price_update` as the callback method
"""
if symbol.upper() in self.price_fetcher.get_all_symbols():
Thread(target=self.price_fetcher.connect_ws,
args=(symbol, self.on_price_update),
daemon=True).start()
while not self.last_price:
sleep(0.05)
else:
raise Exception(f"ticker {symbol} does not exist")
def stop_ticker(self, symbol: str):
"""
stop ticker (kill stream and thread)
"""
self.price_fetcher.disconnect_ws(symbol)
def change_ticker(self, instance, new_symbol: str):
"""
disconnects old symbol stream and connects a new one
uses first fetch via REST for illiquid pairs
"""
self.stop_ticker(self.current_symbol)
self.reset_pnl()
self.reset_position()
self.current_symbol = new_symbol
self.update_symbol_label()
self.start_ticker(new_symbol)
self.main_symbol_button.text = new_symbol
def on_press_news(self, instance):
"""
enable / disable newsflash
"""
self.news_status = not self.news_status
if not self.news_status:
self.news_fetcher.turn_off()
else:
self.start_news_flasher()
self.button_news.text = self.generate_news_button_text()
def generate_news_button_text(self):
"""
generate label for news toggler based on status
"""
return f'Display news - {self.news_status}'
def update_fees_label(self):
"""
update fees button label
"""
self.user_fees = round(self.user_fees, 2)
self.fees_label.text = f"{self.user_fees}"
def on_press_fees(self, instance):
"""
Open `about` popup window
"""
self.fees_window.open()
def on_press_fees_up(self, instance):
"""
increments fees and updates label
"""
self.user_fees += 0.01
self.update_fees_label()
def on_press_fees_down(self, instance):
"""
decrements fees and updates label
"""
self.user_fees -= 0.01
self.update_fees_label()
def on_press_about(self, instance):
"""
Open `fees` popup window
"""
self.about_window.open()
@staticmethod
def on_ref_press(*args):
"""
open ref link
"""
webbrowser.open(args[1])
def on_press_sell(self, instance):
"""
if no pos - enter short
if long - close pos
"""
if self.current_position == 0:
self.current_position = -1
self.entry_price = self.last_price
elif self.current_position == 1:
self.reset_position()
self.update_status_labels()
def on_press_buy(self, instance):
"""
if no pos - enter long
if short - close pos
"""
if self.current_position == 0:
self.current_position = 1
self.entry_price = self.last_price
elif self.current_position == -1:
self.reset_position()
self.update_status_labels()
def on_press_refresh(self, instance):
"""
when pressing refresh button
"""
self.reset_cum_pnl()
def on_press_settings(self, instance):
"""
when pressing settings button
"""
self.open_settings_menu()
def open_settings_menu(self):
"""
opens the settings popup menu
"""
self.popup_settings.open()
def apply_fees(self):
"""
apply fees to pnl
"""
self.current_pnl -= self.user_fees
def reset_cum_pnl(self):
"""
resets cumulative pnl
"""
self.cumulative_pnl = 0.0
self.update_cum_pnl_label()
def update_status_labels(self):
"""
updates:
* entry price label
* position label
* cumulative pnl label
"""
self.update_entry_label()
self.update_position_label()
self.update_cum_pnl_label()
def reset_position(self):
"""
* updates cumulative pnl (with fees)
* resets position status
* resets entry price
* resets pos pnl
"""
self.cumulative_pnl += (self.current_pnl - self.user_fees)
self.current_position = 0
self.entry_price = 0
self.reset_pnl()
self.update_position_label()
self.update_entry_label()
def reset_pnl(self):
"""Reset pnl label"""
self.pnl_label.text = self.zero_pnl
self.pnl_label.color = self._TEXT_COLOR_LIGHTMODE if self.current_display_mode else self._TEXT_COLOR_DARKMODE
def on_price_update(self, price):
"""
will be passed as callback to ws stream
"""
self.update_pnl(price)
precision = self.price_fetcher.get_symbol_precision(
self.current_symbol)
self.price_label.text = f'{price:.{precision}f}'
if price > self.last_price:
self.price_label.color = get_color_from_hex(self._GREEN_HEX)
else:
self.price_label.color = get_color_from_hex(self._RED_HEX)
self.last_price = price
def update_pnl(self, price):
"""
calculates current position PnL and updates the label accordingly
takes user fees into account
"""
if self.current_position != 0:
self.current_pnl = (self.entry_price / price)
self.current_pnl = (self.current_pnl - 1) * 100 if self.current_position == -1 else \
(1 - self.current_pnl) * 100
self.apply_fees()
self.pnl_label.text = f'{self.current_pnl:.{self._PNL_PERC}f}%'
if self.current_pnl > 0:
self.pnl_label.color = get_color_from_hex(self._GREEN_HEX)
elif self.current_pnl < 0:
self.pnl_label.color = get_color_from_hex(self._RED_HEX)
else:
self.reset_pnl()
def update_symbol_label(self):
"""
Updates the entry price label
"""
self.symbol_label.text = self.current_symbol
def update_entry_label(self):
"""
Updates the entry price label
"""
precision = self.price_fetcher.get_symbol_precision(
self.current_symbol)
self.entry_price_label.text = f'{self.entry_price:.{precision}f}'
def update_position_label(self):
"""
Updates current position label
"""
self.pos_str_label.text = self.position_mapping[self.current_position]
if self.current_position > 0:
self.pos_str_label.color = get_color_from_hex(self._GREEN_HEX)
elif self.current_position < 0:
self.pos_str_label.color = get_color_from_hex(self._RED_HEX)
else:
self.pos_str_label.color = self._TEXT_COLOR_LIGHTMODE if self.current_display_mode else \
self._TEXT_COLOR_DARKMODE
def update_cum_pnl_label(self):
"""
Updates cumulative PNL label
"""
self.cum_pnl_label.text = f"{round(self.cumulative_pnl, 2)}%"
if self.cumulative_pnl > 0:
self.cum_pnl_label.color = get_color_from_hex(self._GREEN_HEX)
elif self.cumulative_pnl < 0:
self.cum_pnl_label.color = get_color_from_hex(self._RED_HEX)
else:
self.cum_pnl_label.color = self._TEXT_COLOR_LIGHTMODE if self.current_display_mode \
else self._TEXT_COLOR_DARKMODE
self.save_user_data()
class BeautyDeepApp(MDApp):
'''Contains main interface and application logic'''
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.store = JsonStore('config.json')
if not self.store:
self.store['user_config'] = {
'theme_style': 'Light',
'theme_color': 'Pink',
'app_language': 1,
'public_ip': 'http://192.168.0.102:5000'
}
self.language = self.store['user_config']['app_language']
self.server_ip = self.store['user_config']['public_ip']
self.APP_ROOT = os.path.abspath('')
self.DCIM = self.get_dcim_path()
def build(self):
'''Prepares the application configurations and adds all content to the screens'''
Builder.load_file('beauty_deep.kv')
self.theme_cls.theme_style = self.store['user_config']['theme_style']
self.theme_cls.primary_palette = self.store['user_config'][
'theme_color']
self.main_interface = MainInterface()
self.main_interface.set_toolbar_color(self.theme_cls.primary_color)
self.change_language(self.language)
self.main_interface.beauty_screen.add_content()
self.main_interface.settings_screen.create_language_menu()
return self.main_interface
def on_start(self):
'''Called when the app starts'''
# self.fps_monitor_start()
if platform == 'android':
from android.permissions import request_permissions, Permission
request_permissions([
Permission.INTERNET, Permission.READ_EXTERNAL_STORAGE,
Permission.WRITE_EXTERNAL_STORAGE
])
def on_pause(self):
'''Called when the app is on pause'''
return True
def on_resume(self):
'''Called when the app is resume'''
pass
def on_stop(self):
'''Called when the app is stopped'''
try:
os.remove('output.jpg')
os.remove('mask-output.jpg')
except:
pass
def get_dcim_path(self):
'''Gets gallery directory path'''
if platform == 'android':
return storagepath.get_pictures_dir()
else:
return self.APP_ROOT
def switch_theme_style(self):
'''Changes the theme style of the application'''
if self.theme_cls.theme_style == 'Dark':
self.theme_cls.theme_style = 'Light'
self.store.put('user_config',
theme_style='Light',
theme_color=self.theme_cls.primary_palette,
app_language=self.language,
public_ip=self.server_ip)
else:
self.theme_cls.theme_style = 'Dark'
self.store.put('user_config',
theme_style='Dark',
theme_color=self.theme_cls.primary_palette,
app_language=self.language,
public_ip=self.server_ip)
def switch_theme_color(self, color_name):
'''Changes the theme color of the application'''
self.theme_cls.primary_palette = color_name
self.store.put('user_config',
theme_style=self.theme_cls.theme_style,
theme_color=color_name,
app_language=self.language,
public_ip=self.server_ip)
def change_language(self, language):
'''Changes the interface language of the entire app'''
self.language = language
self.store.put('user_config',
theme_style=self.theme_cls.theme_style,
theme_color=self.theme_cls.primary_palette,
app_language=language,
public_ip=self.server_ip)
self.main_interface.home_screen.add_content(self.language)
self.main_interface.settings_screen.light_label.text = languages[
self.language]['light']
self.main_interface.settings_screen.dark_label.text = languages[
self.language]['dark']
self.main_interface.settings_screen.style_label.text = languages[
self.language]['theme_style']
self.main_interface.settings_screen.color_label.text = languages[
self.language]['theme_color']
self.main_interface.settings_screen.language_label.text = languages[
self.language]['choose_language']
self.main_interface.settings_screen.lang_chooser.text = languages[
self.language]['lang']
self.main_interface.settings_screen.server_label.text = languages[
self.language]['server']
self.main_interface.settings_screen.about_label.text = languages[
self.language]['about_us']
self.main_interface.settings_screen.developer_label.text = languages[
self.language]['developer']
self.main_interface.settings_screen.feedback_label.text = languages[
self.language]['feedback']
self.main_interface.settings_screen.social_label.text = languages[
self.language]['social']
self.main_interface.settings_screen.share_label.text = languages[
self.language]['share']
self.main_interface.settings_screen.rate_label.text = languages[
self.language]['rate']
self.main_interface.spinner_screen.processing_label1.text = languages[
self.language]['image_processing1']
self.main_interface.spinner_screen.processing_label2.text = languages[
self.language]['image_processing2']
self.main_interface.beauty_screen.save_button.text = languages[
self.language]['save_results']
self.main_interface.beauty_screen.mask_button.text = languages[
self.language]['hide_mask']
def change_server_ip(self, ip):
'''Changes server public ip (http://ip:port)'''
self.server_ip = ip
self.store.put('user_config',
theme_style=self.theme_cls.theme_style,
theme_color=self.theme_cls.primary_palette,
app_language=self.language,
public_ip=ip)
def file_manager_open(self):
'''Call plyer filechooser API to run a filechooser activity in given directory'''
filechooser.open_file(path=self.DCIM,
preview=True,
filters=[('Images', '*.jpg', '*.png', '*.svg',
'*.bmp', '*.eps', '*.eic')],
on_selection=self.select_path)
def select_path(self, selection):
'''Callback function for handling the selection response from activity.
Selects a file, launch a spinner and starts image processing in a separate thread'''
if selection:
path = selection[0]
if path[-3:].lower() not in [
'jpg', 'png', 'svg', 'bmp', 'eps', 'eic'
]:
toast(languages[self.language]['unsupported_format'])
else:
self.main_interface.current = 'spinner_screen'
self.main_interface.beauty_screen.image_path = path
Thread(target=self.get_faces).start()
def set_current_screen(self, screen, *, with_reset=True):
'''Goes to the specified screen.
Param with_reset resets BeautyScreen by default and deletes temporary images'''
self.main_interface.current = screen
if with_reset and self.main_interface.beauty_screen.image_path:
try:
os.remove('output.jpg')
os.remove('mask-output.jpg')
except:
pass
self.main_interface.beauty_screen.image_path = None
self.main_interface.beauty_screen.input_image = None
self.main_interface.beauty_screen.image_viewer = None
self.main_interface.beauty_screen.mask_button.text = languages[
self.language]['hide_mask']
def get_faces(self):
'''Recognizes and processes the image with a neural network and goes to the BeautyScreen'''
try:
im = Image(self.main_interface.beauty_screen.image_path)
self.main_interface.beauty_screen.input_image = im.image.copy()
im.send_request(self.server_ip)
im.create_output(mask=False)
im.create_output(mask=True)
self.main_interface.beauty_screen.set_image('mask-output.jpg')
self.main_interface.beauty_screen.set_beauty_params(im.faces[0], 0)
self.main_interface.beauty_screen.faces = im.faces
self.main_interface.beauty_screen.create_face_menu()
self.main_interface.current = 'beauty_screen'
except ValueError:
toast(languages[self.language]['small_resolution'])
self.set_current_screen('menu_screen')
except ConnectionError:
toast(languages[self.language]['server_off'])
self.set_current_screen('menu_screen')
except Exception as e:
print(e)
toast(languages[self.language]['not_recognized'])
self.set_current_screen('menu_screen')
def saverecordedpositions(self,filename):
postionsstore = JsonStore(filename +'.json')
postionsstore.put('3dpostions_list', postionvalues = self.recordedpositions)
class Controller(EventDispatcher):
"""
Controls the playing of audio and coordinates the updating of the playlist
and screen displays
"""
volume = NumericProperty(1.0)
advance = True
# This flag indicates whether to advance to the next track
# once the currently playing one had ended
sm = None # THe ScreenManager
pos = 0
def __init__(self, **kwargs):
""" Initialize the screens and the screen manager """
self._store = JsonStore(
join(self._get_settings_folder(), "zenplayer.json"))
self.playlist = PlayList(self._store)
self.sm = ScreenManager()
self.playing = PlayingScreen(self, name="main")
self.sm.add_widget(self.playing)
self.sm.current = "main"
if platform not in ['ios', 'android']:
self.kb_listener = ZenKeyboardListener(self.on_key_down,
self.playing)
Sound.add_state_callback(self.playing.on_sound_state)
Sound.add_state_callback(self._on_sound_state)
super(Controller, self).__init__(**kwargs)
if self._store.exists('state'):
state = self._store.get("state")
if "volume" in state.keys():
self.volume = state["volume"]
@staticmethod
def _get_settings_folder():
""" Return the folder when the setting file is stored. """
path = expanduser("~/.zencode")
if not exists(path):
mkdir(path)
return path
def _on_sound_state(self, state):
""" The sound state has changed. If the track played to the end,
move to the next track."""
if state == "finished" and self.advance:
self.play_next()
def get_current_art(self):
return self.playlist.get_current_art()
def get_current_info(self):
return self.playlist.get_current_info()
def get_current_file(self):
return self.playlist.get_current_file()
@staticmethod
def get_pos_length():
return Sound.get_pos_length()
def on_key_down(self, keyboard, keycode, text, modifiers):
""" React to the keypress event """
key_name = keycode[1]
if key_name == "up" or text == "+":
self.volume += 0.025
elif key_name == "down" or text == "-":
self.volume -= 0.025
elif key_name == "x":
self.play_pause()
elif key_name == "z":
self.play_previous()
elif key_name == "v":
self.stop()
elif key_name == "b":
self.play_next()
elif key_name == "a":
self.show_filebrowser()
elif key_name == "p":
self.show_playlist()
elif key_name == "s":
self.show_main()
return True
def on_volume(self, widget, value):
""" Set the volume of the currently playing sound """
if 0.0 > value:
self.volume = 0.0
elif value > 1.0:
self.volume = 1.0
else:
Sound.set_volume(value)
self.playing.volume_slider.value = value
def play_index(self, index):
"""
Play the track with the specified playlist index
"""
Sound.stop()
self.playlist.current = index
self.play_pause()
def play_pause(self):
""" Play or pause the currently playing track """
self.advance = True
if Sound.state == "playing":
self.pos, x = Sound.get_pos_length()
Sound.stop()
else:
audio_file = self.get_current_file()
if audio_file:
Sound.play(audio_file, self.volume)
if self.pos > 0:
def set_pos(dt):
Sound.seek(self.pos)
self.pos = 0
Clock.schedule_once(set_pos, 0.1)
def play_next(self):
""" Play the next track in the playlist. """
Sound.stop()
self.playlist.move_next()
self.play_pause()
def play_previous(self):
""" Play the previous track in the playlist. """
Sound.stop()
self.playlist.move_previous()
self.play_pause()
@staticmethod
def set_position(value):
""" Set the playing position to the specified value. """
Sound.set_position(value)
def save(self):
""" Save the state of the the playlist and volume. """
self.playlist.save(self._store)
self._store.put("state", volume=self.volume)
if "filebrowser" in self.sm.screen_names:
self.sm.get_screen("filebrowser").save(self._store)
def show_filebrowser(self):
""" Switch to the file browser screen """
if "filebrowser" not in self.sm.screen_names:
self.sm.add_widget(
ZenFileBrowser(self,
self.playlist,
self._store,
name="filebrowser"))
self.sm.current = "filebrowser"
def show_playlist(self):
""" Switch to the playlist screen """
if "playlist" not in self.sm.screen_names:
self.sm.add_widget(
PlayListScreen(self.sm, self, self.playlist, name="playlist"))
self.sm.current = "playlist"
def show_main(self):
""" Switch to the main playing screen"""
self.sm.current = "main"
def stop(self):
""" Stop any playing audio """
self.advance = False
Sound.stop()
class MainApp(MDApp):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.theme_cls.theme_style = "Light"
self.theme_cls.primary_palette = "Teal"
self.storage = JsonStore('../store.json')
self.emails = JsonStore('../emails.json')
self.view_stock_widgets = []
self.manage_items_widgets = []
self.add_remove_stock_widgets = []
self.edit_item_widgets = []
self.send_data_widgets = []
self.low_stock_widgets = []
def add_item(self, name, stock_type, stock_level, stock_units,
low_threshold, pop_weighting):
inputs = [
name, stock_type, stock_level, stock_units, low_threshold,
pop_weighting
]
if '' not in inputs:
self.storage.put(name,
name=name,
stock_type=stock_type,
stock_level=int(stock_level),
stock_units=stock_units,
low_threshold=int(low_threshold),
pop_weighting=int(pop_weighting))
else:
toast('Some fields were left blank...')
def remove_item(self, name):
self.storage.delete(name)
def remove_email(self, email):
self.emails.delete(email)
def update_stock_level(self, name, stock_level_change):
item = self.storage.get(name)
item['stock_level'] += stock_level_change
if item['stock_level'] < 0:
item['stock_level'] = 0
self.storage.put(name,
name=name,
stock_type=item['stock_type'],
stock_level=item['stock_level'],
stock_units=item['stock_units'],
low_threshold=item['low_threshold'],
pop_weighting=item['pop_weighting'])
def apply_stock_changes(self):
for widget in self.add_remove_stock_widgets:
try:
if widget.ids.plus_minus.active == True:
sign = '+'
else:
sign = '-'
except AttributeError:
continue
if len(widget.ids.stock.text) > 0:
stock_change = sign + widget.ids.stock.text
self.update_stock_level(widget.ids.name.text,
int(stock_change))
widget.ids.stock.text = ''
self.load_add_remove_stock_screen()
self.load_low_stock_screen()
toast('Update Successful')
def apply_edit_changes(self, name, stock_type, stock_level, stock_units,
low_threshold, pop_weighting):
self.storage.delete(self.editing_item)
self.storage.put(name,
name=name,
stock_type=stock_type,
stock_level=int(stock_level),
stock_units=stock_units,
low_threshold=int(low_threshold),
pop_weighting=int(pop_weighting))
self.load_manage_items_screen()
self.load_view_stock_screen()
self.load_add_remove_stock_screen()
self.load_low_stock_screen()
self.editing_item = None
toast('Changes Applied')
def delete_item(self, item):
screen = self.root.ids.screen_manager.current
if screen == 'manage_items':
self.remove_item(item)
self.root.ids.screen_manager.current = 'manage_items'
self.load_manage_items_screen()
self.load_view_stock_screen()
self.load_add_remove_stock_screen()
self.load_low_stock_screen()
elif screen == 'send_data':
self.remove_email(item)
self.root.ids.screen_manager.current = 'send_data'
self.load_send_data_screen()
toast('Deleted')
def load_manage_items_screen(self):
for widget in self.manage_items_widgets:
self.root.ids.manage_items_list.remove_widget(widget)
keys = sorted(self.storage.keys())
stock_types = []
for key in self.storage:
item = self.storage.get(key)
if item['stock_type'] not in stock_types:
stock_types.append(item['stock_type'])
stock_types.sort()
for stock_type in stock_types:
widget = Subtitle_Widget(stock_type)
self.root.ids.manage_items_list.add_widget(widget)
self.manage_items_widgets.append(widget)
for key in keys:
item = self.storage.get(key)
if item['stock_type'] == stock_type:
name = item['name']
widget = Manage_Items_Swipe_Card(name)
self.root.ids.manage_items_list.add_widget(widget)
self.manage_items_widgets.append(widget)
def load_view_stock_screen(self):
for widget in self.view_stock_widgets:
self.root.ids.view_stock_list.remove_widget(widget)
keys = sorted(self.storage.keys())
stock_types = []
for key in self.storage:
item = self.storage.get(key)
if item['stock_type'] not in stock_types:
stock_types.append(item['stock_type'])
stock_types.sort()
for stock_type in stock_types:
widget = Subtitle_Widget(stock_type)
self.root.ids.view_stock_list.add_widget(widget)
self.view_stock_widgets.append(widget)
for key in keys:
item = self.storage.get(key)
if item['stock_type'] == stock_type:
name = item['name']
stock_level = item['stock_level']
units = item['stock_units']
low_threshold = item['low_threshold']
if stock_level <= low_threshold:
low = True
else:
low = False
stock_level_string = str(stock_level) + ' ' + str(units)
widget = View_Stock_Card(name, stock_level_string, low)
self.root.ids.view_stock_list.add_widget(widget)
self.view_stock_widgets.append(widget)
def load_add_remove_stock_screen(self):
for widget in self.add_remove_stock_widgets:
self.root.ids.add_remove_stock_list.remove_widget(widget)
self.add_remove_stock_widgets = []
keys = sorted(self.storage.keys())
stock_types = []
for key in self.storage:
item = self.storage.get(key)
if item['stock_type'] not in stock_types:
stock_types.append(item['stock_type'])
stock_types.sort()
for stock_type in stock_types:
widget = Subtitle_Widget(stock_type)
self.root.ids.add_remove_stock_list.add_widget(widget)
self.add_remove_stock_widgets.append(widget)
for key in keys:
item = self.storage.get(key)
if item['stock_type'] == stock_type:
name = item['name']
widget = Add_Remove_Stock_Card(name)
self.root.ids.add_remove_stock_list.add_widget(widget)
self.add_remove_stock_widgets.append(widget)
widget = MDCard(size_hint_y=None, height='50dp')
self.root.ids.add_remove_stock_list.add_widget(widget)
self.add_remove_stock_widgets.append(widget)
def load_edit_item_screen(self, key):
for widget in self.edit_item_widgets:
self.root.ids.edit_item_layout.remove_widget(widget)
self.edit_item_widgets = []
item = self.storage.get(key)
widget = Edit_Item_Dialog_Content()
widget.ids.item_name.text = str(item['name'])
widget.ids.item_type.text = str(item['stock_type'])
widget.ids.stock_level.text = str(item['stock_level'])
widget.ids.stock_units.text = str(item['stock_units'])
widget.ids.low_threshold.text = str(item['low_threshold'])
widget.ids.pop_weighting.text = str(item['pop_weighting'])
self.root.ids.edit_item_layout.add_widget(widget)
self.edit_item_widgets.append(widget)
self.editing_item = item['name']
def load_send_data_screen(self):
for widget in self.send_data_widgets:
self.root.ids.emails_list.remove_widget(widget)
self.send_data_widgets = []
keys = sorted(self.emails.keys())
for key in keys:
email = self.emails.get(key)
widget = Email_Contact_Card(email['email'])
self.root.ids.emails_list.add_widget(widget)
self.send_data_widgets.append(widget)
def load_low_stock_screen(self):
for widget in self.low_stock_widgets:
self.root.ids.low_stock_layout.remove_widget(widget)
self.low_stock_widgets = []
keys = sorted(self.storage.keys())
stock_types = []
for key in self.storage:
item = self.storage.get(key)
if item['stock_type'] not in stock_types:
stock_types.append(item['stock_type'])
stock_types.sort()
for stock_type in stock_types:
widget = Subtitle_Widget(stock_type)
self.root.ids.low_stock_layout.add_widget(widget)
self.low_stock_widgets.append(widget)
for key in keys:
item = self.storage.get(key)
if item['stock_type'] == stock_type and item[
'stock_level'] <= item['low_threshold']:
widget = Low_Stock_Item_Card(item['name'])
self.root.ids.low_stock_layout.add_widget(widget)
self.low_stock_widgets.append(widget)
def open_add_item_popup(self):
content = Add_Item_Dialog_Content()
self.popup = MDDialog(
type='custom',
content_cls=content,
auto_dismiss=False,
)
self.popup.open()
def confirm_delete_dialog(self, item):
content = Confirm_Delete_Dialog_Content(item)
self.popup = MDDialog(
type='custom',
content_cls=content,
auto_dismiss=False,
)
self.popup.open()
def open_add_email_popup(self):
content = Add_Email_Content()
self.popup = MDDialog(
type='custom',
content_cls=content,
auto_dismiss=False,
)
self.popup.open()
def add_contact(self, email):
self.emails.put(email, email=email, sent=False)
self.load_send_data_screen()
def send_email(self, email):
address = self.emails.get(email)
self.emails.put(email, email=email, sent=True)
#customise frm and password to send emails from your account for testing purposes.
frm = '*****@*****.**'
password = ''
to = email
subject = 'Stock Level Data'
server = smtplib.SMTP(host='smtp.gmail.com', port=587)
server.starttls()
server.login(frm, password)
msg = MIMEMultipart()
msg['From'] = frm
msg['to'] = to
msg['subject'] = subject
body = ""
keys = self.storage.keys()
keys.sort()
stock_types = []
for key in keys:
stock_type = self.storage.get(key)['stock_type']
if stock_type not in stock_types:
stock_types.append(stock_type)
for stock_type in stock_types:
body += '%s\n' % stock_type.upper()
for key in keys:
item = self.storage.get(key)
if item['stock_type'] == stock_type:
body += '%s: %s %s\n' % (item['name'], item['stock_level'],
item['stock_units'])
body += '\n'
msg.attach(MIMEText(body, 'plain'))
server.sendmail(frm, to, msg.as_string())
toast('Sent to: %s' % email)
def set_screen(self, screen):
self.root.ids.screen_manager.current = screen
def build(self):
self.title = 'WTF Stock Take'
return MainLayout()
def on_start(self):
self.load_manage_items_screen()
self.load_view_stock_screen()
self.load_add_remove_stock_screen()
self.load_send_data_screen()
self.load_low_stock_screen()
class DataBase:
url = 'https://ospapp-53708.firebaseio.com/.json?auth='
admin_passwd = ''
def __init__(self, path, heroes_path, passwd_path):
self.path = path
self.store = JsonStore(path)
with open("secret", 'r') as file:
data = file.read().split("\n")
self.url = self.url + data[0]
self.firebase_patch_all()
try:
string = str(requests.get(self.url).json()['heroes'])
if string:
with open(heroes_path, 'w') as file:
file.write(string)
except Exception as e:
print(str(e))
try:
with open(heroes_path, 'r') as file:
self.heroes = json.loads(str(file.read()).replace("'", '"'))
except Exception as e:
print(str(e))
self.heroes = ["brak strażaków w bazie"]
try:
string = str(requests.get(self.url).json()['passwd'])
if string:
with open(passwd_path, 'w') as file:
file.write(string)
except Exception as e:
print(str(e))
try:
with open(passwd_path, 'r') as file:
global admin_passwd
admin_passwd = file.readline()
except Exception as e:
print(str(e))
def put_report(self, uuid_num, id_number, dep_date, dep_time, spot_time,
location, type_of_action, section_com, action_com, driver,
perpetrator, victim, section, details, return_date,
end_time, home_time, stan_licznika, km_location, completed):
if uuid_num == "":
uuid_num = str(uuid.uuid1())
if section_com == "Dowódca sekcji":
section_com = ""
if action_com == "Dowódca akcji":
action_com = ""
if driver == "Kierowca":
driver = ""
self.store.put(uuid_num,
innerID=id_number,
depDate=dep_date,
depTime=dep_time,
spotTime=spot_time,
location=location,
type=type_of_action,
sectionCom=section_com,
actionCom=action_com,
driver=driver,
perpetrator=perpetrator,
victim=victim,
section=section,
details=details,
returnDate=return_date,
endTime=end_time,
homeTime=home_time,
stanLicznika=stan_licznika,
KM=km_location,
modDate=self.get_date(),
ready=completed)
try:
string = "{'" + uuid_num + "': " + str(
self.store.get(uuid_num)) + "}"
to_database = json.loads(string.replace("'", '"'))
requests.patch(url=self.url, json=to_database)
except Exception as e:
print(str(e))
def delete_report(self, uuid_num):
if self.store.exists(uuid_num):
try:
# requests.delete(url=self.url[:-5] + id_number + ".json")
string = '{"deleted-' + uuid_num + '": "true"}'
to_database = json.loads(string)
requests.patch(url=self.url, json=to_database)
except Exception as e:
Factory.deletePopout().open()
print(str(e))
else:
self.store.delete(uuid_num)
else:
return -1
def get_heroes(self):
return self.heroes
def firebase_patch_all(self):
try:
with open(self.path, 'r') as file:
data = file.read()
to_database = json.loads(data)
requests.patch(url=self.url, json=to_database)
except Exception as e:
print(str(e))
def delete_all(self):
string_all = ""
try:
for key in self.store.keys():
# requests.delete(url=self.url[:-5] + key + ".json")
string = '{"deleted-' + key + '": "true"}'
string_all = string_all + string
to_database = json.loads(string)
requests.patch(url=self.url, json=to_database)
except Exception as e:
Factory.deletePopout().open()
print(str(e))
else:
self.store.clear()
def get_report(self, id_number):
for item in self.store.find(innerID=id_number):
dane = self.store.get(item[0])
id_number = dane['innerID']
dep_date = dane['depDate']
dep_time = dane['depTime']
spot_time = dane['spotTime']
location = dane['location']
type_of_action = dane['type']
section_com = dane['sectionCom']
action_com = dane['actionCom']
driver = dane['driver']
perpetrator = dane['perpetrator']
victim = dane['victim']
section = dane['section']
details = dane['details']
return_date = dane['returnDate']
end_time = dane['endTime']
home_time = dane['homeTime']
stan_licznika = dane['stanLicznika']
km_location = dane['KM']
date = dane['modDate']
completed = dane['ready']
return [
item[0], id_number, dep_date, dep_time, spot_time, location,
type_of_action, section_com, action_com, driver, perpetrator,
victim, section, details, return_date, end_time, home_time,
stan_licznika, km_location, date, completed
]
else:
return -1
def get_all_friendly(self):
result = []
for item in self.store.keys():
data = self.store.get(item)
result.append(data["innerID"] + " " + data["location"])
return result
def find_inner_id(self, id_number):
for _ in self.store.find(innerID=id_number):
return True
return False
@staticmethod
def get_date():
return str(datetime.datetime.now()).split(".")[0]
def get_passwd(self):
global admin_passwd
return admin_passwd
def updata_say_text_list(self,text_list):
store = JsonStore('tts.json')
store.put('text',txt1=text_list[0],txt2=text_list[1],txt3=text_list[2],txt4=text_list[3])
def savecalibration(self,mtx,dist):
calibrationstore = JsonStore('Saved_calibration.json')
lstmtx = mtx.tolist()
lstdist = dist.tolist()
calibrationstore.put('calibration_var', mtx = lstmtx, dist = lstdist)
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 CalcPyApp(App):
def build(self):
self.store = JsonStore('scripts.json')
self.appview = NavigationDrawer()
self.appview.anim_type = 'reveal_below_anim'
side_panel = BoxLayout(orientation='vertical')
title = Label(text='Pycalc')
title.size = self.appview.width, 30
title.size_hint_y = None
side_panel.add_widget(title)
new_btn = Button(text='New Script')
new_btn.size = self.appview.width, 50
new_btn.size_hint_y = None
new_btn.bind(on_press=lambda _: self.new_script())
side_panel.add_widget(new_btn)
s_in = TextInput()
s_in.multiline = False
s_in.size = self.appview.width, 50
s_in.size_hint_y = None
def show_s_in():
s_in.height, s_in.opacity, s_in.disabled = 50, 1, False
save_btn.height, save_btn.opacity, save_btn.disabled = 0, 0, True
def focus():
s_in.focus = True
Clock.schedule_once(lambda dt: focus(), 0.1)
def hide_s_in(x=False):
if x:
return
s_in.height, s_in.opacity, s_in.disabled = 0, 0, True
save_btn.height, save_btn.opacity, save_btn.disabled = 50, 1, False
save_btn = Button(text='Save Script')
save_btn.size = self.appview.width, 50
save_btn.size_hint_y = None
save_btn.bind(on_press=lambda _: show_s_in())
side_panel.add_widget(save_btn)
s_in.bind(on_text_validate=lambda instance: self.save_script(
instance.text.strip()))
s_in.bind(focused=lambda _, x: hide_s_in(x))
hide_s_in()
side_panel.add_widget(s_in)
load_btn = Button(text='Load Script')
load_btn.size = self.appview.width, 50
load_btn.size_hint_y = None
load_btn.bind(on_press=lambda _: self.load_script())
side_panel.add_widget(load_btn)
self.appview.add_widget(side_panel)
self.main_panel = ScrollableText()
self.appview.add_widget(self.main_panel)
return self.appview
def new_script(self):
global state
global lexer
state = State()
lexer.state = state
self.main_panel.layout.clear_widgets()
self.main_panel.add_new_codeline()
def save_script(self, name):
lines = []
for wid in reversed(self.main_panel.layout.children):
if isinstance(wid, CodeInput) and len(wid.text) > 0:
lines.append(wid.text)
if len(lines) > 0:
self.store.put(name, data=lines)
def load_script(self):
popup = Popup(title='Load script')
def want_delete(btn, choice_callback, _):
def delete(name):
self.store.delete(name)
btn.height, btn.opacity, btn.disabled = 0, 0, True
saved_text = btn.text
callback = lambda _: delete(saved_text)
def lost_focus(_):
btn.text = saved_text
btn.color = (1, 1, 1, 1)
btn.unbind(on_press=callback)
btn.bind(on_release=choice_callback)
btn.text = 'delete?'
btn.color = (1, 0, 0, 1)
btn.bind(on_press=callback)
Clock.schedule_once(lost_focus, 2)
btn.unbind(on_release=choice_callback)
def create_clock(widget, touch, choice_callback, *args):
if not isinstance(widget, Button):
return
if not widget.collide_point(*touch.pos):
return
callback = partial(want_delete, widget, choice_callback)
Clock.schedule_once(callback, 0.5)
touch.ud['event'] = callback
def delete_clock(widget, touch, *args):
if not isinstance(widget, Button):
return
if 'event' in touch.ud:
Clock.unschedule(touch.ud['event'])
del touch.ud['event']
def choice(name):
self.new_script()
data = self.store.get(name)['data']
for line in data:
codeinput = self.main_panel.layout.children[0]
codeinput.text = line
self.main_panel.code_interpret(codeinput)
popup.dismiss()
scroll_content = ScrollView()
content = BoxLayout(orientation='vertical', size_hint_y=None)
content.bind(minimum_height=content.setter('height'))
scroll_content.add_widget(content)
for item in self.store:
btn = Button(text=item)
btn.size = content.width, 50
btn.size_hint_y = None
choice_callback = lambda _: choice(item)
btn.bind(on_touch_down=partial(create_clock,
choice_callback=choice_callback),
on_touch_up=delete_clock)
btn.bind(on_release=choice_callback)
content.add_widget(btn)
close_btn = Button(text='Cancel')
close_btn.size_hint = 0.3, None
close_btn.height = 50
close_btn.bind(on_press=popup.dismiss)
content.add_widget(close_btn)
popup.content = scroll_content
popup.open()
class KaTrainBase:
USER_CONFIG_FILE = os.path.expanduser("~/.katrain/config.json")
PACKAGE_CONFIG_FILE = "katrain/config.json"
"""Settings, logging, and players functionality, so other classes like bots who need a katrain instance can be used without a GUI"""
def __init__(self, force_package_config=False, debug_level=0, **kwargs):
self.debug_level = debug_level
self.game = None
self.logger = lambda message, level=OUTPUT_INFO: self.log(
message, level)
self.config_file = self._load_config(
force_package_config=force_package_config)
self.debug_level = debug_level or self.config("general/debug_level",
OUTPUT_INFO)
Config.set("kivy", "log_level", "warning")
if self.debug_level >= OUTPUT_DEBUG:
Config.set("kivy", "log_enable", 1)
Config.set("kivy", "log_level", "debug")
if self.debug_level >= OUTPUT_EXTRA_DEBUG:
Config.set("kivy", "log_level", "trace")
self.players_info = {"B": Player("B"), "W": Player("W")}
self.reset_players()
def log(self, message, level=OUTPUT_INFO):
if level == OUTPUT_ERROR:
print(f"ERROR: {message}")
elif self.debug_level >= level:
print(message)
def _load_config(self, force_package_config):
if len(sys.argv) > 1 and sys.argv[1].endswith("config.json"):
config_file = os.path.abspath(sys.argv[1])
self.log(f"Using command line config file {config_file}",
OUTPUT_INFO)
else:
user_config_file = find_package_resource(self.USER_CONFIG_FILE)
package_config_file = find_package_resource(
self.PACKAGE_CONFIG_FILE)
if force_package_config:
config_file = package_config_file
else:
try:
if not os.path.exists(user_config_file):
os.makedirs(os.path.split(user_config_file)[0],
exist_ok=True)
shutil.copyfile(package_config_file, user_config_file)
config_file = user_config_file
self.log(
f"Copied package config to local file {config_file}",
OUTPUT_INFO)
else: # user file exists
version = JsonStore(user_config_file,
indent=4).get("general")["version"]
if version < CONFIG_MIN_VERSION:
backup = user_config_file + f".{version}.backup"
shutil.copyfile(user_config_file, backup)
shutil.copyfile(package_config_file,
user_config_file)
self.log(
f"Copied package config file to {user_config_file} as user file is outdated (<{CONFIG_MIN_VERSION}). Old version stored as {backup}",
OUTPUT_INFO,
)
config_file = user_config_file
self.log(f"Using user config file {config_file}",
OUTPUT_INFO)
except Exception as e:
config_file = package_config_file
self.log(
f"Using package config file {config_file} (exception {e} occurred when finding or creating user config)",
OUTPUT_INFO,
)
try:
self._config_store = JsonStore(config_file, indent=4)
except Exception as e:
self.log(f"Failed to load config {config_file}: {e}", OUTPUT_ERROR)
sys.exit(1)
self._config = dict(self._config_store)
return config_file
def save_config(self, key=None):
if key is None:
for k, v in self._config.items():
self._config_store.put(k, **v)
else:
self._config_store.put(key, **self._config[key])
def config(self, setting, default=None):
try:
if "/" in setting:
cat, key = setting.split("/")
return self._config.get(cat, {}).get(key, default)
else:
return self._config[setting]
except KeyError:
self.log(f"Missing configuration option {setting}", OUTPUT_ERROR)
def update_player(self, bw, **kwargs):
self.players_info[bw].update(**kwargs)
def reset_players(self):
self.update_player("B")
self.update_player("W")
for v in self.players_info.values():
v.periods_used = 0
@property
def last_player_info(self) -> Player:
return self.players_info[self.game.current_node.player]
@property
def next_player_info(self) -> Player:
return self.players_info[self.game.current_node.next_player]
class FindBWidget(BoxLayout):
level = NumericProperty(1)
bfound = NumericProperty(0)
bnumber = NumericProperty(0)
def __init__(self, **kwargs):
super(FindBWidget, self).__init__(**kwargs)
self.BBoxList = []
self.store = JsonStore("findb.json")
self.gridSize_height = 0
self.gridSize_width = 0
self.bnumber = 0
self.badded = 0
self.bfound = 0
self.mute = True
self.gameover = False
self.custimize = False
self.custimize_height = 0
self.custimize_width = 0
self.custimize_brate = 0.2
self.sounds = {
'bomb': SoundLoader.load('bomb.wav'),
'state': SoundLoader.load('state.wav'),
'upgrade': SoundLoader.load('upgrade.mp3')
}
self.start_clock = clock()
self.config = None
def on_bfound(self, instance, value):
self.status_bar.label_left_bomb.text = '{}'.format(self.bnumber -
self.bfound)
self.CheckSucceed()
def on_bnumber(self, instance, value):
self.status_bar.label_left_bomb.text = '{}'.format(self.bnumber -
self.bfound)
def Restart(self):
self.custimize, self.custimize_height, self.custimize_width, self.custimize_brate = self.get_customize_info(
)
self.level, self.levels_info = self.get_level_info()
self.mute = self.get_mute_info()
self.BBoxList = []
if self.custimize == True:
self.status_bar.label_level.text = 'L:C'
self.gridSize_height = self.custimize_height
self.gridSize_width = self.custimize_width
if self.gridSize_height < 5:
self.gridSize_height = 5
if self.gridSize_width < 5:
self.gridSize_width = 5
if self.gridSize_height > 50:
self.gridSize_height = 50
if self.gridSize_width > 50:
self.gridSize_width = 50
else:
self.status_bar.label_level.text = 'L:{}'.format(self.level)
self.gridSize_width = self.level + Rows_For_First_Level
self.gridSize_height = self.level + Rows_For_First_Level
self.bnumber = 0
self.badded = 0
self.bfound = 0
self.start_clock = clock()
self.gameover = False
self.play_area.clear_widgets()
self.play_area.cols = self.gridSize_width
self.play_area.rows = self.gridSize_height
for i in range(0, self.gridSize_height):
for j in range(0, self.gridSize_width):
b = BBox(root=self)
b.row = i
b.col = j
self.BBoxList.append(b)
self.play_area.add_widget(b)
self._calculate_bombs()
self.status_bar.toggle_mark.disable = False
self.status_bar.toggle_mark.state = "normal"
self.status_bar.button_reset.image.source = 'smile.png'
def _calculate_bombs(self):
if self.custimize:
self.brate = self.custimize_brate / 100.0
if self.brate < 0.05:
self.brate = 0.05
if self.brate > 0.8:
self.brate = 0.8
elif self.level < 6:
self.brate = 0.11
elif self.level < 11:
self.brate = 0.13
elif self.level < 20:
self.brate = 0.15
elif self.level < 30:
self.brate = 0.18
else:
self.brate = 0.2
self.bnumber = int(self.brate * self.gridSize_width *
self.gridSize_height)
self.badded = 0
while True:
if self._add_bomb():
self.badded += 1
if self.badded >= self.bnumber:
break
def _add_bomb(self):
if len(self.BBoxList) <= 0:
return
i = Random().randint(0, len(self.BBoxList) - 1)
if self.BBoxList[i].isBomb:
return False
else:
self.BBoxList[i].isBomb = True
#set bomb number of the around boxes
row = self.BBoxList[i].row
col = self.BBoxList[i].col
self._add_bomb_number(row - 1, col - 1)
self._add_bomb_number(row - 1, col)
self._add_bomb_number(row - 1, col + 1)
self._add_bomb_number(row, col - 1)
self._add_bomb_number(row, col + 1)
self._add_bomb_number(row + 1, col - 1)
self._add_bomb_number(row + 1, col)
self._add_bomb_number(row + 1, col + 1)
return True
def _add_bomb_number(self, row, col):
if row < 0 or row >= self.gridSize_width or col < 0 or col >= self.gridSize_height:
return
index = row * self.gridSize_width + col
if index < 0 or index >= len(self.BBoxList):
return
self.BBoxList[index].BNumber += 1
def Clear(self, row, col):
if row < 0 or row >= self.gridSize_width or col < 0 or col >= self.gridSize_height:
return
index = row * self.gridSize_width + col
if index < 0 or index >= len(self.BBoxList):
return
self.BBoxList[index].MarkNumberOrEmpty()
def ShowAll(self):
self.status_bar.toggle_mark.state = 'normal'
for i in range(0, len(self.BBoxList)):
if self.BBoxList[i].isBomb:
self.BBoxList[i].bbutton.MarkB()
else:
self.BBoxList[i].Clear()
def CheckSucceed(self):
if self.bfound > 0 and self.bfound == self.bnumber:
for i in range(0, len(self.BBoxList)):
if self.BBoxList[i].state == 0:
return False
#upgrade level
if self.mute == False:
self.sounds['upgrade'].play()
if self.custimize == False:
duration = round((clock() - self.start_clock), 2)
if self.levels_info.has_key(
self.level) and self.levels_info[self.level] > 0:
if self.levels_info[self.level] > duration:
self.levels_info[self.level] = duration
else:
self.levels_info[self.level] = duration
if self.level < Max_Level:
self.level += 1
self.store_user_data(self.level, self.levels_info)
self.Restart()
return True
else:
return False
def get_level_info(self):
if self.store.exists("UserData") == False:
self.store.put("UserData", CurrentLevel=1, Levels={})
return self.store.get("UserData")["CurrentLevel"], self.store.get(
"UserData")["Levels"]
def get_mute_info(self):
return self.config.get('Sounds', 'Mute') == '1'
def get_customize_info(self):
return self.config.get(
'Customization', 'Enable') == '1', self.config.getint(
'Customization', 'C_Height'), self.config.getint(
'Customization',
'C_Width'), self.config.getint('Customization', 'Rate')
def store_user_data(self, currentLevel, levels):
self.store.put("UserData", CurrentLevel=currentLevel, Levels=levels)
def GameOver(self):
self.status_bar.toggle_mark.disable = True
self.status_bar.button_reset.image.source = 'gameover.png'
self.gameover = True
def on_stop(self):
local_store = JsonStore('library/local_user.json')
local_store.put('local_user', local_ID=local_user.local_ID)
class KognitivoApp(App):
use_kivy_settings = False
user_data_dir = settings.DATABASE_PATH
def open_settings(self, *largs):
if not self.settings_cls:
from settings_widget import KognitivoSettings
self.settings_cls = KognitivoSettings
super(KognitivoApp, self).open_settings(*largs)
def on_stop(self):
if platform == 'linux':
self.profile.disable()
self.profile.dump_stats('kognitivo.profile')
self.profiler.print_all()
if self.billing:
self.billing.unbind()
@property
def tracker(self):
if not self._tracker:
Logger.info("Tracker: initialization")
from tracking import Tracker
self._tracker = Tracker()
return self._tracker
def _initialize_storage(self):
Logger.info("Storage: initialization")
from kivy.storage.jsonstore import JsonStore
self._storage = JsonStore("storage-%s.json" % self.name)
import settings
for key, config in settings.DEFAULT_STORAGE_CONFIG.items():
if key not in self._storage:
self._storage.put(key, **config)
records = self._storage["task_records"]
for key in settings.TASKS:
if key not in records:
records[key] = 0
self._storage.put("task_records", **records)
starts_count = self._storage['starts']['count']
self.tracker.send_event('general', 'start', value=starts_count + 1)
self._storage['starts'] = {"count": starts_count + 1}
Logger.info("Storage: started %s times" %
self._storage['starts']['count'])
@property
def storage(self):
if not self._storage:
self._initialize_storage()
return self._storage
def _initialize_gplay_services(self):
from gplay import GoogleClient
import settings
self._google_client = GoogleClient()
if not settings.PROFILE:
auto_login = self.config.get('preferences', 'google_auto_login')
if auto_login == "1":
self._google_client.connect()
@property
def google_client(self):
if not self._google_client:
Logger.info("Google: initialization")
self._initialize_gplay_services()
return self._google_client
def initialize_cprofile(self):
if platform == 'linux':
import cProfile
self.profile = cProfile.Profile()
self.profile.enable()
def __init__(self, name=None, **kwargs):
from utils import NaiveProfiler
self.profiler = NaiveProfiler()
self.initialize_cprofile()
self.profiler.fix_from("---app-init")
# lazy attributes
self._tracker = None
self._sounds = None
self.billing = None
self._storage = None
self.lang = None
self.manager = None
self._google_client = None
self.profiler.fix_from("super init")
super(KognitivoApp, self).__init__(**kwargs)
self.profiler.fix_to("super init")
self.db_path = None
self.profiler.fix_from("import-configure")
from configure import configure
self.profiler.fix_to("import-configure")
self.profiler.fix_from("configure")
configure()
self.profiler.fix_to("configure")
from settings import DEVELOPMENT_VERSION
if name is None:
KognitivoApp.name = "kognitivo-dev" if DEVELOPMENT_VERSION else "kognitivo"
else:
KognitivoApp.name = name
self.service = None
self.profiler.fix_to("---app-init")
def build_service_params(self):
params = {
"enable_notifications":
self.config.get('preferences', 'enable_notifications'),
"morning_notification_time":
self.config.get('preferences', 'morning_notification_time'),
"lunch_notification_time":
self.config.get('preferences', 'lunch_notification_time'),
"evening_notification_time":
self.config.get('preferences', 'evening_notification_time'),
"language":
self.config.get('preferences', 'language'),
}
return params
def schedule_notifications(self, force=False):
if platform == 'android':
from notifications_scheduler import Scheduler
scheduler = Scheduler([
self.config.get('preferences', 'morning_notification_time'),
self.config.get('preferences', 'lunch_notification_time'),
self.config.get('preferences', 'evening_notification_time')
])
enable_notifications = int(
self.config.get('preferences', 'enable_notifications'))
if enable_notifications == 1:
Logger.debug("Notifications: Creating schedules...")
if force:
scheduler.clean_schedules()
scheduler.create_schedule()
Logger.debug("Notifications: Finished creating schedules")
elif enable_notifications == 0:
if force:
scheduler.clean_schedules()
return
else:
Logger.info("Notifications: no notifications on %s" % platform)
def set_language(self):
if platform == 'android':
if self.config.get('preferences', 'language') == 'system':
Logger.info("Locale: Setting locale to system preference...")
from jnius import autoclass
Locale = autoclass('java.util.Locale')
try:
system_language = Locale.getDefault().getLanguage()
except Exception:
system_language = 'en'
Logger.info("Locale: System locale is %s" % system_language)
from settings import LANGUAGES
if system_language in LANGUAGES:
self.lang = system_language
self.config.set('preferences', 'language', system_language)
else:
Logger.info(
"Locale: System locale is unknown. Falling back to english..."
)
self.lang = 'en'
self.config.set('preferences', 'language', 'en')
self.config.write()
self.lang = self.config.get('preferences', 'language')
from utils import _
_.switch_lang(self.lang)
def _initialize_sounds(self):
Logger.info('App: initialize sounds')
if settings.SOUND_ENABLED and int(
self.config.get('preferences', 'sound')) == 1:
self._sounds = {}
from settings import SOUNDS
from kivy.core.audio import SoundLoader
for name, path in SOUNDS.items():
self._sounds[name] = SoundLoader.load(path)
else:
from collections import defaultdict
from kivy.core.audio import Sound
self._sounds = defaultdict(Sound)
def initialize_billing(self, callback=None, *args):
if not self.billing:
Logger.info("Billing: initialization")
self.profiler.fix_from('billing')
from billing import BillingService
self.billing = BillingService()
self.billing.bind(callback)
self.profiler.fix_to('billing')
else:
if callback:
callback()
@property
def sounds(self):
if not self._sounds:
self._initialize_sounds()
return self._sounds
def build(self):
self.profiler.fix_from('---build')
self.profiler.fix_from('set_language')
self.set_language()
self.profiler.fix_to('set_language')
self.profiler.fix_from('schedule_notifications')
self.schedule_notifications()
self.profiler.fix_to('schedule_notifications')
self.profiler.fix_from('import-root-widget')
from root_manager import RootManager
self.profiler.fix_to('import-root-widget')
self.profiler.fix_from('build-root-widget')
import settings
root = RootManager()
from managers.database import database_manager
if database_manager.total_count() > 1:
from screens.activity.activity import ActivityScreen
start_screen = ActivityScreen()
menu_state = 'open'
else:
from screens.tutorial import TutorialScreen
start_screen = TutorialScreen()
menu_state = 'closed'
root.add_widget(start_screen)
from screens.menu import KognitivoNavigator
navigator = KognitivoNavigator()
navigator.add_widget(root)
navigator.state = menu_state
from kivy.core.window import Window
Window.clearcolor = (1, 1, 1, 1)
if settings.DEVELOPMENT_VERSION and settings.INSPECT and platform == 'linux':
from kivy.modules import inspector
inspector.create_inspector(Window, root)
self.profiler.fix_to('build-root-widget')
self.manager = root
self.bind(on_start=self.post_build_init)
self.profiler.fix_to('---build')
return navigator
def post_build_init(self, *_):
self.profiler.fix_from('post-build')
from managers.facebook import facebook_manager
facebook_manager.initialize()
from kivy.core.window import Window
win = Window
win.bind(on_keyboard=self.key_handler)
self.root.attach_toggle(win)
self.profiler.fix_to('post-build')
# noinspection PyUnusedLocal
def key_handler(self, window, keycode1, *_):
if keycode1 in [27, 1001]:
if not self.close_settings():
self.manager.go_back()
return True
return False
def build_settings(self, settings):
with open("settings.json", "r") as settings_json:
from utils import _
settings.add_json_panel(_('SETTINGS'),
self.config,
data=settings_json.read())
def build_config(self, config):
from settings import KIVY_DEFAULT_CONFIG
for section, conf in KIVY_DEFAULT_CONFIG.items():
config.setdefaults(section, conf)
def on_pause(self):
from managers.facebook import facebook_manager
facebook_manager.activate()
return True
def on_resume(self):
from managers.facebook import facebook_manager
facebook_manager.deactivate()
def on_config_change(self, config, section, key, value):
self.schedule_notifications(force=True)
if section == 'preferences':
if key == 'language':
Logger.info("Settings: change locale to %s" % value)
self.lang = value
if key == 'sound':
self._initialize_sounds()
if key == 'enable_notifications':
self.tracker.send_event(
'general', 'notifications',
'disabled' if value == "0" else 'enabled')
class _2048Controller:
def __init__(self):
self.width = 4
self.height = 4
self.store = JsonStore('data.json')
self.best_score = 0
if self.store.exists('score'):
self.best_score = self.store.get('score')['best_score']
self.initGame()
def initGame(self):
self.score = 0
self.undo_left = 2
self.undo_game_array = []
self.game_array = self.generateGameArray()
#self.game_array = [[0, 0, 8, 16], [32, 64, 128, 256], [512, 1024, 2048, 4096], [8192, 16384, 32768, 65536]]
self.end_game = False
self.new_number_array = [] # list of new number is generated
self.undo_game_array = [] # ####
for i in range(2):
self.generateNumber() # generate 2 new numbers
def checkExists(self, x, y):
return self.game_array[y][x] != 0
def generateGameArray(self):
game_board = []
for y in range(self.height):
rows = []
for x in range(self.width):
rows.append(0)
game_board.append(rows)
return game_board
def generateNumber(self):
while True: # loop until the position is valid
x = random.randint(0, self.width - 1)
y = random.randint(0, self.height - 1)
if not self.checkExists(x, y):
number = 2
if random.randint(1, 100) > 80:
number = 4
self.game_array[y][x] = number
break
self.new_number_array.append((x, y))
def slideUp(self, game_board=None):
if not game_board:
game_board = self.game_array
moved = False
score = 0
animation_way = []
for x in range(self.width):
notCombineList = []
for y in range(self.height):
if game_board[y][x] == 0:
continue
for stop_y in range(y - 1, -1, -1):
if game_board[stop_y][x] != 0:
if game_board[stop_y][x] == game_board[y][x] and stop_y not in notCombineList:
game_board[stop_y][x] *= 2
game_board[y][x] = 0
moved = True
score += game_board[stop_y][x]
notCombineList.append(stop_y)
animation_way.append([(x, y), (x, stop_y)])
else:
game_board[stop_y + 1][x], game_board[y][x] = game_board[y][x], game_board[stop_y + 1][x]
if y != stop_y + 1:
animation_way.append([(x, y), (x, stop_y + 1)])
moved = True
break
if stop_y == 0 and game_board[0][x] == 0 and game_board[y][x] != game_board[0][x]:
game_board[0][x], game_board[y][x] = game_board[y][x], game_board[0][x]
moved = True
animation_way.append([(x, y), (x, stop_y)])
return [moved, score, animation_way]
def slideDown(self, game_board=None):
if not game_board:
game_board = self.game_array
moved = False
score = 0
animation_way = []
for x in range(self.width):
notCombineList = []
for y in range(self.width - 1, -1, -1):
if game_board[y][x] == 0:
continue
for stop_y in range(y + 1, self.height):
if game_board[stop_y][x] != 0:
if game_board[stop_y][x] == game_board[y][x] and stop_y not in notCombineList:
game_board[stop_y][x] *= 2
game_board[y][x] = 0
moved = True
score += game_board[stop_y][x]
notCombineList.append(stop_y)
animation_way.append([(x, y), (x, stop_y)])
else:
game_board[stop_y - 1][x], game_board[y][x] = game_board[y][x], game_board[stop_y - 1][x]
if y != stop_y - 1:
animation_way.append([(x, y), (x, stop_y - 1)])
moved = True
break
if stop_y == (self.height - 1) and game_board[self.height - 1][x] == 0 and \
game_board[y][x] != game_board[self.height - 1][x]:
game_board[self.height - 1][x], game_board[y][x] = game_board[y][x], game_board[self.height - 1][x]
moved = True
animation_way.append([(x, y), (x, stop_y)])
return [moved, score, animation_way]
def slideLeft(self, game_board=None):
if not game_board:
game_board = self.game_array
moved = False
score = 0
animation_way = []
for y in range(self.height):
notCombineList = []
for x in range(1, self.width):
if game_board[y][x] == 0:
continue
for stop_x in range(x - 1, -1, -1):
if game_board[y][stop_x] != 0:
if game_board[y][stop_x] == game_board[y][x] and stop_x not in notCombineList:
game_board[y][stop_x] *= 2
game_board[y][x] = 0
moved = True
score += game_board[y][stop_x]
notCombineList.append(stop_x)
animation_way.append([(x, y), (stop_x, y)])
else:
game_board[y][stop_x + 1], game_board[y][x] = game_board[y][x], game_board[y][stop_x + 1]
if x != stop_x + 1:
animation_way.append([(x, y), (stop_x + 1, y)])
moved = True
break
if stop_x == 0 and game_board[y][0] == 0 and game_board[y][x] != game_board[y][0]:
game_board[y][0], game_board[y][x] = game_board[y][x], game_board[y][0]
moved = True
animation_way.append([(x, y), (stop_x, y)])
return [moved, score, animation_way]
def slideRight(self, game_board=None):
if not game_board:
game_board = self.game_array
moved = False
score = 0
animation_way = []
for y in range(self.height):
notCombineList = []
for x in range(self.width - 2, -1, -1):
if game_board[y][x] == 0:
continue
for stop_x in range(x + 1, self.width):
if game_board[y][stop_x] != 0:
if game_board[y][stop_x] == game_board[y][x] and stop_x not in notCombineList:
game_board[y][stop_x] *= 2
game_board[y][x] = 0
moved = True
score += game_board[y][stop_x]
notCombineList.append(stop_x)
animation_way.append([(x, y), (stop_x, y)])
else:
game_board[y][stop_x - 1], game_board[y][x] = game_board[y][x], game_board[y][stop_x - 1]
if x != stop_x - 1:
animation_way.append([(x, y), (stop_x - 1, y)])
moved = True
break
if stop_x == (self.width - 1) and game_board[y][self.width - 1] == 0 and\
game_board[y][x] != game_board[y][self.width - 1]:
game_board[y][self.width - 1], game_board[y][x] = game_board[y][x], game_board[y][self.width - 1]
moved = True
animation_way.append([(x, y), (stop_x, y)])
return [moved, score, animation_way]
def checkForWin(self):
for y in range(len(self.game_array)):
for x in range(len(self.game_array[0])):
if self.game_array[y][x] == 2048:
return True
else:
return False
def checkForBestScore(self):
if self.score > self.best_score:
self.best_score = self.score
def saveData(self):
self.store.put('score', best_score=self.best_score)
def up(self):
tmp_game_array = copy.deepcopy(self.game_array)
tmp_score = self.score
moved, score, animation_way = self.slideUp()
self.score += score
self.checkForBestScore()
if not self.existsMove() and self.undo_left == 0:
self.end_game = True
elif moved:
self.undo_game_array.append([tmp_game_array, tmp_score])
self.generateNumber()
return animation_way
def down(self):
tmp_game_array = copy.deepcopy(self.game_array)
tmp_score = self.score
moved, score, animation_way = self.slideDown()
self.score += score
self.checkForBestScore()
if not self.existsMove() and self.undo_left == 0:
self.end_game = True
elif moved:
self.undo_game_array.append([tmp_game_array, tmp_score])
self.generateNumber()
return animation_way
def left(self):
tmp_game_array = copy.deepcopy(self.game_array)
tmp_score = self.score
moved, score, animation_way = self.slideLeft()
self.score += score
self.checkForBestScore()
if not self.existsMove() and self.undo_left == 0:
self.end_game = True
elif moved:
self.undo_game_array.append([tmp_game_array, tmp_score])
self.generateNumber()
return animation_way
def right(self):
tmp_game_array = copy.deepcopy(self.game_array)
tmp_score = self.score
moved, score, animation_way = self.slideRight()
self.score += score
self.checkForBestScore()
if not self.existsMove() and self.undo_left == 0:
self.end_game = True
elif moved:
self.undo_game_array.append([tmp_game_array, tmp_score])
self.generateNumber()
return animation_way
def existsMove(self):
exists = False
#if self.slideUp(game_array_clone)[0] or self.slideDown(game_array_clone)[0] or \
# self.slideLeft(game_array_clone)[0] or self.slideRight(game_array_clone)[0]:
# exists = True
for test in (self.slideLeft, self.slideRight, self.slideUp, self.slideDown):
game_array_clone = copy.deepcopy(self.game_array) # clone the game array to check
if test(game_array_clone)[0]:
exists = True
return exists
def undo(self):
if self.undo_left == 0 or len(self.undo_game_array) == 0: # if start game or out of undo left, not do undo
return
self.undo_left -= 1
temp_array, temp_score = self.undo_game_array.pop() # pop the undo data (array and score)
for y in range(len(temp_array)): # dont do this : self.game_array = temp.array
for x in range(len(temp_array[0])): # because it reference to new list, not a current list, it wont work
self.game_array[y][x] = temp_array[y][x]
self.score = temp_score
class RobRehabGUI( Widget ):
connection = None
currentServerAddress = None
UPDATE_INTERVAL = 0.02
setpointsUpdated = True
isCalibrating = False
isSampling = False
isOperating = False
samplingEvent = None
operationEvent = None
JOINT = 0
AXIS = 1
deviceIDs = ( [], [] )
currentDeviceIndexes = [ None for i in range( len(deviceIDs) ) ]
NULL_ID = '<Select>'
axisMeasures = [ 0.0 for var in range( DOF_VARS_NUMBER ) ]
setpoints = [ 0.0 for var in range( DOF_VARS_NUMBER ) ]
jointMeasures = [ 0.0 for var in range( DOF_VARS_NUMBER ) ]
class DataPlot:
def __init__( self, handle, values, source, offset ):
self.handle = handle
self.values = values
self.source = source
self.offset = offset
dataPlots = []
INITIAL_VALUES = [ 0.0 for value in range( 101 ) ]
def __init__( self, **kwargs ):
super( RobRehabGUI, self ).__init__( **kwargs )
self.configStorage = JsonStore( 'config.json' )
if self.configStorage.exists( 'server' ): self.ids[ 'address_input' ].text = self.configStorage.get( 'server' )[ 'address' ]
if self.configStorage.exists( 'user' ): self.ids[ 'user_name_input' ].text = self.configStorage.get( 'user' )[ 'name' ]
self.deviceSelectors = ( self.ids[ 'joint_selector' ], self.ids[ 'axis_selector' ] )
self.deviceEntries = [ DropDown() for selector in self.deviceSelectors ]
for index in range( len(self.deviceEntries) ):
def SelectEntry( instance, name, index=index ):
self.SetDevice( index, name )
self.deviceEntries[ index ].bind( on_select=SelectEntry )
self.deviceSelectors[ index ].bind( on_release=self.deviceEntries[ index ].open )
dataGraph = self.ids[ 'data_graph' ]
measure_range = self.ids[ 'measure_slider' ].range
GRAPH_PROPERTIES = { 'xlabel':'Last Samples', 'x_ticks_minor':5, 'x_ticks_major':25, 'y_ticks_major':0.25, 'y_grid_label':True, 'x_grid_label':True,
'padding':5, 'x_grid':True, 'y_grid':True, 'xmin':0, 'xmax':len(self.INITIAL_VALUES) - 1, 'ymin':measure_range[ 0 ], 'ymax':measure_range[ 1 ],
'background_color':[ 1, 1, 1, 1 ], 'tick_color':[ 0, 0, 0, 1 ], 'border_color':[ 0, 0, 0, 1 ], 'label_options':{ 'color': [ 0, 0, 0, 1 ], 'bold':True } }
axisPositionGraph = Graph( ylabel='Position', **GRAPH_PROPERTIES )
axisPositionPlot = SmoothLinePlot( color=[ 0, 0, 1, 1 ] )
axisPositionGraph.add_plot( axisPositionPlot )
self.dataPlots.append( RobRehabGUI.DataPlot( axisPositionPlot, self.INITIAL_VALUES[:], self.axisMeasures, DOF_POSITION ) )
axisVelocityPlot = SmoothLinePlot( color=[ 0, 1, 0, 1 ] )
axisPositionGraph.add_plot( axisVelocityPlot )
self.dataPlots.append( RobRehabGUI.DataPlot( axisVelocityPlot, self.INITIAL_VALUES[:], self.axisMeasures, DOF_VELOCITY ) )
refPositionPlot = SmoothLinePlot( color=[ 0, 0, 0.5, 1 ] )
axisPositionGraph.add_plot( refPositionPlot )
self.dataPlots.append( RobRehabGUI.DataPlot( refPositionPlot, self.INITIAL_VALUES[:], self.setpoints, DOF_POSITION ) )
refVelocityPlot = SmoothLinePlot( color=[ 0, 0.5, 0, 1 ] )
axisPositionGraph.add_plot( refVelocityPlot )
self.dataPlots.append( RobRehabGUI.DataPlot( refVelocityPlot, self.INITIAL_VALUES[:], self.setpoints, DOF_VELOCITY ) )
axisAccelerationPlot = SmoothLinePlot( color=[ 1, 0, 0, 1 ] )
axisPositionGraph.add_plot( axisAccelerationPlot )
self.dataPlots.append( RobRehabGUI.DataPlot( axisAccelerationPlot, self.INITIAL_VALUES[:], self.axisMeasures, DOF_ACCELERATION ) )
dataGraph.add_widget( axisPositionGraph )
dataGraph.add_widget( Label( size_hint_y=0.05 ) )
axisForceGraph = Graph( ylabel='Torque', **GRAPH_PROPERTIES )
axisForcePlot = SmoothLinePlot( color=[ 1, 0, 0, 1 ] )
axisForceGraph.add_plot( axisForcePlot )
self.dataPlots.append( RobRehabGUI.DataPlot( axisForcePlot, self.INITIAL_VALUES[:], self.axisMeasures, DOF_FORCE ) )
dataGraph.add_widget( axisForceGraph )
Clock.schedule_interval( self.NetworkUpdate, self.UPDATE_INTERVAL / 2 )
Clock.schedule_interval( self.GraphUpdate, self.UPDATE_INTERVAL * 2 )
Clock.schedule_interval( self.SliderUpdate, self.UPDATE_INTERVAL )
def ConnectClient( self, serverAddress ):
self.connection = None
self.robotID = ''
self.deviceIDs = ( [], [] )
serverType, serverHost = serverAddress.split( '://' )
print( 'acquired %s server host: %s' % ( serverType, serverHost ) )
if serverType == 'ip': self.connection = ipclient.Connection()
if self.connection is not None:
self.configStorage.put( 'server', address=serverAddress )
self.connection.Connect( serverHost )
self.robotID, self.deviceIDs = self.connection.RefreshInfo()
self.ids[ 'robot_id_display' ].text = self.robotID
def UpdateSelectorEntries( selector, entriesList, entryNames ):
entriesList.clear_widgets()
for name in entryNames:
entryButton = Button( text=name, size_hint_y=None )
entryButton.height = entryButton.font_size * 2
entryButton.bind( on_release=lambda button: entriesList.select( button.text ) )
entriesList.add_widget( entryButton )
for deviceType in range( len(self.deviceIDs) ):
UpdateSelectorEntries( self.deviceSelectors[ deviceType ], self.deviceEntries[ deviceType ], self.deviceIDs[ deviceType ] )
self.SetDevice( deviceType, self.deviceIDs[ deviceType ][ 0 ] if len(self.deviceIDs[ deviceType ]) > 0 else self.NULL_ID )
def GraphUpdate( self, dt ):
for plot in self.dataPlots:
if len(plot.values) >= len(self.INITIAL_VALUES):
plot.handle.points = [ ( sample, plot.values[ sample ] ) for sample in range( len(self.INITIAL_VALUES) ) ]
plot.values = []
plot.values.append( plot.source[ plot.offset ] )
def SliderUpdate( self, dt ):
self.ids[ 'measure_slider' ].value = self.axisMeasures[ DOF_POSITION ] #* 180 / math.pi
def NetworkUpdate( self, dt ):
currentAxisIndex = self.currentDeviceIndexes[ self.AXIS ]
currentJointIndex = self.currentDeviceIndexes[ self.JOINT ]
if self.connection is not None and currentAxisIndex is not None:
if self.setpointsUpdated:
self.connection.SendAxisSetpoints( currentAxisIndex, self.setpoints )
self.setpointsUpdated = False
self.connection.ReceiveAxisMeasures( currentAxisIndex, self.axisMeasures )
#print( 'NetworkUpdate: received axis measures: ' + str( self.axisMeasures ) )
#self.connection.ReceiveJointMeasures( currentJointIndex, self.jointMeasures )
def SetUserName( self, name ):
if self.connection is not None: self.connection.SetUser( name )
self.configStorage.put( 'user', name=name )
def SetDevice( self, type, name ):
self.deviceSelectors[ type ].text = name
deviceIDs = self.deviceIDs[ type ]
self.currentDeviceIndexes[ type ] = deviceIDs.index( name ) if ( name in deviceIDs ) else None
def SetSetpoints( self ):
if not self.isSampling:
self.setpoints[ DOF_POSITION ] = self.ids[ 'setpoint_slider' ].value #* math.pi / 180
self.setpoints[ DOF_STIFFNESS ] = self.ids[ 'stiffness_slider' ].value
self.setpoints[ DOF_DAMPING ] = self.ids[ 'damping_slider' ].value
self.setpointsUpdated = True
def _SendCommand( self, commandKey ):
self.connection.SendCommand( commandKey )
def SetEnable( self, enabled ):
offsetToggle = self.ids[ 'offset_button' ]
if enabled:
self._SendCommand( ENABLE )
offsetToggle.state = 'down'
else:
self._SendCommand( DISABLE )
offsetToggle.state = 'normal'
def SetOffset( self, enabled ):
if enabled: self._SendCommand( OFFSET )
else:
self._SendCommand( OPERATE if self.isOperating else PASSIVATE )
self.ids[ 'setpoint_slider' ].value = 0
self.SetSetpoints()
def SetCalibration( self, enabled ):
self.isCalibrating = enabled
calibrationLED = self.ids[ 'indication_led' ]
def TurnLedOn( *args ):
calibrationLED.color = [ 0, 1, 0, 1 ]
Clock.schedule_once( TurnLedOff, 5.0 )
def TurnLedOff( *args ):
calibrationLED.color = [ 1, 0, 0, 1 ]
if self.isCalibrating: Clock.schedule_once( TurnLedOn, 3.0 )
if enabled:
self._SendCommand( CALIBRATE )
TurnLedOn()
else:
self._SendCommand( OPERATE if self.isOperating else PASSIVATE )
TurnLedOff()
def SetOptimization( self, enabled ):
PHASE_CYCLES_NUMBER = 5
PHASE_CYCLE_INTERVAL = 8.0
SETPOINT_AMPLITUDE = math.pi / 4
#SETPOINT_AMPLITUDE_ANGLE = SETPOINT_AMPLITUDE * 180 / math.pi
PHASE_INTERVAL = PHASE_CYCLES_NUMBER * PHASE_CYCLE_INTERVAL
PHASES_STIFFNESS_LIST = [ 0, 30, 60, 60, 30, 0, 0, 10 ]
PHASES_DIRECTION_LIST = [ 1, 1, 1, 1, 1, 1, -1, -1 ]
PHASES_ACTIVE_LIST = [ False, False, False, True, True, True, True, True ]
TOTAL_SAMPLING_INTERVAL = len(PHASES_STIFFNESS_LIST) * PHASE_INTERVAL
self.isSampling = enabled
self.samplingTime = 0.0
setpointSlider = self.ids[ 'setpoint_slider' ]
stiffnessSlider = self.ids[ 'stiffness_slider' ]
dampingSlider = self.ids[ 'damping_slider' ]
activeLED = self.ids[ 'indication_led' ]
def UpdateSetpoint( delta ):
phaseIndex = int( self.samplingTime / PHASE_INTERVAL )
if phaseIndex >= len(PHASES_STIFFNESS_LIST):
self.ids[ 'sampling_button' ].state = 'normal'
return False
self.samplingTime += delta
setpointDirection = PHASES_DIRECTION_LIST[ phaseIndex ]
activeLED.color = [ 0, 1, 0, 1 ] if PHASES_ACTIVE_LIST[ phaseIndex ] else [ 1, 0, 0, 1 ]
setpoint = math.sin( 2 * math.pi * self.samplingTime / PHASE_CYCLE_INTERVAL )
setpointSlider.value = setpoint * SETPOINT_AMPLITUDE #SETPOINT_AMPLITUDE_ANGLE #- SETPOINT_AMPLITUDE_ANGLE
self.setpoints[ DOF_POSITION ] = setpoint * SETPOINT_AMPLITUDE * setpointDirection - SETPOINT_AMPLITUDE
targetStiffness = PHASES_STIFFNESS_LIST[ phaseIndex ]
stiffnessSlider.value = stiffnessSlider.value * 0.9 + targetStiffness * 0.1
self.setpoints[ DOF_STIFFNESS ] = stiffnessSlider.value
dampingSlider.value = 0.0
if enabled:
self._SendCommand( PREPROCESS )
self.samplingEvent = Clock.schedule_interval( UpdateSetpoint, self.UPDATE_INTERVAL * 2 )
else:
self.samplingTime = TOTAL_SAMPLING_INTERVAL
setpointSlider.value = 0.0
stiffnessSlider.value = 0.0
dampingSlider.value = 0.0
activeLED.color = [ 1, 0, 0, 1 ]
self._SendCommand( OPERATE if self.isOperating else PASSIVATE )
self.samplingEvent.cancel()
def SetOperation( self, enabled ):
PHASE_CYCLE_INTERVAL = 8.0
SETPOINT_AMPLITUDE = math.pi / 4
#SETPOINT_AMPLITUDE_ANGLE = SETPOINT_AMPLITUDE * 180 / math.pi
self.isOperating = enabled
self.operationTime = 0.0
import numpy
from scipy import signal
self.trajectory = numpy.loadtxt( 'positionknee.txt' )
self.trajectory = numpy.reshape( self.trajectory, numpy.size( self.trajectory ) )
self.trajectory = signal.resample( self.trajectory, int(len(self.trajectory) / 2) )
print( self.trajectory )
self.curveStep = 0
self.setpoints[ DOF_STIFFNESS ] = 0
#self.hasStarted = False
setpointSlider = self.ids[ 'setpoint_slider' ]
stiffnessSlider = self.ids[ 'stiffness_slider' ]
dampingSlider = self.ids[ 'damping_slider' ]
activeLED = self.ids[ 'indication_led' ]
def UpdateSetpoint( delta ):
#cyclesCount = int( self.operationTime / PHASE_CYCLE_INTERVAL )
#self.operationTime += delta
#setpoint = math.sin( 2 * math.pi * self.operationTime / PHASE_CYCLE_INTERVAL )
#if self.hasStarted:
setpoint = - float( self.trajectory[ self.curveStep % len(self.trajectory) ] )
self.curveStep += 1
setpointSlider.value = setpoint * SETPOINT_AMPLITUDE #SETPOINT_AMPLITUDE_ANGLE #- SETPOINT_AMPLITUDE_ANGLE
#elif self.setpoints[ DOF_STIFFNESS ] > 0:
# if( abs( self.setpoints[ DOF_POSITION ] - self.axisMeasures[ DOF_POSITION ] ) ) < 0.0001:
# self.hasStarted = True
#stiffnessSlider.value = self.axisMeasures[ DOF_STIFFNESS ]
#if cyclesCount < 20: self.setpoints[ DOF_STIFFNESS ] = 60
#else: self.setpoints[ DOF_STIFFNESS ] = 0
#self.setpoints[ DOF_STIFFNESS ] = 60
if enabled:
self._SendCommand( OPERATE )
activeLED.color = [ 0, 1, 0, 1 ]
self.operationEvent = Clock.schedule_interval( UpdateSetpoint, self.UPDATE_INTERVAL * 2 )
else:
setpointSlider.value = 0.0
stiffnessSlider.value = 0.0
dampingSlider.value = 0.0
activeLED.color = [ 1, 0, 0, 1 ]
self._SendCommand( PASSIVATE )
self.operationEvent.cancel()
def __init__(self,**kwargs):
super(MainScreen,self).__init__(**kwargs)
js=JsonStore(filename="UmutRss.json")
js.put("current_rss",title=u"Haber Türk",url={"gundem": "http://www.haberturk.com/rss/manset.xml",
"siyaset": "http://www.haberturk.com/rss/siyaset.xml",
"dunya": "http://www.haberturk.com/rss/dunya.xml",
"yasam": "http://www.haberturk.com/rss/yasam.xml",
"sanat": "http://www.haberturk.com/rss/kultur-sanat.xml",
"ekonomi": "http://www.haberturk.com/rss/ekonomi.xml",
"spor": "http://www.haberturk.com/rss/spor.xml"})
js.put("Sabah",title="Sabah",url={"gundem": "http://www.sabah.com.tr/rss/gundem.xml",
"saglik": "http://www.sabah.com.tr/rss/saglik.xml",
"dunya": "http://www.sabah.com.tr/rss/dunya.xml",
"sanat": "http://www.sabah.com.tr/rss/kultur_sanat.xml",
"ekonomi": "http://www.sabah.com.tr/rss/ekonomi.xml",
"spor": "http://www.sabah.com.tr/rss/spor.xml",
"yasam": "http://www.sabah.com.tr/rss/yasam.xml",
"oyun": "http://www.sabah.com.tr/rss/oyun.xml",
"sondakika": "http://www.sabah.com.tr/rss/sondakika.xml",
"teknoloji": "http://www.sabah.com.tr/rss/teknoloji.xml"})
js.put("BBC",title="BBC",url={"gundem": "http://feeds.bbci.co.uk/turkce/rss.xml"
})
js.put("Cmh",title="Cumhuriyet",url={"egitim":"http://www.cumhuriyet.com.tr/rss/18.xml",
"yasam":"http://www.cumhuriyet.com.tr/rss/10.xml",
"sanat":"http://www.cumhuriyet.com.tr/rss/7.xml",
"dunya":"http://www.cumhuriyet.com.tr/rss/5.xml",
"sondakika":"http://www.cumhuriyet.com.tr/rss/son_dakika.xml",
"gundem":"http://www.cumhuriyet.com.tr/rss/1.xml"
})
js.put("AHaber",title="A Haber",url={"gundem": "http://www.ahaber.com.tr/rss/gundem.xml",
"ekonomi": "http://www.ahaber.com.tr/rss/ekonomi.xml",
"spor": "http://www.ahaber.com.tr/rss/spor.xml",
"saglik": "http://www.ahaber.com.tr/rss/saglik.xml",
"dunya": "http://www.ahaber.com.tr/rss/dunya.xml",
"manset": "http://www.ahaber.com.tr/rss/haberler.xml",
"yasam": "http://www.ahaber.com.tr/rss/yasam.xml",
"anasayfa": "http://www.ahaber.com.tr/rss/anasayfa.xml",
"ozelhaber": "http://www.ahaber.com.tr/rss/ozel-haberler.xml",
"teknoloji": "http://www.ahaber.com.tr/rss/teknoloji.xml"
})
titles=JsonStore(filename="titles.json")
titles.put("titles",all={"gundem":u"Gündem","egitim":u"Eğitim","dunya":u"Dünya","sanat":u"Sanat",
"ekonomi":u"Ekonomi","spor":u"Spor","saglik":u"Sağlık","yasam":u"Yaşam",
"oyun":u"Oyun","sondakika":u"Son Dakika","teknoloji":u"Teknoloji",
"basinozeti":u"Basın Özeti","ozelhaber":u"Özel Haber","anasayfa":"Anasayfa",
"turkiye":u"Türkiye","siyaset":"Siyaset","manset":u"Manşet"})
def __init__(self, **kwargs):
super(MainBox, self).__init__(**kwargs)
data_json = JsonStore(os.path.join("data/rogue_trader_data.json"))
for key in data_json.keys():
self.data[key] = data_json[key]
global data
data = self.data
user_dir = pathlib.Path(App.get_running_app().user_data_dir)
# Load config
global config
config = JsonStore(user_dir / "config.json")
if not config.exists("config"):
config.put("config", **default_config)
dos_algorithm = DoSAlgorithm(config.get("config")["dos_algorithm"])
if dos_algorithm == DoSAlgorithm.ROGUE_TRADER:
self.ids["dos_rt"].state = "down"
elif dos_algorithm == DoSAlgorithm.MIXED:
self.ids["dos_mixed"].state = "down"
else:
self.ids["dos_dh2"].state = "down"
self.ids["dos_rt"].algorithm = DoSAlgorithm.ROGUE_TRADER
self.ids["dos_mixed"].algorithm = DoSAlgorithm.MIXED
self.ids["dos_dh2"].algorithm = DoSAlgorithm.DARK_HERESY_2
# load character
global CHARACTER
CHARACTER = JsonStore(user_dir / "character.json")
if not CHARACTER.exists("character"):
CHARACTER.put("character", **default_character)
# CHARACTER.put("character", **default_character)
self.character = CHARACTER.get("character")
start_layout = StartLayout(self.data)
self.ids["all_talents"].add_widget(start_layout)
# set characteristics
for key in characteristics.keys():
self.ids[key].set_text(self.character["characteristics"][key])
self.ids[key].key = self.data["characteristics"][key]["name"]
self.ids[key].value = self.character["characteristics"][key][0]
self.ids[key].bind(
on_press=lambda inst: TestPopup(inst.key, inst.value))
# add skills to the charakter screen
self.ids["skill_box"].height = 0
bg = True
self.skill_box_dict = {}
for key, skill in self.data["skills"].items():
if skill["skill_group"]:
skill_group_box_dict = {}
if key in self.character["skills"]:
for skill_group, status in self.character["skills"][
key].items():
box = SkillBox(
skill,
self.data["characteristics"][
skill["characteristic"]]["short"],
self.character["characteristics"][
skill["characteristic"]][0],
status,
bg,
name="{} ({})".format(skill["name"], skill_group),
)
bg = not bg
self.ids["skill_box"].height += box.height
self.ids["skill_box"].add_widget(box)
skill_group_box_dict[skill_group] = box
else:
box = SkillBox(
skill,
self.data["characteristics"][skill["characteristic"]]
["short"],
self.character["characteristics"][
skill["characteristic"]][0],
None,
bg,
name="{} ()".format(skill["name"]),
)
bg = not bg
self.ids["skill_box"].height += box.height
self.ids["skill_box"].add_widget(box)
self.skill_box_dict[key] = skill_group_box_dict
else:
box = SkillBox(
skill,
self.data["characteristics"][
skill["characteristic"]]["short"],
self.character["characteristics"][skill["characteristic"]]
[0],
self.character["skills"][key]
if key in self.character["skills"].keys() else None,
bg,
)
bg = not bg
self.ids["skill_box"].height += box.height
self.ids["skill_box"].add_widget(box)
self.skill_box_dict[key] = box
# add talents to the character screen
for talent in self.character["talents"]:
if type(talent) == list:
key = talent[0]
groups = talent[1:]
else:
key = talent
groups = []
button = TalentButton(
key=key,
text=f'{self.data["talents"][key]["name"]}'
if len(groups) == 0 else
f'{self.data["talents"][key]["name"]} ({", ".join(groups)})',
)
button.bind(on_press=lambda b: TalentInfoPopup(self.data["talents"]
[b.key]))
self.ids["talents_box"].add_widget(button)
self.ids["talents_box"].height += button.height
# handle talented
if key == "talented":
for skill in groups:
for skill_key, skill_data in self.data["skills"].items():
if skill_data["name"] == skill:
break
self.skill_box_dict[skill_key].skill_value += 10
self.skill_box_dict[skill_key].modifier_list.append({
"name":
f"Talented ({skill})",
"bonus":
10,
"type":
"talent",
"on":
True,
})
self.ids["talents_box"].children.sort()
# add implants to the character srceen
self.ids["implants_box"].height = 0
for implant in self.character["implants"]:
modifier_list = []
for modifier in self.data["implants"][implant["key"]]["bonus"]:
modifier_list.append(
[self.skill_box_dict[modifier[0]], modifier[1]])
implant_box = ImplantBox(
self.data["implants"][implant["key"]],
implant["on"],
implant["quality"],
modifier_list,
)
self.ids["implants_box"].add_widget(implant_box)
self.ids["implants_box"].height += implant_box.height
# add weapons to the battle screen
for weapon in self.character["weapons"]:
weapon_box = WeaponBox(
weapon,
self.character["characteristics"]["ws"][0],
self.character["characteristics"]["bs"][0],
self.character["characteristics"]["s"][0],
self.skill_box_dict["dodge"].skill_value,
)
self.ids["weapon_box"].add_widget(weapon_box)
self.ids["weapon_box"].height += weapon_box.height
# set wounds
self.ids["wounds_max"].text = str(
self.character["status"]["wounds"]["max"])
self.ids["wounds_current"].text = str(
self.character["status"]["wounds"]["current"])
self.ids["wounds_critical"].text = str(
self.character["status"]["wounds"]["critical"])
self.ids["button_take_damage"].bind(
on_press=lambda _: TakeDamagePopup(self))
self.ids["button_heal"].bind(on_press=lambda _: HealDamagePopup(self))
# set fatigue
self.ids["fatigue_current"].text = str(
self.character["status"]["fatigue"])
self.ids["fatigue_max"].text = str(
self.character["characteristics"]["t"][0] // 10)
# set fate points
self.ids["fate_max"].text = str(
self.character["status"]["fate"]["max"])
self.ids["fate_current"].text = str(
self.character["status"]["fate"]["current"])
class AssetsEditorPopupAdd():
# 0.5.0 TEST EVENTS
def on_mouse_pos(self, window, pos):
for item in self.leftBox.children:
print("MOUSE EVENTS >>>>>>>>" + item.__class__.__name__)
if item.__class__.__name__ == "Button":
if item.collide_point(*pos):
print('POINT :::>>:' + item.text)
item.background_color =(self.engineConfig.getThemeTextColor())
item.color = (self.engineConfig.getThemeCustomColor('engineBtnsBackground'))
else:
item.color = (self.engineConfig.getThemeTextColor())
item.background_color = (self.engineConfig.getThemeCustomColor('engineBtnsBackground'))
# do something here
def __init__(self, **kwargs):
self.engineConfig = kwargs.get("engineConfig")
self.engineRoot = kwargs.get("engineRoot")
self.currentAsset = kwargs.get("currentAsset")
Window.bind(mouse_pos=self.on_mouse_pos)
self.operationStatus = True
self.isFreeRigthBox = True
self.box = BoxLayout(orientation="horizontal")
self.leftBox = BoxLayout(orientation="vertical")
self.imageResourceGUIBox = BoxLayout(orientation="vertical")
print("DEBUG", platform)
if platform == 'linux':
drives = psutil.disk_partitions()
if platform == 'win':
drives = ['%s:' % d for d in string.ascii_uppercase if os.path.exists('%s:' % d)]
for item in drives:
print(item)
self.drivesChooseBox = BoxLayout(size_hint=(1, None), height=40,)
for item in drives:
if platform == 'win':
self.drivesChooseBox.add_widget(Button(
text=item + '/',
on_press=partial(self.setFileBrowserPath),
color=(self.engineConfig.getThemeTextColor()),
size_hint=(1, None), height=65,
background_normal= '',
background_color=(self.engineConfig.getThemeCustomColor('engineBtnsBackground'))
))
print(" drive: ", item)
elif platform == 'linux' or True:
self.drivesChooseBox.add_widget(Button(
text=item.mountpoint ,
on_press=partial(self.setFileBrowserPath),
color=(self.engineConfig.getThemeTextColor()),
size_hint=(1, None), height=65,
background_normal= '',
background_color=(self.engineConfig.getThemeCustomColor('engineBtnsBackground'))
))
print(" drive: ", item)
self.imageResourceGUIBox.add_widget(self.drivesChooseBox)
if platform == 'win':
self.fileBrowser = FileChooserListView(# select_string='Select', dirselect: True
# path='projects/' + self.engineConfig.currentProjectName + '/data/',
filters=['*.png', '*.jpg'],
path= drives[0] + '/',
size_hint=(1,3),
dirselect= True,
on_submit=self.load_from_filechooser
)
elif platform == 'linux' or True:
self.fileBrowser = FileChooserListView(# select_string='Select', dirselect: True
# path='projects/' + self.engineConfig.currentProjectName + '/data/',
filters=['*.png', '*.jpg'],
path= drives[0].mountpoint + '/',
size_hint=(1,3),
dirselect= True,
on_submit=self.load_from_filechooser
)
self.imageResourceGUIBox.add_widget(self.fileBrowser)
self.fileBrowser.bind(selection=partial(self.load_from_filechooser))
self.imageResourceGUIBox.add_widget(Label(text='Application assets pack path' , size_hint=(1, None), height=40 ), )
self.selectedPathLabel = Label(text='...')
self.imageResourceGUIBox.add_widget(self.selectedPathLabel)
self.assetName = TextInput( text='MyAssets1', foreground_color=(0,1,1, 1),
size_hint=(1, None), height=40)
with self.assetName.canvas.before:
Color(self.engineConfig.getThemeCustomColor('background')[0],
self.engineConfig.getThemeCustomColor('background')[1],
self.engineConfig.getThemeCustomColor('background')[2],
self.engineConfig.getThemeCustomColor('background')[3])
self.assetName.rect = Rectangle(size=self.assetName.size,
pos=self.assetName.pos)
def update_rect(instance, value):
instance.rect.pos = instance.pos
instance.rect.size = instance.size
self.imageResourceGUIBox.add_widget(self.assetName)
# self.assetName.bind(pos=update_rect, size=update_rect)
self.assetName.foreground_color = (1,1,1,1)
self.commandBtn = Button(text='Add selected image',
color=(self.engineConfig.getThemeTextColor()),
size_hint=(1, None), height=60,
background_normal= '',
background_color=(self.engineConfig.getThemeCustomColor('engineBtnsBackground')) )
#on_press=partial(self.createImageAssets))
self.commandBtn.bind(on_press=partial(self.createImageAssets))
self.imageResourceGUIBox.add_widget(self.commandBtn)
self.leftBox.add_widget(Label(text='Application assets package operation.'))
self.cancelBtn = Button(text='Cancel',
color=(self.engineConfig.getThemeTextColor()),
size_hint=(1, None), height=70,
background_normal= '',
background_color=(self.engineConfig.getThemeCustomColor('engineBtnsBackground')))
self.previewBox = BoxLayout(size_hint=(1,None), height=250)
self.previewPicture = AsyncImage(source="", size_hint=(1, 1))
self.previewBox.add_widget(Label(text='Preview Box'))
self.previewBox.add_widget(self.previewPicture)
self.imageResourceGUIBox.add_widget(self.previewBox)
self.box.add_widget(self.leftBox)
# Add button - ImageResource
self.addImageRes = Button(markup=True, text='[b]Add Image Resource[b]',
color=(self.engineConfig.getThemeTextColor()),
size_hint=(1, None), height=60,
background_normal= '',
background_color=(self.engineConfig.getThemeCustomColor('engineBtnsBackground')))
self.leftBox.add_widget(self.addImageRes)
# Others - Fonts
self.addFontRes = Button(markup=True, text='[b]Add Font Resource[b]',
color=(self.engineConfig.getThemeTextColor()),
size_hint=(1, None), height=60,
background_normal= '',
background_color=(self.engineConfig.getThemeCustomColor('engineBtnsBackground')))
# Add JSON Data - JSONResource
self.addJSONResBtn = Button(markup=True, text='[b]Add JSON DATA Resource[b]',
color=(self.engineConfig.getThemeTextColor()),
size_hint=(1, None), height=60,
background_normal= '',
background_color=(self.engineConfig.getThemeCustomColor('engineBtnsBackground')))
self.leftBox.add_widget(self.addJSONResBtn)
self.leftBox.add_widget(self.addFontRes)
self.leftBox.add_widget(self.cancelBtn)
self.previewFont = Label(
size_hint=(1, 1),
markup=True,
font_size=50,
text="Font [b]Bold[/b]!")
_local = 'CrossK ' + self.engineConfig.getVersion() + ' Assets Editor'
self.popup = Popup(title=_local , content=self.box, auto_dismiss=False)
self.cancelBtn.bind(on_press=self.popup.dismiss)
self.addImageRes.bind(on_press=lambda a:self.showImageAssetGUI())
self.addFontRes.bind(on_press=lambda a:self.showFontAssetGUI())
self.addJSONResBtn.bind(on_press=lambda a:self.showJSONAssetGUI())
self.popup.open()
def showImageAssetGUI(self):
# no prepare it si initial
if self.isFreeRigthBox == True:
self.box.add_widget(self.imageResourceGUIBox)
self.isFreeRigthBox = False
self.previewPicture.size_hint = (1,1)
self.previewFont.size_hint = (0,0)
def showFontAssetGUI(self):
if self.isFreeRigthBox == True:
# prepare
self.fileBrowser.filters = ['*.ttf']
self.commandBtn.text = 'Add Font Family'
self.commandBtn.unbind(on_press=partial(self.createImageAssets)),
self.commandBtn.bind(on_press=partial(self.createFontAssets))
self.previewPicture.size_hint = (0,0)
self.previewFont.size_hint = (1,1)
self.box.add_widget(self.imageResourceGUIBox)
self.isFreeRigthBox = False
def showJSONAssetGUI(self):
if self.isFreeRigthBox == True:
# prepare
self.fileBrowser.filters = ['*.json']
self.commandBtn.text = 'Add JSON Object Data'
self.commandBtn.unbind(on_press=partial(self.createImageAssets)),
self.commandBtn.bind(on_press=partial(self.createJSONAssets))
self.previewPicture.size_hint = (0,0)
# self.previewFont.size_hint = (0,0)
self.box.add_widget(self.imageResourceGUIBox)
self.isFreeRigthBox = False
def resolvePathFolder(self):
ASSETPACK_PATH = os.path.abspath(
os.path.join(os.path.dirname(__file__), '../../projects/' + self.engineConfig.currentProjectName + "/data/")
)
if not os.path.exists(ASSETPACK_PATH):
print("MAKE_ASSETPACK_PATH")
os.mkdir(ASSETPACK_PATH)
else:
print('ASSETPACK_EXIST')
def resolveAssetPathFolder(self, typeOfAsset):
CURRENT_ASSETPACK_PATH = os.path.abspath(
os.path.join(os.path.dirname(__file__), '../../projects/' + self.engineConfig.currentProjectName + "/data/" + self.assetName.text)
)
collectExt = ''
local = self.fileBrowser.selection[0][::-1]
for item in local:
if item == '.':
print("Create Image Resource -> Break EXT = ", collectExt)
break
else:
collectExt += item;
collectExt = collectExt[::-1]
# print(collectExt)
if not os.path.exists(CURRENT_ASSETPACK_PATH):
print("MAKE_ASSETS_PACK_DIR")
os.mkdir(CURRENT_ASSETPACK_PATH)
else:
if self.currentAsset == None:
print("SOMETHIND WRONG - ASSETS ALREADY EXIST")
getMessageBoxYesNo(
message="Asset reference path with this name already exist. Please use some different name.",
msgType="OK")
#callback=wtf)
return None
self.operationStatus = False
print("Assets pack write meta data...")
copyfile(self.fileBrowser.selection[0], CURRENT_ASSETPACK_PATH + '/' + str(self.assetName.text) + '.' + collectExt)
self.assetsStore = JsonStore(self.engineConfig.currentProjectAssetPath+ '/assets.json')
localElements = self.assetsStore.get('assetsComponentArray')['elements']
asset = {
'name': self.assetName.text,
'type': typeOfAsset,
'ext': collectExt,
'source': CURRENT_ASSETPACK_PATH + '/' + str(self.assetName.text) + '.' + collectExt,
'path': 'projects/' + self.engineConfig.currentProjectName + "/data/"+ str(self.assetName.text) + "/" + str(self.assetName.text) + "." + collectExt,
'version': self.engineConfig.getVersion()
}
# Check it if exist
localCheckDouble = False
for checkItem in localElements:
if checkItem['name'] == asset['name']:
localCheckDouble = True
getMessageBoxYesNo(
message="Asset reference with this name already exist. Please use some different name.",
msgType="OK")
#callback=wtf)
if localCheckDouble == False:
localElements.append(asset)
self.assetsStore.put('assetsComponentArray', elements=localElements)
self.engineRoot.resourceGUIContainer.selfUpdate()
def createImageAssets(self, instance):
if self.operationStatus == True:
self.resolvePathFolder()
self.resolveAssetPathFolder('ImageResource')
self.popup.dismiss()
def createFontAssets(self, instance):
if self.operationStatus == True:
self.resolvePathFolder()
self.resolveAssetPathFolder('FontResource')
self.popup.dismiss()
def createJSONAssets(self, instance):
if self.operationStatus == True:
self.resolvePathFolder()
self.resolveAssetPathFolder('JSONResource')
self.popup.dismiss()
def load_from_filechooser(self, instance , selectedData):
print("Selected data: ", selectedData)
#self.load(self.fileBrowser.path, self.fileBrowser.selection)
localHandler = self.fileBrowser.selection[0].replace(self.fileBrowser.path, '')
self.selectedPathLabel.text = localHandler
# check type assets
print(">>", self.fileBrowser.filters)
if self.fileBrowser.filters[0] == '*.png' or self.fileBrowser.filters[0] == '*.jpg':
self.previewPicture.source=self.fileBrowser.selection[0]
# JSON Nidza
if '.json' in localHandler:
self.imageResourceGUIBox.remove_widget(self.previewBox)
testJSONNidzaLOader = JsonN(
assetsPath=self.fileBrowser.selection[0],
currentContainer=self.imageResourceGUIBox,
engineRoot=self.engineRoot
)
def setFileBrowserPath(self, instance):
self.fileBrowser.path = instance.text
print( 'setFileBrowserPath: ' , instance.text)
def save_data(self):
Logger.info("Data: Saving data...")
store = JsonStore(os.path.join(data_dir, 'data.json'))
for k in self.data.keys():
store.put(k, val=str(self.data[k]))
Logger.info("Data: Saving data done")
from kivy.core.window import Window
from random import randint
from kivy.uix.image import Image
from math import radians, cos, sin, sqrt
from kivy.uix.screenmanager import ScreenManager, Screen, NoTransition
from kivy.core.audio import SoundLoader
from kivy.storage.jsonstore import JsonStore
from os.path import join
data_dir = App().user_data_dir
store = JsonStore(join(data_dir, 'store.json'))
try:
store.get('highscore')
except KeyError:
store.put('highscore', best=0)
circle_path = 'images/icon.png'
white_circle_path = 'images/white_circle.png'
grey_circle_path = 'images/grey_circle.png'
big_grey_circle_path = 'images/big_grey_circle.png'
big_orange_circle_path = 'images/orange_big_circle.png'
music_sound = SoundLoader.load('sounds/360music.wav')
win_sound = SoundLoader.load('sounds/360winsound.wav')
lose_sound = SoundLoader.load('sounds/360losesound.wav')
click_sound = SoundLoader.load('sounds/360clicksound.wav')
highscore_sound = SoundLoader.load('sounds/360highscoresound.wav')
size = Window.size
window_x = (size[0])
class AssetsEditorPopup():
def __init__(self, **kwargs):
self.engineConfig = kwargs.get("engineConfig")
self.currentAsset = kwargs.get("currentAsset")
self.engineRoot = kwargs.get("engineRoot")
self.assetsStore = JsonStore('projects/' +
self.engineConfig.currentProjectName +
'/data/assets.json')
self.isFreeRigthBox = True
self.box = BoxLayout(orientation="horizontal")
self.leftBox = BoxLayout(orientation="vertical")
self.imageResourceGUIBox = BoxLayout(orientation="vertical")
if platform == 'linux':
drives = psutil.disk_partitions()
if platform == 'win':
drives = [
'%s:' % d for d in string.ascii_uppercase
if os.path.exists('%s:' % d)
]
self.drivesChooseBox = BoxLayout(
size_hint=(1, None),
height=40,
)
for item in drives:
if platform == 'win':
self.drivesChooseBox.add_widget(
Button(text=item + '/',
on_press=partial(self.setFileBrowserPath),
color=(self.engineConfig.getThemeTextColor()),
size_hint=(1, None),
height=65,
background_normal='',
background_color=(
self.engineConfig.getThemeCustomColor(
'engineBtnsBackground'))))
print(" drive: ", item)
elif platform == 'linux' or True:
self.drivesChooseBox.add_widget(
Button(text=item.mountpoint,
on_press=partial(self.setFileBrowserPath),
color=(self.engineConfig.getThemeTextColor()),
size_hint=(1, None),
height=65,
background_normal='',
background_color=(
self.engineConfig.getThemeCustomColor(
'engineBtnsBackground'))))
print(" drive: ", item)
self.imageResourceGUIBox.add_widget(self.drivesChooseBox)
if platform == 'win':
self.fileBrowser = FileChooserListView(
# Can be added default optimal engine config initial dir
# select_string='Select', dirselect: True
# path='projects/' + self.engineConfig.currentProjectName + '/data/',
filters=['*.png', '*.jpg'],
path=drives[1] + '/',
size_hint=(1, 3),
dirselect=False,
on_submit=self.load_from_filechooser)
elif platform == 'linux' or True:
self.fileBrowser = FileChooserListView( # select_string='Select', dirselect: True
# path='projects/' + self.engineConfig.currentProjectName + '/data/',
filters=['*.png', '*.jpg'],
path=drives[0].mountpoint + '/',
size_hint=(1, 3),
dirselect=True,
on_submit=self.load_from_filechooser)
self.imageResourceGUIBox.add_widget(self.fileBrowser)
self.fileBrowser.bind(selection=partial(self.load_from_filechooser))
self.imageResourceGUIBox.add_widget(
Label(text='Application assets full source path:',
size_hint=(1, None),
height=40,
font_size=15))
self.selectedPathLabel = Label(text='...',
size_hint=(1, None),
height=40,
font_size=9,
underline=True)
self.imageResourceGUIBox.add_widget(self.selectedPathLabel)
self.imageResourceGUIBox.add_widget(
Label(text='Application assets relative path:',
size_hint=(1, None),
height=40))
self.selectedRelativePathLabel = Button(
text='...',
size_hint=(1, None),
height=40,
font_size=12,
underline=True,
on_press=partial(self.copyToClipBoard),
color=(self.engineConfig.getThemeTextColor()),
background_normal='',
background_color=(
self.engineConfig.getThemeCustomColor('engineBtnsBackground')),
)
self.imageResourceGUIBox.add_widget(self.selectedRelativePathLabel)
self.assetNameGUINAme = Label(
text='Name of assets reference (READ ONLY)',
color=(self.engineConfig.getThemeTextColor()),
font_size=15,
size_hint=(1, None),
height=40)
self.imageResourceGUIBox.add_widget(self.assetNameGUINAme)
self.assetName = Label(text='MyAssets1',
color=(self.engineConfig.getThemeTextColor()),
font_size=12,
underline=True,
size_hint=(1, None),
height=40)
with self.assetName.canvas.before:
Color(
self.engineConfig.getThemeCustomColor('warn')[0],
self.engineConfig.getThemeCustomColor('warn')[1],
self.engineConfig.getThemeCustomColor('warn')[2],
self.engineConfig.getThemeCustomColor('warn')[3])
self.assetName.rect = Rectangle(size=self.assetName.size,
pos=self.assetName.pos)
def update_rect(instance, value):
instance.rect.pos = instance.pos
instance.rect.size = instance.size
self.imageResourceGUIBox.add_widget(self.assetName)
self.imageResourceGUIBox.add_widget(
Button(text='Update selected image asset',
color=(self.engineConfig.getThemeTextColor()),
size_hint=(1, None),
height=65,
font_size=15,
bold=True,
background_normal='',
background_color=(self.engineConfig.getThemeCustomColor(
'engineBtnsBackground')),
on_press=partial(self.createImageAssets)))
self.leftBox.add_widget(
Label(text='CrossK assets editor',
size_hint=(1, None),
height=220,
font_size=25,
bold=True))
assetListHeder = BoxLayout(size_hint=(1, None), height=80)
titleText = Label(text='Assets List.',
color=(self.engineConfig.getThemeTextColor()),
font_size=25,
bold=True,
padding_x=0,
padding_y=0,
center=(1, 1),
size_hint_x=1,
size_hint_y=1,
height=60)
with titleText.canvas.before:
Color(self.engineConfig.getThemeBgSceneBtnColor())
titleText.rect = Rectangle(size=titleText.size, pos=titleText.pos)
def update_rect(instance, value):
instance.rect.pos = instance.pos
instance.rect.size = instance.size
self.leftBox.add_widget(titleText)
titleText.bind(pos=update_rect, size=update_rect)
headerSelector = Label(
text='Selector',
color=(self.engineConfig.getThemeTextColor()),
font_size=15, # add
bold=True, # add
padding_x=0, # test
padding_y=0, # test
center=(1, 1), # test
font_blended=True,
size_hint_x=1,
size_hint_y=None,
height=40)
with headerSelector.canvas.before:
Color(
self.engineConfig.getThemeTextColorByComp('background')['r'],
self.engineConfig.getThemeTextColorByComp('background')['g'],
self.engineConfig.getThemeTextColorByComp('background')['b'])
headerSelector.rect = Rectangle(size=headerSelector.size,
pos=headerSelector.pos)
def update_rect(instance, value):
instance.rect.pos = instance.pos
instance.rect.size = instance.size
headerSelector.bind(pos=update_rect, size=update_rect)
assetListHeder.add_widget(headerSelector)
headerPreview = Label(
text='Preview',
color=(self.engineConfig.getThemeTextColor()),
font_size=15, # add
bold=True, # add
padding_x=0, # test
padding_y=0, # test
center=(1, 1), # test
font_blended=True,
size_hint_x=0.3,
size_hint_y=None,
height=40)
with headerPreview.canvas.before:
Color(
self.engineConfig.getThemeTextColorByComp('background')['r'],
self.engineConfig.getThemeTextColorByComp('background')['g'],
self.engineConfig.getThemeTextColorByComp('background')['b'])
headerPreview.rect = Rectangle(size=headerPreview.size,
pos=headerPreview.pos)
def update_rect(instance, value):
instance.rect.pos = instance.pos
instance.rect.size = instance.size
headerPreview.bind(pos=update_rect, size=update_rect)
assetListHeder.add_widget(headerPreview)
headerDelete = Label(
text='Note: No undo operation',
color=(self.engineConfig.getThemeTextColor()),
font_size=15, # add
bold=True, # add
padding_x=0, # test
padding_y=0, # test
center=(1, 1), # test
font_blended=True,
size_hint_x=1,
size_hint_y=None,
height=40)
with headerDelete.canvas.before:
Color(
self.engineConfig.getThemeTextColorByComp('background')['r'],
self.engineConfig.getThemeTextColorByComp('background')['g'],
self.engineConfig.getThemeTextColorByComp('background')['b'])
headerDelete.rect = Rectangle(size=headerDelete.size,
pos=headerDelete.pos)
def update_rect(instance, value):
instance.rect.pos = instance.pos
instance.rect.size = instance.size
headerDelete.bind(pos=update_rect, size=update_rect)
assetListHeder.add_widget(headerDelete)
self.leftBox.add_widget(assetListHeder)
loadAssetElements = self.assetsStore.get(
'assetsComponentArray')['elements']
self.sceneScroller = ScrollView(size_hint=(1, None),
size=(500, 650),
pos_hint={
'center_x': 0.5,
'top': 0
})
self.selfUpdate(loadAssetElements)
self.leftBox.add_widget(self.sceneScroller)
fillSpace = Label(text='---', size_hint=(1, 0.3))
with fillSpace.canvas.before:
Color(
self.engineConfig.getThemeTextColorByComp('background')['r'],
self.engineConfig.getThemeTextColorByComp('background')['g'],
self.engineConfig.getThemeTextColorByComp('background')['b'])
fillSpace.rect = Rectangle(size=fillSpace.size, pos=fillSpace.pos)
def update_rect(instance, value):
instance.rect.pos = instance.pos
instance.rect.size = instance.size
self.leftBox.add_widget(fillSpace)
fillSpace.bind(pos=update_rect, size=update_rect)
self.cancelBtn = Button(
text='Cancel',
color=(self.engineConfig.getThemeTextColor()),
size_hint=(1, None),
height=70,
background_normal='',
background_color=(
self.engineConfig.getThemeCustomColor('engineBtnsBackground')))
self.previewBox = BoxLayout(size_hint=(1, None), height=250)
self.previewPicture = AsyncImage(source="", size_hint=(1, 1))
self.previewFont = Label(size_hint=(1, 1),
markup=True,
font_size=50,
text="Font [b]Bold[/b]!")
self.previewBox.add_widget(
Label(text='Preview Box', bold=True, font_size=15))
self.previewBox.add_widget(self.previewPicture)
self.previewBox.add_widget(self.previewFont)
self.imageResourceGUIBox.add_widget(self.previewBox)
self.box.add_widget(self.leftBox)
self.leftBox.add_widget(self.cancelBtn)
_local = 'CrossK ' + self.engineConfig.getVersion() + ' Assets Editor'
self.popup = Popup(title=_local, content=self.box, auto_dismiss=False)
self.cancelBtn.bind(on_press=self.popup.dismiss)
self.popup.open()
def showAssetGUI(self, item, instance):
if (platform == 'win'):
transformPath = item['path'].replace('/', '\\')
else:
transformPath = item['path']
if item['type'] == 'ImageResource':
if self.isFreeRigthBox == True:
self.box.add_widget(self.imageResourceGUIBox)
self.isFreeRigthBox = False
self.assetName.text = item['name']
self.selectedPathLabel.text = item['source']
self.selectedRelativePathLabel.text = item['path']
self.previewPicture.source = transformPath
self.previewFont.size_hint = (0, 0)
self.previewPicture.size_hint = (1, 1)
elif item['type'] == 'FontResource':
if self.isFreeRigthBox == True:
self.box.add_widget(self.imageResourceGUIBox)
self.isFreeRigthBox = False
self.assetName.text = item['name']
self.selectedPathLabel.text = item['source']
self.selectedRelativePathLabel.text = item['path']
self.previewPicture.size_hint = (0, 0)
self.previewPicture.size = (5, 5)
self.previewFont.text = "Font [b]Bold[/b]!"
self.previewFont.size_hint = (1, 1)
self.previewFont.font_name = item['path']
elif item['type'] == 'JSONResource':
self.fileBrowser.filters = ["*.json"]
if self.isFreeRigthBox == True:
self.box.add_widget(self.imageResourceGUIBox)
self.isFreeRigthBox = False
self.assetName.text = item['name']
self.selectedPathLabel.text = item['source']
self.selectedRelativePathLabel.text = item['path']
self.previewPicture.size_hint = (0, 0)
self.previewPicture.size = (5, 5)
self.previewFont.size_hint = (1, 1)
# nikola 0.5.0
localStore = JsonStore(item['path'])
print(">>>>>>>>>>>>>>>" + localStore.get('name'))
self.previewFont.font_size = "10"
self.previewFont.text = "JSON root keys: \n "
for key in localStore._data.keys():
self.previewFont.text += " " + key + "\n"
# localStore.get('name')
print(key)
def copyToClipBoard(self, instance):
Clipboard.copy(self.selectedRelativePathLabel.text)
print('Copied to clipboard.')
def resolvePathFolder(self):
ASSETPACK_PATH = os.path.abspath(
os.path.join(
os.path.dirname(__file__), '../../projects/' +
self.engineConfig.currentProjectName + "/data/"))
if not os.path.exists(ASSETPACK_PATH):
print("MAKE_ASSETPACK_PATH")
os.mkdir(ASSETPACK_PATH)
else:
print('ASSETPACK_EXIST')
def resolveAssetPathFolder(self):
if len(self.fileBrowser.selection) == 0:
def wtf():
print('wtf')
getMessageBoxYesNo(
message="Nothing to update. Please select new source file.",
msgType="OK",
callback=wtf)
return 0
CURRENT_ASSETPACK_PATH = os.path.abspath(
os.path.join(
os.path.dirname(__file__),
'../../projects/' + self.engineConfig.currentProjectName +
"/data/" + self.assetName.text))
collectExt = ''
print("Create Image Resource ->")
local = self.fileBrowser.selection[0][::-1]
for item in local:
if item == '.':
print("Create Image Resource -> Break EXT = ", collectExt)
break
else:
collectExt += item
collectExt = collectExt[::-1]
print(collectExt)
if not os.path.exists(CURRENT_ASSETPACK_PATH):
print("MAKE ASSETS PACK DIR")
os.mkdir(CURRENT_ASSETPACK_PATH)
else:
if self.currentAsset == None:
print('current asset need load')
print("SOMETHIND WRONG - ASSETS ALREADY EXIST")
return None
print("Assets pack write meta data.")
copyfile(
self.fileBrowser.selection[0], CURRENT_ASSETPACK_PATH + '/' +
str(self.assetName.text) + '.' + collectExt)
self.assetsStore = JsonStore(
self.engineConfig.currentProjectAssetPath + '/assets.json')
localElements = self.assetsStore.get(
'assetsComponentArray')['elements']
########################
# Must be detail show
if self.currentAsset != None:
print('# Must be detail show')
########################
asset = {
'name':
self.assetName.text,
'type':
'ImageResource',
'ext':
collectExt,
'source':
CURRENT_ASSETPACK_PATH + '/' + str(self.assetName.text) + '.' +
collectExt,
'path':
'projects/' + self.engineConfig.currentProjectName + "/data/" +
str(self.assetName.text) + "/" + str(self.assetName.text) + "." +
collectExt,
'version':
self.engineConfig.getVersion()
}
localCheckIsExist = False
for _index, item in enumerate(localElements):
if item['name'] == asset['name']:
localCheckIsExist = True
localElements[_index] = asset
def catchErr1():
print("catchErr1")
if localCheckIsExist == True:
self.assetsStore.put('assetsComponentArray',
elements=localElements)
# resourceGUIContainer
self.popup.dismiss()
else:
getMessageBoxYesNo(
message='Something wrong with updating asset name => ' +
asset['name'],
msgType='OK',
callback=catchErr1)
def createImageAssets(self, instance):
print("Creating first assets ... ")
# resolvePathFolder
self.resolvePathFolder()
self.resolveAssetPathFolder()
def deleteAsset(self, item, instance):
self.assetsStore = JsonStore('projects/' +
self.engineConfig.currentProjectName +
'/data/assets.json')
currElements = self.assetsStore.get('assetsComponentArray')['elements']
isDeleted = False
for index, itemA in enumerate(currElements):
if itemA['name'] == item['name']:
currElements.pop(index)
isDeleted = True
self.assetsStore.put('assetsComponentArray',
elements=currElements)
break
if isDeleted == True:
self.engineRoot.resourceGUIContainer.selfUpdate()
self.selfUpdate(currElements)
rmtree('projects/' + self.engineConfig.currentProjectName +
'/data/' + item['name'])
else:
getMessageBoxYesNo(
message="Something wrong with delete operation.",
msgType="OK",
callback=wtf)
def load_from_filechooser(self, instance, selectedData):
# Selector
if str(self.fileBrowser.selection[0]).find('.png') != -1 or str(
self.fileBrowser.selection[0]).find('.jpg') != -1:
print("Found!")
else:
print("Not found!")
return None
self.selectedPathLabel.text = self.fileBrowser.selection[0]
self.previewPicture.source = self.fileBrowser.selection[0]
def setFileBrowserPath(self, instance):
self.fileBrowser.path = instance.text
print('Selected:', instance.text)
def selfUpdate(self, loadAssetElements):
alllocalBox = BoxLayout(size_hint=(1, None),
height=len(loadAssetElements) * 90,
orientation='vertical')
for _index, item in enumerate(loadAssetElements):
localBox = BoxLayout(size_hint=(1, None),
height=90,
orientation='horizontal')
currentColor = (self.engineConfig.getThemeBgSceneBtnColor())
if item['type'] == 'ImageResource':
currentColor = (self.engineConfig.getThemeBgSceneBoxColor())
localBox.add_widget(
Button(markup=True,
halign="left",
valign="middle",
padding_x=10,
font_size=15,
text='[b]' + item['name'] + '[/b] [u][i]' +
item['type'] + '[/i][/u]',
color=self.engineConfig.getThemeTextColor(),
background_normal='',
background_color=currentColor,
on_press=partial(self.showAssetGUI, item),
size_hint=(1, None),
height=90))
if item['type'] == 'ImageResource':
localPrevListBox = AsyncImage(source=item['path'],
size_hint=(0.4, None),
height=90)
with localPrevListBox.canvas.before:
Color(
self.engineConfig.getThemeCustomColor('background')[0],
self.engineConfig.getThemeCustomColor('background')[1],
self.engineConfig.getThemeCustomColor('background')[2],
self.engineConfig.getThemeCustomColor('background')[3])
localPrevListBox.rect = Rectangle(
size=localPrevListBox.size, pos=localPrevListBox.pos)
def update_rect(instance, value):
instance.rect.pos = instance.pos
instance.rect.size = instance.size
localPrevListBox.bind(pos=update_rect, size=update_rect)
localBox.add_widget(localPrevListBox)
elif item['type'] == 'FontResource':
localBox.add_widget(
Label(font_name=item['path'],
size_hint=(0.4, None),
height=90,
text='Font'))
elif item['type'] == 'JSONResource':
localBox.add_widget(
Label(size_hint=(0.4, None), height=90, text='JSON DATA'))
localBox.add_widget(
Button(
markup=True,
halign="left",
valign="middle",
padding_x=10,
font_size=15,
text='[b]Delete[/b]',
color=(self.engineConfig.getThemeCustomColor("alert")),
background_normal='',
background_color=(
self.engineConfig.getThemeCustomColor('background')),
on_press=partial(self.deleteAsset, item),
size_hint=(1, None),
height=90))
print('ADDED ', item)
alllocalBox.add_widget(localBox)
self.sceneScroller.clear_widgets()
self.sceneScroller.add_widget(alllocalBox)
class MyScreenManager(ScreenManager):
#ultimo = ""
directorio = ''
abierto = ""
cargado = False
modificando = False # alta o modificando
reg = 0
claves_buscando = False # para saber quien listó las claves
dic_items = {} # {item: 'indice registro'}
lista = []
lista_claves = []
listando_claves = False
lista_claves_cargadas = False
claves_seleccionadas = []
eligiendo = False
clave_nueva = False
clave_renombrar = ""
#pulsacion = False
jstore = ""
registros = [] # las lineas del fichero
items = []
memos = []
claves = [] # lista de claves de cada registro [[cla1,cla2],[],...]
#indice = []
clave = [] # claves existentes
num_lineas = StringProperty()
#jstore = JsonStore("pim_store.json")
#i_item = ObjectProperty()
i_buscar_item = ObjectProperty()
b_buscar_claves = ObjectProperty()
#lis_panta = ObjectProperty()
titulo_lista = StringProperty()
titulo_fichero = StringProperty()
panta = StringProperty()
smBotonDeLista = BotonDeLista
smBotonDeVocales = BotonDeVocales
mayusculas = uppercase
def __init__(self, **kwargs):
super(MyScreenManager, self).__init__(**kwargs)
self.current = 'sc_menu_principal'
if platform == 'android': android.hide_keyboard()
self.jstore = JsonStore("pim_store.json")
try:
ultimo = self.jstore.get("pim")['ultimo']
self.directorio = self.jstore.get("pim")['directorio']
except:
return
if not self.abrir_archivo(ultimo, incorporar=False, aviso=False):
self.selec_archivo('Elegir archivo')
log('año')
log(u'año')
def abrir_archivo(self, fich, incorporar, aviso=True):
try:
F = open(self.directorio + fich + FICH)
except:
if aviso: self.aviso('No puedo abrir ' + fich)
return False
if not incorporar: del self.registros[:]
num_lineas = 0
try:
r = F.readline()
while r:
if len(r) > 2:
self.registros.append(r[:-1].decode('utf-8'))
#self.registros.append(r[:-1])
num_lineas += 1
r = F.readline()
except:
self.aviso('No puedo leer ' + fich + ': ' + str(sys.exc_info()[0]))
return False
if not incorporar:
self.abierto = fich
self.titulo_fichero = fich
self.num_lineas = str(num_lineas) if num_lineas else '0'
else:
self.num_lineas = str(int(self.num_lineas) + num_lineas)
self.cargado = False
return True
def selec_archivo(self, opcion):
#self.lista = [f[:-8] for f in listdir(getcwd()) if f[-8:]=='-PIM.csv']
self.lista = [f[:-8] for f in listdir(self.directorio) if f[-8:]=='-PIM.csv']
self.lista.sort()
self.ids.lis_panta.adapter = ListAdapter(data=[], cls=BotonDeLista, args_converter=self.args_converter, selection_mode='single')
self.listando_claves = False
self.rellena("ficheros")
self.titulo_lista = opcion
self.ids.b_lista_izq.text = 'Menu'
self.ids.b_lista_cen.text = ''
self.ids.b_lista_der.text = ''
self.ids.b_lista_over.text = 'Cancelar'
self.current = 'sc_lista'
def alta(self):
if not self.cargado: self.carga_listas()
self.ids.i_item_alta.text = ""
self.ids.i_memo_alta.text = ""
self.ids.i_claves_alta.text = ""
self.modificando = False
self.ids.i_item_alta.focus = True
self.current = 'sc_alta'
#def alta_clave(self, popup, cla):
#if not cla: return
#self.aviso(cla)
#self.clave.append(cla)
#self.clave.sort()
#self.ids.i_claves_alta.text += ','+cla
#popup.dismiss()
#self.elige_claves('registro')
def aviso(self, txt):
the_content = Label(text = txt)
the_content.color = (1,1,1,1)
popup = Popup(title='PIM',
content=the_content, size_hint_y=.25, title_align='center')
#content = the_content, size_hint=(None, None), size=(350, 150))
popup.open()
def confirmacion(self, txt="", tema=""):
def elim_1_reg(self):
popup.dismiss()
mapp.root.eliminar_registros(confirmado=True, modo='uno')
def elim_n_reg(self):
popup.dismiss()
mapp.root.eliminar_registros(confirmado=True, modo='varios')
def borr_fich(self):
popup.dismiss()
mapp.root.borrar_fich(confirmado=True, nombre=tema)
def expor_exis(self):
popup.dismiss()
mapp.root.exportar_existente()
def expor_nue(self):
popup.dismiss()
mapp.root.exportar_nuevo()
def cancelar(self):
popup.dismiss()
cuerpo = Confirmacion(txt)
cuerpo.color = (1,0,0,1)
if tema == 'exportar':
cuerpo.ids.b_aceptar.text = 'Añadir a existente'
cuerpo.ids.b_cancelar.text = 'Archivo nuevo'
cuerpo.ids.b_cancelar.bind(on_release=expor_nue)
else:
cuerpo.ids.b_aceptar.text = 'Aceptar'
cuerpo.ids.b_cancelar.text = 'Cancelar'
cuerpo.ids.b_cancelar.bind(on_release=cancelar)
popup = Popup(title='CONFIRMACION',
content=cuerpo, size_hint_y=.25, title_align='center',
title_color=[1,0,0,1], auto_dismiss=False)
if tema == 'elim_un_reg':
cuerpo.ids.b_aceptar.bind(on_release=elim_1_reg)
if tema == 'elim_n_regs':
cuerpo.ids.b_aceptar.bind(on_release=elim_n_reg)
if tema == 'exportar':
cuerpo.ids.b_aceptar.bind(on_release=expor_exis)
if tema.startswith('fichero-'):
cuerpo.ids.b_aceptar.bind(on_release=borr_fich)
popup.open()
def dialogo(self, txt='', tema=''):
def alta_clave(self):
nueva = the_content.ids.i_dialog.text.strip()
if not nueva: return
mapp.root.clave.append(nueva)
mapp.root.clave.sort()
mapp.root.lista_claves.append(ClaveItem(text=nueva, is_selected=True))
mapp.root.claves_seleccionadas.append(nueva)
if mapp.root.ids.i_claves_alta.text:
mapp.root.ids.i_claves_alta.text += ',' + nueva
else:
mapp.root.ids.i_claves_alta.text = nueva
popup.dismiss()
mapp.root.clave_nueva = True
mapp.root.elige_claves('registro')
def nuevo_fichero(self):
popup.dismiss()
mapp.root.fichero_nuevo(the_content.ids.i_dialog.text.strip())
def exportar_fichero(self):
popup.dismiss()
mapp.root.exportar_nuevo(the_content.ids.i_dialog.text.strip())
def renombre_clave(self):
popup.dismiss()
mapp.root.clave_nuevo_nombre(the_content.ids.i_dialog.text.strip())
the_content = Dialogo(txt)
the_content.color = (1,1,1,1)
popup = Popup(title=txt,
content=the_content, size_hint_y=.25, title_align='center', auto_dismiss=False)
the_content.ids.b_cancelar.bind(on_release=popup.dismiss)
if tema == 'clave':
#~ the_content.ids.b_aceptar.bind(on_release=self.alta_clave(popup, the_content.ids.i_dialog.text))
the_content.ids.b_aceptar.bind(on_release=alta_clave)
elif tema == 'fichero_nuevo':
the_content.ids.b_aceptar.bind(on_release=nuevo_fichero)
elif tema == 'renombrar_clave':
the_content.ids.b_aceptar.bind(on_release=renombre_clave)
elif tema == 'fichero_exportar':
the_content.ids.b_aceptar.bind(on_release=exportar_fichero)
popup.open()
def borrar_fich(self, confirmado, nombre):
if not confirmado:
self.confirmacion(u'¿Borrar el archivo ' + nombre + '?', 'fichero-'+nombre)
return
nombre = nombre[8:]
try:
remove(self.directorio + nombre + FICH)
self.current = 'sc_menu_principal'
self.aviso('Archivo borrado')
except:
self.aviso('Error al borrar archivo')
def boton_lista_izq(self, texto):
if self.titulo_lista == 'Claves':
self.eligiendo = False
if texto == 'Cancelar':
self.current = 'sc_alta'
return
self.current = 'sc_menu_principal'
#if texto == 'Menu': self.current = 'sc_menu_principal'
def boton_lista_cen(self, texto):
if self.titulo_lista.startswith('Registros encontrados'):
#self.exportar()
self.confirmacion('Opciones de exportación', 'exportar')
elif self.titulo_lista == 'Claves':
self.eligiendo = False
if texto == 'Nueva':
self.dialogo('Introduzca nueva clave', 'clave')
else:
self.current = 'sc_buscar'
def boton_lista_der(self, texto):
#~ self.ids.lis_panta._trigger_reset_populate()
if self.titulo_lista.startswith('Registros encontrados'):
self.current = 'sc_buscar'
elif self.titulo_lista == 'Claves':
self.eligiendo = False
#~ cla_selec = [c.text for c in self.ids.lis_panta.adapter.data if c.is_selected]
self.claves_seleccionadas.sort()
if self.claves_buscando:
self.ids.b_buscar_claves.text = ",".join(self.claves_seleccionadas)
self.current = 'sc_buscar'
else:
self.ids.i_claves_alta.text = ",".join(self.claves_seleccionadas)
self.current = 'sc_alta'
def boton_lista_over(self, texto):
if texto == 'Eliminar':
self.eliminar_registros(confirmado=False, modo='varios')
elif texto == 'Cancelar':
self.current = 'sc_menu_principal'
def busca(self):
del self.lista[:]
#self.dic_items = {}
self.dic_items.clear()
cad = self.i_buscar_cadena.text.lower()
if self.ids.sw_ignora.active:
cad = self.traduce(cad)
if self.ids.cb_y.active:
for i in range(len(self.items)):
if self.cadena_en_texto_ignora(i,cad) and self.clave_en_claves(i):
self.dic_items[self.repe(self.items[i])] = i
else:
for i in range(len(self.items)):
if self.cadena_en_texto_ignora(i,cad) or self.clave_en_claves(i):
self.dic_items[self.repe(self.items[i])] = i
else:
if self.ids.cb_y.active:
for i in range(len(self.items)):
if self.cadena_en_texto(i,cad) and self.clave_en_claves(i):
self.dic_items[self.repe(self.items[i])] = i
else:
for i in range(len(self.items)):
if self.cadena_en_texto(i,cad) or self.clave_en_claves(i):
self.dic_items[self.repe(self.items[i])] = i
self.lista = sorted(self.dic_items.keys(), reverse = True)
#self.lista.sort()
self.ids.lis_panta.adapter = ListAdapter(data=[], cls=BotonDeLista, args_converter=self.args_converter, selection_mode='single')
self.titulo_lista = 'Registros encontrados: ' + str(len(self.lista))
self.ids.b_lista_izq.text = 'Menu'
self.ids.b_lista_cen.text = 'Exportar'
self.ids.b_lista_der.text = 'Buscar'
self.ids.b_lista_over.text = 'Eliminar'
self.listando_claves = False
self.rellena("items")
self.current = 'sc_lista'
def cadena_en_texto(self, i, cad):
if cad:
if self.ids.sw_busca.active:
if not (self.items[i].lower().count(cad) or self.memos[i].lower().count(cad)):
return False
else:
if not self.items[i].lower().count(cad):
return False
return True
def cadena_en_texto_ignora(self, i, cad):
if cad:
if self.ids.sw_busca.active:
if not (self.traduce(self.items[i].lower()).count(cad) or self.traduce(self.memos[i].lower()).count(cad)):
return False
else:
if not self.traduce(self.items[i].lower()).count(cad):
return False
return True
def clave_en_claves(self, i):
#if self.b_buscar_claves.text != '<claves>':
if self.b_buscar_claves.text != '':
b_claves = self.b_buscar_claves.text.split(',')
Y_claves = True
if Y_claves:
for c in b_claves:
if c not in self.claves[i]: return False
return True
else:
for c in b_claves:
if c in self.claves[i]: return True
return False
return True
def repe(self, item):
while item in self.dic_items:
item += ';'
return item
def clave_nuevo_nombre(self, nuevo_nombre=""):
if not nuevo_nombre:
self.dialogo('Nuevo nombre para '+self.clave_renombrar, 'renombrar_clave')
return
for i in range(len(self.registros)):
campos = self.registros[i].split(';')
for j in range(2,len(campos)):
if campos[j] == self.clave_renombrar:
campos[j] = nuevo_nombre
self.registros[i] = ';'.join(campos)
break
for j in range(len(self.claves[i])):
if self.claves[i][j] == self.clave_renombrar:
self.claves[i][j] = nuevo_nombre
break
self.clave.append(nuevo_nombre)
self.clave.sort()
self.lista_claves_cargadas = False
self.grabar(modo='renom')
def carga_listas(self):
del self.items[:]
del self.memos[:]
del self.claves[:]
del self.clave[:]
for r in self.registros:
campos = r.split(';')
self.items.append(campos[0])
self.memos.append(campos[1])
self.claves.append(campos[2:])
for c in campos[2:]:
if c not in self.clave: self.clave.append(c)
self.clave.sort()
self.lista_claves_cargadas = False
self.cargado = True
def elige_claves(self, origen='', cuales='todas'):
if self.eligiendo: return
self.ids.lis_c_panta.adapter.selection_mode = 'multiple'
if origen == 'buscar':
self.ids.b_lista_c_izq.text = 'Menú'
self.ids.b_lista_c_cen.text = 'Cancelar'
else:
self.ids.b_lista_c_izq.text = 'Cancelar'
self.ids.b_lista_c_cen.text = 'Nueva'
self.ids.b_lista_c_der.text = 'Aceptar'
if not self.listando_claves:
self.listando_claves = True
self.titulo_lista = 'Claves'
if not self.lista_claves_cargadas:
del self.lista_claves[:]
for c in self.clave: self.lista_claves.append(ClaveItem(text=c))
self.lista_claves_cargadas = True
self.marca_claves(origen)
self.rellena_claves(cuales)
#self.titulo_lista = 'Claves'
self.eligiendo = True
self.current = 'sc_lista_claves'
if platform == 'android': android.hide_keyboard()
def chequeos(self):
reg = self.ids.i_item_alta.text + \
self.ids.i_memo_alta.text + \
self.ids.i_claves_alta.text
if reg == "":
self.aviso('Registro vacío')
return False
if reg.count(';'):
self.aviso('No se puede usar ;')
return False
return True
def eliminar_registros(self, confirmado=False, modo=''):
if not confirmado:
if modo == 'uno':
self.confirmacion('¿Eliminar el registro?', 'elim_un_reg')
else:
self.confirmacion('¿Eliminar ' + str(len(self.dic_items)) + ' registros?', 'elim_n_regs')
return
if modo == 'uno':
a_eliminar = [self.dic_items[self.ids.i_item.text]]
else:
a_eliminar = self.dic_items.values()
a_eliminar.sort(reverse = True)
for i in a_eliminar:
self.registros.pop(i)
self.items.pop(i)
self.memos.pop(i)
self.claves.pop(i)
if self.graba_lista(self.abierto+TEMP, self.registros):
rename(self.directorio+self.abierto+TEMP, self.directorio+self.abierto+FICH)
self.num_lineas = str(int(self.num_lineas) - len(a_eliminar))
self.aviso('Registro(s) eliminado(s)')
else:
self.abrir_archivo(self.abierto, incorporar=False)
self.current = 'sc_menu_principal'
def existe_fichero(self, nombre):
if nombre+FICH in listdir(self.directorio):
self.aviso('Ya existe ese fichero')
return True
return False
# def exportar(self):
# self.confirmacion('Opciones de exportación', 'exportar')
def exportar_existente(self, nombre=''):
if not nombre:
self.selec_archivo('Archivo al que añadir')
return
try:
F = open(self.directorio+nombre+FICH, 'a')
except:
self.aviso('No puedo abrir fichero')
return
regis = [self.registros[i] for i in self.dic_items.values()]
try:
for r in regis: F.write(r.encode('utf-8') + '\n')
except:
self.aviso('No puedo escribir en fichero')
return
finally:
F.close()
self.current = 'sc_menu_principal'
self.aviso('Registros añadidos')
def exportar_nuevo(self, nombre=''):
if not nombre:
self.dialogo('Nombre del fichero', 'fichero_exportar')
return
if self.existe_fichero(nombre): return
regis = [self.registros[i] for i in self.dic_items.values()]
# try:
# F = open(self.directorio + nombre + FICH, 'w')
# except:
# self.aviso('No puedo crear fichero')
# return
# try:
# for r in regis: F.write(r.encode('utf-8') + '\n')
# except:
# self.aviso('No puedo escribir fichero')
# return
# F.close()
if self.graba_lista(nombre+FICH, regis):
self.aviso('Exportados ' + str(len(regis)) + ' registros')
def graba_lista(self, nombre, lista):
try:
F = open(self.directorio + nombre, 'w')
except:
self.aviso('No puedo crear fichero')
return False
try:
for r in lista: F.write(r.encode('utf-8') + '\n')
except:
self.aviso('No puedo escribir fichero')
remove(self.directorio + nombre)
return False
F.close()
return True
def fichero_nuevo(self, nombre=''):
if not nombre:
self.dialogo('Nombre del nuevo fichero', 'fichero_nuevo')
return
if self.existe_fichero(nombre): return
try:
open(self.directorio + nombre + FICH, 'w').close()
except:
self.aviso('No puedo crear fichero')
return
if self.abrir_archivo(nombre, incorporar=False):
self.jstore.put("pim", ultimo=nombre, directorio=self.directorio)
self.num_lineas = '0'
self.current = 'sc_menu_principal'
def grabar(self, modo=""):
if modo=='modif' and not self.modificando:
self.aviso('No está modificando')
return
if modo!='renom' and not self.chequeos(): return
try: F = open(self.directorio + self.abierto + TEMP, 'w')
except:
self.aviso('No puedo crear fichero')
return
if modo != 'renom':
reg = self.ids.i_item_alta.text.strip() + ';' + \
self.ids.i_memo_alta.text.rstrip().replace('\n',' ^ ') + ';' + \
self.ids.i_claves_alta.text.replace(',',';')
if modo == 'nuevo':
self.registros.append(reg)
self.items.append(self.ids.i_item_alta.text)
self.memos.append(self.ids.i_memo_alta.text.replace('\n',' ^ '))
self.claves.append(self.ids.i_claves_alta.text.split(','))
elif modo == 'modif':
self.registros[self.reg] = reg
self.items[self.reg] = self.ids.i_item_alta.text
self.memos[self.reg] = self.ids.i_memo_alta.text.replace('\n',' ^ ')
self.claves[self.reg] = self.ids.i_claves_alta.text.split(',')
try:
for r in self.registros: F.write(r.encode('utf-8') + '\n')
except UnicodeEncodeError:
try: remove(self.directorio + self.abierto+TEMP)
except: pass
self.aviso('Hay caracteres inválidos')
return
except:
#self.aviso('No puedo escribir fichero')
try: remove(self.directorio + self.abierto+TEMP)
except: pass
self.aviso(str(sys.exc_info()[0]))
return
F.close()
rename(self.directorio + self.abierto+TEMP, self.directorio + self.abierto+FICH)
if modo == 'nuevo': self.num_lineas = str(int(self.num_lineas) + 1)
self.current = 'sc_menu_principal'
if modo == 'renom': self.aviso('Clave renombrada')
def importar(self, nombre):
if self.abrir_archivo(nombre, incorporar=True):
if self.graba_lista(self.abierto+TEMP, self.registros):
rename(self.directorio+self.abierto+TEMP, self.directorio+self.abierto+FICH)
self.aviso('Registros importados')
else:
self.abrir_archivo(self.abierto, incorporar=False)
self.current = 'sc_menu_principal'
def limpia_i_buscar_cadena(self):
self.i_buscar_cadena.text = ""
def limpia_b_buscar_claves(self):
if self.b_buscar_claves.text != "":
self.b_buscar_claves.text = ""
for c in self.lista_claves: c.deselect()
self.listando_claves = False
def limpia_busqueda(self):
self.limpia_i_buscar_cadena()
self.limpia_b_buscar_claves()
def lista_elegido(self, boton, texto):
if self.titulo_lista.startswith('Registros encontrados'):
self.reg = self.dic_items[texto]
self.ids.i_item.text = self.items[self.reg]
self.ids.i_memo.text = self.memos[self.reg].replace(' ^ ','\n')
self.ids.i_claves.text = ','.join(self.claves[self.reg])
self.ids.i_item.readonly = True
self.ids.i_memo.readonly = True
self.ids.i_claves.readonly = True
self.current = 'sc_registro'
elif self.titulo_lista == 'Claves':
#self.claves_seleccionadas.append('kkk'); return
#~ cla_selec = [c.text for c in self.ids.lis_panta.adapter.data if c.is_selected]
if texto in self.claves_seleccionadas:
self.claves_seleccionadas.remove(texto)
for c in self.ids.lis_c_panta.adapter.data:
if c.text == texto: c.is_selected = False
else:
self.claves_seleccionadas.append(texto)
for c in self.ids.lis_c_panta.adapter.data:
if c.text == texto: c.is_selected = True
#~ cla_selec = [c.text for c in self.ids.lis_panta.adapter.data if c.is_selected]
elif self.titulo_lista == 'Elegir archivo':
if self.abrir_archivo(texto, incorporar=False):
# self.jstore.put("pim", directorio='/mnt/sdcard/PIM/', ultimo=texto)
self.jstore.put("pim", directorio=self.directorio, ultimo=texto)
self.current = 'sc_menu_principal'
elif self.titulo_lista == 'Archivo a importar':
self.importar(texto)
elif self.titulo_lista == 'Archivo a borrar':
self.borrar_fich(confirmado=False, nombre=texto)
elif self.titulo_lista == 'Clave a renombrar':
self.clave_renombrar = texto
self.clave_nuevo_nombre("")
elif self.titulo_lista == 'Archivo al que añadir':
self.exportar_existente(nombre=texto)
def marca_claves(self, origen):
if origen == 'buscar':
self.claves_buscando = True
if self.ids.b_buscar_claves.text: self.claves_seleccionadas = self.ids.b_buscar_claves.text.split(',')
else: self.claves_seleccionadas = []
else:
self.claves_buscando = False
if not self.clave_nueva:
if self.ids.i_claves_alta.text: self.claves_seleccionadas = self.ids.i_claves_alta.text.split(',')
else: self.claves_seleccionadas = []
else:
self.clave_nueva = False
for cl in self.lista_claves:
cl.is_selected = True if cl.text in self.claves_seleccionadas else False
def limpia_claves_vacias(self):
for i in range(len(self.registros)):
if self.registros[i].count(';') > 2:
self.registros[i] = self.registros[i].rstrip('; ')
while self.registros[i].count(';') < 2:
self.registros[i] += ';'
if self.graba_lista(self.abierto+TEMP, self.registros):
rename(self.directorio+self.abierto+TEMP, self.directorio+self.abierto+FICH)
self.current = 'sc_menu_principal'
self.aviso('Claves limpiadas')
self.cargado = False
def modificar(self):
self.ids.i_item_alta.text = self.ids.i_item.text
self.ids.i_memo_alta.text = self.ids.i_memo.text
self.ids.i_claves_alta.text = self.ids.i_claves.text
self.modificando = True
self.current = 'sc_alta'
def orden_archivo(self, orden):
self.registros.sort(reverse=(orden=='des'), key=lambda s: s.lower())
if self.graba_lista(self.abierto+TEMP, self.registros):
rename(self.directorio+self.abierto+TEMP, self.directorio+self.abierto+FICH)
self.current = 'sc_menu_principal'
self.aviso('Archivo ordenado')
#self.cargado = False
def orden_lista(self, orden):
self.ids.lis_panta.adapter.data.sort()
if orden == 'des': self.ids.lis_panta.adapter.data.reverse()
def panta_buscar(self):
if self.abierto:
if not self.cargado: self.carga_listas()
self.ids.titulo_sc_buscar.text = 'Buscando en ' + self.titulo_fichero
self.current = 'sc_buscar'
self.ids.i_buscar_cadena.focus = True
def rellena(self, tipo=""):
#~ self.lis_panta.item_strings = ['wefrewr', 'klsjf lkj f']
#~ self.lis_panta.adapter.data.clear()
#self.titulo_lista = 'Ficheros disponibles'
del self.ids.lis_panta.adapter.data[:]
if tipo == "ficheros":
#~ self.ids.lis_panta.adapter.data = self.lista
self.ids.lis_panta.adapter.cls = BotonDeLista
else:
self.ids.lis_panta.adapter.cls = LabelDeLista
self.ids.lis_panta.adapter.data.extend(self.lista)
self.ids.lis_panta._trigger_reset_populate()
def rellena_claves(self, cuales):
del self.ids.lis_c_panta.adapter.data[:]
if cuales == 'todas':
self.ids.lis_c_panta.adapter.data.extend(self.lista_claves)
elif cuales == 'marcadas':
self.ids.lis_c_panta.adapter.data.extend(c for c in self.lista_claves if c.text in self.claves_seleccionadas)
else:
letra = cuales.lower()
self.ids.lis_c_panta.adapter.data.extend(c for c in self.lista_claves if c.text.lower()>=letra)
self.ids.lis_c_panta._trigger_reset_populate()
def args_converter(self, index, data_item):
#~ texto = data_item
#~ return {'texto': texto}
return {'text': data_item}
def args_converter_claves(self, index, data_item):
#~ texto = data_item.text
#~ return {'texto': texto}
return {'text': data_item.text}
def renombrar_clave(self):
if not self.cargado: self.carga_listas()
self.clave_renombrar = ""
#self.ids.lis_c_panta.adapter = ListAdapter(data=[], cls=BotonDeLista, args_converter=self.args_converter_claves)
self.ids.lis_c_panta.adapter.selection_mode = 'single'
self.titulo_lista = 'Clave a renombrar'
self.ids.b_lista_c_izq.text = 'Menu'
self.ids.b_lista_c_cen.text = ''
self.ids.b_lista_c_der.text = ''
self.ids.b_lista_c_over.text = 'Cancelar'
if not self.lista_claves_cargadas:
del self.lista_claves[:]
for c in self.clave: self.lista_claves.append(ClaveItem(text=c))
self.lista_claves_cargadas = True
self.rellena_claves('todas')
self.current = 'sc_lista_claves'
def traduce(self, s):
s = s.encode('utf-8')
s = s.replace('á','a').replace('é','e').replace('í','i')\
.replace('ó','o').replace('ú','u').replace('ñ','n')\
.replace('ç','c')
return s.decode('utf-8')
from secp256k1 import PrivateKey, PublicKey
import os
demo_user_names = ('Alice', 'Bob', 'Charlie', 'Mark', 'King', 'Wu', 'Paige')
Builder.load_file('main.kv') # load *.kv file
default_path = './demo_users.json'
message_path = './messages.json'
block_height = 0
message_hash = set()
contact_map = {}
# read block info
try:
init_store = JsonStore(message_path)
if not init_store.exists('block'): # initialize block info
init_store.put('block', height=0)
else:
block_height = init_store.get('block')['height']
for i in range(0, block_height):
msg_hash = init_store[str(i)]['hash']
message_hash.add(msg_hash)
# print(message_hash)
except Exception as e:
print(str(e))
class DemoUserSelScreen(Screen):
"""select demo user screen"""
pass
class Controller(EventDispatcher):
"""
Controls the playing of audio and coordinates the updating of the playlist
and screen displays
"""
volume = NumericProperty(1.0)
advance = True
# This flag indicates whether to advance to the next track
# once the currently playing one had ended
sm = None # THe ScreenManager
pos = 0
def __init__(self, **kwargs):
""" Initialize the screens and the screen manager """
self._store = JsonStore(join(self._get_settings_folder(),
"zenplayer.json"))
self.playlist = PlayList(self._store)
self.sm = ScreenManager()
self.playing = PlayingScreen(self, name="main")
self.sm.add_widget(self.playing)
self.sm.current = "main"
if platform not in ['ios', 'android']:
self.kb_listener = ZenKeyboardListener(self.on_key_down,
self.playing)
Sound.add_state_callback(self.playing.on_sound_state)
Sound.add_state_callback(self._on_sound_state)
super(Controller, self).__init__(**kwargs)
if self._store.exists('state'):
state = self._store.get("state")
if "volume" in state.keys():
self.volume = state["volume"]
@staticmethod
def _get_settings_folder():
""" Return the folder when the setting file is stored. """
path = expanduser("~/.zencode")
if not exists(path):
mkdir(path)
return path
def _on_sound_state(self, state):
""" The sound state has changed. If the track played to the end,
move to the next track."""
if state == "finished" and self.advance:
self.play_next()
def get_current_art(self):
return self.playlist.get_current_art()
def get_current_info(self):
return self.playlist.get_current_info()
def get_current_file(self):
return self.playlist.get_current_file()
@staticmethod
def get_pos_length():
return Sound.get_pos_length()
def on_key_down(self, keyboard, keycode, text, modifiers):
""" React to the keypress event """
key_name = keycode[1]
if key_name == "up" or text == "+":
self.volume += 0.025
elif key_name == "down" or text == "-":
self.volume -= 0.025
elif key_name == "x":
self.play_pause()
elif key_name == "z":
self.play_previous()
elif key_name == "v":
self.stop()
elif key_name == "b":
self.play_next()
elif key_name == "a":
self.show_filebrowser()
elif key_name == "p":
self.show_playlist()
elif key_name == "s":
self.show_main()
return True
def on_volume(self, widget, value):
""" Set the volume of the currently playing sound """
if 0.0 > value:
self.volume = 0.0
elif value > 1.0:
self.volume = 1.0
else:
Sound.set_volume(value)
self.playing.volume_slider.value = value
def play_index(self, index):
"""
Play the track with the specified playlist index
"""
Sound.stop()
self.playlist.current = index
self.play_pause()
def play_pause(self):
""" Play or pause the currently playing track """
self.advance = True
if Sound.state == "playing":
self.pos, x = Sound.get_pos_length()
Sound.stop()
else:
audio_file = self.get_current_file()
if audio_file:
Sound.play(audio_file, self.volume)
if self.pos > 0:
def set_pos(dt):
Sound.seek(self.pos)
self.pos = 0
Clock.schedule_once(set_pos, 0.1)
def play_next(self):
""" Play the next track in the playlist. """
Sound.stop()
self.playlist.move_next()
self.play_pause()
def play_previous(self):
""" Play the previous track in the playlist. """
Sound.stop()
self.playlist.move_previous()
self.play_pause()
@staticmethod
def set_position(value):
""" Set the playing position to the specified value. """
Sound.set_position(value)
def save(self):
""" Save the state of the the playlist and volume. """
self.playlist.save(self._store)
self._store.put("state", volume=self.volume)
if "filebrowser" in self.sm.screen_names:
self.sm.get_screen("filebrowser").save(self._store)
def show_filebrowser(self):
""" Switch to the file browser screen """
if "filebrowser" not in self.sm.screen_names:
self.sm.add_widget(ZenFileBrowser(self,
self.playlist,
self._store,
name="filebrowser"))
self.sm.current = "filebrowser"
def show_playlist(self):
""" Switch to the playlist screen """
if "playlist" not in self.sm.screen_names:
self.sm.add_widget(PlayListScreen(self.sm,
self,
self.playlist,
name="playlist"))
self.sm.current = "playlist"
def show_main(self):
""" Switch to the main playing screen"""
self.sm.current = "main"
def stop(self):
""" Stop any playing audio """
self.advance = False
Sound.stop()
class WeatherRoot(BoxLayout):
current_weather = ObjectProperty()
locations = ObjectProperty()
forecast = ObjectProperty()
def __init__(self, **kwargs):
super(WeatherRoot, self).__init__(**kwargs)
self.store = JsonStore("weather_store.json")
if self.store.exists("locations"):
current_location = self.store.get("locations")["current_location"]
self.show_current_weather(current_location)
def show_current_weather(self, location=None):
self.clear_widgets()
if self.current_weather is None:
self.current_weather = CurrentWeather()
if self.locations is None:
self.locations = Factory.Locations()
if self.store.exists("locations"):
locations = self.store.get("locations")["locations"]
self.locations.locations_list.adapter.data.extend(locations)
if location is not None:
self.current_weather.location = location
if location not in self.locations.locations_list.adapter.data:
self.locations.locations_list.adapter.data.append(location)
self.locations.locations_list._trigger_reset_populate()
self.store.put("locations",
locations=list(
self.locations.locations_list.adapter.data),
current_location=location)
self.current_weather.update_weather()
self.add_widget(self.current_weather)
def show_add_location_form(self):
self.clear_widgets()
self.add_widget(AddLocationForm())
def show_locations(self):
self.clear_widgets()
self.add_widget(self.locations)
def show_cover_page(self):
self.clear_widgets()
self.add_widget(CoverPage())
def show_forecast(self, location=None):
self.clear_widgets()
if self.forecast is None:
self.forecast = Forecast()
if location is not None:
self.forecast.location = location
self.forecast.update_weather()
self.add_widget(self.forecast)
def saveobjectsize(self):
store = JsonStore('Saved_variables.json')
store.put('ballsize',ballsize = self.objectsize)
class FindBWidget(BoxLayout):
level=NumericProperty(1)
bfound = NumericProperty(0)
bnumber = NumericProperty(0)
def __init__(self,**kwargs):
super(FindBWidget,self).__init__(**kwargs)
self.BBoxList=[]
self.store = JsonStore("findb.json")
self.gridSize_height = 0
self.gridSize_width = 0
self.bnumber = 0
self.badded = 0
self.bfound = 0
self.mute=True
self.gameover = False
self.custimize = False
self.custimize_height = 0
self.custimize_width = 0
self.custimize_brate = 0.2
self.sounds = {'bomb':SoundLoader.load('bomb.wav'),
'state':SoundLoader.load('state.wav'),
'upgrade':SoundLoader.load('upgrade.mp3')}
self.start_clock = clock()
self.config = None
def on_bfound(self,instance,value):
self.status_bar.label_left_bomb.text = '{}'.format(self.bnumber - self.bfound)
self.CheckSucceed()
def on_bnumber(self,instance,value):
self.status_bar.label_left_bomb.text = '{}'.format(self.bnumber - self.bfound)
def Restart(self):
self.custimize,self.custimize_height,self.custimize_width,self.custimize_brate = self.get_customize_info()
self.level,self.levels_info = self.get_level_info()
self.mute = self.get_mute_info()
self.BBoxList = []
if self.custimize == True:
self.status_bar.label_level.text = 'L:C'
self.gridSize_height = self.custimize_height
self.gridSize_width = self.custimize_width
if self.gridSize_height < 5:
self.gridSize_height = 5
if self.gridSize_width < 5:
self.gridSize_width = 5
if self.gridSize_height > 50:
self.gridSize_height = 50
if self.gridSize_width > 50:
self.gridSize_width = 50
else:
self.status_bar.label_level.text = 'L:{}'.format(self.level)
self.gridSize_width = self.level + Rows_For_First_Level
self.gridSize_height = self.level + Rows_For_First_Level
self.bnumber = 0
self.badded = 0
self.bfound = 0
self.start_clock = clock()
self.gameover = False
self.play_area.clear_widgets()
self.play_area.cols = self.gridSize_width
self.play_area.rows = self.gridSize_height
for i in range(0,self.gridSize_height):
for j in range(0,self.gridSize_width):
b = BBox(root=self)
b.row=i
b.col=j
self.BBoxList.append(b)
self.play_area.add_widget(b)
self._calculate_bombs()
self.status_bar.toggle_mark.disable = False
self.status_bar.toggle_mark.state = "normal"
self.status_bar.button_reset.image.source='smile.png'
def _calculate_bombs(self):
if self.custimize:
self.brate = self.custimize_brate/100.0
if self.brate < 0.05:
self.brate = 0.05
if self.brate > 0.8:
self.brate = 0.8
elif self.level < 6:
self.brate = 0.11
elif self.level < 11:
self.brate = 0.13
elif self.level < 20:
self.brate = 0.15
elif self.level < 30:
self.brate = 0.18
else:
self.brate = 0.2
self.bnumber = int(self.brate * self.gridSize_width * self.gridSize_height)
self.badded = 0
while True:
if self._add_bomb():
self.badded += 1
if self.badded >= self.bnumber:
break
def _add_bomb(self):
if len(self.BBoxList) <=0:
return
i = Random().randint(0,len(self.BBoxList) - 1)
if self.BBoxList[i].isBomb:
return False
else:
self.BBoxList[i].isBomb = True
#set bomb number of the around boxes
row = self.BBoxList[i].row
col = self.BBoxList[i].col
self._add_bomb_number(row - 1,col - 1)
self._add_bomb_number(row - 1,col)
self._add_bomb_number(row - 1,col + 1)
self._add_bomb_number(row,col - 1)
self._add_bomb_number(row,col + 1)
self._add_bomb_number(row + 1,col - 1)
self._add_bomb_number(row + 1,col)
self._add_bomb_number(row + 1,col + 1)
return True
def _add_bomb_number(self,row,col):
if row < 0 or row >= self.gridSize_width or col < 0 or col >= self.gridSize_height:
return
index = row*self.gridSize_width + col
if index < 0 or index >= len(self.BBoxList):
return
self.BBoxList[index].BNumber += 1
def Clear(self,row,col):
if row < 0 or row >= self.gridSize_width or col < 0 or col >= self.gridSize_height:
return
index = row*self.gridSize_width + col
if index < 0 or index >= len(self.BBoxList):
return
self.BBoxList[index].MarkNumberOrEmpty()
def ShowAll(self):
self.status_bar.toggle_mark.state='normal'
for i in range(0,len(self.BBoxList)):
if self.BBoxList[i].isBomb:
self.BBoxList[i].bbutton.MarkB()
else:
self.BBoxList[i].Clear()
def CheckSucceed(self):
if self.bfound > 0 and self.bfound == self.bnumber:
for i in range(0,len(self.BBoxList)):
if self.BBoxList[i].state == 0:
return False
#upgrade level
if self.mute == False:
self.sounds['upgrade'].play()
if self.custimize == False:
duration = round((clock() - self.start_clock),2)
if self.levels_info.has_key(self.level) and self.levels_info[self.level] > 0:
if self.levels_info[self.level] > duration:
self.levels_info[self.level] = duration
else:
self.levels_info[self.level] = duration
if self.level < Max_Level:
self.level += 1
self.store_user_data(self.level,self.levels_info)
self.Restart()
return True
else:
return False
def get_level_info(self):
if self.store.exists("UserData") == False:
self.store.put("UserData",CurrentLevel=1,Levels={})
return self.store.get("UserData")["CurrentLevel"],self.store.get("UserData")["Levels"]
def get_mute_info(self):
return self.config.get('Sounds','Mute') == '1'
def get_customize_info(self):
return self.config.get('Customization','Enable') == '1',self.config.getint('Customization','C_Height'),self.config.getint('Customization','C_Width'),self.config.getint('Customization','Rate')
def store_user_data(self,currentLevel,levels):
self.store.put("UserData",CurrentLevel=currentLevel,Levels=levels)
def GameOver(self):
self.status_bar.toggle_mark.disable = True
self.status_bar.button_reset.image.source='gameover.png'
self.gameover = True
from kivy.storage.jsonstore import JsonStore
def show_me(**kwargs):
print(kwargs)
for k, v in kwargs.items():
print(f'{k} = {v}')
d1 = {'dog': 1, 'cat': 2, 'mouse': 3}
print('\nPass a dictionary as keywords')
show_me(**d1)
print('\nPass Keywords')
show_me(box=4, fox=5, eggs=6)
store = JsonStore('test_1.json')
store.put('color', red=1, white=2, blue=3)
store.put('critters', **d1)
print(f"\nstore.get('critters') = {store.get('critters')}")
def on_leave(self):
""" The filebrowser screen is being closed """
if len(self.filechooser.selection) > 0:
store = JsonStore("zenplayer.json")
store.put("filebrowser", path=self.filechooser.selection[0])
class LoginScreen(Screen):
def on_enter(self):
self.storage = JsonStore("storage.json")
if self.storage.exists("user"):
user = self.storage.get("user")
if user["remember"]:
query = gql("""
mutation VerifyToken($token: String!) {
verifyToken(input: {
token: $token
}) {
payload
}
}
""")
result = sync_request(query, token=user["authToken"])
if result["verifyToken"]["payload"] is not None:
Clock.schedule_once(self.to_main_screen)
def login(self):
self.ids.email_input, email_valid = validate_input(
self.ids.email_input, not self.ids.email_input,
"Este campo é obrigatório")
self.ids.email_input, password_valid = validate_input(
self.ids.email_input, not self.ids.email_input,
"Este campo é obrigatório")
if email_valid and password_valid:
query = gql("""
mutation Login($email: String!, $password: String!) {
tokenAuth(
input: {
email: $email,
password: $password
}
) {
success,
errors,
token,
user {
id,
firstName,
lastName
}
}
}
""")
email = self.ids.email_input.text
result = sync_request(query,
email=email,
password=self.ids.password_input.text)
if result["tokenAuth"]["success"]:
user = result["tokenAuth"]["user"]
user_name = f"{user['firstName']} {user['lastName']}"
self.storage.put("user",
id=user["id"],
name=user_name,
email=email,
authToken=result["tokenAuth"]["token"],
remember=self.ids.remember_input.active)
self.manager.current = "main"
else:
errors = result["tokenAuth"]["errors"]
for error_field in errors.keys():
if error_field == "nonFieldErrors":
self.add_widget(
MDLabel(text=errors[error_field]["message"],
theme_text_color="Error",
font_style="H6"))
else:
self.ids[
f"{error_field}_input"], input_valid = validate_input(
self.ids[f"{error_field}_input"],
True,
errors[error_field][0]["message"],
)
def to_main_screen(self, event):
self.manager.current = "main"
def on_success(obj, result):
clases = result.get("get")
db = JsonStore("../db/clases.json")
lista = []
for clase in clases.get("clases"):
row_clase = {
'text': clase["nombre"],
'bgColor': clase["color"],
'tipo': 'clase',
"preguntas": []
}
if "precio" in clase:
row_clase["precio"] = clase["precio"]
if "promocion" in clase:
row_clase["promocion"] = clase["promocion"]
lista.append(row_clase)
row_clase['productos'] = unicode(clase["nombre"])
db_pro = JsonStore(u"../db/productos/{0}.json".format(
unicode(clase["nombre"])))
lista_productos = []
for pro in clase["productos"]:
row = {
'text': pro["nombre"],
'bgColor': pro["color"],
'preguntas': [],
'modificadores': [],
'tipo': clase["nombre"].lower()
}
if "precio" in pro:
row["precio"] = pro["precio"]
if "promocion" in clase:
row["promocion"] = clase["promocion"]
if len(pro['ingredientes']) > 0:
row["ingredientes"] = pro['nombre']
db_ing = JsonStore(u"../db/ingredientes/{0}.json".format(
unicode(pro['nombre'])))
lista_ing = []
for ing in pro["ingredientes"]:
row_ing = {
'text': ing["nombre"],
'bgColor': ing["color"],
"precio": ing["precio"] if "precio" in ing else 0
}
lista_ing.append(row_ing)
db_ing.put("selectable", estado=True)
db_ing.put("db", lista=lista_ing)
lista_productos.append(row)
db_pro.put("db", lista=lista_productos)
row_clase["preguntas"] = []
for clase_preg in clase["clasespreguntas"]:
nombre = clase_preg["nombre"]
row_clase["preguntas"].append(nombre)
db_pre = JsonStore(u"../db/preguntas/{0}.json".format(
unicode(nombre)))
lista_preg = []
for preg in clase_preg["preguntas"]:
row_ing = {
'text': preg["nombre"],
'bgColor': preg["color"],
}
if "precio" in preg:
row_ing["precio"] = preg["precio"]
lista_preg.append(row_ing)
db_pre.put("db", lista=lista_preg)
db.put('db', lista=lista)
class MyScreenManager(ScreenManager):
#ultimo = ""
directorio = ''
abierto = ""
cargado = False
modificando = False # alta o modificando
reg = 0
claves_buscando = False # para saber quien listó las claves
dic_items = {} # {item: 'indice registro'}
lista = []
lista_claves = []
listando_claves = False
lista_claves_cargadas = False
claves_seleccionadas = []
eligiendo = False
clave_nueva = False
clave_renombrar = ""
#pulsacion = False
jstore = ""
registros = [] # las lineas del fichero
items = []
memos = []
claves = [] # lista de claves de cada registro [[cla1,cla2],[],...]
#indice = []
clave = [] # claves existentes
num_lineas = StringProperty()
#jstore = JsonStore("pim_store.json")
#i_item = ObjectProperty()
i_buscar_item = ObjectProperty()
b_buscar_claves = ObjectProperty()
#lis_panta = ObjectProperty()
titulo_lista = StringProperty()
titulo_fichero = StringProperty()
panta = StringProperty()
smBotonDeLista = BotonDeLista
smBotonDeVocales = BotonDeVocales
mayusculas = uppercase
def __init__(self, **kwargs):
super(MyScreenManager, self).__init__(**kwargs)
self.current = 'sc_menu_principal'
if platform == 'android': android.hide_keyboard()
self.jstore = JsonStore("pim_store.json")
try:
ultimo = self.jstore.get("pim")['ultimo']
self.directorio = self.jstore.get("pim")['directorio']
except:
return
if not self.abrir_archivo(ultimo, incorporar=False, aviso=False):
self.selec_archivo('Elegir archivo')
log('año')
log(u'año')
def abrir_archivo(self, fich, incorporar, aviso=True):
try:
F = open(self.directorio + fich + FICH)
except:
if aviso: self.aviso('No puedo abrir ' + fich)
return False
if not incorporar: del self.registros[:]
num_lineas = 0
try:
r = F.readline()
while r:
if len(r) > 2:
self.registros.append(r[:-1].decode('utf-8'))
#self.registros.append(r[:-1])
num_lineas += 1
r = F.readline()
except:
self.aviso('No puedo leer ' + fich + ': ' + str(sys.exc_info()[0]))
return False
if not incorporar:
self.abierto = fich
self.titulo_fichero = fich
self.num_lineas = str(num_lineas) if num_lineas else '0'
else:
self.num_lineas = str(int(self.num_lineas) + num_lineas)
self.cargado = False
return True
def selec_archivo(self, opcion):
#self.lista = [f[:-8] for f in listdir(getcwd()) if f[-8:]=='-PIM.csv']
print '--------------------', self.directorio
self.lista = [f[:-8] for f in listdir(self.directorio) if f[-8:]=='-PIM.csv']
self.lista.sort()
self.ids.lis_panta.adapter = ListAdapter(data=[], cls=BotonDeLista, args_converter=self.args_converter, selection_mode='single')
self.listando_claves = False
self.rellena("ficheros")
self.titulo_lista = opcion
self.ids.b_lista_izq.text = 'Menu'
self.ids.b_lista_cen.text = ''
self.ids.b_lista_der.text = ''
self.ids.b_lista_over.text = 'Cancelar'
self.current = 'sc_lista'
def alta(self):
if not self.cargado: self.carga_listas()
self.ids.i_item_alta.text = ""
self.ids.i_memo_alta.text = ""
self.ids.i_claves_alta.text = ""
self.modificando = False
self.ids.i_item_alta.focus = True
self.current = 'sc_alta'
#def alta_clave(self, popup, cla):
#if not cla: return
#self.aviso(cla)
#self.clave.append(cla)
#self.clave.sort()
#self.ids.i_claves_alta.text += ','+cla
#popup.dismiss()
#self.elige_claves('registro')
def aviso(self, txt):
the_content = Label(text = txt)
the_content.color = (1,1,1,1)
popup = Popup(title='PIM',
content=the_content, size_hint_y=.25, title_align='center')
#content = the_content, size_hint=(None, None), size=(350, 150))
popup.open()
def confirmacion(self, txt="", tema=""):
def elim_1_reg(self):
popup.dismiss()
mapp.root.eliminar_registros(confirmado=True, modo='uno')
def elim_n_reg(self):
popup.dismiss()
mapp.root.eliminar_registros(confirmado=True, modo='varios')
def borr_fich(self):
popup.dismiss()
mapp.root.borrar_fich(confirmado=True, nombre=tema)
def expor_exis(self):
popup.dismiss()
mapp.root.exportar_existente()
def expor_nue(self):
popup.dismiss()
mapp.root.exportar_nuevo()
def cancelar(self):
popup.dismiss()
cuerpo = Confirmacion(txt)
cuerpo.color = (1,0,0,1)
if tema == 'exportar':
cuerpo.ids.b_aceptar.text = 'Añadir a existente'
cuerpo.ids.b_cancelar.text = 'Archivo nuevo'
cuerpo.ids.b_cancelar.bind(on_release=expor_nue)
else:
cuerpo.ids.b_aceptar.text = 'Aceptar'
cuerpo.ids.b_cancelar.text = 'Cancelar'
cuerpo.ids.b_cancelar.bind(on_release=cancelar)
popup = Popup(title='CONFIRMACION',
content=cuerpo, size_hint_y=.25, title_align='center',
title_color=[1,0,0,1], auto_dismiss=False)
if tema == 'elim_un_reg':
cuerpo.ids.b_aceptar.bind(on_release=elim_1_reg)
if tema == 'elim_n_regs':
cuerpo.ids.b_aceptar.bind(on_release=elim_n_reg)
if tema == 'exportar':
cuerpo.ids.b_aceptar.bind(on_release=expor_exis)
if tema.startswith('fichero-'):
cuerpo.ids.b_aceptar.bind(on_release=borr_fich)
popup.open()
def dialogo(self, txt='', tema=''):
def alta_clave(self):
nueva = the_content.ids.i_dialog.text.strip()
if not nueva: return
mapp.root.clave.append(nueva)
mapp.root.clave.sort()
mapp.root.lista_claves.append(ClaveItem(text=nueva, is_selected=True))
mapp.root.claves_seleccionadas.append(nueva)
if mapp.root.ids.i_claves_alta.text:
mapp.root.ids.i_claves_alta.text += ',' + nueva
else:
mapp.root.ids.i_claves_alta.text = nueva
popup.dismiss()
mapp.root.clave_nueva = True
mapp.root.elige_claves('registro')
def nuevo_fichero(self):
popup.dismiss()
mapp.root.fichero_nuevo(the_content.ids.i_dialog.text.strip())
def exportar_fichero(self):
popup.dismiss()
mapp.root.exportar_nuevo(the_content.ids.i_dialog.text.strip())
def renombre_clave(self):
popup.dismiss()
mapp.root.clave_nuevo_nombre(the_content.ids.i_dialog.text.strip())
the_content = Dialogo(txt)
the_content.color = (1,1,1,1)
popup = Popup(title=txt,
content=the_content, size_hint_y=.25, title_align='center', auto_dismiss=False)
the_content.ids.b_cancelar.bind(on_release=popup.dismiss)
if tema == 'clave':
#~ the_content.ids.b_aceptar.bind(on_release=self.alta_clave(popup, the_content.ids.i_dialog.text))
the_content.ids.b_aceptar.bind(on_release=alta_clave)
elif tema == 'fichero_nuevo':
the_content.ids.b_aceptar.bind(on_release=nuevo_fichero)
elif tema == 'renombrar_clave':
the_content.ids.b_aceptar.bind(on_release=renombre_clave)
elif tema == 'fichero_exportar':
the_content.ids.b_aceptar.bind(on_release=exportar_fichero)
popup.open()
def borrar_fich(self, confirmado, nombre):
if not confirmado:
self.confirmacion(u'¿Borrar el archivo ' + nombre + '?', 'fichero-'+nombre)
return
nombre = nombre[8:]
try:
remove(self.directorio + nombre + FICH)
self.current = 'sc_menu_principal'
self.aviso('Archivo borrado')
except:
self.aviso('Error al borrar archivo')
def boton_lista_izq(self, texto):
if self.titulo_lista == 'Claves':
self.eligiendo = False
if texto == 'Cancelar':
self.current = 'sc_alta'
return
self.current = 'sc_menu_principal'
#if texto == 'Menu': self.current = 'sc_menu_principal'
def boton_lista_cen(self, texto):
if self.titulo_lista.startswith('Registros encontrados'):
#self.exportar()
self.confirmacion('Opciones de exportación', 'exportar')
elif self.titulo_lista == 'Claves':
self.eligiendo = False
if texto == 'Nueva':
self.dialogo('Introduzca nueva clave', 'clave')
else:
self.current = 'sc_buscar'
def boton_lista_der(self, texto):
#~ self.ids.lis_panta._trigger_reset_populate()
if self.titulo_lista.startswith('Registros encontrados'):
self.current = 'sc_buscar'
elif self.titulo_lista == 'Claves':
self.eligiendo = False
#~ cla_selec = [c.text for c in self.ids.lis_panta.adapter.data if c.is_selected]
self.claves_seleccionadas.sort()
if self.claves_buscando:
self.ids.b_buscar_claves.text = ",".join(self.claves_seleccionadas)
self.current = 'sc_buscar'
else:
self.ids.i_claves_alta.text = ",".join(self.claves_seleccionadas)
self.current = 'sc_alta'
def boton_lista_over(self, texto):
if texto == 'Eliminar':
self.eliminar_registros(confirmado=False, modo='varios')
elif texto == 'Cancelar':
self.current = 'sc_menu_principal'
def busca(self):
del self.lista[:]
#self.dic_items = {}
self.dic_items.clear()
cad = self.i_buscar_cadena.text.lower()
if self.ids.sw_ignora.active:
cad = self.traduce(cad)
if self.ids.cb_y.active:
for i in range(len(self.items)):
if self.cadena_en_texto_ignora(i,cad) and self.clave_en_claves(i):
self.dic_items[self.repe(self.items[i])] = i
else:
for i in range(len(self.items)):
if self.cadena_en_texto_ignora(i,cad) or self.clave_en_claves(i):
self.dic_items[self.repe(self.items[i])] = i
else:
if self.ids.cb_y.active:
for i in range(len(self.items)):
if self.cadena_en_texto(i,cad) and self.clave_en_claves(i):
self.dic_items[self.repe(self.items[i])] = i
else:
for i in range(len(self.items)):
if self.cadena_en_texto(i,cad) or self.clave_en_claves(i):
self.dic_items[self.repe(self.items[i])] = i
self.lista = sorted(self.dic_items.keys(), reverse = True)
#self.lista.sort()
self.ids.lis_panta.adapter = ListAdapter(data=[], cls=BotonDeLista, args_converter=self.args_converter, selection_mode='single')
self.titulo_lista = 'Registros encontrados: ' + str(len(self.lista))
self.ids.b_lista_izq.text = 'Menu'
self.ids.b_lista_cen.text = 'Exportar'
self.ids.b_lista_der.text = 'Buscar'
self.ids.b_lista_over.text = 'Eliminar'
self.listando_claves = False
self.rellena("items")
self.current = 'sc_lista'
def cadena_en_texto(self, i, cad):
if cad:
if self.ids.sw_busca.active:
if not (self.items[i].lower().count(cad) or self.memos[i].lower().count(cad)):
return False
else:
if not self.items[i].lower().count(cad):
return False
return True
def cadena_en_texto_ignora(self, i, cad):
if cad:
if self.ids.sw_busca.active:
if not (self.traduce(self.items[i].lower()).count(cad) or self.traduce(self.memos[i].lower()).count(cad)):
return False
else:
if not self.traduce(self.items[i].lower()).count(cad):
return False
return True
def clave_en_claves(self, i):
#if self.b_buscar_claves.text != '<claves>':
if self.b_buscar_claves.text != '':
b_claves = self.b_buscar_claves.text.split(',')
Y_claves = True
if Y_claves:
for c in b_claves:
if c not in self.claves[i]: return False
return True
else:
for c in b_claves:
if c in self.claves[i]: return True
return False
return True
def repe(self, item):
while item in self.dic_items:
item += SEP
return item
def clave_nuevo_nombre(self, nuevo_nombre=""):
if not nuevo_nombre:
self.dialogo('Nuevo nombre para '+self.clave_renombrar, 'renombrar_clave')
return
for i in range(len(self.registros)):
campos = self.registros[i].split(SEP)
for j in range(2,len(campos)):
if campos[j] == self.clave_renombrar:
campos[j] = nuevo_nombre
self.registros[i] = SEP.join(campos)
break
for j in range(len(self.claves[i])):
if self.claves[i][j] == self.clave_renombrar:
self.claves[i][j] = nuevo_nombre
break
self.clave.append(nuevo_nombre)
self.clave.sort()
self.lista_claves_cargadas = False
self.grabar(modo='renom')
def carga_listas(self):
del self.items[:]
del self.memos[:]
del self.claves[:]
del self.clave[:]
for r in self.registros:
campos = r.split(SEP)
self.items.append(campos[0])
self.memos.append(campos[1])
self.claves.append(campos[2:])
for c in campos[2:]:
if c not in self.clave: self.clave.append(c)
self.clave.sort()
self.lista_claves_cargadas = False
self.cargado = True
def elige_claves(self, origen='', cuales='todas'):
if self.eligiendo: return
self.ids.lis_c_panta.adapter.selection_mode = 'multiple'
if origen == 'buscar':
self.ids.b_lista_c_izq.text = 'Menú'
self.ids.b_lista_c_cen.text = 'Cancelar'
else:
self.ids.b_lista_c_izq.text = 'Cancelar'
self.ids.b_lista_c_cen.text = 'Nueva'
self.ids.b_lista_c_der.text = 'Aceptar'
if not self.listando_claves:
self.listando_claves = True
self.titulo_lista = 'Claves'
if not self.lista_claves_cargadas:
del self.lista_claves[:]
for c in self.clave: self.lista_claves.append(ClaveItem(text=c))
self.lista_claves_cargadas = True
self.marca_claves(origen)
self.rellena_claves(cuales)
#self.titulo_lista = 'Claves'
self.eligiendo = True
self.current = 'sc_lista_claves'
if platform == 'android': android.hide_keyboard()
def chequeos(self):
reg = self.ids.i_item_alta.text + \
self.ids.i_memo_alta.text + \
self.ids.i_claves_alta.text
if reg == "":
self.aviso('Registro vacío')
return False
if reg.count(SEP):
self.aviso('No se puede usar ' + SEP)
return False
return True
def eliminar_registros(self, confirmado=False, modo=''):
if not confirmado:
if modo == 'uno':
self.confirmacion('¿Eliminar el registro?', 'elim_un_reg')
else:
self.confirmacion('¿Eliminar ' + str(len(self.dic_items)) + ' registros?', 'elim_n_regs')
return
if modo == 'uno':
a_eliminar = [self.dic_items[self.ids.i_item.text]]
else:
a_eliminar = self.dic_items.values()
a_eliminar.sort(reverse = True)
for i in a_eliminar:
self.registros.pop(i)
self.items.pop(i)
self.memos.pop(i)
self.claves.pop(i)
if self.graba_lista(self.abierto+TEMP, self.registros):
rename(self.directorio+self.abierto+TEMP, self.directorio+self.abierto+FICH)
self.num_lineas = str(int(self.num_lineas) - len(a_eliminar))
self.aviso('Registro(s) eliminado(s)')
else:
self.abrir_archivo(self.abierto, incorporar=False)
self.current = 'sc_menu_principal'
def existe_fichero(self, nombre):
if nombre+FICH in listdir(self.directorio):
self.aviso('Ya existe ese fichero')
return True
return False
# def exportar(self):
# self.confirmacion('Opciones de exportación', 'exportar')
def exportar_existente(self, nombre=''):
if not nombre:
self.selec_archivo('Archivo al que añadir')
return
try:
F = open(self.directorio+nombre+FICH, 'a')
except:
self.aviso('No puedo abrir fichero')
return
regis = [self.registros[i] for i in self.dic_items.values()]
try:
for r in regis: F.write(r.encode('utf-8') + '\n')
except:
self.aviso('No puedo escribir en fichero')
return
finally:
F.close()
self.current = 'sc_menu_principal'
self.aviso('Registros añadidos')
def exportar_nuevo(self, nombre=''):
if not nombre:
self.dialogo('Nombre del fichero', 'fichero_exportar')
return
if self.existe_fichero(nombre): return
regis = [self.registros[i] for i in self.dic_items.values()]
# try:
# F = open(self.directorio + nombre + FICH, 'w')
# except:
# self.aviso('No puedo crear fichero')
# return
# try:
# for r in regis: F.write(r.encode('utf-8') + '\n')
# except:
# self.aviso('No puedo escribir fichero')
# return
# F.close()
if self.graba_lista(nombre+FICH, regis):
self.aviso('Exportados ' + str(len(regis)) + ' registros')
def graba_lista(self, nombre, lista):
try:
F = open(self.directorio + nombre, 'w')
except:
self.aviso('No puedo crear fichero')
return False
try:
for r in lista: F.write(r.encode('utf-8') + '\n')
except:
self.aviso('No puedo escribir fichero')
remove(self.directorio + nombre)
return False
F.close()
return True
def fichero_nuevo(self, nombre=''):
if not nombre:
self.dialogo('Nombre del nuevo fichero', 'fichero_nuevo')
return
if self.existe_fichero(nombre): return
try:
open(self.directorio + nombre + FICH, 'w').close()
except:
self.aviso('No puedo crear fichero')
return
if self.abrir_archivo(nombre, incorporar=False):
self.jstore.put("pim", ultimo=nombre, directorio=self.directorio)
self.num_lineas = '0'
self.current = 'sc_menu_principal'
def grabar(self, modo=""):
if modo=='modif' and not self.modificando:
self.aviso('No está modificando')
return
if modo!='renom' and not self.chequeos(): return
try: F = open(self.directorio + self.abierto + TEMP, 'w')
except:
self.aviso('No puedo crear fichero')
return
if modo != 'renom':
reg = self.ids.i_item_alta.text.strip() + SEP + \
self.ids.i_memo_alta.text.rstrip().replace('\n',' ^ ') + SEP + \
self.ids.i_claves_alta.text.replace(',',SEP)
if modo == 'nuevo':
self.registros.append(reg)
self.items.append(self.ids.i_item_alta.text)
self.memos.append(self.ids.i_memo_alta.text.replace('\n',' ^ '))
self.claves.append(self.ids.i_claves_alta.text.split(','))
elif modo == 'modif':
self.registros[self.reg] = reg
self.items[self.reg] = self.ids.i_item_alta.text
self.memos[self.reg] = self.ids.i_memo_alta.text.replace('\n',' ^ ')
self.claves[self.reg] = self.ids.i_claves_alta.text.split(',')
try:
for r in self.registros: F.write(r.encode('utf-8') + '\n')
except UnicodeEncodeError:
try: remove(self.directorio + self.abierto+TEMP)
except: pass
self.aviso('Hay caracteres inválidos')
return
except:
#self.aviso('No puedo escribir fichero')
try: remove(self.directorio + self.abierto+TEMP)
except: pass
self.aviso(str(sys.exc_info()[0]))
return
F.close()
rename(self.directorio + self.abierto+TEMP, self.directorio + self.abierto+FICH)
if modo == 'nuevo': self.num_lineas = str(int(self.num_lineas) + 1)
self.current = 'sc_menu_principal'
if modo == 'renom': self.aviso('Clave renombrada')
def importar(self, nombre):
if self.abrir_archivo(nombre, incorporar=True):
if self.graba_lista(self.abierto+TEMP, self.registros):
rename(self.directorio+self.abierto+TEMP, self.directorio+self.abierto+FICH)
self.aviso('Registros importados')
else:
self.abrir_archivo(self.abierto, incorporar=False)
self.current = 'sc_menu_principal'
def limpia_i_buscar_cadena(self):
self.i_buscar_cadena.text = ""
def limpia_b_buscar_claves(self):
if self.b_buscar_claves.text != "":
self.b_buscar_claves.text = ""
for c in self.lista_claves: c.deselect()
self.listando_claves = False
def limpia_busqueda(self):
self.limpia_i_buscar_cadena()
self.limpia_b_buscar_claves()
def lista_elegido(self, boton, texto):
if self.titulo_lista.startswith('Registros encontrados'):
self.reg = self.dic_items[texto]
self.ids.i_item.text = self.items[self.reg]
self.ids.i_memo.text = self.memos[self.reg].replace(' ^ ','\n')
self.ids.i_claves.text = ','.join(self.claves[self.reg])
self.ids.i_item.readonly = True
self.ids.i_memo.readonly = True
self.ids.i_claves.readonly = True
self.current = 'sc_registro'
elif self.titulo_lista == 'Claves':
#self.claves_seleccionadas.append('kkk'); return
#~ cla_selec = [c.text for c in self.ids.lis_panta.adapter.data if c.is_selected]
if texto in self.claves_seleccionadas:
self.claves_seleccionadas.remove(texto)
for c in self.ids.lis_c_panta.adapter.data:
if c.text == texto: c.is_selected = False
else:
self.claves_seleccionadas.append(texto)
for c in self.ids.lis_c_panta.adapter.data:
if c.text == texto: c.is_selected = True
#~ cla_selec = [c.text for c in self.ids.lis_panta.adapter.data if c.is_selected]
elif self.titulo_lista == 'Elegir archivo':
if self.abrir_archivo(texto, incorporar=False):
# self.jstore.put("pim", directorio='/mnt/sdcard/PIM/', ultimo=texto)
self.jstore.put("pim", directorio=self.directorio, ultimo=texto)
self.current = 'sc_menu_principal'
elif self.titulo_lista == 'Archivo a importar':
self.importar(texto)
elif self.titulo_lista == 'Archivo a borrar':
self.borrar_fich(confirmado=False, nombre=texto)
elif self.titulo_lista == 'Clave a renombrar':
self.clave_renombrar = texto
self.clave_nuevo_nombre("")
elif self.titulo_lista == 'Archivo al que añadir':
self.exportar_existente(nombre=texto)
def marca_claves(self, origen):
if origen == 'buscar':
self.claves_buscando = True
if self.ids.b_buscar_claves.text: self.claves_seleccionadas = self.ids.b_buscar_claves.text.split(',')
else: self.claves_seleccionadas = []
else:
self.claves_buscando = False
if not self.clave_nueva:
if self.ids.i_claves_alta.text: self.claves_seleccionadas = self.ids.i_claves_alta.text.split(',')
else: self.claves_seleccionadas = []
else:
self.clave_nueva = False
for cl in self.lista_claves:
cl.is_selected = True if cl.text in self.claves_seleccionadas else False
def limpia_claves_vacias(self):
for i in range(len(self.registros)):
if self.registros[i].count(SEP) > 2:
self.registros[i] = self.registros[i].rstrip(SEP+' ')
while self.registros[i].count(SEP) < 2:
self.registros[i] += SEP
if self.graba_lista(self.abierto+TEMP, self.registros):
rename(self.directorio+self.abierto+TEMP, self.directorio+self.abierto+FICH)
self.current = 'sc_menu_principal'
self.aviso('Claves limpiadas')
self.cargado = False
def modificar(self):
self.ids.i_item_alta.text = self.ids.i_item.text
self.ids.i_memo_alta.text = self.ids.i_memo.text
self.ids.i_claves_alta.text = self.ids.i_claves.text
self.modificando = True
self.current = 'sc_alta'
def orden_archivo(self, orden):
self.registros.sort(reverse=(orden=='des'), key=lambda s: s.lower())
if self.graba_lista(self.abierto+TEMP, self.registros):
rename(self.directorio+self.abierto+TEMP, self.directorio+self.abierto+FICH)
self.current = 'sc_menu_principal'
self.aviso('Archivo ordenado')
#self.cargado = False
def orden_lista(self, orden):
self.ids.lis_panta.adapter.data.sort()
if orden == 'des': self.ids.lis_panta.adapter.data.reverse()
def panta_buscar(self):
if self.abierto:
if not self.cargado: self.carga_listas()
self.ids.titulo_sc_buscar.text = 'Buscando en ' + self.titulo_fichero
self.current = 'sc_buscar'
self.ids.i_buscar_cadena.focus = True
def rellena(self, tipo=""):
#~ self.lis_panta.item_strings = ['wefrewr', 'klsjf lkj f']
#~ self.lis_panta.adapter.data.clear()
#self.titulo_lista = 'Ficheros disponibles'
del self.ids.lis_panta.adapter.data[:]
if tipo == "ficheros":
#~ self.ids.lis_panta.adapter.data = self.lista
self.ids.lis_panta.adapter.cls = BotonDeLista
else:
self.ids.lis_panta.adapter.cls = LabelDeLista
self.ids.lis_panta.adapter.data.extend(self.lista)
self.ids.lis_panta._trigger_reset_populate()
def rellena_claves(self, cuales):
del self.ids.lis_c_panta.adapter.data[:]
if cuales == 'todas':
self.ids.lis_c_panta.adapter.data.extend(self.lista_claves)
elif cuales == 'marcadas':
self.ids.lis_c_panta.adapter.data.extend(c for c in self.lista_claves if c.text in self.claves_seleccionadas)
else:
letra = cuales.lower()
self.ids.lis_c_panta.adapter.data.extend(c for c in self.lista_claves if c.text.lower()>=letra)
self.ids.lis_c_panta._trigger_reset_populate()
def args_converter(self, index, data_item):
#~ texto = data_item
#~ return {'texto': texto}
return {'text': data_item}
def args_converter_claves(self, index, data_item):
#~ texto = data_item.text
#~ return {'texto': texto}
return {'text': data_item.text}
def renombrar_clave(self):
if not self.cargado: self.carga_listas()
self.clave_renombrar = ""
#self.ids.lis_c_panta.adapter = ListAdapter(data=[], cls=BotonDeLista, args_converter=self.args_converter_claves)
self.ids.lis_c_panta.adapter.selection_mode = 'single'
self.titulo_lista = 'Clave a renombrar'
self.ids.b_lista_c_izq.text = 'Menu'
self.ids.b_lista_c_cen.text = ''
self.ids.b_lista_c_der.text = ''
self.ids.b_lista_c_over.text = 'Cancelar'
if not self.lista_claves_cargadas:
del self.lista_claves[:]
for c in self.clave: self.lista_claves.append(ClaveItem(text=c))
self.lista_claves_cargadas = True
self.rellena_claves('todas')
self.current = 'sc_lista_claves'
def traduce(self, s):
s = s.encode('utf-8')
s = s.replace('á','a').replace('é','e').replace('í','i')\
.replace('ó','o').replace('ú','u').replace('ñ','n')\
.replace('ç','c')
return s.decode('utf-8')
