def __getattr__(self, name):
"""
Quick and dirty shortcuts. Will only get called for undefined attributes.
"""
if checkattr(self.fhdhr, name):
return eval("self.fhdhr.%s" % name)
elif checkattr(self.fhdhr.device, name):
return eval("self.fhdhr.device.%s" % name)
def __getattr__(self, name):
"""
Quick and dirty shortcuts. Will only get called for undefined attributes.
"""
if checkattr(self, name.lower()):
return eval("self._logger.%s" % name.lower())
if checkattr(self._logger, name):
return eval("self._logger.%s" % name)
def __getattr__(self, name):
"""
Quick and dirty shortcuts. Will only get called for undefined attributes.
"""
if checkattr(self.method, name):
return eval("self.method.%s" % name)
if checkattr(self.plugin_utils, name):
return eval("self.plugin_utils.%s" % name)
if name in list(self.default_settings.keys()):
return self.get_config_value(name)
def api_sub_handler(self, *args):
parameters = {}
if checkattr(self, "endpoint_parameters"):
for parameter in list(self.endpoint_parameters.keys()):
if "default" in list(self.endpoint_parameters[parameter].keys()):
parameter_default = self.endpoint_parameters[parameter][
"default"]
else:
parameter_default = None
parameter_requested = request.args.get(parameter,
default=parameter_default,
type=str)
if "required" in list(self.endpoint_parameters[parameter].keys()):
parameter_required = self.endpoint_parameters[parameter][
"required"]
else:
parameter_required = False
if "valid_options" in list(
self.endpoint_parameters[parameter].keys()):
parameter_valid_options = self.endpoint_parameters[parameter][
"valid_options"]
else:
parameter_valid_options = []
if parameter_valid_options == "origins":
parameter_valid_options = self.fhdhr.origins.list_origins
if isinstance(parameter_valid_options, str):
parameter_valid_options = [parameter_valid_options]
if parameter_required and not parameter_requested:
return tabbed_json_response({
"Missing required parameter":
parameter,
"Valid %s options" % parameter:
", ".join(parameter_valid_options)
})
if len(parameter_valid_options):
if parameter_requested and parameter_requested not in parameter_valid_options:
return tabbed_json_response({
"Invalid %s" % parameter:
parameter_requested,
"Valid %s options" % parameter:
", ".join(parameter_valid_options)
})
parameters[parameter] = parameter_requested
return self.handler(parameters, *args)
def __getattr__(self, name):
"""
Quick and dirty shortcuts. Will only get called for undefined attributes.
"""
if checkattr(self.channels, name):
return eval("self.channels.%s" % name)
def pages_to_refresh(self):
if checkattr(self.method, "pages_to_refresh"):
pages_to_refresh = self.method.pages_to_refresh
else:
pages_to_refresh = self.config_dict["pages_to_refresh"]
if isinstance(pages_to_refresh, str):
pages_to_refresh = [pages_to_refresh]
return pages_to_refresh
def run_interface_plugin_threads(self):
self.fhdhr.logger.debug("Checking Interface Plugins for threads to run.")
for interface_plugin in list(self.interfaces.keys()):
if checkattr(self.interfaces[interface_plugin], 'run_thread'):
self.fhdhr.logger.info("Starting %s interface plugin thread." % interface_plugin)
self.interfaces[interface_plugin].run_thread()
self.fhdhr.logger.debug("Started %s interface plugin thread." % interface_plugin)
def get_config_value(self, epg_attr):
"""
Returns configuration values in the following order
1) If the plugin manually handles it
2) The value we use in the config system
"""
if checkattr(self.method, epg_attr):
return eval("self.method.%s" % epg_attr)
if self.config_dict[epg_attr]:
return self.config_dict[epg_attr]
return self.get_default_value(epg_attr)
def close_stream(self, tuner_number, stream_args):
if checkattr(self.method, "close_stream"):
self.fhdhr.logger.info("Running %s close_stream method." %
self.name)
self.method.close_stream(tuner_number, stream_args)
def get_origin_property(self, origin_attr):
if checkattr(self, origin_attr):
return eval("self.%s" % origin_attr)
return None
def update_epg(self):
if checkattr(self.method, "update_epg"):
return self.method.update_epg()
return {}
def clear_cache(self):
if checkattr(self.method, "clear_cache"):
self.method.clear_cache()
self._epgdict = {}
self.fhdhr.db.delete_fhdhr_value("epg_dict", self.name)
def has_method(self, method):
if checkattr(self.method, method):
return True
return False
def on_recv(self, headers, cmd, ssdp_handling_list):
if checkattr(self.method, 'on_recv'):
return self.method.on_recv(headers, cmd, ssdp_handling_list)
def webpage_dict(self):
if checkattr(self.method, "webpage_dict"):
return self.method.webpage_dict
return {}
def get_channel_stream(self, chandict, stream_args):
if checkattr(self.method, "get_channel_stream"):
return self.method.get_channel_stream(chandict, stream_args)
return None
def get_channels(self):
if checkattr(self.method, "get_channels"):
return self.method.get_channels()
return []
def add_endpoints(self, index_name):
"""
Add Endpoints.
"""
endpoint_obj = self.endpoints_dict[index_name]
if type(endpoint_obj).__name__ == "WebPlugin":
item_list = [x for x in endpoint_obj.endpoint_directory if self.isapath(x)]
else:
item_list = [x for x in dir(endpoint_obj) if self.isapath(x)]
for item in item_list:
endpoint_handler = eval("endpoint_obj.%s" % item)
if checkattr(endpoint_handler, "endpoints"):
endpoints = endpoint_handler.endpoints
if isinstance(endpoints, str):
endpoints = [endpoints]
else:
endpoints = [str(type(endpoint_handler).__name__)]
if checkattr(endpoint_handler, "endpoint_name"):
endpoint_name = endpoint_handler.endpoint_name
else:
endpoint_name = type(endpoint_handler).__name__
if checkattr(endpoint_handler, "endpoint_methods"):
endpoint_methods = endpoint_handler.endpoint_methods
else:
endpoint_methods = ['GET']
if checkattr(endpoint_handler, "endpoint_access_level"):
endpoint_access_level = endpoint_handler.endpoint_access_level
else:
endpoint_access_level = 0
if checkattr(endpoint_handler, "pretty_name"):
pretty_name = endpoint_handler.pretty_name
else:
pretty_name = endpoint_name
if checkattr(endpoint_handler, "endpoint_category"):
endpoint_category = endpoint_handler.endpoint_category
else:
endpoint_category = index_name
if checkattr(endpoint_handler, "endpoint_parameters"):
endpoint_parameters = endpoint_handler.endpoint_parameters
else:
endpoint_parameters = {}
endpoint_added = True
try:
for endpoint in endpoints:
self.add_endpoint(endpoint=endpoint,
endpoint_name=endpoint_name,
handler=endpoint_handler,
methods=endpoint_methods)
except AssertionError:
endpoint_added = False
if endpoint_added:
self.fhdhr.logger.debug("Adding endpoint %s available at %s with %s methods." % (endpoint_name, ",".join(endpoints), ",".join(endpoint_methods)))
if endpoint_category not in list(self.route_list.keys()):
self.route_list[endpoint_category] = {}
if endpoint_name not in list(self.route_list[endpoint_category].keys()):
self.route_list[endpoint_category][endpoint_name] = {}
self.route_list[endpoint_category][endpoint_name]["name"] = endpoint_name
self.route_list[endpoint_category][endpoint_name]["endpoints"] = endpoints
self.route_list[endpoint_category][endpoint_name]["endpoint_methods"] = endpoint_methods
self.route_list[endpoint_category][endpoint_name]["endpoint_access_level"] = endpoint_access_level
self.route_list[endpoint_category][endpoint_name]["endpoint_parameters"] = endpoint_parameters
self.route_list[endpoint_category][endpoint_name]["pretty_name"] = pretty_name
self.route_list[endpoint_category][endpoint_name]["endpoint_category"] = endpoint_category
def notify(self):
if checkattr(self.method, 'notify'):
return self.method.notify
return None
