urllib2 SSL kļūdas labojums

ContentSources.py

                 streams = [stream]
             else:
                 try:
-                    streams = sources.get_streams(cur2[1])
+                    if not download:
+                        streams = sources.get_streams(cur2[1])
+                    else:
+                        stream = util.item()
+                        stream["url"] = cur2[1]
+                        stream["name"] = cur2[0]
+                        stream["url"] = util.streamproxy_encode2(stream["url"])
+                        print stream["url"]
+                        streams = [stream]
                 except Exception as e:
                     print unicode(e)
                     traceback.print_exc()
                 if not download:
                     util.play_video(streams)
                 else:
-                    Downloader.download_video(streams)
+                    #urlp = util.streamproxy_encode2(streams[0]["url"])
+                    #print urlp
+                    #util.player(urlp)
+                    #Downloader.download_video(streams)
+                    pass
             else:
                 print "**No stream to play - %s "%(
                     cur2[1])

Downloader.py

     def download_fragment(self):
         if self.ts_num>=len(self.ts_list):
             pass
-            print "Call later"
+            #print "Call later"
             reactor.callLater(10,self.update_manifest)
             reactor.callLater(10, self.download_fragment)
         else:
     reactor.stop()
 ###############################################
 
-def download_vide(stream):
+def download_video(stream):
     stream = stream[0]
     url = stream["url"]
     headers = stream["headers"]

PlayStream.py

 # Used fragments of code from enigma2-plugin-tv3play by Taapat (https://github.com/Taapat/enigma2-plugin-tv3play)
 #
 
-__version__ = "0.6r"
+__version__ = "0.6t"
 __id__ = "playstream"
 __title__ = "PlayStream"
 __author__ = "ivars777@gmail.com"

changelog.md

+**0.6t** (17.06.2017)
+- [bugfix] kļūda verot vaļā HTTPS lapas (urllib2 SSL: CERTIFICATE_VERIFY_FAILED)
+
+**0.6s** (13.04.2017)
+- [bugfix] LMT straume google tiešraides kļūda novēsta
+
 **0.6r** (01.04.2017)
 - [feature] LMT Straume video (bez TV, kas strādā tikai LMT tīklā)
+- [bugfix] proxy serveris piefrizēts, cerams ka strādā stabilāk (aktuāls viaplay ejošajai daļai)
 
 **0.6p** (31.03.2017)
 - [bugfix] filmix sērijas

playstreamproxy.py

 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 """
 StreamProxy daemon (based on Livestream daemon)
 Ensures persistent cookies, User-Agents and others tricks to play protected HLS/DASH streams
 import urllib,urlparse
 #import cookielib,urllib2
 import requests
+
 try:
     from requests.packages.urllib3.exceptions import InsecureRequestWarning
     requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
     pass
 
 HOST_NAME = ""
-PORT_NUMBER = 88
+PORT_NUMBER = 8880
 DEBUG = True
 DEBUG2 = False
 
 headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
 headers0 = headers2dict("""
 icy-metadata: 1
-Cache-Control: max-age=0
-Accept-Encoding: gzip, deflate
 User-Agent: GStreamer souphttpsrc libsoup/2.52.2
