README.md

@@ -16,7 +16,5 @@ fHDHR is labeled as beta until we reach v1.0.0
 
 Join us in `#fHDHR <irc://irc.freenode.net/#fHDHR>`_ on Freenode.
 
-# !!NOTICE!!
 
-To reduce code duplication between variants, I am moving to a plugin system.
-The normal variant repos will stay active during the transition.
+Due to multiple issues, I'm dropping official support for Windows.

alternative_epg/__init__.py

@@ -0,0 +1,2 @@
+# pylama:ignore=W0401,W0611
+from .zap2it import *

alternative_epg/zap2it.py

@@ -5,26 +5,26 @@ from fHDHR.tools import xmldictmaker
 from fHDHR.exceptions import EPGSetupError
 
 
-class Plugin_OBJ():
+class zap2itEPG():
 
-    def __init__(self, channels, plugin_utils):
-        self.plugin_utils = plugin_utils
+    def __init__(self, fhdhr, channels):
+        self.fhdhr = fhdhr
 
         self.channels = channels
 
-    @property
-    def postalcode(self):
-        if self.plugin_utils.config.dict["zap2it"]["postalcode"]:
-            return self.plugin_utils.config.dict["zap2it"]["postalcode"]
-        try:
-            postalcode_url = 'http://ipinfo.io/json'
-            postalcode_req = self.plugin_utils.web.session.get(postalcode_url)
-            data = postalcode_req.json()
-            postalcode = data["postal"]
-        except Exception as e:
-            raise EPGSetupError("Unable to automatically optain postalcode: %s" % e)
-            postalcode = None
-        return postalcode
+        self.postalcode = self.fhdhr.config.dict["zap2it"]["postalcode"]
+
+    def get_location(self):
+        self.fhdhr.logger.warning("Zap2it postalcode not set, attempting to retrieve.")
+        if not self.postalcode:
+            try:
+                postalcode_url = 'http://ipinfo.io/json'
+                postalcode_req = self.fhdhr.web.session.get(postalcode_url)
+                data = postalcode_req.json()
+                self.postalcode = data["postal"]
+            except Exception as e:
+                raise EPGSetupError("Unable to automatically optain zap2it postalcode: " + str(e))
+        return self.postalcode
 
     def update_epg(self):
         programguide = {}
@@ -32,12 +32,12 @@ class Plugin_OBJ():
         # Start time parameter is now rounded down to nearest `zap_timespan`, in s.
         zap_time = datetime.datetime.utcnow().timestamp()
         self.remove_stale_cache(zap_time)
-        zap_time_window = int(self.plugin_utils.config.dict["zap2it"]["timespan"]) * 3600
+        zap_time_window = int(self.fhdhr.config.dict["zap2it"]["timespan"]) * 3600
         zap_time = int(zap_time - (zap_time % zap_time_window))
 
         # Fetch data in `zap_timespan` chunks.
         i_times = []
-        for i in range(int(7 * 24 / int(self.plugin_utils.config.dict["zap2it"]["timespan"]))):
+        for i in range(int(7 * 24 / int(self.fhdhr.config.dict["zap2it"]["timespan"]))):
             i_times.append(zap_time + (i * zap_time_window))
 
         cached_items = self.get_cached(i_times)
@@ -63,13 +63,11 @@ class Plugin_OBJ():
                     eventdict = xmldictmaker(event, ["startTime", "endTime", "duration", "rating", "flag"], list_items=["filter", "flag"])
                     progdict = xmldictmaker(event['program'], ["title", "sub-title", "releaseYear", "episodeTitle", "shortDesc", "season", "episode", "id"])
 
-                    timestamp = self.zap2it_timestamps(eventdict['startTime'], eventdict['endTime'])
-
                     clean_prog_dict = {
-                                    "time_start": timestamp['time_start'],
-                                    "time_end": timestamp['time_end'],
+                                    "time_start": self.xmltimestamp_zap(eventdict['startTime']),
+                                    "time_end": self.xmltimestamp_zap(eventdict['endTime']),
                                     "duration_minutes": eventdict['duration'],
-                                    "thumbnail": "https://zap2it.tmsimg.com/assets/%s.jpg" % eventdict['thumbnail'],
+                                    "thumbnail": str("https://zap2it.tmsimg.com/assets/" + str(eventdict['thumbnail']) + ".jpg"),
                                     "title": progdict['title'] or "Unavailable",
                                     "sub-title": progdict['sub-title'] or "Unavailable",
                                     "description": progdict['shortDesc'] or "Unavailable",
@@ -80,30 +78,30 @@ class Plugin_OBJ():
                                     "seasonnumber": progdict['season'],
                                     "episodenumber": progdict['episode'],
                                     "isnew": False,
-                                    "id": str(progdict['id'] or "%s_%s" % (cdict["channelId"], timestamp['time_start'])),
+                                    "id": str(progdict['id'] or self.xmltimestamp_zap(eventdict['startTime'])),
                                     }
 
                     for f in eventdict['filter']:
                         clean_prog_dict["genres"].append(f.replace('filter-', ''))
 
                     if 'movie' in clean_prog_dict['genres'] and clean_prog_dict['releaseyear']:
-                        clean_prog_dict["sub-title"] = 'Movie: %s' % clean_prog_dict['releaseyear']
+                        clean_prog_dict["sub-title"] = 'Movie: ' + clean_prog_dict['releaseyear']
                     elif clean_prog_dict['episodetitle']:
                         clean_prog_dict["sub-title"] = clean_prog_dict['episodetitle']
 
                     if 'New' in eventdict['flag'] and 'live' not in eventdict['flag']:
                         clean_prog_dict["isnew"] = True
 
-                    if not any((d['time_start'] == clean_prog_dict['time_start'] and d['id'] == clean_prog_dict['id']) for d in programguide[str(cdict["channelNo"])]["listing"]):
+                    if not any(d['id'] == clean_prog_dict['id'] for d in programguide[str(cdict["channelNo"])]["listing"]):
                         programguide[str(cdict["channelNo"])]["listing"].append(clean_prog_dict)
 
         return programguide
 
-    def zap2it_timestamps(self, starttime, endtime):
-        timestamp = {}
-        for time_item, time_value in zip(["time_start", "time_end"], [starttime, endtime]):
-            timestamp[time_item] = datetime.datetime.fromisoformat(time_value.replace('Z', '+00:00')).timestamp()
-        return timestamp
+    def xmltimestamp_zap(self, inputtime):
+        xmltime = inputtime.replace('Z', '+00:00')
+        xmltime = datetime.datetime.fromisoformat(xmltime)
+        xmltime = xmltime.strftime('%Y%m%d%H%M%S %z')
+        return xmltime
 
     def get_cached(self, i_times):
 
@@ -111,18 +109,18 @@ class Plugin_OBJ():
         for i_time in i_times:
 
             parameters = {
-                'aid': self.plugin_utils.config.dict["zap2it"]['affiliate_id'],
-                'country': self.plugin_utils.config.dict["zap2it"]['country'],
-                'device': self.plugin_utils.config.dict["zap2it"]['device'],
-                'headendId': self.plugin_utils.config.dict["zap2it"]['headendid'],
+                'aid': self.fhdhr.config.dict["zap2it"]['affiliate_id'],
+                'country': self.fhdhr.config.dict["zap2it"]['country'],
+                'device': self.fhdhr.config.dict["zap2it"]['device'],
+                'headendId': self.fhdhr.config.dict["zap2it"]['headendid'],
                 'isoverride': "true",
-                'languagecode': self.plugin_utils.config.dict["zap2it"]['languagecode'],
+                'languagecode': self.fhdhr.config.dict["zap2it"]['languagecode'],
                 'pref': 'm,p',
-                'timespan': self.plugin_utils.config.dict["zap2it"]['timespan'],
-                'timezone': self.plugin_utils.config.dict["zap2it"]['timezone'],
-                'userId': self.plugin_utils.config.dict["zap2it"]['userid'],
-                'postalCode': str(self.postalcode),
-                'lineupId': '%s-%s-DEFAULT' % (self.plugin_utils.config.dict["zap2it"]['country'], self.plugin_utils.config.dict["zap2it"]['device']),
+                'timespan': self.fhdhr.config.dict["zap2it"]['timespan'],
+                'timezone': self.fhdhr.config.dict["zap2it"]['timezone'],
+                'userId': self.fhdhr.config.dict["zap2it"]['userid'],
+                'postalCode': str(self.postalcode or self.get_location()),
+                'lineupId': '%s-%s-DEFAULT' % (self.fhdhr.config.dict["zap2it"]['country'], self.fhdhr.config.dict["zap2it"]['device']),
                 'time': i_time,
                 'Activity_ID': 1,
                 'FromPage': "TV%20Guide",
@@ -131,43 +129,43 @@ class Plugin_OBJ():
             url = 'https://tvlistings.zap2it.com/api/grid?'
             url += urllib.parse.urlencode(parameters)
             self.get_cached_item(str(i_time), url)
-        cache_list = self.plugin_utils.db.get_plugin_value("cache_list", "epg_cache", "zap2it") or []
-        return [self.plugin_utils.db.get_plugin_value(x, "epg_cache", "zap2it") for x in cache_list]
+        cache_list = self.fhdhr.db.get_cacheitem_value("cache_list", "offline_cache", "zap2it") or []
+        return [self.fhdhr.db.get_cacheitem_value(x, "offline_cache", "zap2it") for x in cache_list]
 
     def get_cached_item(self, cache_key, url):
-        cacheitem = self.plugin_utils.db.get_plugin_value(cache_key, "epg_cache", "zap2it")
+        cacheitem = self.fhdhr.db.get_cacheitem_value(cache_key, "offline_cache", "zap2it")
         if cacheitem:
-            self.plugin_utils.logger.info("FROM CACHE:  %s" % cache_key)
+            self.fhdhr.logger.info('FROM CACHE:  ' + str(cache_key))
             return cacheitem
         else:
-            self.plugin_utils.logger.info("Fetching:  %s" % url)
+            self.fhdhr.logger.info('Fetching:  ' + url)
             try:
-                resp = self.plugin_utils.web.session.get(url)
-            except self.plugin_utils.web.exceptions.HTTPError:
-                self.plugin_utils.logger.info('Got an error!  Ignoring it.')
+                resp = self.fhdhr.web.session.get(url)
+            except self.fhdhr.web.exceptions.HTTPError:
+                self.fhdhr.logger.info('Got an error!  Ignoring it.')
                 return
             result = resp.json()
 
-            self.plugin_utils.db.set_plugin_value(cache_key, "epg_cache", result, "zap2it")
-            cache_list = self.plugin_utils.db.get_plugin_value("cache_list", "epg_cache", "zap2it") or []
+            self.fhdhr.db.set_cacheitem_value(cache_key, "offline_cache", result, "zap2it")
+            cache_list = self.fhdhr.db.get_cacheitem_value("cache_list", "offline_cache", "zap2it") or []
             cache_list.append(cache_key)
-            self.plugin_utils.db.set_plugin_value("cache_list", "epg_cache", cache_list, "zap2it")
+            self.fhdhr.db.set_cacheitem_value("cache_list", "offline_cache", cache_list, "zap2it")
 
     def remove_stale_cache(self, zap_time):
 
-        cache_list = self.plugin_utils.db.get_plugin_value("cache_list", "epg_cache", "zap2it") or []
+        cache_list = self.fhdhr.db.get_cacheitem_value("cache_list", "offline_cache", "zap2it") or []
         cache_to_kill = []
         for cacheitem in cache_list:
             cachedate = int(cacheitem)
             if cachedate < zap_time:
                 cache_to_kill.append(cacheitem)
-                self.plugin_utils.db.delete_plugin_value(cacheitem, "epg_cache", "zap2it")
-                self.plugin_utils.logger.info("Removing stale cache:  %s" % cacheitem)
-        self.plugin_utils.db.set_plugin_value("cache_list", "epg_cache", [x for x in cache_list if x not in cache_to_kill], "zap2it")
+                self.fhdhr.db.delete_cacheitem_value(cacheitem, "offline_cache", "zap2it")
+                self.fhdhr.logger.info('Removing stale cache:  ' + str(cacheitem))
+        self.fhdhr.db.set_cacheitem_value("cache_list", "offline_cache", [x for x in cache_list if x not in cache_to_kill], "zap2it")
 
     def clear_cache(self):
-        cache_list = self.plugin_utils.db.get_plugin_value("cache_list", "epg_cache", "zap2it") or []
+        cache_list = self.fhdhr.db.get_cacheitem_value("cache_list", "offline_cache", "zap2it") or []
         for cacheitem in cache_list:
-            self.plugin_utils.db.delete_plugin_value(cacheitem, "epg_cache", "zap2it")
-            self.plugin_utils.logger.info("Removing cache:  %s" % cacheitem)
-        self.plugin_utils.db.delete_plugin_value("cache_list", "epg_cache", "zap2it")
+            self.fhdhr.db.delete_cacheitem_value(cacheitem, "offline_cache", "zap2it")
+            self.fhdhr.logger.info('Removing cache:  ' + str(cacheitem))
+        self.fhdhr.db.delete_cacheitem_value("cache_list", "offline_cache", "zap2it")

config.all.ini

@@ -0,0 +1,62 @@
+[main]
+# uuid =
+# cache_dir =
+# servicename = NextPVR
+# reponame = fHDHR_NextPVR
+
+[fhdhr]
+# address = 0.0.0.0
+# discovery_address = 0.0.0.0
+# port = 5004
+# stream_type = direct
+# tuner_count =  4
+# friendlyname = fHDHR-NextPVR
+# reporting_firmware_name = fHDHR_NextPVR
+# reporting_manufacturer = BoronDust
+# reporting_model = fHDHR
+# reporting_firmware_ver = 20201001
+# reporting_tuner_type = Antenna
+# device_auth = fHDHR
+
+[epg]
+# images = pass
+# method = origin
+# update_frequency = 43200
+
+[ffmpeg]
+# path = ffmpeg
+# bytes_per_read = 1152000
+
+[vlc]
+# path = cvlc
+# bytes_per_read = 1152000
+
+[direct_stream]
+# chunksize = 1048576
+
+[logging]
+# level = WARNING
+
+[database]
+# type = sqlite
+# driver = None
+
+[nextpvr]
+# address = localhost
+# port = 8866
+# ssl =
+# pin =
+
+[zap2it]
+# delay = 5
+# postalcode = None
+# affiliate_id = gapzap
+# country = USA
+# device = -
+# headendid = lineupId
+# isoverride = True
+# languagecode = en
+# pref =
+# timespan = 6
+# timezone =
+# userid = -

data/internal_config/epg.json

@@ -6,35 +6,14 @@
                     "config_web": true
                 },
           "method":{
-                    "value": "none",
+                    "value": "blocks",
                     "config_file": true,
                     "config_web": true
                 },
           "update_frequency":{
-                    "value": 43200,
+                    "value": 14400,
                     "config_file": true,
                     "config_web": true
-                },
-          "reverse_days": {
-                          "value": -1,
-                          "config_file": true,
-                          "config_web": true
-                        },
-          "forward_days": {
-                          "value": 7,
-                          "config_file": true,
-                          "config_web": true
-                        },
-          "block_size": {
-                          "value": 1800,
-                          "config_file": true,
-                          "config_web": true
-                        }
-                        ,
-          "xmltv_offset": {
-                          "value": "+0000",
-                          "config_file": true,
-                          "config_web": true
-                        }
+                }
   }
 }

data/internal_config/fhdhr.json

@@ -15,6 +15,26 @@
                   "config_file": true,
                   "config_web": true
                 },
+          "reporting_manufacturer":{
+                                    "value": "BoronDust",
+                                    "config_file": true,
+                                    "config_web": true
+                                  },
+          "reporting_model":{
+                              "value": "fHDHR",
+                              "config_file": true,
+                              "config_web": true
+                            },
+          "reporting_firmware_ver":{
+                                    "value": "20201001",
+                                    "config_file": true,
+                                    "config_web": true
+                                  },
+          "reporting_tuner_type":{
+                                  "value": "Antenna",
+                                  "config_file": true,
+                                  "config_web": true
+                                },
           "device_auth":{
                         "value": "fHDHR",
                         "config_file": true,
@@ -34,6 +54,21 @@
                     "value": "fHDHR",
                     "config_file": true,
                     "config_web": true
-                }
+                },
+          "stream_type":{
+                              "value": "direct",
+                              "config_file": true,
+                              "config_web": true
+                              },
+          "tuner_count":{
+                  "value": 4,
+                  "config_file": true,
+                  "config_web": true
+                },
+          "reporting_firmware_name":{
+                                    "value": "fHDHR",
+                                    "config_file": true,
+                                    "config_web": true
+                                  }
   }
 }

data/internal_config/logging.json

@@ -1,7 +1,7 @@
 {
   "logging":{
           "level":{
-                    "value": "INFO",
+                    "value": "WARNING",
                     "config_file": true,
                     "config_web": true
                 }

data/internal_config/main.json

@@ -10,15 +10,35 @@
                       "config_file": true,
                       "config_web": true
                     },
+          "thread_method":{
+                          "value": "multiprocessing",
+                          "config_file": true,
+                          "config_web": true
+                        },
           "servicename":{
                 "value": "fHDHR",
                 "config_file": false,
                 "config_web": false
-              },
+                },
+          "dictpopname":{
+                      "value": "fHDHR",
+                      "config_file": false,
+                      "config_web": false
+                    },
           "reponame":{
                           "value": "fHDHR",
                           "config_file": false,
                           "config_web": false
+                        },
+          "valid_epg_methods":{
+                          "value": "None,blocks",
+                          "config_file": false,
+                          "config_web": false
+                        },
+          "required":{
+                          "value": "none",
+                          "config_file": false,
+                          "config_web": false
                         }
   }
 }

data/internal_config/rmg.json

@@ -0,0 +1,9 @@
+{
+  "rmg":{
+          "enabled":{
+                "value": true,
+                "config_file": true,
+                "config_web": false
+                }
+  }
+}

data/internal_config/streaming.json

@@ -1,24 +1,33 @@
 {
-  "streaming":{
-                "bytes_per_read": {
-                                  "value": 1152000,
-                                  "config_file": true,
-                                  "config_web": true
+  "ffmpeg":{
+          "path":{
+                    "value": "ffmpeg",
+                    "config_file": true,
+                    "config_web": true
                 },
-                "origin_quality": {
-                              "value": "none",
-                              "config_file": true,
-                              "config_web": true
-                },
-                "transcode_quality": {
-                              "value": "none",
-                              "config_file": true,
-                              "config_web": true
-                },
-                "method": {
-                              "value": "direct",
-                              "config_file": true,
-                              "config_web": true
+          "bytes_per_read":{
+                    "value": 1152000,
+                    "config_file": true,
+                    "config_web": true
                 }
-              }
+  },
+  "vlc":{
+          "path":{
+                    "value": "cvlc",
+                    "config_file": true,
+                    "config_web": true
+                },
+          "bytes_per_read":{
+                    "value": 1152000,
+                    "config_file": true,
+                    "config_web": true
+                }
+  },
+  "direct_stream":{
+          "chunksize":{
+                    "value": 1048576,
+                    "config_file": true,
+                    "config_web": true
+                }
+  }
 }

data/internal_config/web_ui.json

@@ -4,11 +4,6 @@
                       "value": "none",
                       "config_file": true,
                       "config_web": true
-                  },
-            "access_level":{
-                      "value": "0",
-                      "config_file": true,
-                      "config_web": true
                   }
   }
 }

docs/ADV_Config.md

@@ -28,33 +28,14 @@ Here's the `main` section.
 # cache_dir =
 ````
 
-## streaming
-
-* `method` can be set to `ffmpeg`, `vlc` or `direct`.
-* `bytes_per_read` determines how many bytes of the stream to read before sending the data to your client. Increasing this value may cause longer load times, and lowering it may effect `stuttering`.
-* `origin_quality` can be set to high,medium,low for most variants. Variants that make use of m3u8 will Autoselect High for the direct method if not set. ffmpeg/vlc will determine the best stream on their own. Some Variants can allow alternative values.
-* `transcode_quality` works with ffmpeg/vlc to use fHDHR for handling quality instead of the origin. Valid settings include: heavy,mobile,internet720,internet480,internet360,internet240
-
-
-````
-[streaming]
-# method = direct
-# bytes_per_read = 1152000
-# origin_quality = None
-# transcode_quality = None
-````
-
-
 ## fhdhr
 
 The `fhdhr` contains all the configuration options for interfacing between this script and your media platform.
 * `address` and `port` are what we will allow the script to listen on. `0.0.0.0` is the default, and will respond to all.
 * `discovery_address` may be helpful for making SSDP work properly. If `address` is not `0.0.0.0`, we will use that. If this is not set to a real IP, we won't run SSDP. SSDP is only really helpful for discovering in Plex/Emby. It's a wasted resource since you can manually add the `ip:port` of the script to Plex.
-* `tuner_count` is a limit of devices able to stream from the script. The default is 3, as per Locast's documentation. A 4th is possible, but is not reccomended.
+* `tuner_count` is a limit of devices able to stream from the script.
 * `friendlyname` is to set the name that Plex sees the script as.
-* `reporting_*` are settings that show how the script projects itself as a hardware device.
-* `device_auth` and `require_auth` are for an unimplemented Authentication feature.
-* `chanscan_on_start` Scans Origin for new channels at startup.
+* `stream_type` can be set to `ffmpeg`, `vlc` or `direct`.
 
 
 ````
@@ -62,56 +43,61 @@ The `fhdhr` contains all the configuration options for interfacing between this
 # address = 0.0.0.0
 # discovery_address = 0.0.0.0
 # port = 5004
+# stream_type = direct
 # tuner_count =  4
-# friendlyname = fHDHR-Locast
-# reporting_firmware_name = fHDHR_Locast
+# friendlyname = fHDHR-NextPVR
+# reporting_firmware_name = fHDHR_NextPVR
 # reporting_manufacturer = BoronDust
 # reporting_model = fHDHR
 # reporting_firmware_ver = 20201001
 # reporting_tuner_type = Antenna
 # device_auth = fHDHR
-# require_auth = False
-# chanscan_on_start = True
 ````
 
 # EPG
 * `images` can be set to `proxy` or `pass`. If you choose `proxy`, images will be reverse proxied through fHDHR.
-* `method` defaults to `origin` and will pull the xmltv data from Locast. Other Options include `blocks` which is an hourly schedule with minimal channel information. Another option is `zap2it`, which is another source of EPG information. Channel Numbers may need to be manually mapped.
-* `update_frequency` determines how often we check for new scheduling information. In Seconds.
-* `reverse_days` allows Blocks of EPG data to be created prior to the start of the EPG Source data.
-* `forward_days` allows Blocks of EPG data to be created after the end of the EPG Source data.
-* `block_size` in seconds, sets the default block size for data before, after and missing timeslots.
-* `xmltv_offset` allows the final xmltv file to have an offset for users with timezone issues.
+* `method` defaults to `origin` and will pull the xmltv data from NextPVR. Other Options include `blocks` which is an hourly schedule with minimal channel information. Another option is `zap2it`, which is another source of EPG information. Channel Numbers may need to be manually mapped.
+* `update_frequency` * `epg_update_frequency` determines how often we check for new scheduling information. In Seconds.
 
 ````
 [epg]
 # images = pass
 # method = origin
 # update_frequency = 43200
-# reverse_days = -1
-# forward_days = 7
-# block_size = 1800
-# xmltv_offset = +0000
 ````
 
 ## ffmpeg
 
 The `ffmpeg` section includes:
 * `path` is useful if ffmpeg is not in your systems PATH, or you want to manually specify.
+* `bytes_per_read` determines how many bytes of the stream to read before sending the data to your client. Increasing this value may cause longer load times, and lowering it may effect `stuttering`.
 
 ````
 [ffmpeg]
 # path = ffmpeg
+# bytes_per_read = 1152000
 ````
 
 ## vlc
 
 The `vlc` section includes:
 * `path` is useful if ffmpeg is not in your systems PATH, or you want to manually specify.
+* `bytes_per_read` determines how many bytes of the stream to read before sending the data to your client. Increasing this value may cause longer load times, and lowering it may effect `stuttering`.
 
 ````
 [vlc]
-# path = cvlc
+# path = ffmpeg
+# bytes_per_read = 1152000
+````
+
+## direct_stream
+
+The `direct_stream` section is for when you set the `[fhdhr]stream_type` to `direct`
+* `chunksize` is how much data to read at a time.
+
+````
+[direct_stream]
+# chunksize = 1024*1024
 ````
 
 # Logging
@@ -131,27 +117,6 @@ TODO: improve documentation here.
 [database]
 # type = sqlite
 # driver = None
-user = None
-pass = None
-host = None
-port = None
-name = None
-````
-
-## RMG
-
-````
-# enabled = True
-````
-
-## SSDP
-
-````
-# enabled = True
-# max_age = 1800
-# proto = ipv6
-# iface = None
-# multicast_address = None
 ````
 
 ## NextPVR

fHDHR/__init__.py

@@ -1,42 +1,37 @@
 # coding=utf-8
 
+from .originwrapper import OriginServiceWrapper
 from .device import fHDHR_Device
 from .api import fHDHR_API_URLs
 
 import fHDHR.tools
-fHDHR_VERSION = "v0.6.0-beta"
+
+fHDHR_VERSION = "v0.4.6-beta"
 
 
 class fHDHR_INT_OBJ():
 
-    def __init__(self, settings, logger, db, plugins):
+    def __init__(self, settings, logger, db):
         self.version = fHDHR_VERSION
         self.config = settings
         self.logger = logger
         self.db = db
-        self.plugins = plugins
 
         self.web = fHDHR.tools.WebReq()
-        for plugin_name in list(self.plugins.plugins.keys()):
-            self.plugins.plugins[plugin_name].plugin_utils.web = self.web
 
-        self.api = fHDHR_API_URLs(settings, self.web)
-        for plugin_name in list(self.plugins.plugins.keys()):
-            self.plugins.plugins[plugin_name].plugin_utils.api = self.api
-
-        self.threads = {}
+        self.api = fHDHR_API_URLs(settings)
 
 
 class fHDHR_OBJ():
 
-    def __init__(self, settings, logger, db, plugins):
-        self.fhdhr = fHDHR_INT_OBJ(settings, logger, db, plugins)
+    def __init__(self, settings, logger, db, origin, alternative_epg):
+        self.fhdhr = fHDHR_INT_OBJ(settings, logger, db)
 
-        self.fhdhr.origins = fHDHR.origins.Origins(self.fhdhr)
+        self.originwrapper = OriginServiceWrapper(self.fhdhr, origin)
 
-        self.device = fHDHR_Device(self.fhdhr, self.fhdhr.origins)
+        self.device = fHDHR_Device(self.fhdhr, self.originwrapper, alternative_epg)
 
     def __getattr__(self, name):
         ''' will only get called for undefined attributes '''
         if hasattr(self.fhdhr, name):
-            return eval("self.fhdhr.%s" % name)
+            return eval("self.fhdhr." + name)

fHDHR/api/__init__.py

@@ -1,61 +1,15 @@
 import urllib.parse
 
 
-class Fillin_Client():
-
-    def __init__(self, settings, web):
-        self.config = settings
-        self.web = web
-
-    def __getattr__(self, name):
-        ''' will only get called for undefined attributes '''
-        if hasattr(self.web.session, name):
-            return eval("self.web.session.%s" % name)
-
-
 class fHDHR_API_URLs():
 
-    def __init__(self, settings, web):
+    def __init__(self, settings):
         self.config = settings
-        self.web = web
-
-        self.headers = {'User-Agent': "fHDHR/%s" % self.config.internal["versions"]["fHDHR"]}
-
-        # Replaced later
-        self.client = Fillin_Client(settings, web)
 
         self.address = self.config.dict["fhdhr"]["address"]
         self.discovery_address = self.config.dict["fhdhr"]["discovery_address"]
         self.port = self.config.dict["fhdhr"]["port"]
 
-    def get(self, url, *args):
-
-        req_method = type(self.client).__name__
-
-        if not url.startswith("http"):
-            if not url.startswith("/"):
-                url = "/%s" % url
-            url = "%s%s" % (self.base, url)
-
-        if req_method == "FlaskClient":
-            self.client.get(url, headers=self.headers, *args)
-        else:
-            self.client.get(url, headers=self.headers, *args)
-
-    def post(self, url, *args):
-
-        req_method = type(self.client).__name__
-
-        if not url.startswith("http"):
-            if not url.startswith("/"):
-                url = "/%s" % url
-            url = "%s%s" % (self.base, url)
-
-        if req_method == "FlaskClient":
-            self.client.post(url, headers=self.headers, *args)
-        else:
-            self.client.post(url, headers=self.headers, *args)
-
     @property
     def base(self):
         if self.discovery_address:

fHDHR/cli/run.py

@@ -2,13 +2,13 @@ import os
 import sys
 import argparse
 import time
+import multiprocessing
+import threading
+import platform
 
 from fHDHR import fHDHR_VERSION, fHDHR_OBJ
 import fHDHR.exceptions
 import fHDHR.config
-import fHDHR.logger
-import fHDHR.plugins
-import fHDHR.origins
 from fHDHR.db import fHDHRdb
 
 ERR_CODE = 1
@@ -19,6 +19,10 @@ if sys.version_info.major == 2 or sys.version_info < (3, 7):
     print('Error: fHDHR requires python 3.7+.')
     sys.exit(1)
 
+opersystem = platform.system()
+if opersystem in ["Windows"]:
+    print("WARNING: This script may fail on Windows. Try Setting the `thread_method` to `threading`")
+
 
 def build_args_parser():
     """Build argument parser for fHDHR"""
@@ -27,38 +31,48 @@ def build_args_parser():
     return parser.parse_args()
 
 
-def get_configuration(args, script_dir, fHDHR_web):
+def get_configuration(args, script_dir, origin, fHDHR_web):
     if not os.path.isfile(args.cfg):
         raise fHDHR.exceptions.ConfigurationNotFound(filename=args.cfg)
-    return fHDHR.config.Config(args.cfg, script_dir, fHDHR_web)
+    return fHDHR.config.Config(args.cfg, script_dir, origin, fHDHR_web)
 
 
-def run(settings, logger, db, script_dir, fHDHR_web, plugins):
+def run(settings, logger, db, script_dir, fHDHR_web, origin, alternative_epg):
 
-    fhdhr = fHDHR_OBJ(settings, logger, db, plugins)
+    fhdhr = fHDHR_OBJ(settings, logger, db, origin, alternative_epg)
     fhdhrweb = fHDHR_web.fHDHR_HTTP_Server(fhdhr)
 
     try:
 
-        # Start Flask Thread
-        fhdhrweb.start()
+        print("HTTP Server Starting")
+        if settings.dict["main"]["thread_method"] in ["multiprocessing"]:
+            fhdhr_web = multiprocessing.Process(target=fhdhrweb.run)
+        elif settings.dict["main"]["thread_method"] in ["threading"]:
+            fhdhr_web = threading.Thread(target=fhdhrweb.run)
+        if settings.dict["main"]["thread_method"] in ["multiprocessing", "threading"]:
+            fhdhr_web.start()
 
-        # Start SSDP Thread
         if settings.dict["fhdhr"]["discovery_address"]:
-            fhdhr.device.ssdp.start()
+            print("SSDP Server Starting")
+            if settings.dict["main"]["thread_method"] in ["multiprocessing"]:
+                fhdhr_ssdp = multiprocessing.Process(target=fhdhr.device.ssdp.run)
+            elif settings.dict["main"]["thread_method"] in ["threading"]:
+                fhdhr_ssdp = threading.Thread(target=fhdhr.device.ssdp.run)
+            if settings.dict["main"]["thread_method"] in ["multiprocessing", "threading"]:
+                fhdhr_ssdp.start()
 
-        # Start EPG Thread
         if settings.dict["epg"]["method"]:
-            fhdhr.device.epg.start()
-
-        # Perform some actions now that HTTP Server is running
-        fhdhr.api.get("/api/startup_tasks")
+            print("EPG Update Starting")
+            if settings.dict["main"]["thread_method"] in ["multiprocessing"]:
+                fhdhr_epg = multiprocessing.Process(target=fhdhr.device.epg.run)
+            elif settings.dict["main"]["thread_method"] in ["threading"]:
+                fhdhr_epg = threading.Thread(target=fhdhr.device.epg.run)
+            if settings.dict["main"]["thread_method"] in ["multiprocessing", "threading"]:
+                fhdhr_epg.start()
 
         # wait forever
-        restart_code = "restart"
-        while fhdhr.threads["flask"].is_alive():
-            time.sleep(1)
-        return restart_code
+        while True:
+            time.sleep(3600)
 
     except KeyboardInterrupt:
         return ERR_CODE_NO_RESTART
@@ -66,52 +80,32 @@ def run(settings, logger, db, script_dir, fHDHR_web, plugins):
     return ERR_CODE
 
 
-def start(args, script_dir, fHDHR_web):
+def start(args, script_dir, fHDHR_web, origin, alternative_epg):
     """Get Configuration for fHDHR and start"""
 
     try:
-        settings = get_configuration(args, script_dir, fHDHR_web)
+        settings = get_configuration(args, script_dir, origin, fHDHR_web)
     except fHDHR.exceptions.ConfigurationError as e:
         print(e)
         return ERR_CODE_NO_RESTART
 
-    # Find Plugins and import their default configs
-    plugins = fHDHR.plugins.PluginsHandler(settings)
+    logger = settings.logging_setup()
 
-    # Apply User Configuration
-    settings.user_config()
-    settings.config_verification()
-
-    # Setup Logging
-    logger = fHDHR.logger.Logger(settings)
-
-    # Setup Database
     db = fHDHRdb(settings)
 
-    # Setup Plugins
-    plugins.load_plugins(logger, db)
-    plugins.setup()
-    settings.config_verification_plugins()
-
-    if not len([x for x in list(plugins.plugins.keys()) if plugins.plugins[x].type == "origin"]):
-        print("No Origin Plugins found.")
-        return ERR_CODE
-
-    return run(settings, logger, db, script_dir, fHDHR_web, plugins)
+    return run(settings, logger, db, script_dir, fHDHR_web, origin, alternative_epg)
 
 
-def main(script_dir, fHDHR_web):
+def main(script_dir, fHDHR_web, origin, alternative_epg):
     """fHDHR run script entry point"""
 
     print("Loading fHDHR %s" % fHDHR_VERSION)
     print("Loading fHDHR_web %s" % fHDHR_web.fHDHR_web_VERSION)
+    print("Loading Origin Service: %s %s" % (origin.ORIGIN_NAME, origin.ORIGIN_VERSION))
 
     try:
         args = build_args_parser()
-        while True:
-            returned_code = start(args, script_dir, fHDHR_web)
-            if returned_code not in ["restart"]:
-                return returned_code
+        return start(args, script_dir, fHDHR_web, origin, alternative_epg)
     except KeyboardInterrupt:
         print("\n\nInterrupted")
         return ERR_CODE

fHDHR/config/__init__.py

@@ -3,6 +3,8 @@ import sys
 import random
 import configparser
 import pathlib
+import logging
+import subprocess
 import platform
 import json
 
@@ -13,31 +15,31 @@ from fHDHR.tools import isint, isfloat, is_arithmetic, is_docker
 
 class Config():
 
-    def __init__(self, filename, script_dir, fHDHR_web):
+    def __init__(self, filename, script_dir, origin, fHDHR_web):
+        self.origin = origin
         self.fHDHR_web = fHDHR_web
 
         self.internal = {}
         self.conf_default = {}
         self.dict = {}
-        self.internal["versions"] = {}
         self.config_file = filename
 
-        self.core_setup(script_dir)
+        self.initial_load(script_dir)
+        self.config_verification()
 
-    def core_setup(self, script_dir):
+    def initial_load(self, script_dir):
 
         data_dir = pathlib.Path(script_dir).joinpath('data')
-        internal_plugins_dir = pathlib.Path(script_dir).joinpath('plugins')
         fHDHR_web_dir = pathlib.Path(script_dir).joinpath('fHDHR_web')
         www_dir = pathlib.Path(fHDHR_web_dir).joinpath('www_dir')
 
         self.internal["paths"] = {
                                     "script_dir": script_dir,
                                     "data_dir": data_dir,
-                                    "plugins_dir": [internal_plugins_dir],
+                                    "alternative_epg": pathlib.Path(script_dir).joinpath('alternative_epg'),
+                                    "origin": pathlib.Path(script_dir).joinpath('origin'),
                                     "cache_dir": pathlib.Path(data_dir).joinpath('cache'),
                                     "internal_config": pathlib.Path(data_dir).joinpath('internal_config'),
-                                    "fHDHR_web_dir": fHDHR_web_dir,
                                     "www_dir": www_dir,
                                     "www_templates_dir": pathlib.Path(fHDHR_web_dir).joinpath('templates'),
                                     "font": pathlib.Path(data_dir).joinpath('garamond.ttf'),
@@ -48,66 +50,32 @@ class Config():
             if str(conffilepath).endswith(".json"):
                 self.read_json_config(conffilepath)
 
-        for file_item in os.listdir(self.internal["paths"]["fHDHR_web_dir"]):
-            file_item_path = pathlib.Path(self.internal["paths"]["fHDHR_web_dir"]).joinpath(file_item)
-            if str(file_item_path).endswith("_conf.json"):
-                self.read_json_config(file_item_path)
+        for dir_type in ["alternative_epg", "origin"]:
 
-        self.dict["epg"]["valid_methods"] = {None: {}}
-        self.dict["origins"] = {}
-        self.dict["origins"]["valid_methods"] = {}
-        self.dict["streaming"]["valid_methods"] = {"direct": {}}
-        self.dict["plugin_web_paths"] = {}
+            for file_item in os.listdir(self.internal["paths"][dir_type]):
+                file_item_path = os.path.join(self.internal["paths"][dir_type], file_item)
+                if str(file_item_path).endswith("_conf.json"):
+                    self.read_json_config(file_item_path)
+
+        print("Loading Configuration File: " + str(self.config_file))
+        self.read_ini_config(self.config_file)
 
         self.load_versions()
 
-    def register_web_path(self, name, path, plugin_dict_name):
-        self.dict["plugin_web_paths"][name.lower()] = {
-            "name": name,
-            "namespace": name.lower(),
-            "path": path,
-            "plugin": plugin_dict_name
-            }
-
-    def register_valid_origin_method(self, method_item):
-        self.dict["origins"]["valid_methods"][method_item.lower()] = {
-            "name": method_item,
-            "namespace": method_item.lower(),
-            }
-
-    def register_valid_streaming_method(self, method_item, plugin_dict_name):
-        self.dict["streaming"]["valid_methods"][method_item.lower()] = {
-            "name": method_item,
-            "namespace": method_item.lower(),
-            "plugin": plugin_dict_name
-            }
-
-    def register_valid_epg_method(self, method_item, plugin_dict_name):
-        self.dict["epg"]["valid_methods"][method_item.lower()] = {
-            "name": method_item,
-            "namespace": method_item.lower(),
-            "plugin": plugin_dict_name
-            }
-
-    def register_version(self, item_name, item_version, item_type):
-        self.internal["versions"][item_name] = {
-                                                "name": item_name,
-                                                "version": item_version,
-                                                "type": item_type
-                                                }
-
-    def import_conf_json(self, file_item_path):
-        self.read_json_config(file_item_path)
-
     def load_versions(self):
 
-        self.register_version("fHDHR", fHDHR_VERSION, "fHDHR")
-        self.register_version("fHDHR_web", self.fHDHR_web.fHDHR_web_VERSION, "fHDHR")
+        self.internal["versions"] = {}
 
-        self.register_version("Python", sys.version, "env")
+        self.internal["versions"]["fHDHR"] = fHDHR_VERSION
+
+        self.internal["versions"]["fHDHR_web"] = self.fHDHR_web.fHDHR_web_VERSION
+
+        self.internal["versions"][self.origin.ORIGIN_NAME] = self.origin.ORIGIN_VERSION
+
+        self.internal["versions"]["Python"] = sys.version
 
         opersystem = platform.system()
-        self.register_version("Operating System", opersystem, "env")
+        self.internal["versions"]["Operating System"] = opersystem
         if opersystem in ["Linux", "Darwin"]:
             # Linux/Mac
             if os.getuid() == 0 or os.geteuid() == 0:
@@ -120,90 +88,41 @@ class Config():
             print("Uncommon Operating System, use at your own risk.")
 
         isdocker = is_docker()
-        self.register_version("Docker", isdocker, "env")
+        self.internal["versions"]["Docker"] = isdocker
 
-    def user_config(self):
-        print("Loading Configuration File: %s" % self.config_file)
-        self.read_ini_config(self.config_file)
+        if self.dict["fhdhr"]["stream_type"] == "ffmpeg":
+            try:
+                ffmpeg_command = [self.dict["ffmpeg"]["path"],
+                                  "-version",
+                                  "pipe:stdout"
+                                  ]
 
-    def config_verification_plugins(self):
-        required_missing = {}
-        # create dict and combine items
-        for config_section in list(self.conf_default.keys()):
-            for config_item in list(self.conf_default[config_section].keys()):
-                if self.conf_default[config_section][config_item]["required"]:
-                    if not self.dict[config_section][config_item]:
-                        if config_section not in list(required_missing.keys()):
-                            required_missing[config_section] = []
-                        required_missing[config_section].append(config_item)
-        for config_section in list(required_missing.keys()):
-            print("Warning! Required configuration options missing: [%s]%s" % (config_section, ", ".join(required_missing[config_section])))
+                ffmpeg_proc = subprocess.Popen(ffmpeg_command, stdout=subprocess.PIPE)
+                ffmpeg_version = ffmpeg_proc.stdout.read()
+                ffmpeg_proc.terminate()
+                ffmpeg_proc.communicate()
+                ffmpeg_version = ffmpeg_version.decode().split("version ")[1].split(" ")[0]
+            except FileNotFoundError:
+                ffmpeg_version = "Missing"
+                print("Failed to find ffmpeg.")
+            self.internal["versions"]["ffmpeg"] = ffmpeg_version
 
-        if self.dict["epg"]["method"] and self.dict["epg"]["method"] not in ["None"]:
-            if isinstance(self.dict["epg"]["method"], str):
-                self.dict["epg"]["method"] = [self.dict["epg"]["method"]]
-            epg_methods = []
-            for epg_method in self.dict["epg"]["method"]:
-                if epg_method in list(self.dict["epg"]["valid_methods"].keys()):
-                    epg_methods.append(epg_method)
-                elif epg_method in list(self.dict["origins"]["valid_methods"].keys()):
-                    epg_methods.append(epg_method)
-                else:
-                    raise fHDHR.exceptions.ConfigurationError("Invalid EPG Method. Exiting...")
-        if self.dict["epg"]["method"]:
-            self.dict["epg"]["def_method"] = self.dict["epg"]["method"][0]
-        else:
-            self.dict["epg"]["def_method"] = None
+        if self.dict["fhdhr"]["stream_type"] == "vlc":
+            try:
+                vlc_command = [self.dict["vlc"]["path"],
+                               "--version",
+                               "pipe:stdout"
+                               ]
 
-        if self.dict["streaming"]["method"] not in self.dict["streaming"]["valid_methods"]:
-            raise fHDHR.exceptions.ConfigurationError("Invalid stream type. Exiting...")
-
-    def config_verification(self):
-
-        if not self.dict["main"]["uuid"]:
-            self.dict["main"]["uuid"] = ''.join(random.choice("hijklmnopqrstuvwxyz") for i in range(8))
-            self.write('uuid', self.dict["main"]["uuid"], 'main')
-
-        if self.dict["main"]["cache_dir"]:
-            if not pathlib.Path(self.dict["main"]["cache_dir"]).is_dir():
-                raise fHDHR.exceptions.ConfigurationError("Invalid Cache Directory. Exiting...")
-            self.internal["paths"]["cache_dir"] = pathlib.Path(self.dict["main"]["cache_dir"])
-        cache_dir = self.internal["paths"]["cache_dir"]
-
-        logs_dir = pathlib.Path(cache_dir).joinpath('logs')
-        self.internal["paths"]["logs_dir"] = logs_dir
-        if not logs_dir.is_dir():
-            logs_dir.mkdir()
-
-        self.dict["database"]["path"] = pathlib.Path(cache_dir).joinpath('fhdhr.db')
-
-        if not self.dict["fhdhr"]["discovery_address"] and self.dict["fhdhr"]["address"] != "0.0.0.0":
-            self.dict["fhdhr"]["discovery_address"] = self.dict["fhdhr"]["address"]
-        if not self.dict["fhdhr"]["discovery_address"] or self.dict["fhdhr"]["discovery_address"] == "0.0.0.0":
-            self.dict["fhdhr"]["discovery_address"] = None
-
-    def get_real_conf_value(self, key, confvalue):
-        if not confvalue:
-            confvalue = None
-        elif key == "xmltv_offset":
-            confvalue = str(confvalue)
-        elif str(confvalue) in ["0"]:
-            confvalue = 0
-        elif isint(confvalue):
-            confvalue = int(confvalue)
-        elif isfloat(confvalue):
-            confvalue = float(confvalue)
-        elif is_arithmetic(confvalue):
-            confvalue = eval(confvalue)
-        elif "," in confvalue:
-            confvalue = confvalue.split(",")
-        elif str(confvalue).lower() in ["none", ""]:
-            confvalue = None
-        elif str(confvalue).lower() in ["false"]:
-            confvalue = False
-        elif str(confvalue).lower() in ["true"]:
-            confvalue = True
-        return confvalue
+                vlc_proc = subprocess.Popen(vlc_command, stdout=subprocess.PIPE)
+                vlc_version = vlc_proc.stdout.read()
+                vlc_proc.terminate()
+                vlc_proc.communicate()
+                vlc_version = vlc_version.decode().split("version ")[1].split('\n')[0]
+            except FileNotFoundError:
+                vlc_version = "Missing"
+                print("Failed to find vlc.")
+            self.internal["versions"]["vlc"] = vlc_version
 
     def read_json_config(self, conffilepath):
         with open(conffilepath, 'r') as jsonconf:
@@ -221,13 +140,27 @@ class Config():
                 if key not in list(self.conf_default[section].keys()):
                     self.conf_default[section][key] = {}
 
-                confvalue = self.get_real_conf_value(key, confimport[section][key]["value"])
+                confvalue = confimport[section][key]["value"]
+                if isint(confvalue):
+                    confvalue = int(confvalue)
+                elif isfloat(confvalue):
+                    confvalue = float(confvalue)
+                elif is_arithmetic(confvalue):
+                    confvalue = eval(confvalue)
+                elif "," in confvalue:
+                    confvalue = confvalue.split(",")
+                elif str(confvalue).lower() in ["none"]:
+                    confvalue = None
+                elif str(confvalue).lower() in ["false"]:
+                    confvalue = False
+                elif str(confvalue).lower() in ["true"]:
+                    confvalue = True
 
                 self.dict[section][key] = confvalue
 
                 self.conf_default[section][key]["value"] = confvalue
 
-                for config_option in ["config_web_hidden", "config_file", "config_web", "required"]:
+                for config_option in ["config_web_hidden", "config_file", "config_web"]:
                     if config_option not in list(confimport[section][key].keys()):
                         config_option_value = False
                     else:
@@ -247,7 +180,22 @@ class Config():
             if each_section.lower() not in list(self.dict.keys()):
                 self.dict[each_section.lower()] = {}
             for (each_key, each_val) in config_handler.items(each_section):
-                each_val = self.get_real_conf_value(each_key, each_val)
+                if not each_val:
+                    each_val = None
+                elif each_val.lower() in ["none"]:
+                    each_val = None
+                elif each_val.lower() in ["false"]:
+                    each_val = False
+                elif each_val.lower() in ["true"]:
+                    each_val = True
+                elif isint(each_val):
+                    each_val = int(each_val)
+                elif isfloat(each_val):
+                    each_val = float(each_val)
+                elif is_arithmetic(each_val):
+                    each_val = eval(each_val)
+                elif "," in each_val:
+                    each_val = each_val.split(",")
 
                 import_val = True
                 if each_section in list(self.conf_default.keys()):
@@ -258,24 +206,11 @@ class Config():
                 if import_val:
                     self.dict[each_section.lower()][each_key.lower()] = each_val
 
-    def write(self, key, value, section):
-
-        if not value:
-            value = None
-        if value.lower() in ["none"]:
-            value = None
-        elif value.lower() in ["false"]:
-            value = False
-        elif value.lower() in ["true"]:
-            value = True
-        elif isint(value):
-            value = int(value)
-        elif isfloat(value):
-            value = float(value)
-        elif isinstance(value, list):
-            ",".join(value)
-
-        self.dict[section][key] = value
+    def write(self, section, key, value):
+        if section == self.dict["main"]["dictpopname"]:
+            self.dict["origin"][key] = value
+        else:
+            self.dict[section][key] = value
 
         config_handler = configparser.ConfigParser()
         config_handler.read(self.config_file)
@@ -283,11 +218,100 @@ class Config():
         if not config_handler.has_section(section):
             config_handler.add_section(section)
 
-        config_handler.set(section, key, str(value))
+        config_handler.set(section, key, value)
 
         with open(self.config_file, 'w') as config_file:
             config_handler.write(config_file)
 
+    def config_verification(self):
+
+        if self.dict["main"]["thread_method"] not in ["threading", "multiprocessing"]:
+            raise fHDHR.exceptions.ConfigurationError("Invalid Threading Method. Exiting...")
+
+        if self.dict["main"]["required"]:
+            required_missing = []
+            if isinstance(self.dict["main"]["required"], str):
+                self.dict["main"]["required"] = [self.dict["main"]["required"]]
+            if len(self.dict["main"]["required"]):
+                for req_item in self.dict["main"]["required"]:
+                    req_section = req_item.split("/")[0]
+                    req_key = req_item.split("/")[1]
+                    if not self.dict[req_section][req_key]:
+                        required_missing.append(req_item)
+            if len(required_missing):
+                raise fHDHR.exceptions.ConfigurationError("Required configuration options missing: " + ", ".join(required_missing))
+
+        self.dict["origin"] = self.dict.pop(self.dict["main"]["dictpopname"])
+
+        if isinstance(self.dict["main"]["valid_epg_methods"], str):
+            self.dict["main"]["valid_epg_methods"] = [self.dict["main"]["valid_epg_methods"]]
+
+        if self.dict["epg"]["method"] and self.dict["epg"]["method"] not in ["None"]:
+            if isinstance(self.dict["epg"]["method"], str):
+                self.dict["epg"]["method"] = [self.dict["epg"]["method"]]
+            epg_methods = []
+            for epg_method in self.dict["epg"]["method"]:
+                if epg_method == self.dict["main"]["dictpopname"] or epg_method == "origin":
+                    epg_methods.append("origin")
+                elif epg_method in ["None"]:
+                    raise fHDHR.exceptions.ConfigurationError("Invalid EPG Method. Exiting...")
+                elif epg_method in self.dict["main"]["valid_epg_methods"]:
+                    epg_methods.append(epg_method)
+                else:
+                    raise fHDHR.exceptions.ConfigurationError("Invalid EPG Method. Exiting...")
+        self.dict["epg"]["def_method"] = self.dict["epg"]["method"][0]
+
+        if not self.dict["main"]["uuid"]:
+            self.dict["main"]["uuid"] = ''.join(random.choice("hijklmnopqrstuvwxyz") for i in range(8))
+            self.write('main', 'uuid', self.dict["main"]["uuid"])
+
+        if self.dict["main"]["cache_dir"]:
+            if not pathlib.Path(self.dict["main"]["cache_dir"]).is_dir():
+                raise fHDHR.exceptions.ConfigurationError("Invalid Cache Directory. Exiting...")
+            self.internal["paths"]["cache_dir"] = pathlib.Path(self.dict["main"]["cache_dir"])
+        cache_dir = self.internal["paths"]["cache_dir"]
+
+        logs_dir = pathlib.Path(cache_dir).joinpath('logs')
+        self.internal["paths"]["logs_dir"] = logs_dir
+        if not logs_dir.is_dir():
+            logs_dir.mkdir()
+
+        self.dict["database"]["path"] = pathlib.Path(cache_dir).joinpath('fhdhr.db')
+
+        if self.dict["fhdhr"]["stream_type"] not in ["direct", "ffmpeg", "vlc"]:
+            raise fHDHR.exceptions.ConfigurationError("Invalid stream type. Exiting...")
+
+        if not self.dict["fhdhr"]["discovery_address"] and self.dict["fhdhr"]["address"] != "0.0.0.0":
+            self.dict["fhdhr"]["discovery_address"] = self.dict["fhdhr"]["address"]
+        if not self.dict["fhdhr"]["discovery_address"] or self.dict["fhdhr"]["discovery_address"] == "0.0.0.0":
+            self.dict["fhdhr"]["discovery_address"] = None
+
+    def logging_setup(self):
+
+        log_level = self.dict["logging"]["level"].upper()
+
+        # Create a custom logger
+        logging.basicConfig(format='%(name)s - %(levelname)s - %(message)s', level=log_level)
+        logger = logging.getLogger('fHDHR')
+        log_file = os.path.join(self.internal["paths"]["logs_dir"], 'fHDHR.log')
+
+        # Create handlers
+        # c_handler = logging.StreamHandler()
+        f_handler = logging.FileHandler(log_file)
+        # c_handler.setLevel(log_level)
+        f_handler.setLevel(log_level)
+
+        # Create formatters and add it to handlers
+        # c_format = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
+        f_format = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        # c_handler.setFormatter(c_format)
+        f_handler.setFormatter(f_format)
+
+        # Add handlers to the logger
+        # logger.addHandler(c_handler)
+        logger.addHandler(f_handler)
+        return logger
+
     def __getattr__(self, name):
         ''' will only get called for undefined attributes '''
         if name in list(self.dict.keys()):

fHDHR/db/__init__.py

@@ -32,10 +32,28 @@ MYSQL_TABLE_ARGS = {'mysql_engine': 'InnoDB',
                     'mysql_collate': 'utf8mb4_unicode_ci'}
 
 
-class PluginValues(BASE):
-    __tablename__ = 'plugin_values'
+class ChannelValues(BASE):
+    __tablename__ = 'channel_values'
     __table_args__ = MYSQL_TABLE_ARGS
-    pluginitem = Column(String(255), primary_key=True)
+    channel = Column(String(255), primary_key=True)
+    namespace = Column(String(255), primary_key=True)
+    key = Column(String(255), primary_key=True)
+    value = Column(Text())
+
+
+class ProgramValues(BASE):
+    __tablename__ = 'program_values'
+    __table_args__ = MYSQL_TABLE_ARGS
+    program = Column(String(255), primary_key=True)
+    namespace = Column(String(255), primary_key=True)
+    key = Column(String(255), primary_key=True)
+    value = Column(Text())
+
+
+class CacheValues(BASE):
+    __tablename__ = 'cache_values'
+    __table_args__ = MYSQL_TABLE_ARGS
+    cacheitem = Column(String(255), primary_key=True)
     namespace = Column(String(255), primary_key=True)
     key = Column(String(255), primary_key=True)
     value = Column(Text())
@@ -130,6 +148,198 @@ class fHDHRdb(object):
     def get_uri(self):
         return self.url
 
+    # Channel Values
+
+    def set_channel_value(self, channel, key, value, namespace='default'):
+        channel = channel.lower()
+        value = json.dumps(value, ensure_ascii=False)
+        session = self.ssession()
+        try:
+            result = session.query(ChannelValues) \
+                .filter(ChannelValues.channel == channel)\
+                .filter(ChannelValues.namespace == namespace)\
+                .filter(ChannelValues.key == key) \
+                .one_or_none()
+            # ChannelValues exists, update
+            if result:
+                result.value = value
+                session.commit()
+            # DNE - Insert
+            else:
+                new_channelvalue = ChannelValues(channel=channel, namespace=namespace, key=key, value=value)
+                session.add(new_channelvalue)
+                session.commit()
+        except SQLAlchemyError:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    def get_channel_value(self, channel, key, namespace='default'):
+        channel = channel.lower()
+        session = self.ssession()
+        try:
+            result = session.query(ChannelValues) \
+                .filter(ChannelValues.channel == channel)\
+                .filter(ChannelValues.namespace == namespace)\
+                .filter(ChannelValues.key == key) \
+                .one_or_none()
+            if result is not None:
+                result = result.value
+            return _deserialize(result)
+        except SQLAlchemyError:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    def delete_channel_value(self, channel, key, namespace='default'):
+        channel = channel.lower()
+        session = self.ssession()
+        try:
+            result = session.query(ChannelValues) \
+                .filter(ChannelValues.channel == channel)\
+                .filter(ChannelValues.namespace == namespace)\
+                .filter(ChannelValues.key == key) \
+                .one_or_none()
+            # ChannelValues exists, delete
+            if result:
+                session.delete(result)
+                session.commit()
+        except SQLAlchemyError:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    # Program Values
+
+    def set_program_value(self, program, key, value, namespace='default'):
+        program = program.lower()
+        value = json.dumps(value, ensure_ascii=False)
+        session = self.ssession()
+        try:
+            result = session.query(ProgramValues) \
+                .filter(ProgramValues.program == program)\
+                .filter(ProgramValues.namespace == namespace)\
+                .filter(ProgramValues.key == key) \
+                .one_or_none()
+            # ProgramValue exists, update
+            if result:
+                result.value = value
+                session.commit()
+            # DNE - Insert
+            else:
+                new_programvalue = ProgramValues(program=program, namespace=namespace, key=key, value=value)
+                session.add(new_programvalue)
+                session.commit()
+        except SQLAlchemyError:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    def get_program_value(self, program, key, namespace='default'):
+        program = program.lower()
+        session = self.ssession()
+        try:
+            result = session.query(ProgramValues) \
+                .filter(ProgramValues.program == program)\
+                .filter(ProgramValues.namespace == namespace)\
+                .filter(ProgramValues.key == key) \
+                .one_or_none()
+            if result is not None:
+                result = result.value
+            return _deserialize(result)
+        except SQLAlchemyError:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    def delete_program_value(self, program, key, namespace='default'):
+        program = program.lower()
+        session = self.ssession()
+        try:
+            result = session.query(ProgramValues) \
+                .filter(ProgramValues.program == program)\
+                .filter(ProgramValues.namespace == namespace)\
+                .filter(ProgramValues.key == key) \
+                .one_or_none()
+            # ProgramValue exists, delete
+            if result:
+                session.delete(result)
+                session.commit()
+        except SQLAlchemyError:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    # Cache Values
+
+    def set_cacheitem_value(self, cacheitem, key, value, namespace='default'):
+        cacheitem = cacheitem.lower()
+        value = json.dumps(value, ensure_ascii=False)
+        session = self.ssession()
+        try:
+            result = session.query(CacheValues) \
+                .filter(CacheValues.cacheitem == cacheitem)\
+                .filter(CacheValues.namespace == namespace)\
+                .filter(CacheValues.key == key) \
+                .one_or_none()
+            # ProgramValue exists, update
+            if result:
+                result.value = value
+                session.commit()
+            # DNE - Insert
+            else:
+                new_cacheitemvalue = CacheValues(cacheitem=cacheitem, namespace=namespace, key=key, value=value)
+                session.add(new_cacheitemvalue)
+                session.commit()
+        except SQLAlchemyError:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    def get_cacheitem_value(self, cacheitem, key, namespace='default'):
+        cacheitem = cacheitem.lower()
+        session = self.ssession()
+        try:
+            result = session.query(CacheValues) \
+                .filter(CacheValues.cacheitem == cacheitem)\
+                .filter(CacheValues.namespace == namespace)\
+                .filter(CacheValues.key == key) \
+                .one_or_none()
+            if result is not None:
+                result = result.value
+            return _deserialize(result)
+        except SQLAlchemyError:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    def delete_cacheitem_value(self, cacheitem, key, namespace='default'):
+        cacheitem = cacheitem.lower()
+        session = self.ssession()
+        try:
+            result = session.query(CacheValues) \
+                .filter(CacheValues.cacheitem == cacheitem)\
+                .filter(CacheValues.namespace == namespace)\
+                .filter(CacheValues.key == key) \
+                .one_or_none()
+            # ProgramValue exists, delete
+            if result:
+                session.delete(result)
+                session.commit()
+        except SQLAlchemyError:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
     # fHDHR Values
 
     def set_fhdhr_value(self, item, key, value, namespace='default'):
@@ -148,8 +358,8 @@ class fHDHRdb(object):
                 session.commit()
             # DNE - Insert
             else:
-                new_pluginitemvalue = fHDHRValues(item=item, namespace=namespace, key=key, value=value)
-                session.add(new_pluginitemvalue)
+                new_cacheitemvalue = fHDHRValues(item=item, namespace=namespace, key=key, value=value)
+                session.add(new_cacheitemvalue)
                 session.commit()
         except SQLAlchemyError:
             session.rollback()
@@ -193,67 +403,3 @@ class fHDHRdb(object):
             raise
         finally:
             session.close()
-
-    # Plugin Values
-
-    def set_plugin_value(self, pluginitem, key, value, namespace='default'):
-        pluginitem = pluginitem.lower()
-        value = json.dumps(value, ensure_ascii=False)
-        session = self.ssession()
-        try:
-            result = session.query(PluginValues) \
-                .filter(PluginValues.pluginitem == pluginitem)\
-                .filter(PluginValues.namespace == namespace)\
-                .filter(PluginValues.key == key) \
-                .one_or_none()
-            # ProgramValue exists, update
-            if result:
-                result.value = value
-                session.commit()
-            # DNE - Insert
-            else:
-                new_pluginitemvalue = PluginValues(pluginitem=pluginitem, namespace=namespace, key=key, value=value)
-                session.add(new_pluginitemvalue)
-                session.commit()
-        except SQLAlchemyError:
-            session.rollback()
-            raise
-        finally:
-            session.close()
-
-    def get_plugin_value(self, pluginitem, key, namespace='default'):
-        pluginitem = pluginitem.lower()
-        session = self.ssession()
-        try:
-            result = session.query(PluginValues) \
-                .filter(PluginValues.pluginitem == pluginitem)\
-                .filter(PluginValues.namespace == namespace)\
-                .filter(PluginValues.key == key) \
-                .one_or_none()
-            if result is not None:
-                result = result.value
-            return _deserialize(result)
-        except SQLAlchemyError:
-            session.rollback()
-            raise
-        finally:
-            session.close()
-
-    def delete_plugin_value(self, pluginitem, key, namespace='default'):
-        pluginitem = pluginitem.lower()
-        session = self.ssession()
-        try:
-            result = session.query(PluginValues) \
-                .filter(PluginValues.pluginitem == pluginitem)\
-                .filter(PluginValues.namespace == namespace)\
-                .filter(PluginValues.key == key) \
-                .one_or_none()
-            # ProgramValue exists, delete
-            if result:
-                session.delete(result)
-                session.commit()
-        except SQLAlchemyError:
-            session.rollback()
-            raise
-        finally:
-            session.close()

fHDHR/device/__init__.py

@@ -3,16 +3,16 @@ from .epg import EPG
 from .tuners import Tuners
 from .images import imageHandler
 from .ssdp import SSDPServer
+from .cluster import fHDHR_Cluster
 
 
 class fHDHR_Device():
 
-    def __init__(self, fhdhr, origins):
-        self.fhdhr = fhdhr
+    def __init__(self, fhdhr, originwrapper, alternative_epg):
 
-        self.channels = Channels(fhdhr, origins)
+        self.channels = Channels(fhdhr, originwrapper)
 
-        self.epg = EPG(fhdhr, self.channels, origins)
+        self.epg = EPG(fhdhr, self.channels, originwrapper, alternative_epg)
 
         self.tuners = Tuners(fhdhr, self.epg, self.channels)
 
@@ -20,15 +20,4 @@ class fHDHR_Device():
 
         self.ssdp = SSDPServer(fhdhr)
 
-        self.interfaces = {}
-
-        for plugin_name in list(self.fhdhr.plugins.plugins.keys()):
-            if self.fhdhr.plugins.plugins[plugin_name].manifest["type"] == "interface":
-                method = self.fhdhr.plugins.plugins[plugin_name].name.lower()
-                plugin_utils = self.fhdhr.plugins.plugins[plugin_name].plugin_utils
-                plugin_utils.channels = self.channels
-                plugin_utils.epg = self.epg
-                plugin_utils.tuners = self.tuners
-                plugin_utils.images = self.images
-                plugin_utils.ssdp = self.ssdp
-                self.interfaces[method] = self.fhdhr.plugins.plugins[plugin_name].Plugin_OBJ(fhdhr, plugin_utils)
+        self.cluster = fHDHR_Cluster(fhdhr, self.ssdp)

fHDHR/device/channels/__init__.py

@@ -1,6 +1,7 @@
+import datetime
 import time
 
-from fHDHR.tools import humanized_time
+from fHDHR.tools import hours_between_datetime
 
 from .channel import Channel
 from .chan_ident import Channel_IDs
@@ -8,111 +9,51 @@ from .chan_ident import Channel_IDs
 
 class Channels():
 
-    def __init__(self, fhdhr, origins):
+    def __init__(self, fhdhr, originwrapper):
         self.fhdhr = fhdhr
 
-        self.origins = origins
+        self.origin = originwrapper
 
-        self.id_system = Channel_IDs(fhdhr, origins)
+        self.id_system = Channel_IDs(fhdhr)
 
         self.list = {}
-        for origin in list(self.origins.origins_dict.keys()):
-            self.list[origin] = {}
+        self.list_update_time = None
 
         self.get_db_channels()
+        haseverscanned = self.fhdhr.db.get_fhdhr_value("channels", "scanned_time")
+        if (self.fhdhr.config.dict["fhdhr"]["chanscan_on_start"] or not haseverscanned):
+            self.get_channels()
 
-    def get_channel_obj(self, keyfind, valfind, origin=None):
-        if origin:
-            origin = origin.lower()
-            if keyfind == "number":
-                matches = [self.list[origin][x].dict["id"] for x in list(self.list[origin].keys()) if self.list[origin][x].number == valfind]
-            else:
-                matches = [self.list[origin][x].dict["id"] for x in list(self.list[origin].keys()) if self.list[origin][x].dict[keyfind] == valfind]
-            if len(matches):
-                return self.list[origin][matches[0]]
-        else:
-            matches = []
-            for origin in list(self.list.keys()):
-                if keyfind == "number":
-                    matches = [self.list[origin][x].dict["id"] for x in list(self.list[origin].keys()) if self.list[origin][x].number == valfind]
-                else:
-                    matches = [self.list[origin][x].dict["id"] for x in list(self.list[origin].keys()) if self.list[origin][x].dict[keyfind] == valfind]
-                if len(matches):
-                    return self.list[origin][matches[0]]
-            if len(matches):
-                return self.list[origin][matches[0]]
-        return None
+    def get_channel_obj(self, keyfind, valfind):
+        return next(self.list[fhdhr_id] for fhdhr_id in list(self.list.keys()) if self.list[fhdhr_id].dict[keyfind] == valfind)
 
-    def get_channel_list(self, keyfind, origin=None):
-        if origin:
-            if keyfind == "number":
-                return [self.list[origin][x].number for x in [x["id"] for x in self.get_channels(origin)]]
-            else:
-                return [self.list[origin][x].dict[keyfind] for x in [x["id"] for x in self.get_channels(origin)]]
-        else:
-            matches = []
-            for origin in list(self.list.keys()):
-                if keyfind == "number":
-                    next_match = [self.list[origin][x].number for x in [x["id"] for x in self.get_channels(origin)]]
-                else:
-                    next_match = [self.list[origin][x].dict[keyfind] for x in [x["id"] for x in self.get_channels(origin)]]
-                if len(next_match):
-                    matches.append(next_match)
-            return matches[0]
+    def get_channel_list(self, keyfind):
+        return [self.list[x].dict[keyfind] for x in list(self.list.keys())]
 
-    def get_channel_dict(self, keyfind, valfind, origin=None):
-        chan_obj = self.get_channel_obj(keyfind, valfind, origin)
-        if chan_obj:
-            return chan_obj.dict
-        return None
+    def set_channel_status(self, keyfind, valfind, updatedict):
+        self.get_channel_obj(keyfind, valfind).set_status(updatedict)
 
-    def set_channel_status(self, keyfind, valfind, updatedict, origin):
-        self.get_channel_obj(keyfind, valfind, origin).set_status(updatedict)
+    def set_channel_enablement_all(self, enablement):
+        for fhdhr_id in list(self.list.keys()):
+            self.list[fhdhr_id].set_enablement(enablement)
 
-    def set_channel_enablement_all(self, enablement, origin):
-        for fhdhr_id in [x["id"] for x in self.get_channels(origin)]:
-            self.list[fhdhr_id].set_enablement(enablement, origin)
+    def set_channel_enablement(self, keyfind, valfind, enablement):
+        self.get_channel_obj(keyfind, valfind).set_enablement(enablement)
 
-    def set_channel_enablement(self, keyfind, valfind, enablement, origin):
-        self.get_channel_obj(keyfind, valfind, origin).set_enablement(enablement)
+    def set_channel_favorite(self, keyfind, valfind, enablement):
+        self.get_channel_obj(keyfind, valfind).set_favorite(enablement)
 
-    def set_channel_favorite(self, keyfind, valfind, enablement, origin):
-        self.get_channel_obj(keyfind, valfind, origin).set_favorite(enablement)
+    def get_db_channels(self):
+        self.fhdhr.logger.info("Checking for Channel information stored in the database.")
+        channel_ids = self.fhdhr.db.get_fhdhr_value("channels", "list") or []
+        if len(channel_ids):
+            self.fhdhr.logger.info("Found %s existing channels in the database." % str(len(channel_ids)))
+        for channel_id in channel_ids:
+            channel_obj = Channel(self.fhdhr, self.id_system, channel_id=channel_id)
+            channel_id = channel_obj.dict["id"]
+            self.list[channel_id] = channel_obj
 
-    def get_db_channels(self, origin=None):
-
-        if not origin:
-            origins_list = list(self.list.keys())
-        else:
-            origins_list = origin.lower()
-
-        if isinstance(origins_list, str):
-            origins_list = [origins_list]
-
-        for origin in origins_list:
-            self.fhdhr.logger.info("Checking for %s Channel information stored in the database." % origin)
-            channel_ids = self.fhdhr.db.get_fhdhr_value("channels", "list", origin) or []
-            if len(channel_ids):
-                self.fhdhr.logger.info("Found %s existing channels in the database." % str(len(channel_ids)))
-            for channel_id in channel_ids:
-                channel_obj = Channel(self.fhdhr, self.id_system, origin=origin, channel_id=channel_id)
-                channel_id = channel_obj.dict["id"]
-                self.list[origin][channel_id] = channel_obj
-
-    def save_db_channels(self, origin=None):
-        if not origin:
-            origins_list = list(self.list.keys())
-        else:
-            origins_list = origin.lower()
-
-        if isinstance(origins_list, str):
-            origins_list = [origins_list]
-
-        for origin in origins_list:
-            channel_ids = [self.list[origin][x].dict["id"] for x in list(self.list[origin].keys())]
-            self.fhdhr.db.set_fhdhr_value("channels", "list", channel_ids, origin)
-
-    def get_channels(self, origin=None, forceupdate=False):
+    def get_channels(self, forceupdate=False):
         """Pull Channels from origin.
 
         Output a list.
@@ -120,64 +61,54 @@ class Channels():
         Don't pull more often than 12 hours.
         """
 
-        if not origin:
-            origins_list = list(self.list.keys())
-        else:
-            origins_list = origin.lower().lower()
+        updatelist = False
+        if not self.list_update_time:
+            updatelist = True
+        elif hours_between_datetime(self.list_update_time, datetime.datetime.now()) > 12:
+            updatelist = True
+        elif forceupdate:
+            updatelist = True
 
-        if isinstance(origins_list, str):
-            origins_list = [origins_list]
+        if updatelist:
+            channel_origin_id_list = [str(self.list[x].dict["origin_id"]) for x in list(self.list.keys())]
 
-        return_chan_list = []
-        for origin in origins_list:
+            self.fhdhr.logger.info("Performing Channel Scan.")
 
-            if not len(list(self.list[origin].keys())):
-                self.get_db_channels(origin=origin)
+            channel_dict_list = self.origin.get_channels()
+            self.fhdhr.logger.info("Found %s channels for %s." % (len(channel_dict_list), self.fhdhr.config.dict["main"]["servicename"]))
 
-            if not forceupdate:
-                return_chan_list.extend([self.list[origin][x].dict for x in list(self.list[origin].keys())])
+            newchan = 0
+            for channel_info in channel_dict_list:
 
-            else:
+                chan_existing = False
+                if str(channel_info["id"]) in channel_origin_id_list:
+                    chan_existing = True
+                    channel_obj = self.get_channel_obj("origin_id", channel_info["id"])
+                else:
+                    channel_obj = Channel(self.fhdhr, self.id_system, origin_id=channel_info["id"])
 
-                channel_origin_id_list = [str(self.list[origin][x].dict["origin_id"]) for x in list(self.list[origin].keys())]
+                channel_id = channel_obj.dict["id"]
+                channel_obj.basics(channel_info)
+                if not chan_existing:
+                    self.list[channel_id] = channel_obj
+                    newchan += 1
 
-                self.fhdhr.logger.info("Performing Channel Scan for %s." % origin)
+            if not newchan:
+                newchan = "no"
+            self.fhdhr.logger.info("Found %s NEW channels." % newchan)
 
-                channel_dict_list = self.origins.origins_dict[origin].get_channels()
-                self.fhdhr.logger.info("Found %s channels for %s." % (len(channel_dict_list), origin))
+            self.fhdhr.logger.info("Total Channel Count: %s" % len(self.list.keys()))
 
-                self.fhdhr.logger.info("Performing Channel Import, This can take some time, Please wait.")
+            self.list_update_time = datetime.datetime.now()
+            self.fhdhr.db.set_fhdhr_value("channels", "scanned_time", time.time())
 
-                newchan = 0
-                chan_scan_start = time.time()
-                for channel_info in channel_dict_list:
+        channel_list = []
+        for chan_obj in list(self.list.keys()):
+            channel_list.append(self.list[chan_obj].dict)
+        return channel_list
 
-                    chan_existing = str(channel_info["id"]) in channel_origin_id_list
+    def get_channel_stream(self, channel_number):
+        return self.origin.get_channel_stream(self.get_channel_dict("number", channel_number))
 
-                    if chan_existing:
-                        channel_obj = self.get_channel_obj("origin_id", channel_info["id"], origin)
-                    else:
-                        channel_obj = Channel(self.fhdhr, self.id_system, origin, origin_id=channel_info["id"])
-
-                    channel_id = channel_obj.dict["id"]
-                    channel_obj.basics(channel_info)
-                    if not chan_existing:
-                        self.list[origin][channel_id] = channel_obj
-                        newchan += 1
-
-                self.fhdhr.logger.info("%s Channel Import took %s" % (origin, humanized_time(time.time() - chan_scan_start)))
-
-                if not newchan:
-                    newchan = "no"
-                self.fhdhr.logger.info("Found %s NEW channels for %s." % (newchan, origin))
-
-                self.fhdhr.logger.info("Total %s Channel Count: %s" % (origin, len(self.list[origin].keys())))
-                self.save_db_channels(origin=origin)
-
-                self.fhdhr.db.set_fhdhr_value("channels", "scanned_time", time.time(), origin)
-                return_chan_list.extend([self.list[origin][x].dict for x in list(self.list[origin].keys())])
-
-        return return_chan_list
-
-    def get_channel_stream(self, stream_args, origin):
-        return self.origins.origins_dict[origin].get_channel_stream(self.get_channel_dict("number", stream_args["channel"]), stream_args)
+    def get_channel_dict(self, keyfind, valfind):
+        return self.get_channel_obj(keyfind, valfind).dict

fHDHR/device/channels/chan_ident.py

@@ -2,44 +2,36 @@ import uuid
 
 
 class Channel_IDs():
-    def __init__(self, fhdhr, origins):
+    def __init__(self, fhdhr):
         self.fhdhr = fhdhr
-        self.origins = origins
 
-    def get(self, origin_id, origin):
-        existing_ids = self.fhdhr.db.get_fhdhr_value("channels", "list", origin) or []
-        existing_channel_info = [self.fhdhr.db.get_fhdhr_value(channel_id, "dict", origin) or {} for channel_id in existing_ids]
+    def get(self, origin_id):
+        existing_ids = self.fhdhr.db.get_fhdhr_value("channels", "list") or []
+        existing_channel_info = [self.fhdhr.db.get_channel_value(channel_id, "dict") or {} for channel_id in existing_ids]
         for existing_channel in existing_channel_info:
             if existing_channel["origin_id"] == origin_id:
                 return existing_channel["id"]
-        return self.assign(origin)
+        return self.assign()
 
-    def assign(self, origin):
-        existing_ids = self.fhdhr.db.get_fhdhr_value("channels", "list", origin) or []
+    def assign(self):
+        existing_ids = self.fhdhr.db.get_fhdhr_value("channels", "list") or []
         channel_id = None
         while not channel_id:
             unique_id = str(uuid.uuid4())
             if str(unique_id) not in existing_ids:
                 channel_id = str(unique_id)
         existing_ids.append(channel_id)
-        self.fhdhr.db.set_fhdhr_value("channels", "list", existing_ids, origin)
+        self.fhdhr.db.set_fhdhr_value("channels", "list", existing_ids)
         return channel_id
 
-    def get_number(self, channel_id, origin):
-        existing_ids = self.fhdhr.db.get_fhdhr_value("channels", "list", origin) or []
-        existing_channel_info = [self.fhdhr.db.get_fhdhr_value(channel_id, "dict", origin) or {} for channel_id in existing_ids]
+    def get_number(self, channel_id):
+        existing_ids = self.fhdhr.db.get_fhdhr_value("channels", "list") or []
+        existing_channel_info = [self.fhdhr.db.get_channel_value(channel_id, "dict") or {} for channel_id in existing_ids]
         cnumber = [existing_channel["number"] for existing_channel in existing_channel_info if existing_channel["id"] == channel_id] or None
         if cnumber:
             return cnumber
 
-        used_numbers = []
-        for existing_channel in existing_channel_info:
-            if existing_channel["subnumber"]:
-                number = "%s.%s" % (existing_channel["number"], existing_channel["subnumber"])
-            else:
-                number = existing_channel["number"]
-            used_numbers.append(number)
-
+        used_numbers = [existing_channel["number"] for existing_channel in existing_channel_info]
         for i in range(1000, 2000):
             if str(float(i)) not in used_numbers:
                 break

fHDHR/device/channels/channel.py

@@ -3,30 +3,21 @@ import time
 
 class Channel():
 
-    def __init__(self, fhdhr, id_system, origin, origin_id=None, channel_id=None):
+    def __init__(self, fhdhr, id_system, origin_id=None, channel_id=None):
         self.fhdhr = fhdhr
-        self.origin = origin
 
         self.id_system = id_system
 
         if not channel_id:
             if origin_id:
-                channel_id = id_system.get(origin_id, origin)
+                channel_id = id_system.get(origin_id)
             else:
-                channel_id = id_system.assign(origin)
+                channel_id = id_system.assign()
         self.channel_id = channel_id
-
-        self.dict = self.fhdhr.db.get_fhdhr_value(str(channel_id), "dict", self.origin) or self.default_dict
+        self.dict = self.fhdhr.db.get_channel_value(str(channel_id), "dict") or self.default_dict
         self.verify_dict()
 
-        self.fhdhr.db.set_fhdhr_value(self.dict["id"], "dict", self.dict, self.origin)
-
-    @property
-    def number(self):
-        if self.dict["subnumber"]:
-            return "%s.%s" % (self.dict["number"], self.dict["subnumber"])
-        else:
-            return self.dict["number"]
+        self.fhdhr.db.set_channel_value(self.dict["id"], "dict", self.dict)
 
     @property
     def thumbnail(self):
@@ -44,9 +35,9 @@ class Channel():
         return {
                 "callsign": self.dict["callsign"],
                 "name": self.dict["name"],
-                "number": self.number,
+                "number": self.dict["number"],
                 "id": self.dict["origin_id"],
-                "thumbnail": self.thumbnail,
+                "thumbnail": self.dict["thumbnail"],
                 "listing": [],
                 }
 
@@ -58,59 +49,37 @@ class Channel():
         for key in list(default_dict.keys()):
             if key not in list(self.dict.keys()):
                 self.dict[key] = default_dict[key]
-        if self.dict["number"]:
-            if "." in self.dict["number"]:
-                self.dict["subnumber"] = self.dict["number"].split(".")[1]
-                self.dict["number"] = self.dict["number"].split(".")[0]
 
     def basics(self, channel_info):
         """Some Channel Information is Critical"""
 
         if "name" not in list(channel_info.keys()):
             channel_info["name"] = self.dict["id"]
-        elif not channel_info["name"]:
-            channel_info["name"] = self.dict["id"]
         self.dict["origin_name"] = channel_info["name"]
         if not self.dict["name"]:
             self.dict["name"] = self.dict["origin_name"]
 
         if "id" not in list(channel_info.keys()):
             channel_info["id"] = channel_info["name"]
-        elif not channel_info["id"]:
-            channel_info["id"] = channel_info["name"]
         self.dict["origin_id"] = channel_info["id"]
 
         if "callsign" not in list(channel_info.keys()):
             channel_info["callsign"] = channel_info["name"]
-        elif not channel_info["callsign"]:
-            channel_info["callsign"] = channel_info["name"]
         self.dict["origin_callsign"] = channel_info["callsign"]
         if not self.dict["callsign"]:
             self.dict["callsign"] = self.dict["origin_callsign"]
 
         if "tags" not in list(channel_info.keys()):
             channel_info["tags"] = []
-        elif not channel_info["tags"]:
-            channel_info["tags"] = []
         self.dict["origin_tags"] = channel_info["tags"]
         if not self.dict["tags"]:
             self.dict["tags"] = self.dict["origin_tags"]
 
         if "number" not in list(channel_info.keys()):
-            channel_info["number"] = self.id_system.get_number(channel_info["id"], self.origin)
-        elif not channel_info["number"]:
-            channel_info["number"] = self.id_system.get_number(channel_info["id"], self.origin)
-        self.dict["origin_number"] = str(channel_info["number"])
+            channel_info["number"] = self.id_system.get_number(channel_info["id"])
+        self.dict["origin_number"] = str(float(channel_info["number"]))
         if not self.dict["number"]:
-            self.dict["number"] = self.dict["origin_number"].split(".")[0]
-            try:
-                self.dict["subnumber"] = self.dict["origin_number"].split(".")[1]
-            except IndexError:
-                self.dict["subnumber"] = None
-        else:
-            if "." in self.dict["number"]:
-                self.dict["subnumber"] = self.dict["number"].split(".")[1]
-                self.dict["number"] = self.dict["number"].split(".")[0]
+            self.dict["number"] = self.dict["origin_number"]
 
         if "thumbnail" not in list(channel_info.keys()):
             channel_info["thumbnail"] = None
@@ -129,7 +98,7 @@ class Channel():
         if "created" not in list(self.dict.keys()):
             self.dict["created"] = time.time()
 
-        self.fhdhr.db.set_fhdhr_value(self.dict["id"], "dict", self.dict, self.origin)
+        self.fhdhr.db.set_channel_value(self.dict["id"], "dict", self.dict)
 
     @property
     def default_dict(self):
@@ -137,7 +106,7 @@ class Channel():
                 "id": str(self.channel_id), "origin_id": None,
                 "name": None, "origin_name": None,
                 "callsign": None, "origin_callsign": None,
-                "number": None, "subnumber": None, "origin_number": None,
+                "number": None, "origin_number": None,
                 "tags": [], "origin_tags": [],
                 "thumbnail": None, "origin_thumbnail": None,
                 "enabled": True, "favorite": 0,
@@ -145,37 +114,48 @@ class Channel():
                 }
 
     def destroy(self):
-        self.fhdhr.db.delete_fhdhr_value(self.dict["id"], "dict", self.origin)
+        self.fhdhr.db.delete_channel_value(self.dict["id"], "dict")
         channel_ids = self.fhdhr.db.get_fhdhr_value("channels", "list") or []
         if self.dict["id"] in channel_ids:
             channel_ids.remove(self.dict["id"])
-        self.fhdhr.db.set_fhdhr_value("channels", "list", channel_ids, self.origin)
+        self.fhdhr.db.set_fhdhr_value("channels", "list", channel_ids)
 
     def set_status(self, updatedict):
         for key in list(updatedict.keys()):
             if key == "number":
-                updatedict[key] = str(updatedict[key])
+                updatedict[key] = str(float(updatedict[key]))
             self.dict[key] = updatedict[key]
-        self.fhdhr.db.set_fhdhr_value(self.dict["id"], "dict", self.dict, self.origin)
+        self.fhdhr.db.set_channel_value(self.dict["id"], "dict", self.dict)
+
+    @property
+    def lineup_dict(self):
+        return {
+                 'GuideNumber': self.dict['number'],
+                 'GuideName': self.dict['name'],
+                 'Tags': ",".join(self.dict['tags']),
+                 'URL': self.stream_url,
+                 'HD': self.dict["HD"],
+                 "Favorite": self.dict["favorite"],
+                }
 
     @property
     def generic_image_url(self):
-        return "/api/images?method=generate&type=channel&message=%s" % self.number
+        return "/api/images?method=generate&type=channel&message=%s" % self.dict["number"]
 
     @property
-    def api_stream_url(self):
-        return '/api/tuners?method=stream&stream_method=%s&channel=%s&origin=%s' % (self.fhdhr.origins.origins_dict[self.origin].stream_method, self.dict["id"], self.origin)
+    def stream_url(self):
+        return '/auto/v%s' % self.dict['number']
 
     @property
-    def api_m3u_url(self):
-        return '/api/m3u?method=get&channel=%s&origin=%s' % (self.dict["id"], self.origin)
+    def play_url(self):
+        return '/api/m3u?method=get&channel=%s' % self.dict['number']
 
     def set_favorite(self, enablement):
         if enablement == "+":
             self.dict["favorite"] = 1
-        elif enablement == "-":
+        elif enablement == "+":
             self.dict["favorite"] = 0
-        self.fhdhr.db.set_fhdhr_value(self.dict["id"], "info", self.dict, self.origin)
+        self.fhdhr.db.set_channel_value(self.dict["id"], "info", self.dict)
 
     def set_enablement(self, enablement):
         if enablement == "disable":
@@ -187,7 +167,7 @@ class Channel():
                 self.dict["enabled"] = False
             else:
                 self.dict["enabled"] = True
-        self.fhdhr.db.set_fhdhr_value(self.dict["id"], "info", self.dict, self.origin)
+        self.fhdhr.db.set_channel_value(self.dict["id"], "info", self.dict)
 
     def __getattr__(self, name):
         ''' will only get called for undefined attributes '''

fHDHR/device/cluster.py

@@ -0,0 +1,158 @@
+from collections import OrderedDict
+
+
+class fHDHR_Cluster():
+
+    def __init__(self, fhdhr, ssdp):
+        self.fhdhr = fhdhr
+
+        self.ssdp = ssdp
+
+        self.friendlyname = self.fhdhr.config.dict["fhdhr"]["friendlyname"]
+
+        if self.fhdhr.config.dict["fhdhr"]["discovery_address"]:
+            self.startup_sync()
+
+    def cluster(self):
+        return self.fhdhr.db.get_fhdhr_value("cluster", "dict") or self.default_cluster()
+
+    def get_cluster_dicts_web(self):
+        fhdhr_list = self.cluster()
+        locations = []
+        for location in list(fhdhr_list.keys()):
+            item_dict = {
+                        "base_url": fhdhr_list[location]["base_url"],
+                        "name": fhdhr_list[location]["name"]
+                        }
+            if item_dict["base_url"] != self.fhdhr.api.base:
+                locations.append(item_dict)
+        if len(locations):
+            locations = sorted(locations, key=lambda i: i['name'])
+            return locations
+        else:
+            return None
+
+    def get_list(self):
+        cluster = self.fhdhr.db.get_fhdhr_value("cluster", "dict") or self.default_cluster()
+        return_dict = {}
+        for location in list(cluster.keys()):
+            if location != self.fhdhr.api.base:
+                return_dict[location] = {
+                                        "Joined": True
+                                        }
+
+        detected_list = self.ssdp.detect_method.get()
+        for location in detected_list:
+            if location not in list(cluster.keys()):
+                return_dict[location] = {
+                                        "Joined": False
+                                        }
+        return_dict = OrderedDict(sorted(return_dict.items()))
+        return return_dict
+
+    def default_cluster(self):
+        defdict = {}
+        defdict[self.fhdhr.api.base] = {
+                                "base_url": self.fhdhr.api.base,
+                                "name": self.friendlyname
+                                }
+        return defdict
+
+    def startup_sync(self):
+        self.fhdhr.logger.info("Syncronizing with Cluster.")
+        cluster = self.fhdhr.db.get_fhdhr_value("cluster", "dict") or self.default_cluster()
+        if not len(list(cluster.keys())):
+            self.fhdhr.logger.info("No Cluster Found.")
+        else:
+            self.fhdhr.logger.info("Found %s clustered services." % str(len(list(cluster.keys()))))
+        for location in list(cluster.keys()):
+            if location != self.fhdhr.api.base:
+                self.fhdhr.logger.info("Checking Cluster Syncronization information from %s." % location)
+                sync_url = location + "/api/cluster?method=get"
+                try:
+                    sync_open = self.fhdhr.web.session.get(sync_url)
+                    retrieved_cluster = sync_open.json()
+                    if self.fhdhr.api.base not in list(retrieved_cluster.keys()):
+                        return self.leave()
+                except self.fhdhr.web.exceptions.ConnectionError:
+                    self.fhdhr.logger.error("Unreachable: " + location)
+
+    def leave(self):
+        self.fhdhr.logger.info("Leaving cluster.")
+        self.fhdhr.db.set_fhdhr_value("cluster", "dict", self.default_cluster())
+
+    def disconnect(self):
+        cluster = self.fhdhr.db.get_fhdhr_value("cluster", "dict") or self.default_cluster()
+        for location in list(cluster.keys()):
+            if location != self.fhdhr.api.base:
+                self.fhdhr.logger.info("Informing %s that I am departing the Cluster." % location)
+                sync_url = location + "/api/cluster?method=del&location=" + self.fhdhr.api.base
+                try:
+                    self.fhdhr.web.session.get(sync_url)
+                except self.fhdhr.web.exceptions.ConnectionError:
+                    self.fhdhr.logger.error("Unreachable: " + location)
+        self.leave()
+
+    def sync(self, location):
+        sync_url = location + "/api/cluster?method=get"
+        try:
+            sync_open = self.fhdhr.web.session.get(sync_url)
+            self.fhdhr.db.set_fhdhr_value("cluster", "dict", sync_open.json())
+        except self.fhdhr.web.exceptions.ConnectionError:
+            self.fhdhr.logger.error("Unreachable: " + location)
+
+    def push_sync(self):
+        cluster = self.fhdhr.db.get_fhdhr_value("cluster", "dict") or self.default_cluster()
+        for location in list(cluster.keys()):
+            if location != self.fhdhr.api.base:
+                sync_url = location + "/api/cluster?method=sync&location=" + self.fhdhr.api.base_quoted
+                try:
+                    self.fhdhr.web.session.get(sync_url)
+                except self.fhdhr.web.exceptions.ConnectionError:
+                    self.fhdhr.logger.error("Unreachable: " + location)
+
+    def add(self, location):
+        cluster = self.fhdhr.db.get_fhdhr_value("cluster", "dict") or self.default_cluster()
+        if location not in list(cluster.keys()):
+            self.fhdhr.logger.info("Adding %s to cluster." % location)
+            cluster[location] = {"base_url": location}
+
+            location_info_url = "%s/hdhr/discover.json" % location
+            try:
+                location_info_req = self.fhdhr.web.session.get(location_info_url)
+            except self.fhdhr.web.exceptions.ConnectionError:
+                self.fhdhr.logger.error("Unreachable: " + location)
+                del cluster[location]
+                self.fhdhr.db.set_fhdhr_value("cluster", "dict", cluster)
+                return
+            location_info = location_info_req.json()
+            cluster[location]["name"] = location_info["FriendlyName"]
+
+            cluster_info_url = location + "/api/cluster?method=get"
+            try:
+                cluster_info_req = self.fhdhr.web.session.get(cluster_info_url)
+            except self.fhdhr.web.exceptions.ConnectionError:
+                self.fhdhr.logger.error("Unreachable: " + location)
+                del cluster[location]
+                self.fhdhr.db.set_fhdhr_value("cluster", "dict", cluster)
+                return
+            cluster_info = cluster_info_req.json()
+            for cluster_key in list(cluster_info.keys()):
+                if cluster_key not in list(cluster.keys()):
+                    cluster[cluster_key] = cluster_info[cluster_key]
+
+            self.fhdhr.db.set_fhdhr_value("cluster", "dict", cluster)
+            self.push_sync()
+
+    def remove(self, location):
+        cluster = self.fhdhr.db.get_fhdhr_value("cluster", "dict") or self.default_cluster()
+        if location in list(cluster.keys()):
+            self.fhdhr.logger.info("Removing %s from cluster." % location)
+            del cluster[location]
+            sync_url = location + "/api/cluster?method=leave"
+            try:
+                self.fhdhr.web.session.get(sync_url)
+            except self.fhdhr.web.exceptions.ConnectionError:
+                self.fhdhr.logger.error("Unreachable: " + location)
+            self.push_sync()
+            self.fhdhr.db.set_fhdhr_value("cluster", "dict", cluster)

fHDHR/device/epg/__init__.py

@@ -1,27 +1,30 @@
+import os
 import time
 import datetime
-import threading
-
-from fHDHR.tools import channel_sort
+from collections import OrderedDict
 
 from .blocks import blocksEPG
 
 
 class EPG():
 
-    def __init__(self, fhdhr, channels, origins):
+    def __init__(self, fhdhr, channels, originwrapper, alternative_epg):
         self.fhdhr = fhdhr
 
-        self.origins = origins
+        self.origin = originwrapper
         self.channels = channels
+        self.alternative_epg = alternative_epg
 
         self.epgdict = {}
 
-        self.epg_methods = self.fhdhr.config.dict["epg"]["method"] or []
-        self.valid_epg_methods = [x for x in list(self.fhdhr.config.dict["epg"]["valid_methods"].keys()) if x and x not in [None, "None"]]
+        self.epg_methods = self.fhdhr.config.dict["epg"]["method"]
+        self.valid_epg_methods = [x for x in self.fhdhr.config.dict["main"]["valid_epg_methods"] if x and x not in [None, "None"]]
 
-        self.blocks = blocksEPG(self.fhdhr, self.channels, self.origins, None)
-        self.epg_handling = {}
+        self.blocks = blocksEPG(self.fhdhr, self.channels)
+        self.epg_handling = {
+                            "origin": self.origin,
+                            "blocks": self.blocks,
+                            }
         self.epg_method_selfadd()
 
         self.def_method = self.fhdhr.config.dict["epg"]["def_method"]
@@ -33,21 +36,21 @@ class EPG():
             if epg_method not in list(self.sleeptime.keys()):
                 self.sleeptime[epg_method] = self.fhdhr.config.dict["epg"]["update_frequency"]
 
-        self.epg_update_url = "/api/epg?method=update"
-
-        self.fhdhr.threads["epg"] = threading.Thread(target=self.run)
+        self.epg_update_url = "%s/api/epg?method=update" % (self.fhdhr.api.base)
 
     def clear_epg_cache(self, method=None):
 
         if not method:
-            if not self.def_method:
-                return
-        if method not in self.valid_epg_methods:
-            if not self.def_method:
-                return
             method = self.def_method
+        if (method == self.fhdhr.config.dict["main"]["dictpopname"] or
+           method not in self.fhdhr.config.dict["main"]["valid_epg_methods"]):
+            method = "origin"
 
-        self.fhdhr.logger.info("Clearing %s EPG cache." % method)
+        epgtypename = method
+        if method in [self.fhdhr.config.dict["main"]["dictpopname"], "origin"]:
+            epgtypename = self.fhdhr.config.dict["main"]["dictpopname"]
+
+        self.fhdhr.logger.info("Clearing " + epgtypename + " EPG cache.")
 
         if hasattr(self.epg_handling[method], 'clear_cache'):
             self.epg_handling[method].clear_cache()
@@ -57,85 +60,55 @@ class EPG():
 
         self.fhdhr.db.delete_fhdhr_value("epg_dict", method)
 
-    def whats_on_now(self, channel_number, method=None, chan_obj=None, chan_dict=None):
-        nowtime = time.time()
+    def whats_on_now(self, channel, method=None):
         epgdict = self.get_epg(method)
-        if channel_number not in list(epgdict.keys()):
-            epgdict[channel_number] = {
-                                        "callsign": "",
-                                        "name": "",
-                                        "number": str(channel_number),
-                                        "id": "",
-                                        "thumbnail": "",
-                                        "listing": []
-                                        }
-
-        for listing in epgdict[channel_number]["listing"]:
-            for time_item in ["time_start", "time_end"]:
-                time_value = listing[time_item]
-                if str(time_value).endswith("+00:00"):
-                    listing[time_item] = datetime.datetime.strptime(time_value, '%Y%m%d%H%M%S +00:00').timestamp()
-                elif str(time_value).endswith("+0000"):
-                    listing[time_item] = datetime.datetime.strptime(time_value, '%Y%m%d%H%M%S +0000').timestamp()
-                else:
-                    listing[time_item] = int(time_value)
-            if int(listing["time_start"]) <= nowtime <= int(listing["time_end"]):
-                epgitem = epgdict[channel_number].copy()
+        listings = epgdict[channel]["listing"]
+        for listing in listings:
+            nowtime = datetime.datetime.utcnow()
+            start_time = datetime.datetime.strptime(listing["time_start"], '%Y%m%d%H%M%S +0000')
+            end_time = datetime.datetime.strptime(listing["time_end"], '%Y%m%d%H%M%S +0000')
+            if start_time <= nowtime <= end_time:
+                epgitem = epgdict[channel].copy()
                 epgitem["listing"] = [listing]
                 return epgitem
-        epgitem = epgdict[channel_number].copy()
-        epgitem["listing"] = [self.blocks.empty_listing(chan_obj=None, chan_dict=None)]
-        return epgitem
+        return None
 
     def whats_on_allchans(self, method=None):
 
         if not method:
-            if not self.def_method:
-                return
-            method = self.def_method
-        if method not in self.valid_epg_methods:
-            if not self.def_method:
-                return
             method = self.def_method
+        if (method == self.fhdhr.config.dict["main"]["dictpopname"] or
+           method not in self.fhdhr.config.dict["main"]["valid_epg_methods"]):
+            method = "origin"
 
-        channel_guide_dict = {}
+        channel_guide_list = []
         epgdict = self.get_epg(method)
-        epgdict = epgdict.copy()
-        for c in list(epgdict.keys()):
-            if method in [origin for origin in list(self.origins.origins_dict.keys())]:
-                chan_obj = self.channels.get_channel_obj("origin_id", epgdict[c]["id"])
-                channel_number = chan_obj.number
-                epgdict[channel_number] = epgdict.pop(c)
-                epgdict[channel_number]["name"] = chan_obj.dict["name"]
-                epgdict[channel_number]["callsign"] = chan_obj.dict["callsign"]
-                epgdict[channel_number]["number"] = chan_obj.number
-                epgdict[channel_number]["id"] = chan_obj.dict["origin_id"]
-                epgdict[channel_number]["thumbnail"] = chan_obj.thumbnail
-            else:
-                chan_obj = None
-                channel_number = c
-            whatson = self.whats_on_now(channel_number, method, chan_dict=epgdict, chan_obj=chan_obj)
+        channels = list(epgdict.keys())
+        for channel in channels:
+            whatson = self.whats_on_now(epgdict[channel]["number"], method)
             if whatson:
-                channel_guide_dict[channel_number] = whatson
-        return channel_guide_dict
+                channel_guide_list.append(whatson)
+        return channel_guide_list
 
     def get_epg(self, method=None):
 
         if not method:
-            if not self.def_method:
-                return
-            method = self.def_method
-        if method not in self.valid_epg_methods:
-            if not self.def_method:
-                return
             method = self.def_method
+        if (method == self.fhdhr.config.dict["main"]["dictpopname"] or
+           method not in self.fhdhr.config.dict["main"]["valid_epg_methods"]):
+            method = "origin"
 
-        if method in list(self.epgdict.keys()):
+        if method not in list(self.epgdict.keys()):
+
+            epgdict = self.fhdhr.db.get_fhdhr_value("epg_dict", method) or None
+            if not epgdict:
+                self.update(method)
+                self.epgdict[method] = self.fhdhr.db.get_fhdhr_value("epg_dict", method) or {}
+            else:
+                self.epgdict[method] = epgdict
+            return self.epgdict[method]
+        else:
             return self.epgdict[method]
-
-        self.update(method)
-        self.epgdict[method] = self.fhdhr.db.get_fhdhr_value("epg_dict", method) or {}
-        return self.epgdict[method]
 
     def get_thumbnail(self, itemtype, itemid):
         if itemtype == "channel":
@@ -148,171 +121,71 @@ class EPG():
 
     def find_channel_dict(self, channel_id):
         epgdict = self.get_epg()
-        channel_list = [epgdict[x] for x in list(epgdict.keys())]
-        return next(item for item in channel_list if item["id"] == channel_id) or None
+        channel_list = []
+        for channel in list(epgdict.keys()):
+            channel_list.append(epgdict[channel])
+        return next(item for item in channel_list if item["id"] == channel_id)
 
     def find_program_dict(self, event_id):
         epgdict = self.get_epg()
         event_list = []
         for channel in list(epgdict.keys()):
             event_list.extend(epgdict[channel]["listing"])
-        return next(item for item in event_list if item["id"] == event_id) or None
+        return next(item for item in event_list if item["id"] == event_id)
 
     def epg_method_selfadd(self):
-        for plugin_name in list(self.fhdhr.plugins.plugins.keys()):
-            if self.fhdhr.plugins.plugins[plugin_name].type == "alt_epg":
-                method = self.fhdhr.plugins.plugins[plugin_name].name.lower()
-                self.epg_handling[method] = self.fhdhr.plugins.plugins[plugin_name].Plugin_OBJ(self.channels, self.fhdhr.plugins.plugins[plugin_name].plugin_utils)
-        for origin in list(self.origins.origins_dict.keys()):
-            if origin.lower() not in list(self.epg_handling.keys()):
-                self.epg_handling[origin.lower()] = blocksEPG(self.fhdhr, self.channels, self.origins, origin)
-                self.fhdhr.config.register_valid_epg_method(origin, "Blocks")
-                self.valid_epg_methods.append(origin.lower())
+        self.fhdhr.logger.info("Checking for Alternative EPG methods.")
+        new_epgtype_list = []
+        for entry in os.scandir(self.fhdhr.config.internal["paths"]["alternative_epg"]):
+            if entry.is_file():
+                if entry.name[0] != '_' and entry.name.endswith(".py"):
+                    new_epgtype_list.append(str(entry.name[:-3]))
+        for method in new_epgtype_list:
+            self.fhdhr.logger.info("Found %s EPG method." % method)
+            self.epg_handling[method] = eval("self.alternative_epg.%s.%sEPG(self.fhdhr, self.channels)" % (method, method))
 
     def update(self, method=None):
 
-        if not method:
-            if not self.def_method:
-                return
-            method = self.def_method
-        if method not in self.valid_epg_methods:
-            if not self.def_method:
-                return
+        if (not method or
+           method not in self.fhdhr.config.dict["main"]["valid_epg_methods"]):
             method = self.def_method
 
-        self.fhdhr.logger.info("Updating %s EPG cache." % method)
-        programguide = self.epg_handling[method].update_epg()
+        if method == self.fhdhr.config.dict["main"]["dictpopname"]:
+            method = "origin"
 
-        # sort the channel listings by time stamp
-        for cnum in list(programguide.keys()):
+        epgtypename = method
+        if method in [self.fhdhr.config.dict["main"]["dictpopname"], "origin"]:
+            epgtypename = self.fhdhr.config.dict["main"]["dictpopname"]
+
+        self.fhdhr.logger.info("Updating " + epgtypename + " EPG cache.")
+        if method == 'origin':
+            programguide = self.epg_handling['origin'].update_epg(self.channels)
+        else:
+            programguide = self.epg_handling[method].update_epg()
+
+        for chan in list(programguide.keys()):
+            floatnum = str(float(chan))
+            programguide[floatnum] = programguide.pop(chan)
+            programguide[floatnum]["number"] = floatnum
+
+        programguide = OrderedDict(sorted(programguide.items()))
+
+        for cnum in programguide:
             programguide[cnum]["listing"] = sorted(programguide[cnum]["listing"], key=lambda i: i['time_start'])
 
-        # Gernate Block periods for between EPG data, if missing
-        clean_prog_guide = {}
-        desired_start_time = (datetime.datetime.today() + datetime.timedelta(days=self.fhdhr.config.dict["epg"]["reverse_days"])).timestamp()
-        desired_end_time = (datetime.datetime.today() + datetime.timedelta(days=self.fhdhr.config.dict["epg"]["forward_days"])).timestamp()
-        for cnum in list(programguide.keys()):
-
-            if cnum not in list(clean_prog_guide.keys()):
-                clean_prog_guide[cnum] = programguide[cnum].copy()
-                clean_prog_guide[cnum]["listing"] = []
-
-            if method in [origin for origin in list(self.origins.origins_dict.keys())]:
-                chan_obj = self.channels.get_channel_obj("origin_id", programguide[cnum]["id"])
-            else:
-                chan_obj = None
-
-            # Generate Blocks for Channels containing No Lisiings
-            if not len(programguide[cnum]["listing"]):
-                timestamps = self.blocks.timestamps_between(desired_start_time, desired_end_time)
-                clean_prog_dicts = self.blocks.empty_channel_epg(timestamps, chan_dict=programguide[cnum], chan_obj=chan_obj)
-                clean_prog_guide[cnum]["listing"].extend(clean_prog_dicts)
-
-            else:
-
-                # Clean Timetamps from old xmltv method to timestamps
-                progindex = 0
-                for program_item in programguide[cnum]["listing"]:
-                    for time_item in ["time_start", "time_end"]:
-                        time_value = programguide[cnum]["listing"][progindex][time_item]
-                        if str(time_value).endswith("+00:00"):
-                            programguide[cnum]["listing"][progindex][time_item] = datetime.datetime.strptime(time_value, '%Y%m%d%H%M%S +00:00').timestamp()
-                        elif str(time_value).endswith("+0000"):
-                            programguide[cnum]["listing"][progindex][time_item] = datetime.datetime.strptime(time_value, '%Y%m%d%H%M%S +0000').timestamp()
-                        else:
-                            programguide[cnum]["listing"][progindex][time_item] = int(time_value)
-                    progindex += 1
-
-                # Generate time before the listing actually starts
-                first_prog_time = programguide[cnum]["listing"][0]['time_start']
-                if desired_start_time < first_prog_time:
-                    timestamps = self.blocks.timestamps_between(desired_start_time, first_prog_time)
-                    clean_prog_dicts = self.blocks.empty_channel_epg(timestamps, chan_dict=programguide[cnum], chan_obj=chan_obj)
-                    clean_prog_guide[cnum]["listing"].extend(clean_prog_dicts)
-
-                # Generate time blocks between events if chunks of time are missing
-                progindex = 0
-                for program_item in programguide[cnum]["listing"]:
-                    try:
-                        nextprog_dict = programguide[cnum]["listing"][progindex + 1]
-                    except IndexError:
-                        nextprog_dict = None
-                    if not nextprog_dict:
-                        clean_prog_guide[cnum]["listing"].append(program_item)
-                    else:
-                        if nextprog_dict['time_start'] > program_item['time_end']:
-                            timestamps = self.blocks.timestamps_between(program_item['time_end'], nextprog_dict['time_start'])
-                            clean_prog_dicts = self.blocks.empty_channel_epg(timestamps, chan_dict=programguide[cnum], chan_obj=chan_obj)
-                            clean_prog_guide[cnum]["listing"].extend(clean_prog_dicts)
-                        else:
-                            clean_prog_guide[cnum]["listing"].append(program_item)
-                        progindex += 1
-
-                # Generate time after the listing actually ends
-                end_prog_time = programguide[cnum]["listing"][progindex]['time_end']
-                if desired_end_time > end_prog_time:
-                    timestamps = self.blocks.timestamps_between(end_prog_time, desired_end_time)
-                    clean_prog_dicts = self.blocks.empty_channel_epg(timestamps, chan_dict=programguide[cnum], chan_obj=chan_obj)
-                    clean_prog_guide[cnum]["listing"].extend(clean_prog_dicts)
-
-        programguide = clean_prog_guide.copy()
-
-        # if a stock method, generate Blocks EPG for missing channels
-        if method in [origin for origin in list(self.origins.origins_dict.keys())]:
-            timestamps = self.blocks.timestamps
-            for fhdhr_id in [x["id"] for x in self.channels.get_channels(method)]:
-                chan_obj = self.channels.get_channel_obj("id", fhdhr_id, method)
-                if str(chan_obj.number) not in list(programguide.keys()):
-                    programguide[str(chan_obj.number)] = chan_obj.epgdict
-                    clean_prog_dicts = self.blocks.empty_channel_epg(timestamps, chan_obj=chan_obj)
-                    programguide[str(chan_obj.number)]["listing"].extend(clean_prog_dicts)
-
-        # Make Thumbnails for missing thumbnails
-        for cnum in list(programguide.keys()):
-            if not programguide[cnum]["thumbnail"]:
-                programguide[cnum]["thumbnail"] = "/api/images?method=generate&type=channel&message=%s" % programguide[cnum]["number"]
-            programguide[cnum]["listing"] = sorted(programguide[cnum]["listing"], key=lambda i: i['time_start'])
-            prog_index = 0
-            for program_item in programguide[cnum]["listing"]:
-                if not programguide[cnum]["listing"][prog_index]["thumbnail"]:
-                    programguide[cnum]["listing"][prog_index]["thumbnail"] = programguide[cnum]["thumbnail"]
-                prog_index += 1
-
-        # Get Totals
-        total_channels = len(list(programguide.keys()))
-        total_programs = 0
-
-        # Sort the channels
-        sorted_channel_list = channel_sort(list(programguide.keys()))
-        sorted_chan_guide = {}
-        for channel in sorted_channel_list:
-            total_programs += len(programguide[cnum]["listing"])
-            sorted_chan_guide[channel] = programguide[channel]
-
-        self.epgdict[method] = sorted_chan_guide
+        self.epgdict = programguide
         self.fhdhr.db.set_fhdhr_value("epg_dict", method, programguide)
         self.fhdhr.db.set_fhdhr_value("update_time", method, time.time())
-        self.fhdhr.logger.info("Wrote %s EPG cache. %s Programs for %s Channels" % (method, total_programs, total_channels))
-
-    def start(self):
-        self.fhdhr.logger.info("EPG Update Thread Starting")
-        self.fhdhr.threads["epg"].start()
-
-    def stop(self):
-        self.fhdhr.logger.info("EPG Update Thread Stopping")
+        self.fhdhr.logger.info("Wrote " + epgtypename + " EPG cache.")
 
     def run(self):
-        time.sleep(1800)
-        while True:
-            for epg_method in self.epg_methods:
-                last_update_time = self.fhdhr.db.get_fhdhr_value("update_time", epg_method)
-                updatetheepg = False
-                if not last_update_time:
-                    updatetheepg = True
-                elif time.time() >= (last_update_time + self.sleeptime[epg_method]):
-                    updatetheepg = True
-                if updatetheepg:
-                    self.fhdhr.api.get("%s&source=%s" % (self.epg_update_url, epg_method))
-            time.sleep(1800)
-
-        self.stop()
+        for epg_method in self.epg_methods:
+            self.fhdhr.web.session.get(self.epg_update_url)
+        try:
+            while True:
+                for epg_method in self.epg_methods:
+                    if time.time() >= (self.fhdhr.db.get_fhdhr_value("update_time", epg_method) + self.sleeptime[epg_method]):
+                        self.fhdhr.web.session.get(self.epg_update_url)
+                time.sleep(360)
+        except KeyboardInterrupt:
+            pass

fHDHR/device/epg/blocks.py

@@ -3,118 +3,72 @@ import datetime
 
 class blocksEPG():
 
-    def __init__(self, fhdhr, channels, origins, origin):
+    def __init__(self, fhdhr, channels):
         self.fhdhr = fhdhr
+
         self.channels = channels
-        self.origins = origins
-        self.origin = origin
 
     def update_epg(self):
         programguide = {}
 
         timestamps = self.timestamps
 
-        for fhdhr_id in [x["id"] for x in self.channels.get_channels(self.origin)]:
-            chan_obj = self.channels.get_channel_obj("id", fhdhr_id, self.origin)
+        for fhdhr_id in list(self.channels.list.keys()):
+            chan_obj = self.channels.list[fhdhr_id]
 
-            if str(chan_obj.number) not in list(programguide.keys()):
-                programguide[str(chan_obj.number)] = chan_obj.epgdict
+            if str(chan_obj.dict["number"]) not in list(programguide.keys()):
+                programguide[str(chan_obj.dict["number"])] = chan_obj.epgdict
 
-            clean_prog_dicts = self.empty_channel_epg(timestamps, chan_obj=chan_obj)
+            clean_prog_dicts = self.empty_channel_epg(timestamps, chan_obj)
             for clean_prog_dict in clean_prog_dicts:
-                programguide[str(chan_obj.number)]["listing"].append(clean_prog_dict)
+                programguide[str(chan_obj.dict["number"])]["listing"].append(clean_prog_dict)
 
         return programguide
 
+    def get_content_thumbnail(self, content_id):
+        return "/api/images?method=generate&type=content&message=%s" % content_id
+
     @property
     def timestamps(self):
-        desired_start_time = (datetime.datetime.today() + datetime.timedelta(days=self.fhdhr.config.dict["epg"]["reverse_days"])).timestamp()
-        desired_end_time = (datetime.datetime.today() + datetime.timedelta(days=self.fhdhr.config.dict["epg"]["forward_days"])).timestamp()
-        return self.timestamps_between(desired_start_time, desired_end_time)
-
-    def timestamps_between(self, starttime, endtime):
         timestamps = []
-        desired_blocksize = self.fhdhr.config.dict["epg"]["block_size"]
-        current_time = starttime
-        while (current_time + desired_blocksize) <= endtime:
-            timestampdict = {
-                            "time_start": current_time,
-                            "time_end": current_time + desired_blocksize,
-                            }
-            timestamps.append(timestampdict)
-            current_time += desired_blocksize
-        if current_time < endtime:
-            timestampdict = {
-                            "time_start": current_time,
-                            "time_end": endtime
-                            }
-            timestamps.append(timestampdict)
+        todaydate = datetime.date.today()
+        for x in range(0, 6):
+            xdate = todaydate + datetime.timedelta(days=x)
+            xtdate = xdate + datetime.timedelta(days=1)
+
+            for hour in range(0, 24):
+                time_start = datetime.datetime.combine(xdate, datetime.time(hour, 0))
+                if hour + 1 < 24:
+                    time_end = datetime.datetime.combine(xdate, datetime.time(hour + 1, 0))
+                else:
+                    time_end = datetime.datetime.combine(xtdate, datetime.time(0, 0))
+                timestampdict = {
+                                "time_start": str(time_start.strftime('%Y%m%d%H%M%S')) + " +0000",
+                                "time_end": str(time_end.strftime('%Y%m%d%H%M%S')) + " +0000",
+                                }
+                timestamps.append(timestampdict)
         return timestamps
 
-    def single_channel_epg(self, timestampdict, chan_obj=None, chan_dict=None):
-
-        if chan_obj:
-            content_id = "%s_%s" % (chan_obj.dict["origin_id"], timestampdict['time_start'])
-        elif chan_dict:
-            content_id = "%s_%s" % (chan_dict["id"], timestampdict['time_start'])
-
-        clean_prog_dict = {
-                            "time_start": timestampdict['time_start'],
-                            "time_end": timestampdict['time_end'],
-                            "duration_minutes": (timestampdict['time_end'] - timestampdict['time_start']) / 60,
-                            "title": "Unavailable",
-                            "sub-title": "Unavailable",
-                            "description": "Unavailable",
-                            "rating": "N/A",
-                            "episodetitle": None,
-                            "releaseyear": None,
-                            "genres": [],
-                            "seasonnumber": None,
-                            "episodenumber": None,
-                            "isnew": False,
-                            "id": content_id,
-                            }
-        if chan_obj:
-            clean_prog_dict["thumbnail"] = chan_obj.thumbnail
-        elif chan_dict:
-            clean_prog_dict["thumbnail"] = chan_dict["thumbnail"]
-        if not clean_prog_dict["thumbnail"]:
-            clean_prog_dict["thumbnail"] = "/api/images?method=generate&type=content&message=%s" % content_id
-
-        return clean_prog_dict
-
-    def empty_channel_epg(self, timestamps, chan_obj=None, chan_dict=None):
+    def empty_channel_epg(self, timestamps, chan_obj):
         clean_prog_dicts = []
-        for timestampdict in timestamps:
-            clean_prog_dict = self.single_channel_epg(timestampdict, chan_obj=chan_obj, chan_dict=chan_dict)
+        for timestamp in timestamps:
+            content_id = "%s_%s" % (chan_obj.dict["origin_id"], str(timestamp['time_start']).split(" ")[0])
+            clean_prog_dict = {
+                                "time_start": timestamp['time_start'],
+                                "time_end": timestamp['time_end'],
+                                "duration_minutes": 60,
+                                "thumbnail": chan_obj.dict["thumbnail"] or self.get_content_thumbnail(content_id),
+                                "title": "Unavailable",
+                                "sub-title": "Unavailable",
+                                "description": "Unavailable",
+                                "rating": "N/A",
+                                "episodetitle": None,
+                                "releaseyear": None,
+                                "genres": [],
+                                "seasonnumber": None,
+                                "episodenumber": None,
+                                "isnew": False,
+                                "id": content_id,
+                                }
             clean_prog_dicts.append(clean_prog_dict)
         return clean_prog_dicts
-
-    def empty_listing(self, chan_obj=None, chan_dict=None):
-        clean_prog_dict = {
-                            "time_start": None,
-                            "time_end": None,
-                            "duration_minutes": None,
-                            "title": "Unavailable",
-                            "sub-title": "Unavailable",
-                            "description": "Unavailable",
-                            "rating": "N/A",
-                            "episodetitle": None,
-                            "releaseyear": None,
-                            "genres": [],
-                            "seasonnumber": None,
-                            "episodenumber": None,
-                            "isnew": False,
-                            "id": "Unavailable",
-                        }
-
-        if chan_obj:
-            clean_prog_dict["thumbnail"] = chan_obj.thumbnail
-        elif chan_dict:
-            clean_prog_dict["thumbnail"] = chan_dict["thumbnail"]
-        else:
-            clean_prog_dict["thumbnail"] = None
-        if not clean_prog_dict["thumbnail"]:
-            clean_prog_dict["thumbnail"] = "/api/images?method=generate&type=content&message=Unavailable"
-
-        return clean_prog_dict

fHDHR/device/ssdp/__init__.py

@@ -2,7 +2,10 @@
 import socket
 import struct
 import time
-import threading
+
+from .ssdp_detect import fHDHR_Detect
+from .rmg_ssdp import RMG_SSDP
+from .hdhr_ssdp import HDHR_SSDP
 
 
 class SSDPServer():
@@ -10,14 +13,10 @@ class SSDPServer():
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
 
-        self.ssdp_handling = {}
-        self.methods = [x for x in list(self.fhdhr.plugins.plugins.keys()) if self.fhdhr.plugins.plugins[x].type == "ssdp"]
+        self.detect_method = fHDHR_Detect(fhdhr)
 
         if (self.fhdhr.config.dict["fhdhr"]["discovery_address"] and
-           self.fhdhr.config.dict["ssdp"]["enabled"] and
-           len(self.methods)):
-
-            self.fhdhr.threads["ssdp"] = threading.Thread(target=self.run)
+           self.fhdhr.config.dict["ssdp"]["enabled"]):
             self.setup_ssdp()
 
             self.sock.bind((self.bind_address, 1900))
@@ -27,33 +26,12 @@ class SSDPServer():
             self.max_age = int(fhdhr.config.dict["ssdp"]["max_age"])
             self.age_time = None
 
-            self.ssdp_method_selfadd()
+            self.rmg_ssdp = RMG_SSDP(fhdhr, self.broadcast_ip, self.max_age)
+            self.hdhr_ssdp = HDHR_SSDP(fhdhr, self.broadcast_ip, self.max_age)
 
             self.do_alive()
             self.m_search()
 
-    def ssdp_method_selfadd(self):
-        for plugin_name in list(self.fhdhr.plugins.plugins.keys()):
-            if self.fhdhr.plugins.plugins[plugin_name].type == "ssdp":
-                method = self.fhdhr.plugins.plugins[plugin_name].name.lower()
-                plugin_utils = self.fhdhr.plugins.plugins[plugin_name].plugin_utils
-                self.ssdp_handling[method] = self.fhdhr.plugins.plugins[plugin_name].Plugin_OBJ(self.fhdhr, plugin_utils, self.broadcast_ip, self.max_age)
-
-    def start(self):
-        self.fhdhr.logger.info("SSDP Server Starting")
-        self.fhdhr.threads["ssdp"].start()
-
-    def stop(self):
-        self.fhdhr.logger.info("SSDP Server Stopping")
-        self.sock.close()
-
-    def run(self):
-        while True:
-            data, address = self.sock.recvfrom(1024)
-            self.on_recv(data, address)
-            self.do_alive()
-        self.stop()
-
     def do_alive(self, forcealive=False):
 
         send_alive = False
@@ -66,22 +44,21 @@ class SSDPServer():
 
         if send_alive:
             self.fhdhr.logger.info("Sending Alive message to network.")
-            self.do_notify(self.broadcast_address_tuple)
+            self.do_notify(self.broadcase_address_tuple)
             self.age_time = time.time()
 
     def do_notify(self, address):
 
         notify_list = []
-        for ssdp_handler in list(self.ssdp_handling.keys()):
-            if self.ssdp_handling[ssdp_handler].enabled and hasattr(self.ssdp_handling[ssdp_handler], 'notify'):
-                notify_data = self.ssdp_handling[ssdp_handler].notify
-                if isinstance(notify_data, list):
-                    notify_list.extend(notify_data)
-                else:
-                    notify_list.append(notify_data)
+
+        hdhr_notify = self.hdhr_ssdp.get()
+        notify_list.append(hdhr_notify)
+
+        if self.fhdhr.config.dict["rmg"]["enabled"]:
+            rmg_notify = self.rmg_ssdp.get()
+            notify_list.append(rmg_notify)
 
         for notifydata in notify_list:
-            notifydata = notifydata.encode("utf-8")
 
             self.fhdhr.logger.debug("Created {}".format(notifydata))
             try:
@@ -108,10 +85,6 @@ class SSDPServer():
         headers = [x.split(':', 1) for x in lines]
         headers = dict(map(lambda x: (x[0].lower(), x[1]), headers))
 
-        for ssdp_handler in list(self.ssdp_handling.keys()):
-            if self.ssdp_handling[ssdp_handler].enabled and hasattr(self.ssdp_handling[ssdp_handler], 'on_recv'):
-                self.ssdp_handling[ssdp_handler].on_recv(headers, cmd, list(self.ssdp_handling.keys()))
-
         if cmd[0] == 'M-SEARCH' and cmd[1] == '*':
             # SSDP discovery
             self.fhdhr.logger.debug("Received qualifying M-SEARCH from {}".format(address))
@@ -119,14 +92,26 @@ class SSDPServer():
 
             self.do_notify(address)
 
-        if cmd[0] == 'NOTIFY' and cmd[1] == '*':
+        elif cmd[0] == 'NOTIFY' and cmd[1] == '*':
+            # SSDP presence
             self.fhdhr.logger.debug("NOTIFY data: {}".format(headers))
+            try:
+                if headers["server"].startswith("fHDHR"):
+                    savelocation = headers["location"].split("/device.xml")[0]
+                    if savelocation.endswith("/hdhr"):
+                        savelocation = savelocation.replace("/hdhr", '')
+                    elif savelocation.endswith("/rmg"):
+                        savelocation = savelocation.replace("/rmg", '')
+                    if savelocation != self.fhdhr.api.base:
+                        self.detect_method.set(savelocation)
+            except KeyError:
+                return
         else:
             self.fhdhr.logger.debug('Unknown SSDP command %s %s' % (cmd[0], cmd[1]))
 
     def m_search(self):
         data = self.msearch_payload
-        self.sock.sendto(data, self.broadcast_address_tuple)
+        self.sock.sendto(data, self.broadcase_address_tuple)
 
     def create_msearch_payload(self):
 
@@ -147,6 +132,15 @@ class SSDPServer():
 
         return data.encode("utf-8")
 
+    def run(self):
+        try:
+            while True:
+                data, address = self.sock.recvfrom(1024)
+                self.on_recv(data, address)
+                self.do_alive()
+        except KeyboardInterrupt:
+            self.sock.close()
+
     def setup_ssdp(self):
         self.sock = None
 
@@ -173,7 +167,7 @@ class SSDPServer():
         if self.proto == "ipv4":
             self.af_type = socket.AF_INET
             self.broadcast_ip = "239.255.255.250"
-            self.broadcast_address_tuple = (self.broadcast_ip, 1900)
+            self.broadcase_address_tuple = (self.broadcast_ip, 1900)
             self.bind_address = "0.0.0.0"
         elif self.proto == "ipv6":
             self.af_type = socket.AF_INET6

fHDHR/device/ssdp/hdhr_ssdp.py

@@ -0,0 +1,39 @@
+
+
+class HDHR_SSDP():
+
+    def __init__(self, fhdhr, broadcast_ip, max_age):
+        self.fhdhr = fhdhr
+
+        self.ssdp_content = None
+
+        self.broadcast_ip = broadcast_ip
+        self.device_xml_path = '/device.xml'
+
+        self.max_age = max_age
+
+    def get(self):
+        if self.ssdp_content:
+            return self.ssdp_content.encode("utf-8")
+
+        data = ''
+        data_command = "NOTIFY * HTTP/1.1"
+
+        data_dict = {
+                    "HOST": "%s:%s" % (self.broadcast_ip, 1900),
+                    "NT": 'urn:schemas-upnp-org:device:MediaServer:1',
+                    "NTS": "ssdp:alive",
+                    "USN": 'uuid:%s::%s' % (self.fhdhr.config.dict["main"]["uuid"], 'urn:schemas-upnp-org:device:MediaServer:1'),
+                    "SERVER": 'fHDHR/%s UPnP/1.0' % self.fhdhr.version,
+                    "LOCATION": "%s%s" % (self.fhdhr.api.base, self.device_xml_path),
+                    "AL": "%s%s" % (self.fhdhr.api.base, self.device_xml_path),
+                    "Cache-Control:max-age=": self.max_age
+                    }
+
+        data += "%s\r\n" % data_command
+        for data_key in list(data_dict.keys()):
+            data += "%s:%s\r\n" % (data_key, data_dict[data_key])
+        data += "\r\n"
+
+        self.ssdp_content = data
+        return data.encode("utf-8")

fHDHR/device/ssdp/rmg_ssdp.py

@@ -0,0 +1,39 @@
+
+
+class RMG_SSDP():
+
+    def __init__(self, fhdhr, broadcast_ip, max_age):
+        self.fhdhr = fhdhr
+
+        self.ssdp_content = None
+
+        self.broadcast_ip = broadcast_ip
+        self.device_xml_path = '/device.xml'
+
+        self.max_age = max_age
+
+    def get(self):
+        if self.ssdp_content:
+            return self.ssdp_content.encode("utf-8")
+
+        data = ''
+        data_command = "NOTIFY * HTTP/1.1"
+
+        data_dict = {
+                    "HOST": "%s:%s" % (self.broadcast_ip, 1900),
+                    "NT": 'urn:schemas-upnp-org:device-1-0',
+                    "NTS": "ssdp:alive",
+                    "USN": 'uuid:%s::%s' % (self.fhdhr.config.dict["main"]["uuid"], 'urn:schemas-upnp-org:device-1-0'),
+                    "SERVER": 'fHDHR/%s UPnP/1.0' % self.fhdhr.version,
+                    "LOCATION": "%s%s" % (self.fhdhr.api.base, self.device_xml_path),
+                    "AL": "%s%s" % (self.fhdhr.api.base, self.device_xml_path),
+                    "Cache-Control:max-age=": self.max_age
+                    }
+
+        data += "%s\r\n" % data_command
+        for data_key in list(data_dict.keys()):
+            data += "%s:%s\r\n" % (data_key, data_dict[data_key])
+        data += "\r\n"
+
+        self.ssdp_content = data
+        return data.encode("utf-8")

fHDHR/device/ssdp/ssdp_detect.py

@@ -0,0 +1,16 @@
+
+
+class fHDHR_Detect():
+
+    def __init__(self, fhdhr):
+        self.fhdhr = fhdhr
+        self.fhdhr.db.delete_fhdhr_value("ssdp_detect", "list")
+
+    def set(self, location):
+        detect_list = self.fhdhr.db.get_fhdhr_value("ssdp_detect", "list") or []
+        if location not in detect_list:
+            detect_list.append(location)
+            self.fhdhr.db.set_fhdhr_value("ssdp_detect", "list", detect_list)
+
+    def get(self):
+        return self.fhdhr.db.get_fhdhr_value("ssdp_detect", "list") or []

fHDHR/device/tuners/__init__.py

@@ -1,4 +1,3 @@
-import m3u8
 
 from fHDHR.exceptions import TunerError
 
@@ -12,218 +11,96 @@ class Tuners():
         self.channels = channels
 
         self.epg = epg
+        self.max_tuners = int(self.fhdhr.config.dict["fhdhr"]["tuner_count"])
 
         self.tuners = {}
-        for origin in list(self.fhdhr.origins.origins_dict.keys()):
-            self.tuners[origin] = {}
 
-            max_tuners = int(self.fhdhr.origins.origins_dict[origin].tuners)
+        self.fhdhr.logger.info("Creating %s tuners." % str(self.max_tuners))
 
-            self.fhdhr.logger.info("Creating %s tuners for %s." % (max_tuners, origin))
+        for i in range(0, self.max_tuners):
+            self.tuners[str(i)] = Tuner(fhdhr, i, epg)
 
-            for i in range(0, max_tuners):
-                self.tuners[origin][str(i)] = Tuner(fhdhr, i, epg, origin)
+    def get_available_tuner(self):
+        return next(tunernum for tunernum in list(self.tuners.keys()) if not self.tuners[tunernum].tuner_lock.locked()) or None
 
-        self.alt_stream_handlers = {}
+    def get_scanning_tuner(self):
+        return next(tunernum for tunernum in list(self.tuners.keys()) if self.tuners[tunernum].status["status"] == "Scanning") or None
 
-    def alt_stream_methods_selfadd(self):
-        for plugin_name in list(self.fhdhr.plugins.plugins.keys()):
-            if self.fhdhr.plugins.plugins[plugin_name].type == "alt_stream":
-                method = self.fhdhr.plugins.plugins[plugin_name].name
-                self.alt_stream_handlers[method] = self.fhdhr.plugins.plugins[plugin_name]
-
-    def get_available_tuner(self, origin):
-        return next(tunernum for tunernum in list(self.tuners[origin].keys()) if not self.tuners[origin][tunernum].tuner_lock.locked()) or None
-
-    def get_scanning_tuner(self, origin):
-        return next(tunernum for tunernum in list(self.tuners[origin].keys()) if self.tuners[origin][tunernum].status["status"] == "Scanning") or None
-
-    def stop_tuner_scan(self, origin):
-        tunernum = self.get_scanning_tuner(origin)
+    def stop_tuner_scan(self):
+        tunernum = self.get_scanning_tuner()
         if tunernum:
-            self.tuners[origin][str(tunernum)].close()
+            self.tuners[str(tunernum)].close()
 
-    def tuner_scan(self, origin="all"):
+    def tuner_scan(self):
         """Temporarily use a tuner for a scan"""
+        if not self.available_tuner_count():
+            raise TunerError("805 - All Tuners In Use")
 
-        if origin == "all":
-            origins = list(self.tuners.keys())
-        else:
-            origins = [origin]
+        tunernumber = self.get_available_tuner()
+        self.tuners[str(tunernumber)].channel_scan()
 
-        for origin in origins:
+        if not tunernumber:
+            raise TunerError("805 - All Tuners In Use")
 
-            if not self.available_tuner_count(origin):
-                raise TunerError("805 - All Tuners In Use")
+    def tuner_grab(self, tuner_number, channel_number):
 
-            tunernumber = self.get_available_tuner(origin)
-            self.tuners[origin][str(tunernumber)].channel_scan(origin)
-
-            if not tunernumber:
-                raise TunerError("805 - All Tuners In Use")
-
-    def tuner_grab(self, tuner_number, origin, channel_number):
-
-        if str(tuner_number) not in list(self.tuners[origin].keys()):
-            self.fhdhr.logger.error("Tuner %s does not exist for %s." % (tuner_number, origin))
+        if str(tuner_number) not in list(self.tuners.keys()):
+            self.fhdhr.logger.error("Tuner %s does not exist." % str(tuner_number))
             raise TunerError("806 - Tune Failed")
 
         # TunerError will raise if unavailable
-        self.tuners[origin][str(tuner_number)].grab(origin, channel_number)
+        self.tuners[str(tuner_number)].grab(channel_number)
 
         return tuner_number
 
-    def first_available(self, origin, channel_number, dograb=True):
+    def first_available(self, channel_number):
 
-        if not self.available_tuner_count(origin):
+        if not self.available_tuner_count():
             raise TunerError("805 - All Tuners In Use")
 
-        tunernumber = self.get_available_tuner(origin)
+        tunernumber = self.get_available_tuner()
 
         if not tunernumber:
             raise TunerError("805 - All Tuners In Use")
         else:
-            self.tuners[origin][str(tunernumber)].grab(origin, channel_number)
+            self.tuners[str(tunernumber)].grab(channel_number)
             return tunernumber
 
-    def tuner_close(self, tunernum, origin):
-        self.tuners[origin][str(tunernum)].close()
+    def tuner_close(self, tunernum):
+        self.tuners[str(tunernum)].close()
 
-    def status(self, origin=None):
+    def status(self):
         all_status = {}
-        if origin:
-            for tunernum in list(self.tuners[origin].keys()):
-                all_status[tunernum] = self.tuners[origin][str(tunernum)].get_status()
-        else:
-            for origin in list(self.tuners.keys()):
-                all_status[origin] = {}
-                for tunernum in list(self.tuners[origin].keys()):
-                    all_status[origin][tunernum] = self.tuners[origin][str(tunernum)].get_status()
+        for tunernum in list(self.tuners.keys()):
+            all_status[tunernum] = self.tuners[str(tunernum)].get_status()
         return all_status
 
-    def available_tuner_count(self, origin):
+    def available_tuner_count(self):
         available_tuners = 0
-        for tunernum in list(self.tuners[origin].keys()):
-            if not self.tuners[origin][str(tunernum)].tuner_lock.locked():
+        for tunernum in list(self.tuners.keys()):
+            if not self.tuners[str(tunernum)].tuner_lock.locked():
                 available_tuners += 1
         return available_tuners
 
-    def inuse_tuner_count(self, origin):
+    def inuse_tuner_count(self):
         inuse_tuners = 0
-        for tunernum in list(self.tuners[origin].keys()):
-            if self.tuners[origin][str(tunernum)].tuner_lock.locked():
+        for tunernum in list(self.tuners.keys()):
+            if self.tuners[str(tunernum)].tuner_lock.locked():
                 inuse_tuners += 1
         return inuse_tuners
 
     def get_stream_info(self, stream_args):
 
-        stream_info = self.channels.get_channel_stream(stream_args, stream_args["origin"])
-        if not stream_info:
+        stream_args["channelUri"] = self.channels.get_channel_stream(str(stream_args["channel"]))
+        if not stream_args["channelUri"]:
             raise TunerError("806 - Tune Failed")
 
-        if isinstance(stream_info, str):
-            stream_info = {"url": stream_info, "headers": None}
-        stream_args["stream_info"] = stream_info
+        channelUri_headers = self.fhdhr.web.session.head(stream_args["channelUri"]).headers
+        stream_args["true_content_type"] = channelUri_headers['Content-Type']
 
-        if not stream_args["stream_info"]["url"]:
-            raise TunerError("806 - Tune Failed")
-
-        if "headers" not in list(stream_args["stream_info"].keys()):
-            stream_args["stream_info"]["headers"] = None
-
-        if stream_args["stream_info"]["url"].startswith("udp://"):
-            stream_args["true_content_type"] = "video/mpeg"
+        if stream_args["true_content_type"].startswith(tuple(["application/", "text/"])):
             stream_args["content_type"] = "video/mpeg"
         else:
-
-            channel_stream_url_headers = self.fhdhr.web.session.head(stream_args["stream_info"]["url"]).headers
-            stream_args["true_content_type"] = channel_stream_url_headers['Content-Type']
-
-            if stream_args["true_content_type"].startswith(tuple(["application/", "text/"])):
-                stream_args["content_type"] = "video/mpeg"
-                if stream_args["origin_quality"] != -1:
-                    stream_args["stream_info"]["url"] = self.m3u8_quality(stream_args)
-            else:
-                stream_args["content_type"] = stream_args["true_content_type"]
+            stream_args["content_type"] = stream_args["true_content_type"]
 
         return stream_args
-
-    def m3u8_quality(self, stream_args):
-
-        m3u8_url = stream_args["stream_info"]["url"]
-        quality_profile = stream_args["origin_quality"]
-
-        if not quality_profile:
-            if stream_args["method"] == "direct":
-                quality_profile = "high"
-                self.fhdhr.logger.info("Origin Quality not set in config. Direct Method set and will default to Highest Quality")
-            else:
-                self.fhdhr.logger.info("Origin Quality not set in config. %s Method will select the Quality Automatically" % stream_args["method"])
-                return m3u8_url
-        else:
-            quality_profile = quality_profile.lower()
-            self.fhdhr.logger.info("Origin Quality set in config to %s" % (quality_profile))
-
-        while True:
-            self.fhdhr.logger.info("Opening m3u8 for reading %s" % m3u8_url)
-
-            try:
-                if stream_args["stream_info"]["headers"]:
-                    videoUrlM3u = m3u8.load(m3u8_url, headers=stream_args["stream_info"]["headers"])
-                else:
-                    videoUrlM3u = m3u8.load(m3u8_url)
-            except Exception as e:
-                self.fhdhr.logger.info("m3u8 load error: %s" % e)
-                return m3u8_url
-
-            if len(videoUrlM3u.playlists):
-                self.fhdhr.logger.info("%s m3u8 varients found" % len(videoUrlM3u.playlists))
-
-                # Create list of dicts
-                playlists, playlist_index = {}, 0
-                for playlist_item in videoUrlM3u.playlists:
-                    playlist_index += 1
-                    playlist_dict = {
-                                    "url": playlist_item.absolute_uri,
-                                    "bandwidth": playlist_item.stream_info.bandwidth,
-                                    }
-
-                    if not playlist_item.stream_info.resolution:
-                        playlist_dict["width"] = None
-                        playlist_dict["height"] = None
-                    else:
-                        try:
-                            playlist_dict["width"] = playlist_item.stream_info.resolution[0]
-                            playlist_dict["height"] = playlist_item.stream_info.resolution[1]
-                        except TypeError:
-                            playlist_dict["width"] = None
-                            playlist_dict["height"] = None
-
-                    playlists[playlist_index] = playlist_dict
-
-                sorted_playlists = sorted(playlists, key=lambda i: (
-                    int(playlists[i]['bandwidth']),
-                    int(playlists[i]['width'] or 0),
-                    int(playlists[i]['height'] or 0)
-                    ))
-                sorted_playlists = [playlists[x] for x in sorted_playlists]
-
-                if not quality_profile or quality_profile == "high":
-                    selected_index = -1
-                elif quality_profile == "medium":
-                    selected_index = int((len(sorted_playlists) - 1)/2)
-                elif quality_profile == "low":
-                    selected_index = 0
-
-                m3u8_stats = ",".join(
-                    ["%s %s" % (x, sorted_playlists[selected_index][x])
-                     for x in list(sorted_playlists[selected_index].keys())
-                     if x != "url" and sorted_playlists[selected_index][x]])
-                self.fhdhr.logger.info("Selected m3u8 details: %s" % m3u8_stats)
-                m3u8_url = sorted_playlists[selected_index]["url"]
-
-            else:
-                self.fhdhr.logger.info("No m3u8 varients found")
-                break
-
-        return m3u8_url

fHDHR/device/tuners/stream/__init__.py

@@ -2,6 +2,8 @@
 
 from .direct_stream import Direct_Stream
 from .direct_m3u8_stream import Direct_M3U8_Stream
+from .ffmpeg_stream import FFMPEG_Stream
+from .vlc_stream import VLC_Stream
 
 
 class Stream():
@@ -10,14 +12,16 @@ class Stream():
         self.fhdhr = fhdhr
         self.stream_args = stream_args
 
-        if stream_args["method"] == "direct":
-            if self.stream_args["true_content_type"].startswith(tuple(["application/", "text/"])):
-                self.method = Direct_M3U8_Stream(fhdhr, stream_args, tuner)
-            else:
-                self.method = Direct_Stream(fhdhr, stream_args, tuner)
-        else:
-            plugin_name = self.fhdhr.config.dict["streaming"]["valid_methods"][stream_args["method"]]["plugin"]
-            self.method = self.fhdhr.plugins.plugins[plugin_name].Plugin_OBJ(fhdhr, self.fhdhr.plugins.plugins[plugin_name].plugin_utils, stream_args, tuner)
+        if stream_args["method"] == "ffmpeg":
+            self.method = FFMPEG_Stream(fhdhr, stream_args, tuner)
+        if stream_args["method"] == "vlc":
+            self.method = VLC_Stream(fhdhr, stream_args, tuner)
+        elif (stream_args["method"] == "direct" and
+              not self.stream_args["true_content_type"].startswith(tuple(["application/", "text/"]))):
+            self.method = Direct_Stream(fhdhr, stream_args, tuner)
+        elif (stream_args["method"] == "direct" and
+              self.stream_args["true_content_type"].startswith(tuple(["application/", "text/"]))):
+            self.method = Direct_M3U8_Stream(fhdhr, stream_args, tuner)
 
     def get(self):
         return self.method.get()

fHDHR/device/tuners/stream/direct_m3u8_stream.py

@@ -14,17 +14,25 @@ class Direct_M3U8_Stream():
         self.stream_args = stream_args
         self.tuner = tuner
 
-        self.bytes_per_read = int(self.fhdhr.config.dict["streaming"]["bytes_per_read"])
+        self.chunksize = int(self.fhdhr.config.dict["direct_stream"]['chunksize'])
 
     def get(self):
 
         if not self.stream_args["duration"] == 0:
             self.stream_args["time_end"] = self.stream_args["duration"] + time.time()
 
-        self.fhdhr.logger.info("Detected stream of m3u8 URL: %s" % self.stream_args["stream_info"]["url"])
+        self.fhdhr.logger.info("Detected stream URL is m3u8: %s" % self.stream_args["true_content_type"])
 
-        if self.stream_args["transcode_quality"]:
-            self.fhdhr.logger.info("Client requested a %s transcode for stream. Direct Method cannot transcode." % self.stream_args["transcode_quality"])
+        channelUri = self.stream_args["channelUri"]
+        while True:
+
+            self.fhdhr.logger.info("Opening m3u8 for reading %s" % channelUri)
+            videoUrlM3u = m3u8.load(channelUri)
+            if len(videoUrlM3u.playlists):
+                self.fhdhr.logger.info("%s m3u8 varients found" % len(videoUrlM3u.playlists))
+                channelUri = videoUrlM3u.playlists[0].absolute_uri
+            else:
+                break
 
         def generate():
 
@@ -34,16 +42,7 @@ class Direct_M3U8_Stream():
 
                 while self.tuner.tuner_lock.locked():
 
-                    try:
-                        if self.stream_args["stream_info"]["headers"]:
-                            playlist = m3u8.load(self.stream_args["stream_info"]["url"], headers=self.stream_args["stream_info"]["headers"])
-                        else:
-                            playlist = m3u8.load(self.stream_args["stream_info"]["url"])
-                    except Exception as e:
-                        self.fhdhr.logger.info("Connection Closed: %s" % e)
-                        self.tuner.close()
-                        return None
-
+                    playlist = m3u8.load(channelUri)
                     segments = playlist.segments
 
                     if len(played_chunk_urls):
@@ -71,19 +70,13 @@ class Direct_M3U8_Stream():
                                 self.fhdhr.logger.info("Requested Duration Expired.")
                                 self.tuner.close()
 
-                            if self.stream_args["stream_info"]["headers"]:
-                                chunk = self.fhdhr.web.session.get(chunkurl, headers=self.stream_args["stream_info"]["headers"]).content
-                            else:
-                                chunk = self.fhdhr.web.session.get(chunkurl).content
+                            chunk = self.fhdhr.web.session.get(chunkurl).content
                             if not chunk:
                                 break
                                 # raise TunerError("807 - No Video Data")
                             if key:
                                 if key["url"]:
-                                    if self.stream_args["stream_info"]["headers"]:
-                                        keyfile = self.fhdhr.web.session.get(key["url"], headers=self.stream_args["stream_info"]["headers"]).content
-                                    else:
-                                        keyfile = self.fhdhr.web.session.get(key["url"]).content
+                                    keyfile = self.fhdhr.web.session.get(key["url"]).content
                                     cryptor = AES.new(keyfile, AES.MODE_CBC, keyfile)
                                     self.fhdhr.logger.info("Decrypting Chunk #%s with key: %s" % (len(played_chunk_urls), key["url"]))
                                     chunk = cryptor.decrypt(chunk)
@@ -98,11 +91,8 @@ class Direct_M3U8_Stream():
             except GeneratorExit:
                 self.fhdhr.logger.info("Connection Closed.")
             except Exception as e:
-                self.fhdhr.logger.info("Connection Closed: %s" % e)
+                self.fhdhr.logger.info("Connection Closed: " + str(e))
             finally:
-                self.fhdhr.logger.info("Connection Closed: Tuner Lock Removed")
-                if hasattr(self.fhdhr.origins.origins_dict[self.tuner.origin], "close_stream"):
-                    self.fhdhr.origins.origins_dict[self.tuner.origin].close_stream(self.tuner.number, self.stream_args)
                 self.tuner.close()
                 # raise TunerError("806 - Tune Failed")
 

fHDHR/device/tuners/stream/direct_stream.py

@@ -11,22 +11,16 @@ class Direct_Stream():
         self.stream_args = stream_args
         self.tuner = tuner
 
-        self.bytes_per_read = int(self.fhdhr.config.dict["streaming"]["bytes_per_read"])
+        self.chunksize = int(self.fhdhr.config.dict["direct_stream"]['chunksize'])
 
     def get(self):
 
         if not self.stream_args["duration"] == 0:
             self.stream_args["time_end"] = self.stream_args["duration"] + time.time()
 
-        self.fhdhr.logger.info("Direct Stream of %s URL: %s" % (self.stream_args["true_content_type"], self.stream_args["stream_info"]["url"]))
+        self.fhdhr.logger.info("Direct Stream of %s URL: %s" % (self.stream_args["true_content_type"], self.stream_args["channelUri"]))
 
-        if self.stream_args["transcode_quality"]:
-            self.fhdhr.logger.info("Client requested a %s transcode for stream. Direct Method cannot transcode." % self.stream_args["transcode_quality"])
-
-        if self.stream_args["stream_info"]["headers"]:
-            req = self.fhdhr.web.session.get(self.stream_args["stream_info"]["url"], stream=True, headers=self.stream_args["stream_info"]["headers"])
-        else:
-            req = self.fhdhr.web.session.get(self.stream_args["stream_info"]["url"], stream=True)
+        req = self.fhdhr.web.session.get(self.stream_args["channelUri"], stream=True)
 
         def generate():
 
@@ -36,7 +30,7 @@ class Direct_Stream():
 
                 while self.tuner.tuner_lock.locked():
 
-                    for chunk in req.iter_content(chunk_size=self.bytes_per_read):
+                    for chunk in req.iter_content(chunk_size=self.chunksize):
 
                         if (not self.stream_args["duration"] == 0 and
                            not time.time() < self.stream_args["time_end"]):
@@ -60,12 +54,9 @@ class Direct_Stream():
             except GeneratorExit:
                 self.fhdhr.logger.info("Connection Closed.")
             except Exception as e:
-                self.fhdhr.logger.info("Connection Closed: %s" % e)
+                self.fhdhr.logger.info("Connection Closed: " + str(e))
             finally:
                 req.close()
-                self.fhdhr.logger.info("Connection Closed: Tuner Lock Removed")
-                if hasattr(self.fhdhr.origins.origins_dict[self.tuner.origin], "close_stream"):
-                    self.fhdhr.origins.origins_dict[self.tuner.origin].close_stream(self.tuner.number, self.stream_args)
                 self.tuner.close()
                 # raise TunerError("806 - Tune Failed")
 

fHDHR/device/tuners/stream/ffmpeg_stream.py

@@ -0,0 +1,130 @@
+import sys
+import subprocess
+
+# from fHDHR.exceptions import TunerError
+
+
+class FFMPEG_Stream():
+
+    def __init__(self, fhdhr, stream_args, tuner):
+        self.fhdhr = fhdhr
+        self.stream_args = stream_args
+        self.tuner = tuner
+
+        self.bytes_per_read = int(self.fhdhr.config.dict["ffmpeg"]["bytes_per_read"])
+        self.ffmpeg_command = self.ffmpeg_command_assemble(stream_args)
+
+    def get(self):
+
+        ffmpeg_proc = subprocess.Popen(self.ffmpeg_command, stdout=subprocess.PIPE)
+
+        def generate():
+            try:
+                while self.tuner.tuner_lock.locked():
+
+                    chunk = ffmpeg_proc.stdout.read(self.bytes_per_read)
+                    if not chunk:
+                        break
+                        # raise TunerError("807 - No Video Data")
+                    yield chunk
+                    chunk_size = int(sys.getsizeof(chunk))
+                    self.tuner.add_downloaded_size(chunk_size)
+                self.fhdhr.logger.info("Connection Closed: Tuner Lock Removed")
+
+            except GeneratorExit:
+                self.fhdhr.logger.info("Connection Closed.")
+            except Exception as e:
+                self.fhdhr.logger.info("Connection Closed: " + str(e))
+            finally:
+                ffmpeg_proc.terminate()
+                ffmpeg_proc.communicate()
+                self.tuner.close()
+                # raise TunerError("806 - Tune Failed")
+
+        return generate()
+
+    def ffmpeg_command_assemble(self, stream_args):
+        ffmpeg_command = [
+                          self.fhdhr.config.dict["ffmpeg"]["path"],
+                          "-i", stream_args["channelUri"],
+                          ]
+        ffmpeg_command.extend(self.ffmpeg_duration(stream_args))
+        ffmpeg_command.extend(self.transcode_profiles(stream_args))
+        ffmpeg_command.extend(self.ffmpeg_loglevel())
+        ffmpeg_command.extend(["pipe:stdout"])
+        return ffmpeg_command
+
+    def ffmpeg_duration(self, stream_args):
+        ffmpeg_command = []
+        if stream_args["duration"]:
+            ffmpeg_command.extend(["-t", str(stream_args["duration"])])
+        else:
+            ffmpeg_command.extend(
+                                  [
+                                   "-reconnect", "1",
+                                   "-reconnect_at_eof", "1",
+                                   "-reconnect_streamed", "1",
+                                   "-reconnect_delay_max", "2",
+                                  ]
+                                  )
+
+        return ffmpeg_command
+
+    def ffmpeg_loglevel(self):
+        ffmpeg_command = []
+        log_level = self.fhdhr.config.dict["logging"]["level"].lower()
+
+        loglevel_dict = {
+                        "debug": "debug",
+                        "info": "info",
+                        "error": "error",
+                        "warning": "warning",
+                        "critical": "fatal",
+                        }
+        if log_level not in ["info", "debug"]:
+            ffmpeg_command.extend(["-nostats", "-hide_banner"])
+        ffmpeg_command.extend(["-loglevel", loglevel_dict[log_level]])
+        return ffmpeg_command
+
+    def transcode_profiles(self, stream_args):
+        # TODO implement actual profiles here
+        """
+        • heavy: transcode to AVC with the same resolution, frame-rate, and interlacing as the
+        original stream. For example 1080i60 AVC 1080i60, 720p60 AVC 720p60. → →
+        • mobile: trancode to AVC progressive not exceeding 1280x720 30fps.
+        • internet720: transcode to low bitrate AVC progressive not exceeding 1280x720 30fps.
+        • internet480: transcode to low bitrate AVC progressive not exceeding 848x480 30fps for
+        16:9 content, not exceeding 640x480 30fps for 4:3 content.
+        • internet360: transcode to low bitrate AVC progressive not exceeding 640x360 30fps for
+        16:9 content, not exceeding 480x360 30fps for 4:3 content.
+        • internet240: transcode to low bitrate AVC progressive not exceeding 432x240 30fps for
+        16:9 content, not exceeding 320x240 30fps for 4:3 content
+        """
+
+        if stream_args["transcode"]:
+            self.fhdhr.logger.info("Client requested a " + stream_args["transcode"] + " transcode for stream.")
+            stream_args["transcode"] = None
+
+        ffmpeg_command = []
+
+        if not stream_args["transcode"]:
+            ffmpeg_command.extend(
+                                    [
+                                     "-c", "copy",
+                                     "-f", "mpegts",
+                                    ]
+                                    )
+        elif stream_args["transcode"] == "heavy":
+            ffmpeg_command.extend([])
+        elif stream_args["transcode"] == "mobile":
+            ffmpeg_command.extend([])
+        elif stream_args["transcode"] == "internet720":
+            ffmpeg_command.extend([])
+        elif stream_args["transcode"] == "internet480":
+            ffmpeg_command.extend([])
+        elif stream_args["transcode"] == "internet360":
+            ffmpeg_command.extend([])
+        elif stream_args["transcode"] == "internet240":
+            ffmpeg_command.extend([])
+
+        return ffmpeg_command

fHDHR/device/tuners/stream/vlc_stream.py

@@ -0,0 +1,121 @@
+import sys
+import subprocess
+
+# from fHDHR.exceptions import TunerError
+
+
+class VLC_Stream():
+
+    def __init__(self, fhdhr, stream_args, tuner):
+        self.fhdhr = fhdhr
+        self.stream_args = stream_args
+        self.tuner = tuner
+
+        self.bytes_per_read = int(self.fhdhr.config.dict["vlc"]["bytes_per_read"])
+        self.vlc_command = self.vlc_command_assemble(stream_args)
+
+    def get(self):
+
+        vlc_proc = subprocess.Popen(self.vlc_command, stdout=subprocess.PIPE)
+
+        def generate():
+            try:
+
+                while self.tuner.tuner_lock.locked():
+
+                    chunk = vlc_proc.stdout.read(self.bytes_per_read)
+                    if not chunk:
+                        break
+                        # raise TunerError("807 - No Video Data")
+                    yield chunk
+                    chunk_size = int(sys.getsizeof(chunk))
+                    self.tuner.add_downloaded_size(chunk_size)
+                self.fhdhr.logger.info("Connection Closed: Tuner Lock Removed")
+
+            except GeneratorExit:
+                self.fhdhr.logger.info("Connection Closed.")
+            except Exception as e:
+                self.fhdhr.logger.info("Connection Closed: " + str(e))
+            finally:
+                vlc_proc.terminate()
+                vlc_proc.communicate()
+                self.fhdhr.logger.info("Connection Closed: Tuner Lock Removed")
+                self.tuner.close()
+                # raise TunerError("806 - Tune Failed")
+
+        return generate()
+
+    def vlc_command_assemble(self, stream_args):
+        vlc_command = [
+                          self.fhdhr.config.dict["vlc"]["path"],
+                          "-I", "dummy", stream_args["channelUri"],
+                          ]
+        vlc_command.extend(self.vlc_duration(stream_args))
+        vlc_command.extend(self.vlc_loglevel())
+        vlc_command.extend(["--sout"])
+        vlc_command.extend(self.transcode_profiles(stream_args))
+        return vlc_command
+
+    def vlc_duration(self, stream_args):
+        vlc_command = []
+        if stream_args["duration"]:
+            vlc_command.extend(["--run-time=%s" % str(stream_args["duration"])])
+        return vlc_command
+
+    def vlc_loglevel(self):
+        vlc_command = []
+        log_level = self.fhdhr.config.dict["logging"]["level"].lower()
+
+        loglevel_dict = {
+                        "debug": "3",
+                        "info": "0",
+                        "error": "1",
+                        "warning": "2",
+                        "critical": "1",
+                        }
+        vlc_command.extend(["--log-verbose=", loglevel_dict[log_level]])
+        if log_level not in ["info", "debug"]:
+            vlc_command.extend(["--quiet"])
+        return vlc_command
+
+    def transcode_profiles(self, stream_args):
+        # TODO implement actual profiles here
+        """
+        • heavy: transcode to AVC with the same resolution, frame-rate, and interlacing as the
+        original stream. For example 1080i60 AVC 1080i60, 720p60 AVC 720p60. → →
+        • mobile: trancode to AVC progressive not exceeding 1280x720 30fps.
+        • internet720: transcode to low bitrate AVC progressive not exceeding 1280x720 30fps.
+        • internet480: transcode to low bitrate AVC progressive not exceeding 848x480 30fps for
+        16:9 content, not exceeding 640x480 30fps for 4:3 content.
+        • internet360: transcode to low bitrate AVC progressive not exceeding 640x360 30fps for
+        16:9 content, not exceeding 480x360 30fps for 4:3 content.
+        • internet240: transcode to low bitrate AVC progressive not exceeding 432x240 30fps for
+        16:9 content, not exceeding 320x240 30fps for 4:3 content
+        """
+        vlc_command = []
+
+        if stream_args["transcode"]:
+            self.fhdhr.logger.info("Client requested a " + stream_args["transcode"] + " transcode for stream.")
+            stream_args["transcode"] = None
+
+        vlc_transcode_string = "#std{mux=ts,access=file,dst=-}"
+        return [vlc_transcode_string]
+
+        '#transcode{vcodec=mp2v,vb=4096,acodec=mp2a,ab=192,scale=1,channels=2,deinterlace}:std{access=file,mux=ts,dst=-"}'
+
+        if not stream_args["transcode"]:
+            vlc_command.extend([])
+        elif stream_args["transcode"] == "heavy":
+            vlc_command.extend([])
+        elif stream_args["transcode"] == "mobile":
+            vlc_command.extend([])
+        elif stream_args["transcode"] == "internet720":
+            vlc_command.extend([])
+        elif stream_args["transcode"] == "internet480":
+            vlc_command.extend([])
+        elif stream_args["transcode"] == "internet360":
+            vlc_command.extend([])
+        elif stream_args["transcode"] == "internet240":
+            vlc_command.extend([])
+
+        return vlc_command

fHDHR/device/tuners/tuner.py

@@ -1,3 +1,4 @@
+import multiprocessing
 import threading
 import datetime
 
@@ -8,76 +9,70 @@ from .stream import Stream
 
 
 class Tuner():
-    def __init__(self, fhdhr, inum, epg, origin):
+    def __init__(self, fhdhr, inum, epg):
         self.fhdhr = fhdhr
 
         self.number = inum
-        self.origin = origin
         self.epg = epg
 
         self.tuner_lock = threading.Lock()
         self.set_off_status()
 
-        self.chanscan_url = "/api/channels?method=scan"
-        self.close_url = "/api/tuners?method=close&tuner=%s&origin=%s" % (self.number, self.origin)
+        self.chanscan_url = "%s/api/channels?method=scan" % (self.fhdhr.api.base)
+        self.close_url = "%s/api/tuners?method=close&tuner=%s" % (self.fhdhr.api.base, str(self.number))
 
-    def channel_scan(self, origin, grabbed=False):
-        if self.tuner_lock.locked() and not grabbed:
-            self.fhdhr.logger.error("%s Tuner #%s is not available." % (self.origin, self.number))
+    def channel_scan(self):
+        if self.tuner_lock.locked():
+            self.fhdhr.logger.error("Tuner #%s is not available." % str(self.number))
             raise TunerError("804 - Tuner In Use")
 
         if self.status["status"] == "Scanning":
             self.fhdhr.logger.info("Channel Scan Already In Progress!")
         else:
 
-            if not grabbed:
-                self.tuner_lock.acquire()
+            self.tuner_lock.acquire()
             self.status["status"] = "Scanning"
-            self.status["origin"] = origin
-            self.status["time_start"] = datetime.datetime.utcnow()
-            self.fhdhr.logger.info("Tuner #%s Performing Channel Scan for %s origin." % (self.number, origin))
+            self.fhdhr.logger.info("Tuner #%s Performing Channel Scan." % str(self.number))
 
-            chanscan = threading.Thread(target=self.runscan, args=(origin,))
-            chanscan.start()
+            if self.fhdhr.config.dict["main"]["thread_method"] in ["multiprocessing"]:
+                chanscan = multiprocessing.Process(target=self.runscan)
+            elif self.fhdhr.config.dict["main"]["thread_method"] in ["threading"]:
+                chanscan = threading.Thread(target=self.runscan)
+            if self.fhdhr.config.dict["main"]["thread_method"] in ["multiprocessing", "threading"]:
+                chanscan.start()
 
-    def runscan(self, origin):
-        self.fhdhr.api.get("%s&origin=%s" % (self.chanscan_url, origin))
-        self.fhdhr.logger.info("Requested Channel Scan for %s origin Complete." % origin)
-        self.close()
-        self.fhdhr.api.get(self.close_url)
+    def runscan(self):
+        self.fhdhr.web.session.get(self.chanscan_url)
+        self.fhdhr.logger.info("Requested Channel Scan Complete.")
+        self.fhdhr.web.session.get(self.close_url)
 
     def add_downloaded_size(self, bytes_count):
         if "downloaded" in list(self.status.keys()):
             self.status["downloaded"] += bytes_count
 
-    def grab(self, origin, channel_number):
+    def grab(self, channel_number):
         if self.tuner_lock.locked():
-            self.fhdhr.logger.error("Tuner #%s is not available." % self.number)
+            self.fhdhr.logger.error("Tuner #" + str(self.number) + " is not available.")
             raise TunerError("804 - Tuner In Use")
         self.tuner_lock.acquire()
         self.status["status"] = "Acquired"
-        self.status["origin"] = origin
         self.status["channel"] = channel_number
-        self.status["time_start"] = datetime.datetime.utcnow()
         self.fhdhr.logger.info("Tuner #%s Acquired." % str(self.number))
 
     def close(self):
         self.set_off_status()
         if self.tuner_lock.locked():
             self.tuner_lock.release()
-            self.fhdhr.logger.info("Tuner #%s Released." % self.number)
+        self.fhdhr.logger.info("Tuner #" + str(self.number) + " Released.")
 
     def get_status(self):
         current_status = self.status.copy()
-        current_status["epg"] = {}
-        if current_status["status"] in ["Acquired", "Active", "Scanning"]:
-            current_status["running_time"] = str(
+        if current_status["status"] == "Active":
+            current_status["Play Time"] = str(
                 humanized_time(
                     int((datetime.datetime.utcnow() - current_status["time_start"]).total_seconds())))
             current_status["time_start"] = str(current_status["time_start"])
-        if current_status["status"] in ["Active"]:
-            if current_status["origin"] in self.epg.epg_methods:
-                current_status["epg"] = self.epg.whats_on_now(current_status["channel"], method=current_status["origin"])
+            current_status["epg"] = self.epg.whats_on_now(current_status["channel"])
         return current_status
 
     def set_off_status(self):
@@ -85,7 +80,7 @@ class Tuner():
 
     def get_stream(self, stream_args, tuner):
         stream = Stream(self.fhdhr, stream_args, tuner)
-        return stream
+        return stream.get()
 
     def set_status(self, stream_args):
         if self.status["status"] != "Active":
@@ -95,9 +90,8 @@ class Tuner():
                             "clients_id": [],
                             "method": stream_args["method"],
                             "accessed": [stream_args["accessed"]],
-                            "origin": stream_args["origin"],
                             "channel": stream_args["channel"],
-                            "proxied_url": stream_args["stream_info"]["url"],
+                            "proxied_url": stream_args["channelUri"],
                             "time_start": datetime.datetime.utcnow(),
                             "downloaded": 0
                             }

fHDHR/logger/__init__.py

@@ -1,36 +0,0 @@
-import os
-import logging
-
-
-class Logger():
-
-    def __init__(self, settings):
-        self.config = settings
-
-        log_level = self.config.dict["logging"]["level"].upper()
-
-        # Create a custom logger
-        logging.basicConfig(format='%(name)s - %(levelname)s - %(message)s', level=log_level)
-        self.logger = logging.getLogger('fHDHR')
-        log_file = os.path.join(self.config.internal["paths"]["logs_dir"], 'fHDHR.log')
-
-        # Create handlers
-        # c_handler = logging.StreamHandler()
-        f_handler = logging.FileHandler(log_file)
-        # c_handler.setLevel(log_level)
-        f_handler.setLevel(log_level)
-
-        # Create formatters and add it to handlers
-        # c_format = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
-        f_format = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-        # c_handler.setFormatter(c_format)
-        f_handler.setFormatter(f_format)
-
-        # Add handlers to the logger
-        # logger.addHandler(c_handler)
-        self.logger.addHandler(f_handler)
-
-    def __getattr__(self, name):
-        ''' will only get called for undefined attributes '''
-        if hasattr(self.logger, name):
-            return eval("self.logger.%s" % name)

fHDHR/origins/__init__.py

@@ -1,48 +0,0 @@
-
-import fHDHR.exceptions
-
-
-class Origin_StandIN():
-    def __init__(self):
-        self.setup_success = False
-
-    def get_channels(self):
-        return []
-
-    def get_channel_stream(self, chandict, stream_args):
-        return None
-
-
-class Origins():
-
-    def __init__(self, fhdhr):
-        self.fhdhr = fhdhr
-
-        self.origins_dict = {}
-        self.origin_selfadd()
-        for plugin_name in list(self.fhdhr.plugins.plugins.keys()):
-            if self.fhdhr.plugins.plugins[plugin_name].manifest["tagged_mod"] and self.fhdhr.plugins.plugins[plugin_name].manifest["tagged_mod_type"] == "origin":
-                self.fhdhr.plugins.plugins[plugin_name].plugin_utils.origin = self.origins_dict[self.fhdhr.plugins.plugins[plugin_name].manifest["tagged_mod"].lower()]
-
-    @property
-    def valid_origins(self):
-        return [origin for origin in list(self.origins_dict.keys())]
-
-    def origin_selfadd(self):
-        for plugin_name in list(self.fhdhr.plugins.plugins.keys()):
-            if self.fhdhr.plugins.plugins[plugin_name].type == "origin":
-                method = self.fhdhr.plugins.plugins[plugin_name].name.lower()
-                try:
-                    plugin_utils = self.fhdhr.plugins.plugins[plugin_name].plugin_utils
-                    self.origins_dict[method] = self.fhdhr.plugins.plugins[plugin_name].Plugin_OBJ(plugin_utils)
-                    self.fhdhr.logger.info("%s Setup Success" % method)
-                    self.origins_dict[method].setup_success = True
-                except fHDHR.exceptions.OriginSetupError as e:
-                    self.fhdhr.logger.error(e)
-                    self.origins_dict[method] = Origin_StandIN()
-
-                if not hasattr(self.origins_dict[method], 'tuners'):
-                    self.origins_dict[method].tuners = 4
-
-                if not hasattr(self.origins_dict[method], 'stream_method'):
-                    self.origins_dict[method].stream_method = self.fhdhr.config.dict["streaming"]["method"]

fHDHR/originwrapper/__init__.py

@@ -0,0 +1,92 @@
+
+
+import fHDHR.exceptions
+
+
+class OriginEPG_StandIN():
+    def __init__(self):
+        pass
+
+    def update_epg(self, channels):
+        return {}
+
+
+class OriginChannels_StandIN():
+    def __init__(self):
+        pass
+
+    def get_channels(self):
+        return []
+
+    def get_channel_stream(self, chandict):
+        return None
+
+
+class OriginServiceWrapper():
+
+    def __init__(self, fhdhr, origin):
+        self.fhdhr = fhdhr
+        self.origin = origin
+
+        self.servicename = fhdhr.config.dict["main"]["servicename"]
+
+        self.setup_success = None
+        self.setup()
+
+    def setup(self):
+
+        try:
+            self.originservice = self.origin.OriginService(self.fhdhr)
+            self.setup_success = True
+            self.fhdhr.logger.info("%s Setup Success" % self.servicename)
+        except fHDHR.exceptions.OriginSetupError as e:
+            self.fhdhr.logger.error(e)
+            self.setup_success = False
+
+        if self.setup_success:
+            self.channels = self.origin.OriginChannels(self.fhdhr, self.originservice)
+            self.epg = self.origin.OriginEPG(self.fhdhr)
+        else:
+            self.channels = OriginChannels_StandIN()
+            self.epg = OriginEPG_StandIN()
+
+    def get_channels(self):
+        return self.channels.get_channels()
+
+    def get_channel_stream(self, chandict):
+        return self.channels.get_channel_stream(chandict)
+
+    def update_epg(self, channels):
+        return self.epg.update_epg(channels)
+
+    def get_status_dict(self):
+
+        if self.setup_success:
+            status_dict = {
+                            "Setup": "Success",
+                            }
+
+            try:
+                full_status_dict = self.origin.get_status_dict()
+                for status_key in list(full_status_dict.keys()):
+                    status_dict[status_key] = full_status_dict[status_key]
+                return status_dict
+            except AttributeError:
+                return status_dict
+        else:
+            return {
+                    "Setup": "Failed",
+                    }
+
+    def __getattr__(self, name):
+        ''' will only get called for undefined attributes '''
+        if hasattr(self.fhdhr, name):
+            return eval("self.fhdhr." + name)
+        if hasattr(self.originservice, name):
+            return eval("self.originservice." + name)
+        elif hasattr(self.channels, name):
+            return eval("self.channels." + name)
+        elif hasattr(self.epg, name):
+            return eval("self.epg." + name)
+        else:
+            raise AttributeError(name)

fHDHR/plugins/__init__.py

@@ -1,250 +0,0 @@
-import os
-import imp
-import json
-
-
-class Plugin_DB():
-    def __init__(self, db, name):
-        self._db = db
-        self.name = name
-        self.namespace = name.lower()
-
-    # fhdhr
-    def set_fhdhr_value(self, pluginitem, key, value, namespace="default"):
-        print("%s plugin is not allowed write access to fhdhr db namespaces." % self.name)
-        return
-
-    def get_fhdhr_value(self, pluginitem, key, namespace="default"):
-        return self._db.get_fhdhr_value(pluginitem, key, namespace=namespace.lower())
-
-    def delete_fhdhr_value(self, pluginitem, key, namespace="default"):
-        print("%s plugin is not allowed write access to fhdhr db namespaces." % self.name)
-        return
-
-    # Plugin
-    def set_plugin_value(self, pluginitem, key, value, namespace=None):
-        if not namespace:
-            namespace = self.namespace
-        elif namespace.lower() != self.namespace:
-            print("%s plugin is not allowed write access to %s db namespace." % (self.name, namespace))
-            return
-        return self._db.set_plugin_value(pluginitem, key, value, namespace=self.namespace)
-
-    def get_plugin_value(self, pluginitem, key, namespace=None):
-        if not namespace:
-            namespace = self.namespace
-        return self._db.get_plugin_value(pluginitem, key, namespace=namespace.lower())
-
-    def delete_plugin_value(self, pluginitem, key, namespace=None):
-        if not namespace:
-            namespace = self.namespace
-        elif namespace.lower() != self.namespace:
-            print("%s plugin is not allowed write access to %s db namespace." % (self.name, namespace))
-            return
-        return self._db.delete_plugin_value(pluginitem, key, namespace=self.namespace)
-
-
-class Plugin_Config():
-    def __init__(self, config, name):
-        self._config = config
-        self.name = name
-        self.namespace = name.lower()
-
-    @property
-    def dict(self):
-        return self._config.dict.copy()
-
-    @property
-    def internal(self):
-        return self._config.internal.copy()
-
-    @property
-    def conf_default(self):
-        return self._config.conf_default.copy()
-
-    def write(self, key, value, namespace=None):
-        if not namespace:
-            namespace = self.namespace
-        elif str(namespace).lower() != self.namespace:
-            print("%s plugin is not allowed write access to fhdhr config namespaces." % self.name)
-            return
-        return self._config.write(key, value, self.namespace)
-
-
-class Plugin_Utils():
-
-    def __init__(self, config, logger, db, plugin_name, plugin_manifest, modname):
-        self.config = Plugin_Config(config, plugin_manifest["name"])
-        self.db = Plugin_DB(db, plugin_manifest["name"])
-        self.logger = logger
-        self.namespace = plugin_manifest["name"].lower()
-        self.plugin_name = plugin_name
-        self.plugin_manifest = plugin_manifest
-        self.origin = None
-
-
-class Plugin():
-
-    def __init__(self, config, logger, db, plugin_name, plugin_path, plugin_conf, plugin_manifest):
-        self.config = config
-        self.db = db
-        self.logger = logger
-
-        # Gather Info about Plugin
-        self.plugin_name = plugin_name
-        self.modname = os.path.basename(plugin_path)
-        self.path = plugin_path
-        self.module_type = imp.PKG_DIRECTORY
-        self.multi_plugin = (self.plugin_name != self.modname)
-        self.default_conf = plugin_conf
-        self.manifest = plugin_manifest
-
-        if self.multi_plugin:
-            self.plugin_dict_name = "%s_%s" % (plugin_name, self.modname)
-        else:
-            self.plugin_dict_name = plugin_name
-
-        self.plugin_utils = Plugin_Utils(config, logger, db, plugin_name, plugin_manifest, self.modname)
-
-        # Load the module
-        self._module = self._load()
-
-    def setup(self):
-
-        if self.type == "alt_epg":
-            self.config.register_valid_epg_method(self.name, self.plugin_dict_name)
-        elif self.type == "alt_stream":
-            self.config.register_valid_streaming_method(self.name, self.plugin_dict_name)
-        elif self.type == "web":
-            self.config.register_web_path(self.manifest["name"], self.path, self.plugin_dict_name)
-
-        if self.has_setup():
-            self._module.setup(self)
-
-    def has_setup(self):
-        return hasattr(self._module, 'setup')
-
-    def _load(self):
-        description = ('', '', self.module_type)
-        mod = imp.load_module(self.plugin_dict_name, None, self.path, description)
-        return mod
-
-    @property
-    def name(self):
-        return self.manifest["name"]
-
-    @property
-    def version(self):
-        return self.manifest["version"]
-
-    @property
-    def type(self):
-        return self.manifest["type"]
-
-    def __getattr__(self, name):
-        ''' will only get called for undefined attributes '''
-        if name == "Plugin_OBJ":
-            return self._module.Plugin_OBJ
-
-
-class PluginsHandler():
-
-    def __init__(self, settings):
-        self.config = settings
-
-        self.plugins = {}
-
-        self.found_plugins = []
-        self.found_plugins_conf = []
-        self.list_plugins()
-
-    def setup(self):
-        for plugin_name in list(self.plugins.keys()):
-            self.plugins[plugin_name].setup()
-
-    def load_plugin_configs(self):
-        for file_item_path in self.found_plugins_conf:
-            self.config.import_conf_json(file_item_path)
-
-    def list_plugins(self):
-        for directory in self.config.internal["paths"]["plugins_dir"]:
-
-            base = os.path.abspath(directory)
-            for filename in os.listdir(base):
-                abspath = os.path.join(base, filename)
-
-                if os.path.isdir(abspath):
-
-                    plugin_conf = []
-                    for subfilename in os.listdir(abspath):
-                        subabspath = os.path.join(abspath, subfilename)
-                        if subfilename.endswith("_conf.json"):
-                            plugin_conf.append(subabspath)
-                            self.found_plugins_conf.append(subabspath)
-
-                    # Plugin/multi-plugin must have a basic manifest json
-                    conffilepath = os.path.join(abspath, 'plugin.json')
-                    if os.path.isfile(conffilepath):
-                        plugin_manifest = json.load(open(conffilepath, 'r'))
-
-                        for plugin_man_item in ["name", "version", "type"]:
-                            if plugin_man_item not in list(plugin_manifest.keys()):
-                                plugin_manifest[plugin_man_item] = None
-
-                        self.config.register_version(os.path.basename(filename), plugin_manifest["version"], "plugin")
-
-                        if plugin_manifest["type"] == "origin":
-                            self.config.register_valid_origin_method(plugin_manifest["name"])
-
-                        plugin_import_print_string = "Found %s type plugin: %s %s. " % (plugin_manifest["type"], plugin_manifest["name"], plugin_manifest["version"])
-
-                        # Warn for multiple origins
-                        if plugin_manifest["type"] == "origin" and len([plugin_name for plugin_name, plugin_path, plugin_conf, plugin_manifest in self.found_plugins if plugin_manifest["type"] == "origin"]):
-                            plugin_import_print_string += " ImportWarning: Only one Origin Allowed."
-
-                        if not any(plugin_manifest[plugin_item] for plugin_item in ["name", "version", "type"]):
-                            plugin_import_print_string += " ImportWarning: Missing PLUGIN_* Value."
-                        else:
-
-                            # Single Plugin
-                            if os.path.isfile(os.path.join(abspath, '__init__.py')):
-                                plugin_manifest["tagged_mod"] = None
-                                plugin_manifest["tagged_mod_type"] = None
-                                self.found_plugins.append((os.path.basename(filename), abspath, plugin_conf, plugin_manifest))
-
-                            else:
-
-                                # Multi-Plugin
-                                for subfilename in os.listdir(abspath):
-                                    subabspath = os.path.join(abspath, subfilename)
-
-                                    if os.path.isdir(subabspath):
-
-                                        subconffilepath = os.path.join(subabspath, 'plugin.json')
-                                        if os.path.isfile(subconffilepath):
-                                            subplugin_manifest = json.load(open(subconffilepath, 'r'))
-
-                                            for subplugin_man_item in ["name", "version", "type"]:
-                                                if subplugin_man_item not in list(subplugin_manifest.keys()):
-                                                    subplugin_manifest[subplugin_man_item] = plugin_manifest[subplugin_man_item]
-                                        else:
-                                            subplugin_manifest = plugin_manifest
-
-                                        subplugin_manifest["tagged_mod"] = None
-                                        subplugin_manifest["tagged_mod_type"] = None
-                                        if plugin_manifest["type"] != subplugin_manifest["type"]:
-                                            subplugin_manifest["tagged_mod"] = plugin_manifest["name"]
-                                            subplugin_manifest["tagged_mod_type"] = plugin_manifest["type"]
-
-                                        if os.path.isfile(os.path.join(subabspath, '__init__.py')):
-                                            self.found_plugins.append((os.path.basename(filename), subabspath, plugin_conf, subplugin_manifest))
-
-                        print(plugin_import_print_string)
-        self.load_plugin_configs()
-
-    def load_plugins(self, logger, db):
-        self.logger = logger
-        self.db = db
-        for plugin_name, plugin_path, plugin_conf, plugin_manifest in self.found_plugins:
-            plugin_item = Plugin(self.config, self.logger, self.db, plugin_name, plugin_path, plugin_conf, plugin_manifest)
-            self.plugins[plugin_item.plugin_dict_name] = plugin_item

fHDHR/tools/__init__.py

@@ -8,19 +8,6 @@ UNARY_OPS = (ast.UAdd, ast.USub)
 BINARY_OPS = (ast.Add, ast.Sub, ast.Mult, ast.Div, ast.Mod)
 
 
-def channel_sort(channel_list):
-    """Take a list of channel number strings and sort the Numbers and SubNumbers"""
-    chan_dict_list_split = {}
-    for number in channel_list:
-        try:
-            subnumber = number.split(".")[1]
-        except IndexError:
-            subnumber = None
-        prinumber = number.split(".")[0]
-        chan_dict_list_split[number] = {"number": prinumber, "subnumber": subnumber}
-    return sorted(chan_dict_list_split, key=lambda i: (int(chan_dict_list_split[i]['number']), int(chan_dict_list_split[i]['subnumber'] or 0)))
-
-
 def is_docker():
     path = "/proc/self/cgroup"
     if not os.path.isfile(path):
@@ -133,9 +120,9 @@ def humanized_time(countdownseconds):
             if currenttimevar > 1:
                 timetype = str(x+"s")
             if displaymsg:
-                displaymsg = "%s %s %s" % (displaymsg, int(currenttimevar), timetype)
+                displaymsg = str(displaymsg + " " + str(int(currenttimevar)) + " " + timetype)
             else:
-                displaymsg = "%s %s" % (int(currenttimevar), timetype)
+                displaymsg = str(str(int(currenttimevar)) + " " + timetype)
     if not displaymsg:
         return "just now"
     return displaymsg
@@ -147,8 +134,3 @@ class WebReq():
     def __init__(self):
         self.session = requests.Session()
         self.exceptions = requests.exceptions
-
-    def __getattr__(self, name):
-        ''' will only get called for undefined attributes '''
-        if hasattr(self.session, name):
-            return eval("self.session.%s" % name)

fHDHR_web/__init__.py

@@ -1,15 +1,14 @@
 from gevent.pywsgi import WSGIServer
-from flask import Flask, request, session
-import threading
-import uuid
+from flask import Flask, request
 
 from .pages import fHDHR_Pages
 from .files import fHDHR_Files
-from .brython import fHDHR_Brython
+from .hdhr import fHDHR_HDHR
+from .rmg import fHDHR_RMG
 from .api import fHDHR_API
 
 
-fHDHR_web_VERSION = "v0.8.1-beta"
+fHDHR_web_VERSION = "v0.4.0-beta"
 
 
 class fHDHR_HTTP_Server():
@@ -22,182 +21,55 @@ class fHDHR_HTTP_Server():
 
         self.fhdhr.logger.info("Loading Flask.")
 
-        self.fhdhr.app = Flask("fHDHR", template_folder=self.template_folder)
-        self.instance_id = str(uuid.uuid4())
+        self.app = Flask("fHDHR", template_folder=self.template_folder)
 
-        # Allow Internal API Usage
-        self.fhdhr.app.testing = True
-        self.fhdhr.api.client = self.fhdhr.app.test_client()
+        self.fhdhr.logger.info("Loading HTTP Pages Endpoints.")
+        self.pages = fHDHR_Pages(fhdhr)
+        self.add_endpoints(self.pages, "pages")
 
-        # Set Secret Key For Sessions
-        self.fhdhr.app.secret_key = self.fhdhr.config.dict["fhdhr"]["friendlyname"]
+        self.fhdhr.logger.info("Loading HTTP Files Endpoints.")
+        self.files = fHDHR_Files(fhdhr)
+        self.add_endpoints(self.files, "files")
 
-        self.route_list = {}
+        self.fhdhr.logger.info("Loading HTTP HDHR Endpoints.")
+        self.hdhr = fHDHR_HDHR(fhdhr)
+        self.add_endpoints(self.hdhr, "hdhr")
 
-        self.endpoints_obj = {}
-        self.endpoints_obj["pages"] = fHDHR_Pages(fhdhr)
-        self.endpoints_obj["files"] = fHDHR_Files(fhdhr)
-        self.endpoints_obj["brython"] = fHDHR_Brython(fhdhr)
-        self.endpoints_obj["api"] = fHDHR_API(fhdhr)
+        self.fhdhr.logger.info("Loading HTTP RMG Endpoints.")
+        self.rmg = fHDHR_RMG(fhdhr)
+        self.add_endpoints(self.rmg, "rmg")
 
-        self.selfadd_web_plugins()
-        for endpoint_type in list(self.endpoints_obj.keys()):
-            self.fhdhr.logger.info("Loading HTTP %s Endpoints." % endpoint_type)
-            self.add_endpoints(endpoint_type)
+        self.fhdhr.logger.info("Loading HTTP API Endpoints.")
+        self.api = fHDHR_API(fhdhr)
+        self.add_endpoints(self.api, "api")
 
-        self.fhdhr.app.before_request(self.before_request)
-        self.fhdhr.app.after_request(self.after_request)
-        self.fhdhr.app.before_first_request(self.before_first_request)
-
-        self.fhdhr.threads["flask"] = threading.Thread(target=self.run)
-
-    def selfadd_web_plugins(self):
-        for plugin_name in list(self.fhdhr.plugins.plugins.keys()):
-            if self.fhdhr.plugins.plugins[plugin_name].type == "web":
-                method = self.fhdhr.plugins.plugins[plugin_name].name.lower()
-                plugin_utils = self.fhdhr.plugins.plugins[plugin_name].plugin_utils
-                try:
-                    self.endpoints_obj[method] = self.fhdhr.plugins.plugins[plugin_name].Plugin_OBJ(self.fhdhr, plugin_utils)
-                except Exception as e:
-                    print(e)
-
-    def start(self):
-        self.fhdhr.logger.info("Flask HTTP Thread Starting")
-        self.fhdhr.threads["flask"].start()
-
-    def stop(self):
-        self.fhdhr.logger.info("Flask HTTP Thread Stopping")
-        self.http.stop()
+        self.app.before_request(self.before_request)
+        self.app.after_request(self.after_request)
+        self.app.before_first_request(self.before_first_request)
 
     def before_first_request(self):
         self.fhdhr.logger.info("HTTP Server Online.")
 
     def before_request(self):
-
-        session["session_id"] = str(uuid.uuid4())
-        session["instance_id"] = self.instance_id
-        session["route_list"] = self.route_list
-
-        session["user_agent"] = request.headers.get('User-Agent')
-
-        session["is_internal_api"] = self.detect_internal_api(request)
-        if session["is_internal_api"]:
-            self.fhdhr.logger.debug("Client is using internal API call.")
-
-        session["is_mobile"] = self.detect_mobile(request)
-        if session["is_mobile"]:
-            self.fhdhr.logger.debug("Client is a mobile device.")
-
-        session["is_plexmediaserver"] = self.detect_plexmediaserver(request)
-        if session["is_plexmediaserver"]:
-            self.fhdhr.logger.debug("Client is a Plex Media Server.")
-
-        session["deviceauth"] = self.detect_plexmediaserver(request)
-
-        session["tuner_used"] = None
-
-        session["restart"] = False
-
         self.fhdhr.logger.debug("Client %s requested %s Opening" % (request.method, request.path))
 
     def after_request(self, response):
-
-        # Close Tuner if it was in use, and did not close already
-        # if session["tuner_used"] is not None:
-        #    tuner = self.fhdhr.device.tuners.tuners[str(session["tuner_used"])]
-        #    if tuner.tuner_lock.locked():
-        #        self.fhdhr.logger.info("Shutting down Tuner #%s after Request." % session["tuner_used"])
-        #        tuner.close()
-
         self.fhdhr.logger.debug("Client %s requested %s Closing" % (request.method, request.path))
-        if not session["restart"]:
-            return response
-        else:
-            return self.stop()
+        return response
 
-    def detect_internal_api(self, request):
-        user_agent = request.headers.get('User-Agent')
-        if not user_agent:
-            return False
-        elif str(user_agent).lower().startswith("fhdhr"):
-            return True
-        else:
-            return False
-
-    def detect_deviceauth(self, request):
-        return request.args.get('DeviceAuth', default=None, type=str)
-
-    def detect_mobile(self, request):
-        user_agent = request.headers.get('User-Agent')
-        phones = ["iphone", "android", "blackberry"]
-        if not user_agent:
-            return False
-        elif any(phone in user_agent.lower() for phone in phones):
-            return True
-        else:
-            return False
-
-    def detect_plexmediaserver(self, request):
-        user_agent = request.headers.get('User-Agent')
-        if not user_agent:
-            return False
-        elif str(user_agent).lower().startswith("plexmediaserver"):
-            return True
-        else:
-            return False
-
-    def add_endpoints(self, index_name):
-
-        item_list = [x for x in dir(self.endpoints_obj[index_name]) if self.isapath(x)]
-        endpoint_main = self.endpoints_obj[index_name]
-        endpoint_main.fhdhr.version  # dummy line
+    def add_endpoints(self, index_list, index_name):
+        item_list = [x for x in dir(index_list) if self.isapath(x)]
         for item in item_list:
-            endpoints = eval("endpoint_main.%s.%s" % (item, "endpoints"))
+            endpoints = eval("self." + str(index_name) + "." + str(item) + ".endpoints")
             if isinstance(endpoints, str):
                 endpoints = [endpoints]
-            handler = eval("endpoint_main.%s" % item)
-            endpoint_name = eval("endpoint_main.%s.%s" % (item, "endpoint_name"))
-
+            handler = eval("self." + str(index_name) + "." + str(item))
+            endpoint_name = eval("self." + str(index_name) + "." + str(item) + ".endpoint_name")
             try:
-                endpoint_methods = eval("endpoint_main.%s.%s" % (item, "endpoint_methods"))
+                endpoint_methods = eval("self." + str(index_name) + "." + str(item) + ".endpoint_methods")
             except AttributeError:
                 endpoint_methods = ['GET']
-
-            try:
-                endpoint_access_level = eval("endpoint_main.%s.%s" % (item, "endpoint_access_level"))
-            except AttributeError:
-                endpoint_access_level = 0
-
-            try:
-                pretty_name = eval("endpoint_main.%s.%s" % (item, "pretty_name"))
-            except AttributeError:
-                pretty_name = endpoint_name
-
-            try:
-                endpoint_category = eval("endpoint_main.%s.%s" % (item, "endpoint_category"))
-            except AttributeError:
-                endpoint_category = index_name
-
-            try:
-                endpoint_default_parameters = eval("endpoint_main.%s.%s" % (item, "endpoint_default_parameters"))
-            except AttributeError:
-                endpoint_default_parameters = {}
-
-            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_default_parameters"] = endpoint_default_parameters
-            self.route_list[endpoint_category][endpoint_name]["pretty_name"] = pretty_name
-            self.route_list[endpoint_category][endpoint_name]["endpoint_category"] = endpoint_category
-
+            self.fhdhr.logger.info("Adding endpoint %s available at %s with %s methods." % (endpoint_name, ",".join(endpoints), ",".join(endpoint_methods)))
             for endpoint in endpoints:
                 self.add_endpoint(endpoint=endpoint,
                                   endpoint_name=endpoint_name,
@@ -205,7 +77,7 @@ class fHDHR_HTTP_Server():
                                   methods=endpoint_methods)
 
     def isapath(self, item):
-        not_a_page_list = ["fhdhr", "plugin_utils"]
+        not_a_page_list = ["fhdhr", "htmlerror", "page_elements"]
         if item in not_a_page_list:
             return False
         elif item.startswith("__") and item.endswith("__"):
@@ -214,16 +86,15 @@ class fHDHR_HTTP_Server():
             return True
 
     def add_endpoint(self, endpoint=None, endpoint_name=None, handler=None, methods=['GET']):
-        self.fhdhr.app.add_url_rule(endpoint, endpoint_name, handler, methods=methods)
+        self.app.add_url_rule(endpoint, endpoint_name, handler, methods=methods)
 
     def run(self):
 
         self.http = WSGIServer(self.fhdhr.api.address_tuple,
-                               self.fhdhr.app.wsgi_app,
-                               log=self.fhdhr.logger.logger,
-                               error_log=self.fhdhr.logger.logger)
+                               self.app.wsgi_app,
+                               log=self.fhdhr.logger)
+
         try:
             self.http.serve_forever()
-            self.stop()
-        except AttributeError:
-            self.fhdhr.logger.info("HTTP Server Offline")
+        except KeyboardInterrupt:
+            self.http.stop()

fHDHR_web/api/__init__.py

@@ -1,18 +1,14 @@
 
 from .root_url import Root_URL
-from .startup_tasks import Startup_Tasks
 
+from .cluster import Cluster
 from .settings import Settings
 from .channels import Channels
 from .xmltv import xmlTV
 from .m3u import M3U
-from .w3u import W3U
 from .epg import EPG
 from .tuners import Tuners
 from .debug import Debug_JSON
-from .plugins import Plugins_JSON
-
-from .route_list import Route_List
 
 from .images import Images
 
@@ -23,18 +19,14 @@ class fHDHR_API():
         self.fhdhr = fhdhr
 
         self.root_url = Root_URL(fhdhr)
-        self.startup_tasks = Startup_Tasks(fhdhr)
 
+        self.cluster = Cluster(fhdhr)
         self.settings = Settings(fhdhr)
         self.channels = Channels(fhdhr)
         self.xmltv = xmlTV(fhdhr)
         self.m3u = M3U(fhdhr)
-        self.w3u = W3U(fhdhr)
         self.epg = EPG(fhdhr)
         self.tuners = Tuners(fhdhr)
         self.debug = Debug_JSON(fhdhr)
-        self.plugins = Plugins_JSON(fhdhr)
-
-        self.route_list = Route_List(fhdhr)
 
         self.images = Images(fhdhr)

fHDHR_web/api/channels.py

@@ -2,16 +2,11 @@ from flask import request, redirect, Response, abort
 import urllib.parse
 import json
 
-from fHDHR.tools import channel_sort
-
 
 class Channels():
     endpoints = ["/api/channels"]
     endpoint_name = "api_channels"
     endpoint_methods = ["GET", "POST"]
-    endpoint_default_parameters = {
-                                    "method": "get"
-                                    }
 
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
@@ -24,37 +19,14 @@ class Channels():
         method = request.args.get('method', default=None, type=str)
         redirect_url = request.args.get('redirect', default=None, type=str)
 
-        origin_methods = self.fhdhr.origins.valid_origins
-        origin = request.args.get('origin', default=None, type=str)
-        if origin and origin not in origin_methods:
-            return "%s Invalid channels origin" % origin
-
         if method == "get":
-            channels_info = {}
-            if not origin:
-                origin_list = origin_methods
-            else:
-                origin_list = [origin]
-
-            for origin_item in origin_list:
-
-                channels_info[origin_item] = {}
-
-                for fhdhr_id in [x["id"] for x in self.fhdhr.device.channels.get_channels(origin=origin_item)]:
-                    channel_obj = self.fhdhr.device.channels.list[origin_item][fhdhr_id]
-                    channel_dict = channel_obj.dict.copy()
-                    channel_dict["m3u_url"] = channel_obj.api_m3u_url
-                    channel_dict["stream_url"] = channel_obj.api_stream_url
-                    channels_info[origin_item][channel_obj.number] = channel_dict
-
-                # Sort the channels
-                sorted_channel_list = channel_sort(list(channels_info[origin_item].keys()))
-                sorted_chan_guide = []
-                for channel in sorted_channel_list:
-                    sorted_chan_guide.append(channels_info[origin_item][channel])
-
-                channels_info[origin_item] = sorted_chan_guide
-
+            channels_info = []
+            for fhdhr_id in list(self.fhdhr.device.channels.list.keys()):
+                channel_obj = self.fhdhr.device.channels.list[fhdhr_id]
+                channel_dict = channel_obj.dict.copy()
+                channel_dict["play_url"] = channel_obj.play_url
+                channel_dict["stream_url"] = channel_obj.stream_url
+                channels_info.append(channel_dict)
             channels_info_json = json.dumps(channels_info, indent=4)
 
             return Response(status=200,
@@ -66,7 +38,7 @@ class Channels():
             channel = request.args.get('channel', default=None, type=str)
             if not channel:
                 if redirect_url:
-                    return redirect("%s?retmessage=%s" % (redirect_url, urllib.parse.quote("%s Failed" % method)))
+                    return redirect(redirect_url + "?retmessage=" + urllib.parse.quote("%s Failed" % method))
                 else:
                     return "%s Falied" % method
 
@@ -75,34 +47,34 @@ class Channels():
                 channel_method = channel[0]
                 channel_number = channel[1:]
 
-                if str(channel_number) not in [str(x) for x in self.fhdhr.device.channels.get_channel_list("number", origin)]:
+                if str(channel_number) not in [str(x) for x in self.fhdhr.device.channels.get_channel_list("number")]:
                     response = Response("Not Found", status=404)
                     response.headers["X-fHDHR-Error"] = "801 - Unknown Channel"
                     self.fhdhr.logger.error(response.headers["X-fHDHR-Error"])
                     abort(response)
 
                 if channel_method == "+":
-                    self.fhdhr.device.channels.set_channel_enablement("number", channel_number, channel_method, origin)
+                    self.fhdhr.device.channels.set_channel_enablement("number", channel_number, channel_method)
                 elif channel_method == "-":
-                    self.fhdhr.device.channels.set_channel_enablement("number", channel_number, channel_method, origin)
+                    self.fhdhr.device.channels.set_channel_enablement("number", channel_number, channel_method)
                 elif channel_method == "x":
-                    self.fhdhr.device.channels.set_channel_enablement("number", channel_number, "toggle", origin)
+                    self.fhdhr.device.channels.set_channel_enablement("number", channel_number, "toggle")
 
             else:
-                self.fhdhr.logger.warning("Unknown favorite command %s" % request.args['favorite'])
+                self.fhdhr.logger.warning("Unknown favorite command " + request.args['favorite'])
                 return abort(200, "Not a valid favorite command")
 
         elif method in ["enable", "disable"]:
             channel = request.args.get('channel', default=None, type=str)
             if channel == "all":
-                self.fhdhr.device.channels.set_channel_enablement_all(method, origin)
-            elif not channel or str(channel) not in [str(x) for x in self.fhdhr.device.channels.get_channel_list("number", origin)]:
+                self.fhdhr.device.channels.set_channel_enablement_all(method)
+            elif not channel or str(channel) not in [str(x) for x in self.fhdhr.device.channels.get_channel_list("number")]:
                 if redirect_url:
-                    return redirect("%s?retmessage=%s" % (redirect_url, urllib.parse.quote("%s Failed" % method)))
+                    return redirect(redirect_url + "?retmessage=" + urllib.parse.quote("%s Failed" % method))
                 else:
                     return "%s Falied" % method
             else:
-                self.fhdhr.device.channels.set_channel_enablement("number", channel, method, origin)
+                self.fhdhr.device.channels.set_channel_enablement("number", channel, method)
 
         elif method == "update":
             channel_id = request.form.get('id', None)
@@ -112,12 +84,7 @@ class Channels():
                     if key in ["name", "callsign", "thumbnail"]:
                         updatedict[key] = str(request.form.get(key))
                     elif key in ["number"]:
-                        number = str(request.form.get(key))
-                        if "." in number:
-                            updatedict["subnumber"] = number.split(".")[1]
-                            updatedict["number"] = number.split(".")[0]
-                        else:
-                            updatedict["number"] = number
+                        updatedict[key] = float(request.form.get(key))
                     elif key in ["enabled"]:
                         confvalue = request.form.get(key)
                         if str(confvalue).lower() in ["false"]:
@@ -127,44 +94,16 @@ class Channels():
                         updatedict[key] = confvalue
                     elif key in ["favorite", "HD"]:
                         updatedict[key] = int(request.form.get(key))
-            self.fhdhr.device.channels.set_channel_status("id", channel_id, updatedict, origin)
-
-        elif method == "modify":
-            channels_list = json.loads(request.form.get('channels', []))
-            for channel in channels_list:
-                updatedict = {}
-                for key in list(channel.keys()):
-                    if key != "id":
-                        if key in ["name", "callsign", "thumbnail"]:
-                            updatedict[key] = str(channel[key])
-                        elif key in ["number"]:
-                            number = str(channel[key])
-                            if "." in number:
-                                updatedict["subnumber"] = number.split(".")[1]
-                                updatedict["number"] = number.split(".")[0]
-                            else:
-                                updatedict["number"] = number
-                        elif key in ["enabled"]:
-                            confvalue = channel[key]
-                            if str(confvalue).lower() in ["false"]:
-                                confvalue = False
-                            elif str(confvalue).lower() in ["true"]:
-                                confvalue = True
-                            updatedict[key] = confvalue
-                        elif key in ["favorite", "HD"]:
-                            updatedict[key] = int(channel[key])
-                    else:
-                        channel_id = str(channel[key])
-                self.fhdhr.device.channels.set_channel_status("id", channel_id, updatedict, origin)
+            self.fhdhr.device.channels.set_channel_status("id", channel_id, updatedict)
 
         elif method == "scan":
-            self.fhdhr.device.channels.get_channels(forceupdate=True, origin=origin)
+            self.fhdhr.device.channels.get_channels(forceupdate=True)
 
         else:
             return "Invalid Method"
 
         if redirect_url:
-            return redirect("%s?retmessage=%s" % (redirect_url, urllib.parse.quote("%s Success" % method)))
+            return redirect(redirect_url + "?retmessage=" + urllib.parse.quote("%s Success" % method))
         else:
             if method == "scan":
                 return redirect('/lineup_status.json')

fHDHR_web/api/cluster.py

@@ -0,0 +1,56 @@
+from flask import request, redirect, Response
+import urllib.parse
+import json
+
+
+class Cluster():
+    endpoints = ["/api/cluster"]
+    endpoint_name = "api_cluster"
+    endpoint_methods = ["GET", "POST"]
+
+    def __init__(self, fhdhr):
+        self.fhdhr = fhdhr
+
+    def __call__(self, *args):
+        return self.get(*args)
+
+    def get(self, *args):
+
+        method = request.args.get('method', default="get", type=str)
+        location = request.args.get("location", default=None, type=str)
+        redirect_url = request.args.get('redirect', default=None, type=str)
+
+        if method == "get":
+            jsoncluster = self.fhdhr.device.cluster.cluster()
+            cluster_json = json.dumps(jsoncluster, indent=4)
+
+            return Response(status=200,
+                            response=cluster_json,
+                            mimetype='application/json')
+
+        elif method == "scan":
+            self.fhdhr.device.ssdp.m_search()
+
+        elif method == 'add':
+            self.fhdhr.device.cluster.add(location)
+        elif method == 'del':
+            self.fhdhr.device.cluster.remove(location)
+
+        elif method == 'sync':
+            self.fhdhr.device.cluster.sync(location)
+
+        elif method == 'leave':
+            self.fhdhr.device.cluster.leave()
+        elif method == 'disconnect':
+            self.fhdhr.device.cluster.disconnect()
+
+        elif method == 'alive':
+            self.fhdhr.device.ssdp.do_alive(forcealive=True)
+
+        else:
+            return "Invalid Method"
+
+        if redirect_url:
+            return redirect(redirect_url + "?retmessage=" + urllib.parse.quote("%s Success" % method))
+        else:
+            return "%s Success" % method

fHDHR_web/api/debug.py

@@ -19,16 +19,11 @@ class Debug_JSON():
 
         debugjson = {
                     "base_url": base_url,
+                    "total channels": len(self.fhdhr.device.channels.list),
+                    "tuner status": self.fhdhr.device.tuners.status(),
                     }
-
-        for origin in list(self.fhdhr.origins.origins_dict.keys()):
-            debugjson[origin] = {
-                                "tuner status": self.fhdhr.device.tuners.status(origin),
-                                "total channels": len(list(self.fhdhr.device.channels.list[origin].keys()))
-                                }
-
-        debug_json = json.dumps(debugjson, indent=4)
+        cluster_json = json.dumps(debugjson, indent=4)
 
         return Response(status=200,
-                        response=debug_json,
+                        response=cluster_json,
                         mimetype='application/json')

fHDHR_web/api/epg.py

@@ -1,9 +1,6 @@
 from flask import Response, request, redirect
 import urllib.parse
 import json
-import datetime
-
-from fHDHR.tools import humanized_time, channel_sort
 
 
 class EPG():
@@ -23,95 +20,25 @@ class EPG():
         method = request.args.get('method', default="get", type=str)
 
         source = request.args.get('source', default=self.fhdhr.config.dict["epg"]["def_method"], type=str)
-        if source not in list(self.fhdhr.config.dict["epg"]["valid_methods"].keys()):
-            return "%s Invalid epg method" % source
+        if source not in self.fhdhr.config.dict["main"]["valid_epg_methods"]:
+            return "%s Invalid xmltv method" % source
 
         redirect_url = request.args.get('redirect', default=None, type=str)
 
         if method == "get":
 
             epgdict = self.fhdhr.device.epg.get_epg(source)
-            if source in self.fhdhr.origins.valid_origins:
-                epgdict = epgdict.copy()
-                for c in list(epgdict.keys()):
-                    chan_obj = self.fhdhr.device.channels.get_channel_obj("origin_id", epgdict[c]["id"], source)
-                    epgdict[chan_obj.number] = epgdict.pop(c)
-                    epgdict[chan_obj.number]["name"] = chan_obj.dict["name"]
-                    epgdict[chan_obj.number]["callsign"] = chan_obj.dict["callsign"]
-                    epgdict[chan_obj.number]["number"] = chan_obj.number
-                    epgdict[chan_obj.number]["id"] = chan_obj.dict["origin_id"]
-                    epgdict[chan_obj.number]["thumbnail"] = chan_obj.thumbnail
+            epgdict = epgdict.copy()
+            for c in list(epgdict.keys()):
+                chan_obj = self.fhdhr.device.channels.get_channel_obj("origin_id", epgdict[c]["id"])
+                epgdict[chan_obj.dict["number"]] = epgdict.pop(c)
+                epgdict[chan_obj.dict["number"]]["name"] = chan_obj.dict["name"]
+                epgdict[chan_obj.dict["number"]]["callsign"] = chan_obj.dict["callsign"]
+                epgdict[chan_obj.dict["number"]]["number"] = chan_obj.dict["number"]
+                epgdict[chan_obj.dict["number"]]["id"] = chan_obj.dict["origin_id"]
+                epgdict[chan_obj.dict["number"]]["thumbnail"] = chan_obj.thumbnail
 
-            # Sort the channels
-            sorted_channel_list = channel_sort(list(epgdict.keys()))
-            sorted_chan_guide = {}
-            for channel in sorted_channel_list:
-                sorted_chan_guide[channel] = epgdict[channel]
-
-            epg_json = json.dumps(sorted_chan_guide, indent=4)
-
-            return Response(status=200,
-                            response=epg_json,
-                            mimetype='application/json')
-
-        elif method == "current":
-
-            nowtime = datetime.datetime.utcnow().timestamp()
-
-            chan_guide_list = []
-
-            whatson = self.fhdhr.device.epg.whats_on_allchans(source)
-
-            # Sort the channels
-            sorted_channel_list = channel_sort(list(whatson.keys()))
-            sorted_chan_guide = {}
-            for channel in sorted_channel_list:
-                sorted_chan_guide[channel] = whatson[channel]
-
-            for channel in list(sorted_chan_guide.keys()):
-                if sorted_chan_guide[channel]["listing"][0]["time_end"]:
-                    remaining_time = humanized_time(sorted_chan_guide[channel]["listing"][0]["time_end"] - nowtime)
-                else:
-                    remaining_time = "N/A"
-
-                chan_dict = {
-                             "name": sorted_chan_guide[channel]["name"],
-                             "number": sorted_chan_guide[channel]["number"],
-                             "chan_thumbnail": sorted_chan_guide[channel]["thumbnail"],
-                             "listing_title": sorted_chan_guide[channel]["listing"][0]["title"],
-                             "listing_thumbnail": sorted_chan_guide[channel]["listing"][0]["thumbnail"],
-                             "listing_description": sorted_chan_guide[channel]["listing"][0]["description"],
-                             "listing_remaining_time": str(remaining_time)
-                             }
-
-                for time_item in ["time_start", "time_end"]:
-
-                    if not sorted_chan_guide[channel]["listing"][0][time_item]:
-                        chan_dict["listing_%s" % time_item] = "N/A"
-                    elif str(sorted_chan_guide[channel]["listing"][0][time_item]).endswith(tuple(["+0000", "+00:00"])):
-                        chan_dict["listing_%s" % time_item] = str(sorted_chan_guide[channel]["listing"][0][time_item])
-                    else:
-                        chan_dict["listing_%s" % time_item] = str(datetime.datetime.fromtimestamp(sorted_chan_guide[channel]["listing"][0][time_item]))
-
-                if source in self.fhdhr.origins.valid_origins:
-                    chan_obj = self.fhdhr.device.channels.get_channel_obj("origin_id", sorted_chan_guide[channel]["id"], source)
-
-                    chan_dict["name"] = chan_obj.dict["name"]
-                    chan_dict["number"] = chan_obj.number
-                    chan_dict["chan_thumbnail"] = chan_obj.thumbnail
-                    chan_dict["enabled"] = chan_obj.dict["enabled"]
-                    chan_dict["m3u_url"] = chan_obj.api_m3u_url
-
-                    chan_dict["listing_thumbnail"] = chan_dict["listing_thumbnail"] or chan_obj.thumbnail
-                else:
-                    if not chan_dict["listing_thumbnail"]:
-                        chan_dict["listing_thumbnail"] = chan_dict["chan_thumbnail"]
-                    if not chan_dict["listing_thumbnail"]:
-                        chan_dict["listing_thumbnail"] = "/api/images?method=generate&type=channel&message=%s" % chan_dict["number"]
-
-                chan_guide_list.append(chan_dict)
-
-            epg_json = json.dumps(chan_guide_list, indent=4)
+            epg_json = json.dumps(epgdict, indent=4)
 
             return Response(status=200,
                             response=epg_json,
@@ -127,6 +54,6 @@ class EPG():
             return "%s Invalid Method" % method
 
         if redirect_url:
-            return redirect("%s?retmessage=%s" % (redirect_url, urllib.parse.quote("%s Success" % method)))
+            return redirect(redirect_url + "?retmessage=" + urllib.parse.quote("%s Success" % method))
         else:
             return "%s Success" % method

fHDHR_web/api/images.py

@@ -5,11 +5,6 @@ class Images():
     endpoints = ["/api/images"]
     endpoint_name = "api_images"
     endpoint_methods = ["GET", "POST"]
-    endpoint_default_parameters = {
-                                    "method": "generate",
-                                    "type": "content",
-                                    "message": "Internal Image Handling"
-                                    }
 
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
@@ -31,7 +26,7 @@ class Images():
 
         elif method == "get":
             source = request.args.get('source', default=self.fhdhr.config.dict["epg"]["method"], type=str)
-            if source in list(self.fhdhr.config.dict["epg"]["valid_methods"].keys()):
+            if source in self.fhdhr.config.dict["main"]["valid_epg_methods"]:
                 image_type = request.args.get('type', default="content", type=str)
                 if image_type in ["content", "channel"]:
                     image_id = request.args.get('id', default=None, type=str)

fHDHR_web/api/m3u.py

@@ -2,8 +2,6 @@ from flask import Response, request, redirect
 import urllib.parse
 from io import StringIO
 
-from fHDHR.tools import channel_sort
-
 
 class M3U():
     endpoints = ["/api/m3u", "/api/channels.m3u"]
@@ -26,11 +24,6 @@ class M3U():
 
         if method == "get":
 
-            origin_methods = self.fhdhr.origins.valid_origins
-            origin = request.args.get('origin', default=None, type=str)
-            if origin and origin not in origin_methods:
-                return "%s Invalid channels origin" % origin
-
             FORMAT_DESCRIPTOR = "#EXTM3U"
             RECORD_MARKER = "#EXTINF"
 
@@ -38,41 +31,24 @@ class M3U():
 
             xmltvurl = ('%s/api/xmltv' % base_url)
 
-            fakefile.write("%s url-tvg=\"%s\" x-tvg-url=\"%s\"\n" % (FORMAT_DESCRIPTOR, xmltvurl, xmltvurl))
+            fakefile.write(
+                            "%s\n" % (
+                                     FORMAT_DESCRIPTOR + " " +
+                                     "url-tvg=\"" + xmltvurl + "\"" + " " +
+                                     "x-tvg-url=\"" + xmltvurl + "\"")
+                            )
 
             channel_items = []
 
-            if origin:
-                if channel == "all":
-                    fileName = "channels.m3u"
-                    for fhdhr_id in [x["id"] for x in self.fhdhr.device.channels.get_channels(origin)]:
-                        channel_obj = self.fhdhr.device.channels.get_channel_obj("id", fhdhr_id, origin)
-                        if channel_obj.enabled:
-                            channel_items.append(channel_obj)
-                elif str(channel) in [str(x) for x in self.fhdhr.device.channels.get_channel_list("number", origin)]:
-                    channel_obj = self.fhdhr.device.channels.get_channel_obj("number", channel, origin)
-                    fileName = "%s.m3u" % channel_obj.number
-                    if channel_obj.enabled:
-                        channel_items.append(channel_obj)
-                    else:
-                        return "Channel Disabled"
-                elif channel != "all" and str(channel) in [str(x) for x in self.fhdhr.device.channels.get_channel_list("id", origin)]:
-                    channel_obj = self.fhdhr.device.channels.get_channel_obj("id", channel, origin)
-                    fileName = "%s.m3u" % channel_obj.number
-                    if channel_obj.enabled:
-                        channel_items.append(channel_obj)
-                    else:
-                        return "Channel Disabled"
-            elif not origin and channel == "all":
+            if channel == "all":
                 fileName = "channels.m3u"
-                for origin in list(self.fhdhr.origins.origins_dict.keys()):
-                    for fhdhr_id in [x["id"] for x in self.fhdhr.device.channels.get_channels(origin)]:
-                        channel_obj = self.fhdhr.device.channels.get_channel_obj("id", fhdhr_id, origin)
-                        if channel_obj.enabled:
-                            channel_items.append(channel_obj)
-            elif not origin and channel != "all" and str(channel) in [str(x) for x in self.fhdhr.device.channels.get_channel_list("id")]:
-                channel_obj = self.fhdhr.device.channels.get_channel_obj("id", channel)
-                fileName = "%s.m3u" % channel_obj.number
+                for fhdhr_id in list(self.fhdhr.device.channels.list.keys()):
+                    channel_obj = self.fhdhr.device.channels.list[fhdhr_id]
+                    if channel_obj.enabled:
+                        channel_items.append(channel_obj)
+            elif str(channel) in [str(x) for x in self.fhdhr.device.channels.get_channel_list("number")]:
+                channel_obj = self.fhdhr.device.channels.get_channel_obj("number", channel)
+                fileName = str(channel_obj.number) + ".m3u"
                 if channel_obj.enabled:
                     channel_items.append(channel_obj)
                 else:
@@ -80,7 +56,6 @@ class M3U():
             else:
                 return "Invalid Channel"
 
-            channels_info = {}
             for channel_obj in channel_items:
 
                 if self.fhdhr.config.dict["epg"]["images"] == "proxy" or not channel_obj.thumbnail:
@@ -89,39 +64,26 @@ class M3U():
                 else:
                     logourl = channel_obj.thumbnail
 
-                channels_info[channel_obj.number] = {
-                                                    "channelID": str(channel_obj.dict['origin_id']),
-                                                    "tvg-chno": str(channel_obj.number),
-                                                    "tvg-name": str(channel_obj.dict['name']),
-                                                    "tvg-id": str(channel_obj.number),
-                                                    "tvg-logo": logourl,
-                                                    "group-title": channel_obj.origin,
-                                                    "group-titleb": str(channel_obj.dict['name']),
-                                                    "stream_url": "%s%s" % (base_url, channel_obj.api_stream_url)
-                                                    }
+                fakefile.write(
+                                "%s\n" % (
+                                          RECORD_MARKER + ":0" + " " +
+                                          "channelID=\"" + str(channel_obj.dict['origin_id']) + "\" " +
+                                          "tvg-chno=\"" + str(channel_obj.dict['number']) + "\" " +
+                                          "tvg-name=\"" + str(channel_obj.dict['name']) + "\" " +
+                                          "tvg-id=\"" + str(channel_obj.dict['number']) + "\" " +
+                                          "tvg-logo=\"" + logourl + "\" " +
+                                          "group-title=\"" + self.fhdhr.config.dict["fhdhr"]["friendlyname"] + "\"," + str(channel_obj.dict['name']))
+                                )
 
-            # Sort the channels
-            sorted_channel_list = channel_sort(list(channels_info.keys()))
-            sorted_chan_guide = []
-            for channel in sorted_channel_list:
-                sorted_chan_guide.append(channels_info[channel])
-
-            for channel_item_dict in sorted_chan_guide:
-                m3ustring = "%s:0 " % (RECORD_MARKER)
-                for chan_key in list(channel_item_dict.keys()):
-                    if not chan_key.startswith(tuple(["group-title", "stream_url"])):
-                        m3ustring += "%s=\"%s\" " % (chan_key, channel_item_dict[chan_key])
-                m3ustring += "group-title=\"%s\",%s\n" % (channel_item_dict["group-title"], channel_item_dict["group-titleb"])
-                m3ustring += "%s\n" % channel_item_dict["stream_url"]
-                fakefile.write(m3ustring)
+                fakefile.write("%s%s\n" % (base_url, channel_obj.stream_url))
 
                 channels_m3u = fakefile.getvalue()
 
             resp = Response(status=200, response=channels_m3u, mimetype='audio/x-mpegurl')
-            resp.headers["content-disposition"] = "attachment; filename=%s" % fileName
+            resp.headers["content-disposition"] = "attachment; filename=" + fileName
             return resp
 
         if redirect_url:
-            return redirect("%s?retmessage=%s" % (redirect_url, urllib.parse.quote("%s Success" % method)))
+            return redirect(redirect_url + "?retmessage=" + urllib.parse.quote("%s Success" % method))
         else:
             return "%s Success" % method

fHDHR_web/api/plugins.py

@@ -1,30 +0,0 @@
-from flask import Response
-import json
-
-
-class Plugins_JSON():
-    endpoints = ["/api/plugins"]
-    endpoint_name = "api_plugins"
-    endpoint_methods = ["GET", "POST"]
-
-    def __init__(self, fhdhr):
-        self.fhdhr = fhdhr
-
-    def __call__(self, *args):
-        return self.get(*args)
-
-    def get(self, *args):
-
-        pluginsjson = {}
-
-        for plugin in list(self.fhdhr.plugins.plugins.keys()):
-            pluginsjson[plugin] = {
-                                    "name": plugin,
-                                    "manifest": self.fhdhr.plugins.plugins[plugin].manifest
-                                    }
-
-        plugins_json = json.dumps(pluginsjson, indent=4)
-
-        return Response(status=200,
-                        response=plugins_json,
-                        mimetype='application/json')

fHDHR_web/api/root_url.py

@@ -1,4 +1,4 @@
-from flask import redirect
+from flask import redirect, request
 
 
 class Root_URL():
@@ -13,4 +13,20 @@ class Root_URL():
         return self.get(*args)
 
     def get(self, *args):
-        return redirect("/index")
+
+        user_agent = request.headers.get('User-Agent')
+
+        # Client Devices Discovering Device Information
+        if not user_agent or str(user_agent).lower().startswith("plexmediaserver"):
+
+            # Plex Remote Media Grabber redirect
+            if self.fhdhr.config.dict["rmg"]["enabled"] and str(user_agent).lower().startswith("plexmediaserver"):
+                return redirect("/rmg")
+
+            # Client Device is looking for HDHR type device
+            else:
+                return redirect("/hdhr/device.xml")
+
+        # Anything Else is likely a Web Browser
+        else:
+            return redirect("/index")

fHDHR_web/api/route_list.py

@@ -1,37 +0,0 @@
-from flask import Response, request, redirect, session
-import urllib.parse
-import json
-
-
-class Route_List():
-    endpoints = ["/api/routes"]
-    endpoint_name = "api_routes"
-    endpoint_methods = ["GET", "POST"]
-
-    def __init__(self, fhdhr):
-        self.fhdhr = fhdhr
-
-    def __call__(self, *args):
-        return self.get(*args)
-
-    def get(self, *args):
-
-        method = request.args.get('method', default="get", type=str)
-
-        redirect_url = request.args.get('redirect', default=None, type=str)
-
-        if method == "get":
-
-            return_json = json.dumps(session["route_list"], indent=4)
-
-            return Response(status=200,
-                            response=return_json,
-                            mimetype='application/json')
-
-        else:
-            return "%s Invalid Method" % method
-
-        if redirect_url:
-            return redirect("%s?retmessage=%s" % (redirect_url, urllib.parse.quote("%s Success" % method)))
-        else:
-            return "%s Success" % method

fHDHR_web/api/settings.py

@@ -1,8 +1,5 @@
-from flask import request, redirect, Response, session
+from flask import request, redirect
 import urllib.parse
-import threading
-import time
-import json
 
 
 class Settings():
@@ -13,9 +10,6 @@ class Settings():
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
 
-        self.restart_url = "/api/settings?method=restart_actual"
-        self.restart_sleep = 5
-
     def __call__(self, *args):
         return self.get(*args)
 
@@ -24,50 +18,23 @@ class Settings():
         method = request.args.get('method', default="get", type=str)
         redirect_url = request.args.get('redirect', default=None, type=str)
 
-        if method == "get":
-            web_settings_dict = {}
-            for config_section in list(self.fhdhr.config.conf_default.keys()):
-                web_settings_dict[config_section] = {}
-
-                for config_item in list(self.fhdhr.config.conf_default[config_section].keys()):
-                    web_settings_dict[config_section][config_item] = {
-                        "value": self.fhdhr.config.dict[config_section][config_item],
-                        }
-                    if self.fhdhr.config.conf_default[config_section][config_item]["config_web_hidden"]:
-                        web_settings_dict[config_section][config_item]["value"] = "***********"
-
-            return_json = json.dumps(web_settings_dict, indent=4)
-
-            return Response(status=200,
-                            response=return_json,
-                            mimetype='application/json')
-
-        elif method == "update":
+        if method == "update":
             config_section = request.form.get('config_section', None)
             config_name = request.form.get('config_name', None)
             config_value = request.form.get('config_value', None)
 
             if not config_section or not config_name or not config_value:
                 if redirect_url:
-                    return redirect("%s?retmessage=%s" % (redirect_url, urllib.parse.quote("%s Failed" % method)))
+                    return redirect(redirect_url + "?retmessage=" + urllib.parse.quote("%s Failed" % method))
                 else:
                     return "%s Falied" % method
 
-            self.fhdhr.config.write(config_name, config_value, config_section)
+            if config_section == "origin":
+                config_section = self.fhdhr.config.dict["main"]["dictpopname"]
 
-        elif method == "restart":
-            restart_thread = threading.Thread(target=self.restart_thread)
-            restart_thread.start()
-            return redirect("%s?retmessage=%s" % (redirect_url, urllib.parse.quote("Restarting in %s seconds" % self.restart_sleep)))
-
-        elif method == "restart_actual":
-            session["restart"] = True
+            self.fhdhr.config.write(config_section, config_name, config_value)
 
         if redirect_url:
-            return redirect("%s?retmessage=%s" % (redirect_url, urllib.parse.quote("%s Success" % method)))
+            return redirect(redirect_url + "?retmessage=" + urllib.parse.quote("%s Success" % method))
         else:
             return "%s Success" % method
-
-    def restart_thread(self):
-        time.sleep(self.restart_sleep)
-        self.fhdhr.api.get(self.restart_url)

fHDHR_web/api/startup_tasks.py

@@ -1,39 +0,0 @@
-
-
-class Startup_Tasks():
-    endpoints = ["/api/startup_tasks"]
-    endpoint_name = "api_startup_tasks"
-    endpoint_methods = ["GET", "POST"]
-
-    def __init__(self, fhdhr):
-        self.fhdhr = fhdhr
-
-        self.epg_update_url = "/api/epg?method=update"
-        self.channel_update_url = "/api/channels?method=scan"
-
-    def __call__(self, *args):
-        return self.get(*args)
-
-    def get(self, *args):
-
-        self.fhdhr.logger.info("Running Startup Tasks.")
-
-        # Hit Channel Update API
-        haseverscanned = self.fhdhr.db.get_fhdhr_value("channels", "scanned_time")
-        updatechannels = False
-        if not haseverscanned:
-            updatechannels = True
-        elif self.fhdhr.config.dict["fhdhr"]["chanscan_on_start"]:
-            updatechannels = True
-
-        if updatechannels:
-            for origin in list(self.fhdhr.origins.origins_dict.keys()):
-                self.fhdhr.api.get("%s&origin=%s" % (self.channel_update_url, origin))
-
-        # Hit EPG Update API
-        for epg_method in self.fhdhr.device.epg.epg_methods:
-            self.fhdhr.api.get("%s&source=%s" % (self.epg_update_url, epg_method))
-
-        self.fhdhr.logger.info("Startup Tasks Complete.")
-
-        return "Success"

fHDHR_web/api/tuners.py

@@ -1,6 +1,6 @@
-from flask import Response, request, redirect, abort, stream_with_context, session
+from flask import Response, request, redirect, abort, stream_with_context
 import urllib.parse
-import json
+import uuid
 
 from fHDHR.exceptions import TunerError
 
@@ -9,9 +9,6 @@ class Tuners():
     endpoints = ["/api/tuners"]
     endpoint_name = "api_tuners"
     endpoint_methods = ["GET", "POST"]
-    endpoint_default_parameters = {
-                                    "method": "status"
-                                    }
 
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
@@ -25,66 +22,36 @@ class Tuners():
 
         accessed_url = request.args.get('accessed', default=request.url, type=str)
 
-        method = request.args.get('method', default=self.fhdhr.config.dict["streaming"]["method"], type=str)
+        method = request.args.get('method', default=self.fhdhr.config.dict["fhdhr"]["stream_type"], type=str)
 
-        tuner_number = request.args.get('tuner', default=None, type=str)
+        tuner_number = request.args.get('tuner', None, type=str)
 
         redirect_url = request.args.get('redirect', default=None, type=str)
 
-        origin_methods = self.fhdhr.origins.valid_origins
-        origin = request.args.get('origin', default=None, type=str)
-        if origin and origin not in origin_methods:
-            return "%s Invalid channels origin" % origin
-
-        if method == "stream":
+        if method in ["direct", "ffmpeg", "vlc"]:
 
             channel_number = request.args.get('channel', None, type=str)
             if not channel_number:
                 return "Missing Channel"
 
-            if origin:
+            if str(channel_number) not in [str(x) for x in self.fhdhr.device.channels.get_channel_list("number")]:
+                response = Response("Not Found", status=404)
+                response.headers["X-fHDHR-Error"] = "801 - Unknown Channel"
+                self.fhdhr.logger.error(response.headers["X-fHDHR-Error"])
+                abort(response)
 
-                if str(channel_number) in [str(x) for x in self.fhdhr.device.channels.get_channel_list("number", origin)]:
-                    chan_obj = self.fhdhr.device.channels.get_channel_obj("number", channel_number, origin)
-                elif str(channel_number) in [str(x) for x in self.fhdhr.device.channels.get_channel_list("id", origin)]:
-                    chan_obj = self.fhdhr.device.channels.get_channel_obj("id", channel_number, origin)
-                else:
-                    response = Response("Not Found", status=404)
-                    response.headers["X-fHDHR-Error"] = "801 - Unknown Channel"
-                    self.fhdhr.logger.error(response.headers["X-fHDHR-Error"])
-                    abort(response)
-
-            else:
-
-                if str(channel_number) in [str(x) for x in self.fhdhr.device.channels.get_channel_list("id")]:
-                    chan_obj = self.fhdhr.device.channels.get_channel_obj("id", channel_number)
-                else:
-                    response = Response("Not Found", status=404)
-                    response.headers["X-fHDHR-Error"] = "801 - Unknown Channel"
-                    self.fhdhr.logger.error(response.headers["X-fHDHR-Error"])
-                    abort(response)
-
-            if not chan_obj.dict["enabled"]:
+            channel_dict = self.fhdhr.device.channels.get_channel_dict("number", channel_number)
+            if not channel_dict["enabled"]:
                 response = Response("Service Unavailable", status=503)
                 response.headers["X-fHDHR-Error"] = str("806 - Tune Failed")
                 self.fhdhr.logger.error(response.headers["X-fHDHR-Error"])
                 abort(response)
 
-            origin = chan_obj.origin
-            channel_number = chan_obj.number
-
-            stream_method = request.args.get('stream_method', default=self.fhdhr.origins.origins_dict[origin].stream_method, type=str)
-            if stream_method not in list(self.fhdhr.config.dict["streaming"]["valid_methods"].keys()):
-                response = Response("Service Unavailable", status=503)
-                response = Response("Service Unavailable", status=503)
-                response.headers["X-fHDHR-Error"] = str("806 - Tune Failed")
-                abort(response)
-
             duration = request.args.get('duration', default=0, type=int)
 
-            transcode_quality = request.args.get('transcode', default=None, type=str)
+            transcode = request.args.get('transcode', default=None, type=str)
             valid_transcode_types = [None, "heavy", "mobile", "internet720", "internet480", "internet360", "internet240"]
-            if transcode_quality not in valid_transcode_types:
+            if transcode not in valid_transcode_types:
                 response = Response("Service Unavailable", status=503)
                 response.headers["X-fHDHR-Error"] = "802 - Unknown Transcode Profile"
                 self.fhdhr.logger.error(response.headers["X-fHDHR-Error"])
@@ -92,21 +59,19 @@ class Tuners():
 
             stream_args = {
                             "channel": channel_number,
-                            "origin": origin,
-                            "method": stream_method,
+                            "method": method,
                             "duration": duration,
-                            "origin_quality": self.fhdhr.config.dict["streaming"]["origin_quality"],
-                            "transcode_quality": transcode_quality or self.fhdhr.config.dict["streaming"]["transcode_quality"],
+                            "transcode": transcode,
                             "accessed": accessed_url,
                             "client": client_address,
-                            "client_id": session["session_id"]
+                            "client_id": str(client_address) + "_" + str(uuid.uuid4())
                             }
 
             try:
                 if not tuner_number:
-                    tunernum = self.fhdhr.device.tuners.first_available(origin, channel_number)
+                    tunernum = self.fhdhr.device.tuners.first_available(channel_number)
                 else:
-                    tunernum = self.fhdhr.device.tuners.tuner_grab(tuner_number, origin, channel_number)
+                    tunernum = self.fhdhr.device.tuners.tuner_grab(tuner_number, channel_number)
             except TunerError as e:
                 self.fhdhr.logger.info("A %s stream request for channel %s was rejected due to %s"
                                        % (stream_args["method"], str(stream_args["channel"]), str(e)))
@@ -114,91 +79,47 @@ class Tuners():
                 response.headers["X-fHDHR-Error"] = str(e)
                 self.fhdhr.logger.error(response.headers["X-fHDHR-Error"])
                 abort(response)
-
-            tuner = self.fhdhr.device.tuners.tuners[origin][str(tunernum)]
+            tuner = self.fhdhr.device.tuners.tuners[str(tunernum)]
 
             try:
                 stream_args = self.fhdhr.device.tuners.get_stream_info(stream_args)
             except TunerError as e:
-                self.fhdhr.logger.info("A %s stream request for %s channel %s was rejected due to %s"
-                                       % (origin, stream_args["method"], str(stream_args["channel"]), str(e)))
+                self.fhdhr.logger.info("A %s stream request for channel %s was rejected due to %s"
+                                       % (stream_args["method"], str(stream_args["channel"]), str(e)))
                 response = Response("Service Unavailable", status=503)
                 response.headers["X-fHDHR-Error"] = str(e)
                 self.fhdhr.logger.error(response.headers["X-fHDHR-Error"])
                 tuner.close()
                 abort(response)
 
-            self.fhdhr.logger.info("%s Tuner #%s to be used for stream." % (origin, tunernum))
+            self.fhdhr.logger.info("Tuner #" + str(tunernum) + " to be used for stream.")
             tuner.set_status(stream_args)
-            session["tuner_used"] = tunernum
 
-            try:
-                stream = tuner.get_stream(stream_args, tuner)
-            except TunerError as e:
-                response.headers["X-fHDHR-Error"] = str(e)
-                self.fhdhr.logger.error(response.headers["X-fHDHR-Error"])
-                tuner.close()
-                abort(response)
-
-            return Response(stream_with_context(stream.get()), mimetype=stream_args["content_type"])
+            if stream_args["method"] == "direct":
+                return Response(tuner.get_stream(stream_args, tuner), content_type=stream_args["content_type"], direct_passthrough=True)
+            elif stream_args["method"] in ["ffmpeg", "vlc"]:
+                return Response(stream_with_context(tuner.get_stream(stream_args, tuner)), mimetype=stream_args["content_type"])
 
         elif method == "close":
 
-            if not origin:
-                return "Missing Origin"
-
-            if not tuner_number or str(tuner_number) not in list(self.fhdhr.device.tuners.tuners[origin].keys()):
+            if not tuner_number or str(tuner_number) not in list(self.fhdhr.device.tuners.tuners.keys()):
                 return "%s Invalid tuner" % str(tuner_number)
 
-            session["tuner_used"] = tuner_number
-
-            tuner = self.fhdhr.device.tuners.tuners[origin][str(tuner_number)]
+            tuner = self.fhdhr.device.tuners.tuners[str(tuner_number)]
             tuner.close()
 
         elif method == "scan":
 
-            if not origin:
-                for origin in list(self.fhdhr.device.tuners.tuners.keys()):
-                    if not tuner_number:
-                        tunernum = self.fhdhr.device.tuners.first_available(origin, None)
-                    else:
-                        tunernum = self.fhdhr.device.tuners.tuner_grab(tuner_number, origin, None)
-                    tuner = self.fhdhr.device.tuners.tuners[origin][str(tunernum)]
-                    tuner.channel_scan(origin=origin, grabbed=False)
+            if not tuner_number:
+                self.fhdhr.device.tuners.tuner_scan()
             else:
-                if not tuner_number:
-                    tunernum = self.fhdhr.device.tuners.first_available(origin, None)
-                else:
-                    tunernum = self.fhdhr.device.tuners.tuner_grab(tuner_number, origin, None)
-                tuner = self.fhdhr.device.tuners.tuners[origin][str(tunernum)]
-                tuner.channel_scan(origin=origin, grabbed=True)
-
-        elif method == "status":
-
-            if not origin:
-                if not tuner_number:
-                    tuner_status = self.fhdhr.device.tuners.status()
-                else:
-                    tuner_status = ["Invalid Tuner %s" % tuner_number]
-            else:
-
-                if not tuner_number:
-                    tuner_status = self.fhdhr.device.tuners.status(origin)
-                elif str(tuner_number) in list(self.fhdhr.device.tuners.tuners[origin].keys()):
-                    tuner_status = self.fhdhr.device.tuners.tuners[origin][str(tuner_number)].get_status()
-                else:
-                    tuner_status = ["Invalid Tuner %s" % tuner_number]
-
-            tuner_status_json = json.dumps(tuner_status, indent=4)
-
-            return Response(status=200,
-                            response=tuner_status_json,
-                            mimetype='application/json')
+                tuner = self.fhdhr.device.tuners.tuners[str(tuner_number)]
+                tuner.channel_scan()
 
         else:
             return "%s Invalid Method" % method
 
         if redirect_url:
-            return redirect("%s?retmessage=%s" % (redirect_url, urllib.parse.quote("%s Success" % method)))
+            return redirect(redirect_url + "?retmessage=" + urllib.parse.quote("%s Success" % method))
         else:
             return "%s Success" % method

fHDHR_web/api/w3u.py

@@ -1,116 +0,0 @@
-from flask import Response, request, redirect
-import urllib.parse
-import json
-
-from fHDHR.tools import channel_sort
-
-
-class W3U():
-    endpoints = ["/api/w3u"]
-    endpoint_name = "api_w3u"
-    endpoint_methods = ["GET", "POST"]
-
-    def __init__(self, fhdhr):
-        self.fhdhr = fhdhr
-
-    def __call__(self, *args):
-        return self.get(*args)
-
-    def get(self, *args):
-
-        base_url = request.url_root[:-1]
-
-        method = request.args.get('method', default="get", type=str)
-        channel = request.args.get('channel', default="all", type=str)
-        redirect_url = request.args.get('redirect', default=None, type=str)
-
-        if method == "get":
-
-            origin_methods = self.fhdhr.origins.valid_origins
-            origin = request.args.get('origin', default=None, type=str)
-            if origin and origin not in origin_methods:
-                return "%s Invalid channels origin" % origin
-
-            channel_info_w3u = {
-                                "name": self.fhdhr.config.dict["fhdhr"]["friendlyname"],
-                                "image": '%s/favicon.ico' % base_url,
-                                "epg": '%s/api/xmltv' % base_url,
-                                "stations": []
-                                }
-
-            channel_items = []
-
-            if origin:
-                if channel == "all":
-                    fileName = "channels.w3u"
-                    for fhdhr_id in [x["id"] for x in self.fhdhr.device.channels.get_channels(origin)]:
-                        channel_obj = self.fhdhr.device.channels.get_channel_obj("id", fhdhr_id, origin)
-                        if channel_obj.enabled:
-                            channel_items.append(channel_obj)
-                elif str(channel) in [str(x) for x in self.fhdhr.device.channels.get_channel_list("number", origin)]:
-                    channel_obj = self.fhdhr.device.channels.get_channel_obj("number", channel, origin)
-                    fileName = "%s.w3u" % channel_obj.number
-                    if channel_obj.enabled:
-                        channel_items.append(channel_obj)
-                    else:
-                        return "Channel Disabled"
-                elif channel != "all" and str(channel) in [str(x) for x in self.fhdhr.device.channels.get_channel_list("id", origin)]:
-                    channel_obj = self.fhdhr.device.channels.get_channel_obj("id", channel, origin)
-                    fileName = "%s.w3u" % channel_obj.number
-                    if channel_obj.enabled:
-                        channel_items.append(channel_obj)
-                    else:
-                        return "Channel Disabled"
-            elif not origin and channel == "all":
-                fileName = "channels.w3u"
-                for origin in list(self.fhdhr.origins.origins_dict.keys()):
-                    for fhdhr_id in [x["id"] for x in self.fhdhr.device.channels.get_channels(origin)]:
-                        channel_obj = self.fhdhr.device.channels.get_channel_obj("id", fhdhr_id, origin)
-                        if channel_obj.enabled:
-                            channel_items.append(channel_obj)
-            elif not origin and channel != "all" and str(channel) in [str(x) for x in self.fhdhr.device.channels.get_channel_list("id")]:
-                channel_obj = self.fhdhr.device.channels.get_channel_obj("id", channel)
-                fileName = "%s.w3u" % channel_obj.number
-                if channel_obj.enabled:
-                    channel_items.append(channel_obj)
-                else:
-                    return "Channel Disabled"
-            else:
-                return "Invalid Channel"
-
-            channels_info = {}
-
-            for channel_obj in channel_items:
-
-                if self.fhdhr.config.dict["epg"]["images"] == "proxy" or not channel_obj.thumbnail:
-                    logourl = ('%s/api/images?method=get&type=channel&id=%s' %
-                               (base_url, str(channel_obj.dict['origin_id'])))
-                else:
-                    logourl = channel_obj.thumbnail
-
-                channels_info[channel_obj.number] = {
-                                                    "name": str(channel_obj.dict['name']),
-                                                    "url": "%s%s" % (base_url, channel_obj.api_stream_url),
-                                                    "epgId": str(channel_obj.dict['origin_id']),
-                                                    "image": logourl,
-                                                    }
-
-            # Sort the channels
-            sorted_channel_list = channel_sort(list(channels_info.keys()))
-            for channel in sorted_channel_list:
-                channel_info_w3u["stations"].append(channels_info[channel])
-
-            channels_info_json = json.dumps(channel_info_w3u, indent=4)
-
-            resp = Response(status=200, response=channels_info_json, mimetype='application/json')
-            resp.headers["content-disposition"] = "attachment; filename=%s" % fileName
-            return resp
-
-            return Response(status=200,
-                            response=channels_info_json,
-                            mimetype='application/json')
-
-        if redirect_url:
-            return redirect("%s?retmessage=%s" % (redirect_url, urllib.parse.quote("%s Success" % method)))
-        else:
-            return "%s Success" % method

fHDHR_web/api/xmltv.py

@@ -1,8 +1,7 @@
-from flask import Response, request, redirect, session
+from flask import Response, request, redirect
 import xml.etree.ElementTree
 from io import BytesIO
 import urllib.parse
-import datetime
 
 from fHDHR.tools import sub_el
 
@@ -16,21 +15,14 @@ class xmlTV():
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
 
-        self.xmltv_offset = {}
-        for epg_method in list(self.fhdhr.device.epg.epg_handling.keys()):
-            if epg_method in list(self.fhdhr.config.dict.keys()):
-                if "xmltv_offset" in list(self.fhdhr.config.dict[epg_method].keys()):
-                    self.xmltv_offset[epg_method] = self.fhdhr.config.dict[epg_method]["xmltv_offset"]
-            if epg_method not in list(self.xmltv_offset.keys()):
-                self.xmltv_offset[epg_method] = self.fhdhr.config.dict["epg"]["xmltv_offset"]
-
     def __call__(self, *args):
         return self.get(*args)
 
     def get(self, *args):
 
         if self.fhdhr.config.dict["fhdhr"]["require_auth"]:
-            if session["deviceauth"] != self.fhdhr.config.dict["fhdhr"]["device_auth"]:
+            DeviceAuth = request.args.get('DeviceAuth', default=None, type=str)
+            if DeviceAuth != self.fhdhr.config.dict["fhdhr"]["device_auth"]:
                 return "not subscribed"
 
         base_url = request.url_root[:-1]
@@ -38,7 +30,7 @@ class xmlTV():
         method = request.args.get('method', default="get", type=str)
 
         source = request.args.get('source', default=self.fhdhr.config.dict["epg"]["def_method"], type=str)
-        if source not in list(self.fhdhr.config.dict["epg"]["valid_methods"].keys()):
+        if source not in self.fhdhr.config.dict["main"]["valid_epg_methods"]:
             return "%s Invalid xmltv method" % source
 
         redirect_url = request.args.get('redirect', default=None, type=str)
@@ -46,18 +38,6 @@ class xmlTV():
         if method == "get":
 
             epgdict = self.fhdhr.device.epg.get_epg(source)
-
-            if source in self.fhdhr.origins.valid_origins:
-                epgdict = epgdict.copy()
-                for c in list(epgdict.keys()):
-                    chan_obj = self.fhdhr.device.channels.get_channel_obj("origin_id", epgdict[c]["id"], source)
-                    epgdict[chan_obj.number] = epgdict.pop(c)
-                    epgdict[chan_obj.number]["name"] = chan_obj.dict["name"]
-                    epgdict[chan_obj.number]["callsign"] = chan_obj.dict["callsign"]
-                    epgdict[chan_obj.number]["number"] = chan_obj.number
-                    epgdict[chan_obj.number]["id"] = chan_obj.dict["origin_id"]
-                    epgdict[chan_obj.number]["thumbnail"] = chan_obj.thumbnail
-
             xmltv_xml = self.create_xmltv(base_url, epgdict, source)
 
             return Response(status=200,
@@ -74,7 +54,7 @@ class xmlTV():
             return "%s Invalid Method" % method
 
         if redirect_url:
-            return redirect("%s?retmessage=%s" % (redirect_url, urllib.parse.quote("%s Success" % method)))
+            return redirect(redirect_url + "?retmessage=" + urllib.parse.quote("%s Success" % method))
         else:
             return "%s Success" % method
 
@@ -84,7 +64,7 @@ class xmlTV():
         xmltvgen.set('source-info-url', self.fhdhr.config.dict["fhdhr"]["friendlyname"])
         xmltvgen.set('source-info-name', self.fhdhr.config.dict["main"]["servicename"])
         xmltvgen.set('generator-info-name', 'fHDHR')
-        xmltvgen.set('generator-info-url', 'fHDHR/%s' % self.fhdhr.config.dict["main"]["reponame"])
+        xmltvgen.set('generator-info-url', 'fHDHR/' + self.fhdhr.config.dict["main"]["reponame"])
         return xmltvgen
 
     def xmltv_file(self, xmltvgen):
@@ -98,14 +78,6 @@ class xmlTV():
         """This method is called when creation of a full xmltv is not possible"""
         return self.xmltv_file(self.xmltv_headers())
 
-    def timestamp_to_datetime(self, time_start, time_end, source):
-        xmltvtimetamps = {}
-        source_offset = self.xmltv_offset[source]
-        for time_item, time_value in zip(["time_start", "time_end"], [time_start, time_end]):
-            timestampval = datetime.datetime.fromtimestamp(time_value).strftime('%Y%m%d%H%M%S')
-            xmltvtimetamps[time_item] = "%s %s" % (timestampval, source_offset)
-        return xmltvtimetamps
-
     def create_xmltv(self, base_url, epgdict, source):
         if not epgdict:
             return self.xmltv_empty()
@@ -113,15 +85,15 @@ class xmlTV():
 
         out = self.xmltv_headers()
 
-        if source in self.fhdhr.origins.valid_origins:
+        if source in ["origin", "blocks", self.fhdhr.config.dict["main"]["dictpopname"]]:
             for c in list(epgdict.keys()):
-                chan_obj = self.fhdhr.device.channels.get_channel_obj("origin_id", epgdict[c]["id"], source)
-                epgdict[chan_obj.number] = epgdict.pop(c)
-                epgdict[chan_obj.number]["name"] = chan_obj.dict["name"]
-                epgdict[chan_obj.number]["callsign"] = chan_obj.dict["callsign"]
-                epgdict[chan_obj.number]["number"] = chan_obj.number
-                epgdict[chan_obj.number]["id"] = chan_obj.dict["origin_id"]
-                epgdict[chan_obj.number]["thumbnail"] = chan_obj.thumbnail
+                chan_obj = self.fhdhr.device.channels.get_channel_obj("origin_id", epgdict[c]["id"])
+                epgdict[chan_obj.dict["number"]] = epgdict.pop(c)
+                epgdict[chan_obj.dict["number"]]["name"] = chan_obj.dict["name"]
+                epgdict[chan_obj.dict["number"]]["callsign"] = chan_obj.dict["callsign"]
+                epgdict[chan_obj.dict["number"]]["number"] = chan_obj.dict["number"]
+                epgdict[chan_obj.dict["number"]]["id"] = chan_obj.dict["origin_id"]
+                epgdict[chan_obj.dict["number"]]["thumbnail"] = chan_obj.thumbnail
 
         for c in list(epgdict.keys()):
 
@@ -135,7 +107,7 @@ class xmlTV():
             sub_el(c_out, 'display-name', text=epgdict[c]['name'])
 
             if self.fhdhr.config.dict["epg"]["images"] == "proxy":
-                sub_el(c_out, 'icon', src=("%s/api/images?method=get&type=channel&id=%s" % (base_url, epgdict[c]['id'])))
+                sub_el(c_out, 'icon', src=(str(base_url) + "/api/images?method=get&type=channel&id=" + str(epgdict[c]['id'])))
             else:
                 sub_el(c_out, 'icon', src=(epgdict[c]["thumbnail"]))
 
@@ -145,18 +117,16 @@ class xmlTV():
 
             for program in channel_listing:
 
-                xmltvtimetamps = self.timestamp_to_datetime(program['time_start'], program['time_end'], source)
-
                 prog_out = sub_el(out, 'programme',
-                                       start=xmltvtimetamps['time_start'],
-                                       stop=xmltvtimetamps['time_end'],
+                                       start=program['time_start'],
+                                       stop=program['time_end'],
                                        channel=str(channelnum))
 
                 sub_el(prog_out, 'title', lang='en', text=program['title'])
 
                 sub_el(prog_out, 'desc', lang='en', text=program['description'])
 
-                sub_el(prog_out, 'sub-title', lang='en', text='Movie: %s' % program['sub-title'])
+                sub_el(prog_out, 'sub-title', lang='en', text='Movie: ' + program['sub-title'])
 
                 sub_el(prog_out, 'length', units='minutes', text=str(int(program['duration_minutes'])))
 
@@ -178,11 +148,11 @@ class xmlTV():
 
                 if program["thumbnail"]:
                     if self.fhdhr.config.dict["epg"]["images"] == "proxy":
-                        sub_el(prog_out, 'icon', src=("%s/api/images?method=get&type=content&id=%s" % (base_url, program['id'])))
+                        sub_el(prog_out, 'icon', src=(str(base_url) + "/api/images?method=get&type=content&id=" + str(program['id'])))
                     else:
                         sub_el(prog_out, 'icon', src=(program["thumbnail"]))
                 else:
-                    sub_el(prog_out, 'icon', src=("%s/api/images?method=generate&type=content&message=%s" % (base_url, urllib.parse.quote(program['title']))))
+                    sub_el(prog_out, 'icon', src=(str(base_url) + "/api/images?method=generate&type=content&message=" + urllib.parse.quote(program['title'])))
 
                 if program['rating']:
                     rating_out = sub_el(prog_out, 'rating', system="MPAA")

fHDHR_web/brython/__init__.py

@@ -1,17 +0,0 @@
-
-
-from .brython import Brython
-from .brython_stdlib import Brython_stdlib
-
-from .brython_bry import Brython_bry
-
-
-class fHDHR_Brython():
-
-    def __init__(self, fhdhr):
-        self.fhdhr = fhdhr
-
-        self.brython = Brython(fhdhr)
-        self.brython_stdlib = Brython_stdlib(fhdhr)
-
-        self.brython_bry = Brython_bry(fhdhr)

fHDHR_web/brython/brython.py

@@ -1,21 +0,0 @@
-from flask import send_from_directory
-
-import pathlib
-
-
-class Brython():
-    endpoints = ["/brython.js"]
-    endpoint_name = "file_brython_js"
-
-    def __init__(self, fhdhr):
-        self.fhdhr = fhdhr
-        self.brython_path = pathlib.Path(self.fhdhr.config.internal["paths"]["fHDHR_web_dir"]).joinpath('brython')
-
-    def __call__(self, *args):
-        return self.get(*args)
-
-    def get(self, *args):
-
-        return send_from_directory(self.brython_path,
-                                   'brython.js',
-                                   mimetype='text/javascript')

fHDHR_web/brython/brython_bry.py

@@ -1,19 +0,0 @@
-from flask import send_from_directory
-
-import pathlib
-
-
-class Brython_bry():
-    endpoints = ["/brython.bry"]
-    endpoint_name = "file_brython_bry"
-
-    def __init__(self, fhdhr):
-        self.fhdhr = fhdhr
-        self.brython_path = pathlib.Path(self.fhdhr.config.internal["paths"]["fHDHR_web_dir"]).joinpath('brython')
-
-    def __call__(self, *args):
-        return self.get(*args)
-
-    def get(self, *args):
-
-        return send_from_directory(self.brython_path, 'brython_code.py')

fHDHR_web/brython/brython_code.py

@@ -1,104 +0,0 @@
-from browser import document, bind  # alert, window
-import json
-
-
-def chan_edit_data(items, channel_id):
-
-    chanlist = []
-    chandict = {}
-
-    for element in items:
-        if element.name == "id":
-            if len(chandict.keys()) >= 2 and "id" in list(chandict.keys()):
-                chanlist.append(chandict)
-            chandict = {"id": element.value}
-        if element.type == "checkbox":
-            if element.name in ["enabled"]:
-                save_val = element.checked
-            else:
-                save_val = int(element.checked)
-        else:
-            save_val = element.value
-        if element.name != "id":
-            cur_value = element.placeholder
-            if element.type == "checkbox":
-                if element.name in ["enabled"]:
-                    cur_value = element.placeholder
-                else:
-                    cur_value = int(element.placeholder)
-            if str(save_val) != str(cur_value):
-                chandict[element.name] = save_val
-
-    if channel_id != "all":
-        chanlist == [x for x in chanlist if x["id"] == channel_id]
-
-    return chanlist
-
-
-def chan_edit_postform(chanlist):
-    origin = document["origin"].value
-    postForm = document.createElement('form')
-    postForm.method = "POST"
-    postForm.action = "/api/channels?method=modify&origin=%s&redirect=/channels_editor&origin=%s" % (origin, origin)
-    postForm.setRequestHeader = "('Content-Type', 'application/json')"
-
-    postData = document.createElement('input')
-    postData.type = 'hidden'
-    postData.name = "channels"
-    postData.value = json.dumps(chanlist)
-
-    postForm.appendChild(postData)
-    document.body.appendChild(postForm)
-    return postForm
-
-
-@bind("#Chan_Edit_Reset", "submit")
-def chan_edit_reset(evt):
-    chanlist = chan_edit_data(
-                              document.select(".reset"),
-                              str(evt.currentTarget.children[0].id).replace("reset_", ""))
-    postForm = chan_edit_postform(chanlist)
-    postForm.submit()
-    evt.preventDefault()
-
-
-@bind("#Chan_Edit_Modify", "submit")
-def chan_edit_modify(evt):
-    chanlist = chan_edit_data(
-                              document.select(".channels"),
-                              str(evt.currentTarget.children[0].id).replace("update_", ""))
-    postForm = chan_edit_postform(chanlist)
-    postForm.submit()
-    evt.preventDefault()
-
-
-@bind("#Chan_Edit_Enable_Toggle", "click")
-def chan_edit_enable(event):
-    enable_bool = bool(int(document["enable_button"].value))
-    for element in document.get(selector='input[type="checkbox"]'):
-        if element.name == "enabled":
-            element.checked = enable_bool
-            element.value = enable_bool
-
-    if not enable_bool:
-        document["enable_button"].value = "1"
-        document["enable_button"].text = "Enable All"
-    else:
-        document["enable_button"].value = "0"
-        document["enable_button"].text = "Disable All"
-
-
-@bind("#Chan_Edit_Favorite_Toggle", "click")
-def chan_edit_favorite(event):
-    enable_bool = bool(int(document["favorite_button"].value))
-    for element in document.get(selector='input[type="checkbox"]'):
-        if element.name == "favorite":
-            element.checked = enable_bool
-            element.value = int(enable_bool)
-
-    if not enable_bool:
-        document["favorite_button"].value = "1"
-        document["favorite_button"].text = "Favorite All"
-    else:
-        document["favorite_button"].value = "0"
-        document["favorite_button"].text = "Unfavorite All"

fHDHR_web/brython/brython_stdlib.py

@@ -1,22 +0,0 @@
-from flask import send_from_directory
-
-import pathlib
-
-
-class Brython_stdlib():
-    endpoints = ["/brython_stdlib.js"]
-    endpoint_name = "file_brython_stdlib_js"
-
-    def __init__(self, fhdhr):
-        self.fhdhr = fhdhr
-
-        self.brython_path = pathlib.Path(self.fhdhr.config.internal["paths"]["fHDHR_web_dir"]).joinpath('brython')
-
-    def __call__(self, *args):
-        return self.get(*args)
-
-    def get(self, *args):
-
-        return send_from_directory(self.brython_path,
-                                   'brython_stdlib.js',
-                                   mimetype='text/javascript')

fHDHR_web/files/__init__.py

@@ -2,6 +2,7 @@
 
 from .favicon_ico import Favicon_ICO
 from .style_css import Style_CSS
+from .device_xml import Device_XML
 
 
 class fHDHR_Files():
@@ -11,3 +12,4 @@ class fHDHR_Files():
 
         self.favicon = Favicon_ICO(fhdhr)
         self.style = Style_CSS(fhdhr)
+        self.device_xml = Device_XML(fhdhr)

fHDHR_web/files/device_xml.py

@@ -0,0 +1,21 @@
+from flask import request, redirect
+
+
+class Device_XML():
+    endpoints = ["/device.xml"]
+    endpoint_name = "file_device_xml"
+
+    def __init__(self, fhdhr):
+        self.fhdhr = fhdhr
+
+    def __call__(self, *args):
+        return self.get(*args)
+
+    def get(self, *args):
+
+        user_agent = request.headers.get('User-Agent')
+        if (self.fhdhr.config.dict["rmg"]["enabled"] and
+           str(user_agent).lower().startswith("plexmediaserver")):
+            return redirect("/rmg/device.xml")
+        else:
+            return redirect("/hdhr/device.xml")

fHDHR_web/hdhr/__init__.py

@@ -12,11 +12,10 @@ from .auto import Auto
 from .tuner import Tuner
 
 
-class Plugin_OBJ():
+class fHDHR_HDHR():
 
-    def __init__(self, fhdhr, plugin_utils):
+    def __init__(self, fhdhr):
         self.fhdhr = fhdhr
-        self.plugin_utils = plugin_utils
 
         self.lineup_post = Lineup_Post(fhdhr)
 

fHDHR_web/hdhr/auto.py

@@ -9,46 +9,36 @@ class Auto():
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
 
-    @property
-    def source(self):
-        return self.fhdhr.config.dict["hdhr"]["source"] or self.fhdhr.origins.valid_origins[0]
-
     def __call__(self, channel, *args):
         return self.get(channel, *args)
 
     def get(self, channel, *args):
 
-        origin = self.source
+        method = request.args.get('method', default=self.fhdhr.config.dict["fhdhr"]["stream_type"], type=str)
 
-        redirect_url = "/api/tuners?method=stream"
+        redirect_url = "/api/tuners?method=%s" % (method)
 
         if channel.startswith("v"):
             channel_number = channel.replace('v', '')
         elif channel.startswith("ch"):
             channel_freq = channel.replace('ch', '').split("-")[0]
-            subchannel = None
+            subchannel = 0
             if "-" in channel:
                 subchannel = channel.replace('ch', '').split("-")[1]
-            if subchannel:
-                self.fhdhr.logger.error("Not Implemented %s-%s" % (channel_freq, subchannel))
-                abort(501, "Not Implemented %s-%s" % (channel_freq, subchannel))
-            else:
-                self.fhdhr.logger.error("Not Implemented %s" % (channel_freq, subchannel))
-                abort(501, "Not Implemented %s" % channel_freq)
+            self.fhdhr.logger.error("Not Implemented %s-%s" % (str(channel_freq), str(subchannel)))
+            abort(501, "Not Implemented %s-%s" % (str(channel_freq), str(subchannel)))
         else:
             channel_number = channel
 
         redirect_url += "&channel=%s" % str(channel_number)
-        redirect_url += "&origin=%s" % str(origin)
-        redirect_url += "&stream_method=%s" % self.fhdhr.origins.origins_dict[origin].stream_method
 
         duration = request.args.get('duration', default=0, type=int)
         if duration:
             redirect_url += "&duration=%s" % str(duration)
 
-        transcode_quality = request.args.get('transcode', default=None, type=str)
-        if transcode_quality:
-            redirect_url += "&transcode=%s" % str(transcode_quality)
+        transcode = request.args.get('transcode', default=None, type=str)
+        if transcode:
+            redirect_url += "&transcode=%s" % str(transcode)
 
         redirect_url += "&accessed=%s" % urllib.parse.quote(request.url)
 

fHDHR_web/hdhr/device_xml.py

@@ -6,16 +6,12 @@ from fHDHR.tools import sub_el
 
 
 class HDHR_Device_XML():
-    endpoints = ["/hdhr", "/hdhr/", "/hdhr/device.xml"]
+    endpoints = ["/hdhr/device.xml"]
     endpoint_name = "hdhr_device_xml"
 
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
 
-    @property
-    def source(self):
-        return self.fhdhr.config.dict["hdhr"]["source"] or self.fhdhr.origins.valid_origins[0]
-
     def __call__(self, *args):
         return self.get(*args)
 
@@ -24,14 +20,10 @@ class HDHR_Device_XML():
 
         base_url = request.url_root[:-1]
 
-        origin = self.source
-        origin_plugin_name = self.fhdhr.origins.origins_dict[origin].plugin_utils.plugin_name
-        origin_plugin_version = self.fhdhr.origins.origins_dict[origin].plugin_utils.plugin_manifest["version"]
-
         out = xml.etree.ElementTree.Element('root')
         out.set('xmlns', "urn:schemas-upnp-org:device-1-0")
 
-        sub_el(out, 'URLBase', "%s/hdhr" % base_url)
+        sub_el(out, 'URLBase', "%s" % base_url)
 
         specVersion_out = sub_el(out, 'specVersion')
         sub_el(specVersion_out, 'major', "1")
@@ -41,15 +33,15 @@ class HDHR_Device_XML():
 
         sub_el(device_out, 'deviceType', "urn:schemas-upnp-org:device:MediaServer:1")
 
-        sub_el(device_out, 'friendlyName', "%s %s" % (self.fhdhr.config.dict["fhdhr"]["friendlyname"], origin))
-        sub_el(device_out, 'manufacturer', self.fhdhr.config.dict["hdhr"]["reporting_manufacturer"])
-        sub_el(device_out, 'manufacturerURL', "https://github.com/fHDHR/%s" % origin_plugin_name)
-        sub_el(device_out, 'modelName', self.fhdhr.config.dict["hdhr"]["reporting_model"])
-        sub_el(device_out, 'modelNumber', origin_plugin_version)
+        sub_el(device_out, 'friendlyName', self.fhdhr.config.dict["fhdhr"]["friendlyname"])
+        sub_el(device_out, 'manufacturer', self.fhdhr.config.dict["fhdhr"]["reporting_manufacturer"])
+        sub_el(device_out, 'manufacturerURL', "https://github.com/fHDHR/%s" % self.fhdhr.config.dict["main"]["reponame"])
+        sub_el(device_out, 'modelName', self.fhdhr.config.dict["fhdhr"]["reporting_model"])
+        sub_el(device_out, 'modelNumber', self.fhdhr.config.internal["versions"]["fHDHR"])
 
         sub_el(device_out, 'serialNumber')
 
-        sub_el(device_out, 'UDN', "uuid:%s%s" % (self.fhdhr.config.dict["main"]["uuid"], origin))
+        sub_el(device_out, 'UDN', "uuid:" + self.fhdhr.config.dict["main"]["uuid"])
 
         fakefile = BytesIO()
         fakefile.write(b'<?xml version="1.0" encoding="UTF-8"?>\n')

fHDHR_web/hdhr/discover_json.py

@@ -9,10 +9,6 @@ class Discover_JSON():
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
 
-    @property
-    def source(self):
-        return self.fhdhr.config.dict["hdhr"]["source"] or self.fhdhr.origins.valid_origins[0]
-
     def __call__(self, *args):
         return self.get(*args)
 
@@ -20,19 +16,17 @@ class Discover_JSON():
 
         base_url = request.url_root[:-1]
 
-        origin = self.source
-
         jsondiscover = {
-                            "FriendlyName": "%s %s" % (self.fhdhr.config.dict["fhdhr"]["friendlyname"], origin),
-                            "Manufacturer": self.fhdhr.config.dict["hdhr"]["reporting_manufacturer"],
-                            "ModelNumber": self.fhdhr.config.dict["hdhr"]["reporting_model"],
-                            "FirmwareName": self.fhdhr.config.dict["hdhr"]["reporting_firmware_name"],
-                            "TunerCount": self.fhdhr.origins.origins_dict[origin].tuners,
-                            "FirmwareVersion": self.fhdhr.config.dict["hdhr"]["reporting_firmware_ver"],
-                            "DeviceID": "%s%s" % (self.fhdhr.config.dict["main"]["uuid"], origin),
+                            "FriendlyName": self.fhdhr.config.dict["fhdhr"]["friendlyname"],
+                            "Manufacturer": self.fhdhr.config.dict["fhdhr"]["reporting_manufacturer"],
+                            "ModelNumber": self.fhdhr.config.dict["fhdhr"]["reporting_model"],
+                            "FirmwareName": self.fhdhr.config.dict["fhdhr"]["reporting_firmware_name"],
+                            "TunerCount": self.fhdhr.config.dict["fhdhr"]["tuner_count"],
+                            "FirmwareVersion": self.fhdhr.config.dict["fhdhr"]["reporting_firmware_ver"],
+                            "DeviceID": self.fhdhr.config.dict["main"]["uuid"],
                             "DeviceAuth": self.fhdhr.config.dict["fhdhr"]["device_auth"],
-                            "BaseURL": "%s/hdhr" % base_url,
-                            "LineupURL": "%s/hdhr/lineup.json" % base_url
+                            "BaseURL": "%s" % base_url,
+                            "LineupURL": "%s/lineup.json" % base_url
                         }
         discover_json = json.dumps(jsondiscover, indent=4)
 

fHDHR_web/hdhr/lineup_json.py

@@ -0,0 +1,37 @@
+from flask import Response, request
+import json
+
+
+class Lineup_JSON():
+    endpoints = ["/lineup.json", "/hdhr/lineup.json"]
+    endpoint_name = "hdhr_lineup_json"
+
+    def __init__(self, fhdhr):
+        self.fhdhr = fhdhr
+
+    def __call__(self, *args):
+        return self.get(*args)
+
+    def get(self, *args):
+
+        base_url = request.url_root[:-1]
+
+        show = request.args.get('show', default="all", type=str)
+
+        jsonlineup = []
+        for fhdhr_id in list(self.fhdhr.device.channels.list.keys()):
+            channel_obj = self.fhdhr.device.channels.list[fhdhr_id]
+            if channel_obj.enabled or show == "found":
+                lineup_dict = channel_obj.lineup_dict
+                lineup_dict["URL"] = "%s%s" % (base_url, lineup_dict["URL"])
+                if show == "found" and channel_obj.enabled:
+                    lineup_dict["Enabled"] = 1
+                elif show == "found" and not channel_obj.enabled:
+                    lineup_dict["Enabled"] = 0
+                jsonlineup.append(lineup_dict)
+
+        lineup_json = json.dumps(jsonlineup, indent=4)
+
+        return Response(status=200,
+                        response=lineup_json,
+                        mimetype='application/json')

fHDHR_web/hdhr/lineup_post.py

@@ -11,32 +11,26 @@ class Lineup_Post():
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
 
-    @property
-    def source(self):
-        return self.fhdhr.config.dict["hdhr"]["source"] or self.fhdhr.origins.valid_origins[0]
-
     def __call__(self, *args):
         return self.get(*args)
 
     def get(self, *args):
 
-        origin = self.source
-
         if 'scan' in list(request.args.keys()):
 
             if request.args['scan'] == 'start':
                 try:
-                    self.fhdhr.device.tuners.tuner_scan(origin)
+                    self.fhdhr.device.tuners.tuner_scan()
                 except TunerError as e:
                     self.fhdhr.logger.info(str(e))
                 return Response(status=200, mimetype='text/html')
 
             elif request.args['scan'] == 'abort':
-                self.fhdhr.device.tuners.stop_tuner_scan(origin)
+                self.fhdhr.device.tuners.stop_tuner_scan()
                 return Response(status=200, mimetype='text/html')
 
             else:
-                self.fhdhr.logger.warning("Unknown scan command %s" % request.args['scan'])
+                self.fhdhr.logger.warning("Unknown scan command " + request.args['scan'])
                 return abort(200, "Not a valid scan command")
 
         elif 'favorite' in list(request.args.keys()):
@@ -45,21 +39,21 @@ class Lineup_Post():
                 channel_method = request.args['favorite'][0]
                 channel_number = request.args['favorite'][1:]
 
-                if str(channel_number) not in [str(x) for x in self.fhdhr.device.channels.get_channel_list("number", origin)]:
+                if str(channel_number) not in [str(x) for x in self.fhdhr.device.channels.get_channel_list("number")]:
                     response = Response("Not Found", status=404)
                     response.headers["X-fHDHR-Error"] = "801 - Unknown Channel"
                     self.fhdhr.logger.error(response.headers["X-fHDHR-Error"])
                     abort(response)
 
                 if channel_method == "+":
-                    self.fhdhr.device.channels.set_channel_enablement("number", channel_number, channel_method, origin)
+                    self.fhdhr.device.channels.set_channel_enablement("number", channel_number, channel_method)
                 elif channel_method == "-":
-                    self.fhdhr.device.channels.set_channel_enablement("number", channel_number, channel_method, origin)
+                    self.fhdhr.device.channels.set_channel_enablement("number", channel_number, channel_method)
                 elif channel_method == "x":
-                    self.fhdhr.device.channels.set_channel_enablement("number", channel_number, "toggle", origin)
+                    self.fhdhr.device.channels.set_channel_enablement("number", channel_number, "toggle")
 
             else:
-                self.fhdhr.logger.warning("Unknown favorite command %s" % request.args['favorite'])
+                self.fhdhr.logger.warning("Unknown favorite command " + request.args['favorite'])
                 return abort(200, "Not a valid favorite command")
 
         else:

fHDHR_web/hdhr/lineup_status_json.py

@@ -9,29 +9,21 @@ class Lineup_Status_JSON():
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
 
-    @property
-    def source(self):
-        return self.fhdhr.config.dict["hdhr"]["source"] or self.fhdhr.origins.valid_origins[0]
-
     def __call__(self, *args):
         return self.get(*args)
 
     def get(self, *args):
 
-        origin = self.source
-
-        tuner_status = self.fhdhr.device.tuners.status(origin)
+        tuner_status = self.fhdhr.device.tuners.status()
         tuners_scanning = 0
         for tuner_number in list(tuner_status.keys()):
             if tuner_status[tuner_number]["status"] == "Scanning":
                 tuners_scanning += 1
 
-        channel_count = len(list(self.fhdhr.device.channels.list[origin].keys()))
-
         if tuners_scanning:
-            jsonlineup = self.scan_in_progress(origin)
-        elif not channel_count:
-            jsonlineup = self.scan_in_progress(origin)
+            jsonlineup = self.scan_in_progress()
+        elif not len(self.fhdhr.device.channels.list):
+            jsonlineup = self.scan_in_progress()
         else:
             jsonlineup = self.not_scanning()
         lineup_json = json.dumps(jsonlineup, indent=4)
@@ -40,14 +32,11 @@ class Lineup_Status_JSON():
                         response=lineup_json,
                         mimetype='application/json')
 
-    def scan_in_progress(self, origin):
-
-        channel_count = len(list(self.fhdhr.device.channels.list[origin].keys()))
-
+    def scan_in_progress(self):
         jsonlineup = {
                       "ScanInProgress": "true",
                       "Progress": 99,
-                      "Found": channel_count
+                      "Found": len(self.fhdhr.device.channels.list)
                       }
         return jsonlineup
 
@@ -55,7 +44,7 @@ class Lineup_Status_JSON():
         jsonlineup = {
                       "ScanInProgress": "false",
                       "ScanPossible": "true",
-                      "Source": self.fhdhr.config.dict["hdhr"]["reporting_tuner_type"],
-                      "SourceList": [self.fhdhr.config.dict["hdhr"]["reporting_tuner_type"]],
+                      "Source": self.fhdhr.config.dict["fhdhr"]["reporting_tuner_type"],
+                      "SourceList": [self.fhdhr.config.dict["fhdhr"]["reporting_tuner_type"]],
                       }
         return jsonlineup

fHDHR_web/hdhr/lineup_xml.py

@@ -0,0 +1,45 @@
+from flask import Response, request
+from io import BytesIO
+import xml.etree.ElementTree
+
+from fHDHR.tools import sub_el
+
+
+class Lineup_XML():
+    endpoints = ["/lineup.xml", "/hdhr/lineup.xml"]
+    endpoint_name = "hdhr_lineup_xml"
+
+    def __init__(self, fhdhr):
+        self.fhdhr = fhdhr
+
+    def __call__(self, *args):
+        return self.get(*args)
+
+    def get(self, *args):
+
+        base_url = request.url_root[:-1]
+
+        show = request.args.get('show', default="all", type=str)
+
+        out = xml.etree.ElementTree.Element('Lineup')
+        for fhdhr_id in list(self.fhdhr.device.channels.list.keys()):
+            channel_obj = self.fhdhr.device.channels.list[fhdhr_id]
+            if channel_obj.enabled or show == "found":
+                program_out = sub_el(out, 'Program')
+                lineup_dict = channel_obj.lineup_dict
+                lineup_dict["URL"] = base_url + lineup_dict["URL"]
+                if show == "found" and channel_obj.enabled:
+                    lineup_dict["Enabled"] = 1
+                elif show == "found" and not channel_obj.enabled:
+                    lineup_dict["Enabled"] = 0
+                for key in list(lineup_dict.keys()):
+                    sub_el(program_out, str(key), str(lineup_dict[key]))
+
+        fakefile = BytesIO()
+        fakefile.write(b'<?xml version="1.0" encoding="UTF-8"?>\n')
+        fakefile.write(xml.etree.ElementTree.tostring(out, encoding='UTF-8'))
+        lineup_xml = fakefile.getvalue()
+
+        return Response(status=200,
+                        response=lineup_xml,
+                        mimetype='application/xml')

fHDHR_web/hdhr/tuner.py

@@ -9,48 +9,38 @@ class Tuner():
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
 
-    @property
-    def source(self):
-        return self.fhdhr.config.dict["hdhr"]["source"] or self.fhdhr.origins.valid_origins[0]
-
     def __call__(self, tuner_number, channel, *args):
         return self.get(tuner_number, channel, *args)
 
     def get(self, tuner_number, channel, *args):
 
-        origin = self.source
+        method = request.args.get('method', default=self.fhdhr.config.dict["fhdhr"]["stream_type"], type=str)
 
-        redirect_url = "/api/tuners?method=stream"
+        redirect_url = "/api/tuners?method=%s" % (method)
 
-        redirect_url += "&tuner=%s" % (tuner_number)
+        redirect_url += "&tuner=%s" % str(tuner_number)
 
         if channel.startswith("v"):
             channel_number = channel.replace('v', '')
         elif channel.startswith("ch"):
             channel_freq = channel.replace('ch', '').split("-")[0]
-            subchannel = None
+            subchannel = 0
             if "-" in channel:
                 subchannel = channel.replace('ch', '').split("-")[1]
-            if subchannel:
-                self.fhdhr.logger.error("Not Implemented %s-%s" % (channel_freq, subchannel))
-                abort(501, "Not Implemented %s-%s" % (channel_freq, subchannel))
-            else:
-                self.fhdhr.logger.error("Not Implemented %s" % (channel_freq, subchannel))
-                abort(501, "Not Implemented %s" % channel_freq)
+            self.fhdhr.logger.error("Not Implemented %s-%s" % (str(channel_freq), str(subchannel)))
+            abort(501, "Not Implemented %s-%s" % (str(channel_freq), str(subchannel)))
         else:
             channel_number = channel
 
         redirect_url += "&channel=%s" % str(channel_number)
-        redirect_url += "&origin=%s" % str(origin)
-        redirect_url += "&stream_method=%s" % self.fhdhr.origins.origins_dict[origin].stream_method
 
         duration = request.args.get('duration', default=0, type=int)
         if duration:
             redirect_url += "&duration=%s" % str(duration)
 
-        transcode_quality = request.args.get('transcode', default=None, type=str)
-        if transcode_quality:
-            redirect_url += "&transcode=%s" % str(transcode_quality)
+        transcode = request.args.get('transcode', default=None, type=str)
+        if transcode:
+            redirect_url += "&transcode=%s" % str(transcode)
 
         redirect_url += "&accessed=%s" % urllib.parse.quote(request.url)
 

fHDHR_web/pages/__init__.py

@@ -1,14 +1,16 @@
 
 
 from .index_html import Index_HTML
+from .origin_html import Origin_HTML
 from .channels_html import Channels_HTML
 from .guide_html import Guide_HTML
+from .cluster_html import Cluster_HTML
 from .tuners_html import Tuners_HTML
 from .xmltv_html import xmlTV_HTML
 from .version_html import Version_HTML
 from .diagnostics_html import Diagnostics_HTML
 from .settings_html import Settings_HTML
-from .channels_editor_html import Channels_Editor_HTML
+from .channels_editor import Channels_Editor_HTML
 
 
 class fHDHR_Pages():
@@ -17,9 +19,11 @@ class fHDHR_Pages():
         self.fhdhr = fhdhr
 
         self.index_html = Index_HTML(fhdhr)
+        self.origin_html = Origin_HTML(fhdhr)
         self.channels_html = Channels_HTML(fhdhr)
-        self.channels_editor_html = Channels_Editor_HTML(fhdhr)
+        self.channels_editor = Channels_Editor_HTML(fhdhr)
         self.guide_html = Guide_HTML(fhdhr)
+        self.cluster_html = Cluster_HTML(fhdhr)
         self.tuners_html = Tuners_HTML(fhdhr)
         self.xmltv_html = xmlTV_HTML(fhdhr)
         self.version_html = Version_HTML(fhdhr)

fHDHR_web/pages/channels_editor.py

@@ -0,0 +1,23 @@
+from flask import request, render_template
+
+
+class Channels_Editor_HTML():
+    endpoints = ["/channels_editor", "/channels_editor.html"]
+    endpoint_name = "page_channels_editor_html"
+
+    def __init__(self, fhdhr):
+        self.fhdhr = fhdhr
+
+    def __call__(self, *args):
+        return self.get(*args)
+
+    def get(self, *args):
+
+        channelslist = []
+        for fhdhr_id in list(self.fhdhr.device.channels.list.keys()):
+            channel_obj = self.fhdhr.device.channels.list[fhdhr_id]
+            channel_dict = channel_obj.dict.copy()
+            channel_dict["play_url"] = channel_obj.play_url
+            channelslist.append(channel_dict)
+
+        return render_template('channels_editor.html', request=request, fhdhr=self.fhdhr, channelslist=channelslist)

fHDHR_web/pages/channels_editor_html.py

@@ -1,43 +0,0 @@
-from flask import request, render_template, session
-
-from fHDHR.tools import channel_sort
-
-
-class Channels_Editor_HTML():
-    endpoints = ["/channels_editor", "/channels_editor.html"]
-    endpoint_name = "page_channels_editor_html"
-    endpoint_access_level = 2
-    endpoint_category = "tool_pages"
-    pretty_name = "Channels Editor"
-
-    def __init__(self, fhdhr):
-        self.fhdhr = fhdhr
-
-    def __call__(self, *args):
-        return self.get(*args)
-
-    def get(self, *args):
-
-        origin = request.args.get('origin', default=self.fhdhr.device.epg.def_method, type=str)
-        origin_methods = self.fhdhr.origins.valid_origins
-        if origin not in origin_methods:
-            origin = origin_methods[0]
-
-        channelslist = {}
-        for fhdhr_id in [x["id"] for x in self.fhdhr.device.channels.get_channels(origin)]:
-            channel_obj = self.fhdhr.device.channels.get_channel_obj("id", fhdhr_id, origin)
-            channel_dict = channel_obj.dict.copy()
-
-            channel_dict["number"] = channel_obj.number
-            channel_dict["chan_thumbnail"] = channel_obj.thumbnail
-            channel_dict["m3u_url"] = channel_obj.api_m3u_url
-
-            channelslist[channel_dict["number"]] = channel_dict
-
-        # Sort the channels
-        sorted_channel_list = channel_sort(list(channelslist.keys()))
-        sorted_chan_guide = []
-        for channel in sorted_channel_list:
-            sorted_chan_guide.append(channelslist[channel])
-
-        return render_template('channels_editor.html', request=request, session=session, fhdhr=self.fhdhr, channelslist=sorted_chan_guide, origin=origin, origin_methods=origin_methods, list=list)

fHDHR_web/pages/channels_html.py

@@ -1,13 +1,9 @@
-from flask import request, render_template, session
-
-from fHDHR.tools import channel_sort
+from flask import request, render_template
 
 
 class Channels_HTML():
     endpoints = ["/channels", "/channels.html"]
     endpoint_name = "page_channels_html"
-    endpoint_access_level = 0
-    pretty_name = "Channels"
 
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
@@ -17,33 +13,18 @@ class Channels_HTML():
 
     def get(self, *args):
 
-        origin = request.args.get('origin', default=self.fhdhr.device.epg.def_method, type=str)
-        origin_methods = self.fhdhr.origins.valid_origins
-        if origin not in origin_methods:
-            origin = origin_methods[0]
-
         channels_dict = {
-                        "Total Channels": len(self.fhdhr.device.channels.get_channels(origin)),
-                        "Enabled": 0
+                        "Total Channels": len(list(self.fhdhr.device.channels.list.keys())),
+                        "Enabled": 0,
                         }
 
-        channelslist = {}
-        for fhdhr_id in [x["id"] for x in self.fhdhr.device.channels.get_channels(origin)]:
-            channel_obj = self.fhdhr.device.channels.get_channel_obj("id", fhdhr_id, origin)
+        channelslist = []
+        for fhdhr_id in list(self.fhdhr.device.channels.list.keys()):
+            channel_obj = self.fhdhr.device.channels.list[fhdhr_id]
             channel_dict = channel_obj.dict.copy()
-
-            channel_dict["number"] = channel_obj.number
-            channel_dict["chan_thumbnail"] = channel_obj.thumbnail
-            channel_dict["m3u_url"] = channel_obj.api_m3u_url
-
-            channelslist[channel_dict["number"]] = channel_dict
+            channel_dict["play_url"] = channel_obj.play_url
+            channelslist.append(channel_dict)
             if channel_dict["enabled"]:
                 channels_dict["Enabled"] += 1
 
-        # Sort the channels
-        sorted_channel_list = channel_sort(list(channelslist.keys()))
-        sorted_chan_guide = []
-        for channel in sorted_channel_list:
-            sorted_chan_guide.append(channelslist[channel])
-
-        return render_template('channels.html', request=request, session=session, fhdhr=self.fhdhr, channelslist=sorted_chan_guide, channels_dict=channels_dict, origin=origin, origin_methods=origin_methods, list=list)
+        return render_template('channels.html', request=request, fhdhr=self.fhdhr, channelslist=channelslist, channels_dict=channels_dict, list=list)

fHDHR_web/pages/cluster_html.py

@@ -0,0 +1,50 @@
+from flask import request, render_template
+import urllib.parse
+
+
+class Cluster_HTML():
+    endpoints = ["/cluster", "/cluster.html"]
+    endpoint_name = "page_cluster_html"
+
+    def __init__(self, fhdhr):
+        self.fhdhr = fhdhr
+        self.location_dict = {
+                              "name": self.fhdhr.config.dict["fhdhr"]["friendlyname"],
+                              "location": self.fhdhr.api.base,
+                              "joined": "N/A",
+                              "url_query": self.fhdhr.api.base_quoted
+                              }
+
+    def __call__(self, *args):
+        return self.get(*args)
+
+    def get(self, *args):
+
+        locations_list = []
+
+        if self.fhdhr.config.dict["fhdhr"]["discovery_address"]:
+
+            locations_list.append(self.location_dict)
+
+            fhdhr_list = self.fhdhr.device.cluster.get_list()
+            for location in list(fhdhr_list.keys()):
+
+                if location in list(self.fhdhr.device.cluster.cluster().keys()):
+                    location_name = self.fhdhr.device.cluster.cluster()[location]["name"]
+                else:
+                    try:
+                        location_info_url = location + "/discover.json"
+                        location_info_req = self.fhdhr.web.session.get(location_info_url)
+                        location_info = location_info_req.json()
+                        location_name = location_info["FriendlyName"]
+                    except self.fhdhr.web.exceptions.ConnectionError:
+                        self.fhdhr.logger.error("Unreachable: " + location)
+                location_dict = {
+                                "name": location_name,
+                                "location": location,
+                                "joined": str(fhdhr_list[location]["Joined"]),
+                                "url_query": urllib.parse.quote(location)
+                                }
+                locations_list.append(location_dict)
+
+        return render_template('cluster.html', request=request, fhdhr=self.fhdhr, locations_list=locations_list)

fHDHR_web/pages/diagnostics_html.py

@@ -1,12 +1,9 @@
-from flask import request, render_template, session
+from flask import request, render_template
 
 
 class Diagnostics_HTML():
     endpoints = ["/diagnostics", "/diagnostics.html"]
     endpoint_name = "page_diagnostics_html"
-    endpoint_access_level = 2
-    endpoint_category = "tool_pages"
-    pretty_name = "Diagnostics"
 
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
@@ -18,33 +15,111 @@ class Diagnostics_HTML():
 
         base_url = request.url_root[:-1]
 
-        button_dict = {}
+        button_list = []
 
-        for route_group in list(session["route_list"].keys()):
-            if route_group not in ["pages", "brython", "files", "tool_pages"]:
-                button_dict[route_group] = []
-                for route_item in list(session["route_list"][route_group].keys()):
-                    if not session["route_list"][route_group][route_item]["name"].startswith("page_"):
-                        button_link = session["route_list"][route_group][route_item]["endpoints"][0]
-                        parameter_index = 0
-                        for parameter in list(session["route_list"][route_group][route_item]["endpoint_default_parameters"].keys()):
-                            parameter_val = session["route_list"][route_group][route_item]["endpoint_default_parameters"][parameter]
-                            if not parameter_index:
-                                button_link += "?"
-                            else:
-                                button_link += "&"
-                            button_link += "%s=%s" % (parameter, parameter_val)
-                        button_link = button_link.replace("<devicekey>", self.fhdhr.config.dict["main"]["uuid"])
-                        button_link = button_link.replace("<base_url>", base_url)
-                        curr_button_dict = {
-                                            "label": session["route_list"][route_group][route_item]["pretty_name"],
-                                            "link": button_link,
-                                            "methods": ",".join(session["route_list"][route_group][route_item]["endpoint_methods"]),
-                                            "button": True
-                                            }
-                        if ("GET" not in session["route_list"][route_group][route_item]["endpoint_methods"]
-                           or "<tuner_number>" in button_link or "<channel>" in button_link):
-                            curr_button_dict["button"] = False
-                        button_dict[route_group].append(curr_button_dict)
+        button_list.append({
+                            "label": "Debug Json",
+                            "hdhr": None,
+                            "rmg": None,
+                            "other": "/api/debug",
+                            })
 
-        return render_template('diagnostics.html', request=request, session=session, fhdhr=self.fhdhr, button_dict=button_dict, list=list)
+        button_list.append({
+                            "label": "Cluster Json",
+                            "hdhr": None,
+                            "rmg": None,
+                            "other": "/api/cluster?method=get",
+                            })
+
+        button_list.append({
+                            "label": "Lineup XML",
+                            "hdhr": "/lineup.xml",
+                            "rmg": None,
+                            "other": None,
+                            })
+
+        button_list.append({
+                            "label": "Lineup JSON",
+                            "hdhr": "/hdhr/lineup.json",
+                            "rmg": None,
+                            "other": None,
+                            })
+
+        button_list.append({
+                            "label": "Lineup Status",
+                            "hdhr": "/hdhr/lineup_status.json",
+                            "rmg": None,
+                            "other": None,
+                            })
+
+        button_list.append({
+                            "label": "Discover Json",
+                            "hdhr": "/hdhr/discover.json",
+                            "rmg": None,
+                            "other": None,
+                            })
+
+        button_list.append({
+                            "label": "Device XML",
+                            "hdhr": "/hdhr/device.xml",
+                            "rmg": "/rmg/device.xml",
+                            "other": None,
+                            })
+
+        button_list.append({
+                            "label": "RMG Identification XML",
+                            "hdhr": "",
+                            "rmg": "/rmg",
+                            "other": None,
+                            })
+
+        button_list.append({
+                            "label": "RMG Devices Discover",
+                            "hdhr": "",
+                            "rmg": "/rmg/devices/discover",
+                            "other": None,
+                            })
+
+        button_list.append({
+                            "label": "RMG Devices Probe",
+                            "hdhr": "",
+                            "rmg": "/rmg/devices/probe?uri=%s" % base_url,
+                            "other": None,
+                            })
+
+        button_list.append({
+                            "label": "RMG Devices by DeviceKey",
+                            "hdhr": "",
+                            "rmg": "/rmg/devices/%s" % self.fhdhr.config.dict["main"]["uuid"],
+                            "other": None,
+                            })
+
+        button_list.append({
+                            "label": "RMG Channels by DeviceKey",
+                            "hdhr": "",
+                            "rmg": "/rmg/devices/%s/channels" % self.fhdhr.config.dict["main"]["uuid"],
+                            "other": None,
+                            })
+
+        button_list.append({
+                            "label": "RMG Scanners by DeviceKey",
+                            "hdhr": "",
+                            "rmg": "/rmg/devices/%s/scanners" % self.fhdhr.config.dict["main"]["uuid"],
+                            "other": None,
+                            })
+
+        button_list.append({
+                            "label": "RMG Networks by DeviceKey",
+                            "hdhr": "",
+                            "rmg": "/rmg/devices/%s/networks" % self.fhdhr.config.dict["main"]["uuid"],
+                            "other": None,
+                            })
+
+        button_list.append({
+                            "label": "RMG Scan by DeviceKey",
+                            "hdhr": "",
+                            "rmg": "/rmg/devices/%s/scan" % self.fhdhr.config.dict["main"]["uuid"],
+                            "other": None,
+                            })
+
+        return render_template('diagnostics.html', request=request, fhdhr=self.fhdhr, button_list=button_list)

fHDHR_web/pages/guide_html.py

@@ -1,14 +1,12 @@
-from flask import request, render_template, session
+from flask import request, render_template
 import datetime
 
-from fHDHR.tools import humanized_time, channel_sort
+from fHDHR.tools import humanized_time
 
 
 class Guide_HTML():
     endpoints = ["/guide", "/guide.html"]
     endpoint_name = "page_guide_html"
-    endpoint_access_level = 0
-    pretty_name = "Guide"
 
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
@@ -18,7 +16,7 @@ class Guide_HTML():
 
     def get(self, *args):
 
-        nowtime = datetime.datetime.utcnow().timestamp()
+        nowtime = datetime.datetime.utcnow()
 
         chan_guide_list = []
 
@@ -27,58 +25,19 @@ class Guide_HTML():
         if source not in epg_methods:
             source = self.fhdhr.device.epg.def_method
 
-        if not source:
-            return render_template('guide.html', request=request, session=session, fhdhr=self.fhdhr, chan_guide_list=chan_guide_list, epg_methods=epg_methods, source=source, list=list)
-
-        whatson = self.fhdhr.device.epg.whats_on_allchans(source)
-
-        # Sort the channels
-        sorted_channel_list = channel_sort(list(whatson.keys()))
-        sorted_chan_guide = {}
-        for channel in sorted_channel_list:
-            sorted_chan_guide[channel] = whatson[channel]
-
-        for channel in list(sorted_chan_guide.keys()):
-            if sorted_chan_guide[channel]["listing"][0]["time_end"]:
-                remaining_time = humanized_time(sorted_chan_guide[channel]["listing"][0]["time_end"] - nowtime)
-            else:
-                remaining_time = "N/A"
+        for channel in self.fhdhr.device.epg.whats_on_allchans(source):
+            end_time = datetime.datetime.strptime(channel["listing"][0]["time_end"], '%Y%m%d%H%M%S +0000')
+            remaining_time = humanized_time(int((end_time - nowtime).total_seconds()))
 
             chan_dict = {
-                         "name": sorted_chan_guide[channel]["name"],
-                         "number": sorted_chan_guide[channel]["number"],
-                         "chan_thumbnail": sorted_chan_guide[channel]["thumbnail"],
-                         "listing_title": sorted_chan_guide[channel]["listing"][0]["title"],
-                         "listing_thumbnail": sorted_chan_guide[channel]["listing"][0]["thumbnail"],
-                         "listing_description": sorted_chan_guide[channel]["listing"][0]["description"],
-                         "listing_remaining_time": str(remaining_time)
+                         "name": channel["name"],
+                         "number": channel["number"],
+                         "chan_thumbnail": channel["thumbnail"],
+                         "listing_title": channel["listing"][0]["title"],
+                         "listing_thumbnail": channel["listing"][0]["thumbnail"],
+                         "listing_description": channel["listing"][0]["description"],
+                         "remaining_time": str(remaining_time)
                          }
-
-            for time_item in ["time_start", "time_end"]:
-
-                if not sorted_chan_guide[channel]["listing"][0][time_item]:
-                    chan_dict["listing_%s" % time_item] = "N/A"
-                elif str(sorted_chan_guide[channel]["listing"][0][time_item]).endswith(tuple(["+0000", "+00:00"])):
-                    chan_dict["listing_%s" % time_item] = str(sorted_chan_guide[channel]["listing"][0][time_item])
-                else:
-                    chan_dict["listing_%s" % time_item] = str(datetime.datetime.fromtimestamp(sorted_chan_guide[channel]["listing"][0][time_item]))
-
-            if source in self.fhdhr.origins.valid_origins:
-                chan_obj = self.fhdhr.device.channels.get_channel_obj("origin_id", sorted_chan_guide[channel]["id"], source)
-
-                chan_dict["name"] = chan_obj.dict["name"]
-                chan_dict["number"] = chan_obj.number
-                chan_dict["chan_thumbnail"] = chan_obj.thumbnail
-                chan_dict["enabled"] = chan_obj.dict["enabled"]
-                chan_dict["m3u_url"] = chan_obj.api_m3u_url
-
-                chan_dict["listing_thumbnail"] = chan_dict["listing_thumbnail"] or chan_obj.thumbnail
-            else:
-                if not chan_dict["listing_thumbnail"]:
-                    chan_dict["listing_thumbnail"] = chan_dict["chan_thumbnail"]
-                if not chan_dict["listing_thumbnail"]:
-                    chan_dict["listing_thumbnail"] = "/api/images?method=generate&type=channel&message=%s" % chan_dict["number"]
-
             chan_guide_list.append(chan_dict)
 
-        return render_template('guide.html', request=request, session=session, fhdhr=self.fhdhr, chan_guide_list=chan_guide_list, epg_methods=epg_methods, source=source, list=list)
+        return render_template('guide.html', request=request, fhdhr=self.fhdhr, chan_guide_list=chan_guide_list, epg_methods=epg_methods)

fHDHR_web/pages/index_html.py

@@ -1,11 +1,9 @@
-from flask import request, render_template, session
+from flask import request, render_template
 
 
 class Index_HTML():
     endpoints = ["/index", "/index.html"]
     endpoint_name = "page_index_html"
-    endpoint_access_level = 0
-    pretty_name = "Index"
 
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
@@ -15,13 +13,15 @@ class Index_HTML():
 
     def get(self, *args):
 
-        origin = self.fhdhr.origins.valid_origins[0]
+        tuners_in_use = self.fhdhr.device.tuners.inuse_tuner_count()
+        max_tuners = self.fhdhr.device.tuners.max_tuners
 
         fhdhr_status_dict = {
                             "Script Directory": str(self.fhdhr.config.internal["paths"]["script_dir"]),
                             "Config File": str(self.fhdhr.config.config_file),
                             "Cache Path": str(self.fhdhr.config.internal["paths"]["cache_dir"]),
-                            "Total Channels": len(list(self.fhdhr.device.channels.list[origin].keys())),
+                            "Total Channels": len(self.fhdhr.device.channels.list),
+                            "Tuner Usage": ("%s/%s" % (str(tuners_in_use), str(max_tuners))),
                             }
 
-        return render_template('index.html', request=request, session=session, fhdhr=self.fhdhr, fhdhr_status_dict=fhdhr_status_dict, list=list)
+        return render_template('index.html', request=request, fhdhr=self.fhdhr, fhdhr_status_dict=fhdhr_status_dict, list=list)

fHDHR_web/pages/origin_html.py

@@ -0,0 +1,18 @@
+from flask import request, render_template
+
+
+class Origin_HTML():
+    endpoints = ["/origin", "/origin.html"]
+    endpoint_name = "page_origin_html"
+
+    def __init__(self, fhdhr):
+        self.fhdhr = fhdhr
+
+    def __call__(self, *args):
+        return self.get(*args)
+
+    def get(self, *args):
+
+        origin_status_dict = self.fhdhr.originwrapper.get_status_dict()
+        origin_status_dict["Total Channels"] = len(self.fhdhr.device.channels.list)
+        return render_template('origin.html', request=request, fhdhr=self.fhdhr, origin_status_dict=origin_status_dict, list=list)

fHDHR_web/pages/settings_html.py

@@ -1,12 +1,9 @@
-from flask import request, render_template, session
+from flask import request, render_template
 
 
 class Settings_HTML():
     endpoints = ["/settings", "/settings.html"]
     endpoint_name = "page_settings_html"
-    endpoint_access_level = 1
-    endpoint_category = "tool_pages"
-    pretty_name = "Settings"
 
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
@@ -22,12 +19,15 @@ class Settings_HTML():
 
             for config_item in list(self.fhdhr.config.conf_default[config_section].keys()):
                 if self.fhdhr.config.conf_default[config_section][config_item]["config_web"]:
+                    real_config_section = config_section
+                    if config_section == self.fhdhr.config.dict["main"]["dictpopname"]:
+                        real_config_section = "origin"
                     web_settings_dict[config_section][config_item] = {
-                        "value": self.fhdhr.config.dict[config_section][config_item],
+                        "value": self.fhdhr.config.dict[real_config_section][config_item],
                         "value_default": self.fhdhr.config.conf_default[config_section][config_item]["value"],
                         "hide": self.fhdhr.config.conf_default[config_section][config_item]["config_web_hidden"]
                         }
             if not len(web_settings_dict[config_section].keys()):
                 del web_settings_dict[config_section]
 
-        return render_template('settings.html', request=request, session=session, fhdhr=self.fhdhr, web_settings_dict=web_settings_dict, list=list)
+        return render_template('settings.html', request=request, fhdhr=self.fhdhr, web_settings_dict=web_settings_dict, list=list)

fHDHR_web/pages/tuners_html.py

@@ -1,4 +1,4 @@
-from flask import request, render_template, session
+from flask import request, render_template
 
 from fHDHR.tools import humanized_filesize
 
@@ -6,9 +6,6 @@ from fHDHR.tools import humanized_filesize
 class Tuners_HTML():
     endpoints = ["/tuners", "/tuners.html"]
     endpoint_name = "page_streams_html"
-    endpoint_access_level = 0
-    endpoint_category = "tool_pages"
-    pretty_name = "Tuners"
 
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
@@ -18,36 +15,22 @@ class Tuners_HTML():
 
     def get(self, *args):
 
-        tuner_status_dict = {}
-
+        tuner_list = []
         tuner_status = self.fhdhr.device.tuners.status()
-        for origin in list(tuner_status.keys()):
-            tuner_status_dict[origin] = {}
-            tuner_status_dict[origin]["scan_count"] = 0
-            tuner_status_dict[origin]["status_list"] = []
-            for tuner in list(tuner_status[origin].keys()):
-                if tuner_status[origin][tuner]["status"] == "Scanning":
-                    tuner_status_dict[origin]["scan_count"] += 1
+        tuner_scanning = 0
+        for tuner in list(tuner_status.keys()):
+            tuner_dict = {
+                          "number": str(tuner),
+                          "status": str(tuner_status[tuner]["status"]),
+                          }
+            if tuner_status[tuner]["status"] == "Active":
+                tuner_dict["channel_number"] = tuner_status[tuner]["channel"]
+                tuner_dict["method"] = tuner_status[tuner]["method"]
+                tuner_dict["play_duration"] = str(tuner_status[tuner]["Play Time"])
+                tuner_dict["downloaded"] = humanized_filesize(tuner_status[tuner]["downloaded"])
+            elif tuner_status[tuner]["status"] == "Scanning":
+                tuner_scanning += 1
 
-                tuner_dict = {
-                              "number": str(tuner),
-                              "status": str(tuner_status[origin][tuner]["status"]),
-                              "origin": "N/A",
-                              "channel_number": "N/A",
-                              "method": "N/A",
-                              "running_time": "N/A",
-                              "downloaded": "N/A",
-                              }
+            tuner_list.append(tuner_dict)
 
-                if tuner_status[origin][tuner]["status"] in ["Active", "Acquired", "Scanning"]:
-                    tuner_dict["origin"] = tuner_status[origin][tuner]["origin"]
-                    tuner_dict["channel_number"] = tuner_status[origin][tuner]["channel"] or "N/A"
-                    tuner_dict["running_time"] = str(tuner_status[origin][tuner]["running_time"])
-
-                if tuner_status[origin][tuner]["status"] in "Active":
-                    tuner_dict["method"] = tuner_status[origin][tuner]["method"]
-                    tuner_dict["downloaded"] = humanized_filesize(tuner_status[origin][tuner]["downloaded"])
-
-                tuner_status_dict[origin]["status_list"].append(tuner_dict)
-
-        return render_template('tuners.html', request=request, session=session, fhdhr=self.fhdhr, tuner_status_dict=tuner_status_dict, list=list)
+        return render_template('tuners.html', request=request, fhdhr=self.fhdhr, tuner_list=tuner_list, tuner_scanning=tuner_scanning)

fHDHR_web/pages/version_html.py

@@ -1,12 +1,9 @@
-from flask import request, render_template, session
+from flask import request, render_template
 
 
 class Version_HTML():
     endpoints = ["/version", "/version.html"]
     endpoint_name = "page_version_html"
-    endpoint_access_level = 1
-    endpoint_category = "tool_pages"
-    pretty_name = "Version"
 
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
@@ -15,19 +12,7 @@ class Version_HTML():
         return self.get(*args)
 
     def get(self, *args):
-
         version_dict = {}
         for key in list(self.fhdhr.config.internal["versions"].keys()):
             version_dict[key] = self.fhdhr.config.internal["versions"][key]
-
-        # Sort the Version Info
-        sorted_version_list = sorted(version_dict, key=lambda i: (version_dict[i]['type'], version_dict[i]['name']))
-        sorted_version_dict = {
-                                "fHDHR": version_dict["fHDHR"],
-                                "fHDHR_web": version_dict["fHDHR_web"]
-                                }
-        for version_item in sorted_version_list:
-            if version_item not in ["fHDHR", "fHDHR_web"]:
-                sorted_version_dict[version_item] = version_dict[version_item]
-
-        return render_template('version.html', request=request, session=session, fhdhr=self.fhdhr, version_dict=sorted_version_dict, list=list)
+        return render_template('version.html', request=request, fhdhr=self.fhdhr, version_dict=version_dict, list=list)

fHDHR_web/pages/xmltv_html.py

@@ -1,12 +1,9 @@
-from flask import request, render_template, session
+from flask import request, render_template
 
 
 class xmlTV_HTML():
     endpoints = ["/xmltv", "/xmltv.html"]
     endpoint_name = "page_xmltv_html"
-    endpoint_access_level = 1
-    endpoint_category = "tool_pages"
-    pretty_name = "xmltv"
 
     def __init__(self, fhdhr):
         self.fhdhr = fhdhr
@@ -16,4 +13,4 @@ class xmlTV_HTML():
 
     def get(self, *args):
 
-        return render_template('xmltv.html', request=request, session=session, fhdhr=self.fhdhr, list=list)
+        return render_template('xmltv.html', request=request, fhdhr=self.fhdhr)

fHDHR_web/rmg/__init__.py

@@ -1,5 +1,4 @@
 
-
 from .rmg_ident_xml import RMG_Ident_XML
 from .device_xml import RMG_Device_XML
 from .devices_discover import RMG_Devices_Discover
@@ -13,11 +12,10 @@ from .devices_devicekey_prefs import RMG_Devices_DeviceKey_Prefs
 from .devices_devicekey_media import RMG_Devices_DeviceKey_Media
 
 
-class Plugin_OBJ():
+class fHDHR_RMG():
 
-    def __init__(self, fhdhr, plugin_utils):
+    def __init__(self, fhdhr):
         self.fhdhr = fhdhr
-        self.plugin_utils = plugin_utils
 
         self.rmg_ident_xml = RMG_Ident_XML(fhdhr)
         self.device_xml = RMG_Device_XML(fhdhr)

fHDHR_web/rmg/device_xml.py

@@ -0,0 +1,58 @@
+from flask import Response, request
+from io import BytesIO
+import xml.etree.ElementTree
+
+from fHDHR.tools import sub_el
+
+
+class RMG_Device_XML():
+    endpoints = ["/rmg/device.xml"]
+    endpoint_name = "rmg_device_xml"
+
+    def __init__(self, fhdhr):
+        self.fhdhr = fhdhr
+
+    def __call__(self, *args):
+        return self.get(*args)
+
+    def get(self, *args):
+        """Device.xml referenced from SSDP"""
+
+        base_url = request.url_root[:-1]
+
+        out = xml.etree.ElementTree.Element('root')
+        out.set('xmlns', "urn:schemas-upnp-org:device-1-0")
+
+        specVersion_out = sub_el(out, 'specVersion')
+        sub_el(specVersion_out, 'major', "1")
+        sub_el(specVersion_out, 'minor', "0")
+
+        device_out = sub_el(out, 'device')
+
+        sub_el(device_out, 'deviceType', "urn:plex-tv:device:Media:1")
+
+        sub_el(device_out, 'friendlyName', self.fhdhr.config.dict["fhdhr"]["friendlyname"])
+        sub_el(device_out, 'manufacturer', self.fhdhr.config.dict["fhdhr"]["reporting_manufacturer"])
+        sub_el(device_out, 'manufacturerURL', "https://github.com/fHDHR/%s" % self.fhdhr.config.dict["main"]["reponame"])
+        sub_el(device_out, 'modelName', self.fhdhr.config.dict["fhdhr"]["reporting_model"])
+        sub_el(device_out, 'modelNumber', self.fhdhr.config.internal["versions"]["fHDHR"])
+
+        sub_el(device_out, 'modelDescription', self.fhdhr.config.dict["fhdhr"]["friendlyname"])
+        sub_el(device_out, 'modelURL', "https://github.com/fHDHR/%s" % self.fhdhr.config.dict["main"]["reponame"])
+
+        serviceList_out = sub_el(device_out, 'serviceList')
+        service_out = sub_el(serviceList_out, 'service')
+        sub_el(out, 'URLBase', "%s" % base_url)
+        sub_el(service_out, 'serviceType', "urn:plex-tv:service:MediaGrabber:1")
+        sub_el(service_out, 'serviceId', "urn:plex-tv:serviceId:MediaGrabber")
+
+        sub_el(device_out, 'UDN', "uuid:%s" % self.fhdhr.config.dict["main"]["uuid"])
+
+        fakefile = BytesIO()
+        fakefile.write(b'<?xml version="1.0" encoding="UTF-8"?>\n')
+        fakefile.write(xml.etree.ElementTree.tostring(out, encoding='UTF-8'))
+        device_xml = fakefile.getvalue()
+
+        return Response(status=200,
+                        response=device_xml,
+                        mimetype='application/xml')

fHDHR_web/rmg/devices_devicekey.py

@@ -6,7 +6,7 @@ from fHDHR.tools import sub_el
 
 
 class RMG_Devices_DeviceKey():
-    endpoints = ["/rmg/devices/<devicekey>"]
+    endpoints = ["/devices/<devicekey>", "/rmg/devices/<devicekey>"]
     endpoint_name = "rmg_devices_devicekey"
     endpoint_methods = ["GET"]
 
@@ -22,30 +22,22 @@ class RMG_Devices_DeviceKey():
         base_url = request.url_root[:-1]
 
         out = xml.etree.ElementTree.Element('MediaContainer')
-
-        if devicekey.startswith(self.fhdhr.config.dict["main"]["uuid"]):
-            origin = devicekey.split(self.fhdhr.config.dict["main"]["uuid"])[-1]
+        if devicekey == self.fhdhr.config.dict["main"]["uuid"]:
             out.set('size', "1")
-
-            if self.fhdhr.origins.origins_dict[origin].setup_success:
-                alive_status = "alive"
-            else:
-                alive_status = "dead"
-
             device_out = sub_el(out, 'Device',
-                                key="%s%s" % (self.fhdhr.config.dict["main"]["uuid"], origin),
-                                make=self.fhdhr.config.dict["rmg"]["reporting_manufacturer"],
-                                model=self.fhdhr.config.dict["rmg"]["reporting_model"],
+                                key=self.fhdhr.config.dict["main"]["uuid"],
+                                make=self.fhdhr.config.dict["fhdhr"]["reporting_manufacturer"],
+                                model=self.fhdhr.config.dict["fhdhr"]["reporting_model"],
                                 modelNumber=self.fhdhr.config.internal["versions"]["fHDHR"],
                                 protocol="livetv",
-                                status=alive_status,
-                                title="%s %s" % (self.fhdhr.config.dict["fhdhr"]["friendlyname"], origin),
-                                tuners=str(self.fhdhr.origins.origins_dict[origin].tuners),
-                                uri="%s/rmg/%s%s" % (base_url, self.fhdhr.config.dict["main"]["uuid"], origin),
-                                uuid="device://tv.plex.grabbers.fHDHR/%s%s" % (self.fhdhr.config.dict["main"]["uuid"], origin),
+                                status="alive",
+                                title=self.fhdhr.config.dict["fhdhr"]["friendlyname"],
+                                tuners=str(self.fhdhr.config.dict["fhdhr"]["tuner_count"]),
+                                uri=base_url,
+                                uuid="device://tv.plex.grabbers.fHDHR/%s" % self.fhdhr.config.dict["main"]["uuid"],
                                 )
 
-            tuner_status = self.fhdhr.device.tuners.status(origin)
+            tuner_status = self.fhdhr.device.tuners.status()
 
             for tuner_number in list(tuner_status.keys()):
                 tuner_dict = tuner_status[tuner_number]
@@ -75,7 +67,7 @@ class RMG_Devices_DeviceKey():
                            index=tuner_number,
                            status="scanning",
                            progress="99",
-                           channelsFound=str(len(list(self.fhdhr.device.channels.list[origin].keys()))),
+                           channelsFound=str(len(self.fhdhr.device.channels.list)),
                            )
 
                 # TODO networksScanned

fHDHR_web/rmg/devices_devicekey_channels.py

@@ -0,0 +1,47 @@
+from flask import Response
+from io import BytesIO
+import xml.etree.ElementTree
+
+from fHDHR.tools import sub_el
+
+
+class RMG_Devices_DeviceKey_Channels():
+    endpoints = ["/devices/<devicekey>/channels", "/rmg/devices/<devicekey>/channels"]
+    endpoint_name = "rmg_devices_devicekey_channels"
+    endpoint_methods = ["GET"]
+
+    def __init__(self, fhdhr):
+        self.fhdhr = fhdhr
+
+    def __call__(self, devicekey, *args):
+        return self.get(devicekey, *args)
+
+    def get(self, devicekey, *args):
+        """Returns the current channels."""
+
+        out = xml.etree.ElementTree.Element('MediaContainer')
+        if devicekey == self.fhdhr.config.dict["main"]["uuid"]:
+            out.set('size', str(len(self.fhdhr.device.channels.list)))
+            for fhdhr_id in list(self.fhdhr.device.channels.list.keys()):
+                channel_obj = self.fhdhr.device.channels.list[fhdhr_id]
+                if channel_obj.enabled:
+                    sub_el(out, 'Channel',
+                           drm="0",
+                           channelIdentifier="id://%s" % channel_obj.dict["number"],
+                           name=channel_obj.dict["name"],
+                           origin=channel_obj.dict["callsign"],
+                           number=str(channel_obj.dict["number"]),
+                           type="tv",
+                           # TODO param
+                           signalStrength="100",
+                           signalQuality="100",
+                           )
+
+        fakefile = BytesIO()
+        fakefile.write(b'<?xml version="1.0" encoding="UTF-8"?>\n')
+        fakefile.write(xml.etree.ElementTree.tostring(out, encoding='UTF-8'))
+        device_xml = fakefile.getvalue()
+
+        return Response(status=200,
+                        response=device_xml,
+                        mimetype='application/xml')

fHDHR_web/rmg/devices_devicekey_media.py

@@ -0,0 +1,31 @@
+from flask import request, redirect
+import urllib.parse
+
+
+class RMG_Devices_DeviceKey_Media():
+    endpoints = ["/devices/<devicekey>/media/<channel>", "/rmg/devices/<devicekey>/media/<channel>"]
+    endpoint_name = "rmg_devices_devicekey_media"
+    endpoint_methods = ["GET"]
+
+    def __init__(self, fhdhr):
+        self.fhdhr = fhdhr
+
+    def __call__(self, devicekey, channel, *args):
+        return self.get(devicekey, channel, *args)
+
+    def get(self, devicekey, channel, *args):
+
+        param = request.args.get('method', default=None, type=str)
+        self.fhdhr.logger.debug("param:%s" % param)
+
+        method = self.fhdhr.config.dict["fhdhr"]["stream_type"]
+
+        redirect_url = "/api/tuners?method=%s" % (method)
+
+        if str(channel).startswith('id://'):
+            channel = str(channel).replace('id://', '')
+        redirect_url += "&channel=%s" % str(channel)
+
+        redirect_url += "&accessed=%s" % urllib.parse.quote(request.url)
+
+        return redirect(redirect_url)

fHDHR_web/rmg/devices_devicekey_networks.py

@@ -6,7 +6,7 @@ from fHDHR.tools import sub_el
 
 
 class RMG_Devices_DeviceKey_Networks():
-    endpoints = ["/rmg/devices/<devicekey>/networks"]
+    endpoints = ["/devices/<devicekey>/networks", "/rmg/devices/<devicekey>/networks"]
     endpoint_name = "rmg_devices_devicekey_networks"
     endpoint_methods = ["GET"]
 
@@ -20,13 +20,12 @@ class RMG_Devices_DeviceKey_Networks():
         """In some cases, channel scanning is a two-step process, where the first stage consists of scanning for networks (this is called "fast scan")."""
 
         out = xml.etree.ElementTree.Element('MediaContainer')
-        if devicekey.startswith(self.fhdhr.config.dict["main"]["uuid"]):
-            origin = devicekey.split(self.fhdhr.config.dict["main"]["uuid"])[-1]
+        if devicekey == self.fhdhr.config.dict["main"]["uuid"]:
             out.set('size', "1")
 
             sub_el(out, 'Network',
-                   key="%s%s" % (self.fhdhr.config.dict["main"]["uuid"], origin),
-                   title="%s %s" % (self.fhdhr.config.dict["fhdhr"]["friendlyname"], origin),
+                   key="1",
+                   title="fHDHR"
                    )
 
         fakefile = BytesIO()

fHDHR_web/rmg/devices_devicekey_prefs.py

@@ -2,7 +2,7 @@ from flask import Response
 
 
 class RMG_Devices_DeviceKey_Prefs():
-    endpoints = ["/rmg/devices/<devicekey>/prefs"]
+    endpoints = ["/devices/<devicekey>/prefs", "/rmg/devices/<devicekey>/prefs"]
     endpoint_name = "rmg_devices_devicekey_prefs"
     endpoint_methods = ["GET", "PUT"]
 
@@ -15,7 +15,4 @@ class RMG_Devices_DeviceKey_Prefs():
     def get(self, devicekey, *args):
         """Prefs sent back from Plex in Key-Pair format"""
 
-        if devicekey.startswith(self.fhdhr.config.dict["main"]["uuid"]):
-            return Response(status=200)
-
         return Response(status=200)

fHDHR_web/rmg/devices_devicekey_scan.py

@@ -4,7 +4,7 @@ import xml.etree.ElementTree
 
 
 class RMG_Devices_DeviceKey_Scan():
-    endpoints = ["/rmg/devices/<devicekey>/scan"]
+    endpoints = ["/devices/<devicekey>/scan", "/rmg/devices/<devicekey>/scan"]
     endpoint_name = "rmg_devices_devicekey_scan"
     endpoint_methods = ["GET", "POST", "DELETE"]
 
@@ -26,11 +26,9 @@ class RMG_Devices_DeviceKey_Scan():
             self.fhdhr.logger.debug("Scan Requested network:%s, source:%s, provider:%s" % (network, source, provider))
 
             out = xml.etree.ElementTree.Element('MediaContainer')
+            if devicekey == self.fhdhr.config.dict["main"]["uuid"]:
 
-            if devicekey.startswith(self.fhdhr.config.dict["main"]["uuid"]):
-                origin = devicekey.split(self.fhdhr.config.dict["main"]["uuid"])[-1]
-
-                tuner_status = self.fhdhr.device.tuners.status(origin)
+                tuner_status = self.fhdhr.device.tuners.status()
                 tuner_scanning = 0
                 for tuner in list(tuner_status.keys()):
                     if tuner_status[tuner]["status"] == "Scanning":
@@ -55,10 +53,9 @@ class RMG_Devices_DeviceKey_Scan():
         elif request.method in ["DELETE"]:
 
             out = xml.etree.ElementTree.Element('MediaContainer')
-            if devicekey.startswith(self.fhdhr.config.dict["main"]["uuid"]):
-                origin = devicekey.split(self.fhdhr.config.dict["main"]["uuid"])[-1]
+            if devicekey == self.fhdhr.config.dict["main"]["uuid"]:
 
-                self.fhdhr.device.tuners.stop_tuner_scan(origin)
+                self.fhdhr.device.tuners.stop_tuner_scan()
                 out.set('status', "0")
                 out.set('message', "Scan Aborted")
 

fHDHR_web/rmg/devices_devicekey_scanners.py

@@ -6,7 +6,7 @@ from fHDHR.tools import sub_el
 
 
 class RMG_Devices_DeviceKey_Scanners():
-    endpoints = ["/rmg/devices/<devicekey>/scanners"]
+    endpoints = ["/devices/<devicekey>/scanners", "/rmg/devices/<devicekey>/scanners"]
     endpoint_name = "rmg_devices_devicekey_scanners"
     endpoint_methods = ["GET"]
 
@@ -23,9 +23,7 @@ class RMG_Devices_DeviceKey_Scanners():
         # 0 (atsc), 1 (cqam), 2 (dvb-s), 3 (iptv), 4 (virtual), 5 (dvb-t), 6 (dvb-c), 7 (isdbt)
 
         out = xml.etree.ElementTree.Element('MediaContainer')
-        if devicekey.startswith(self.fhdhr.config.dict["main"]["uuid"]):
-            origin = devicekey.split(self.fhdhr.config.dict["main"]["uuid"])[-1]
-
+        if devicekey == self.fhdhr.config.dict["main"]["uuid"]:
             if method == "0":
                 out.set('size', "1")
                 out.set('simultaneousScanners', "1")
@@ -37,7 +35,7 @@ class RMG_Devices_DeviceKey_Scanners():
                 sub_el(scanner_out, 'Setting',
                        id="provider",
                        type="text",
-                       enumValues=origin
+                       enumValues=self.fhdhr.config.dict["main"]["servicename"]
                        )
 
         fakefile = BytesIO()

fHDHR_web/rmg/devices_discover.py

@@ -0,0 +1,49 @@
+from flask import Response, request
+from io import BytesIO
+import xml.etree.ElementTree
+
+from fHDHR.tools import sub_el
+
+
+class RMG_Devices_Discover():
+    endpoints = ["/devices/discover", "/rmg/devices/discover"]
+    endpoint_name = "rmg_devices_discover"
+    endpoint_methods = ["GET", "POST"]
+
+    def __init__(self, fhdhr):
+        self.fhdhr = fhdhr
+
+    def __call__(self, *args):
+        return self.get(*args)
+
+    def get(self, *args):
+        """This endpoint requests the grabber attempt to discover any devices it can, and it returns zero or more devices."""
+
+        base_url = request.url_root[:-1]
+
+        out = xml.etree.ElementTree.Element('MediaContainer')
+        out.set('size', "1")
+        sub_el(out, 'Device',
+               key=self.fhdhr.config.dict["main"]["uuid"],
+               make=self.fhdhr.config.dict["fhdhr"]["reporting_manufacturer"],
+               model=self.fhdhr.config.dict["fhdhr"]["reporting_model"],
+               modelNumber=self.fhdhr.config.internal["versions"]["fHDHR"],
+               protocol="livetv",
+               status="alive",
+               title=self.fhdhr.config.dict["fhdhr"]["friendlyname"],
+               tuners=str(self.fhdhr.config.dict["fhdhr"]["tuner_count"]),
+               uri=base_url,
+               uuid="device://tv.plex.grabbers.fHDHR/%s" % self.fhdhr.config.dict["main"]["uuid"],
+               thumb="favicon.ico",
+               interface='network'
+               # TODO add preferences
+               )
+
+        fakefile = BytesIO()
+        fakefile.write(b'<?xml version="1.0" encoding="UTF-8"?>\n')
+        fakefile.write(xml.etree.ElementTree.tostring(out, encoding='UTF-8'))
+        device_xml = fakefile.getvalue()
+
+        return Response(status=200,
+                        response=device_xml,
+                        mimetype='application/xml')

fHDHR_web/rmg/devices_probe.py

@@ -0,0 +1,51 @@
+from flask import Response, request
+from io import BytesIO
+import xml.etree.ElementTree
+
+from fHDHR.tools import sub_el
+
+
+class RMG_Devices_Probe():
+    endpoints = ["/devices/probe", "/rmg/devices/probe"]
+    endpoint_name = "rmg_devices_probe"
+    endpoint_methods = ["GET", "POST"]
+
+    def __init__(self, fhdhr):
+        self.fhdhr = fhdhr
+
+    def __call__(self, *args):
+        return self.get(*args)
+
+    def get(self, *args):
+        """Probes a specific URI for a network device, and returns a device, if it exists at the given URI."""
+
+        base_url = request.url_root[:-1]
+
+        uri = request.args.get('uri', default=None, type=str)
+
+        out = xml.etree.ElementTree.Element('MediaContainer')
+        out.set('size', "1")
+        if uri == base_url:
+            sub_el(out, 'Device',
+                   key=self.fhdhr.config.dict["main"]["uuid"],
+                   make=self.fhdhr.config.dict["fhdhr"]["reporting_manufacturer"],
+                   model=self.fhdhr.config.dict["fhdhr"]["reporting_model"],
+                   modelNumber=self.fhdhr.config.internal["versions"]["fHDHR"],
+                   protocol="livetv",
+                   status="alive",
+                   title=self.fhdhr.config.dict["fhdhr"]["friendlyname"],
+                   tuners=str(self.fhdhr.config.dict["fhdhr"]["tuner_count"]),
+                   uri=base_url,
+                   uuid="device://tv.plex.grabbers.fHDHR/%s" % self.fhdhr.config.dict["main"]["uuid"],
+                   thumb="favicon.ico",
+                   interface='network'
+                   )
+
+        fakefile = BytesIO()
+        fakefile.write(b'<?xml version="1.0" encoding="UTF-8"?>\n')
+        fakefile.write(xml.etree.ElementTree.tostring(out, encoding='UTF-8'))
+        device_xml = fakefile.getvalue()
+
+        return Response(status=200,
+                        response=device_xml,
+                        mimetype='application/xml')

fHDHR_web/rmg/rmg_ident_xml.py

@@ -6,7 +6,7 @@ from fHDHR.tools import sub_el
 
 
 class RMG_Ident_XML():
-    endpoints = ["/rmg/<devicekey>/"]
+    endpoints = ["/rmg", "/rmg/"]
     endpoint_name = "rmg_ident_xml"
 
     def __init__(self, fhdhr):
@@ -15,22 +15,18 @@ class RMG_Ident_XML():
     def __call__(self, *args):
         return self.get(*args)
 
-    def get(self, devicekey, *args):
-        """Device.xml referenced from SSDP"""
+    def get(self, *args):
         """Provides general information about the media grabber"""
 
         base_url = request.url_root[:-1]
 
         out = xml.etree.ElementTree.Element('MediaContainer')
-        if devicekey.startswith(self.fhdhr.config.dict["main"]["uuid"]):
-            origin = devicekey.split(self.fhdhr.config.dict["main"]["uuid"])[-1]
-
-            sub_el(out, 'MediaGrabber',
-                   identifier="tv.plex.grabbers.fHDHR.%s" % origin,
-                   title="%s %s" % (self.fhdhr.config.dict["fhdhr"]["friendlyname"], origin),
-                   protocols="livetv",
-                   icon="%s/favicon.ico" % base_url
-                   )
+        sub_el(out, 'MediaGrabber',
+               identifier="tv.plex.grabbers.fHDHR",
+               title=str(self.fhdhr.config.dict["fhdhr"]["friendlyname"]),
+               protocols="livetv",
+               icon="%s/favicon.ico" % base_url
+               )
 
         fakefile = BytesIO()
         fakefile.write(b'<?xml version="1.0" encoding="UTF-8"?>\n')