Initial commit: xStream Downloader
This commit is contained in:
+711
@@ -0,0 +1,711 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
xStream Downloader — Flask App
|
||||
Nutzt den echten xStream cRequestHandler für HTTP-Requests.
|
||||
"""
|
||||
import sys, os, re, io, gzip, hashlib, types, traceback, json, time
|
||||
from pathlib import Path
|
||||
from urllib.request import Request, urlopen, HTTPCookieProcessor, build_opener
|
||||
from urllib.parse import quote, urlencode, urlparse
|
||||
from urllib.error import HTTPError, URLError
|
||||
import ssl
|
||||
|
||||
BASE = Path(__file__).parent.resolve()
|
||||
sys.path.insert(0, str(BASE / 'deps'))
|
||||
sys.path.insert(0, str(BASE))
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
# MOCK KODI MODULES (in sys.modules vorallen imports)
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
|
||||
def _mkmod(name, **attrs):
|
||||
class _M(types.ModuleType):
|
||||
def __getattr__(self, n):
|
||||
return lambda *a, **k: None
|
||||
m = _M(name)
|
||||
for k,v in attrs.items(): setattr(m, k, v)
|
||||
return m
|
||||
|
||||
class _FakeAddon:
|
||||
def __init__(self, *a, **kw):
|
||||
self._id = a[0] if a else 'service.module.resolveurl'
|
||||
def getAddonInfo(self, k):
|
||||
return {'id': self._id, 'name': 'xStream', 'version': '1.0.0',
|
||||
'icon': '', 'profile': '/tmp', 'author': '', 'description': ''}.get(k, '')
|
||||
def openSettings(self, *a, **kw): pass
|
||||
def getSetting(self, k): return ''
|
||||
def setSetting(self, k, v): pass
|
||||
def getLocalizedString(self, k): return str(k)
|
||||
|
||||
class _FakeDialog:
|
||||
def ok(self, *a, **k): pass
|
||||
def yesno(self, *a, **k): return True
|
||||
def select(self, *a, **k): return 0
|
||||
def notification(self, *a, **k): pass
|
||||
def browse(self, *a, **k): return ''
|
||||
|
||||
class _FakeDialogBusy:
|
||||
def create(self, *a, **k): pass
|
||||
def update(self, *a, **k): pass
|
||||
def close(self): pass
|
||||
def isFinished(self): return True
|
||||
|
||||
class _FakeListItem:
|
||||
def __init__(self, *a, **k):
|
||||
self._title = str(a[0]) if a else ''
|
||||
def __getattr__(self, name):
|
||||
return lambda *a, **k: None
|
||||
def setInfo(self, *a, **k): pass
|
||||
def setThumbnail(self, *a, **k): pass
|
||||
def setIsFolder(self, *a, **k): pass
|
||||
def getLabel(self): return self._title
|
||||
def addContextMenuItems(self, *a, **k): pass
|
||||
|
||||
class _FakeWin:
|
||||
def __init__(self, *a, **k): pass
|
||||
def doModal(self, *a, **k): pass
|
||||
def close(self, *a, **k): pass
|
||||
def clearProperty(self, *a, **k): pass
|
||||
def setProperty(self, *a, **k): pass
|
||||
def getProperty(self, *a, **k): return ''
|
||||
|
||||
class _FakePlayer:
|
||||
def __init__(self): pass
|
||||
def play(self, *a, **k): pass
|
||||
def isPlaying(self): return False
|
||||
def isPlayingVideo(self): return False
|
||||
def getPlayingFile(self): return ''
|
||||
def stop(self): pass
|
||||
|
||||
class _FakeMonitor:
|
||||
def __init__(self, *a, **k): pass
|
||||
def abortRequested(self): return False
|
||||
def waitForAbort(self, t=None): return False
|
||||
|
||||
sys.modules['xbmcaddon'] = _mkmod('xbmcaddon', Addon=_FakeAddon)
|
||||
sys.modules['xbmcgui'] = _mkmod('xbmcgui',
|
||||
Dialog=_FakeDialog, DialogBusy=_FakeDialogBusy,
|
||||
Window=_FakeWin, WindowDialog=_FakeWin, WindowXMLDialog=_FakeWin,
|
||||
ControlButton=_FakeDialog, ControlImage=_FakeDialog, ControlFadeLabel=_FakeDialog,
|
||||
ListItem=_FakeListItem,
|
||||
ACTION_MOUSE_LEFT=100, ACTION_PREVIOUS_MENU=10, ACTION_NAV_BACK=92,
|
||||
)
|
||||
sys.modules['xbmcvfs'] = _mkmod('xbmcvfs',
|
||||
translatePath=lambda s: '/tmp',
|
||||
exists=lambda s: False, mkdir=lambda s: True, mkdirs=lambda s: True,
|
||||
delete=lambda s: True, rename=lambda s,d: True, listdir=lambda s: ([],[]),
|
||||
File=type('F',(),{'__enter__':lambda s:s,'__exit__':lambda s,*a:None,
|
||||
'read':lambda s,n=-1:b'','write':lambda s,b:len(b),'close':lambda s:None})(),
|
||||
)
|
||||
sys.modules['xbmc'] = _mkmod('xbmc',
|
||||
translatePath=lambda s: '/tmp', log=lambda s,*a: None,
|
||||
executeJSONRPC=lambda s: '{}',
|
||||
Player=_FakePlayer, Monitor=_FakeMonitor,
|
||||
getCondVisibility=lambda s: 0, sleep=lambda s: None,
|
||||
getInfoLabel=lambda s: '', executebuiltin=lambda s: None,
|
||||
LOGDEBUG=0, LOGINFO=1, LOGWARNING=2, LOGERROR=3, LOGNONE=4, LOGFATAL=5,
|
||||
)
|
||||
sys.modules['xbmcplugin'] = _mkmod('xbmcplugin')
|
||||
sys.modules['xbmcweb'] = _mkmod('xbmcweb')
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
# ECHTER cRequestHandler (nur Standard-Lib + minimale Anpassungen)
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
|
||||
class _FakeConfig:
|
||||
"""cConfig-Ersatz: gibt sichere Defaults zurück."""
|
||||
_settings = {
|
||||
'cacheTime': '1', 'requestTimeout': '10',
|
||||
'bypassDNSlock': 'false', 'volatileHtmlCache': 'false',
|
||||
}
|
||||
def getAddonInfo(self, k):
|
||||
return {'profile': '/tmp', 'id': 'xstream', 'name': 'xStream',
|
||||
'version': '1.0.0', 'icon': '', 'author': '', 'description': ''}.get(k, '')
|
||||
def getSetting(self, k): return self._settings.get(k, '')
|
||||
def setSetting(self, k, v): self._settings[k] = str(v)
|
||||
def getLocalizedString(self, k): return f'[{k}]'
|
||||
|
||||
class _FakeCache:
|
||||
"""cCache-Ersatz: kein Memory-Cache, gibt immer None zurück."""
|
||||
def get(self, key, cache_time):
|
||||
return None
|
||||
def set(self, key, data):
|
||||
pass
|
||||
def clear(self):
|
||||
pass
|
||||
|
||||
class _FakeLogger:
|
||||
def info(self, *a, **k): pass
|
||||
def debug(self, *a, **k): pass
|
||||
def error(self, *a, **k): pass
|
||||
|
||||
def _infoDialog(*a, **k): pass
|
||||
|
||||
# ── Standalone cRequestHandler ──────────────────────────────────
|
||||
class cRequestHandler:
|
||||
"""Echter HTTP-Client, basiert auf dem xStream requestHandler."""
|
||||
persistent_openers = {}
|
||||
|
||||
UA_LIST = [
|
||||
'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:152.0) Gecko/20100101 Firefox/152.0',
|
||||
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36',
|
||||
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15',
|
||||
]
|
||||
|
||||
def __init__(self, sUrl, caching=True, ignoreErrors=False, method='GET',
|
||||
data=None, compression=True, jspost=False, ssl_verify=False):
|
||||
self._sUrl = str(sUrl) if sUrl else ''
|
||||
self._sRealUrl = ''
|
||||
self._USER_AGENT = self.UA_LIST[0]
|
||||
self._aParameters = {}
|
||||
self._headerEntries = {}
|
||||
self._Status = ''
|
||||
self._sResponseHeader = ''
|
||||
self._ssl_verify = ssl_verify
|
||||
self.ignoreDiscard(False)
|
||||
self.ignoreExpired(False)
|
||||
self.caching = caching
|
||||
self.method = method
|
||||
self.data = data
|
||||
self.ignoreErrors = ignoreErrors
|
||||
self.compression = compression
|
||||
self.jspost = jspost
|
||||
self.requestTimeout = 15
|
||||
self.removeBreakLines(True)
|
||||
self.removeNewLines(True)
|
||||
self.__setDefaultHeader()
|
||||
self.isMemoryCacheActive = False
|
||||
self._memCache = None
|
||||
self.__bRemoveNewLines = True
|
||||
self.__bRemoveBreakLines = True
|
||||
|
||||
def __setDefaultHeader(self):
|
||||
self.addHeaderEntry('User-Agent', self._USER_AGENT)
|
||||
self.addHeaderEntry('Accept', '*/*')
|
||||
self.addHeaderEntry('Accept-Language', 'en-US,en;q=0.5')
|
||||
self.addHeaderEntry('Accept-Encoding', 'gzip, deflate' if self.compression else 'identity')
|
||||
|
||||
def removeNewLines(self, b): self.__bRemoveNewLines = b
|
||||
def removeBreakLines(self, b): self.__bRemoveBreakLines = b
|
||||
|
||||
def addHeaderEntry(self, k, v):
|
||||
self._headerEntries[k] = v
|
||||
|
||||
def addParameters(self, k, v, Quote=False):
|
||||
self._aParameters[k] = v if not Quote else quote(str(v))
|
||||
|
||||
def getHeaderEntry(self, k): return self._headerEntries.get(k)
|
||||
|
||||
def getResponseHeader(self): return self._sResponseHeader
|
||||
def getRealUrl(self): return self._sRealUrl or self._sUrl
|
||||
def getStatus(self): return self._Status
|
||||
def getUrl(self): return self._sUrl
|
||||
|
||||
def setUrl(self, url):
|
||||
self._sUrl = str(url)
|
||||
return self
|
||||
|
||||
def ignoreDiscard(self, v): pass
|
||||
def ignoreExpired(self, v): pass
|
||||
|
||||
def getHtml(self, encoding='utf-8'):
|
||||
"""Führt den Request aus und gibt den HTML-Body zurück."""
|
||||
if not self._sUrl or self._sUrl == 'False':
|
||||
return ''
|
||||
try:
|
||||
url = self._sUrl
|
||||
if self._aParameters and self.method == 'GET':
|
||||
url = url + ('&' if '?' in url else '?') + urlencode(self._aParameters)
|
||||
|
||||
req = Request(url, data=self.data, method=self.method)
|
||||
for k, v in self._headerEntries.items():
|
||||
req.add_header(k, v)
|
||||
|
||||
ctx = ssl.create_default_context() if not self._ssl_verify else None
|
||||
if self._ssl_verify is False:
|
||||
ctx = ssl._create_unverified_context()
|
||||
|
||||
opener = build_opener(HTTPCookieProcessor())
|
||||
if ctx:
|
||||
opener.handlers = [h for h in opener.handlers
|
||||
if not isinstance(h, ssl.SSLHandler)] + [HTTPSHandler(context=ctx)]
|
||||
|
||||
with opener.open(req, timeout=self.requestTimeout) as resp:
|
||||
self._sRealUrl = resp.geturl()
|
||||
self._sResponseHeader = str(resp.headers)
|
||||
data = resp.read()
|
||||
|
||||
if self.compression and 'gzip' in resp.headers.get('Content-Encoding', ''):
|
||||
try: data = gzip.decompress(data)
|
||||
except: pass
|
||||
|
||||
text = data.decode(encoding, errors='replace')
|
||||
|
||||
if self.__bRemoveBreakLines:
|
||||
text = re.sub(r'[\r\n]+', '\n', text)
|
||||
if self.__bRemoveNewLines:
|
||||
text = re.sub(r'\n+', ' ', text)
|
||||
|
||||
return text
|
||||
|
||||
except HTTPError as e:
|
||||
self._Status = str(e.code)
|
||||
if self.ignoreErrors: return ''
|
||||
return f'<!-- HTTPError {e.code} -->'
|
||||
except URLError as e:
|
||||
self._Status = str(e.reason)
|
||||
if self.ignoreErrors: return ''
|
||||
return f'<!-- URLError {e.reason} -->'
|
||||
except Exception as e:
|
||||
self._Status = str(e)
|
||||
if self.ignoreErrors: return ''
|
||||
return f'<!-- Error {e} -->'
|
||||
|
||||
def getJson(self):
|
||||
import json
|
||||
text = self.getHtml()
|
||||
if text.strip().startswith('<!--'): return {}
|
||||
try: return json.loads(text)
|
||||
except: return {}
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
# ECHTES cParser (nur Standard-Lib)
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
|
||||
class cParser:
|
||||
@staticmethod
|
||||
def urlEncode(params):
|
||||
if isinstance(params, dict):
|
||||
return urlencode(params)
|
||||
return quote(str(params) if params else '')
|
||||
|
||||
@staticmethod
|
||||
def parseDouble(source, pattern1, pattern2):
|
||||
match1 = re.search(pattern1, source, re.S)
|
||||
if not match1: return []
|
||||
match2 = re.search(pattern2, source[match1.end():], re.S)
|
||||
if not match2: return []
|
||||
return [(match1.group(0), match2.group(0))]
|
||||
|
||||
@staticmethod
|
||||
def parse(source, pattern, flags=0):
|
||||
return re.findall(pattern, source, flags)
|
||||
|
||||
@staticmethod
|
||||
def replace(pattern, replacement, source, count=0):
|
||||
return re.sub(pattern, replacement, source, count)
|
||||
|
||||
@staticmethod
|
||||
def searchSingle(result, searchPattern, outputParam=None, source=None):
|
||||
if source is not None:
|
||||
match = re.search(searchPattern, source, re.S)
|
||||
elif result:
|
||||
match = re.search(searchPattern, str(result), re.S)
|
||||
else:
|
||||
return None
|
||||
if not match: return None
|
||||
return match.group(1) if outputParam and outputParam <= match.lastindex else match.group(0)
|
||||
|
||||
@staticmethod
|
||||
def htmlParse(html):
|
||||
"""Extrahiert Text aus HTML-Tags."""
|
||||
if not html: return []
|
||||
text = re.sub(r'<script[^>]*>.*?</script>', '', html, flags=re.S|re.I)
|
||||
text = re.sub(r'<style[^>]*>.*?</style>', '', text, flags=re.S|re.I)
|
||||
text = re.sub(r'<[^>]+>', ' ', text)
|
||||
text = re.sub(r'\s+', ' ', text).strip()
|
||||
return text.split(' ')
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
# ECHTES ParameterHandler
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
|
||||
class ParameterHandler:
|
||||
def __init__(self, url=''):
|
||||
self._params = {}
|
||||
if url:
|
||||
if '?' in url:
|
||||
_, qs = url.split('?', 1)
|
||||
for part in qs.split('&'):
|
||||
if '=' in part:
|
||||
k, v = part.split('=', 1)
|
||||
self._params[quote(k, safe='')] = quote(v, safe='')
|
||||
def getValue(self, key='', default=''):
|
||||
return self._params.get(key, default)
|
||||
def setParam(self, key, value):
|
||||
self._params[str(key)] = str(value)
|
||||
def getAll(self): return self._params
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
# GUI COLLECTOR (sammelt addFolder-Aufrufe)
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
|
||||
class _CollectingGui:
|
||||
"""Ersetzt cGui und sammelt alle addFolder()-Einträge."""
|
||||
def __init__(self):
|
||||
self.entries = []
|
||||
self.params_stack = [{}]
|
||||
|
||||
def addFolder(self, oGuiElement, params=None, bIsFolder=True, iTotal=0, isHoster=False, **kw):
|
||||
# params kann ParameterHandler, dict, oder string sein
|
||||
url = ''
|
||||
name = ''
|
||||
img = ''
|
||||
fan = ''
|
||||
desc = ''
|
||||
|
||||
if hasattr(oGuiElement, 'getTitle'):
|
||||
name = oGuiElement.getTitle() or ''
|
||||
if hasattr(oGuiElement, 'getMediaUrl'):
|
||||
url = oGuiElement.getMediaUrl() or ''
|
||||
elif hasattr(oGuiElement, '_sUrl'):
|
||||
url = oGuiElement._sUrl or ''
|
||||
if hasattr(oGuiElement, 'getThumbnailImage'):
|
||||
img = oGuiElement.getThumbnailImage() or ''
|
||||
if hasattr(oGuiElement, 'getFanart'):
|
||||
fan = oGuiElement.getFanart() or ''
|
||||
elif isinstance(oGuiElement, str):
|
||||
name = oGuiElement
|
||||
|
||||
# URL aus params extrahieren
|
||||
if not url and params:
|
||||
if hasattr(params, 'getValue'):
|
||||
url = params.getValue('entryUrl') or params.getValue('sUrl') or ''
|
||||
elif isinstance(params, dict):
|
||||
url = params.get('entryUrl') or params.get('sUrl') or ''
|
||||
|
||||
if url and not url.startswith(('http', '/')):
|
||||
url = ''
|
||||
|
||||
if name and url:
|
||||
self.entries.append({
|
||||
'name': name.strip(),
|
||||
'url': url,
|
||||
'img': img,
|
||||
'fan': fan,
|
||||
'desc': desc,
|
||||
})
|
||||
|
||||
def showInfo(self, *a, **k): pass
|
||||
def showError(self, *a, **k): pass
|
||||
def showKeyBoard(self, *a, **k): return ''
|
||||
def showNofication(self, *a, **k): pass
|
||||
def showLanguage(self, *a, **k): pass
|
||||
def updateDirectory(self, *a, **k): pass
|
||||
def setEndOfDirectory(self, *a, **k): pass
|
||||
def setView(self, *a, **k): pass
|
||||
def createListItem(self, *a, **k): return None
|
||||
def getControl(self, *a, **k): return None
|
||||
def doModal(self, *a, **k): pass
|
||||
def close(self): pass
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
# RESOLVEURL LAZY LOADER
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
|
||||
_resolver = None
|
||||
def get_resolver():
|
||||
global _resolver
|
||||
if _resolver is None:
|
||||
import resolveurl
|
||||
_resolver = resolveurl
|
||||
return _resolver
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
# SITE SCANNER
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
|
||||
def scan_sites():
|
||||
sites_dir = BASE / 'xstream' / 'sites'
|
||||
result = []
|
||||
for path in sorted(sites_dir.glob('*.py')):
|
||||
if path.name.startswith('_'): continue
|
||||
try:
|
||||
txt = path.read_text(errors='ignore')
|
||||
except: continue
|
||||
ident_m = re.search(r"SITE_IDENTIFIER\s*=\s*['\"]([^'\"]+)['\"]", txt)
|
||||
name_m = re.search(r"SITE_NAME\s*=\s*['\"]([^'\"]+)['\"]", txt)
|
||||
url_m = re.search(r"URL_MAIN\s*=\s*['\"]([^'\"]+)['\"]", txt)
|
||||
ident = ident_m.group(1) if ident_m else path.stem
|
||||
name = name_m.group(1) if name_m else ident
|
||||
url = url_m.group(1) if url_m else ''
|
||||
has_search = bool(re.search(r'def\s+search\s*\(', txt))
|
||||
result.append({'identifier': ident, 'name': name, 'url': url, 'hasSearch': has_search})
|
||||
return result
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
# SITE EXEC IN SUB-PROCESS
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
|
||||
import multiprocessing
|
||||
|
||||
def _run_site_in_subprocess(func_name, ident, url_arg='', timeout=20):
|
||||
def worker(pipe, func_name, ident, url_arg):
|
||||
# Mocks in diesem subprocess
|
||||
sys.modules['xbmcaddon'] = _mkmod('xbmcaddon', Addon=_FakeAddon)
|
||||
sys.modules['xbmcgui'] = _mkmod('xbmcgui',
|
||||
Dialog=_FakeDialog, DialogBusy=_FakeDialogBusy,
|
||||
Window=_FakeWin, WindowDialog=_FakeWin, WindowXMLDialog=_FakeWin,
|
||||
ListItem=_FakeListItem,
|
||||
ACTION_MOUSE_LEFT=100, ACTION_PREVIOUS_MENU=10, ACTION_NAV_BACK=92,
|
||||
)
|
||||
sys.modules['xbmcvfs'] = _mkmod('xbmcvfs', translatePath=lambda s: '/tmp',
|
||||
exists=lambda s: False, mkdir=lambda s: True, mkdirs=lambda s: True,
|
||||
delete=lambda s: True, rename=lambda s,d: True,
|
||||
File=type('F',(),{'__enter__':lambda s:s,'__exit__':lambda s,*a:None,
|
||||
'read':lambda s,n=-1:b'','write':lambda s,b:len(b),'close':lambda s:None})())
|
||||
sys.modules['xbmc'] = _mkmod('xbmc',
|
||||
translatePath=lambda s: '/tmp', log=lambda s,*a: None,
|
||||
executeJSONRPC=lambda s: '{}',
|
||||
Player=_FakePlayer, Monitor=_FakeMonitor,
|
||||
getCondVisibility=lambda s: 0, sleep=lambda s: None,
|
||||
getInfoLabel=lambda s: '', executebuiltin=lambda s: None,
|
||||
LOGDEBUG=0, LOGINFO=1, LOGWARNING=2, LOGERROR=3, LOGNONE=4,
|
||||
)
|
||||
sys.modules['xbmcplugin'] = _mkmod('xbmcplugin')
|
||||
sys.modules['xbmcweb'] = _mkmod('xbmcweb')
|
||||
|
||||
# Die echten Handler einsetzen
|
||||
sys.modules['cRequestHandler'] = sys.modules.get('cRequestHandler', None)
|
||||
sys.modules['cParser'] = sys.modules.get('cParser', None)
|
||||
|
||||
BASE_PATH = Path('/home/matthiasberner/Schreibtisch/kodi/xstreamDownloader')
|
||||
site_path = BASE_PATH / 'xstream' / 'sites' / f'{ident}.py'
|
||||
xstream_base = BASE_PATH / 'xstream'
|
||||
handler_base = xstream_base / 'resources' / 'lib' / 'handler'
|
||||
|
||||
if not site_path.exists():
|
||||
pipe.send({'error': 'site not found'}); pipe.close(); return
|
||||
|
||||
gui = _CollectingGui()
|
||||
params = ParameterHandler(url_arg) if url_arg else ParameterHandler()
|
||||
|
||||
mod = {
|
||||
'__name__': ident, '__file__': str(site_path),
|
||||
'sys': sys, 'os': os, 'time': time, 're': re,
|
||||
'xbmc': sys.modules['xbmc'], 'xbmcgui': sys.modules['xbmcgui'],
|
||||
'xbmcaddon': sys.modules['xbmcaddon'], 'xbmcvfs': sys.modules['xbmcvfs'],
|
||||
'xbmcplugin': sys.modules['xbmcplugin'],
|
||||
'cGui': gui, 'ParameterHandler': ParameterHandler,
|
||||
'cConfig': _FakeConfig, 'cCache': _FakeCache,
|
||||
'logger': _FakeLogger(), 'infoDialog': _infoDialog,
|
||||
'showEntries': None, 'showHosters': None, 'search': None,
|
||||
}
|
||||
|
||||
old_path = list(sys.path)
|
||||
# WICHTIG: handler_base VOR xstream_base, damit unser standalone cRequestHandler
|
||||
# VOR dem original requestHandler.py gefunden wird
|
||||
sys.path[:0] = [str(handler_base), str(xstream_base), str(xstream_base / 'resources' / 'lib')]
|
||||
|
||||
try:
|
||||
code = site_path.read_text(errors='ignore')
|
||||
exec(compile(code, str(site_path), 'exec'), mod)
|
||||
|
||||
func = mod.get(func_name)
|
||||
if not func:
|
||||
pipe.send({'error': f'{func_name} not found'}); pipe.close(); return
|
||||
|
||||
# Prüfe Signatur
|
||||
import inspect
|
||||
try:
|
||||
sig = inspect.signature(func)
|
||||
wants_url = any(p.name in ('entryUrl', 'url', 'sUrl', 'pageUrl') for p in sig.parameters.values())
|
||||
except (ValueError, TypeError):
|
||||
wants_url = bool(url_arg)
|
||||
|
||||
if wants_url and url_arg:
|
||||
result = func(url_arg)
|
||||
else:
|
||||
result = func()
|
||||
|
||||
if isinstance(result, list):
|
||||
pipe.send({'entries': result})
|
||||
elif hasattr(result, 'entries'):
|
||||
pipe.send({'entries': result.entries})
|
||||
else:
|
||||
pipe.send({'entries': gui.entries})
|
||||
except Exception as e:
|
||||
pipe.send({'error': str(e), 'trace': traceback.format_exc()})
|
||||
finally:
|
||||
sys.path[:] = old_path
|
||||
pipe.close()
|
||||
|
||||
ctx = multiprocessing.get_context('fork')
|
||||
parent_conn, child_conn = ctx.Pipe()
|
||||
p = ctx.Process(target=worker, args=(child_conn, func_name, ident, url_arg))
|
||||
p.daemon = True
|
||||
p.start()
|
||||
p.join(timeout=timeout)
|
||||
if p.is_alive():
|
||||
p.terminate(); p.join(timeout=2)
|
||||
return {'error': 'timeout'}
|
||||
if parent_conn.poll(timeout=2):
|
||||
return parent_conn.recv()
|
||||
return {'error': 'no response'}
|
||||
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
# FLASK APP
|
||||
# ═══════════════════════════════════════════════════════════════
|
||||
|
||||
from flask import Flask, send_from_directory, jsonify, request, send_file
|
||||
import threading
|
||||
|
||||
app = Flask(__name__, static_folder='web')
|
||||
DOWNLOADS = {}
|
||||
dl_lock = threading.Lock()
|
||||
|
||||
def _resolve_real(url):
|
||||
try:
|
||||
r = get_resolver()
|
||||
h = r.resolve(url)
|
||||
return (h, None) if h else (None, 'resolve failed')
|
||||
except Exception as e:
|
||||
return (None, str(e))
|
||||
|
||||
def _start_download(url, title, dl_id):
|
||||
import requests
|
||||
def run():
|
||||
try:
|
||||
final_url, err = _resolve_real(url)
|
||||
if err:
|
||||
DOWNLOADS[dl_id]['error'] = err; DOWNLOADS[dl_id]['status'] = 'error'
|
||||
return
|
||||
r = requests.get(final_url, stream=True, timeout=30,
|
||||
headers={'User-Agent': 'Mozilla/5.0'})
|
||||
r.raise_for_status()
|
||||
total = int(r.headers.get('Content-Length', 0))
|
||||
dl_path = BASE / 'downloads' / f'{dl_id}.mp4'
|
||||
dl_path.parent.mkdir(exist_ok=True)
|
||||
downloaded = 0
|
||||
with open(dl_path, 'wb') as f:
|
||||
for chunk in r.iter_content(65536):
|
||||
if chunk:
|
||||
f.write(chunk)
|
||||
downloaded += len(chunk)
|
||||
if total:
|
||||
DOWNLOADS[dl_id]['progress'] = downloaded / total
|
||||
DOWNLOADS[dl_id]['status'] = 'done'
|
||||
DOWNLOADS[dl_id]['path'] = str(dl_path)
|
||||
DOWNLOADS[dl_id]['progress'] = 1.0
|
||||
except Exception as e:
|
||||
DOWNLOADS[dl_id]['error'] = str(e)
|
||||
DOWNLOADS[dl_id]['status'] = 'error'
|
||||
threading.Thread(target=run, daemon=True).start()
|
||||
|
||||
@app.route('/')
|
||||
def index():
|
||||
return send_from_directory('web', 'index.html')
|
||||
|
||||
@app.route('/<path:fn>')
|
||||
def static_files(fn):
|
||||
return send_from_directory('web', fn)
|
||||
|
||||
@app.route('/api/sites')
|
||||
def api_sites():
|
||||
return jsonify(scan_sites())
|
||||
|
||||
@app.route('/api/sites/<ident>')
|
||||
def api_site_info(ident):
|
||||
for s in scan_sites():
|
||||
if s['identifier'] == ident:
|
||||
return jsonify(s)
|
||||
return jsonify({'error': 'site not found'}), 404
|
||||
|
||||
@app.route('/api/sites/<ident>/entries')
|
||||
def api_entries(ident):
|
||||
url = request.args.get('url', '')
|
||||
DEFAULTS = {
|
||||
'hdfilme': 'https://hdfilme1.co/kinofilme-online/',
|
||||
'fhdfilme': 'https://fhdfilme.stream',
|
||||
'aniworld': 'https://aniworld.to',
|
||||
'serienstream': 'https://serienstream.to',
|
||||
'burningseries': 'https://burningseries.cx',
|
||||
'filmpalast': 'https://filmpalast.to',
|
||||
'kinoger': 'https://kinoger.com',
|
||||
'kkiste': 'https://kkiste.movie',
|
||||
'netzkino': 'https://netzkino.com',
|
||||
'moflix-stream': 'https://moflix-stream.com',
|
||||
'topstreamfilm': 'https://topstreamfilm.com',
|
||||
'streamcloud': 'https://streamcloud.store',
|
||||
'megakino': 'https://megakino.com',
|
||||
'einschalten': 'https://einschalten.io',
|
||||
'internetarchive': 'https://archive.org',
|
||||
'animetoast': 'https://animetoast.org',
|
||||
}
|
||||
if not url and ident in DEFAULTS:
|
||||
url = DEFAULTS[ident]
|
||||
|
||||
for func in ('showEntries', 'showNeues', 'showLatest', 'showNewest'):
|
||||
result = _run_site_in_subprocess(func, ident, url)
|
||||
err = result.get('error', '')
|
||||
skip = ('not found', 'timeout', 'site not found', 'no response')
|
||||
if err and any(s in err for s in skip):
|
||||
continue
|
||||
break
|
||||
|
||||
if 'error' in result and len(result) == 1:
|
||||
return jsonify(result), 500
|
||||
return jsonify(result)
|
||||
|
||||
@app.route('/api/sites/<ident>/hosters')
|
||||
def api_hosters(ident):
|
||||
url = request.args.get('url', '')
|
||||
if not url:
|
||||
return jsonify({'error': 'url required'}), 400
|
||||
result = _run_site_in_subprocess('showHosters', ident, url)
|
||||
if 'error' in result and len(result) == 1:
|
||||
return jsonify(result), 500
|
||||
return jsonify(result)
|
||||
|
||||
@app.route('/api/resolve')
|
||||
def api_resolve():
|
||||
url = request.args.get('url', '')
|
||||
if not url:
|
||||
return jsonify({'error': 'url required'}), 400
|
||||
final_url, err = _resolve_real(url)
|
||||
if err:
|
||||
return jsonify({'error': err}), 400
|
||||
return jsonify({'url': final_url})
|
||||
|
||||
@app.route('/api/download')
|
||||
def api_download():
|
||||
url = request.args.get('url', '')
|
||||
title = request.args.get('title', 'download')
|
||||
if not url:
|
||||
return jsonify({'error': 'url required'}), 400
|
||||
dl_id = hashlib.md5(f'{url}{title}'.encode()).hexdigest()[:12]
|
||||
with dl_lock:
|
||||
if dl_id not in DOWNLOADS:
|
||||
DOWNLOADS[dl_id] = {'id': dl_id, 'title': title, 'url': url,
|
||||
'status': 'starting', 'progress': 0.0,
|
||||
'path': None, 'error': None}
|
||||
_start_download(url, title, dl_id)
|
||||
dl = dict(DOWNLOADS[dl_id])
|
||||
return jsonify(dl)
|
||||
|
||||
@app.route('/api/downloads')
|
||||
def api_downloads():
|
||||
with dl_lock:
|
||||
return jsonify(list(DOWNLOADS.values()))
|
||||
|
||||
@app.route('/api/downloads/<dl_id>')
|
||||
def api_download_info(dl_id):
|
||||
with dl_lock:
|
||||
if dl_id not in DOWNLOADS:
|
||||
return jsonify({'error': 'not found'}), 404
|
||||
return jsonify(dict(DOWNLOADS[dl_id]))
|
||||
|
||||
@app.route('/api/downloads/<dl_id>/file')
|
||||
def api_download_file(dl_id):
|
||||
with dl_lock:
|
||||
dl = DOWNLOADS.get(dl_id, {})
|
||||
path = dl.get('path')
|
||||
if not path or not os.path.exists(path):
|
||||
return jsonify({'error': 'not ready'}), 404
|
||||
return send_file(path, as_attachment=True, download_name=os.path.basename(path))
|
||||
|
||||
if __name__ == '__main__':
|
||||
(BASE / 'downloads').mkdir(exist_ok=True)
|
||||
print(f'xStream Downloader — http://localhost:8765')
|
||||
print(f'Sites: {len(scan_sites())}')
|
||||
app.run(host='0.0.0.0', port=8765, debug=False, threaded=True, use_reloader=False)
|
||||
Reference in New Issue
Block a user