-Connection: Keep-Alive
 """)
 sessions = {}
+cur_directory = os.path.dirname(os.path.realpath(__file__))
+sources = None
+slinks = {}
+
 
 class StreamHandler(BaseHTTPRequestHandler):
 
     def do_HEAD(self):
-        print "**head"
+        print "**get_head"
         self.send_response(200)
         self.send_header("Server", "playstreamproxy")
         if ".m3u8" in self.path.lower():
 
     def do_GET(self):
         """Respond to a GET request"""
-        self.log_message("\n\n"+40*"#"+"\nget_url: \n%s", self.path)
+        print "\n\n"+40*"#"+"\nget_url: \n%s", self.path
         p = self.path.split("~")
-        #url = urllib.unquote(p[0][1:])
-        url = p[0][1:]
-        url = url.replace(COL_CODE, ":")
-        headers = self.headers.dict
-        headers = {} # TODO
-        headers["host"] = urlparse.urlparse(url).hostname
+        #url = urllib.unquote(p[0][1:]) # TODO - vajag nocekot vai visi urli strādā
+        urlp = p[0][1:]
+        url = urlp.replace(COL_CODE, ":")
+        #headers = self.headers.dict
+        headers = {} # TODO izmanto saņemtos headerus, var aizvietot ar defaultajiem
+        #headers["host"] = urlparse.urlparse(url).hostname
         if len(p)>1:
             for h in p[1:]:
                 k = h.split("=")[0].lower()
         if DEBUG:
             print "url=%s"%url
             print "Original request headers + url headers:"
-            print_headers(headers)
-
+            print_headers(self.headers.dict)
         self.protocol_version = 'HTTP/1.1'
 
-        # TODO fetch selection
         try:
-            if ".lattelecom.tv/" in url: # lattelecom.tv hack
-                self.fetch_ltc(self.wfile, url, headers)
+            if "::" in url: # encoded source link
+                self.fetch_source(urlp, headers)
+            elif ".lattelecom.tv/" in url: # lattelecom.tv hack
+                self.fetch_ltc( url, headers)
             elif "filmas.lv" in url or "viaplay" in url: #  HLS session/decode filmas.lv in url:
-                self.fetch_url2(self.wfile, url, headers)
+                self.fetch_url2(url, headers)
             else: # plain fetch
-                self.fetch_url(self.wfile, url, headers)
+                self.fetch_url( url, headers)
         except Exception as e:
             print "Got Exception: ", str(e)
             import traceback
 
     ### Remote server request procedures ###
 
-    def fetch_offline(self,wfile):
+    def fetch_offline(self):
         print "** Fetch offline"
         self.send_response(200)
         self.send_header("Server", "playstreamproxy")
         self.wfile.write(open("offline.mp4", "rb").read())
         #self.wfile.close()
 
-    def fetch_url(self,wfile,url,headers):
+    def fetch_source(self, urlp, headers):
         if DEBUG:
             print "\n***********************************************************"
-            print "fetch_url: \n%s"%url
-            print "**Server request headers: "
-            print_headers(headers)
-        #if ".lattelecom.tv/" in url and EQ_CODE in url:
-        #    url = url.replace(EQ_CODE,"=")
-        r = requests.get(url,headers = headers)
+            print "fetch_source: \n%s"%urlp
+        base_data = hls_base(urlp)
+        data = urllib.unquote_plus(base_data)[:-1]
+        if DEBUG: print "base_data=", base_data
+        if DEBUG: print "data=", data
+        if not base_data in slinks :
+            streams = sources.get_streams(data)
+            if not streams:
+                self.write_error(500)  # TODO
+                return
+            url = streams[0]["url"]
+            base_url = hls_base(url)
+            if DEBUG: print "New link, base_url=",base_url
+            ses = requests.Session()
+            ses.trust_env = False
+            slinks[base_data] = {"data": data, "urlp":urlp,"url": url, "base_url": base_url,"session":ses}
+        else:
+            ses = slinks[base_data]["session"]
+            if urlp == slinks[base_data]["urlp"]:
+                url = slinks[base_data]["url"]
+                if DEBUG: print "Existing base link", url
+            else:
+                url = urlp.replace(base_data, slinks[base_data]["base_url"])
+                if DEBUG: print "Existing new link", url
+        r = self.get_page_ses(url,ses,True,headers = headers)
         code = r.status_code
+        if not code in (200,206): # TODO mēģina vēlreiz get_streams
+            self.write_error(code)
+            return
+        self.send_response(code)
+        self.send_headers(r.headers)
+        CHUNK_SIZE = 1024 *4
+        for chunk in r.iter_content(chunk_size=CHUNK_SIZE):
+            try:
+                self.wfile.write(chunk)
+            except Exception as e:
+                print "Exception: ", str(e)
+                self.wfile.close()
+                return
+        if DEBUG: print "**File downloaded"
+        if "connection" in r.headers and r.headers["connection"] <> "keep-alive":
+            self.wfile.close()
+        return
+
+
+    def fetch_url(self, url,headers):
         if DEBUG:
-            print "** Server/proxy response, code = %s"%code
-            print_headers(r.headers)
+            print "\n***********************************************************"
+            print "fetch_url: \n%s"%url
+        r = self.get_page(url,headers = headers)
+        code = r.status_code
         if not code in (200,206):
-            print "***Error, code=%s",code
-            self.send_response(code)
-            self.send_headers(r.headers)
-            wfile.close()
+            self.write_error(code)
             return
         self.send_response(code)
         self.send_headers(r.headers)
         CHUNK_SIZE = 1024*4
-        for chunk in r.iter_content(CHUNK_SIZE):
+        for chunk in r.iter_content(chunk_size=CHUNK_SIZE):
             try:
-                wfile.write(chunk)
+                self.wfile.write(chunk)
             except Exception as e:
                 print "Exception: ", str(e)
-                wfile.close()
+                self.wfile.close()
                 return
         if DEBUG: print "**File downloaded"
-        wfile.close()
-        # time.sleep(1)
+        if "connection" in r.headers and r.headers["connection"] <> "keep-alive":
+            self.wfile.close()
         return
 
-    def fetch_ltc(self, wfile, url, headers):
+    def fetch_ltc(self, url, headers):
+        "lattelecom.tv hack (have to update chunklist after each 6 min"
         if DEBUG:
-            print "\n***********************************************************"
-            print "fetch_url2: \n%s"%url
-        #self.log_message("fetch_filmas: \n%s", url)
-        #self.log_message("headers: %s", headers)
+            print "\n\n***********************************************************"
+            print "fetch_ltc: \n%s"%url
         base_url = hls_base(url)
         if DEBUG: print "base_url=",base_url
         if base_url not in sessions:
             if DEBUG: print "New session"
             sessions[base_url] = {}
             sessions[base_url]["session"] = requests.Session()
-            #sessions[base_url]["session"].headers = {}
-            sessions[base_url]["key"] = binascii.a2b_hex(headers["key"]) if "key" in headers and headers["key"] else None
+            sessions[base_url]["session"].trust_env = False
+            sessions[base_url]["session"].headers.update(headers0)
+            sessions[base_url]["playlist"] = ""
+            sessions[base_url]["chunklist"] = []
+
+        #  change ts file to valid one media_w215689190_33.ts?
+        tsfile = re.search("media_\w+_(\d+)\.ts", url, re.IGNORECASE)
+        if tsfile and sessions[base_url]["chunklist"]:
+            tnum = int(tsfile.group(1))
+            url2 = sessions[base_url]["chunklist"][tnum]
+            if not url2.startswith("http"):
+                url2 = base_url + url2
+            url = url2
+            if DEBUG: print "[playstreamproxy] url changed to ", url
+
+        ### get_page ###
         ses = sessions[base_url]["session"]
-        key = sessions[base_url]["key"]
-        ses.headers.clear()
-        ses.headers.update(headers0)
+        #ses.headers.update(headers0)
         ses.headers.update(headers)
-        ses.headers["Connection"]="Keep-Alive"
-        if DEBUG:
-            print "**Server request headers: "
-            print_headers(ses.headers)
-        for t in range(3):
-            r = ses.get(url, stream=True, verify=False)
-            code = r.status_code #r.status_code
-            if DEBUG:
-                print "\n\n=====================================\n**Server response:", code #r.status_code
-                print "**Server response headers: "
-                print_headers(r.headers)
-            if code in (200,2016): break
-        if not (code in (200,206)):
-            print "***Error, code=%s"%code
-            self.send_response(code)
-            self.send_headers(r.headers)
-            wfile.close()
-            #self.fetch_offline(wfile)
+        # ses.headers["Connection"]="Keep-Alive"
+        r = self.get_page_ses(url,ses)
+        code = r.status_code #r.status_code
+
+        if not (code in (200,206)) and tsfile:
+            # update chunklist
+            r2 = self.get_page(sessions[base_url]["playlist"])
+            streams = re.findall(r"#EXT-X-STREAM-INF:.*?BANDWIDTH=(\d+).*?\n(.+?)$", r2.content, re.IGNORECASE | re.MULTILINE)
+            if streams:
+                sorted(streams, key=lambda item: int(item[0]), reverse=True)
+                chunklist = streams[0][1]
+                if not chunklist.startswith("http"):
+                    chunklist = base_url + chunklist
+            else:
+                self.write_error(r.status_code)
+                return
+            print "[playstreamproxy] trying to update chunklist", chunklist
+            r3 = self.get_page_ses(chunklist,ses,True)
+            ts_list = re.findall(r"#EXTINF:.*?\n(.+?)$", r3.content, re.IGNORECASE | re.MULTILINE)
+            sessions[base_url]["chunklist"]= ts_list
+            tnum = int(tsfile.group(1))
+            url2 = sessions[base_url]["chunklist"][tnum]
+            if not url2.startswith("http"):
+                url2 = base_url + url2
+            r = self.get_page_ses(url2,ses,True)
+            if not r.status_code in (200,206):
+                self.write_error(r.status_code)
+                return
+        elif not r.status_code in (200,206):
+            self.write_error(r.status_code)
             return
 
+        if "playlist.m3u8" in url:
+            sessions[base_url]["playlist"] = url
+
         ### Start of return formin and sending
         self.send_response(200)
         #headers2 = del_headers(r.headers,["Content-Encoding",'Transfer-Encoding',"Connection",'content-range',"range"])
         headers2  = {"server":"playstreamproxy", "content-type":"text/html"}
 
-        # Content-Type: application/vnd.apple.mpegurl (encrypted)
-        if r.headers["content-type"] == "application/vnd.apple.mpegurl":
-            content = r.content
-            content = r.content.replace(base_url,"")
-            content = re.sub("#EXT-X-KEY:METHOD=AES-128.+\n", "", content, 0, re.IGNORECASE | re.MULTILINE)
-            headers2["content-type"] = "application/vnd.apple.mpegurl"
-            headers2["content-length"] = "%s"%len(content)
-            r.headers["content-length"] = "%s"%len(content)
-            #headers2['content-range'] = 'bytes 0-%s/%s'%(len(content)-1,len(content))
-            #self.send_headers(headers2)
-            self.send_headers(r.headers)
-            wfile.write(content)
-            wfile.close()
-
-        # Content-Type: video/MP2T (encrypted)
-        elif r.headers["content-type"] == "video/MP2T" and key:
-            print "Decode video/MP2T"
-            content = r.content
-            from Crypto.Cipher import AES
-            iv = content[:16]
-            d = AES.new(key, AES.MODE_CBC, iv)
-            content = d.decrypt(content[16:])
-            headers2["content-type"] = "video/MP2T"
-            headers2["content-length"] = "%s"% (len(content))
-            #headers2['content-range'] = 'bytes 0-%s/%s' % (len(content) - 1, len(content))
-            print content[0:16]
-            print "Finish decode"
-            self.send_headers(headers2)
-            wfile.write(content)
-            wfile.close()
-
-        else:
-            print "Return regular content"
-            headers2["content-type"]  = r.headers["content-type"]
-            if "content-length" in r.headers:
-                headers2["content-length"] = r.headers["content-length"]
-            self.send_headers(r.headers)
-            CHUNK_SIZE = 4 * 1024
-            for chunk in r.iter_content(CHUNK_SIZE):
-                try:
-                    #print "#",
-                    wfile.write(chunk)
-                except Exception as e:
-                    print "Exception: ", str(e)
-                    return
-            if DEBUG: print "File downloaded = "
-            wfile.close()
-            #time.sleep(1)
-            return
+        if DEBUG: print "\n** Return  content"
+        headers2["content-type"]  = r.headers["content-type"]
+        if "content-length" in r.headers:
+            headers2["content-length"] = r.headers["content-length"]
+        self.send_headers(r.headers)
+        CHUNK_SIZE = 4 * 1024
+        for chunk in r.iter_content(chunk_size=CHUNK_SIZE):
+            try:
+                #print "#",
+                self.wfile.write(chunk)
+            except Exception as e:
+                print "Exception: ", str(e)
+                return
+        if DEBUG: print "File downloaded = "
+        self.wfile.close()
+        #time.sleep(1)
+        return
 
 
-    def fetch_url2(self, wfile, url, headers):
+    def fetch_url2(self, url, headers):
         if DEBUG:
             print "\n***********************************************************"
             print "fetch_url2: \n%s"%url
-        #self.log_message("fetch_filmas: \n%s", url)
-        #self.log_message("headers: %s", headers)
         base_url = hls_base(url)
         if DEBUG: print "base_url=",base_url
         if base_url not in sessions:
             if DEBUG: print "New session"
             sessions[base_url] = {}
             sessions[base_url]["session"] = requests.Session()
-            #sessions[base_url]["session"].headers = {}
+            sessions[base_url]["session"].trust_env = False
+            sessions[base_url]["session"].headers.update(headers0)
             sessions[base_url]["key"] = binascii.a2b_hex(headers["key"]) if "key" in headers and headers["key"] else None
         ses = sessions[base_url]["session"]
+        ses.trust_env = False
         key = sessions[base_url]["key"]
-        ses.headers.clear()
-        ses.headers.update(headers0)
+        #ses.headers.clear()
         ses.headers.update(headers)
-        ses.headers["Connection"]="Keep-Alive"
-        if DEBUG:
-            print "**Server request headers: "
-            print_headers(ses.headers)
-        for t in range(3):
-            r = ses.get(url, stream=True, verify=False)
-            code = r.status_code #r.status_code
-            if DEBUG:
-                print "\n\n=====================================\n**Server response:", code #r.status_code
-                print "**Server response headers: "
-                print_headers(r.headers)
-            if code in (200,2016): break
+        r = self.get_page_ses(url, ses,stream=False)
+        code = r.status_code #r.status_code
         if not (code in (200,206)):
-            print "***Error, code=%s"%code
-            self.send_response(code)
-            self.send_headers(r.headers)
-            wfile.close()
-            #self.fetch_offline(wfile)
+            self.write_error(r.status_code)
             return
 
         ### Start of return formin and sending
         headers2  = {"server":"playstreamproxy", "content-type":"text/html"}
 
         # Content-Type: application/vnd.apple.mpegurl (encrypted)
-        if r.headers["content-type"] == "application/vnd.apple.mpegurl":
+        if r.headers["content-type"] == "application/vnd.apple.mpegurl" and key:
             content = r.content
             content = r.content.replace(base_url,"")
             content = re.sub("#EXT-X-KEY:METHOD=AES-128.+\n", "", content, 0, re.IGNORECASE | re.MULTILINE)
             headers2["content-length"] = "%s"%len(content)
             r.headers["content-length"] = "%s"%len(content)
             #headers2['content-range'] = 'bytes 0-%s/%s'%(len(content)-1,len(content))
-            #self.send_headers(headers2)
-            self.send_headers(r.headers)
-            wfile.write(content)
-            wfile.close()
+            self.send_headers(headers2)
+            #self.send_headers(r.headers)
+            self.wfile.write(content)
+            self.wfile.close()
 
         # Content-Type: video/MP2T (encrypted)
         elif r.headers["content-type"] == "video/MP2T" and key:
             print content[0:16]
             print "Finish decode"
             self.send_headers(headers2)
-            wfile.write(content)
-            wfile.close()
+            self.wfile.write(content)
+            self.wfile.close()
 
         else:
-            print "Return regular content"
+            if DEBUG: print "Return regular content"
             headers2["content-type"]  = r.headers["content-type"]
             if "content-length" in r.headers:
                 headers2["content-length"] = r.headers["content-length"]
             self.send_headers(r.headers)
+            #self.send_headers(headers2)
             CHUNK_SIZE = 4 * 1024
-            for chunk in r.iter_content(CHUNK_SIZE):
+            for chunk in r.iter_content(chunk_size=CHUNK_SIZE):
                 try:
                     #print "#",
-                    wfile.write(chunk)
+                    self.wfile.write(chunk)
                 except Exception as e:
                     print "Exception: ", str(e)
                     return
             if DEBUG: print "File downloaded = "
-            wfile.close()
+            if "connection" in r.headers and r.headers["connection"]<>"keep-alive":
+                self.wfile.close()
             #time.sleep(1)
             return
 
             self.send_header(h, headers[h])
         self.end_headers()
 
+    def write_error(self,code):
+        print "***Error, code=%s" % code
+        self.send_response(code)
+        #self.send_headers(r.headers)
+        self.wfile.close() # TODO?
+        # self.fetch_offline()
+
+    def get_page_ses(self,url,ses,stream=True, headers=None):
+        headers= headers if headers else headers0
+        ses.headers.update(headers)
+        if DEBUG:
+            print "\n\n====================================================\n**get_page_ses\n%s"%url
+            print "**Server request headers: "
+            print_headers(ses.headers)
+        r = ses.get(url, stream=stream, verify=False)
+        if DEBUG:
+            print "**Server response:", r.status_code
+            print "**Server response headers: "
+            print_headers(r.headers)
+        return r
+
+    def get_page(self,url,headers=None):
+        if not headers:
+            headers = headers0
+        if DEBUG:
+            print "\n\n====================================================\n**get_page\n%s"%url
+            print "**Server request headers: "
+            print_headers(headers)
+        r = requests.get(url, headers=headers,stream=True)
+        if DEBUG:
+            print "**Server response:", r.status_code
+            print "**Server response headers: "
+            print_headers(r.headers)
+        return r
 
 class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
     """Handle requests in a separate thread."""
 
 def start(host = HOST_NAME, port = PORT_NUMBER):
+    import ContentSources, util
+    global sources
+    sources = ContentSources.ContentSources(os.path.join(cur_directory, "sources"))
     httpd = ThreadedHTTPServer((host, port), StreamHandler)
     print time.asctime(), "Server Starts - %s:%s" % (HOST_NAME, PORT_NUMBER)
     try:

sources/SourceBase.py

 import urllib2, urllib
 import datetime, re, sys,os
 import requests
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
 try:
     from requests.packages.urllib3.exceptions import InsecureRequestWarning
     requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

sources/YouTubeVideoUrl.py

 from urllib import urlencode
 from urllib2 import urlopen, URLError
 import sys
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
 
 #from Components.config import config
 
 		import ssl
 		sslContext = ssl._create_unverified_context()
 	except:
-		pass 
+		pass
 from jsinterp import JSInterpreter
 from swfinterp import SWFInterpreter
 

sources/cinemalive.py

 from SourceBase import SourceBase
 #from collections import OrderedDict
 import os
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
 
-#sys.path.insert(0,os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) 
+
+#sys.path.insert(0,os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from resolver import resolve
 import util
 
 headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
 import HTMLParser
 h = HTMLParser.HTMLParser()
-    
+
 class Source(SourceBase):
-    
+
     def __init__(self,country="",cfg_path=None):
         self.name = "cinemalive"
         self.title = "cinemalive.tv"
 """)
         self.url = "https://cinemalive.tv/"
         #self.login()
