#!/usr/bin/env python # -*- coding: utf-8 -*- import time import os.path import TextConfig from lib.RepeatTimer import RepeatTimer import configparser class DeviceStats(object): #TODO: via config.ini deaktivierbare Stats, z.B. angry dauerhaft auf 0 setzen #TODO: Abhängigkeit der Mondphase einbauen - Bei Vollmond gehen manche Stats schneller höch #TODO: Abhängigkeit der Blauen Stunde / Goldenen Stunde, bedingt an Wetter und Wolken MAX_VALUE:float = 1000 SAVE_STATS_INTERVAL = 1 #angry = 0.0 #aroused = 0.0 #hungry = 0.0 #happyness = 0.0 #funny = 0.0 #annoyed = 0.0 #irritated = 0.0 #bored = 0.0 #intelligent = 0.0 #sleepy = 0.0 #energy = 0.0 #exhausted = 0.0 #depressive = 0.0 #sad = 0.0 #useless = 0.0 #usefull = 0.0 #compfortable = 0.0 #temperate = 0.0 # Wohl temperiert - ist die Temperatur angenehm #shy = 0.0 #excited = 0.0 #toLoud = 0.0 # Zu laut #toQuiet = 0.0 # Zu leise #playful = 0.0 #naiv = 0.0 #freezy = 0.0 #hot = 0.0 #humanity = 0.0 #lonely = 0.0 #soziality = 0.0 #lastTimeToLoud = 0 #lastTimeToQuiet = 0 #lastTimeAngry = 0 #lastTimeLonely = 0 lastUpdate = 0 def __init__(self): self._angry = 0.0 self._aroused = 0.0 self._hungry = 0.0 self._happyness = 0.0 self._funny = 0.0 self._annoyed = 0.0 self._irritated = 0.0 self._bored = 0.0 self._intelligent = 0.0 self._sleepy = 0.0 self._energy = 0.0 self._exhausted = 0.0 self._depressive = 0.0 self._sad = 0.0 self._useless = 0.0 self._usefull = 0.0 self._compfortable = 0.0 self._temperate = 0.0 self._shy = 0.0 self._excited = 0.0 self._toLoud = 0.0 self._toQuiet = 0.0 self._playful = 0.0 self._naiv = 0.0 self._freezy = 0.0 self._hot = 0.0 self._lonely = 0.0 self._humanity = 0.0 self._soziality = 0.0 self._lastTimeToLoud = 0.0 self._lastTimeToQuiet = 0.0 self._lastTimeAngry = 0.0 self._lastTimeLonely = 0.0 self._locked_angry = -1.0 self._locked_aroused = -1.0 self._locked_hungry = -1.0 self._locked_happyness = -1.0 self._locked_funny = -1.0 self._locked_annoyed = -1.0 self._locked_irritated = -1.0 self._locked_bored = -1.0 self._locked_intelligent = -1.0 self._locked_sleepy = -1.0 self._locked_energy = -1.0 self._locked_exhausted = -1.0 self._locked_depressive = -1.0 self._locked_sad = -1.0 self._locked_useless = -1.0 self._locked_usefull = -1.0 self._locked_compfortable = -1.0 self._locked_temperate = -1.0 self._locked_shy = -1.0 self._locked_excited = -1.0 self._locked_toLoud = -1.0 self._locked_toQuiet = -1.0 self._locked_playful = -1.0 self._locked_naiv = -1.0 self._locked_freezy = -1.0 self._locked_hot = -1.0 self._locked_lonely = -1.0 self._locked_humanity = -1.0 self._locked_soziality = -1.0 self.textconfig = TextConfig.TextConfig("cache/stats.txt") self.Load() self.Thread_Save = RepeatTimer(self.SAVE_STATS_INTERVAL*60, self.Save) self.Thread_Save.start() if(True): config = configparser.ConfigParser() config.read('config/stats.ini') if "Locked_Stats" in config: if "angry" in config["Locked_Stats"]: self._locked_angry = float(config["Locked_Stats"]["angry"]) if "aroused" in config["Locked_Stats"]: self._locked_aroused = float(config["Locked_Stats"]["aroused"]) if "hungry" in config["Locked_Stats"]: self._locked_hungry = float(config["Locked_Stats"]["hungry"]) if "happyness" in config["Locked_Stats"]: self._locked_happyness = float(config["Locked_Stats"]["happyness"]) if "funny" in config["Locked_Stats"]: self._locked_funny = float(config["Locked_Stats"]["funny"]) if "annoyed" in config["Locked_Stats"]: self._locked_annoyed = float(config["Locked_Stats"]["annoyed"]) if "irritated" in config["Locked_Stats"]: self._locked_irritated = float(config["Locked_Stats"]["irritated"]) if "bored" in config["Locked_Stats"]: self._locked_bored = float(config["Locked_Stats"]["bored"]) if "intelligent" in config["Locked_Stats"]: self._locked_intelligent = float(config["Locked_Stats"]["intelligent"]) if "sleepy" in config["Locked_Stats"]: self._locked_sleepy = float(config["Locked_Stats"]["sleepy"]) if "energy" in config["Locked_Stats"]: self._locked_energy = float(config["Locked_Stats"]["energy"]) if "exhausted" in config["Locked_Stats"]: self._locked_exhausted = float(config["Locked_Stats"]["exhausted"]) if "depressive" in config["Locked_Stats"]: self._locked_depressive = float(config["Locked_Stats"]["depressive"]) if "sad" in config["Locked_Stats"]: self._locked_sad = float(config["Locked_Stats"]["sad"]) if "useless" in config["Locked_Stats"]: self._locked_useless = float(config["Locked_Stats"]["useless"]) if "usefull" in config["Locked_Stats"]: self._locked_usefull = float(config["Locked_Stats"]["usefull"]) if "compfortable" in config["Locked_Stats"]: self._locked_compfortable = float(config["Locked_Stats"]["compfortable"]) if "temperate" in config["Locked_Stats"]: self._locked_temperate = float(config["Locked_Stats"]["temperate"]) if "shy" in config["Locked_Stats"]: self._locked_shy = float(config["Locked_Stats"]["shy"]) if "excited" in config["Locked_Stats"]: self._locked_excited = float(config["Locked_Stats"]["excited"]) if "toLoud" in config["Locked_Stats"]: self._locked_toLoud = float(config["Locked_Stats"]["toLoud"]) if "toQuiet" in config["Locked_Stats"]: self._locked_toQuiet = float(config["Locked_Stats"]["toQuiet"]) if "playful" in config["Locked_Stats"]: self._locked_playful = float(config["Locked_Stats"]["playful"]) if "naiv" in config["Locked_Stats"]: self._locked_naiv = float(config["Locked_Stats"]["naiv"]) if "freezy" in config["Locked_Stats"]: self._locked_freezy = float(config["Locked_Stats"]["freezy"]) if "hot" in config["Locked_Stats"]: self._locked_hot = float(config["Locked_Stats"]["hot"]) if "lonely" in config["Locked_Stats"]: self._locked_lonely = float(config["Locked_Stats"]["lonely"]) if "humanity" in config["Locked_Stats"]: self._locked_humanity = float(config["Locked_Stats"]["humanity"]) if "soziality" in config["Locked_Stats"]: self._locked_soziality = float(config["Locked_Stats"]["soziality"]) @property def angry(self) -> float: if self._locked_angry >= 0: return self._locked_angry return self._angry @angry.setter def angry(self, value:float): if value<0: self._angry = 0 elif value > self.MAX_VALUE: self._angry = self.MAX_VALUE else: self._angry = value if value > 0: self._lastTimeAngry = time.time() @property def aroused(self) -> float: if self._locked_aroused >= 0: return self._locked_aroused return self._aroused @aroused.setter def aroused(self, value:float): if value<0: self._aroused = 0 elif value > self.MAX_VALUE: self._aroused = self.MAX_VALUE else: self._aroused = value @property def hungry(self) -> float: if self._locked_hungry >= 0: return self._locked_hungry return self._hungry @hungry.setter def hungry(self, value:float): if value<0: self._hungry = 0 elif value > self.MAX_VALUE: self._hungry = self.MAX_VALUE else: self._hungry = value @property def happyness(self) -> float: if self._locked_happyness >= 0: return self._locked_happyness return self._happyness @happyness.setter def happyness(self, value:float): if value<0: self._happyness = 0 elif value > self.MAX_VALUE: self._happyness = self.MAX_VALUE else: self._happyness = value @property def funny(self) -> float: if self._locked_funny >= 0: return self._locked_funny return self._funny @funny.setter def funny(self, value:float): if value<0: self._funny = 0 elif value > self.MAX_VALUE: self._funny = self.MAX_VALUE else: self._funny = value @property def annoyed(self) -> float: if self._locked_annoyed >= 0: return self._locked_annoyed return self._annoyed @annoyed.setter def annoyed(self, value:float): if value<0: self._annoyed = 0 elif value > self.MAX_VALUE: self._annoyed = self.MAX_VALUE else: self._annoyed = value @property def irritated(self) -> float: if self._locked_irritated >= 0: return self._locked_irritated return self._irritated @irritated.setter def irritated(self, value:float): if value<0: self._irritated = 0 elif value > self.MAX_VALUE: self._irritated = self.MAX_VALUE else: self._irritated = value @property def bored(self) -> float: if self._locked_bored >= 0: return self._locked_bored return self._bored @bored.setter def bored(self, value:float): if value<0: self._bored = 0 elif value > self.MAX_VALUE: self._bored = self.MAX_VALUE else: self._bored = value @property def intelligent(self) -> float: if self._locked_intelligent >= 0: return self._locked_intelligent return self._intelligent @intelligent.setter def intelligent(self, value:float): if value<0: self._intelligent = 0 elif value > self.MAX_VALUE: self._intelligent = self.MAX_VALUE else: self._intelligent = value @property def sleepy(self) -> float: if self._locked_sleepy >= 0: return self._locked_sleepy return self._sleepy @sleepy.setter def sleepy(self, value:float): if value<0: self._sleepy = 0 elif value > self.MAX_VALUE: self._sleepy = self.MAX_VALUE else: self._sleepy = value @property def energy(self) -> float: if self._locked_energy >= 0: return self._locked_energy return self._energy @energy.setter def energy(self, value:float): if value<0: self._energy = 0 elif value > self.MAX_VALUE: self._energy = self.MAX_VALUE else: self._energy = value @property def exhausted(self) -> float: if self._locked_exhausted >= 0: return self._locked_exhausted return self._exhausted @exhausted.setter def exhausted(self, value:float): if value<0: self._exhausted = 0 elif value > self.MAX_VALUE: self._exhausted = self.MAX_VALUE else: self._exhausted = value @property def depressive(self) -> float: if self._locked_depressive >= 0: return self._locked_depressive return self._depressive @depressive.setter def depressive(self, value:float): if value<0: self._depressive = 0 elif value > self.MAX_VALUE: self._depressive = self.MAX_VALUE else: self._depressive = value @property def sad(self) -> float: if self._locked_sad >= 0: return self._locked_sad return self._sad @sad.setter def sad(self, value:float): if value<0: self._sad = 0 elif value > self.MAX_VALUE: self._sad = self.MAX_VALUE else: self._sad = value @property def useless(self) -> float: if self._locked_useless >= 0: return self._locked_useless return self._useless @useless.setter def useless(self, value): if value<0: self._useless = 0 elif value > self.MAX_VALUE: self._useless = self.MAX_VALUE else: self._useless = value @property def usefull(self) -> float: if self._locked_usefull >= 0: return self._locked_usefull return self._usefull @usefull.setter def usefull(self, value:float): if value<0: self._usefull = 0 elif value > self.MAX_VALUE: self._usefull = self.MAX_VALUE else: self._usefull = value @property def compfortable(self) -> float: if self._locked_compfortable >= 0: return self._locked_compfortable return self._compfortable @compfortable.setter def compfortable(self, value:float): if value<0: self._compfortable = 0 elif value > self.MAX_VALUE: self._compfortable = self.MAX_VALUE else: self._compfortable = value @property def temperate(self) -> float: if self._locked_temperate >= 0: return self._locked_temperate return self._temperate @temperate.setter def temperate(self, value:float): if value<0: self._temperate = 0 elif value > self.MAX_VALUE: self._temperate = self.MAX_VALUE else: self._temperate = value @property def shy(self) -> float: if self._locked_shy >= 0: return self._locked_shy return self._shy @shy.setter def shy(self, value:float): if value<0: self._shy = 0 elif value > self.MAX_VALUE: self._shy = self.MAX_VALUE else: self._shy = value @property def excited(self) -> float: if self._locked_excited >= 0: return self._locked_excited return self._excited @excited.setter def excited(self, value:float): if value<0: self._excited = 0 elif value > self.MAX_VALUE: self._excited = self.MAX_VALUE else: self._excited = value @property def toLoud(self) -> float: if self._locked_toLoud >= 0: return self._locked_toLoud return self._toLoud @toLoud.setter def toLoud(self, value:float): if value<0: self._toLoud = 0 elif value > self.MAX_VALUE: self._toLoud = self.MAX_VALUE else: self._toLoud = value if value > 0: lastTimeToLoud = time.time() @property def toQuiet(self) -> float: if self._locked_toQuiet >= 0: return self._locked_toQuiet return self._toQuiet @toQuiet.setter def toQuiet(self, value:float): if value<0: self._toQuiet = 0 elif value > self.MAX_VALUE: self._toQuiet = self.MAX_VALUE else: self._toQuiet = value if value > 0: lastTimeToQuiet = time.time() @property def playful(self) -> float: if self._locked_playful >= 0: return self._locked_playful return self._playful @playful.setter def playful(self, value:float): if value<0: self._playful = 0 elif value > self.MAX_VALUE: self._playful = self.MAX_VALUE else: self._playful = value @property def naiv(self) -> float: if self._locked_naiv >= 0: return self._locked_naiv return self._naiv @naiv.setter def naiv(self, value:float): if value<0: self._naiv = 0 elif value > self.MAX_VALUE: self._naiv = self.MAX_VALUE else: self._naiv = value @property def freezy(self) -> float: if self._locked_freezy >= 0: return self._locked_freezy return self._freezy @freezy.setter def freezy(self, value:float): if value<0: self._freezy = 0 elif value > self.MAX_VALUE: self._freezy = self.MAX_VALUE else: self._freezy = value @property def hot(self) -> float: if self._locked_hot >= 0: return self._locked_hot return self._hot @hot.setter def hot(self, value:float): if value<0: self._hot = 0 elif value > self.MAX_VALUE: self._hot = self.MAX_VALUE else: self._hot = value @property def humanity(self) -> float: if self._locked_humanity >= 0: return self._locked_humanity return self._humanity @humanity.setter def humanity(self, value:float): if value<0: self._humanity = 0 elif value > self.MAX_VALUE: self._humanity = self.MAX_VALUE else: self._humanity = value @property def lonely(self) -> float: if self._locked_lonely >= 0: return self._locked_lonely return self._lonely @lonely.setter def lonely(self, value:float): if value<0: self._lonely = 0 elif value > self.MAX_VALUE: self._lonely = self.MAX_VALUE else: self._lonely = value if value > 0: self._lastTimeLonely = time.time() @property def soziality(self) -> float: if self._locked_soziality >= 0: return self._locked_soziality return self._soziality @soziality.setter def soziality(self, value:float): if value<0: self._soziality = 0 elif value > self.MAX_VALUE: self._soziality = self.MAX_VALUE else: self._soziality = value @property def lastTimeToQuiet(self): return self._lastTimeToQuiet @property def lastTimeToLoud(self): return self._lastTimeToLoud @property def lastTimeAngry(self): return self._lastTimeAngry @property def lastTimeLonely(self): return self._lastTimeLonely def set(self, name:str, val:float) -> bool: """ Setzt den Wert der entsprechenden Property """ n = name.lower() if n=="angry": self.angry = val elif n=="aroused": self.aroused = val elif n=="hungry": self.hungry = val elif n=="happyness": self.happyness = val elif n=="funny": self.funny = val elif n=="annoyed": self.annoyed = val elif n=="irritated": self.irritated = val elif n=="bored": self.bored = val elif n=="intelligent": self.intelligent = val elif n=="sleepy": self.sleepy = val elif n=="energy": self.energy = val elif n=="exhausted": self.exhausted = val elif n=="depressive": self.depressive = val elif n=="sad": self.sad = val elif n=="useless": self.useless = val elif n=="usefull": self.usefull = val elif n=="compfortable": self.compfortable = val elif n=="temperate": self.temperate = val elif n=="shy": self.shy = val elif n=="excited": self.excited = val elif n=="toloud": self.toLoud = val elif n=="toquiet": self.toQuiet = val elif n=="playful": self.playful = val elif n=="naiv": self.naiv = val elif n=="freezy": self.freezy = val elif n=="hot": self.hot = val elif n=="humanity": self.humanity = val elif n=="lonely": self.lonely = val elif n=="soziality": self.soziality = val else: return False return True def force(self, name:str, val:float) -> bool: """ Setzt im Gegenteil zu 'set()' den Wert der Variable. Es findet keine Überprüfung auf _locked, min und max statt """ n = name.lower() if n=="angry": self._angry = val elif n=="aroused": self._aroused = val elif n=="hungry": self._hungry = val elif n=="happyness": self._happyness = val elif n=="funny": self._funny = val elif n=="annoyed": self._annoyed = val elif n=="irritated": self._irritated = val elif n=="bored": self._bored = val elif n=="intelligent": self._intelligent = val elif n=="sleepy": self._sleepy = val elif n=="energy": self._energy = val elif n=="exhausted": self._exhausted = val elif n=="depressive": self._depressive = val elif n=="sad": self._sad = val elif n=="useless": self._useless = val elif n=="usefull": self._usefull = val elif n=="compfortable": self._compfortable = val elif n=="temperate": self._temperate = val elif n=="shy": self._shy = val elif n=="excited": self._excited = val elif n=="toloud": self._toLoud = val elif n=="toquiet": self._toQuiet = val elif n=="playful": self._playful = val elif n=="naiv": self._naiv = val elif n=="freezy": self._freezy = val elif n=="hot": self._hot = val elif n=="humanity": self._humanity = val elif n=="lonely": self._lonely = val elif n=="soziality": self._soziality = val else: return False return True def lock(self, name:str, val:float) -> bool: """ Setzt einen Lock Wert für die entsprechende Variable """ n = name.lower() if n=="angry": self._locked_angry = val elif n=="aroused": self._locked_aroused = val elif n=="hungry": self._locked_hungry = val elif n=="happyness": self._locked_happyness = val elif n=="funny": self._locked_funny = val elif n=="annoyed": self._locked_annoyed = val elif n=="irritated": self._locked_irritated = val elif n=="bored": self._locked_bored = val elif n=="intelligent": self._locked_intelligent = val elif n=="sleepy": self._locked_sleepy = val elif n=="energy": self._locked_energy = val elif n=="exhausted": self._locked_exhausted = val elif n=="depressive": self._locked_depressive = val elif n=="sad": self._locked_sad = val elif n=="useless": self._locked_useless = val elif n=="usefull": self._locked_usefull = val elif n=="compfortable": self._locked_compfortable = val elif n=="temperate": self._locked_temperate = val elif n=="shy": self._locked_shy = val elif n=="excited": self._locked_excited = val elif n=="toloud": self._locked_toLoud = val elif n=="toquiet": self._locked_toQuiet = val elif n=="playful": self._locked_playful = val elif n=="naiv": self._locked_naiv = val elif n=="freezy": self._locked_freezy = val elif n=="hot": self._locked_hot = val elif n=="humanity": self._locked_humanity = val elif n=="lonely": self._locked_lonely = val elif n=="soziality": self._locked_soziality = val else: return False return True def get(self, name:str) -> float: """ Gibt die entsprechende Einstellung zurück """ n = name.lower() if n=="angry": return self.angry elif n=="aroused": return self.aroused elif n=="hungry": return self.hungry elif n=="happyness": return self.happyness elif n=="funny": return self.funny elif n=="annoyed": return self.annoyed elif n=="irritated": return self.irritated elif n=="bored": return self.bored elif n=="intelligent": return self.intelligent elif n=="sleepy": return self.sleepy elif n=="energy": return self.energy elif n=="exhausted": return self.exhausted elif n=="depressive": return self.depressive elif n=="sad": return self.sad elif n=="useless": return self.useless elif n=="usefull": return self.usefull elif n=="compfortable": return self.compfortable elif n=="temperate": return self.temperate elif n=="shy": return self.shy elif n=="excited": return self.excited elif n=="toloud": return self.toLoud elif n=="toquiet": return self.toQuiet elif n=="playful": return self.playful elif n=="naiv": return self.naiv elif n=="freezy": return self.freezy elif n=="hot": return self.hot elif n=="humanity": return self.humanity elif n=="lonely": return self.lonely elif n=="soziality": return self.soziality else: return -1.0 def raw(self, name:str) -> float: """ Gibt im gegensatz zu 'get()' den Wert der Variable zurück Es findet keine Überprüfung auf _locked, min und max statt """ n = name.lower() if n=="angry": return self._angry elif n=="aroused": return self._aroused elif n=="hungry": return self._hungry elif n=="happyness": return self._happyness elif n=="funny": return self._funny elif n=="annoyed": return self._annoyed elif n=="irritated": return self._irritated elif n=="bored": return self._bored elif n=="intelligent": return self._intelligent elif n=="sleepy": return self._sleepy elif n=="energy": return self._energy elif n=="exhausted": return self._exhausted elif n=="depressive": return self._depressive elif n=="sad": return self._sad elif n=="useless": return self._useless elif n=="usefull": return self._usefull elif n=="compfortable": return self._compfortable elif n=="temperate": return self._temperate elif n=="shy": return self._shy elif n=="excited": return self._excited elif n=="toloud": return self._toLoud elif n=="toquiet": return self._toQuiet elif n=="playful": return self._playful elif n=="naiv": return self._naiv elif n=="freezy": return self._freezy elif n=="hot": return self._hot elif n=="humanity": return self._humanity elif n=="lonely": return self._lonely elif n=="soziality": return self._soziality else: return -1.0 def Save(self): self.textconfig.setValue({ "max": self.MAX_VALUE, "angry": self._angry, "aroused": self.aroused, "hungry": self.hungry, "happyness": self._happyness, "funny": self._funny, "annoyed":self._annoyed, "irritated": self.irritated, "bored": self.bored, "intelligent": self.intelligent, "sleepy": self.sleepy, "energy": self.energy, "exhausted": self.exhausted, "depressive": self.depressive, "sad": self.sad, "useless": self.useless, "usefull": self.usefull, "compfortable": self.compfortable, "temperate": self.temperate, "shy": self.shy, "excited": self.excited, "toLoud": self.toLoud, "toQuiet": self.toQuiet, "playful": self.playful, "naiv": self.naiv, "freezy": self.freezy, "hot": self.hot, "humanity": self.humanity, "lonely": self.lonely, "soziality": self.soziality, "lastTimeToLoud": self.lastTimeToLoud, "lastTimeToQuiet": self.lastTimeToQuiet, "lastTimeAngry": self.lastTimeAngry, "lastTimeLonely": self.lastTimeLonely, "lastUpdate": self.lastUpdate }) self.textconfig.Save() def Save(self, file = "stats.txt"): """ Speichert die Daten in einer TextConfig """ if os.path.isfile(file): os.remove(file) with open(file, 'w') as f: f.writelines([ "max "+str(self.MAX_VALUE)+"\n", "angry "+str(self.angry)+"\n", "aroused "+str(self.aroused)+"\n", "hungry "+str(self.hungry)+"\n", "happyness "+str(self.happyness)+"\n", "funny "+str(self.funny)+"\n", "annoyed "+str(self.annoyed)+"\n", "irritated "+str(self.irritated)+"\n", "bored "+str(self.bored)+"\n", "intelligent "+str(self.intelligent)+"\n", "sleepy "+str(self.sleepy)+"\n", "energy "+str(self.energy)+"\n", "exhausted "+str(self.exhausted)+"\n", "depressive "+str(self.depressive)+"\n", "sad "+str(self.sad)+"\n", "useless "+str(self.useless)+"\n", "usefull "+str(self.usefull)+"\n", "compfortable "+str(self.compfortable)+"\n", "temperate "+str(self.temperate)+"\n", "shy "+str(self.shy)+"\n", "excited "+str(self.excited)+"\n", "toLoud "+str(self.toLoud)+"\n", "toQuiet "+str(self.toQuiet)+"\n", "playful "+str(self.playful)+"\n", "naiv "+str(self.naiv)+"\n", "freezy "+str(self.freezy)+"\n", "hot "+str(self.hot)+"\n", "humanity "+str(self.humanity)+"\n", "lonely "+str(self.lonely)+"\n", "soziality "+str(self.soziality)+"\n", "\n", "lastTimeToLoud "+str(self.lastTimeToLoud)+"\n", "lastTimeToQuiet "+str(self.lastTimeToQuiet)+"\n", "lastTimeAngry "+str(self.lastTimeAngry)+"\n", "lastTimeLonely "+str(self.lastTimeLonely)+"\n", "lastUpdate "+str(self.lastUpdate)+"\n" ]) def Load(self, file = "stats.txt"): """ Läd die Daten aus einer TextConfig """ if os.path.isfile(file) == False: return False #lines=[] count=0 max = self.MAX_VALUE #lines = self._loadTextConfig("stats.txt") self.textconfig.Load() lines = self.textconfig.getItems() count = self.textconfig.count if count>0: for c in range(0, count): itm = lines[c] if itm["var"]=="angry": self.angry = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="aroused": self.aroused = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="hungry": self.hungry = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="happyness": self.happyness = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="funny": self.funny = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="annoyed": self.annoyed = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="irritated": self.irritated = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="bored": self.bored = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="intelligent": self.intelligent = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="sleepy": self.sleepy = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="energy": self.energy = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="exhausted": self.exhausted = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="depressive": self.depressive = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="sad": self.sad = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="useless": self.useless = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="usefull": self.usefull = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="compfortable": self.compfortable = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="temperate": self.temperate = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="shy": self.shy = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="excited": self.excited = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="toLoud": self.toLoud = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="toQuiet": self.toQuiet = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="playful": self.playful = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="naiv": self.naiv = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="freezy": self.freezy = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="hot": self.hot = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="humanity": self.humanity = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="lonely": self.lonely = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="soziality": self.soziality = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="lastTimeToLoud": self._lastTimeToLoud = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="lastTimeToQuiet": self._lastTimeToQuiet = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="lastTimeAngry": self._lastTimeAngry = float(itm["val"]) / max * self.MAX_VALUE elif itm["var"]=="lastTimeLonely": self._lastTimeLonely = float(itm["val"]) / max * self.MAX_VALUE self.lastUpdate = time.time return True return False def __del__(self): print("Del DeviceStats") self.Thread_Save.cancel() del self._angry del self._annoyed del self._aroused del self._bored del self._compfortable del self._depressive del self._energy del self._excited del self._exhausted del self._freezy del self._funny del self._happyness del self._hot del self._humanity del self._hungry del self._intelligent del self._irritated del self._lastTimeToLoud del self._lastTimeToQuiet del self._lonely del self._naiv del self._playful del self._sad del self._shy del self._sleepy del self._soziality del self._temperate del self._toLoud del self._toQuiet del self._usefull del self._useless del self._locked_angry del self._locked_annoyed del self._locked_aroused del self._locked_bored del self._locked_compfortable del self._locked_depressive del self._locked_energy del self._locked_excited del self._locked_exhausted del self._locked_freezy del self._locked_funny del self._locked_happyness del self._locked_hot del self._locked_humanity del self._locked_hungry del self._locked_intelligent del self._locked_irritated del self._locked_lastTimeToLoud del self._locked_lastTimeToQuiet del self._locked_lonely del self._locked_naiv del self._locked_playful del self._locked_sad del self._locked_shy del self._locked_sleepy del self._locked_soziality del self._locked_temperate del self._locked_toLoud del self._locked_toQuiet del self._locked_usefull del self._locked_useless del self.Thread_Save def getJson(self): return { "angry": self.angry, "aroused": self.aroused, "hungry": self.hungry, "happyness": self.happyness, "funny": self.funny, "annoyed": self.annoyed, "irritated": self.irritated, "bored": self.bored, "intelligent": self.intelligent, "sleepy": self.sleepy, "energy": self.energy, "exhausted": self.exhausted, "depressive": self.depressive, "sad": self.sad, "useless": self.useless, "usefull": self.usefull, "compfortable": self.compfortable, "temperate": self.temperate, "shy": self.shy, "excited": self.excited, "toLoud": self.toLoud, "toQuiet": self.toQuiet, "playful": self.playful, "naiv": self.naiv, "freezy": self.freezy, "hot": self.hot, "humanity": self.humanity, "lonely": self.lonely, "soziality": self.soziality, "lastTimeToLoud":self.lastTimeToLoud, "lastTimeToQuiet":self.lastTimeToQuiet, "lastTimeAngry":self.lastTimeAngry, "lastTimeLonely":self.lastTimeLonely, "lastUpdate":self.lastUpdate }