sākotnējais komits

README.md

@@ -1,3 +1,69 @@
-# ltcproxy
+# ltcproxy - m3u8 playlist proxy for shortcut.lv 
+Eksponē permamentus m3u8 linkus (playlisti), ko var norādīt PerfectPlayer, Kodi vai kādai citai IPTV aplikācijai.
 
-m3u8 proxy for shortcut.lv streams
+Ļauj skatīties shortcut.lv uz jebkuras iekārtas klasiskās TV pieredzes formā. Var to darīt no vairākām iekārtām (proxy režīmā).
+
+Strādā arhīvs (ar PerfectPlayer, bet var teorētiski pielāgot arī citiem pleijeriem). 
+
+Nepieciešams derīgs shortcut.lv konts.
+
+Strādā jebkuŗā tīklā (tiek izmantots Android TV shortcut API).
+
+__Pagaidām ALFA versija__ (*proof of concept*, daudz vēl kas pietaisāms)!
+
+## Instalēšana
+1. Strādā uz jebkura datora, kur ir Python 2.7. Vislabāk  kāds Linux serveris, var arī uz Windows (nestrādās daemona režīms)
+   
+2. Lejupielādējam/atzipojam aktuālo versiju no http://git.blue.lv/home/ltcproxy vai noklonējam folderi ar `git clone http://git.blue.lv/home/ltcproxy` un uztaisam cd uz folderi.
+
+3. Uzinstalējam Python atkarības
+```
+pip install -r reqirments.txt
+```
+4. (Optional) Uzinstalējam "mīļāko" WSGI serveri - cheroot, waitress u.c. Skat. iespējamos variantus https://bottlepy.org/docs/dev/deployment.html. Defaultā strādas ar wsgiref, kas derēs mazām slodzēm. Piemēram, 
+```
+pip install cheroot
+```
+5. Sakonfigurējam ar redatoru `ltcproxy.cfg`
+   - `debug = False|True`  - papildus debug info 
+   - `port = 8881` - proxy ports
+   - `redirect = False` - ja True, tad veic vienkāršu pāradresāciju (302), citādi strādā kā proxy
+   - `cache = True` - kešo pieprasījumus (t.sk. video), lai lieki neraustītu shortcut.lv serveri un paātrinātu darbu   
+   - `key = 0000` - drošības kods, kas jānorāda url (skat ltc2.m3u9 piemēru)
+   - `wsgi = wsgiref|mtwsgi|cheroot|waitress...` - izmantojamais WSGI serveris (mtwsgi - multitredingots defaultais wsgi)
+   - `workers = n` - tredu skaits (atkarībā no izmantotā WSGI servera)
+   - `ltc_user = user` - shortcut.lv lietotājs
+   - `ltc_password = passowrd` - shortcut.lv parole
+  6. Piestartējam vai no `foreground` vai `daemon` (tikai uz linux) režīmā atticīgi (palaižot bez parametriem var redzēt iespējamās opcijas)
+```
+python ltcproxy.py manualstart
+python ltcproxy.py start
+```
+7. Ja `daemon` procesu vajag apstādināt vai pārstartēt
+```
+python ltcproxy.py stop
+python ltcproxy.py restart
+```
+8. Sagatavojam pleilisti. Paraugs ltc2.m3u8 ir folderī vai šeit http://epg.blue.lv/ltc2.m3u8. `localhost` aizvietojam ar servera `hostname`. Neaizmirtam ielikt pareizo key uzreiz pēc servera vārda. Kanāla paraugs (catchup tagi ir lai strādātu arhīvs PerfectPlayer)
+```
+ #EXTINF:0 group-title="Latvian" tvg-id="ltc101" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/ltv-1_70x70.png" 
+catchup="append" catchup-source="${start}/",LTV1
+http://hostname:8881/00000/live/101/
+```
+9. IPTV aplikācijā norādām sagatavoto playlisti, kā arī EPG linku. Pašreiz var izmantot http://epg.blue.lv/ltc.xml.gz. Paredzēts, ka nākotnē to eksponēs ltcproxy.
+10. Tas arī viss. Ja lieto kešu, tad vēlams 1x dienā pārstartēt (pārstartējot kešs nodzēšas). Ja iestrēgst kanāls, var mēģināt pārslēgties uz priekšu/atpakaļ. Ja nelīdz, tad jāpārstartē ltcproxy.
+    
+## Zināmās kļūdas/plāni
+- Ne līdz galam korekti nostrādā HEAD pieprasījumi (daži playeri pirms spēlēšanas nočeko ar HEAD, kas par strīma tipu). Šī iemesla dēļ šobrīd nestrādā uz Android TV Channels
+- Brīžiem pārlec uz priekšu atpakaļ par 5-10 sekundēm proxy režīmā (īsti nesaprotu iemeslu, varbūt kaut kāda shortcut strīmu īpatnība atjaunojot sesijas kukiju)
+- Plānā ir iespēja skatīties shortcut.lv filmas VOD playlista veidā
+- Plānā ir iespēja proxy režīmā izmantot citus (ne ltc strīmus)
+
+## Kļūdām/ierosmēm
+- Vislābāk reģistrējiet kļūdu http://git.blue.lv/home/ltcproxy
+- Var arī boot forumā
+
+
+Kaut kā tā,
+
+ivars777@gmail.com

changelog.md

@@ -0,0 +1,33 @@
+**06.10.2019**
+- salabots lmt.lv (facebook video)
+
+**08.07.2019**
+- izmaiņas GITā (autonoms projekts)
+
+**23.02.2019**
+- salabots tvdom
+- playstreamproxy servē strīmus priekš m3u8
+
+**23.12.2018**
+- salabots tvplay, filmix
+
+**05.12.2018**
+- pielabots ltc (arhīvu bildes, kārtība u.c.)
+
+**29.09.2018**
+- salabots TVPlay (raidījumi pa ketogorijām)
+
+**24.06.2018**:
+- salabots replay
+- sataisītas filmas.lv (nav downloada)
+
+**18.05.2018**:
+- salabots filmix domeins (tagad filmix.co)
+
+**10.04.2018**:
+- salaboti shortcut.lv videonomas saraksti
+
+**10.03.2018**:
+- filmix tulkojumi/strīmi salaboti (nerādīja visas sērijas u.c.)
+
+

daemonize.py