-        
-            
+
+
     ######### Entry point ########
     def get_content(self, data):
         print "[cinemalive] get_content:", data
-        source,data,path,plist,clist,params,qs = self.parse_data(data)     
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
         content=[]
         content.append(("..return", "back","","Return back"))
-        
+
         if clist=="home":
             content.extend([
-                ("Search", "cinemalive::scripts/search.php?search={0}","","Search"),            
+                ("Search", "cinemalive::scripts/search.php?search={0}","","Search"),
                 ("Filmas latviski - visas", "cinemalive::filmaslatviski/visas/lapa/1","","Filmas latviski - visas"),
                 ("Filmas angliski", "cinemalive::home_en","","Filmas angliski"),
                 ("Filmas latviski - jaunākās", "cinemalive::filmaslatviski/jaunakas/lapa/1","","Filmas latviski - jaunākās"),
                 data2 = item[0]+"/lapa/1"
                 img = self.img
                 desc = title
-                content.append((title,self.name+"::"+data2,img,desc))      
+                content.append((title,self.name+"::"+data2,img,desc))
             return content
 
         elif clist=="home_en":
             content.extend([
-                ("Search", "cinemalive::scripts/search.php?search={0}","","Search"),            
+                ("Search", "cinemalive::scripts/search.php?search={0}","","Search"),
                 ("Movies English - all", "cinemalive::moviesenglish/all/page/1","","Movies English - all"),
                 ("Movies Latvian", "cinemalive::home","","Filmas latviski"),
                 ("Movies English - newest", "cinemalive::moviesenglish/newestmovies/page/1","","Movies English - newest"),
                 data2 = item[0]+"/page/1"
                 img = self.img
                 desc = title
-                content.append((title,self.name+"::"+data2,img,desc))      
+                content.append((title,self.name+"::"+data2,img,desc))
             return content
 
-    
+
         elif "search.php" in data:
-            
+
             r=self.call(path,params=params[1:],headers=self.headers2)
-            result = re.findall(r'<div class="results.+?<a href="https://cinemalive\.tv/(.+?)">.+?<img src="(.+?)".+?<span style="color:#bcbcbc">([^<]+)</span> <span style="color:#5a606d;font-size:12px;">([^<]+)</span><br/>.+?<p class="dec" style="font-size:12px; color:#777;line-height:14px;">([^<]+)</p>', r, re.DOTALL)            
+            result = re.findall(r'<div class="results.+?<a href="https://cinemalive\.tv/(.+?)">.+?<img src="(.+?)".+?<span style="color:#bcbcbc">([^<]+)</span> <span style="color:#5a606d;font-size:12px;">([^<]+)</span><br/>.+?<p class="dec" style="font-size:12px; color:#777;line-height:14px;">([^<]+)</p>', r, re.DOTALL)
             for item in result:
                 title = item[2]
                 title0 = re.sub(" \(\d+\)","",title)
                 data2 = item[0]
                 img = item[1].replace("xs.","sm.")
                 desc = util.unescape(item[4])
-                content.append((title,self.name+"::"+data2,img,desc))            
+                content.append((title,self.name+"::"+data2,img,desc))
             return content
 
         elif clist in ("filmaslatviski","moviesenglish"):
                 img = "https://cinemalive.tv/"+item[1]
                 title = util.unescape(title)
                 desc = title
-                content.append((title,self.name+"::"+data2,img,desc)) 
+                content.append((title,self.name+"::"+data2,img,desc))
             m = re.search(r"""<a href='https://cinemalive\.tv/([^']+)' style="border-right:none;">»</a>""", r, re.DOTALL)
             if m:
                 data2 = m.group(1)
-                content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))                                  
-            return content      
-         
+                content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))
+            return content
+
         else:
-            return content                            
-              
+            return content
+
     def is_video(self,data):
-        source,data,path,plist,clist,params,qs = self.parse_data(data)        
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
         if clist=="movie":
             return True
         else:
             return False
-                        
+
     def get_streams(self, data):
         print "[cinemalive] get_streams:", data
         source,data,path,plist,clist,params,qs = self.parse_data(data)
         title = title0.replace(" - Filma Online Latviski","").replace(" - Movie Online English HD","")
         desc = re.search('<p class="plot">(.+?)</p>', r).group(1)
         img = "http://cinemalive.tv"+re.search('<img src="(.+?)" class="img-thumbnail"', r).group(1)
-        
+
         m = re.search(r'<video id=.+?<source src="([^"]+\.mp4)"', r, re.DOTALL)
         if m:
             s = util.item()
             s["desc"] = util.unescape(desc)
             s["img"] = img
             s["type"] = self.stream_type(s["url"])
-            s["lang"] = lang 
+            s["lang"] = lang
             return [s]
-        
+
         #m = re.search('<div class="viboom-overroll"><iframe src="([^"]+)"', r)
         #if m:
         result = re.findall('<div id="video_container"><iframe.+?src="(.+?)"', r)
                     s["img"] = img
                     s["type"]= self.stream_type(s["url"])
                     s["lang"] = lang2
-                    streams.append(s)  
+                    streams.append(s)
             return streams
         else:
             return []
 
-                    
+
 if __name__ == "__main__":
     country= "lv"
     c = Source(country)

sources/config.py

         self.read_streams()
 
     def get_content(self, data):
+        print "[config] get_content",data
         self.read_streams()
         if "::" in data:
             data = data.split("::")[1]

sources/euronews.py

 from collections import OrderedDict
 from SourceBase import SourceBase
 import util
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
 
 headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
 import HTMLParser

sources/filmix.py

 import base64
 from collections import OrderedDict
 import sys
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
 try:
     import util
 except:
                 for i,ep in enumerate(js["playlist"]):
                     title = title0 +" - "+js["playlist"][i]["comment"].encode("utf8")
                     serie = js["playlist"][i]["comment"].encode("utf8")
-                    data2 = data+"?s=%s"%(i+1)
+                    if "file" in ep and ep["file"]:
+                        data2 = data+"?e=%s"%(i+1)
+                    else:
+                        data2 = data+"?s=%s"%(i+1)
                     desc = serie +"\n"+desc0
                     content.append((title,self.name+"::"+data2,img,desc))
             return content
 
     def is_video(self,data):
         source,data,path,plist,clist,params,qs = self.parse_data(data)
-        if clist == "play" and "s=" in data and "e=" in data:
+        if clist == "play" and "e=" in data:
             return True
         elif clist=="play" and not params:
             r = self.call(path)
             js = self._http_request(pl_link)
             js = self.decode_uppod_text(js)
             js = json.loads(js)
-            if "s" in qs and "e" in qs:
-                s = int(qs["s"])
+            if "e" in qs:
+                if "s" in qs:
+                    s = int(qs["s"])
+                else:
+                    s = None
                 e = int(qs["e"])
