def __init__(self, sym, s_date, e_date, path=None): self.symbol = sym self.d_data = {} self.log = Logging() if not path: s = Symbol(sym, s_date, e_date) self.d_data[s.name] = s
def __init__(self): self.openhab = pf_openhab() self.logging = Logging() self.name = "widget_handler" PATH = os.path.dirname(os.path.abspath(__file__)) self.template_dir = PATH + "/../templates/" self.imported_widget_classes = {}
class LocationManager(Singleton): def __init__(self): try: if self.doneloading: pass except: self.name = "Wunderground" self.doneloading = True self.settings_c = Settings() self.logging = Logging() try: self.apikey = self.settings_c.get_setting("wunderground", "apikey") self.updateperiod = int(self.settings_c.get_setting("wunderground", "updateperiod")) self.language = self.settings_c.get_setting("wunderground", "language") except Exception as e: self.logging.error("Check your wunderground settings: " + str(e), location="wunderground") self.locations = {} def GetLocation(self, location, update = False): if not update: period = self.updateperiod else: period = update if location in self.locations.keys(): return self.locations[location] else: self.locations[location] = ForecastData(self.apikey, location, update = period, language = self.language) return self.locations[location]
def __init__(self): try: if self.loadingdone: pass except: self.loadingdone = True self.openhab = pf_openhab() self.name = "state_handler" self.database = main_database() self.setting_handler = setting_handler() self.message_handler = message_handler() self.logging = Logging() settings_c = Settings() self.host = settings_c.get_setting("main", "hostname") self.port = settings_c.get_setting("main", "port") self.http = urllib3.PoolManager() self.timeouts = {} self.update_timeout("screensaver", 60) self.update_timeout("message", -1) self.screentrigger = 0 self.screen_state = True try: self.im_size = settings_c.get_setting("album", "image_size") self.album_url = settings_c.get_setting("album", "random_picture_url") except Exception as e: self.logging.error("Invalid album settings: " + str(e), location=self.name) self.album_url = "none" try: self.album_info_url = settings_c.get_setting("album", "picture_info_url") if self.album_info_url == None: raise Exception("No data") except: self.logging.warn("No album info url", location=self.name) self.album_info_url = "none"
def __init__(self): try: if self.loadingdone: pass except: self.loadingdone = True self.started = True self.logging = Logging() self.name = "mqtt" self.settings_c = Settings() try: self.server = self.settings_c.get_setting("mqtt", "server") self.port = int(self.settings_c.get_setting("mqtt", "port")) self.timeout = int( self.settings_c.get_setting("mqtt", "timeout")) except Exception as e: self.logging.error("Configuration not correct, check settings", location=self.name) self.listeners = [] self.client = mqtt_cl.Client() self.client.on_connect = self.on_connect self.client.on_message = self.on_message self.client.connect(self.server, self.port, self.timeout) self.client.loop_start() self.logging.info("Connected to mqtt broker at: " + self.server, location=self.name)
def __init__(self): try: if self.loadingdone: pass except: self.loadingdone = True self.logging = Logging() self.scheduled_tasks = [] self.add_task(self.logging, "log_rotate", (time.time() + 4 * 60 * 60), period=24 * 60 * 60)
def _backup_prev_files(self, current_filepath): """ Moves the previous files to the backup directory. If the backup directory was not specified in the initializer it does nothing. """ if self.backup_dir and not os.path.exists(current_filepath): # new file will be created # move all current files inside the store dir to the backup dir for filename in os.listdir(self.data_dir): shutil.move(src=os.path.join(self.data_dir, filename), dst=os.path.join(self.backup_dir, filename)) Logging.info("moved file %s to the backup " "directory" % filename)
def _receive_and_log(self, data_receiver, connection) -> bytes: """ Receives an answer and logs it, before returning, by pre-pending the tag 'CONFIGURATION'. """ answer = data_receiver.raw_receive(connection, timeout=1) try: decoded_answer = answer.decode() Logging.info("CONFIGURATION:" + decoded_answer) except UnicodeDecodeError: Logging.info("CONFIGURATION: answer is in binary") return answer
def __init__(self): try: if self.doneloading: pass except: self.name = "Wunderground" self.doneloading = True self.settings_c = Settings() self.logging = Logging() try: self.apikey = self.settings_c.get_setting("wunderground", "apikey") self.updateperiod = int(self.settings_c.get_setting("wunderground", "updateperiod")) self.language = self.settings_c.get_setting("wunderground", "language") except Exception as e: self.logging.error("Check your wunderground settings: " + str(e), location="wunderground") self.locations = {}
def __init__(self): self.openhab = pf_openhab() self.name = "page_handler" self.database = main_database() self.setting_handler = setting_handler() self.message_handler = message_handler() self.widgets_handler = widgets_handler() self.state_handler = state_handler() self.logging = Logging() settings_c = Settings() self.host = settings_c.get_setting("main", "hostname") self.port = settings_c.get_setting("main", "port") self.enable_screen_control = settings_c.get_setting( "main", "enable_screen_control") self.openhab_host = settings_c.get_setting("main", "openhab_ip") self.openhab_port = settings_c.get_setting("main", "openhab_port")
class main_database(Singleton): def __init__(self): try: if self.loadingdone: pass except: self.loadingdone = True settings_c = settings.Settings() self.logging = Logging() self.data_location = settings_c.get_setting("data", "location") PATH = os.path.dirname(os.path.abspath(__file__)) self.datafile = PATH + "/../" + self.data_location + "/main_db.pckl" my_file = Path(self.datafile) if not my_file.is_file(): self.logging.write("Creating database", level=1) self.data = { "last_saved": time.time(), "settings": {}, "messages": [] } self.data["settings"]["main_page"] = 0 self.data["settings"]["items_per_page"] = 0 self.data["settings"]["sensors_per_page"] = 0 self.data["settings"]["screen_timeout"] = 1 self.data["settings"]["album_timeout"] = 0 self.data["settings"]["message_timeout"] = 0 self.data["settings"]["mouse"] = 0 self.data["settings"]["screen"] = 0 self.data["settings"]["frame"] = 0 self.data["settings"]["frame_info"] = 0 self.data["settings"]["frame_td"] = 0 self.data["settings"]["frame_display_time"] = 0 self.data["settings"]["toast_timeout"] = 0 self.data["settings"]["clock_type"] = 0 self.data["settings"]["chart_period"] = 0 self.data["settings"]["first_run_messages_flag"] = False self.data["messages"] = [] self.save_datafile() self.data = self.load_datafile() def load_datafile(self): return pickle.load(open(self.datafile, "rb")) def save_datafile(self): self.data["last_saved"] = time.time() self.logging.write("Saving database", level=2) pickle.dump(self.data, open(self.datafile, "wb"))
def __init__(self, params={}, debug=0): self.parameters = params self.debug = 0 self.num_params = len(params) self.info = {} self.results = {} self.logger = Logging() self.processor = Processor()
def __init__(self, api_key, location, update = 15, language = "EN", fetch = False): args = {} args["apikey"] = api_key args["location"] = location args["language"] = language args["fetch"] = -1 args["sub"] = "fetch" self.args = args self.data_update = 0 self.update_time = update*60 self.logging = Logging() self.name = "Wunderground" if fetch: self.fetch_data()
def __init__(self): try: if self.loadingdone: pass except: self.loadingdone = True self.logging = Logging() settings_c = Settings() self.openhab_server = settings_c.get_setting("main", "openhab_ip") self.openhab_port = settings_c.get_setting("main", "openhab_port") self.host = settings_c.get_setting("main", "hostname") self.port = settings_c.get_setting("main", "port") self.sitemap_name = settings_c.get_setting("main", "sitemap") self.sitemap_name = "main" if self.sitemap_name == None else self.sitemap_name self.resize_icons = settings_c.get_setting("main", "resize_icons") self.iconh = 64 self.iconw = 64 self.name = "pf_openhab" self.http = urllib3.PoolManager()
def __init__(self): self.openhab = pf_openhab() self.name = "item_handler" self.database = main_database() self.setting_handler = setting_handler() self.page_handler = page_handler() self.message_handler = message_handler() self.logging = Logging() settings_c = Settings() self.host = settings_c.get_setting("main", "hostname") self.port = settings_c.get_setting("main", "port") self.enable_clock = settings_c.get_setting("main", "enable_clock") self.enable_album = settings_c.get_setting("main", "enable_album") self.openhab_server = settings_c.get_setting("main", "openhab_ip") self.openhab_port = settings_c.get_setting("main", "openhab_port") self.http = urllib3.PoolManager() self.timeout_message_popup = 0 self.saved_chart_periods = {} self.screentrigger = 0
def __init__(self, symbol, s_date=None, e_date=None): self.log=Logging() self.name=symbol self.created=datetime.datetime.utcnow() self.log.info("created {}".format(self.name)) try: self.share=Share(symbol) except: self.log.error("platform is offline or not connecting") if s_date and e_date: self.begin=s_date self.end=e_date try: self.share=Share(symbol) self.data=self.share.get_historical(self.begin, self.end) self.log.refresh("{} data collected".format(self.name)) except: self.log.error("platform is offline or not connecting")
def __init__(self): try: if self.loadingdone: pass except: self.loadingdone = True self.database = main_database() self.popupflag = False self.popupactive = False self.logging = Logging() self.setting_handler = setting_handler() self.setting_popup_timeout = self.setting_handler.get_setting( "message_timeout") self.page_handler = page_handler.page_handler() self.toast_flag = False self.toast_db = [] self.toast_message = "none" self.toast_sender = "none" self.toast_received = 0 self.mqtt = mqtt() settings_c = Settings() self.mqtt_topics = settings_c.get_setting("messaging", "mqtt_topics").split(",") for topic in self.mqtt_topics: self.mqtt.add_listener(topic, self, "received_mqtt_message") ##send information messages on first run if not self.database.data["settings"]["first_run_messages_flag"]: self.database.data["settings"][ "first_run_messages_flag"] = True message = "On a black screen, clock or photoframe, click on the bottom left corner to return to the main screen. " self.database.data["messages"].append([ time.time(), "HABframe", "Return from screensaver", message, False ]) message = "Thank you for using HABframe!" self.database.data["messages"].append([ time.time(), "HABframe", "welcome message", message, False ]) self.database.save_datafile() self.del_popup_flag()
def store(self, data: str): """ Stores the data line according to the implementation. """ if not data: # ignore empty message return # the datetime passed to teh adjust_data() and generate_filename() # methods must be the same to avoid incoherency current_datetime = datetime.now() data = self._adjust_data(data, current_datetime) out_filename = self._generate_filename(data, current_datetime) out_filepath = os.path.join(self.data_dir, out_filename) # this must be called before dumping the data to the file self._backup_prev_files(out_filepath) with open(out_filepath, "a") as out_file: out_file.write(data) out_file.write('\n') Logging.info("stored new line in %s" % out_filename)
def load(self): """ Loads the configuration file. Raises LoadError if the config file is corrupted. """ log_file = None # will store the loaded path to the log file with open(self.config_file) as file: for i, line in enumerate(file): try: line = line.rstrip('\n\r') key, value = line.split(':') except ValueError: raise LoadError("error in line %d" % i) if key == 'log': log_file = value continue self._add_param(key, value) Logging.setup(log_file) self._finished_loading()
class Loader(): def __init__(self, sym, s_date, e_date, path=None): self.symbol = sym self.d_data = {} self.log = Logging() if not path: s = Symbol(sym, s_date, e_date) self.d_data[s.name] = s def get_data(self, name=None): if not name: return self.d_data elif name in self.d_data: return self.d_data[name] else: self.log.error("{} not found in loader list".format(name)) def to_csv(self, path=""): return 0 def to_pandas(self, symbol): df_s = pd.DataFrame(symbol.data) return df_s def run_all_methods(self, symbol): return 0 def data_to_csv(self, symbol): symdata = self.get_data(symbol) df_data = self.to_pandas(symdata) df_data['Date'] = pd.to_datetime(df_data['Date']) #df_data['Adj_Close'] = df_data.apply(pd.to_numeric) try: df_data = df_data.set_index('Date').sort_index() return df_data except: self.log.error("unable to format {} to csv".format(symbol))
def run(self, decoder, data_handlers, connection_handlers): """ Runs the application after loading the configuration. If this method is called before loading the configuration a ValueError is raised. :param decoder: decoder to be used :param data_handlers: iterable with all the data handlers to register with the data receiver. :param connection_handlers: iterable with all the connection handlers to register with the data receiver. """ if not self._config: raise ValueError("can not run before loading the configuration") # make terminate signals raise keyboard interrupts signal.signal(signal.SIGTERM, raise_keyboard_interrupt) receiver = DataReceiver((self._config.ip_address, self._config.port), decoder) # register all data handlers for handler in data_handlers: receiver.register_data_handler(handler) # register all connection handlers for handler in connection_handlers: receiver.register_connection_handler(handler) try: Logging.info("Started") receiver.receive_forever() except KeyboardInterrupt: # user pressed Ctrl-C to close the program Logging.info("Closing as requested by user...") except BaseException: Logging.exception("Program will closed due to unexpected error...") Logging.info("Closed")
def main(): if len(sys.argv) != 2: return fileName = sys.argv[1] file = None try: # ファイルから問題の条件などを取得 file = open(fileName, "r") limits = __getMoveLimit(file.readline()) numBoard = __getNumBoard(file.readline()) Logging.debug('Start solving ' + str(numBoard) + ' problems') # 問題を解くループ noProblem = 1 numSolved = 0 for row in file: Logging.debug('Start solving No.%d problem' % noProblem) solve = solve_exercises(row, limits) if limits.isOver(): break # 問題の回答を出力 if str(solve) == '': Logging.debug('Failed!') else: Logging.debug('Success!') numSolved += 1 Logging.output(solve) noProblem += 1 Logging.debug('Solving ' + str(numBoard) + ' problems finished -- ' + str(numSolved)) finally: if file != None: file.close()
class task_scheduler(Singleton): def __init__(self): try: if self.loadingdone: pass except: self.loadingdone = True self.logging = Logging() self.scheduled_tasks = [] self.add_task(self.logging, "log_rotate", (time.time() + 4 * 60 * 60), period=24 * 60 * 60) def check_tasks(self): self.logging.write("Checking tasks, running scheduler", level="TRACE", location="tasks") cur_time = time.time() length = len(self.scheduled_tasks) for h in range(length): try: i = length - h - 1 ##reverse iteration task = self.scheduled_tasks[i] if cur_time > task[2]: ##task[2] == next_time class_name = task[0].get_name() try: item_name = task[0].get_item().get_name() self.logging.write("Executing task: " + class_name + "." + task[1] + " for item: " + item_name, level='info', location="tasks") except: self.logging.write("Executing task: " + class_name + "." + task[1], level='info', location="tasks") try: getattr(task[0], task[1])() except Exception as e: self.logging.write("Processing task failed: " + str(e), level="error", location="tasks") self.logging.write("Could not execute task: " + class_name + "." + task[1], level="error", location="tasks") if task[3] == 0 and task[4] == 0: del self.scheduled_tasks[i] elif task[3] != 0: task[3] = task[3] - 1 ##repeat n times task[2] = cur_time + task[ 4] ## add period for next time timestamp = datetime.datetime.fromtimestamp( task[2]).strftime('%c') self.logging.write("Repeating task: " + class_name + "." + task[1] + " scheduled at " + str(timestamp), level=2, location="tasks") elif task[4] != 0: if type(task[4]) == str: task[2] = self.calculatenexttime(task[2], task[4]) else: task[2] = cur_time + task[ 4] ## add period for next time timestamp = datetime.datetime.fromtimestamp( task[2]).strftime('%c') self.logging.write("Repeating task: " + class_name + "." + task[1] + " scheduled at " + str(timestamp), level=4, location="tasks") else: ##delete task anyway del self.scheduled_tasks[i] gc.collect() except Exception as e: self.logging.write("Could not handle task in list: " + str(e), level="error", location="tasks") def add_task(self, class_item, functionname, next_time, repeat=0, period=0): self.scheduled_tasks.append( [class_item, functionname, next_time, repeat, period]) task = self.scheduled_tasks[-1] class_name = task[0].get_name() if type(next_time) == str: next_time = self.calculatetimestamp(next_time) timestamp = datetime.datetime.fromtimestamp(next_time).strftime('%c') self.logging.write("Added task: " + class_name + "." + task[1] + " scheduled at " + str(timestamp), level='info', location="tasks") def list_tasks(self): self.logging.write("Listing tasks: " + str(len(self.scheduled_tasks)) + " tasks active", level='info', location="tasks") tasks = [] for i in range(len(self.scheduled_tasks)): try: task = self.scheduled_tasks[i] class_name = task[0].get_name() timestamp = datetime.datetime.fromtimestamp( task[2]).strftime('%c') try: item_name = task[0].get_item().get_name() if len(item_name) > 20: item_name = item_name[0:19] task_string = (class_name + "." + task[1]).ljust( 25) + " for item: " + (item_name).ljust( 20) + " scheduled at: " + str(timestamp) tasks.append([ class_name + "." + task[1], str(timestamp), item_name ]) except: task_string = (class_name + "." + task[1]).ljust( 56) + " scheduled at: " + str(timestamp) tasks.append([class_name + "." + task[1], str(timestamp)]) self.logging.write( ("Task " + str(i + 1) + ": ").ljust(9) + task_string, level='debug', location="tasks") except: pass return tasks def delete_tasks(self): self.logging.write("Deleting tasks: " + str(len(self.scheduled_tasks)) + " tasks active", level="warning", location="tasks") self.scheduled_tasks = [] self.add_task(self.logging, "log_rotate", (time.time() + 4 * 60 * 60), period=24 * 60 * 60) def calculatetimestamp(self, next_time): date = datetime.datetime.strptime(next_time, "%c") return int(date.strftime("%s")) def calculatenexttime(self, now, nexttime): nexttime = str(nexttime).lower() date = datetime.datetime.fromtimestamp(now) if "year" in nexttime: nd = date + datetime.timedelta( years=int(nexttime[0:nexttime.find(" ")])) if "mon" in nexttime: nd = date + datetime.timedelta( months=int(nexttime[0:nexttime.find(" ")])) if "week" in nexttime: nd = date + datetime.timedelta( weeks=int(nexttime[0:nexttime.find(" ")])) if "day" in nexttime: nd = date + datetime.timedelta( days=int(nexttime[0:nexttime.find(" ")])) if "hour" in nexttime: nd = date + datetime.timedelta( hours=int(nexttime[0:nexttime.find(" ")])) if "min" in nexttime: nd = date + datetime.timedelta( minutes=int(nexttime[0:nexttime.find(" ")])) return int(nd.strftime("%s")) def getHourMinuteTomorrow(self, hour, minute, days=1): dtnow = datetime.datetime.now() dt6 = None # If today's hour is < 6 AM if dtnow.hour < hour - 1: dt6 = datetime.datetime(dtnow.year, dtnow.month, dtnow.day, hour, minute, 0, 0) # If today is past 6 AM, increment date by 1 day else: day = datetime.timedelta(days=days) tomorrow = dtnow + day dt6 = datetime.datetime(tomorrow.year, tomorrow.month, tomorrow.day, hour, minute, 0, 0) timestamp = time.mktime(dt6.timetuple()) return timestamp
from flask_cors import CORS PATH = os.path.dirname(os.path.abspath(__file__)) sys.path.append(PATH + "/classes") sys.path.append(PATH + "/classes/general") sys.path.append(PATH + "/data") from HABframe_main import habframe_main from settings import Settings from logger import Logging ##load settings settings_class = Settings() port = settings_class.get_setting("main", "port") main = habframe_main() logging = Logging() app = Flask("HABFrame", template_folder=PATH + '/templates', static_folder=PATH + "/static") CORS(app) @app.route('/', defaults={'path': ''}, methods=['GET', 'POST']) @app.route('/<path:path>', methods=['GET', 'POST']) def catch_all(path): env = get_env(request) key = get_key(env) response = main.process_request(env) return format_response(response)
def main(): if len(sys.argv) != 2: return fileName = sys.argv[1] file = None try: # ファイルから問題の条件などを取得 file = open(fileName, "r") limits = __getMoveLimit(file.readline()) numBoard = __getNumBoard(file.readline()) Logging.debug('Start solving ' + str(numBoard) + ' problems') # 問題を解くループ noProblem = 1 numSolved = 0 for row in file: Logging.debug('Start solving No.%d problem' % noProblem) solve = solve_exercises(row, limits) if limits.isOver(): break # 問題の回答を出力 if str(solve) == '': Logging.debug('Failed!') else: Logging.debug('Success!') numSolved += 1 Logging.output(solve) noProblem += 1 Logging.debug('Solving ' + str(numBoard) + ' problems finished -- ' + str(numSolved)) finally: if file != None: file.close()
class Symbol(object): def __init__(self, symbol, s_date=None, e_date=None): self.log=Logging() self.name=symbol self.created=datetime.datetime.utcnow() self.log.info("created {}".format(self.name)) try: self.share=Share(symbol) except: self.log.error("platform is offline or not connecting") if s_date and e_date: self.begin=s_date self.end=e_date try: self.share=Share(symbol) self.data=self.share.get_historical(self.begin, self.end) self.log.refresh("{} data collected".format(self.name)) except: self.log.error("platform is offline or not connecting") def refresh_data(self, s_date=None, e_date=None): if s_date and e_date: try: share=Share(self.name) self.begin=s_date self.end=e_date share.get_historical(s_date, e_date) self.log.refresh("{} data collected".format(self.name)) except: self.log.error("platform is offline or not connecting") def market_cap(self): try: self.market_cap = self.share.get_market_cap() self.log.info("{} market cap refreshed".format(self.name)) except: self.log.error("platform is offline or not connecting") def earnings_per_share(self): try: self.eps = self.share.get_earnings_share() self.log.info("{} eps refreshed".format(self.name)) except: self.log.error("platform is offline or not connecting") def moving_average_50(self): try: self.moving_average_50 = self.share.get_50day_moving_average() self.log.info("{} 50 day moving ave refreshed".format(self.name)) except: self.log.error("platform is offline or not connecting") #implement TODO def nday_moving_average(self, n): try: self.moving_average_n = None self.log.info("{} {} day moving ave refreshed".format(self.name, n)) except: self.log.error("platform is offline or not connecting") def price_earnings_ratio(self): try: self.price_to_earnings = self.share.get_price_earnings_ratio() self.log.info("{} price to earnings refreshed".format(self.name)) except: self.log.error("platform is offline or not connecting") def book_value(self): try: self.book = self.share.get_price_book() self.log.info("{} book value refreshed".format(self.name)) except: self.log.error("platform is offline or not connecting") def year_high(self): try: self.year_high = self.share.get_change_from_year_high() self.log.info("{} year high change refreshed".format(self.name)) except: self.log.error("platform is offline or not connecting") def year_low(self): try: self.year_low = self.share.get_change_from_year_low() self.log.info("{} year low change refreshed".format(self.name)) except: self.log.error("platform is offline or not connecting") def target_price(self): try: self.year_target = self.share.get_change_from_year_high() self.log.info("{} year target change refreshed".format(self.name)) except: self.log.error("platform is offline or not connecting") def year_range(self): try: self.year_range = self.share.get_change_from_year_high() self.log.info("{} year range change refreshed".format(self.name)) except: self.log.error("platform is offline or not connecting")
def main(FLAGS): logger = Logging() nn = network.Network() settings = Parameters() greed = Epsilon_Greedy() replay = Replay() #X_state, actor_q_values, actor_vars, critic_..., copy_ops, copy_critic... X_state = tf.placeholder(tf.float32, shape=[ None, settings.input_height, settings.input_width, settings.input_channels ]) #setup both an actor and a 'critic' network -- methodology to predict and play as cost function (y-y') actor_q_values, actor_vars = nn.q_network(X_state, name='q_networks/actor') critic_q_values, critic_vars = nn.q_network(X_state, name='q_networks/critic') copy_ops = [ actor_var.assign(critic_vars[var_name]) for var_name, actor_var in actor_vars.items() ] copy_critic_to_actor = tf.group(*copy_ops) #x_action, q_value X_action = tf.placeholder(tf.int32, shape=[None]) q_value = tf.reduce_sum(critic_q_values * tf.one_hot(X_action, settings.n_outputs), axis=1, keep_dims=True) #y, cost, globalstep, optimzier, training_op, init, saver y = tf.placeholder(tf.float32, shape=[None, 1]) cost = tf.reduce_mean(tf.square(y - q_value)) global_step = tf.Variable(0, trainable=False, name='global_step') optimizer = tf.train.AdamOptimizer(settings.learning_rate) training_op = optimizer.minimize(cost, global_step=global_step) init = tf.global_variables_initializer() saver = tf.train.Saver() logger.info('finished setup') #with tf.Session as sess: ********put this in driver with tf.Session() as sess: # check for saved session if os.path.isfile(settings.checkpoint_path): save.restore(sess, settings.checkpoint_path) else: init.run() while True: step = global_step.eval() if step >= settings.n_steps: break settings.iteration += 1 if settings.done: logger.info('uh oh hit the done!') settings.obs = settings.env.reset() #manufactured 'fast forward' for skip in range(settings.skip_start): obs, reward, settings.done, info = settings.env.step(0) state = network.preprocess_observation(obs, settings.mspacmancolor) #print(reward, settings.done, info) # vector of q values q_values = actor_q_values.eval(feed_dict={X_state: [state]}) # epsilon greedy method to retrieve next action action = greed.e_greedy(q_values, step) # take this action obs, reward, settings.done, info = settings.env.step(action) next_state = network.preprocess_observation( obs, settings.mspacmancolor) # record these actions in replay memory replay.replay_memory.append( (state, action, reward, next_state, 1.0 - settings.done)) state = next_state if settings.iteration < settings.training_start or settings.iteration % settings.training_interval != 0: continue X_state_val, X_action_val, rewards, X_next_state_val, continues = ( replay.sample_memories(settings.batch_size)) next_q_values = actor_q_values.eval( feed_dict={X_state: X_next_state_val}) max_next_q_values = np.max(next_q_values, axis=1, keepdims=True) y_val = rewards + continues * settings.discount_rate * max_next_q_values training_op.run(feed_dict={ X_state: X_state_val, X_action: X_action_val, y: y_val }) if step % settings.copy_steps == 0: #logger.info('copy to critic') copy_critic_to_actor.run() if step % settings.save_steps == 0: logger.info('saving settings of iteration %g' % (settings.iteration)) logger.results('action, reward, done, info: ') print(action, reward, settings.done, info) saver.save(sess, settings.checkpoint_path) logger.info('saving settings of iteration %g' % (settings.iteration)) logger.results('action, reward, done, info:') print(action, reward, settings.done, info) logger.info('program finished')
def __init__(self): try: if self.loadingdone: pass except: self.loadingdone = True self.name = "setting_handler" self.database = main_database() self.logging = Logging() self.http = urllib3.PoolManager() self.settings = {} #self.settings["main_page"] = ["Front page", ["OpenHAB", "Weather"]] self.settings["screen_timeout"] = [ "Screen timeout (min)", [1, 3, 5, 10, 15, 30, "off"] ] self.settings["album_timeout"] = [ "Album timeout (hr)", [1, 3, 5, 10, 15, 30] ] self.settings["message_timeout"] = [ "Message timeout (s)", [10, 30, 60, 120, 300] ] self.settings["toast_timeout"] = [ "Info timeout (s)", [7, 10, 15, 20, 30] ] self.settings["mouse"] = ["Mouse button", ["on", "off"]] self.settings["items_per_page"] = [ "Number of items per page", [6, 8, 9, 12] ] self.settings["sensors_per_page"] = [ "Number of sensor items per page", [6, 8, 9, 12] ] self.settings["screen"] = ["Screen", ["on", "off"]] self.settings["frame"] = ["Photo / Clock", ["photoframe", "clock"]] self.settings["frame_info"] = [ "Frame Info", ["none", "load", "album", "both"] ] self.settings["frame_td"] = [ "Frame Time/Date", ["none", "clock", "date", "both"] ] self.settings["frame_display_time"] = [ "Photo display time", ["short", "medium", "long", "extra long"] ] self.settings["clock_type"] = ["Clock type", ["digital", "analog"]] self.settings["chart_period"] = [ "Default chart period", ["auto", "4 hours", "12 hours", "1 day", "3 days", "1 week"] ] for key, item in self.settings.items(): value = self.database.data["settings"][key] self.settings[key].append(int(value)) settings_c = Settings() self.enable_screen_control = settings_c.get_setting( "main", "enable_screen_control") try: topics = settings_c.get_setting( "main", "mqtt_control_topic").split(",") self.mqtt = mqtt() for topic in topics: self.mqtt.add_listener(topic, self, "received_mqtt_message") except: self.logging.warn("Mqtt not configured for handling settings", location="settings_handler") if self.enable_screen_control in ["pi", "black"]: pass elif self.enable_screen_control == "url": try: self.screen_control_on_url = settings_c.get_setting( "main", "screen_on_url") self.screen_control_off_url = settings_c.get_setting( "main", "screen_off_url") self.settings["screen_control_on_url"] = [ 0, 0, self.screen_control_on_url ] self.settings["screen_control_off_url"] = [ 0, 0, self.screen_control_off_url ] except: self.logging.error( "Add settings 'screen_on_url' and 'screen_off_url' for external url screen control", location="settings_handler") self.enable_screen_control = "black" elif self.enable_screen_control == "cmd": try: self.screen_control_on_cmd = settings_c.get_setting( "main", "screen_on_cmd") self.screen_control_off_cmd = settings_c.get_setting( "main", "screen_off_cmd") self.settings["screen_control_on_cmd"] = [ 0, 0, self.screen_control_on_cmd ] self.settings["screen_control_off_cmd"] = [ 0, 0, self.screen_control_off_cmd ] except: self.logging.error( "Add settings 'screen_on_cmd' and 'screen_off_cmd' for external command screen control", location="settings_handler") self.enable_screen_control = "black" elif self.enable_screen_control != "off": self.logging.error( "Incorrect screen control enable settings, screen control is off", location="settings_handler") self.enable_screen_control = "off" self.settings["main_enable_clock"] = [ 0, 0, settings_c.get_setting("main", "enable_clock") ] self.settings["main_enable_album"] = [ 0, 0, settings_c.get_setting("main", "enable_album") ] if settings_c.get_setting("main", "enable_album") == "0": self.logging.warn("Album not enabled, setting frame to clock", location="settings_handler") self.__set_setting("frame", "clock") elif settings_c.get_setting("main", "enable_clock") == "0": self.logging.warn( "clock not enabled, setting frame to photoframe", location="settings_handler") self.__set_setting("frame", "photoframe") if settings_c.get_setting( "main", "enable_clock") == "0" and settings_c.get_setting( "main", "enable_album") == "0": self.logging.warn( "Album and clock not enabled, turning off screen setting", location="settings_handler") self.__set_setting( "screen", "off" ) ##in this case only the screensaver determines if the screen is turned on or off self.settings["main_screen_control"] = [ 0, 0, self.enable_screen_control ]
class setting_handler(Singleton): def __init__(self): try: if self.loadingdone: pass except: self.loadingdone = True self.name = "setting_handler" self.database = main_database() self.logging = Logging() self.http = urllib3.PoolManager() self.settings = {} #self.settings["main_page"] = ["Front page", ["OpenHAB", "Weather"]] self.settings["screen_timeout"] = [ "Screen timeout (min)", [1, 3, 5, 10, 15, 30, "off"] ] self.settings["album_timeout"] = [ "Album timeout (hr)", [1, 3, 5, 10, 15, 30] ] self.settings["message_timeout"] = [ "Message timeout (s)", [10, 30, 60, 120, 300] ] self.settings["toast_timeout"] = [ "Info timeout (s)", [7, 10, 15, 20, 30] ] self.settings["mouse"] = ["Mouse button", ["on", "off"]] self.settings["items_per_page"] = [ "Number of items per page", [6, 8, 9, 12] ] self.settings["sensors_per_page"] = [ "Number of sensor items per page", [6, 8, 9, 12] ] self.settings["screen"] = ["Screen", ["on", "off"]] self.settings["frame"] = ["Photo / Clock", ["photoframe", "clock"]] self.settings["frame_info"] = [ "Frame Info", ["none", "load", "album", "both"] ] self.settings["frame_td"] = [ "Frame Time/Date", ["none", "clock", "date", "both"] ] self.settings["frame_display_time"] = [ "Photo display time", ["short", "medium", "long", "extra long"] ] self.settings["clock_type"] = ["Clock type", ["digital", "analog"]] self.settings["chart_period"] = [ "Default chart period", ["auto", "4 hours", "12 hours", "1 day", "3 days", "1 week"] ] for key, item in self.settings.items(): value = self.database.data["settings"][key] self.settings[key].append(int(value)) settings_c = Settings() self.enable_screen_control = settings_c.get_setting( "main", "enable_screen_control") try: topics = settings_c.get_setting( "main", "mqtt_control_topic").split(",") self.mqtt = mqtt() for topic in topics: self.mqtt.add_listener(topic, self, "received_mqtt_message") except: self.logging.warn("Mqtt not configured for handling settings", location="settings_handler") if self.enable_screen_control in ["pi", "black"]: pass elif self.enable_screen_control == "url": try: self.screen_control_on_url = settings_c.get_setting( "main", "screen_on_url") self.screen_control_off_url = settings_c.get_setting( "main", "screen_off_url") self.settings["screen_control_on_url"] = [ 0, 0, self.screen_control_on_url ] self.settings["screen_control_off_url"] = [ 0, 0, self.screen_control_off_url ] except: self.logging.error( "Add settings 'screen_on_url' and 'screen_off_url' for external url screen control", location="settings_handler") self.enable_screen_control = "black" elif self.enable_screen_control == "cmd": try: self.screen_control_on_cmd = settings_c.get_setting( "main", "screen_on_cmd") self.screen_control_off_cmd = settings_c.get_setting( "main", "screen_off_cmd") self.settings["screen_control_on_cmd"] = [ 0, 0, self.screen_control_on_cmd ] self.settings["screen_control_off_cmd"] = [ 0, 0, self.screen_control_off_cmd ] except: self.logging.error( "Add settings 'screen_on_cmd' and 'screen_off_cmd' for external command screen control", location="settings_handler") self.enable_screen_control = "black" elif self.enable_screen_control != "off": self.logging.error( "Incorrect screen control enable settings, screen control is off", location="settings_handler") self.enable_screen_control = "off" self.settings["main_enable_clock"] = [ 0, 0, settings_c.get_setting("main", "enable_clock") ] self.settings["main_enable_album"] = [ 0, 0, settings_c.get_setting("main", "enable_album") ] if settings_c.get_setting("main", "enable_album") == "0": self.logging.warn("Album not enabled, setting frame to clock", location="settings_handler") self.__set_setting("frame", "clock") elif settings_c.get_setting("main", "enable_clock") == "0": self.logging.warn( "clock not enabled, setting frame to photoframe", location="settings_handler") self.__set_setting("frame", "photoframe") if settings_c.get_setting( "main", "enable_clock") == "0" and settings_c.get_setting( "main", "enable_album") == "0": self.logging.warn( "Album and clock not enabled, turning off screen setting", location="settings_handler") self.__set_setting( "screen", "off" ) ##in this case only the screensaver determines if the screen is turned on or off self.settings["main_screen_control"] = [ 0, 0, self.enable_screen_control ] def get_name(self): return self.name def setting_request(self, request): if request[0] == "setsetting": setting = request[1] if setting == "screen" and self.get_setting( "main_enable_album") == "0" and self.get_setting( "main_enable_clock") == "0": return [ "Enable album or clock to be able to control this setting" ] if setting == "frame" and ( self.get_setting("main_enable_album") == "0" or self.get_setting("main_enable_clock") == "0"): return [ "Enable album and clock to be able to control this setting" ] cur_value = self.settings[setting][2] if cur_value + 1 < len(self.settings[setting][1]): self.settings[setting][2] = cur_value + 1 else: self.settings[setting][2] = 0 self.save_settings() self.logging.write( self.settings[setting][0] + ": " + str(self.settings[setting][1][self.settings[setting][2]]), level=2) return [ self.settings[setting][0] + ": " + str(self.settings[setting][1][self.settings[setting][2]]) ] elif request[0] == "getsetting": return [str(self.get_setting(request[1]))] def set_setting(self, setting, value): if setting == "screen" and self.get_setting( "main_enable_album") == "0" and self.get_setting( "main_enable_clock") == "0": return ["Enable album or clock to be able to control this setting"] if setting == "frame" and (self.get_setting("main_enable_album") == "0" or self.get_setting("main_enable_clock") == "0"): return [ "Enable album and clock to be able to control this setting" ] self.__set_setting(setting, value) def __set_setting(self, setting, value): values = self.settings[setting][1] self.screen_timeout_start = time.time() for i in range(len(values)): if values[i] == value: self.settings[setting][2] = i self.save_settings() def get_settings(self): settings = [] for key, item in self.settings.items(): if (key == "clock_type" ) and self.get_setting("main_enable_clock") == "0": pass elif (key == "album_timeout" or key == "frame_info" or key == "frame_td" or key == "frame_display_time" ) and self.get_setting("main_enable_album") == "0": pass elif key == "frame" and ( self.get_setting("main_enable_album") == "0" or self.get_setting("main_enable_clock") == "0"): pass elif key == "screen" and self.get_setting( "main_enable_album") == "0" and self.get_setting( "main_enable_clock") == "0": pass elif key == "screen" and self.enable_screen_control == "off": pass elif item[0] != 0: settings.append([key, item[0], item[1][item[2]]]) return settings def save_settings(self): for key, item in self.settings.items(): self.database.data["settings"][key] = item[2] self.database.save_datafile() def get_setting(self, setting): value = self.settings[setting][2] if self.settings[setting][0] != 0: return self.translate_setting(setting, self.settings[setting][1][value]) else: return value def translate_setting(self, setting, value): if setting == "frame_display_time": timing = { "short": 5000, "medium": 13000, "long": 20000, "extra long": 60000 } if value == 0: return "short" return timing[value] elif setting == "chart_period": period = { "auto": "auto", "4 hours": "4H", "12 hours": "12H", "1 day": "1D", "3 days": "3D", "1 week": "1W" } if value == 0: return "auto" return period[value] return value def received_mqtt_message(self, topic, payload): try: payload_setting = payload['setting'] for setting in self.settings: if setting == payload_setting: if "cmd" in topic.lower(): self.set_setting(setting, payload[setting]) self.logging.info( "Set setting via mqtt message: %s, %s" % (setting, payload[setting]), location="settings_handler") elif "state" in topic.lower(): val = self.get_setting(setting) topic = topic[0:topic.rfind("/") + 1] + "status" self.mqtt.publish( topic, str({ 'setting': setting, 'value': val })) if payload_setting == "all": topic = topic[0:topic.rfind("/") + 1] + "status" self.mqtt.publish(topic, str(list(self.settings.keys()))) except Exception as e: raise Exception(e)
def receive_forever(self): """ Puts the receiver in receiving mode forever. In this mode the receiver blocks until new data is received from the sender. Every time a new chunk of data is received it calls the registered handlers' on_new_data() method. """ while True: # allow reconnecting on error try: Logging.debug("Trying to connect to %s:%s..." % (self._sender_address[0], self._sender_address[1])) with sock.create_connection(self._sender_address, timeout=30) as connection: for handler in self._connection_handlers: handler.on_new_connection(self, connection, self._sender_address) Logging.debug("Connected successfully") while True: try: Logging.info("Waiting for data...") data = self.receive(connection) Logging.info("Received data") for handler in self._data_handlers: handler.on_new_data(data) except InvalidFormatException as error: # data was not correct Logging.warning("Received data with invalid format:" " %s" % str(error)) except ConnectionAbortedError: Logging.warning("connection aborted by the sender") except sock.timeout: Logging.warning("connection timed out") except (sock.herror, sock.gaierror): Logging.error("the address of the sender is not valid") break # leave the function except ConnectionRefusedError: Logging.warning("can not reach the sender") # retry in connecting in 10 seconds Logging.debug( "connection failed: will try to connect in 10 seconds") sleep(10)
class mqtt(Singleton): def __init__(self): try: if self.loadingdone: pass except: self.loadingdone = True self.started = True self.logging = Logging() self.name = "mqtt" self.settings_c = Settings() try: self.server = self.settings_c.get_setting("mqtt", "server") self.port = int(self.settings_c.get_setting("mqtt", "port")) self.timeout = int( self.settings_c.get_setting("mqtt", "timeout")) except Exception as e: self.logging.error("Configuration not correct, check settings", location=self.name) self.listeners = [] self.client = mqtt_cl.Client() self.client.on_connect = self.on_connect self.client.on_message = self.on_message self.client.connect(self.server, self.port, self.timeout) self.client.loop_start() self.logging.info("Connected to mqtt broker at: " + self.server, location=self.name) def on_connect(self, client, userdata, flags, rc): self.logging.info("Resubscribing for all listeners at " + self.server, location=self.name) for listen in self.listeners: self.client.subscribe(listen[0]) def on_message(self, client, userdata, msg): self.logging.info("Received message: " + msg.topic + " " + str(msg.payload), location=self.name) if self.started: for listen in self.listeners: topic = listen[0][0:-1] if msg.topic.find(topic) != -1: self.logging.debug("Topic match for %s at %s" % (listen[1].get_name(), listen[0]), location=self.name) try: data = ast.literal_eval(msg.payload.decode("utf-8")) except: data = msg.payload.decode("utf-8") try: p = getattr(listen[1], listen[2]) p(msg.topic, data) except Exception as e: self.logging.error("Error executing: " + str(e), location=self.name) def add_listener(self, topic, class_item, functionname): self.listeners.append([topic, class_item, functionname]) self.client.subscribe(topic) try: name = class_item.get_name() except: name = "unknown" self.logging.info("Added listener for %s at %s" % (name, topic), location=self.name) def publish(self, topic, payload): self.logging.info("Publish %s, %s " % (topic, str(payload)), location=self.name) self.client.publish(topic, payload)
class ForecastData: data = None args = None verbose = False def __init__(self, api_key, location, update=15, language="EN", fetch=False): args = {} args["apikey"] = api_key args["location"] = location args["language"] = language args["fetch"] = -1 args["sub"] = "fetch" self.args = args self.data_update = 0 self.update_time = update * 60 self.logging = Logging() self.name = "Wunderground" if fetch: self.fetch_data() def check_update(self): if time.time() - self.update_time > self.data_update: self.fetch_data() def fetch_data(self): # Grab data from Weather Underground API req = ( "http://api.wunderground.com/api/%s/conditions/alerts/forecast10day/lang:%s/q/%s.json" % (self.args["apikey"], self.args["language"], quote(self.args["location"]))) self.link = req self.logging.info("Fetching weather data from location: " + str(self.args["location"]), location=self.name) try: response = urlopen(req) except URLError as e: if hasattr(e, 'reason'): self.logging.error(e.reason, location=self.name) elif hasattr(e, 'code'): self.logging.error("Status returned: " + str(e.code), location=self.name) json_data = response.read().decode('utf-8', 'replace') data = json.loads(json_data) try: self.logging.error(data['response']['error']['description'], location=self.name) self.logging.error("Error fetching data, check settings", location=self.name) except KeyError: self.logging.info("Data fetched successfully", location=self.name) self.data = data self.data_update = time.time() def read_current(self): self.check_update() # Assign current conditions to a dictionary try: current = self.data['current_observation'] except KeyError: self.fetch_error() # Collect and merge wind data wind_dir = current['wind_dir'] wind_mph = current['wind_mph'] wind_kph = current['wind_kph'] wind_gust_mph = current['wind_gust_mph'] wind_gust_kph = current['wind_gust_kph'] wind_string_mph = (wind_dir + " " + str(float(wind_mph)) + "mph gusting to " + str(float(wind_gust_mph)) + "mph") wind_string_kph = (wind_dir + " " + str(float(wind_kph)) + "km/h gusting to " + str(float(wind_gust_kph)) + "km/h") wind = wind_dir + " " + str(float(wind_kph)) + "km/h" neerslag = current["precip_today_string"] neerslag = neerslag[neerslag.find("(") + 1:neerslag.find(")")].replace( " ", "") current_dict = { "location": current["display_location"]["full"], "city": current["display_location"]["city"], "condition": current['weather'], "n_condition": self.get_numbered_state(self.convert_icon(current['icon'], True), True), "temp_f": int(round(float(current['temp_f']))), "temp_c": "%.1f" % (float(current['temp_c'])), "humidity": current['relative_humidity'].replace("%", ""), "icon": self.convert_icon(current['icon'], True), "icon_url": current['icon_url'], "wind": wind, "wind_dir": wind_dir, "wind_mph": wind_mph, "wind_kph": wind_kph, "wind_gust_mph": wind_gust_mph, "wind_gust_kph": wind_gust_kph, "wind_string_mph": wind_string_mph, "wind_string_kph": wind_string_kph, "pressure_mb": current['pressure_mb'], "pressure_in": current['pressure_in'], "pressure_trend": current['pressure_trend'], "dewpoint_c": current['dewpoint_c'], "dewpoint_f": current['dewpoint_f'], "heat_index_c": current['heat_index_c'], "heat_index_f": current['heat_index_f'], "windchill_c": current['windchill_c'], "windchill_f": current['windchill_f'], "feelslike_c": current['feelslike_c'], "feelslike_f": current['feelslike_f'], "visibility_mi": current['visibility_mi'], "visibility_km": current['visibility_km'], "prec_hour_in": current['precip_1hr_in'], "prec_hour_cm": current['precip_1hr_metric'], "prec_day_mm": neerslag, "prec_day_cm": current['precip_today_metric'], "timezone": current['local_tz_long'], "sunset": self.get_next_sunset( current['local_tz_long'], current["display_location"]).strftime('%H:%M'), "sunrise": self.get_next_sunrise( current['local_tz_long'], current["display_location"]).strftime('%H:%M'), } return current_dict def read_forecast(self): self.check_update() # Assign forecast to a dictionary forecast_dict = [] try: forecast = self.data['forecast']['simpleforecast']['forecastday'] except KeyError: self.fetch_error() count = 1 for index, node in enumerate(forecast): d = node['date'] if str(node['qpf_allday']['mm']) == "None": node['qpf_allday']['mm'] = "-" conditions = { "day": d['weekday'], "shortdate": str(d['month']) + "/" + str(d['day']) + "/" + str(d['year']), "longdate": d['monthname'] + " " + str(d['day']) + ", " + str(d['year']), "low_f": node['low']['fahrenheit'], "low_c": node['low']['celsius'], "high_f": node['high']['fahrenheit'], "high_c": node['high']['celsius'], "avg_c": "%.0f" % ((float(node['low']['celsius']) + float(node['high']['celsius'])) / 2.0), "avg_f": "%.0f" % ((float(node['low']['fahrenheit']) + float(node['high']['fahrenheit'])) / 2.0), "icon": self.convert_icon(node['icon']), "icon_url": node['icon_url'], "condition": node['conditions'], "n_condition": self.get_numbered_state(self.convert_icon(node['icon'])), "rain_in": node['qpf_allday']['in'], "rain_mm": str(node['qpf_allday']['mm']) + "mm", "snow_in": node['snow_allday']['in'], "snow_cm": str(node['snow_allday']['cm']) + "cm", } forecast_dict.append(conditions) count += 1 return forecast_dict def read_info(self): self.check_update() try: info = self.data['current_observation'] except KeyError: self.fetch_error() info_dict = { "city": info['display_location']['city'], "postal": info['display_location']['zip'], "datetime": info['observation_time'], "location": info['display_location']['full'], "country": info['display_location']['country'], "latitude": info['display_location']['latitude'], "longitude": info['display_location']['longitude'], "elevation": info['display_location']['elevation'], "observation": info['observation_location']['full'], } return info_dict def read_alerts(self): self.check_update() alerts_dict = [] try: alerts = self.data['alerts'] except KeyError: self.fetch_error() for index, node in enumerate(alerts): a = { "start": node['date'], "expires": node['expires'], "description": node['description'], "message": node['message'], } alerts_dict.append(a) return alerts_dict def convert_icon(self, icon, current=False): self.check_update() pattern = re.compile(r'[A-Za-z]+ \d+ (.+):\d+:\d+') time_string = self.data['current_observation']['local_time_rfc822'] hour = int(pattern.search(time_string).group(1)) day_icon_dict = self.get_icons_db() night_icon_dict = self.get_icons_db(day=False) try: if (hour > 20 or hour < 6) and current is True: new_icon = night_icon_dict[icon] else: new_icon = day_icon_dict[icon] except KeyError: self.logging.error( "Icon type doesn't exist. Please report this. [%s]" % str(icon), location=self.name) new_icon = "" return new_icon def get_numbered_state(self, icon, current=False): day_icon_dict = self.get_icons_db() numbered_dict = self.get_icons_db(numbered=True) pattern = re.compile(r'[A-Za-z]+ \d+ (.+):\d+:\d+') time_string = self.data['current_observation']['local_time_rfc822'] hour = int(pattern.search(time_string).group(1)) if (hour > 20 or hour < 6) and current is True: add = 31 else: add = 1 for i in range(len(numbered_dict)): name = numbered_dict[i] if day_icon_dict[name][-1:] == icon[-1:]: return i + add return 20 + add def get_icons_db(self, day=True, numbered=False): if numbered: return [ "chancerain", "sunny", "mostlysunny", "partlycloudy", "mostlycloudy", "rain", "chancesnow", "cloudy", "tstorms", "chancetstorms", "sleet", "snow", "fog", "smoke", "hazy", "flurries", "chanceflurries", "chancesleet", "clear", "partlysunny", "unknown" ] elif day: return { "chancerain": "weather_g", "sunny": "weather_h", "mostlysunny": "weather_b", "partlycloudy": "weather_c", "mostlycloudy": "weather_d", "rain": "weather_i", "chancesnow": "weather_u", "cloudy": "weather_e", "tstorms": "weather_m", "chancetstorms": "weather_k", "sleet": "weather_j", "snow": "weather_q", "fog": "weather_f", "smoke": "weather_n", "hazy": "weather_t", "flurries": "weather_p", "chanceflurries": "weather_s", "chancesleet": "weather_o", "clear": "weather_r", "partlysunny": "weather_l", "unknown": "weather_u" } else: return { "chancerain": "weather_nt_g", "sunny": "weather_nt_a", "mostlysunny": "weather_nt_b", "partlycloudy": "weather_nt_c", "mostlycloudy": "weather_nt_d", "rain": "weather_nt_i", "chancesnow": "weather_nt_u", "cloudy": "weather_nt_e", "tstorms": "weather_nt_m", "chancetstorms": "weather_nt_k", "sleet": "weather_nt_j", "snow": "weather_nt_q", "fog": "weather_nt_f", "smoke": "weather_nt_n", "hazy": "weather_nt_t", "flurries": "weather_nt_p", "chanceflurries": "weather_nt_s", "chancesleet": "weather_nt_o", "clear": "weather_nt_r", "partlysunny": "weather_nt_l", "unknown": "weather_nt_u" } def getCondNames(self, language="EN"): if language == "EN": return [ "chancerain", "sunny", "mostlysunny", "partlycloudy", "mostlycloudy", "rain", "chancesnow", "cloudy", "tstorms", "chancetstorms", "sleet", "snow", "fog", "smoke", "hazy", "flurries", "chanceflurries", "chancesleet", "clear", "partlysunny", "unknown" ] def fetch_error(self): pass def output_data(self, parser): if self.args.sub == "current": current_dict = self.read_current() print(current_dict[self.args.current], file=sys.stdout) elif self.args.sub == "forecast": forecast_dict = self.read_forecast() self.logging.info(forecast_dict[int( self.args.day)][self.args.forecast], location=self.name) elif self.args.sub == "info": info_dict = self.read_info() print(info_dict[self.args.information], file=sys.stdout) elif self.args.sub == "alert": alerts_dict = self.read_alerts() if len(alerts_dict) < 1: print('No alerts to display') sys.exit(10) if self.args.num > len(alerts_dict): self.logging.error('Invalid alert number. Available: %s' % len(alerts_dict), location=self.name) print(alerts_dict[int(self.args.num - 1)][self.args.alert], file=sys.stdout) elif self.args.sub != "fetch": parser.print_usage() def get_next_sunrise(self, timezone, location): tz = pytz.timezone(timezone) obs = self.create_observer(location) sunrise = obs.next_rising(ephem.Sun()).datetime() return pytz.utc.localize(sunrise).astimezone(tz) def get_next_sunset(self, timezone, location): tz = pytz.timezone(timezone) obs = self.create_observer(location) sunset = obs.next_setting(ephem.Sun()).datetime() return pytz.utc.localize(sunset).astimezone(tz) def create_observer(self, loc): user = ephem.Observer() #print(loc) user.lat = loc["latitude"] user.lon = loc["longitude"] user.elevation = float(loc["elevation"]) return user
from logger import Logging log_path = './logs/logger_test.log' log_lable = "logger_test" idc = "BJ" log = Logging("%s.%s" % (log_path, idc), "%s.%s" % (log_lable, idc)) log.logger.info("info test ok") log.logger.debug("debug test ok") log.logger.error("error test ok") log.logger.warning("warning test ok") #log.logger.log("log test ok") log.logger.exception("exception test ok")
'''logger解耦,生成多个logger实例''' from logger import Logging import foo logging = Logging('main', 'test.log') logger = logging.logger logger.info('main 收到一个请求') foo.foo() print(logging.th.baseFilename) print(logger.name)
class pf_openhab(Singleton): def __init__(self): try: if self.loadingdone: pass except: self.loadingdone = True self.logging = Logging() settings_c = Settings() self.openhab_server = settings_c.get_setting("main", "openhab_ip") self.openhab_port = settings_c.get_setting("main", "openhab_port") self.host = settings_c.get_setting("main", "hostname") self.port = settings_c.get_setting("main", "port") self.sitemap_name = settings_c.get_setting("main", "sitemap") self.sitemap_name = "main" if self.sitemap_name == None else self.sitemap_name self.resize_icons = settings_c.get_setting("main", "resize_icons") self.iconh = 64 self.iconw = 64 self.name = "pf_openhab" self.http = urllib3.PoolManager() def get_pages(self, filter): if type(filter) != list: filter = [filter] self.load_sitemap() data = [] n = 0 for i in range(len(self.sitemap["homepage"]["widgets"][0]["widgets"])): key = self.sitemap["homepage"]["widgets"][0]["widgets"][i] found = False for filt in filter: if key["label"][0:len(filt)] == filt and not found: icon_url = "/item/icon/" + key["icon"] + ".png" data.append({ "label": key["label"], "icon": icon_url, "id": n }) found = True n += 1 return data def get_page(self, name): for i in range(len(self.sitemap["homepage"]["widgets"][0]["widgets"])): key = self.sitemap["homepage"]["widgets"][0]["widgets"][i] if key["label"] == name: return key def get_items(self, pagename, subpage="none", subsubpage=0): self.load_sitemap() page = self.get_page(pagename) data = [] n_subp = 1 n = 0 page_type = [page["label"], page["icon"]] for key in page["linkedPage"]["widgets"]: n += 1 item = self.convert_item_data(key) item["id"] = item["name"] + "__" + pagename + "__" + str( subpage) + "__" + str(n) if subpage == "none" or str(subpage) == "0": if item["type"] == "Frame": item["page"] = pagename item["subpage"] = item["label"] data.append(item) elif item["type"] == "Frame" and item["label"] == subpage: page_type[0] = page_type[0] + " / " + key["label"] sub_n = 0 for k in key["widgets"]: sub_n += 1 item = self.convert_item_data(k) item["id"] = item["name"] + "__" + pagename + "__" + str( subpage) + "__" + str(sub_n) if item["type"] == "Frame": item["type"] = "Text" data.append(item) return [data, page_type] def load_sitemap(self): if self.host == None or self.openhab_server == None: #if self.openhab_server == None: data = self.load_error_sitemap(False) else: try: url = "http://" + self.openhab_server + ":" + self.openhab_port + "/rest/sitemaps/" + self.sitemap_name #print(url) content = self.http.request('GET', url) data = content.data.decode("utf-8") except: self.logging.error( "Error connecting to openHAB server, please check settings", location=self.name) data = self.load_error_sitemap(True) data = data.replace("true", "True").replace("false", "False") data = eval(data) self.sitemap = data def load_error_sitemap(self, exception): PATH = os.path.dirname(os.path.abspath(__file__)) errorfile = PATH + "/files/error_sitemap.txt" with open(errorfile, 'r') as f: data = f.read() if exception: data = data.replace("{{HOST_CONFIG_ERROR}}", "No error detected") data = data.replace("{{OPENHAB_CONFIG_ERROR}}", "Error connecting to server, check settings") else: data = data.replace("{{HOST_CONFIG_ERROR}}", "Check settings") data = data.replace("{{OPENHAB_CONFIG_ERROR}}", "Check settings") data = data.replace("{{IP}}", str(self.openhab_server)) data = data.replace("{{PORT}}", str(self.openhab_port)) data = data.replace("{{SITEMAP}}", str(self.sitemap_name)) data = data.replace("{{RESIZE}}", str(self.resize_icons)) data = data.replace("{{HOST_IP}}", str(self.host)) data = data.replace("{{HOST_PORT}}", str(self.port)) return data def get_item(self, item_name): name, pagename, subpage, n = self.split_item_name(item_name) #print(name, pagename, subpage, n) item = self.get_item_data(name, pagename, subpage, n) self.logging.debug("Item from get_item: " + str(item), location=self.name) return item def get_item_data(self, item_name, pagename, subpage, n): #search for the item self.load_sitemap() #print("Name: " + item_name) o = 1 subpage_o = 1 for i in range(len(self.sitemap["homepage"]["widgets"][0]["widgets"])): if self.sitemap["homepage"]["widgets"][0]["widgets"][i][ "label"] == pagename: for key in self.sitemap["homepage"]["widgets"][0]["widgets"][ i]["linkedPage"]["widgets"]: if key["label"].find("[") != -1: comp_label = key["label"][0:key["label"].find("[")] while comp_label[-1:] == " ": comp_label = comp_label[0:-1] else: comp_label = key["label"] try: if key["type"] == "Frame" and ( str(subpage_o) == subpage or comp_label == subpage): #print(subpage) sub_o = 0 for k in key["widgets"]: sub_o += 1 try: if k["item"][ "name"] == item_name and sub_o == n: item = self.convert_item_data(k) item["id"] = item[ "name"] + "__" + pagename + "__" + str( subpage) + "__" + str(n) item["page"] = pagename item["subpage"] = str(subpage) self.logging.debug("Item found, id: " + item["id"], location=self.name) return item except Exception as e: self.logging.warn( "Invalid item found in sitemap 2 %s" % (str(e)), location=self.name) elif "item" in key and key["item"][ "name"] == item_name and o == n: item = self.convert_item_data(key) item["id"] = item[ "name"] + "__" + pagename + "__" + str( subpage) + "__" + str(n) item["page"] = pagename item["subpage"] = str(subpage) self.logging.debug("Item found, id: " + item["id"], location=self.name) return item elif str(subpage) == "0" or subpage == "none": o += 1 elif key["type"] == "Frame": subpage_o += 1 o += 1 except Exception as e: self.logging.warn( "Invalid item found in sitemap 1: %s, %s" % (str(key), str(e)), location=self.name) def convert_item_data(self, key): #print(key) item_data = { "icon": key["icon"], "type": key["type"], "name": key["label"], "state": "" } if "item" in key: item_data.update({ "state": key["item"]["state"], "link": key["item"]["link"], "name": key["item"]["name"] }) if key["item"]["state"] != "" and key["item"]["state"].find( " ") == -1: item_data["icon"] = key["icon"] + "-" + key["item"]["state"] if "transformedState" in key["item"]: transformedState = key["item"]["transformedState"] if len(str(transformedState)) < 15: item_data.update( {"icon": key["icon"] + "-" + transformedState}) if "mappings" in key: item_data.update({"mappings": key["mappings"]}) if "label" in key: item_data.update({"label": key["label"]}) #### correct icon for state try: state = float(item_data["state"]) if state < 0.0: item_data["icon"] = key["icon"] + "-" + str(-1 * state + 100) except: if item_data["state"] == "NULL": item_data["state"] = "OFF" item_data["icon"] = key["icon"] + "-off" elif len(str(item_data["state"])) > 15: item_data["icon"] = key["icon"] #### transform state name if item_data["label"].find("[") != -1: label = item_data["label"][0:item_data["label"].find("[")] while label[-1:] == " ": label = label[0:-1] state = item_data["label"][item_data["label"].find("[") + 1:item_data["label"].find("]")] item_data.update({"state": state, "label": label}) if key["type"] == "Colorpicker": if item_data["state"].lower() != "off": item_data["state"] = self.convert_color_to_rgb( item_data["state"]) item_data["icon"] = key["icon"] + "-on" if len(item_data["state"].split(",")) > 2: if item_data["state"].split(",")[2] == "0" or item_data[ "state"].split(",")[2] == "0.0": item_data.update({ "state": "off", "icon": key["icon"] + "-off" }) elif key["type"] == "Selection": item_state = "" if len(key["mappings"]) == 1: item_data["type"] = "Switch_single" item_state = key["mappings"][0]["label"] for mapp in key["mappings"]: if mapp["command"].lower() == item_data["state"].lower(): ## mappings are like [ displayed state, actual state ] item_state = mapp["label"] elif mapp["label"].lower() == item_data["state"].lower(): item_state = mapp[ 'label'] ##sometimes a state is 0 ==> OFF, which is not mapped correctly with Off or 0 try: ##why is this????? #print(item_state) int(item_state) item_data.update({"item_state": item_data["label"]}) item_data.update({"label": "_"}) except: item_data.update({"state": item_state}) elif key["type"] == "Setpoint": try: step = round(float(key["step"]), 1) if int(step) == step: step = int(step) item_data.update({ "setpoint": [int(key["minValue"]), int(key["maxValue"]), step] }) except: pass elif key["type"] == "Slider": item_data.update({"setpoint": [0, 100, 10]}) ##update the icon to the right url: if self.resize_icons == "1": item_data["icon"] = "/item/icon/" + item_data["icon"] + ".png" else: item_data[ "icon"] = "http://" + self.openhab_server + ":" + self.openhab_port + "/icon/" + item_data[ "icon"] + ".png" return item_data def set_state(self, item_name, state): item, pagename, subpage, n = self.split_item_name(item_name) if state[0:5] == "Color": state = self.convert_color_to_hsv(state[5:]) #cmd = "curl --header \"Content-Type: text/plain\" --request POST --data \"" + state+ "\" " + self.openhab_server + ":" + self.openhab_port + "/rest/items/" + item url = "http://" + self.openhab_server + ":" + self.openhab_port + "/rest/items/" + item headers = {'Content-Type': 'text/plain'} requests.post(url, data=state, headers=headers) self.logging.info("Put state openhab: " + url + " " + str(state), location="openhab") #os.system(cmd) #print(cmd) self.load_sitemap() return self.get_item(item_name) def get_mappings(self, item_name, occurrence=1): ##self.load_sitemap() item = self.get_item(item_name) mappings = [] for mapping in item["mappings"]: mappings.append([mapping["label"], mapping["command"]]) return mappings def convert_color_to_rgb(self, color): if color == "": color = "0.0,0.0,0" color = color.split(",") color = colorsys.hsv_to_rgb( float(color[0]) / 360, float(color[1]) / 100, float(color[2]) / 100) red = hex(int(color[0] * 255))[2:] if len(red) < 2: red = "0" + red blue = hex(int(color[1] * 255))[2:] if len(blue) < 2: blue = "0" + blue green = hex(int(color[2] * 255))[2:] if len(green) < 2: green = "0" + green return "#" + red + blue + green def convert_color_to_hsv(self, color): color = colorsys.rgb_to_hsv( float(int("0x" + color[0:2], 0)) / 255.0, float(int("0x" + color[2:4], 0)) / 255.0, float(int("0x" + color[4:6], 0)) / 255.0) return str(color[0] * 360) + "," + str(color[1] * 100) + "," + str( color[2] * 100) def get_icon(self, name): URL = "http://" + self.openhab_server + ":" + self.openhab_port + "/icon/" + name response = requests.get(URL) with Image.open(BytesIO(response.content)) as image: imgByteArr = BytesIO() cover = Image.Image.resize(image, [self.iconh, self.iconw]) cover.save(imgByteArr, image.format) return imgByteArr.getvalue() def get_chart_data(self, item, period): try: p = int(period[0:len(period) - 1]) except: p = 1 if period[-1:] == "D": dt = datetime.datetime.now() - datetime.timedelta(days=p) elif period[-1:] == "H": p += 1 dt = datetime.datetime.now() - datetime.timedelta(hours=p) elif period[-1:] == "W": dt = datetime.datetime.now() - datetime.timedelta(weeks=p) elif period[-1:] == "M": dt = datetime.datetime.now() - relativedelta(months=p) start = dt.strftime("%Y-%m-%dT%H:%M:%S.000+01:00") self.logging.info("Starting date for data: " + start, location="openhab") start = start.replace("+", "%2B").replace(":", "%3A") name, pagename, subpage, n = self.split_item_name(item) URL = "http://" + self.openhab_server + ":" + self.openhab_port + "/rest/persistence/items/" + name + "?serviceId=rrd4j&starttime=" + start response = requests.get(URL) ## get item info i = self.get_item(item) if i == None: return None else: if i["icon"].lower().find("temp") != -1: typ = "temp" elif i["icon"].lower().find("humi") != -1: typ = "humi" elif i["icon"].lower().find("press") != -1: typ = "pres" elif i["icon"].lower().find("energy") != -1: typ = "watt" else: typ = "value" return {"data": response.content, "type": typ} def split_item_name(self, item_name): a = item_name.split("__") if len(a) > 1: name = a[0] pagename = a[1] subpage = a[2] n = int(a[3]) else: return item_name return name, pagename, subpage, n
class widgets_handler: def __init__(self): self.openhab = pf_openhab() self.logging = Logging() self.name = "widget_handler" PATH = os.path.dirname(os.path.abspath(__file__)) self.template_dir = PATH + "/../templates/" self.imported_widget_classes = {} def render_widget(self, page, lowerpage): w_info = self.get_widget_info(lowerpage, main_page=page) data = self.openhab.get_items(page, lowerpage) item_data = self.render_item_data_for_widget(data[0]) try: item_data = self.get_widget_data(w_info, item_data) if "error" in item_data: return render_template("error.html", data=item_data) except Exception as e: self.logging.error("Error creating widget %s" % str(e), location=self.name) er = self.render_widget_error(e, lowerpage) return render_template("error.html", data={"error": str(er)}) item_data["gen_name"] = w_info["name"] item_data["pagename"] = page try: self.logging.debug("Rendering widget: %s" % w_info["template"], location=self.name) return render_template("widgets/%s.html" % w_info["template"].lower(), data=item_data) except Exception as e: self.logging.error("Error creating widget %s" % str(e), location=self.name) er = self.render_widget_error(e, lowerpage) return render_template("error.html", data={"error": str(er)}) def create_mainpage_popup(self, page, subpage, menuwidget=False): if page == "none": ##in case the widget is on the main page data = self.openhab.get_items(subpage, page) else: data = self.openhab.get_items(page, subpage) item_data = self.render_item_data_for_widget(data[0]) if len(item_data) == 0: #return "widget not in sitemap" self.logging.error("Widget is not in sitemap", location=self.name) er = self.render_widget_error("widget not in sitemap", subpage) return render_template("popups/error.html", data={"error": str(er)}) info = self.get_widget_info(subpage, main_page=page) try: item_data = self.get_widget_data(info, item_data) if "error" in item_data: return render_template("popups/error.html", data=item_data) except Exception as e: self.logging.error("Error creating widget %s" % str(e), location=self.name) er = self.render_widget_error(e, subpage) if menuwidget: return render_template("popups/error.html", data={"error": str(er)}), "Error" else: return render_template("popups/error.html", data={"error": str(er)}) item_data["page_name"] = page item_data["widget_name"] = subpage item_data["menuwidget"] = menuwidget if info == None: return render_template( "popups/error.html", data={ "error": "Popup widget template for %s does not exist" % subpage.lower() }) elif info["template"] == "generic_button_page": return info["template"] else: try: self.logging.debug("Rendering popup widget: %s" % info["template"], location=self.name) data = render_template("popup_widgets/" + info["template"] + ".html", data=item_data) if menuwidget: title = self.find_var(data, "Title") if title == None: title = "" return data, title else: return data except Exception as e: self.logging.error("Error creating popup widget %s" % str(e), location=self.name) er = self.render_widget_error(e, subpage) if menuwidget: return render_template("popups/error.html", data={"error": str(er)}), "Error" else: return render_template("popups/error.html", data={"error": str(er)}) def get_widget_data(self, w_info, item_data): if w_info["name"] not in self.imported_widget_classes: try: a = __import__(w_info["name"] + "_widget") self.imported_widget_classes[w_info["name"]] = getattr( a, w_info["name"] + "_widget")() except Exception as e: self.logging.warn("Could not create widget %s" % str(e), location=self.name) self.logging.warn("Could not create widget %s" % str(w_info["name"]), location=self.name) self.logging.warn("Importing normal widget", location=self.name) a = __import__("widget") self.imported_widget_classes[w_info["name"]] = a.widget() cl = self.imported_widget_classes[w_info["name"]] item_data = cl.get_data(item_data) return item_data def check_widget_type(self, name): if name[0:2] == "m_": return "menu_button" if name[0:2] in ["a_"]: return "menu_popup" if name[0:2] in ["b_"]: return "widget_popup" if name[0:2] in ["c_"]: return "widget_subpage" if name[0:2] == "s_": info = self.get_widget_info(name) return "widget_" + str(info["rows"]) else: return name def get_widget_label(self, name): for n in ["b_"]: if name.find(n) != -1: return name[name.find(n) + 2:] if name.find("[") != -1 and name.find("]") != -1: name = name[name.find("[") + 1:name.find("]")] return name for n in ["m_", "a_", "b_", "c_", "d_"]: if name.find("/ " + n) != -1: return name[name.find("/ " + n) + 4:] if name.find(n) != -1: return name[name.find(n) + 2:] i = self.get_widget_info(name) if i == None: return name else: return i["name"] def get_widget_info(self, name, main_page="none"): ## s_ frontpage widget with possible popup widget ## a_ generic button page (with large button on frontpage ## b_ bottom page ## c_ popup widget with button ## d_ popup widget with button ## m_ generic button linking to a page instead of popup widget_data = {} widget_data["a_"] = { "type": "popup_widget", "name": name[2:], "template": "generic_button_page" } if name[0:2] in widget_data: return widget_data[name[0:2]] else: ##try to find the info from the widget template data = "_" name_lower = name[2:].lower() if name[0:2] == "s_": ##widget f_name = self.template_dir + "widgets/" + name_lower + ".html" if Path(f_name).is_file(): with open(f_name, 'r') as myfile: data = myfile.read().replace('\n', '') n = self.find_var(data, "Name") rows = self.find_var(data, "Rows") title = self.find_var(data, "Title") if rows != None and n != None: return { "title": title, "name": n, "rows": int(rows), "template": name_lower, "type": "frontpage_widget", "pagename": main_page } else: ##popup f_name = self.template_dir + "popup_widgets/" + name_lower + ".html" if Path(f_name).is_file(): with open(f_name, 'r') as myfile: data = myfile.read().replace('\n', '') n = self.find_var(data, "Name") if n != None: return { "name": n, "template": name_lower, "type": "popup_widget", "pagename": main_page } return None def find_var(self, data, var): if data.find(var + "=") != -1: pos = data.find(var + "=") pos2 = data[pos + len(var) + 1:].find("/") return data[pos + len(var) + 1:pos + len(var) + 1 + pos2] else: return None def render_item_data_for_widget(self, data): d = {} for dat in data: dat["state_length"] = len(dat["state"]) d[dat["label"].lower()] = dat return d def render_widget_error(self, e, w): e = str(e) if e.find("attribute") != -1: pos = e.find("attribute") n = e[pos + 10:] return "Please add an item labeled %s to the widget named %s" % ( n, str(w)) else: return "Widget: " + str(w) + " " + str(e)
from __future__ import print_function import argparse import sys import collections import time import numpy as np import tensorflow as tf import matplotlib.pyplot as plt from blackbox import BlackBox from logger import Logging import random FLAGS = None logger = Logging() def deepnn(x): """deepnn builds the graph for a deep net for classifying digits. Args: x: an input tensor with the dimensions (N_examples, 784) for example Returns: A tuple (y, keep_prob). y is a tensor of shape (N_examples, 10), with values equal to the logits of classifying the digit into one of 10 classes (the digits 0-9). keep_prob is a scalar placeholder for the probability of dropout """ # Reshape to use within a convolutional neural net. # Last dimension is for "features" - there is only one here, since images are # grayscale -- it would be 3 for an RGB image
from logger import Logging from symbol import Symbol from loader import Loader print "***** logging test *****" l = Logging() l.error("missing symbol") l.info("missing symbol") l.refresh("missing symbol") l.buy("missing symbol") l.profit("missing symbol") l.terminate("missing symbol") print "***** symbol test *****" s = Symbol('AMD') s.market_cap() print s.market_cap s.earnings_per_share() print s.eps print "***** loader test *****" load = Loader('AMD', '2016-11-01', '2016-11-21') amd = load.get_data('AMD') amd.book_value() print amd.book print load.data_to_csv('AMD')