@@ -0,0 +1,287 @@
+#!/bin/env python
+'''
+***
+Modified generic daemon class
+***
+
+Author:
+                https://web.archive.org/web/20160305151936/http://www.jejik.com/articles/2007/02/a_simple_unix_linux_daemon_in_python/
+
+Modified by ivars777@gmail.com
+
+License:        http://creativecommons.org/licenses/by-sa/3.0/
+
+'''
+
+# Core modules
+from __future__ import print_function
+import atexit
+import errno
+import os
+import sys
+import time
+import signal
+
+
+class Daemon(object):
+    """
+    A generic daemon class.
+
+    Usage: subclass the Daemon class and override the run() method
+    """
+    def __init__(self, app, pidfile, stdin=os.devnull,
+                 stdout=os.devnull, stderr=os.devnull,
+                 home_dir='.', umask=0o22, verbose=1,
+                 use_gevent=False, use_eventlet=False):
+        self.app = app
+        self.stdin = stdin
+        self.stdout = stdout
+        self.stderr = stderr
+        self.pidfile = pidfile
+        self.home_dir = home_dir
+        self.verbose = verbose
+        self.umask = umask
+        self.daemon_alive = True
+        self.use_gevent = use_gevent
+        self.use_eventlet = use_eventlet
+
+    def log(self, *args):
+        if self.verbose >= 1:
+            print(*args)
+
+    def daemonize(self):
+        """
+        Do the UNIX double-fork magic, see Stevens' "Advanced
+        Programming in the UNIX Environment" for details (ISBN 0201563177)
+        http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
+        """
+        if self.use_eventlet:
+            import eventlet.tpool
+            eventlet.tpool.killall()
+        try:
+            pid = os.fork()
+            if pid > 0:
+                # Exit first parent
+                sys.exit(0)
+        except OSError as e:
+            sys.stderr.write(
+                "fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
+            sys.exit(1)
+
+        # Decouple from parent environment
+        os.chdir(self.home_dir)
+        os.setsid()
+        os.umask(self.umask)
+
+        # Do second fork
+        try:
+            pid = os.fork()
+            if pid > 0:
+                # Exit from second parent
+                sys.exit(0)
+        except OSError as e:
+            sys.stderr.write(
+                "fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
+            sys.exit(1)
+
+        if sys.platform != 'darwin':  # This block breaks on OS X
+            # Redirect standard file descriptors
+            sys.stdout.flush()
+            sys.stderr.flush()
+            si = open(self.stdin, 'r')
+            so = open(self.stdout, 'a+')
+            if self.stderr:
+                try:
+                    se = open(self.stderr, 'a+', 0)
+                except ValueError:
+                    # Python 3 can't have unbuffered text I/O
+                    se = open(self.stderr, 'a+', 1)
+            else:
+                se = so
+            os.dup2(si.fileno(), sys.stdin.fileno())
+            os.dup2(so.fileno(), sys.stdout.fileno())
+            os.dup2(se.fileno(), sys.stderr.fileno())
+
+        def sigtermhandler(signum, frame):
+            self.daemon_alive = False
+            sys.exit()
+
+        if self.use_gevent:
+            import gevent
+            gevent.reinit()
+            gevent.signal(signal.SIGTERM, sigtermhandler, signal.SIGTERM, None)
+            gevent.signal(signal.SIGINT, sigtermhandler, signal.SIGINT, None)
+        else:
+            signal.signal(signal.SIGTERM, sigtermhandler)
+            signal.signal(signal.SIGINT, sigtermhandler)
+
+        self.log("Started")
+
+        # Write pidfile
+        atexit.register(
+            self.delpid)  # Make sure pid file is removed if we quit
+        pid = str(os.getpid())
+        open(self.pidfile, 'w+').write("%s\n" % pid)
+
+    def delpid(self):
+        try:
+            # the process may fork itself again
+            pid = int(open(self.pidfile, 'r').read().strip())
+            if pid == os.getpid():
+                os.remove(self.pidfile)
+        except OSError as e:
+            if e.errno == errno.ENOENT:
+                pass
+            else:
+                raise
+
+    def start(self, *args, **kwargs):
+        """
+        Start the daemon
+        """
+
+        self.log("Starting...")
+
+        # Check for a pidfile to see if the daemon already runs
+        try:
+            pf = open(self.pidfile, 'r')
+            pid = int(pf.read().strip())
+            pf.close()
+        except IOError:
+            pid = None
+        except SystemExit:
+            pid = None
+
+        if pid:
+            message = "pidfile %s already exists. Is it already running?\n"
+            sys.stderr.write(message % self.pidfile)
+            sys.exit(1)
+
+        # Start the daemon
+        self.daemonize()
+        self.run(*args, **kwargs)
+
+    def stop(self):
+        """
+        Stop the daemon
+        """
+
+        if self.verbose >= 1:
+            self.log("Stopping...")
+
+        # Get the pid from the pidfile
+        pid = self.get_pid()
+
+        if not pid:
+            message = "pidfile %s does not exist. Not running?\n"
+            sys.stderr.write(message % self.pidfile)
+
+            # Just to be sure. A ValueError might occur if the PID file is
+            # empty but does actually exist
+            if os.path.exists(self.pidfile):
+                os.remove(self.pidfile)
+
+            return  # Not an error in a restart
+
+        # Try killing the daemon process
+        try:
+            i = 0
+            while 1:
+                os.kill(pid, signal.SIGTERM)
+                time.sleep(0.1)
+                i = i + 1
+                if i % 10 == 0:
+                    os.kill(pid, signal.SIGHUP)
+        except OSError as err:
+            if err.errno == errno.ESRCH:
+                if os.path.exists(self.pidfile):
+                    os.remove(self.pidfile)
+            else:
+                print(str(err))
+                sys.exit(1)
+
+        self.log("Stopped")
+
+    def restart(self):
+        """
+        Restart the daemon
+        """
+        self.stop()
+        self.start()
+
+    def get_pid(self):
+        try:
+            pf = open(self.pidfile, 'r')
+            pid = int(pf.read().strip())
+            pf.close()
+        except IOError:
+            pid = None
+        except SystemExit:
+            pid = None
+        return pid
+
+    def is_running(self):
+        pid = self.get_pid()
+
+        if pid is None:
+            self.log('Process is stopped')
+            return False
+        elif os.path.exists('/proc/%d' % pid):
+            self.log('Process (pid %d) is running...' % pid)
+            return True
+        else:
+            self.log('Process (pid %d) is killed' % pid)
+            return False
+
+    def run(self, *args, **kwargs):
+        """
+        Running app
+        """
+        self.app(*args, **kwargs)
+        #self.log("Starting foreground...")
+
+
+def main(cmd):
+    from datetime import datetime
+    from time import sleep
+    import subprocess
+    print("Starting cmd: ")
+    print(str(cmd))
+    subprocess.call(cmd)
+    #while True:
+    #    print(str(datetime.now()))
+    #    sleep(5)
+
+#def main2(cmd):
+#    from bottle import route, run
+
+#    @route('/')
+#    def index():
+#        return '<b>Hello </b>!'
+
+#    run(host='localhost', port=8080)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        cmd=sys.argv[2:]
+        app = cmd[0] if cmd else "daemonize2"
+        pid = "/var/run/%s.pid"%app
+        daemon = Daemon(main,pid)
+        if "start" == sys.argv[1]:
+            daemon.start(cmd)
+        elif "stop" == sys.argv[1]:
+            daemon.stop()
+        elif "restart" == sys.argv[1]:
+            daemon.restart()
+        elif "manualstart" == sys.argv[1]:
+            daemon.run(cmd)
+        elif "status" == sys.argv[1]:
+            daemon.is_running()
+        else:
+            print("Unknown command")
+            sys.exit(2)
+        sys.exit(0)
+    else:
+        print("usage: %s start|stop|restart|manualstart" % sys.argv[0])
+        sys.exit(2)

ltc2.m3u8

@@ -0,0 +1,137 @@
+#EXTM3U
+#EXTINF:0 group-title="Latvian" tvg-id="ltc101" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/ltv-1_70x70.png" catchup="append" catchup-source="${start}/",LTV1
+http://localhost:8881/00000/live/101/
+#EXTINF:0 group-title="Latvian" tvg-id="ltc102" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/LTV7_70x70.png" catchup="append" catchup-source="${start}/",LTV7
+http://localhost:8881/00000/live/102/
+#EXTINF:0 group-title="Latvian" tvg-id="ltc104" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/LNT_new.png" catchup="append" catchup-source="${start}/",LNT
+http://localhost:8881/00000/live/104/
+#EXTINF:0 group-title="Latvian" tvg-id="ltc103" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/tv3-app-70x70.png" catchup="append" catchup-source="${start}/",TV3
+http://localhost:8881/00000/live/103/
+#EXTINF:0 group-title="Latvian" tvg-id="ltc967" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/riga-tv-24_70x70.png" catchup="append" catchup-source="${start}/",RīgaTV 24
+http://localhost:8881/00000/live/967/
+#EXTINF:0 group-title="Latvian" tvg-id="ltc106" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/tv6.png" catchup="append" catchup-source="${start}/",TV6
+http://localhost:8881/00000/live/106/
+#EXTINF:0 group-title="Latvian" tvg-id="ltc608" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Kanals2_70x70.png" catchup="append" catchup-source="${start}/",Kanāls 2
+http://localhost:8881/00000/live/608/
+#EXTINF:0 group-title="Latvian" tvg-id="ltc107" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/3plus_70x70.png" catchup="append" catchup-source="${start}/",3+
+http://localhost:8881/00000/live/107/
+#EXTINF:0 group-title="Latvian" tvg-id="ltc924" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/ReTV_logo.png" catchup="append" catchup-source="${start}/",Re:TV
+http://localhost:8881/00000/live/924/
+#EXTINF:0 group-title="Latvian" tvg-id="ltc1069" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/stv-pirma_70x70.png" catchup="append" catchup-source="${start}/",STV Pirmā!
+http://localhost:8881/00000/live/1069/
+#EXTINF:0 group-title="Latvian" tvg-id="ltc1051" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/360-hd_70x70.png" catchup="append" catchup-source="${start}/",360TV
+http://localhost:8881/00000/live/1051/
+#EXTINF:0 group-title="Latvian" tvg-id="ltc1220" tvg-logo="https://manstv.lattelecom.tv/images/360hokejsapp-70x70.png" catchup="append" catchup-source="${start}/",360TV Hokejs HD
+http://localhost:8881/00000/live/1220/
+#EXTINF:0 group-title="Latvian" tvg-id="ltc1238" tvg-logo="https://manstv.lattelecom.tv/images/360_dinamo_70x70.png" catchup="append" catchup-source="${start}/",360TV Dinamo
+http://localhost:8881/00000/live/1238/
+#EXTINF:0 group-title="Russian" tvg-id="ltc108" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/PBK_70x70.png" catchup="append" catchup-source="${start}/",Pirmais Baltijas Kanāls
+http://localhost:8881/00000/live/108/
+#EXTINF:0 group-title="Russian" tvg-id="ltc110" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/NTV_mir_logo_new.png" catchup="append" catchup-source="${start}/",NTV Mir
+http://localhost:8881/00000/live/110/
+#EXTINF:0 group-title="Russian" tvg-id="ltc111" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Ren_TV_Baltic_logo.png" catchup="append" catchup-source="${start}/",REN Baltija
+http://localhost:8881/00000/live/111/
+#EXTINF:0 group-title="Russian" tvg-id="ltc977" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/dozhd_new.png" catchup="append" catchup-source="${start}/",Дождь
+http://localhost:8881/00000/live/977/
+#EXTINF:0 group-title="Russian" tvg-id="ltc1147" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/tht_70x70.png" catchup="append" catchup-source="${start}/",THT
+http://localhost:8881/00000/live/1147/
+#EXTINF:0 group-title="Russian" tvg-id="ltc1201" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/pjatnica_70x70.png" catchup="append" catchup-source="${start}/",THT4 International
+http://localhost:8881/00000/live/1201/
+#EXTINF:0 group-title="Russian" tvg-id="ltc1203" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/THT4_70x70.png" catchup="append" catchup-source="${start}/",Пятница International
+http://localhost:8881/00000/live/1203/
+#EXTINF:0 group-title="Russian" tvg-id="ltc109" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/RTR_Planeta_70x70.png" catchup="append" catchup-source="${start}/",RTR Planeta
+http://localhost:8881/00000/live/109/
+#EXTINF:0 group-title="Russian" tvg-id="ltc1236" tvg-logo="https://manstv.lattelecom.tv/" catchup="append" catchup-source="${start}/",Pjatij kanal
+http://localhost:8881/00000/live/1236/
+#EXTINF:0 group-title="Movies" tvg-id="ltc907" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/TV1000.png" catchup="append" catchup-source="${start}/",TV1000
+http://localhost:8881/00000/live/907/
+#EXTINF:0 group-title="Movies" tvg-id="ltc908" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/TV1000_Action.png" catchup="append" catchup-source="${start}/",TV1000 Action
+http://localhost:8881/00000/live/908/
+#EXTINF:0 group-title="Movies" tvg-id="ltc909" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/tv1000-russkoe-kino.png" catchup="append" catchup-source="${start}/",TV1000 Russkoje Kino
+http://localhost:8881/00000/live/909/
+#EXTINF:0 group-title="Movies" tvg-id="ltc203" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/fox.png" catchup="append" catchup-source="${start}/",FOX
+http://localhost:8881/00000/live/203/
+#EXTINF:0 group-title="Movies" tvg-id="ltc204" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/fox_life.png" catchup="append" catchup-source="${start}/",FOX Life
+http://localhost:8881/00000/live/204/
+#EXTINF:0 group-title="Movies" tvg-id="ltc1139" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Vip-comedy-70x70.png" catchup="append" catchup-source="${start}/",VIP Comedy
+http://localhost:8881/00000/live/1139/
+#EXTINF:0 group-title="Movies" tvg-id="ltc1188" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Filmzone_plus_70.png" catchup="append" catchup-source="${start}/",Filmzone+
+http://localhost:8881/00000/live/1188/
+#EXTINF:0 group-title="Movies" tvg-id="ltc1213" tvg-logo="https://manstv.lattelecom.tv/images/epic-drama_70x70px_SIZE.png" catchup="append" catchup-source="${start}/",Epic Drama HD (Skatītāju izvēle)
+http://localhost:8881/00000/live/1213/
+#EXTINF:0 group-title="Movies" tvg-id="ltc210" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Sony_Entertainm.png" catchup="append" catchup-source="${start}/",Sony Channel
+http://localhost:8881/00000/live/210/
+#EXTINF:0 group-title="Movies" tvg-id="ltc938" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Sony_Turbo_70x70.png" catchup="append" catchup-source="${start}/",Sony Turbo
+http://localhost:8881/00000/live/938/
+#EXTINF:0 group-title="News" tvg-id="ltc801" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/euronews_70x70.png" catchup="append" catchup-source="${start}/",Euronews ENG
+http://localhost:8881/00000/live/801/
+#EXTINF:0 group-title="News" tvg-id="ltc803" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Bbc_world_dark.png" catchup="append" catchup-source="${start}/",BBC World
+http://localhost:8881/00000/live/803/
+#EXTINF:0 group-title="Sport" tvg-id="ltc401" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Eurosport1.png" catchup="append" catchup-source="${start}/",Eurosport 1 HD
+http://localhost:8881/00000/live/401/
+#EXTINF:0 group-title="Sport" tvg-id="ltc402" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Eurosport2.png" catchup="append" catchup-source="${start}/",Eurosport 2 HD
+http://localhost:8881/00000/live/402/
+#EXTINF:0 group-title="Sport" tvg-id="ltc1055" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/setanta_sports_logo.png" catchup="append" catchup-source="${start}/",Setanta Sports HD
+http://localhost:8881/00000/live/1055/
+#EXTINF:0 group-title="Sport" tvg-id="ltc914" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Sportacentrs_70x70.png" catchup="append" catchup-source="${start}/",sportacentrs.com
+http://localhost:8881/00000/live/914/
+#EXTINF:0 group-title="Sport" tvg-id="ltc1021" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Best4sport_70x70.png" catchup="append" catchup-source="${start}/",Best4Sport TV
+http://localhost:8881/00000/live/1021/
+#EXTINF:0 group-title="Sport" tvg-id="ltc1218" tvg-logo="https://manstv.lattelecom.tv/images/app-70x70-2hd.png" catchup="append" catchup-source="${start}/",Best4sport TV-2
+http://localhost:8881/00000/live/1218/
+#EXTINF:0 group-title="Sport" tvg-id="ltc1219" tvg-logo="https://manstv.lattelecom.tv/images/app-70x70-extra.png" catchup="append" catchup-source="${start}/",Best4sport TV extra
+http://localhost:8881/00000/live/1219/
+#EXTINF:0 group-title="Sport" tvg-id="ltc1175" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/fight-sport_70x70.png" catchup="append" catchup-source="${start}/",Fight Sports
+http://localhost:8881/00000/live/1175/
+#EXTINF:0 group-title="Sport" tvg-id="ltc406" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/NBA_70x70.png" catchup="append" catchup-source="${start}/",NBA TV
+http://localhost:8881/00000/live/406/
+#EXTINF:0 group-title="Sport" tvg-id="ltc409" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/motorsportTV.png" catchup="append" catchup-source="${start}/",Motorsport.tv
+http://localhost:8881/00000/live/409/
+#EXTINF:0 group-title="Sport" tvg-id="ltc407" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/KHLTV_70x70.png" catchup="append" catchup-source="${start}/",KHL
+http://localhost:8881/00000/live/407/
+#EXTINF:0 group-title="Documentaries" tvg-id="ltc501" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/DiscoveryChannel_70x70.png" catchup="append" catchup-source="${start}/",Discovery Channel
+http://localhost:8881/00000/live/501/
+#EXTINF:0 group-title="Documentaries" tvg-id="ltc505" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Discovery_science_70x70.png" catchup="append" catchup-source="${start}/",Discovery Science
+http://localhost:8881/00000/live/505/
+#EXTINF:0 group-title="Documentaries" tvg-id="ltc503" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/446e_national_geographic_channel.png" catchup="append" catchup-source="${start}/",National Geographic
+http://localhost:8881/00000/live/503/
+#EXTINF:0 group-title="Documentaries" tvg-id="ltc513" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Travel_Channel_70x70.png" catchup="append" catchup-source="${start}/",Travel Channel
+http://localhost:8881/00000/live/513/
+#EXTINF:0 group-title="Documentaries" tvg-id="ltc1087" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/BBC_Earth_dark.png" catchup="append" catchup-source="${start}/",BBC Earth
+http://localhost:8881/00000/live/1087/
+#EXTINF:0 group-title="Documentaries" tvg-id="ltc502" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Animal-planet-hd_70x70.png" catchup="append" catchup-source="${start}/",Animal Planet HD
+http://localhost:8881/00000/live/502/
+#EXTINF:0 group-title="Documentaries" tvg-id="ltc1169" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/viasat_history_70.png" catchup="append" catchup-source="${start}/",Viasat History
+http://localhost:8881/00000/live/1169/
+#EXTINF:0 group-title="Documentaries" tvg-id="ltc507" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/ID_70x70.png" catchup="append" catchup-source="${start}/",Investigation Discovery
+http://localhost:8881/00000/live/507/
+#EXTINF:0 group-title="Documentaries" tvg-id="ltc506" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/TLC_70x70.png" catchup="append" catchup-source="${start}/",TLC
+http://localhost:8881/00000/live/506/
+#EXTINF:0 group-title="Documentaries" tvg-id="ltc1137" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/ohotairibalka-hd_70x70.png" catchup="append" catchup-source="${start}/",Ohotnik i Ribolov
+http://localhost:8881/00000/live/1137/
+#EXTINF:0 group-title="Documentaries" tvg-id="ltc508" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/dtx_tv_70.png" catchup="append" catchup-source="${start}/",DTX
+http://localhost:8881/00000/live/508/
+#EXTINF:0 group-title="Children" tvg-id="ltc951" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Kidzone_70x70.png" catchup="append" catchup-source="${start}/",Kidzone
+http://localhost:8881/00000/live/951/
+#EXTINF:0 group-title="Children" tvg-id="ltc302" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Nickelodeon_70x70.png" catchup="append" catchup-source="${start}/",Nickelodeon
+http://localhost:8881/00000/live/302/
+#EXTINF:0 group-title="Children" tvg-id="ltc303" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/JimJam_70x70.png" catchup="append" catchup-source="${start}/",Jim Jam
+http://localhost:8881/00000/live/303/
+#EXTINF:0 group-title="Children" tvg-id="ltc1095" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Nick_jr_new.png" catchup="append" catchup-source="${start}/",Nick Jr
+http://localhost:8881/00000/live/1095/
+#EXTINF:0 group-title="Music" tvg-id="ltc602" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/VH1_Europe_70x70.png" catchup="append" catchup-source="${start}/",VH1 Europe
+http://localhost:8881/00000/live/602/
+#EXTINF:0 group-title="Music" tvg-id="ltc601" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/mtv_europe.png" catchup="append" catchup-source="${start}/",MTV Europe
+http://localhost:8881/00000/live/601/
+#EXTINF:0 group-title="Music" tvg-id="ltc605" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/MuzikasVideo_70x70.png" catchup="append" catchup-source="${start}/",Mūzikas video
+http://localhost:8881/00000/live/605/
+#EXTINF:0 group-title="Music" tvg-id="ltc603" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/LatvijasSlagerkanals_70x70.png" catchup="append" catchup-source="${start}/",Latvijas Šlāgerkanāls
+http://localhost:8881/00000/live/603/
+#EXTINF:0 group-title="Music" tvg-id="ltc614" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/Mezzo_70x70.png" catchup="append" catchup-source="${start}/",Mezzo
+http://localhost:8881/00000/live/614/
+#EXTINF:0 group-title="Music" tvg-id="ltc1226" tvg-logo="https://manstv.lattelecom.tv/images/tht-music_70x70.png" catchup="append" catchup-source="${start}/",THT Music
+http://localhost:8881/00000/live/1226/
+#EXTINF:0 group-title="National" tvg-id="ltc806" tvg-logo="https://manstv.lattelecom.tv/images/01_Bildes/01_Kanalu_LOGO/RTL_70x70.png" catchup="append" catchup-source="${start}/",RTL
+http://localhost:8881/00000/live/806/
+#EXTINF:0 group-title="Other" tvg-id="ltc1233" tvg-logo="https://manstv.lattelecom.tv/images/svetki-2_70x70.png" catchup="append" catchup-source="${start}/",Noskaņojuma kanāls
+http://localhost:8881/00000/live/1233/

ltcproxy.cfg

@@ -0,0 +1,11 @@
+[ltcproxy]
+debug = False
+port = 8881
+redirect = False
+cache = True
+key = 0000
+wsgi = wsgiref
+workers = 10
+ltc_user = user
+ltc_password = passowrd
+

ltcproxy.py

@@ -0,0 +1,582 @@
+#!/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Shortcut.lv proxy server
+
+usage: %s start|stop|restart|manualstart [options]
+    -p PORT         - port number
+    -s WSGI_SERVER  - wsgi server - wsgiref,cheroot,mtwsgi,waitress...
+    -d              - debug printout
+    -r              - remote debug mode (ptvsd)"""
+    
+__version__ = "0.1a"
+
+import os, sys, time
+import urllib,urlparse, urllib2, requests
+from urllib import unquote, quote
+import re, json
+import ConfigParser, getopt
+import arrow
+from diskcache import Cache
+import daemonize
+import bottle
+from bottle import Bottle, hook, response, route, request, run
+
+cunicode = lambda s: s.decode("utf8") if isinstance(s, str) else s
+cstr = lambda s: s.encode("utf8") if isinstance(s, unicode) else s
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+
+headers0 = headers2dict("""
+User-Agent: Shortcut.lv v2.9.1 / Dalvik/1.6.0 (Linux; U; Android 4.4.2; SM-G900FD Build/KOT49H)
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
+""")
+url0 = "https://manstv.lattelecom.tv/api/v1.7/get/content/"
+
+cur_directory = os.path.dirname(os.path.realpath(__file__))
+cache_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "cache")
+if not os.path.exists(cache_dir):
+    os.mkdir(cache_dir)
+
+config = ConfigParser.ConfigParser()
+proxy_cfg_file = os.path.join(cur_directory, "ltcproxy.cfg")
+
+DEBUG = False
+PORT_NUMBER = 8881
+REDIRECT = False
+CACHE = True
+KEY = ["0000","1111"]
+SERVER = "wsgiref"
+WORKERS = 10
+LTC_USER = "user"
+LTC_PASSWORD = "password"
+
+if not os.path.exists(proxy_cfg_file):
+    config.add_section("ltcproxy")
+    config.set("ltcproxy", "debug", DEBUG)
+    config.set("ltcproxy", "port", PORT_NUMBER)
+    config.set("ltcproxy", "redirect", REDIRECT)
+    config.set("ltcproxy", "cache", CACHE)
+    config.set("ltcproxy", "key", " ".join(KEY))
+    config.set("ltcproxy", "wsgi", SERVER)
+    config.set("ltcproxy", "workers", WORKERS)
+    config.set("ltcproxy", "ltc_user", LTC_USER)
+    config.set("ltcproxy", "ltc_password", LTC_PASSWORD)
+    config.write(open(proxy_cfg_file, "w"))
+else:
+    config.read(proxy_cfg_file)
+    DEBUG = config.getboolean("ltcproxy", "debug")
+    PORT_NUMBER = config.getint("ltcproxy", "port")
+    REDIRECT = config.getboolean("ltcproxy", "redirect")
+    CACHE = config.getboolean("ltcproxy", "cache")
+    KEY = config.get("ltcproxy", "key").split(" ")
+    SERVER = config.get("ltcproxy", "wsgi")
+    WORKERS = config.getint("ltcproxy", "workers")
+    LTC_USER = config.get("ltcproxy", "ltc_user")
+    LTC_PASSWORD = config.get("ltcproxy", "ltc_password")
+
+s = Cache(cache_dir)
+app = Bottle()
+token = None
+
+########################################################################################
+
+@app.hook('before_request')
+def set_globals():
+    global s, headers0, token
+    key = request.path.split("/")[1]
+    if not key in KEY:
+        print "Error: Wrong key - %s"% key
+        raise bottle.HTTPError(500, "Wrong key")
+    s = Cache(cache_dir)
+    if "token" in s and s["token"]:
+        token = s["token"]
+    else:
+        token = login(LTC_USER, LTC_PASSWORD)
+        if token:
+            s.set("token", token, expire=3600*24*1) #  pēc 1d ekspirejas
+            print "** %s: token=%s" % (request.remote_addr,token)
+        else:
+            print "Can not login"
+            raise bottle.HTTPError(500, "Can not login")
+
+# @app.route('/playstream/<url:re:.*>')
+
+
+### Live playlist ###
+@app.route("/<key>/live/<ch>/")
+def get_live(key, ch):
+    global s, token, headers0
+    path0, rest = hls_split(request.url)
+    response.content_type = "application/x-mpegURL" # r.headers["content-type"] # 'application/vnd.apple.mpegurl' # application/x-mpegURL
+    if "c"+ch in s:
+        stream_url2 = s["c"+ch]
+        mediaid = s["m"+ch]
+        print "** %s: serving live playlist for %s (%s) from cache" % (request.remote_addr,path0,mediaid )
+    else:
+        stream_url2, mediaid = refresh_live_chunklist_url(ch)
+        print "** %s: getting ive playlist for %s (%s)" % (request.remote_addr,path0,mediaid )
+    stream_url2 += token
+
+    if REDIRECT:
+        bottle.redirect(stream_url2, 307)
+
+    for i in range(3):
+        r2 = requests.get(stream_url2,headers=headers0)
+        if r2.status_code == 200:
+            break
+        time.sleep(1)
+    else:
+        print "Error %s getting live chunklist %s"% (r2.status_code,stream_url2)
+        raise bottle.HTTPError(r2.status_code)
+    return r2.content
+
+### Live TS chunk ###
+@app.route("/<key>/live/<ch>/<tail>")
+def get_live_chunk(key, ch, tail):
+    global s, token, headers0
+    path0, rest = hls_split(request.url)
+    chid = re.search("resource_id=c-(\\w+)",rest).group(1)
+    chunkid = re.search("(\d+)\.ts", request.url).group(1)
+    path2 = ch + "/" +  chunkid
+    if CACHE and path2 in s:
+        print "** %s: serving live ts %s from cache" % (request.remote_addr,path2)
+        f = s.get(path2, read=True)
+        response.headers["Content-Type"] =  s[path2+"@"] #'video/MP2T'
+        response.headers["Content-Length"] = s[path2+"#"]
+        while True:
+            chunk = f.read(8192)
+            if not chunk:
+                break
+            yield chunk
+
+    else: #  no cache
+        if ch in s:
+            stream_url = s[ch]
+            mediaid= s["m"+ch]
+        else:
+            refresh_live_chunklist_url(ch)
+            if ch in s:
+                stream_url = s[ch]
+                mediaid= s["m"+ch]
+            else:
+                print "No stream_url %s in cache" % path0
+                raise bottle.HTTPError(500)
+        base0, rest0 = hls_base(stream_url)
+        rest2 = "media_%s_%s.ts?resource_id=c-%s&auth_token=app_" % (mediaid, chunkid, chid)
+        url = base0 + rest2 + token
+        url2 = hls_base(stream_url)[0] + rest
+        headers = dict(request.headers)
+        del headers["Host"]
+        # headers["Authorization"] = "Bearer " + token
+        print "** %s: getting live ts from %s(%s)- %s" % (request.remote_addr, path2, mediaid,url[:40])
+        if DEBUG:
+            print "=== Request headers ==="
+            print_headers(headers)
+        r = requests.get(url, stream=True, headers=headers0)
+        if r.status_code <> 200:
+            r = requests.get(url, stream=True, headers=headers0) # try once more
+            if r.status_code <> 200:
+                # Refresh chunklist
+                print "## %s: Refreshing chunklist/mediaid  for live channel %s" %(request.remote_addr, ch)
+                chunklist_url, mediaid = refresh_live_chunklist_url(ch)
+                rest2 = "media_%s_%s.ts?resource_id=c-%s&auth_token=app_" % (mediaid, chunkid, chid)
+                url = base0 + rest2 + token
+                url2 = chunklist_url + token
+                print "** %s: getting live ts from %s(%s)- %s" % (request.remote_addr, path2, mediaid,url[:40])
+                r = requests.get(url, stream=True, headers=headers0)
+                if r.status_code <> 200:
+                    print "Error %s opening stream \n%s" %(r.status_code,url)
+                    print url2
+                    raise bottle.HTTPError(r.status_code, "Error opening stream "+url)
+
+        content = ""
+        response.content_type = r.headers["content-type"] # 'application/vnd.apple.mpegurl' #
+        # response.headers.clear()
+        for k in r.headers:
+            response.headers[k] =  r.headers[k]
+        if DEBUG:
+            print "=== Response headers ==="
+            print_headers(response.headers)
+        for chunk in r.iter_content(chunk_size=8192):
+            if chunk:
+                content += chunk
+                yield chunk
+        if len(content) <> int(r.headers["content-length"]):
+            print "Content length problem"
+        if CACHE:
+            s.set(path2, content, expire=3600, read=True)
+            s.set(path2+"#", len(content), expire=3600, read=True)
+            s.set(path2+"@", r.headers["Content-Type"], expire=3600, read=True)
+
+### Archive playlist ###
+@app.route("/<key>/live/<ch>/<ts>/")
+def get_archive(key, ch, ts):
+    global s, token, headers0
+    path0, rest = hls_split(request.url)
+    start = int(ts) + 60 * 5
+    epg = get_epg(ch, start)
+    print "** %s: getting archive playlist for channel %s" % (request.remote_addr,path0)
+    if epg:
+        epgid = epg["id"]
+        epg_start = int(epg["attributes"]["unix-start"])
+        epg_stop = int(epg["attributes"]["unix-stop"])
+        epg_title = epg["attributes"]["title"]
+    else:
+        print "EPG not found"
+        raise bottle.HTTPError(500, "EPG not found")
+
+    stream_url = epg_get_stream_url(epgid)
+    if REDIRECT:
+        bottle.redirect(stream_url, 307)
+
+    # Getting chunklist
+    stream_url2, mediaid = refresh_epg_chunklist_url(stream_url)
+    r2 = requests.get(stream_url2)
+    if r2.status_code <> 200:
+        print "Error %s getting archive chunklist %s"% (r2.status_code,stream_url2)
+        raise bottle.HTTPError(r2.status_code)
+    result = re.findall(r"#EXTINF:([\d\.]+),\n(.+)", r2.content)
+    ll = 0
+    i = 0
+    for chunk_len, chunk_url in result:
+        ll += float(chunk_len)
+        if ll > (start - epg_start):
+            break
+        i += 1
+    result2 =result[i:]
+    content = re.search("(^.+?)#EXTINF", r2.content, re.DOTALL).group(1)
+    for chunk_len, chunk_url in result2:
+        content += "#EXTINF:%s,\n" % chunk_len
+        content += chunk_url + "\n"
+    content += "#EXT-X-ENDLIST"
+    response.content_type = r2.headers["content-type"] # 'application/vnd.apple.mpegurl' #
+    return content
+
+
+def live_get_stream_url(ch):
+    global s, token, headers0
+    if ch in s:
+        stream_url = s[ch]
+        stream_url += token
+    else:
+        # Getting live stream url
+        url = url0 + "live-streams/%s?include=quality&auth_token=app_%s" % (ch, token)
+        headers = headers0.copy()
+        headers["Authorization"] = "Bearer " + token
+        r = requests.get(url, headers=headers)
+        if r.status_code <> 200:
+            print "Error getting epg stream url "+url
+            raise bottle.HTTPError(r.status_code, "Error getting epg stream url "+url)
+        js = json.loads(r.content)
+        stream_url = js["data"][0]["attributes"]["stream-url"]
+        stream_url0 = stream_url.replace(token, "")
+        s.set(ch, stream_url0, expire=3600*24*7, read=False)
+    return str(stream_url)
+
+
+def epg_get_stream_url(epgid):
+    global s, token, headers0
+    if epgid in s:
+        stream_url = s[epgid]
+        stream_url += token
+    else:
+        # Getting epg stream url
+        url = url0 + "record-streams/%s?include=quality&auth_token=app_%s" % (epgid, token)
+        headers = headers0.copy()
+        headers["Authorization"] = "Bearer " + token
+        r = requests.get(url, headers=headers)
+        if r.status_code <> 200:
+            print "Error getting epg stream url "+url
+            raise bottle.HTTPError(r.status_code, "Error getting epg stream url "+url)
+        js = json.loads(r.content)
+        stream_url = js["data"][0]["attributes"]["stream-url"]
+        stream_url0 = stream_url.replace(token, "")
+        s.set(epgid, stream_url0, expire=3600*24*7, read=False)
+    return str(stream_url)
+
+
+def refresh_live_chunklist_url(ch):
+    global s, token, headers0
+    stream_url = live_get_stream_url(ch)
+    r = requests.get(stream_url)
+    if r.status_code <> 200:
+        print "Error %s getting live chunklist %s"% (r.status_code,stream_url)
+        raise bottle.HTTPError(r.status_code)
+    chid = re.search("resource_id=c\\-(\\w+)",stream_url).group(1)
+    rest2 = re.search("chunklist.+$", r.content).group(0).replace(token,"")
+    mediaid = re.search("chunklist_(.+?)\\.m3u8",rest2).group(1)
+    base2 = hls_base(stream_url)[0]
+    stream_url2 = base2 + rest2 # chunlist url
+    s.set("m"+ch, mediaid, expire=3600*24*7, read=False)
+    s.set("c"+ch, stream_url2, expire=3600*24*7, read=False)
+    
+    
+def refresh_epg_chunklist_url(stream_url):
+    global s, token, headers0
+    r = requests.get(stream_url)
+    if r.status_code <> 200:
+        print "Error %s getting archive chunklist %s"% (r.status_code,stream_url)
+        raise bottle.HTTPError(r.status_code)
+    epgid = re.search("resource_id=a-(\\d+)",stream_url).group(1)
+    rest2 = re.search("chunklist.+$", r.content).group(0)
+    mediaid = re.search("chunklist_(.+?)\\.m3u8",rest2).group(1)
+    s.set("m"+epgid, mediaid, expire=3600*24*7, read=False)
+    base2 = hls_base(stream_url)[0]
+    stream_url2 = base2 + rest2 # chunlist url
+    return stream_url2,mediaid
+
+
+### Archive ts chunk ###
+@app.route("/<key>/live/<ch>/<ts>/<tail>")
+def get_archive_chunk(key, ch, ts, tail):
+    global s, token, headers0
+    path0, rest = hls_split(request.url)
+    epgid = re.search("resource_id=a-(\\d+)",rest).group(1)
+    chunkid = re.search("(\\d+)\\.ts", rest).group(1)
+    path2 = epgid + "/" +  chunkid
+    if CACHE and path2 in s:
+        print "** %s: serving archive ts from cache %s" % (request.remote_addr,path2)
+        f = s.get(path2, read=True)
+        response.headers["Content-Type"] =  s[path2+"@"] #'video/MP2T'
+        response.headers["Content-Length"] = s[path2+"#"]
+        while True:
+            chunk = f.read(8192)
+            if not chunk:
+                break
+            yield chunk
+
+    else: #  No cache
+        stream_url = epg_get_stream_url(epgid)
+        if "m"+epgid in s:
+            mediaid= s["m"+epgid]
+        else:
+            chunklist_url, mediaid = refresh_epg_chunklist_url(stream_url)
+        base0, rest0 = hls_base(stream_url)
+        #media_w76603200_0.ts?resource_id=a-6559656352477&auth_token=app_
+        rest2 = "media_%s_%s.ts?resource_id=a-%s&auth_token=app_" % (mediaid, chunkid, epgid)
+        url = base0 + rest2 + token
+        print "** %s: getting archive ts from %s(%s) - %s" % (request.remote_addr,path2, mediaid, rest2[:rest2.index("?")])
+        #print url
+        headers = dict(request.headers)
+        del headers["Host"]
+        # headers["Authorization"] = "Bearer " + token
+
+        r = requests.get(url, stream=True, headers=headers)
+        if r.status_code <> 200:
+            r = requests.get(url, stream=True, headers=headers) # try once more
+            if r.status_code <> 200:
+                # Refresh chunklist
+                print "## %s: Refreshing chunklist/mediaid  for epg %s" %(request.remote_addr, epgid)
+                chunklist_url, mediaid = refresh_epg_chunklist_url(stream_url)
+                rest2 = "media_%s_%s.ts?resource_id=a-%s&auth_token=app_" % (mediaid, chunkid, epgid)
+                url = base0 + rest2 + token
+                print "** %s: getting archive ts from %s(%s) - %s" % (request.remote_addr, path2, mediaid, rest2[:rest2.index("?")])
+                r = requests.get(url, stream=True, headers=headers0)
+                if r.status_code <> 200:
+                    print "Error %s opening stream \n%s" %(r.status_code,url)
+                    raise bottle.HTTPError(r.status_code, "Error opening stream "+url)
+
+        content = ""
+        response.content_type = r.headers["content-type"] # 'application/vnd.apple.mpegurl' #
+        # response.headers.clear()
+        for k in r.headers:
+            response.headers[k] =  r.headers[k]
+        if DEBUG:
+            print_headers(response.headers)
+        for chunk in r.iter_content(chunk_size=8192):
+            if chunk:
+                content += chunk
+            yield chunk
+        if CACHE:
+            path2 = epgid + "/" + chunkid
+            s.set(path2, content, expire=3600, read=True)
+            s.set(path2+"#", len(content), expire=3600, read=True)
+            s.set(path2+"@", r.headers["Content-Type"], expire=3600, read=True)
+
+
+@app.route("/<key>/vod/<ch>/")
+def get_vod(key, ch):
+    global s, token, headers0
+    path0, rest = hls_split(request.url)
+    if path0 in s:
+        stream_url = s[path0] + token
+        print "** %s: getting vod to %s from cache (%s)" % (request.remote_addr, path0)
+    else:
+        url = url0 + "vod-streams/%s?include=language,subtitles,quality &auth_token=app_%s" % (ch, token)
+        headers = headers0.copy()
+        headers["Authorization"] = "Bearer " + token
+        r = requests.get(url, headers=headers)
+        if r.status_code <> 200:
+            raise bottle.HTTPError(r.status_code, "Error opening stream "+url)
+        js = json.loads(r.content)
+        stream_url = js["data"][0]["attributes"]["stream-url"]
+        stream_url0 = stream_url.replace(token, "")
+        s.set(path0, stream_url0, expire=3600*24*7, read=False)
+        print "** %s: changing vod to %s (%s)" % (request.remote_addr, path0)
+    if True: # REDIRECT:
+        bottle.redirect(stream_url, 307)
+    r = requests.get(stream_url)
+    if r.status_code <> 200:
+        raise bottle.HTTPError(r.status_code)
+    response.content_type = r.headers["content-type"] # 'application/vnd.apple.mpegurl' #
+    return r.content
+
+
+def get_epg(ch, start):
+    url = url0 + "epgs/?filter[channel]=%s&filter[utFrom]=%s&filter[utTo]=%s&include=channel&page[size]=40page[number]=1" % (ch, start, start )
+    r = requests.get(url)
+    if r.status_code <> 200:
+        raise bottle.HTTPError(500, "EPG not found")
+    js = json.loads(r.content)
+    if "data" in js:
+        for epg in js["data"]:
+            if int(epg["id"]) < 0:
+                continue
+            else:
+                break
+        return epg
+    else:
+        return None
+
+
+####################################################################
+# Run WSGI server
+def start(server,port):
+    print "*** Starting ltcproxy ***"
+    options = {}
+    if server == "mtwsgi":
+        import mtwsgi
+        server = mtwsgi.MTServer
+        options = {"thread_count": WORKERS,}
+
+    run(app=app,server=server, host='0.0.0.0',
+            port=port,
+            reloader=False,
+            quiet=False,
+            plugins=None,
+            debug=True,
+            config=None,
+            **options)
+
+def login(user,password):
+    """Login in to site, get token"""
+
+    # Dabūjam tokenu
+    url = "https://manstv.lattelecom.tv/api/v1.7/post/user/users/%s" % user
+    params = "uid=5136baee57505694&password=%s&" % (password)
+    headers = headers2dict("""
+User-Agent: Shortcut.lv v2.9.1 / Dalvik/1.6.0 (Linux; U; Android 4.4.2; SM-G900FD Build/KOT49H)
+Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+Host: manstv.lattelecom.tv
+""" )
+    try:
+        r = urllib2.Request(url, data=params, headers=headers)
+        u = urllib2.urlopen(r)
+        content = u.read()
+        u.close()
+    except Exception as ex:
+        return None
+    if r and "token" in content:
+        token = re.search('"token":"(.+?)"', content).group(1)
+        return token
+    else:
+        return False
+
+def refresh_token(token):
+    """Refresh"""
+
+    url = "https://manstv.lattelecom.tv/api/v1.7/post/user/refresh-token/"
+    params = "uid=5136baee57505694&token=%s&" % (token)
+    headers = headers2dict("""
+User-Agent: Shortcut.lv v2.9.1 / Dalvik/1.6.0 (Linux; U; Android 4.4.2; SM-G900FD Build/KOT49H)
+Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+Host: manstv.lattelecom.tv
+""" )
+    try:
+        r = urllib2.Request(url, data=params, headers=headers)
+        u = urllib2.urlopen(r)
+        content = u.read()
+        u.close()
+    except Exception as ex:
+        return None
+    if r and "token" in content:
+        token2 = re.search('"token":"(.+?)"', content).group(1)
+        return token2
+    else:
+        return False
+
+def print_headers(headers):
+    for h in headers:
+        print "%s: %s"%(h,headers[h])
+
+def del_headers(headers0,tags):
+    headers = headers0.copy()
+    for t in tags:
+        if t in headers:
+            del headers[t]
+        if t.lower() in headers:
+            del headers[t.lower()]
+    return headers
+
+def hls_split(url):
+    pp = urlparse.urlsplit(url)
+    path0 = pp.path[:pp.path.rindex("/")+1]
+    path0 = path0[path0.index("/", 1):]
+    rest = pp.path[pp.path.rindex("/")+1:] + "?" + pp.query
+    return path0, rest
+
+def hls_base(url):
+    base = url.split("?")[0]
+    base = "/".join(base.split("/")[0:-1])+ "/"
+    rest = url.replace(base, "")
+    return base, rest
+
+#########################################################################################
+if __name__ == '__main__':
+    # 1561839586
+    # get_epg("101", 1561839586)
+
+    try:
+        opts, args = getopt.gnu_getopt(sys.argv[1:], "p:s:dr", ["port=","server=","--debug"])
+    except getopt.GetoptError as err:
+        print str(err)
+        print str(__doc__)
+        sys.exit(2)
+    opts = dict(opts)
+
+    if not len(args):
+        print str(__doc__)
+        sys.exit(2)
+
+    if "-r" in opts:
+        print "Enabling remote debuging (ptvsd)"
+        import ptvsd
+        ptvsd.enable_attach(address = ('0.0.0.0', 5678),redirect_output=False)
+    if "-d" in opts:
+        print "Enabling debuging mode (more output)"
+        DEBUG = True
+    pid = "/var/run/ltcproxy.pid"
+    daemon = daemonize.Daemon(start, pid)
+    server =  opts["-s"] if "-s" in opts else SERVER
+    port = opts["-p"] if "-p" in opts else PORT_NUMBER
+
+    if "start" == args[0]:
+        s.clear()
+        daemon.start(server,port)
+        daemon.is_running()
+    elif "stop" == args[0]:
+        daemon.stop()
+    elif "restart" == args[0]:
+        s.clear()
+        daemon.restart()
+        daemon.is_running()
+    elif "manualstart" == args[0]:
+        s.clear()
+        start(server,port)
+    elif "status" == args[0]:
+        daemon.is_running()
+    else:
+        print "Unknown command"
+        print str(__doc__)
+        sys.exit(2)
+    sys.exit(0)

mtbottle.py

@@ -0,0 +1,30 @@
+'''Multithreading Bottle server adapter.'''
+
+import bottle
+import mtwsgi
+
+class MTServer(bottle.ServerAdapter):
+    def run(self, handler):
+        thread_count = self.options.pop('thread_count', None)
+        server = mtwsgi.make_server(self.host, self.port, handler, thread_count, **self.options)
+        server.serve_forever()
+
+
+
+if __name__ == '__main__':
+    import bottle
+    import time
+
+    app = bottle.Bottle()
+
+    @app.route('/')
+    def foo():
+        time.sleep(2)
+        return 'hello, world!\n'
+
+    app.run(server=MTServer, host='0.0.0.0', port=8080, thread_count=3)
+
+    # or:
+    # httpd = mtwsgi.make_server('0.0.0.0', 8080, app, 3)
+    # httpd.serve_forever()
+

requirments.txt

@@ -0,0 +1,3 @@
+requests
+arrow
+diskcache