-                serie = js["playlist"][s-1]["playlist"][e-1]["comment"].encode("utf8")
-                title = title0+" - "+ serie
-                url0 = js["playlist"][s-1]["playlist"][e-1]["file"].encode("utf8")
+                if s: # sezona + epizode
+                    serie = js["playlist"][s-1]["playlist"][e-1]["comment"].encode("utf8")
+                    title = title0+" - "+ serie
+                    url0 = js["playlist"][s-1]["playlist"][e-1]["file"].encode("utf8")
+                else: # tikai epizode, nav sezonas
+                    title = title0 +" - "+js["playlist"][e-1]["comment"].encode("utf8")
+                    serie = js["playlist"][e-1]["comment"].encode("utf8")
+                    url0 = js["playlist"][e-1]["file"].encode("utf8")
                 streams2 = self.get_streams2(url0)
                 for st in streams2:
                     stream = util.item()

sources/filmon.py

 import urllib2, urllib
 import datetime, re, sys
 from SourceBase import SourceBase
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
 
 API_URL = 'http://www.filmon.com/'
 headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
     def get_content(self, data):
         print "[filmon] get_content:", data
         if "::" in data:
-            data = data.split("::")[1] 
+            data = data.split("::")[1]
         path = data.split("?")[0]
         clist = path.split("/")[0]
         params = data[data.find("?"):] if "?" in data else ""
         ### TV group channels ###
         elif clist=="group":
             if "id" in qs:
-                group_id = qs["id"] 
+                group_id = qs["id"]
             else:
                 return content
             group = None
         ### TV Channel ###
         elif clist == "channel" or clist == "video":
             if "id" in qs:
-                ch_id = qs["id"] 
+                ch_id = qs["id"]
             else:
                 return ("No stream found %s"%data,"","","No stream found")
             ch = self.get_tv_channel_info(ch_id)
                 img = gr["images"][0]["url"].encode("utf8")
                 desc = gr["description"].encode("utf8") if gr["description"] else title
                 content.append((title,self.name+"::"+data2,img,desc))
-            return content           
+            return content
 
         ### VOD genre videos ###
         elif path == "vod/search":
             if start_index+js["total"]<js["total_found"]:
                 start_index += 30
                 data2 = re.sub("start_index=\d+","start_index=%s"%start_index,data) if "start_index" in qs else data +"&start_index=30"
-                content.append(("Next page",self.name+"::"+data2,"","Next page"))                                            
+                content.append(("Next page",self.name+"::"+data2,"","Next page"))
             return content
 
         ### VOD video sigle/series ###

sources/iplayer.py

 from SourceBase import SourceBase, stream_type
 import util
 from collections import OrderedDict
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
 
 API_URL = 'https://m.lattelecom.tv/'
 user_agent = "Mozilla/5.0 (iPhone; U; CPU iPhone OS 5_1_1 like Mac OS X; da-dk) AppleWebKit/534.46.0 (KHTML, like Gecko) CriOS/19.0.1084.60 Mobile/9B206 Safari/7534.48.3"
             return r.content
 
         except Exception as ex:
-            if ex.code==403:
+            if "code" in dir(ex) and ex.code==403:
                 return ex.read()
             else:
                 return None

sources/lmt.py

 import requests
 import datetime, re, sys,os
 import ConfigParser
-from collections import OrderedDict
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
+
 from SourceBase import SourceBase
+
 import resolver
 try:
     import util
             stream["desc"] = desc
             stream["resolver"] = "lmt"
             return [stream]
-        elif re.search('src="http*://www.youtube.com/embed/(\w+).*"',r):
-            m = re.search('src="http*://www.youtube.com/embed/(\w+).*"',r)
+        elif re.search('src="http*://www.youtube.com/embed/([\w-]+).*"',r):
+            m = re.search('src="http*://www.youtube.com/embed/([\w-]+).*"',r)
             video_id = m.group(1)
             #http://www.youtube.com/embed/RUyQ_JJ6A84?rel=0&fs=1&wmode=transparent
             data2 = YouTubeVideoUrl().extract(video_id)

sources/ltc.py

 from SourceBase import SourceBase, stream_type
 import util
 from collections import OrderedDict
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
 
 API_URL = 'https://m.lattelecom.tv/'
 user_agent = "Mozilla/5.0 (iPhone; U; CPU iPhone OS 5_1_1 like Mac OS X; da-dk) AppleWebKit/534.46.0 (KHTML, like Gecko) CriOS/19.0.1084.60 Mobile/9B206 Safari/7534.48.3"
 
     def get_content(self, data):
         print "[ltc] get_content:", data
-        if "::" in data:
-            data = data.split("::")[1]
-        path = data.split("?")[0]
-        clist = path.split("/")[0]
-        params = data[data.find("?"):] if "?" in data else ""
-        qs = dict(map(lambda x:x.split("="),re.findall("\w+=[\w-]+",params)))
-        #lang = qs["lang"] if "lang" in qs else self.country
+        source, data, path, plist, clist, params, qs = self.parse_data(data)
 
         content=[]
         content.append(("..return", "back","","Return back"))
                 data2 = item["url"][1:].encode("utf8")
                 if data2[-1]=="/": data2=data2[:-1]
                 if "/raidijumi/" in data2:
-                    data2 += "?series"
+                    data2 += "?series" # TODO
                 img = "https://www.lattelecom.tv"+item["image"].encode("utf8")
                 desc = "%s\n%s"%(title,item["genre"].encode("utf8"))
                 content.append((title,self.name+"::"+data2,img,desc))
             return content
 
         ### Sērijas
-        elif clist=="videonoma" and  params=="?series":
+        elif clist=="videonoma" and  (params=="?series" or "season_nr" in qs):
             url = "https://www.lattelecom.tv/"+path
             r = self._http_request(url,headers=self.headers2)
             if not r:
                 return content
             m = re.search('<div class="movie_details"><div class="movie_titles"><div class="en">([^<]+?)</div>', r, re.DOTALL | re.IGNORECASE)
             raidijums = m.group(1) + " - " if m else ""
+            img0 = re.search('<meta name="og:image" content="([^"]+)">', r).group(1) if re.search('<meta name="dr:say:img" content="([^"]+)">', r) else ""
+
+            m = re.search('<ul class="episode_choiser".+?(<li>[^<]+</li>)+</ul>', r)
+            if m and not "season_nr" in qs: # ir sezonas
+                for s,it in enumerate(re.findall('<li>([^<]+)</li>', m.group())):
+                    title = "%s%s" % (raidijums, it)
+                    se = re.search("(\d+)",it).group(1)
+                    data2 = path+"?season_nr=%s"%(se)
+                    img = img0
+                    desc = title
+                    content.append((title, self.name + "::" + data2, img, desc))
+                return content
+
             m = re.search('data-bid="([^"]+)',r)
             if m:
-                url = "https://www.lattelecom.tv/episode-loader.json?bcast_ids=%s"%(m.group(1))
+                if not "season_nr" in qs:
+                    qs["season_nr"]="0"
+                url = "https://www.lattelecom.tv/episode-loader.json?bcast_ids=%s&season_nr=%s"%(m.group(1),qs["season_nr"])
                 r = self._http_request(url,headers=self.headers2)
                 i1 = r.find('{"total":')
                 i2 = r.find('}<div class=')
                     desc = title
             elif vtype == "record-streams":
                 epg = self.get_epg_id(vid)
