def exportm3u(self, hostport, path='', add_ts=False, empty_header=False, archive=False,
process_url=True, header=None, fmt=None, _bytearray=bytearray):
'''
Exports m3u playlist
'''
if add_ts: hostport = 'ts://%s' % hostport # Adding ts:// after http:// for some players
if header is None: itemlist = self.m3uheader if not empty_header else self.m3uemptyheader
else: itemlist = header
items = self.sort(self.itemlist) if self.sort else self.itemlist
for i in items:
item = i.copy() # {'group': XXX, 'tvg': XXX, 'logo': XXX, 'name': XXX, 'tvgid': XXX, 'url': XXX}
name = quote(ensure_str(item.get('name').replace('"', "'").replace(',', '.')), '')
url = item['url']
if process_url:
if url.startswith(('http://', 'https://')) and url.endswith(('.acelive', '.acestream', '.acemedia', '.torrent')): # For .acelive and .torrent
item['url'] = 'http://%s/url/%s/%s.ts' % (hostport, quote(url,''), name)
elif url.startswith('infohash://'): # For INFOHASHes
item['url'] = 'http://%s/infohash/%s/%s.ts' % (hostport, url.split('/')[2], name)
elif url.startswith('acestream://'): # For PIDs
item['url'] = 'http://%s/content_id/%s/%s.ts' % (hostport, url.split('/')[2], name)
elif archive and url.isdigit(): # For archive channel id's
item['url'] = 'http://%s/archive/play?id=%s' % (hostport, url)
elif not archive and url.isdigit(): # For channel id's
item['url'] = 'http://%s/channels/play?id=%s' % (hostport, url)
elif path.endswith('channel'): # For plugins channel name maping
item['url'] = 'http://%s%s/%s' % (hostport, path, url)
if fmt: item['url'] += '&fmt=%s' % fmt if '?' in item['url'] else '/?fmt=%s' % fmt
itemlist += self.m3uchanneltemplate.format(**item) #Generates EXTINF line with url
return _bytearray(itemlist, 'utf-8')
def line_generator(item):
'''
Generates EXTINF line with url
'''
item = item.copy() # {'group': XXX, 'tvg': XXX, 'logo': XXX, 'name': XXX, 'tvgid': XXX, 'url': XXX}
params.update({'name': quote(ensure_str(item.get('name').replace('"', "'").replace(',', '.')), '')})
url = item['url']
if not params.get('parse_url'):
if params.get('path') and params.get('path').endswith('channel'): # For plugins channel name maping
params.update({'value': url})
item['url'] = urlunparse(u'{schema};{netloc};{path}/{value}.{ext};;{query};'.format(**params).split(';'))
elif url.startswith(('http://', 'https://')) and url.endswith(('.acelive', '.acestream', '.acemedia', '.torrent')): # For .acelive and .torrent
params.update({'value': quote(url,'')})
item['url'] = urlunparse(u'{schema};{netloc};/url/{value}/{name}.{ext};;{query};'.format(**params).split(';'))
elif url.startswith('infohash://'): # For INFOHASHes
params.update({'value': url.split('/')[2]})
item['url'] = urlunparse(u'{schema};{netloc};/infohash/{value}/{name}.{ext};;{query};'.format(**params).split(';'))
elif url.startswith('acestream://'): # For PIDs
params.update({'value': url.split('/')[2]})
item['url'] = urlunparse(u'{schema};{netloc};/content_id/{value}/{name}.{ext};;{query};'.format(**params).split(';'))
elif params.get('archive') and url.isdigit(): # For archive channel id's
params.update({'value': url})
item['url'] = urlunparse(u'{schema};{netloc};/archive/play;;id={value};'.format(**params).split(';'))
elif not params.get('archive') and url.isdigit(): # For channel id's
params.update({'value': url})
item['url'] = urlunparse(u'{schema};{netloc};/channels/play;;id={value};'.format(**params).split(';'))
return self.m3uchanneltemplate.format(**item)
def handle(self, connection):
# 30 minutes cache
if not self.playlist or (gevent.time.time() - self.playlisttime > 30 * 60):
if not self.Playlistparser():
logging.info('Parser failed to parse')
connection.send_error()
connection.ext = query_get(connection.query, 'ext', 'ts')
if connection.path.startswith('/{reqtype}/channel/'.format(**connection.__dict__)):
if not connection.path.endswith(connection.ext):
logging.info('Invalid path')
connection.send_error(404, 'Invalid path: {path}'.format(**connection.__dict__), logging.ERROR)
name = ensure_text(unquote(os.path.splitext(os.path.basename(connection.path))[0]))
url = self.channels.get(name)
if url is None:
logging.info('Unknown channel')
connection.send_error(404, '[%s]: unknown channel: %s' % (self.__class__.__name__, name), logging.ERROR)
connection.__dict__.update({'channelName': name,
'channelIcon': self.picons.get(name),
'path': {'acestream': '/content_id/%s/%s.%s' % (urlparse(url).netloc, name, connection.ext),
'infohash' : '/infohash/%s/%s.%s' % (urlparse(url).netloc, name, connection.ext),
'http' : '/url/%s/%s.%s' % (quote(url,''), name, connection.ext),
'https' : '/url/%s/%s.%s' % (quote(url,''), name, connection.ext),
}[urlparse(url).scheme]})
connection.__dict__.update({'splittedpath': connection.path.split('/')})
connection.__dict__.update({'reqtype': connection.splittedpath[1].lower()})
return
elif self.etag == connection.headers.get('If-None-Match'):
logging.debug('[%s]: ETag matches. Return 304 to [%s]' % (self.__class__.__name__, connection.clientip))
connection.send_response(304)
connection.send_header('Connection', 'close')
connection.end_headers()
return
else:
host_port = connection.headers['Host']
exported = self.playlist.exportm3u( hostport=host_port,
path='' if not self.channels else '/{reqtype}/channel'.format(**connection.__dict__),
header=config.m3uheadertemplate.format(get_epg_url(host_port, config, config.tvgurl), config.tvgshift),
query=connection.query
)
response_headers = {'Content-Type': 'audio/mpegurl; charset=utf-8', 'Connection': 'close', 'Access-Control-Allow-Origin': '*'}
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
compress_method = { 'zlib': zlib.compressobj(9, zlib.DEFLATED, zlib.MAX_WBITS),
'deflate': zlib.compressobj(9, zlib.DEFLATED, -zlib.MAX_WBITS),
'gzip': zlib.compressobj(9, zlib.DEFLATED, zlib.MAX_WBITS | 16) }
exported = compress_method[h].compress(exported) + compress_method[h].flush()
response_headers['Content-Encoding'] = h
except: pass
response_headers['Content-Length'] = len(exported)
if connection.request_version == 'HTTP/1.1':
response_headers['ETag'] = self.etag
connection.send_response(200)
gevent.joinall([gevent.spawn(connection.send_header, k, v) for (k,v) in response_headers.items()])
connection.end_headers()
connection.wfile.write(exported)
logging.debug('[%s]: plugin sent playlist to [%s]' % (self.__class__.__name__, connection.clientip))
def exportm3u(self,
hostport,
path='',
add_ts=False,
empty_header=False,
archive=False,
process_url=True,
header=None,
fmt=None):
'''
Exports m3u playlist
'''
if add_ts:
hostport = 'ts://%s' % hostport # Adding ts:// after http:// for some players
if header is None:
itemlist = self.m3uheader if not empty_header else self.m3uemptyheader
else:
itemlist = header
self._changeItems()
items = self.sort(self.itemlist) if self.sort else self.itemlist
for i in items:
item = i.copy()
item['name'] = item['name'].replace('"', "'").replace(',', '.')
name = quote(item['name'].encode('utf-8'), '')
url = item['url']
if process_url:
if url.endswith(('.acelive', '.acestream', '.acemedia',
'.torrent')): # For .acelive and .torrent
item['url'] = 'http://%s/url/%s/%s.ts' % (
hostport, quote(url, ''), name)
elif url.startswith('infohash://'): # For INFOHASHes
item['url'] = 'http://%s/infohash/%s/%s.ts' % (
hostport, url.split('/')[2], name)
elif url.startswith('acestream://'): # For PIDs
item['url'] = 'http://%s/content_id/%s/%s.ts' % (
hostport, url.split('/')[2], name)
elif archive and url.isdigit(): # For archive channel id's
item['url'] = 'http://%s/archive/play?id=%s' % (hostport,
url)
elif not archive and url.isdigit(): # For channel id's
item['url'] = 'http://%s/channels/play?id=%s' % (hostport,
url)
elif path == '/torrenttv/channel': # For channel name for torrenttv_plugin
item['url'] = 'http://%s%s/%s' % (hostport, path, url)
if fmt:
item['url'] += '&fmt=%s' % fmt if '?' in item[
'url'] else '/?fmt=%s' % fmt
itemlist += self._generatem3uline(item)
return itemlist
def handle(self, connection, headers_only=False):
play = False
# 30 minutes cache
if not self.playlist or (gevent.time.time() - self.playlisttime > 30 * 60):
if not self.Playlistparser(): connection.dieWithError(); return
url = urlparse(connection.path)
path = url.path[0:-1] if url.path.endswith('/') else url.path
params = parse_qs(connection.query)
if path.startswith('/%s/channel/' % connection.reqtype):
if not path.endswith('.ts'):
connection.dieWithError(404, 'Invalid path: %s' % unquote(path), logging.ERROR)
return
name = ensure_text(unquote(path[path.rfind('/')+1:]))
url = self.channels.get('.'.join(name.split('.')[:-1]))
if url is None:
connection.dieWithError(404, 'Unknown channel: ' + name, logging.ERROR)
return
elif url.startswith('acestream://'):
connection.path = '/content_id/%s/%s' % (url.split('/')[2], name)
elif url.startswith('infohash://'):
connection.path = '/infohash/%s/%s' % (url.split('/')[2], name)
elif url.startswith(('http://', 'https://')) and url.endswith(('.acelive', '.acestream', '.acemedia', '.torrent')):
connection.path = '/url/%s/%s' % (quote(url,''), name)
connection.splittedpath = connection.path.split('/')
connection.reqtype = connection.splittedpath[1].lower()
name = name.split('.')[0]
play = True
elif self.etag == connection.headers.get('If-None-Match'):
self.logger.debug('ETag matches - returning 304')
connection.send_response(304)
connection.send_header('Connection', 'close')
connection.end_headers()
return
else:
hostport = connection.headers['Host']
path = '' if not self.channels else '/%s/channel' % connection.reqtype
add_ts = True if path.endswith('/ts') else False
exported = self.playlist.exportm3u(hostport=hostport, path=path, add_ts=add_ts, header=config.m3uheadertemplate, fmt=params.get('fmt', [''])[0])
response_headers = { 'Content-Type': 'audio/mpegurl; charset=utf-8', 'Connection': 'close', 'Content-Length': len(exported),
'Access-Control-Allow-Origin': '*', 'ETag': self.etag }
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
compress_method = { 'zlib': zlib.compressobj(9, zlib.DEFLATED, zlib.MAX_WBITS),
'deflate': zlib.compressobj(9, zlib.DEFLATED, -zlib.MAX_WBITS),
'gzip': zlib.compressobj(9, zlib.DEFLATED, zlib.MAX_WBITS | 16) }
exported = compress_method[h].compress(exported) + compress_method[h].flush()
response_headers['Content-Length'] = len(exported)
response_headers['Content-Encoding'] = h
except: pass
connection.send_response(200)
gevent.joinall([gevent.spawn(connection.send_header, k, v) for (k,v) in response_headers.items()])
connection.end_headers()
if play: connection.handleRequest(headers_only, name, self.picons.get(name), fmt=params.get('fmt', [''])[0])
elif not headers_only:
self.logger.debug('Exporting torrent-telik.m3u playlist')
connection.wfile.write(exported)
def Playlistparser(self):
try:
s = requests.Session()
s.mount('file://', FileAdapter())
with s.get(config.url,
headers=self.headers,
proxies=config.proxies,
stream=False,
timeout=30) as playlist:
if playlist.status_code != 304:
if playlist.encoding is None: playlist.encoding = 'utf-8'
playlist = playlist.json()
self.headers['If-Modified-Since'] = gevent.time.strftime(
'%a, %d %b %Y %H:%M:%S %Z',
gevent.time.gmtime(self.playlisttime))
self.playlist = PlaylistGenerator(
m3uchanneltemplate=config.m3uchanneltemplate)
self.picons = picons.logomap
self.channels = {}
m = requests.auth.hashlib.md5()
logging.info('[%s]: playlist %s downloaded' %
(self.__class__.__name__, config.url))
try:
urlpattern = requests.utils.re.compile(
r'^(acestream|infohash)://[0-9a-f]{40}$|^(http|https)://.*.(acelive|acestream|acemedia|torrent)$'
)
for channel in playlist['channels']:
name = channel['name']
url = 'infohash://{url}'.format(**channel)
channel['group'] = channel.pop('cat')
channel['logo'] = self.picons[name] = channel.get(
'logo', picons.logomap.get(name))
channel['tvgid'] = channel.pop('program')
if requests.utils.re.search(urlpattern, url):
self.channels[name] = url
channel['url'] = quote(ensure_str(name), '')
self.playlist.addItem(channel)
m.update(ensure_binary(name))
except Exception as e:
logging.error("[%s]: can't parse JSON! %s" %
(self.__class__.__name__, repr(e)))
return False
self.etag = '"' + m.hexdigest() + '"'
logging.debug('[%s]: plugin playlist generated' %
self.__class__.__name__)
self.playlisttime = gevent.time.time()
except requests.exceptions.RequestException:
logging.error("[%s]: can't download %s playlist!" %
(self.__class__.__name__, config.url))
return False
except:
logging.error(traceback.format_exc())
return False
def Playlistparser(self):
try:
s = requests.Session()
s.mount('file://', FileAdapter())
with s.get(config.url,
headers=self.headers,
proxies=config.proxies,
stream=False,
timeout=30) as r:
if r.status_code != 304:
if r.encoding is None: r.encoding = 'utf-8'
self.headers['If-Modified-Since'] = gevent.time.strftime(
'%a, %d %b %Y %H:%M:%S %Z',
gevent.time.gmtime(self.playlisttime))
self.playlist = PlaylistGenerator(
m3uchanneltemplate=config.m3uchanneltemplate)
self.picons = picons.logomap
self.channels = {}
m = requests.auth.hashlib.md5()
logging.info('[%s]: playlist %s downloaded' %
(self.__class__.__name__, config.url))
pattern = requests.utils.re.compile(
r',(?P<name>.+) \((?P<group>.+)\)[\r\n]+(?P<url>[^\r\n]+)?'
)
urlpattern = requests.utils.re.compile(
r'^(acestream|infohash)://[0-9a-f]{40}$|^(http|https)://.*.(acelive|acestream|acemedia|torrent)$'
)
for match in pattern.finditer(r.text,
requests.auth.re.MULTILINE):
itemdict = match.groupdict()
name = itemdict.get('name', '')
itemdict['logo'] = self.picons[name] = itemdict.get(
'logo', picons.logomap.get(name))
url = itemdict['url']
if requests.utils.re.search(urlpattern, url):
self.channels[name] = url
itemdict['url'] = quote(ensure_str(name), '')
self.playlist.addItem(itemdict)
m.update(ensure_binary(name))
self.etag = '"' + m.hexdigest() + '"'
logging.debug('[%s]: plugin playlist generated' %
self.__class__.__name__)
self.playlisttime = gevent.time.time()
except requests.exceptions.RequestException:
logging.error("[%s]: can't download %s playlist!" %
(self.__class__.__name__, config.url))
return False
except:
logging.error(traceback.format_exc())
return False
return True
def Playlistparser(self):
try:
with requests.get(config.url,
headers=self.headers,
proxies=config.proxies,
stream=False,
timeout=30) as playlist:
if playlist.status_code != 304:
if playlist.encoding is None: playlist.encoding = 'utf-8'
self.headers['If-Modified-Since'] = gevent.time.strftime(
'%a, %d %b %Y %H:%M:%S %Z',
gevent.time.gmtime(self.playlisttime))
self.playlist = PlaylistGenerator(
m3uchanneltemplate=config.m3uchanneltemplate)
self.picons = picons.logomap
self.channels = {}
m = requests.auth.hashlib.md5()
self.logger.info('Playlist %s downloaded' % config.url)
try:
for channel in playlist.json()['channels']:
channel['name'] = name = channel.get('name', '')
channel[
'url'] = url = 'acestream://%s' % channel.get(
'url')
channel['group'] = channel.get('cat')
if not 'logo' in channel:
channel['logo'] = picons.logomap.get(name)
self.picons[name] = channel['logo']
if url.startswith(('acestream://', 'infohash://')) \
or (url.startswith(('http://','https://')) and url.endswith(('.acelive','.acestream','.acemedia'))):
self.channels[name] = url
channel['url'] = quote(
ensure_str(name) + '.ts', '')
self.playlist.addItem(channel)
m.update(name.encode('utf-8'))
except Exception as e:
self.logger.error("Can't parse JSON! %s" % repr(e))
return
self.etag = '"' + m.hexdigest() + '"'
self.logger.debug('torrent-telik.m3u playlist generated')
self.playlisttime = gevent.time.time()
except requests.exceptions.RequestException:
self.logger.error("Can't download %s playlist!" % config.url)
return False
except:
self.logger.error(traceback.format_exc())
return False
return True
def Playlistparser(self):
try:
s = requests.Session()
s.mount('file://', FileAdapter())
with s.get(config.url,
headers=self.headers,
proxies=config.proxies,
stream=False,
timeout=30) as r:
if r.status_code != 304:
if r.encoding is None: r.encoding = 'utf-8'
self.headers['If-Modified-Since'] = gevent.time.strftime(
'%a, %d %b %Y %H:%M:%S %Z',
gevent.time.gmtime(self.playlisttime))
self.playlist = PlaylistGenerator(
m3uchanneltemplate=config.m3uchanneltemplate)
self.picons = picons.logomap
self.channels = {}
m = requests.auth.hashlib.md5()
self.logger.info('Playlist %s downloaded' % config.url)
pattern = requests.auth.re.compile(
r',(?P<name>.+) \((?P<group>.+)\)[\r\n]+(?P<url>[^\r\n]+)?'
)
for match in pattern.finditer(r.text,
requests.auth.re.MULTILINE):
itemdict = match.groupdict()
name = itemdict.get('name', '')
if not 'logo' in itemdict:
itemdict['logo'] = picons.logomap.get(name)
self.picons[name] = itemdict['logo']
url = itemdict['url']
if url.startswith(('acestream://', 'infohash://')) \
or (url.startswith(('http://','https://')) and url.endswith(('.acelive', '.acestream', '.acemedia', '.torrent'))):
self.channels[name] = url
itemdict['url'] = quote(ensure_str('%s.ts' % name),
'')
self.playlist.addItem(itemdict)
m.update(name.encode('utf-8'))
self.etag = '"' + m.hexdigest() + '"'
self.logger.debug('torrenttv.m3u playlist generated')
self.playlisttime = gevent.time.time()
except requests.exceptions.RequestException:
self.logger.error("Can't download %s playlist!" % config.url)
return False
except:
self.logger.error(traceback.format_exc())
return False
return True
def handle(self, connection):
P2pproxy.logger.debug('Handling request')
hostport = connection.headers['Host']
self.params = parse_qs(connection.query)
# /channels/ branch
if connection.reqtype in ('channels', 'channels.m3u'):
if connection.path.endswith('play'): # /channels/play?id=[id]
channel_id = self.params.get('id', [''])[0]
if not channel_id:
# /channels/play?id=&_=[epoch timestamp] is Torrent-TV widget proxy check
# P2pProxy simply closes connection on this request sending Server header, so do we
if self.params.get('_', [''])[0]:
P2pproxy.logger.debug('Status check')
response_headers = {
'Content-Type': 'text/plain;charset=utf-8',
'Server': 'P2pProxy/1.0.4.4 HTTPAceProxy',
'Access-Control-Allow-Origin': '*',
'Connection': 'close'
}
connection.send_response(200)
for k, v in response_headers.items():
connection.send_header(k, v)
connection.wfile.write('\r\n')
return
else:
connection.send_error(400,
'Bad request') # Bad request
try:
stream_type, stream, translations_list = TorrentTvApi(
config.email,
config.password).stream_source(channel_id)
except Exception as err:
connection.send_error(404, '%s' % repr(err), logging.ERROR)
name = logo = ''
for channel in translations_list:
if channel.getAttribute('id') == channel_id:
name = channel.getAttribute('name')
logo = channel.getAttribute('logo')
if logo != '' and config.fullpathlogo:
logo = config.logobase + logo
break
if stream_type not in ('torrent', 'contentid'):
connection.send_error(
404, 'Unknown stream type: %s' % stream_type,
logging.ERROR)
elif stream_type == 'torrent':
connection.path = '/url/%s/%s.ts' % (quote(stream,
''), name)
elif stream_type == 'contentid':
connection.path = '/content_id/%s/%s.ts' % (stream, name)
connection.__dict__.update(
{'splittedpath': connection.path.split('/')})
connection.__dict__.update({
'channelName':
name,
'channelIcon':
logo,
'reqtype':
connection.splittedpath[1].lower()
})
return
# /channels/?filter=[filter]&group=[group]&type=m3u
elif connection.reqtype == 'channels.m3u' or self.params.get(
'type', [''])[0] == 'm3u':
param_group = self.params.get('group', [''])[0]
if param_group and 'all' in param_group: param_group = None
try:
translations_list = TorrentTvApi(
config.email, config.password).translations(
self.params.get('filter', ['all'])[0])
except Exception as err:
connection.send_error(404, '%s' % repr(err), logging.ERROR)
playlistgen = PlaylistGenerator(
m3uchanneltemplate=config.m3uchanneltemplate)
P2pproxy.logger.debug('Generating requested m3u playlist')
for channel in translations_list:
group_id = channel.getAttribute('group')
if param_group and not group_id in param_group.split(','):
continue # filter channels by &group=1,2,5...
name = channel.getAttribute('name')
group = TorrentTvApi.CATEGORIES[int(group_id)]
cid = channel.getAttribute('id')
logo = channel.getAttribute('logo')
if logo != '' and config.fullpathlogo:
logo = config.logobase + logo
fields = {
'name':
name,
'id':
cid,
'url':
cid,
'group':
group,
'logo':
logo,
'tvgid':
config.tvgid.format(**fields)
if channel.getAttribute('epg_id') != '0' else ''
}
playlistgen.addItem(fields)
P2pproxy.logger.debug('Exporting m3u playlist')
exported = playlistgen.exportm3u(
hostport=hostport,
header=config.m3uheadertemplate,
fmt=self.params.get('fmt', [''])[0])
connection.send_response(200)
connection.send_header('Content-Type',
'audio/mpegurl; charset=utf-8')
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
exported = P2pproxy.compress_method[h].compress(
exported) + P2pproxy.compress_method[h].flush()
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(exported))
connection.end_headers()
connection.wfile.write(exported)
# /channels/?filter=[filter]
else:
try:
translations_list = TorrentTvApi(
config.email, config.password).translations(
self.params.get('filter', ['all'])[0], True)
except Exception as err:
connection.send_error(404, '%s' % repr(err), logging.ERROR)
P2pproxy.logger.debug('Exporting m3u playlist')
response_headers = {
'Access-Control-Allow-Origin': '*',
'Connection': 'close',
'Content-Type': 'text/xml;charset=utf-8',
'Content-Length': len(translations_list)
}
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
translations_list = P2pproxy.compress_method[h].compress(
translations_list) + P2pproxy.compress_method[h].flush(
)
connection.send_header('Content-Encoding', h)
except:
pass
response_headers['Content-Length'] = len(translations_list)
connection.send_response(200)
for k, v in response_headers.items():
connection.send_header(k, v)
connection.end_headers()
connection.wfile.write(translations_list)
# same as /channels request
elif connection.reqtype == 'xbmc.pvr' and connection.path.endswith(
'playlist'):
connection.send_response(200)
connection.send_header('Access-Control-Allow-Origin', '*')
connection.send_header('Connection', 'close')
connection.send_header('Content-Type', 'text/xml;charset=utf-8')
try:
translations_list = TorrentTvApi(config.email,
config.password).translations(
'all', True)
except Exception as err:
connection.send_error(404, '%s' % repr(err), logging.ERROR)
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
translations_list = P2pproxy.compress_method[h].compress(
translations_list) + P2pproxy.compress_method[h].flush()
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(translations_list))
connection.end_headers()
P2pproxy.logger.debug('Exporting m3u playlist')
connection.wfile.write(translations_list)
# /archive/ branch
elif connection.reqtype == 'archive':
if connection.path.endswith(
('dates', 'dates.m3u')): # /archive/dates.m3u
d = datetime.now()
delta = timedelta(days=1)
playlistgen = PlaylistGenerator()
hostport = connection.headers['Host']
days = int(self.params.get('days', ['7'])[0])
suffix = '&suffix=%s' % self.params.get(
'suffix')[0] if 'suffix' in self.params else ''
for i in range(days):
dfmt = d.strftime('%d-%m-%Y')
url = 'http://%s/archive/playlist/?date=%s%s' % (
hostport, dfmt, suffix)
playlistgen.addItem({
'group': '',
'tvg': '',
'name': dfmt,
'url': url
})
d -= delta
exported = playlistgen.exportm3u(hostport=hostport,
empty_header=True,
parse_url=False,
fmt=self.params.get(
'fmt', [''])[0])
connection.send_response(200)
connection.send_header('Content-Type',
'audio/mpegurl; charset=utf-8')
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
exported = P2pproxy.compress_method[h].compress(
exported) + P2pproxy.compress_method[h].flush()
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(exported))
connection.end_headers()
connection.wfile.write(exported)
return
elif connection.path.endswith(
('playlist', 'playlist.m3u')): # /archive/playlist.m3u
dates = []
if 'date' in self.params:
for d in self.params['date']:
dates.append(self.parse_date(d).strftime('%d-%m-%Y'))
else:
d = datetime.now()
delta = timedelta(days=1)
days = int(self.params.get('days', ['7'])[0])
for i in range(days):
dates.append(d.strftime('%d-%m-%Y'))
d -= delta
connection.send_response(200)
connection.send_header('Content-Type',
'audio/mpegurl; charset=utf-8')
try:
channels_list = TorrentTvApi(
config.email, config.password).archive_channels()
except Exception as err:
connection.send_error(404, '%s' % repr(err), logging.ERROR)
hostport = connection.headers['Host']
playlistgen = PlaylistGenerator()
suffix = '&suffix=%s' % self.params.get(
'suffix')[0] if 'suffix' in self.params else ''
for channel in channels_list:
epg_id = channel.getAttribute('epg_id')
name = channel.getAttribute('name')
logo = channel.getAttribute('logo')
if logo != '' and config.fullpathlogo:
logo = config.logobase + logo
for d in dates:
n = name + ' (' + d + ')' if len(dates) > 1 else name
url = 'http://%s/archive/?type=m3u&date=%s&channel_id=%s%s' % (
hostport, d, epg_id, suffix)
playlistgen.addItem({
'group': name,
'tvg': '',
'name': n,
'url': url,
'logo': logo
})
exported = playlistgen.exportm3u(hostport=hostport,
empty_header=True,
parse_url=False,
fmt=self.params.get(
'fmt', [''])[0])
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
exported = P2pproxy.compress_method[h].compress(
exported) + P2pproxy.compress_method[h].flush()
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(exported))
connection.end_headers()
connection.wfile.write(exported)
return
elif connection.path.endswith('channels'): # /archive/channels
connection.send_response(200)
connection.send_header('Access-Control-Allow-Origin', '*')
connection.send_header('Connection', 'close')
connection.send_header('Content-Type',
'text/xml;charset=utf-8')
try:
archive_channels = TorrentTvApi(
config.email, config.password).archive_channels(True)
except Exception as err:
connection.send_error(404, '%s' % repr(err), logging.ERROR)
P2pproxy.logger.debug('Exporting m3u playlist')
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
archive_channels = P2pproxy.compress_method[h].compress(
archive_channels) + P2pproxy.compress_method[h].flush(
)
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(archive_channels))
connection.end_headers()
connection.wfile.write(archive_channels)
return
if connection.path.endswith(
'play'): # /archive/play?id=[record_id]
record_id = self.params.get('id', [''])[0]
if not record_id:
connection.send_error(400, 'Bad request') # Bad request
try:
stream_type, stream = TorrentTvApi(
config.email,
config.password).archive_stream_source(record_id)
except Exception as err:
connection.send_error(404, '%s' % repr(err), logging.ERROR)
if stream_type not in ('torrent', 'contentid'):
connection.send_error(
404, 'Unknown stream type: %s' % stream_type,
logging.ERROR)
elif stream_type == 'torrent':
connection.path = '/url/%s/stream.ts' % quote(stream, '')
elif stream_type == 'contentid':
connection.path = '/content_id/%s/stream.ts' % stream
connection.__dict__.update(
{'splittedpath': connection.path.split('/')})
connection.__dict__.update(
{'reqtype': connection.splittedpath[1].lower()})
return
# /archive/?type=m3u&date=[param_date]&channel_id=[param_channel]
elif self.params.get('type', [''])[0] == 'm3u':
playlistgen = PlaylistGenerator()
param_channel = self.params.get('channel_id', [''])[0]
d = self.get_date_param()
if not param_channel:
try:
channels_list = TorrentTvApi(
config.email, config.password).archive_channels()
except Exception as err:
connection.send_error(404, '%s' % repr(err),
logging.ERROR)
for channel in channels_list:
channel_id = channel.getAttribute('epg_id')
try:
try:
records_list = TorrentTvApi(
config.email,
config.password).records(channel_id, d)
except Exception as err:
connection.send_error(404, '%s' % repr(err),
logging.ERROR)
channel_name = channel.getAttribute('name')
logo = channel.getAttribute('logo')
if logo != '' and config.fullpathlogo:
logo = config.logobase + logo
for record in records_list:
name = record.getAttribute('name')
record_id = record.getAttribute('record_id')
playlistgen.addItem({
'group': channel_name,
'tvg': '',
'name': name,
'url': record_id,
'logo': logo
})
except:
P2pproxy.logger.debug(
'Failed to load archive for %s' % channel_id)
else:
try:
records_list = TorrentTvApi(config.email,
config.password).records(
param_channel, d)
channels_list = TorrentTvApi(
config.email, config.password).archive_channels()
except Exception as err:
connection.send_error(404, '%s' % repr(err),
logging.ERROR)
P2pproxy.logger.debug('Generating archive m3u playlist')
for record in records_list:
record_id = record.getAttribute('record_id')
channel_id = record.getAttribute('epg_id')
name = record.getAttribute('name')
d = datetime.fromtimestamp(
float(
record.getAttribute('time'))).strftime('%H:%M')
n = '%s %s' % (d, name)
logo = ''
for channel in channels_list:
if channel.getAttribute('epg_id') == channel_id:
channel_name = channel.getAttribute('name')
logo = channel.getAttribute('logo')
if channel_name != '':
name = '(' + channel_name + ') ' + name
if logo != '' and config.fullpathlogo:
logo = config.logobase + logo
playlistgen.addItem({
'group': channel_name,
'name': n,
'url': record_id,
'logo': logo,
'tvg': ''
})
P2pproxy.logger.debug('Exporting m3u playlist')
exported = playlistgen.exportm3u(hostport=hostport,
empty_header=True,
archive=True,
fmt=self.params.get(
'fmt', [''])[0])
connection.send_response(200)
connection.send_header('Content-Type',
'audio/mpegurl; charset=utf-8')
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
exported = P2pproxy.compress_method[h].compress(
exported) + P2pproxy.compress_method[h].flush()
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(exported))
connection.end_headers()
connection.wfile.write(exported)
# /archive/?date=[param_date]&channel_id=[param_channel]
else:
param_date = self.params.get('date', [''])[0]
if not param_date: d = datetime.now()
else:
try:
d = parse_date(param_date)
except:
return
param_channel = self.params.get('channel_id', [''])[0]
if not param_channel:
connection.send_error(
500,
'Got /archive/ request but no channel_id specified!',
logging.ERROR)
connection.send_response(200)
connection.send_header('Access-Control-Allow-Origin', '*')
connection.send_header('Connection', 'close')
connection.send_header('Content-Type',
'text/xml;charset=utf-8')
try:
records_list = TorrentTvApi(config.email,
config.password).records(
param_channel,
d.strftime('%d-%m-%Y'),
True)
except Exception as err:
connection.send_error(404, '%s' % repr(err), logging.ERROR)
P2pproxy.logger.debug('Exporting m3u playlist')
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
records_list = P2pproxy.compress_method[h].compress(
records_list) + P2pproxy.compress_method[h].flush()
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(records_list))
connection.end_headers()
connection.wfile.write(records_list)
# Used to generate logomap for the torrenttv plugin
elif connection.reqtype == 'logobase':
logomap = {}
try:
import config.picons.torrenttv as picons
logomap = {
k: v[v.rfind('/') + 1:]
for k, v in picons.logomap.items() if v is not None
}
except:
pass
#try: translations_list = TorrentTvApi(config.email, config.password).translations('all')
#except Exception as err:
# connection.send_error(404, '%s' % repr(err), logging.ERROR)
# return
#logomap.update({ channel.getAttribute('name'):channel.getAttribute('logo') for channel in translations_list })
import requests
url = 'http://hmxuku36whbypzxi.onion/trash/ttv-list/ttv_logo.json'
proxies = {
'http': 'socks5h://192.168.2.1:9100',
'https': 'socks5h://192.168.2.1:9100'
}
with requests.get(url, proxies=proxies, timeout=30) as r:
logomap.update(r.json())
connection.send_response(200)
if self.params.get('format', [''])[0] == 'json':
from requests.compat import json
exported = ensure_binary(
json.dumps(logomap, ensure_ascii=False))
connection.send_header('Content-Type', 'application/json')
else:
exported = "logobase = '%s'\nlogomap = {\n" % config.logobase
exported += ''.join(" u'%s': logobase + '%s',\n" %
(name, logo)
for name, logo in logomap.items())
exported += '}\n'
exported = ensure_binary(exported)
connection.send_header('Content-Type',
'text/plain;charset=utf-8')
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
exported = P2pproxy.compress_method[h].compress(
exported) + P2pproxy.compress_method[h].flush()
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(exported))
connection.end_headers()
connection.wfile.write(exported)
P2pproxy.logger.debug('%s picon channels exported' % len(logomap))
def handle(self, connection, headers_only=False):
P2pproxy.logger.debug('Handling request')
hostport = connection.headers['Host']
self.params = parse_qs(connection.query)
# /channels/ branch
if connection.reqtype in ('channels', 'channels.m3u'):
if connection.path.endswith('play'): # /channels/play?id=[id]
channel_id = self.params.get('id', [''])[0]
if not channel_id:
# /channels/play?id=&_=[epoch timestamp] is Torrent-TV widget proxy check
# P2pProxy simply closes connection on this request sending Server header, so do we
if self.params.get('_', [''])[0]:
P2pproxy.logger.debug('Status check')
response_headers = {
'Content-Type': 'text/plain;charset=utf-8',
'Server': 'P2pProxy/1.0.4.4 HTTPAceProxy',
'Access-Control-Allow-Origin': '*',
'Connection': 'close'
}
connection.send_response(200)
for k, v in response_headers.items():
connection.send_header(k, v)
connection.wfile.write('\r\n')
return
else:
connection.dieWithError(400,
'Bad request') # Bad request
return
if headers_only:
connection.send_response(200)
connection.send_header('Content-Type', 'video/mpeg')
connection.end_headers()
return
stream_type, stream, translations_list = TorrentTvApi(
config.email, config.password).stream_source(channel_id)
name = logo = ''
for channel in translations_list:
if channel.getAttribute('id') == channel_id:
name = channel.getAttribute('name')
logo = channel.getAttribute('logo')
if logo != '' and config.fullpathlogo:
logo = config.logobase + logo
break
if stream_type not in (b'torrent', b'contentid'):
connection.dieWithError(
404, 'Unknown stream type: %s' % stream_type,
logging.ERROR)
return
elif stream_type == b'torrent':
connection.path = '/url/%s/stream.mp4' % quote(stream, '')
elif stream_type == b'contentid':
connection.path = '/content_id/%s/stream.mp4' % stream
connection.splittedpath = connection.path.split('/')
connection.reqtype = connection.splittedpath[1].lower()
connection.handleRequest(headers_only,
name,
logo,
fmt=self.params.get('fmt', [''])[0])
# /channels/?filter=[filter]&group=[group]&type=m3u
elif connection.reqtype == 'channels.m3u' or self.params.get(
'type', [''])[0] == 'm3u':
if headers_only:
connection.send_response(200)
connection.send_header('Content-Type',
'audio/mpegurl; charset=utf-8')
connection.end_headers()
return
param_group = self.params.get('group', [''])[0]
if param_group and 'all' in param_group: param_group = None
translations_list = TorrentTvApi(config.email,
config.password).translations(
self.params.get(
'filter', ['all'])[0])
playlistgen = PlaylistGenerator(
m3uchanneltemplate=config.m3uchanneltemplate)
P2pproxy.logger.debug('Generating requested m3u playlist')
for channel in translations_list:
group_id = channel.getAttribute('group')
if param_group and not group_id in param_group.split(','):
continue # filter channels by &group=1,2,5...
name = channel.getAttribute('name')
group = TorrentTvApi.CATEGORIES[int(group_id)]
cid = channel.getAttribute('id')
logo = channel.getAttribute('logo')
if logo != '' and config.fullpathlogo:
logo = config.logobase + logo
fields = {
'name': name,
'id': cid,
'url': cid,
'group': group,
'logo': logo
}
if channel.getAttribute('epg_id') != '0':
fields['tvgid'] = config.tvgid % fields
playlistgen.addItem(fields)
P2pproxy.logger.debug('Exporting m3u playlist')
exported = playlistgen.exportm3u(
hostport=hostport,
header=config.m3uheadertemplate,
fmt=self.params.get('fmt', [''])[0]).encode('utf-8')
connection.send_response(200)
connection.send_header('Content-Type',
'audio/mpegurl; charset=utf-8')
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
exported = P2pproxy.compress_method[h].compress(
exported) + P2pproxy.compress_method[h].flush()
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(exported))
connection.end_headers()
connection.wfile.write(exported)
# /channels/?filter=[filter]
else:
if headers_only:
connection.send_response(200)
connection.send_header('Access-Control-Allow-Origin', '*')
connection.send_header('Connection', 'close')
connection.send_header('Content-Type',
'text/xml;charset=utf-8')
connection.end_headers()
return
translations_list = TorrentTvApi(
config.email, config.password).translations(
self.params.get('filter', ['all'])[0], True)
P2pproxy.logger.debug('Exporting m3u playlist')
response_headers = {
'Access-Control-Allow-Origin': '*',
'Connection': 'close',
'Content-Type': 'text/xml;charset=utf-8',
'Content-Length': len(translations_list)
}
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
translations_list = P2pproxy.compress_method[h].compress(
translations_list) + P2pproxy.compress_method[h].flush(
)
connection.send_header('Content-Encoding', h)
except:
pass
response_headers['Content-Length'] = len(translations_list)
connection.send_response(200)
for k, v in response_headers.items():
connection.send_header(k, v)
connection.end_headers()
connection.wfile.write(translations_list)
# same as /channels request
elif connection.reqtype == 'xbmc.pvr' and connection.path.endswith(
'playlist'):
connection.send_response(200)
connection.send_header('Access-Control-Allow-Origin', '*')
connection.send_header('Connection', 'close')
connection.send_header('Content-Type', 'text/xml;charset=utf-8')
if headers_only:
connection.end_headers()
return
translations_list = TorrentTvApi(config.email,
config.password).translations(
'all', True)
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
translations_list = P2pproxy.compress_method[h].compress(
translations_list) + P2pproxy.compress_method[h].flush()
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(translations_list))
connection.end_headers()
P2pproxy.logger.debug('Exporting m3u playlist')
connection.wfile.write(translations_list)
# /archive/ branch
elif connection.reqtype == 'archive':
if connection.path.endswith(
('dates', 'dates.m3u')): # /archive/dates.m3u
d = datetime.now()
delta = timedelta(days=1)
playlistgen = PlaylistGenerator()
hostport = connection.headers['Host']
days = int(self.params.get('days', ['7'])[0])
suffix = '&suffix=%s' % self.params.get(
'suffix')[0] if 'suffix' in self.params else ''
for i in range(days):
dfmt = d.strftime('%d-%m-%Y')
url = 'http://%s/archive/playlist/?date=%s%s' % (
hostport, dfmt, suffix)
playlistgen.addItem({
'group': '',
'tvg': '',
'name': dfmt,
'url': url
})
d -= delta
exported = playlistgen.exportm3u(hostport,
empty_header=True,
process_url=False,
fmt=self.params.get(
'fmt',
[''])[0]).encode('utf-8')
connection.send_response(200)
connection.send_header('Content-Type',
'audio/mpegurl; charset=utf-8')
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
exported = P2pproxy.compress_method[h].compress(
exported) + P2pproxy.compress_method[h].flush()
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(exported))
connection.end_headers()
connection.wfile.write(exported)
return
elif connection.path.endswith(
('playlist', 'playlist.m3u')): # /archive/playlist.m3u
dates = []
if 'date' in self.params:
for d in self.params['date']:
dates.append(self.parse_date(d).strftime('%d-%m-%Y'))
else:
d = datetime.now()
delta = timedelta(days=1)
days = int(self.params.get('days', ['7'])[0])
for i in range(days):
dates.append(d.strftime('%d-%m-%Y'))
d -= delta
connection.send_response(200)
connection.send_header('Content-Type',
'audio/mpegurl; charset=utf-8')
if headers_only:
connection.end_headers()
return
channels_list = TorrentTvApi(
config.email, config.password).archive_channels()
hostport = connection.headers['Host']
playlistgen = PlaylistGenerator()
suffix = '&suffix=%s' % self.params.get(
'suffix')[0] if 'suffix' in self.params else ''
for channel in channels_list:
epg_id = channel.getAttribute('epg_id')
name = channel.getAttribute('name')
logo = channel.getAttribute('logo')
if logo != '' and config.fullpathlogo:
logo = config.logobase + logo
for d in dates:
n = name + ' (' + d + ')' if len(dates) > 1 else name
url = 'http://%s/archive/?type=m3u&date=%s&channel_id=%s%s' % (
hostport, d, epg_id, suffix)
playlistgen.addItem({
'group': name,
'tvg': '',
'name': n,
'url': url,
'logo': logo
})
exported = playlistgen.exportm3u(hostport,
empty_header=True,
process_url=False,
fmt=self.params.get(
'fmt',
[''])[0]).encode('utf-8')
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
exported = P2pproxy.compress_method[h].compress(
exported) + P2pproxy.compress_method[h].flush()
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(exported))
connection.end_headers()
connection.wfile.write(exported)
return
elif connection.path.endswith('channels'): # /archive/channels
connection.send_response(200)
connection.send_header('Access-Control-Allow-Origin', '*')
connection.send_header('Connection', 'close')
connection.send_header('Content-Type',
'text/xml;charset=utf-8')
if headers_only: connection.end_headers()
else:
archive_channels = TorrentTvApi(
config.email, config.password).archive_channels(True)
P2pproxy.logger.debug('Exporting m3u playlist')
try:
h = connection.headers.get('Accept-Encoding').split(
',')[0]
archive_channels = P2pproxy.compress_method[h].compress(
archive_channels
) + P2pproxy.compress_method[h].flush()
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length',
len(archive_channels))
connection.end_headers()
connection.wfile.write(archive_channels)
return
if connection.path.endswith(
'play'): # /archive/play?id=[record_id]
record_id = self.params.get('id', [''])[0]
if not record_id:
connection.dieWithError(400, 'Bad request') # Bad request
return
if headers_only:
connection.send_response(200)
connection.send_header("Content-Type", "video/mpeg")
connection.end_headers()
return
stream_type, stream = TorrentTvApi(
config.email,
config.password).archive_stream_source(record_id)
if stream_type not in (b'torrent', b'contentid'):
connection.dieWithError(
404, 'Unknown stream type: %s' % stream_type,
logging.ERROR)
return
elif stream_type == b'torrent':
connection.path = '/url/%s/stream.mp4' % quote(stream, '')
elif stream_type == b'contentid':
connection.path = '/content_id/%s/stream.mp4' % stream
connection.splittedpath = connection.path.split('/')
connection.reqtype = connection.splittedpath[1].lower()
connection.handleRequest(headers_only,
fmt=self.params.get('fmt', [''])[0])
# /archive/?type=m3u&date=[param_date]&channel_id=[param_channel]
elif self.params.get('type', [''])[0] == 'm3u':
if headers_only:
connection.send_response(200)
connection.send_header('Content-Type',
'audio/mpegurl; charset=utf-8')
connection.end_headers()
return
playlistgen = PlaylistGenerator()
param_channel = self.params.get('channel_id', [''])[0]
d = self.get_date_param()
if not param_channel:
channels_list = TorrentTvApi(
config.email, config.password).archive_channels()
for channel in channels_list:
channel_id = channel.getAttribute('epg_id')
try:
records_list = TorrentTvApi(
config.email,
config.password).records(channel_id, d)
channel_name = channel.getAttribute('name')
logo = channel.getAttribute('logo')
if logo != '' and config.fullpathlogo:
logo = config.logobase + logo
for record in records_list:
name = record.getAttribute('name')
record_id = record.getAttribute('record_id')
playlistgen.addItem({
'group': channel_name,
'tvg': '',
'name': name,
'url': record_id,
'logo': logo
})
except:
P2pproxy.logger.debug(
'Failed to load archive for %s' % channel_id)
else:
records_list = TorrentTvApi(config.email,
config.password).records(
param_channel, d)
channels_list = TorrentTvApi(
config.email, config.password).archive_channels()
P2pproxy.logger.debug('Generating archive m3u playlist')
for record in records_list:
record_id = record.getAttribute('record_id')
channel_id = record.getAttribute('epg_id')
name = record.getAttribute('name')
d = datetime.fromtimestamp(
float(
record.getAttribute('time'))).strftime('%H:%M')
n = '%s %s' % (d, name)
logo = ''
for channel in channels_list:
if channel.getAttribute('epg_id') == channel_id:
channel_name = channel.getAttribute('name')
logo = channel.getAttribute('logo')
if channel_name != '':
name = '(' + channel_name + ') ' + name
if logo != '' and config.fullpathlogo:
logo = config.logobase + logo
playlistgen.addItem({
'group': channel_name,
'name': n,
'url': record_id,
'logo': logo,
'tvg': ''
})
P2pproxy.logger.debug('Exporting m3u playlist')
exported = playlistgen.exportm3u(hostport,
empty_header=True,
archive=True,
fmt=self.params.get(
'fmt',
[''])[0]).encode('utf-8')
connection.send_response(200)
connection.send_header('Content-Type',
'audio/mpegurl; charset=utf-8')
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
exported = P2pproxy.compress_method[h].compress(
exported) + P2pproxy.compress_method[h].flush()
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(exported))
connection.end_headers()
connection.wfile.write(exported)
# /archive/?date=[param_date]&channel_id=[param_channel]
else:
param_date = self.params.get('date', [''])[0]
if not param_date: d = datetime.now()
else:
try:
d = parse_date(param_date)
except:
return
param_channel = self.params.get('channel_id', [''])[0]
if not param_channel:
connection.dieWithError(
500,
'Got /archive/ request but no channel_id specified!',
logging.ERROR)
return
connection.send_response(200)
connection.send_header('Access-Control-Allow-Origin', '*')
connection.send_header('Connection', 'close')
connection.send_header('Content-Type',
'text/xml;charset=utf-8')
if headers_only: connection.end_headers()
else:
records_list = TorrentTvApi(config.email,
config.password).records(
param_channel,
d.strftime('%d-%m-%Y'),
True)
P2pproxy.logger.debug('Exporting m3u playlist')
try:
h = connection.headers.get('Accept-Encoding').split(
',')[0]
records_list = P2pproxy.compress_method[h].compress(
records_list) + P2pproxy.compress_method[h].flush(
)
connection.send_header('Content-Encoding', h)
except:
pass
connection.send_header('Content-Length', len(records_list))
connection.end_headers()
connection.wfile.write(records_list)
# Used to generate logomap for the torrenttv plugin
elif connection.reqtype == 'logos':
translations_list = TorrentTvApi(
config.email, config.password).translations('all')
last = translations_list[-1]
connection.send_response(200)
connection.send_header('Content-Type', 'text/plain;charset=utf-8')
connection.end_headers()
connection.wfile.write("logobase = '" + config.logobase + "'\n")
connection.wfile.write('logomap = {\n')
for channel in translations_list:
name = channel.getAttribute('name').encode('utf-8')
logo = channel.getAttribute('logo').encode('utf-8')
connection.wfile.write(" u'%s': logobase + '%s'" %
(name, logo))
connection.wfile.write(
',\n') if not channel == last else connection.wfile.write(
'\n')
connection.wfile.write('}\n')
def downloadPlaylist(self):
self.playlisttime = int(gevent.time.time())
self.playlist = PlaylistGenerator(
m3uchanneltemplate=config.m3uchanneltemplate)
self.channels = {}
m = requests.auth.hashlib.md5()
try:
if self.updatelogos:
try:
translations_list = TorrentTvApi(
p2pconfig.email,
p2pconfig.password).translations('all')
for channel in translations_list:
name = channel.getAttribute('name')
if channel.getAttribute('epg_id') not in ('0', '',
' '):
self.epg_id[name] = 'ttv%s' % channel.getAttribute(
'id')
if not name in self.logomap:
self.logomap[
name] = config.logobase + channel.getAttribute(
'logo')
self.logger.debug('Logos updated')
finally:
self.updatelogos = False # p2pproxy plugin not configured
headers = {'User-Agent': 'Magic Browser'}
with requests.get(config.url,
headers=headers,
proxies=config.proxies,
stream=False,
timeout=30) as r:
if r.encoding is None: r.encoding = 'utf-8'
self.logger.info('TTV playlist %s downloaded' % config.url)
pattern = requests.auth.re.compile(
r',(?P<name>.+) \((?P<group>.+)\)[\r\n]+(?P<url>[^\r\n]+)?'
)
for match in pattern.finditer(r.text,
requests.auth.re.MULTILINE):
itemdict = match.groupdict()
name = itemdict.get('name')
itemdict['logo'] = self.logomap.get(
name,
'http://static.acestream.net/sites/acestream/img/ACE-logo.png'
)
itemdict['tvgid'] = self.epg_id.get(name, '')
url = itemdict['url']
if url.startswith(('acestream://', 'infohash://')) \
or (url.startswith(('http://','https://')) and url.endswith(('.acelive','.acestream','.acemedia'))):
self.channels[name] = url
itemdict['url'] = quote(name.encode('utf-8'),
'') + '.ts'
self.playlist.addItem(itemdict)
m.update(name.encode('utf-8'))
self.etag = '"' + m.hexdigest() + '"'
self.logger.debug('Requested m3u playlist generated')
except requests.exceptions.RequestException:
self.logger.error("Can't download TTV playlist!")
return False
except:
self.logger.error(traceback.format_exc())
return False
return True
def handle(self, connection, headers_only=False):
play = False
# 30 minutes cache
if not self.playlist or (int(gevent.time.time()) - self.playlisttime >
30 * 60):
self.updatelogos = p2pconfig.email != 're.place@me' and p2pconfig.password != 'ReplaceMe'
if not self.downloadPlaylist():
connection.dieWithError()
return
url = urlparse(connection.path)
path = url.path[0:-1] if url.path.endswith('/') else url.path
params = parse_qs(connection.query)
if path.startswith('/torrenttv/channel/'):
name = path.rsplit('.', 1)
if not name[1]:
connection.dieWithError(404,
'Invalid path: %s' % unquote(path),
logging.ERROR)
return
name = unquote(name[0].rsplit('/', 1)[1])
if isinstance(name, bytes): name = name.decode('utf-8') # PY2
url = self.channels.get(name, None)
if url is None:
connection.dieWithError(404, 'Unknown channel: ' + name,
logging.ERROR)
return
elif url.startswith('acestream://'):
connection.path = '/content_id/%s/stream.ts' % url.split(
'/')[2]
elif url.startswith('infohash://'):
connection.path = '/infohash/%s/stream.ts' % url.split('/')[2]
elif url.startswith(('http://', 'https://')) and url.endswith(
('.acelive', '.acestream', '.acemedia')):
connection.path = '/url/%s/stream.ts' % quote(url, '')
connection.splittedpath = connection.path.split('/')
connection.reqtype = connection.splittedpath[1].lower()
play = True
elif self.etag == connection.headers.get('If-None-Match'):
self.logger.debug('ETag matches - returning 304')
connection.send_response(304)
connection.send_header('Connection', 'close')
connection.end_headers()
return
else:
hostport = connection.headers['Host']
path = '' if len(self.channels) == 0 else '/torrenttv/channel'
add_ts = True if path.endswith('/ts') else False
exported = self.playlist.exportm3u(
hostport=hostport,
path=path,
add_ts=add_ts,
header=config.m3uheadertemplate,
fmt=params.get('fmt', [''])[0]).encode('utf-8')
response_headers = {
'Content-Type': 'audio/mpegurl; charset=utf-8',
'Connection': 'close',
'Content-Length': len(exported),
'Access-Control-Allow-Origin': '*',
'ETag': self.etag
}
try:
h = connection.headers.get('Accept-Encoding').split(',')[0]
compress_method = {
'zlib': zlib.compressobj(9, zlib.DEFLATED, zlib.MAX_WBITS),
'deflate': zlib.compressobj(9, zlib.DEFLATED,
-zlib.MAX_WBITS),
'gzip': zlib.compressobj(9, zlib.DEFLATED,
zlib.MAX_WBITS | 16)
}
exported = compress_method[h].compress(
exported) + compress_method[h].flush()
response_headers['Content-Length'] = len(exported)
response_headers['Content-Encoding'] = h
except:
pass
connection.send_response(200)
gevent.joinall([
gevent.spawn(connection.send_header, k, v)
for (k, v) in response_headers.items()
])
connection.end_headers()
if play:
connection.handleRequest(headers_only,
name,
self.logomap.get(name),
fmt=params.get('fmt', [''])[0])
elif not headers_only:
self.logger.debug('Exporting m3u playlist')
connection.wfile.write(exported)
