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')