-                title = epg["title"].encode("utf8")
-                t1 = datetime.datetime.fromtimestamp(int(epg["unix_start"])).strftime('%H:%M')
-                t2 = datetime.datetime.fromtimestamp(int(epg["unix_stop"])).strftime('%H:%M')
-                date = epg["date"]
-                title = "%s (%s %s-%s)"%(title,date,t1,t2)
-                desc = epg["description"]
+                if epg:
+                    title = epg["title"].encode("utf8")
+                    t1 = datetime.datetime.fromtimestamp(int(epg["unix_start"])).strftime('%H:%M')
+                    t2 = datetime.datetime.fromtimestamp(int(epg["unix_stop"])).strftime('%H:%M')
+                    date = epg["date"]
+                    title = "%s (%s %s-%s)"%(title,date,t1,t2)
+                    desc = epg["description"]
+                else:
+                    title = desc = data
 
             streams = []
             for s in r["data"]:
             self.epg_id={}
             self.epg_id2={}
             self.epg_date={}
-            slef.epg_ch={}
+            self.epg_ch={}
             self.epg_cat={}
         if not date in self.epgdates:
             r=self.call("tv/epg/?daynight=%s"%date)

sources/movieplace.py

 import ConfigParser
 from collections import OrderedDict
 from SourceBase import SourceBase
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
 import resolver
 try:
     import util

sources/mtgplay.py

 # coding=utf8
 import urllib2, urllib
 import datetime, re, sys
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
 from SourceBase import SourceBase
 
 API_URL = 'http://playapi.mtgx.tv/v3/'
 
 
 class Source(SourceBase):
-    
+
     def __init__(self,country="lv",cfg_path=None):
         self.name = "mtgplay"
         self.title = "Skaties.lv (TV3)"
         self.img = "http://skaties.lv/touch-icon-192x192.png"
         self.desc = "MTG skaties.lv satura skatīšanās (LNT,TV3, TV6 u.c.)"
-        
+
         self.country=country
         self.pic_size = "327x250" #"1000x765"
-        
+
     def get_content(self, data):
         print "[mtgplay] get_content:", data
         if "::" in data:
-            data = data.split("::")[1]        
+            data = data.split("::")[1]
         if "/" in data:
             citem,cid = data.split("/")
             clist = ""
             qs = dict(map(lambda x:x.split("="),re.findall("\w+=\w+",data)))
             citem,cid = ("","")
             self.country = qs["country"] if "country" in qs else "lv"
-        
+
         content=[]
         content.append(("..return", "back","","Return back"))
-        
+
         if clist=="home":
             content.extend([
-                #("Search", "mtgplay::meklet?country=%s&term={0}"%self.country,"","Search videos"), ### TODO                
+                #("Search", "mtgplay::meklet?country=%s&term={0}"%self.country,"","Search videos"), ### TODO
                 ("TV Live", "mtgplay::videos?country=%s&order=title&type=live"%self.country,"","TV live streams(not always available)"),
                 ("Last videos", "mtgplay::videos?country=%s&order=-airdate"%self.country,"","Last aired videos"),
                 ("Categories", "mtgplay::categories?country=%s&order=name"%self.country,"","Categories"),
                 ("Channels", "mtgplay::channels?country=%s&order=id"%self.country,"","TV channels"),
-                ("Programs by name", "mtgplay::formats?country=%s&order=-title"%self.country,"","Programs by name"),             
-                ("Programs by popularity", "mtgplay::formats?country=%s&order=-popularity"%self.country,"","Programs by popularity")             
+                ("Programs by name", "mtgplay::formats?country=%s&order=-title"%self.country,"","Programs by name"),
+                ("Programs by popularity", "mtgplay::formats?country=%s&order=-popularity"%self.country,"","Programs by popularity")
             ])
             return content
-        
+
         r = self.call(data)
         if not r:
             content.append(("Error", "","","Error reading '%s'"%data))
             return content
-        
+
         if clist:
             if r["_links"].has_key("prev"):
                 data2 = r["_links"]["prev"]["href"].replace(API_URL,"")
                 content.append(("Previous page", self.name+"::"+data2.encode("utf8"),"", "Goto previous page"))
-                
+
             if "_embedded" in r:
                 for item in r["_embedded"][clist]:
                     if "title" in item:
                         title = item["title"]
                     elif "name" in item:
                         title = item["name"]
-                    #data2 = self.name+"::"+"%s/%s"%(clist,item["id"]) 
+                    #data2 = self.name+"::"+"%s/%s"%(clist,item["id"])
                     img = item["_links"]["image"]["href"].replace("{size}",self.pic_size) if "image" in item["_links"] else ""
                     desc = item["summary"] if "summary" in item and item["summary"] else ""
-                    
+
                     ### Video ###
                     if clist=="videos":
-                        data2 = "videos/%s"%item["id"]                            
+                        data2 = "videos/%s"%item["id"]
                         summary = item["summary"] if item["summary"] else ""
                         air_at = item["broadcasts"][0]["air_at"] if "broadcasts" in item and len(item["broadcasts"])>0 and "air_at" in item["broadcasts"][0] else ""
                         if not air_at:
                             views = views+" views"
                         except: views = ""
                         desc = "Aired: %s %s\nDuration: %s %s\n\n%s"%(air_at, playable_to,duration,views,summary)
-                        
-                    ### Categories ###     
+
+                    ### Categories ###
                     elif clist == "categories":
                         #data2 = item["_links"]["formats"]["href"].replace(API_URL,"")
                         data2 = "formats?category=%s"%item["id"]
                         if "category" in qs: data2 += "&category="+qs["category"]
                         if "channel" in qs: data2 += "&channel="+qs["channel"]
                         data2 += "&order=title"
-                        
-                    ### Channels ###     
+
+                    ### Channels ###
                     elif clist == "channels":
                         #data2 = item["_links"]["categories"]["href"].replace(API_URL,"")
                         data2 = "categories?channel=%s"%item["id"]
                         if "category" in qs: data2 += "&category="+qs["category"]
                         if "channel" in qs: data2 += "&channel="+qs["channel"]
                         data2 += "&order=name"
-                        
-                    ### Formats (programs) ###     
+
+                    ### Formats (programs) ###
                     elif clist == "formats":
                         #data2 = item["_links"]["videos"]["href"].replace(API_URL,"")
                         data2 = "seasons?format=%s"%item["id"]
                         air_at = item["latest_video"]["publish_at"] if "publish_at" in item["latest_video"] else ""
                         air_at = air_at[0:16].replace("T"," ") if air_at else ""
                         if air_at:
-                            desc = "Last video: %s\n"%air_at + desc                        
-                        
-                    ### Seasons ###     
+                            desc = "Last video: %s\n"%air_at + desc
+
+                    ### Seasons ###
                     elif clist == "seasons":
                         #data2 = item["_links"]["videos"]["href"].replace(API_URL,"")
                         data2 = "videos?season=%s"%item["id"]
                         #if "category" in qs: data2 += "&category="+qs["category"]
                         #if "channel" in qs: data2 += "&channel="+qs["channel"]
                         data2 += "&order=title"
-                        
+
                         summary = item["summary"] if "summary" in item and item["summary"] else ""
                         try:
                             latest_video = item["latest_video"]["publish_at"]
                             latest_video = latest_video[0:16].replace("T"," ")
                         except: latest_video = ""
                         desc = ("%s\nLatest video: %s"%(summary,latest_video))
-                                      
+
                     content.append((title.encode("utf8"),self.name+"::"+data2.encode("utf8"),img.encode("utf8"),desc.encode("utf8")))
-                    
+
             if r["_links"].has_key("next"):
                 data2 = r["_links"]["next"]["href"].replace(API_URL,"").encode("utf8")
                 content.append(("Next page", self.name+"::"+data2.encode("utf8"),"","Goto next page"))
-                
+
         elif citem:
             item = r
             if "title" in item:
                 title = item["title"]
             elif "name" in item:
                 title = r["name"]
-            #data2 = self.name+"::"+"%s/%s"%(clist,item["id"]) 
+            #data2 = self.name+"::"+"%s/%s"%(clist,item["id"])
             img = item["_links"]["image"]["href"].replace("{size}",self.pic_size) if "image" in item["_links"] else ""
             desc = item["summary"] if "summary" in item and item["summary"] else ""
-            
+
             dd = "videos/stream/%s"%cid
             r2 = self.call(dd)
             if "streams" in r2 and "hls" in r2["streams"]:
                 content = (title.encode("utf8"),data2.encode("utf8"),img.encode("utf8"),desc.encode("utf8"))
             elif "msg" in r2:
                 content = (r2["msg"].encode("utf8"),"","","")
-            else: 
-                content = ("Error getting stream","","","")            
-            
+            else:
+                content = ("Error getting stream","","","")
+
         else:
             pass
         return content
-    
+
     def is_video(self,data):
         if "::" in data:
             data = data.split("::")[1]
             return True
         else:
             return False
-    
-    def get_stream(self,id):   
+
+    def get_stream(self,id):
         dd = "videos/stream/%s"%id
         r2 = self.call(dd)
         if "streams" in r2 and "hls" in r2["streams"]:
         else:
             data2 = ""
         return data2.encode("utf8")
-        
+
     def call_all(self, endpoint, params = None):
         url = API_URL % (endpoint)
         if params:
                 url = content["_links"]["next"]["href"]
             else: break
         return result
-    
+
     def call(self, data,headers=headers0):
         url = API_URL + data
         #print "[TVPlay Api] url: ",url

sources/play24.py

 
 import urllib2, urllib
 import datetime, re, sys
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
 from SourceBase import SourceBase
 
 API_URL = 'http://replay.lsm.lv/'
 """)
 import HTMLParser
 h = HTMLParser.HTMLParser()
-    
+
 class Source(SourceBase):
-    
+
     def __init__(self,country="lv",cfg_path=None):
         self.name = "play24"
         self.title = "Play24.lv"
         self.img = "http://play24.lv/images/play24-logo-black.png"
         self.desc = "play24.lv (Riga24TV) satura skatīšanās"
-        
+
         self.country=country
-        
+
     def get_content(self, data):
         print "[play24] get_content:", data
         if "::" in data:
-            data = data.split("::")[1] 
+            data = data.split("::")[1]
         path = data.split("?")[0]
         clist = path.split("/")[0]
         params = data[data.find("?"):] if "?" in data else ""
         qs = dict(map(lambda x:x.split("="),re.findall("\w+=\w+",params)))
         lang = qs["lang"] if "lang" in qs else self.country
-    
+
         content=[]
         content.append(("..return", "back","","Return back"))
-        
+
         if clist=="home":
             content.extend([
                 ("Live stream", "play24::tiesraide","","TV live streams"),
                 ("Last videos", "play24::jaunakie","","Last videos"),
                 ("Categories", "play24::kategorijas","","Categories"),
-                ("Programs", "play24::raidijumi","","Programs"),             
+                ("Programs", "play24::raidijumi","","Programs"),
              ])
             return content
-  
+
         ### Jaunākie video ###
         elif clist=="jaunakie":
             url = "http://play24.lv/"
                 desc = title
                 content.append((title,self.name+"::"+data2,img,desc))
             return content
-                
+
         ### Kategorijas ###
         elif clist=="kategorijas":
             url = "http://play24.lv/"
                 desc = title
                 content.append((title,self.name+"::"+data2,img,desc))
             return content
-       
+
         elif clist=="kategorija":
             url = "http://play24.lv/"+data
             r = self._http_request(url)
                 progr = m.group(2) if m else ""
                 m = re.search('<span class="masonry-item__date">([^<]+)</span>', article, re.DOTALL)
                 date = m.group(1).strip() if m else ""
-                         
+
                 if date:
                     title = title + " (%s %s)"%(date,progr)
                 desc = title + "\n%s - %s"%(progr,date)
             m = re.search(r'<li><a href="http://play24\.lv/([^"]+)" rel="next">&raquo;</a></li>', r, re.DOTALL)
             if m:
                 data2 = m.group(1)
-                content.append(("Next page",self.name+"::"+data2,"","Next page"))                                            
+                content.append(("Next page",self.name+"::"+data2,"","Next page"))
             return content
-        
+
         ### Raidijumi (programmas)
         elif clist=="raidijumi":
             url = "http://play24.lv/"
             m = re.search(r'<li><a href="http://play24\.lv/([^"]+)" rel="next">&raquo;</a></li>', r, re.DOTALL)
             if m:
                 data2 = m.group(1)
-                content.append(("Next page",self.name+"::"+data2,"","Next page"))                                            
+                content.append(("Next page",self.name+"::"+data2,"","Next page"))
             return content
 
         elif clist == "video" or clist == "tiesraide":
-            if clist == "video":  
+            if clist == "video":
                 url = "http://play24.lv/"+data
                 r = self._http_request(url)
                 # var ov_video_id = '59422';
                 m = re.search('<meta name="description" content="([^"]+)" />', r, re.DOTALL)
                 desc = m.group(1) if m else ""
                 desc = h.unescape(desc.decode("utf8")).encode("utf8")
-                
+
                 url = "http://player.tvnet.lv/v/%s"%id
             else:
                 url = "http://player.tvnet.lv/l/11"
                 desc = ""
             r = self._http_request(url)
             m = re.search('<h1 class="static title">.+?<a href="[^"]+">([^<]+)</a>', r, re.DOTALL)
-            title = m.group(1) if m else ""   
+            title = m.group(1) if m else ""
             s = {}
             for item in re.findall('source src="([^"]+)" data-stream="([^"]+)" data-quality="([^"]+)"', r, re.DOTALL):
                 s[item[1]] = (item[0],item[2])
                     data2 = s[t][0]
                     break
             return (title,data2,"",desc)
-               
-    
+
+
     def is_video(self,data):
         if "::" in data:
             data = data.split("::")[1]
             return True
         else:
             return False
-    
+
     def call(self, data,headers=headers0,lang=""):
         if not lang: lang = self.country
         url = API_URL%lang + data

sources/replay.py

 
 import urllib2, urllib
 import datetime, re, sys
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
 from SourceBase import SourceBase
 import util
 
                     content=("No stream found %s"%data,"","","No stream found")
                     return content
                 data2 = m.group(1).replace("\\","")
+                #r = self._http_request(data2, headers=headers)
 
             else: # audio
                 lrn = ch.replace("lr","")

sources/serialguru.py

 import urllib2, urllib
 import datetime, re, sys,os
 import ConfigParser
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
 from SourceBase import SourceBase
 
 headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])

sources/streams.cfg

 Shortcut (lattelecom.tv)|ltc::home|https://kursors.lv/wp-content/uploads/2016/07/Shortcut-logo.png|lattelecom TV, arhīves un video
 Play24.lv (Riga24TV)|play24::home|http://play24.lv/images/play24-logo-black.png|play24.lv (Riga24TV)tiešraide un arhīvs
 viaplay.lv|viaplay::home|https://yt3.ggpht.com/-noVdjbNR-V8/AAAAAAAAAAI/AAAAAAAAAAA/yZ9XNP5urLY/s900-c-k-no-mo-rj-c0xffffff/photo.jpg|Viaplay.lv - filmas latviešu, krievu u.c. valodās
-LMT straume|lmt::home|http://www.lob.lv/images/logo/lmt_straume_vert_rgb.png|LMT straume - dažādi video latviesu valodā
 TVDom.tv|tvdom::home|https://tvdom.tv/front/assets/images/logo.png|PBK tiešraides un arhīvs
 BBC iPlayer|iplayer::home|http://www.userlogos.org/files/logos/inductiveload/BBC_iPlayer_logo.png|BBC live streams and arhive
 Euronews|euronews::home|http://pbs.twimg.com/profile_images/732665354242150400/tZsCnjuh_400x400.jpg|Euronews live streams and archive
 FilmOn|filmon::home|http://behindthegloves.com/wp-content/uploads/2016/01/FilmOn-logo1.jpg|FilmOn - tiešraides un video (dažādās valodās)
 MTGPlay|config::mtg|https://www.mtg.com/wp-content/uploads/2015/11/MTG-Logo-Medium-Red-PNG.png|Other countries MTG media portals content
 Filmas.lv|filmas::home|https://www.filmas.lv/wp-content/uploads/2013/06/LVfilmas-logo-jauns21.png|Filmas.lv - Latvijas filmas
-
+LMT straume|lmt::home|http://www.lob.lv/images/logo/lmt_straume_vert_rgb.png|LMT straume - dažādi video latviesu valodā
 
 [my_tv]
 My Tv

sources/tvdom.py

     import json
 except:
     import simplejson as json
-
 import urllib2, urllib
 import datetime, re, sys,os
 from collections import OrderedDict
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
 from SourceBase import SourceBase
 
 API_URL = 'http://replay.lsm.lv/'

sources/ustvnow.py

     import json
 except:
     import simplejson as json
-
 import urllib2, urllib
 import datetime, re, sys,os
 import traceback
 from collections import OrderedDict
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
 from SourceBase import SourceBase
 
 headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])

sources/viaplay.py

 import urlparse, urllib
 import datetime, time,re, sys,os
 from collections import OrderedDict
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
 from SourceBase import SourceBase
 try:
     import util
                         #headers = {"Cookie":r2.headers["set-cookie"]}
                     #else:
                         #headers={}
-                    url2p=util.streamproxy_encode(url2,headers)
+                    #url2p=util.streamproxy_encode(url2,headers)
                     stream = util.item()
-                    stream["url"]=url2p
+                    stream["url"]=url2
                     stream["lang"]=s["lang"]
                     stream["quality"]="%s"%(s2[1])
                     stream["name"]= title

util.py

 EQ_CODE = urllib.quote("=")
 COL_CODE = urllib.quote(":")
 SPACE_CODE = urllib.quote(" ")
-PROXY_URL = "http://localhost:88/"
-
 
 def make_fname(title):
     "Make file name from title"
     fname0 = re.sub("['""]","",fname0)
     return fname0
 
-
 def hls_base(url):
     url2 = url.split("?")[0]
     url2 = "/".join(url2.split("/")[0:-1])+ "/"
 def stream_change(stream):
     #return stream # TODO
     if "resolver" in stream and stream["resolver"] in ("viaplay","hqq","filmas") or \
-        "surl" in stream and re.search("https*://(hqq|goo.\gl)",stream["surl"]):
+        "surl" in stream and re.search("https*://(hqq|goo\.gl)",stream["surl"]):
         stream["url"] = streamproxy_encode(stream["url"],stream["headers"])
         stream["headers"] = {}
         return stream
     else:
         return stream
 
-def streamproxy_encode(url,headers=[]):
+def streamproxy_encode(url,headers=[],proxy_url=None):
+    PROXY_URL = "http://localhost:8880/"
     if not "?" in url:
         url = url+"?"
     url2 = url.replace(SPLIT_CHAR,SPLIT_CODE).replace(":",COL_CODE).replace(" ",SPACE_CODE)
-    url2 = PROXY_URL + url2
+    if not proxy_url:
+        proxy_url = PROXY_URL
+    url2 = proxy_url + url2
     if headers:
         headers2 = []
         for h in headers:
             headers2.append("%s=%s"%(h,headers[h].replace("=",EQ_CODE).replace(SPLIT_CHAR,SPLIT_CODE).replace(" ",SPACE_CODE)))
         headers2 = SPLIT_CHAR.join(headers2)
         url2 = url2+SPLIT_CHAR+headers2
+    #return url2.encode("utf8") if isinstance(url2,unicode) else url2
     return url2
 
 def streamproxy_decode(urlp):
             headers[h.split("=")[0]]=urllib.unquote(h.split("=")[1])
     return url,headers
 
+def streamproxy_encode2(url,headers=[],proxy_url=None):
+    PROXY_URL = "http://localhost:8880/"
+    #url2 = url.replace(SPLIT_CHAR,SPLIT_CODE).replace(":",COL_CODE).replace(" ",SPACE_CODE)
+    url2 = urllib.quote_plus(url)
+    if not proxy_url:
+        proxy_url = PROXY_URL
+    url2 = proxy_url + url2+"/?"
+    if headers:
+        headers2 = []
+        for h in headers:
+            headers2.append("%s=%s"%(h,headers[h].replace("=",EQ_CODE).replace(SPLIT_CHAR,SPLIT_CODE).replace(" ",SPACE_CODE)))
+        headers2 = SPLIT_CHAR.join(headers2)
+        url2 = url2+SPLIT_CHAR+headers2
+    return url2
+
+def streamproxy_decode2(urlp):
+    path = urlp.replace(re.search("http://[^/]+",urlp).group(0),"")
+    p = path.split(SPLIT_CHAR)
+    url = urllib.unquote_plus(p[0][1:-2])
+    #headers = {"User-Agent":"Mozilla/5.0 (iPhone; CPU iPhone OS 9_2 like Mac OS X) AppleWebKit/601.1 (KHTML, like Gecko) CriOS/47.0.2526.70 Mobile/13C71 Safari/601.1.46"}
+    headers={}
+    if len(p)>1:
+        for h in p[1:]:
+            #h = urllib.unquote()
+            headers[h.split("=")[0]]=urllib.unquote(h.split("=")[1])
+    return url,headers
+
 class Captions(object):
     def __init__(self,uri):
         self.uri = uri
     url = "http://str1e.lattelecom.tv/mobile-vod/mp4:sf_fantastic_beasts_and_where_to_find_them_en_hd.mp4/playlist.m3u8?resource_id=fantastic_beasts_and_where_to_find_them&auth_token=6NAvMFDG+rYTAc4hb5JeL2bmsaRR7bAE23M6KDmhKYOGyXoo0gDpJUE9scYy+nQmfbgk03cWMe9MuXWSH1GqwolEk2jOQ/8Mrg7tOdbwrA8zM7nmkfCZPqQkwajZN4mfSJQVKHqXqJ8="
     headers={}
     print url
-    urlp = streamproxy_encode(url,headers)
+    url = "replay::tiesraide/ltv1/"
+    url = "ltc::content/live-streams/103?include=quality"
+    urlp = streamproxy_encode2(url,headers)
     print urlp
-    url2,headers2 = streamproxy_decode(urlp)
-    #print url2 - 2
+    url2,headers2 = streamproxy_decode2(urlp)
+    print url2
     player(urlp)
     pass