salabots lmt.lv u.c.

changelog.md

@@ -1,3 +1,6 @@
+**06.10.2019**
+- salabots lmt.lv (facebook video)
+
 **08.07.2019**
 - izmaiņas GITā (autonoms projekts)
 

diskcache/__init__.py

@@ -1,36 +0,0 @@
-"DiskCache: disk and file backed cache."
-
-from .core import Cache, Disk, UnknownFileWarning, EmptyDirWarning, Timeout
-from .core import DEFAULT_SETTINGS, ENOVAL, EVICTION_POLICY, UNKNOWN
-from .fanout import FanoutCache
-from .persistent import Deque, Index
-
-__all__ = [
-    'Cache',
-    'Disk',
-    'UnknownFileWarning',
-    'EmptyDirWarning',
-    'Timeout',
-    'DEFAULT_SETTINGS',
-    'ENOVAL',
-    'EVICTION_POLICY',
-    'UNKNOWN',
-    'FanoutCache',
-    'Deque',
-    'Index',
-]
-
-try:
-    from .djangocache import DjangoCache  # pylint: disable=wrong-import-position
-    __all__.append('DjangoCache')
-except Exception:  # pylint: disable=broad-except
-    # Django not installed or not setup so ignore.
-    pass
-
-
-__title__ = 'diskcache'
-__version__ = '3.1.1'
-__build__ = 0x030101
-__author__ = 'Grant Jenks'
-__license__ = 'Apache 2.0'
-__copyright__ = 'Copyright 2016-2018 Grant Jenks'

diskcache/cli.py

@@ -1 +0,0 @@
-"Command line interface to disk cache."

diskcache/fanout.py

@@ -1,595 +0,0 @@
-"Fanout cache automatically shards keys and values."
-
-import itertools as it
-import os.path as op
-import sqlite3
-import time
-
-from .core import ENOVAL, DEFAULT_SETTINGS, Cache, Disk, Timeout
-from .memo import memoize
-from .persistent import Deque, Index
-
-
-class FanoutCache(object):
-    "Cache that shards keys and values."
-    def __init__(self, directory, shards=8, timeout=0.010, disk=Disk,
-                 **settings):
-        """Initialize cache instance.
-
-        :param str directory: cache directory
-        :param int shards: number of shards to distribute writes
-        :param float timeout: SQLite connection timeout
-        :param disk: `Disk` instance for serialization
-        :param settings: any of `DEFAULT_SETTINGS`
-
-        """
-        self._directory = directory
-        self._count = shards
-        default_size_limit = DEFAULT_SETTINGS['size_limit']
-        size_limit = settings.pop('size_limit', default_size_limit) / shards
-        self._shards = tuple(
-            Cache(
-                op.join(directory, '%03d' % num),
-                timeout=timeout,
-                disk=disk,
-                size_limit=size_limit,
-                **settings
-            )
-            for num in range(shards)
-        )
-        self._hash = self._shards[0].disk.hash
-        self._deques = {}
-        self._indexes = {}
-
-
-    @property
-    def directory(self):
-        """Cache directory."""
-        return self._directory
-
-
-    def __getattr__(self, name):
-        return getattr(self._shards[0], name)
-
-
-    def set(self, key, value, expire=None, read=False, tag=None, retry=False):
-        """Set `key` and `value` item in cache.
-
-        When `read` is `True`, `value` should be a file-like object opened
-        for reading in binary mode.
-
-        If database timeout occurs then fails silently unless `retry` is set to
-        `True` (default `False`).
-
-        :param key: key for item
-        :param value: value for item
-        :param float expire: seconds until the key expires
-            (default None, no expiry)
-        :param bool read: read value as raw bytes from file (default False)
-        :param str tag: text to associate with key (default None)
-        :param bool retry: retry if database timeout expires (default False)
-        :return: True if item was set
-
-        """
-        index = self._hash(key) % self._count
-        set_func = self._shards[index].set
-
-        while True:
-            try:
-                return set_func(key, value, expire, read, tag)
-            except Timeout:
-                if retry:
-                    continue
-                else:
-                    return False
-
-
-    def __setitem__(self, key, value):
-        """Set `key` and `value` item in cache.
-
-        Calls :func:`FanoutCache.set` internally with `retry` set to `True`.
-
-        :param key: key for item
-        :param value: value for item
-
-        """
-        self.set(key, value, retry=True)
-
-
-    def add(self, key, value, expire=None, read=False, tag=None, retry=False):
-        """Add `key` and `value` item to cache.
-
-        Similar to `set`, but only add to cache if key not present.
-
-        This operation is atomic. Only one concurrent add operation for given
-        key from separate threads or processes will succeed.
-
-        When `read` is `True`, `value` should be a file-like object opened
-        for reading in binary mode.
-
-        :param key: key for item
-        :param value: value for item
-        :param float expire: seconds until the key expires
-            (default None, no expiry)
-        :param bool read: read value as bytes from file (default False)
-        :param str tag: text to associate with key (default None)
-        :param bool retry: retry if database timeout expires (default False)
-        :return: True if item was added
-
-        """
-        index = self._hash(key) % self._count
-        add_func = self._shards[index].add
-
-        while True:
-            try:
-                return add_func(key, value, expire, read, tag)
-            except Timeout:
-                if retry:
-                    continue
-                else:
-                    return False
-
-
-    def incr(self, key, delta=1, default=0, retry=False):
-        """Increment value by delta for item with key.
-
-        If key is missing and default is None then raise KeyError. Else if key
-        is missing and default is not None then use default for value.
-
-        Operation is atomic. All concurrent increment operations will be
-        counted individually.
-
-        Assumes value may be stored in a SQLite column. Most builds that target
-        machines with 64-bit pointer widths will support 64-bit signed
-        integers.
-
-        :param key: key for item
-        :param int delta: amount to increment (default 1)
-        :param int default: value if key is missing (default 0)
-        :param bool retry: retry if database timeout expires (default False)
-        :return: new value for item on success else None
-        :raises KeyError: if key is not found and default is None
-
-        """
-        index = self._hash(key) % self._count
-        incr_func = self._shards[index].incr
-
-        while True:
-            try:
-                return incr_func(key, delta, default)
-            except Timeout:
-                if retry:
-                    continue
-                else:
-                    return None
-
-
-    def decr(self, key, delta=1, default=0, retry=False):
-        """Decrement value by delta for item with key.
-
-        If key is missing and default is None then raise KeyError. Else if key
-        is missing and default is not None then use default for value.
-
-        Operation is atomic. All concurrent decrement operations will be
-        counted individually.
-
-        Unlike Memcached, negative values are supported. Value may be
-        decremented below zero.
-
-        Assumes value may be stored in a SQLite column. Most builds that target
-        machines with 64-bit pointer widths will support 64-bit signed
-        integers.
-
-        :param key: key for item
-        :param int delta: amount to decrement (default 1)
-        :param int default: value if key is missing (default 0)
-        :param bool retry: retry if database timeout expires (default False)
-        :return: new value for item on success else None
-        :raises KeyError: if key is not found and default is None
-
-        """
-        return self.incr(key, -delta, default, retry)
-
-
-    def get(self, key, default=None, read=False, expire_time=False, tag=False,
-            retry=False):
-        """Retrieve value from cache. If `key` is missing, return `default`.
-
-        If database timeout occurs then returns `default` unless `retry` is set
-        to `True` (default `False`).
-
-        :param key: key for item
-        :param default: return value if key is missing (default None)
-        :param bool read: if True, return file handle to value
-            (default False)
-        :param float expire_time: if True, return expire_time in tuple
-            (default False)
-        :param tag: if True, return tag in tuple (default False)
-        :param bool retry: retry if database timeout expires (default False)
-        :return: value for item if key is found else default
-
-        """
-        index = self._hash(key) % self._count
-        get_func = self._shards[index].get
-
-        while True:
-            try:
-                return get_func(
-                    key, default=default, read=read, expire_time=expire_time,
-                    tag=tag,
-                )
-            except (Timeout, sqlite3.OperationalError):
-                if retry:
-                    continue
-                else:
-                    return default
-
-
-    def __getitem__(self, key):
-        """Return corresponding value for `key` from cache.
-
-        Calls :func:`FanoutCache.get` internally with `retry` set to `True`.
-
-        :param key: key for item
-        :return: value for item
-        :raises KeyError: if key is not found
-
-        """
-        value = self.get(key, default=ENOVAL, retry=True)
-
-        if value is ENOVAL:
-            raise KeyError(key)
-
-        return value
-
-
-    def read(self, key):
-        """Return file handle corresponding to `key` from cache.
-
-        :param key: key for item
-        :return: file open for reading in binary mode
-        :raises KeyError: if key is not found
-
-        """
-        handle = self.get(key, default=ENOVAL, read=True, retry=True)
-        if handle is ENOVAL:
-            raise KeyError(key)
-        return handle
-
-
-    def __contains__(self, key):
-        """Return `True` if `key` matching item is found in cache.
-
-        :param key: key for item
-        :return: True if key is found
-
-        """
-        index = self._hash(key) % self._count
-        return key in self._shards[index]
-
-
-    def pop(self, key, default=None, expire_time=False, tag=False,
-            retry=False):
-        """Remove corresponding item for `key` from cache and return value.
-
-        If `key` is missing, return `default`.
-
-        Operation is atomic. Concurrent operations will be serialized.
-
-        :param key: key for item
-        :param default: return value if key is missing (default None)
-        :param float expire_time: if True, return expire_time in tuple
-            (default False)
-        :param tag: if True, return tag in tuple (default False)
-        :param bool retry: retry if database timeout expires (default False)
-        :return: value for item if key is found else default
-
-        """
-        index = self._hash(key) % self._count
-        pop_func = self._shards[index].pop
-
-        while True:
-            try:
-                return pop_func(
-                    key, default=default, expire_time=expire_time, tag=tag,
-                )
-            except Timeout:
-                if retry:
-                    continue
-                else:
-                    return default
-
-
-    def delete(self, key, retry=False):
-        """Delete corresponding item for `key` from cache.
-
-        Missing keys are ignored.
-
-        If database timeout occurs then fails silently unless `retry` is set to
-        `True` (default `False`).
-
-        :param key: key for item
-        :param bool retry: retry if database timeout expires (default False)
-        :return: True if item was deleted
-
-        """
-        index = self._hash(key) % self._count
-        del_func = self._shards[index].__delitem__
-
-        while True:
-            try:
-                return del_func(key)
-            except Timeout:
-                if retry:
-                    continue
-                else:
-                    return False
-            except KeyError:
-                return False
-
-
-    def __delitem__(self, key):
-        """Delete corresponding item for `key` from cache.
-
-        Calls :func:`FanoutCache.delete` internally with `retry` set to `True`.
-
-        :param key: key for item
-        :raises KeyError: if key is not found
-
-        """
-        deleted = self.delete(key, retry=True)
-
-        if not deleted:
-            raise KeyError(key)
-
-
-    memoize = memoize
-
-
-    def check(self, fix=False):
-        """Check database and file system consistency.
-
-        Intended for use in testing and post-mortem error analysis.
-
-        While checking the cache table for consistency, a writer lock is held
-        on the database. The lock blocks other cache clients from writing to
-        the database. For caches with many file references, the lock may be
-        held for a long time. For example, local benchmarking shows that a
-        cache with 1,000 file references takes ~60ms to check.
-
-        :param bool fix: correct inconsistencies
-        :return: list of warnings
-        :raises Timeout: if database timeout expires
-
-        """
-        return sum((shard.check(fix=fix) for shard in self._shards), [])
-
-
-    def expire(self):
-        """Remove expired items from cache.
-
-        :return: count of items removed
-
-        """
-        return self._remove('expire', args=(time.time(),))
-
-
-    def create_tag_index(self):
-        """Create tag index on cache database.
-
-        It is better to initialize cache with `tag_index=True` than use this.
-
-        :raises Timeout: if database timeout expires
-
-        """
-        for shard in self._shards:
-            shard.create_tag_index()
-
-
-    def drop_tag_index(self):
-        """Drop tag index on cache database.
-
-        :raises Timeout: if database timeout expires
-
-        """
-        for shard in self._shards:
-            shard.drop_tag_index()
-
-
-    def evict(self, tag):
-        """Remove items with matching `tag` from cache.
-
-        :param str tag: tag identifying items
-        :return: count of items removed
-
-        """
-        return self._remove('evict', args=(tag,))
-
-
-    def cull(self):
-        """Cull items from cache until volume is less than size limit.
-
-        :return: count of items removed
-
-        """
-        return self._remove('cull')
-
-
-    def clear(self):
-        """Remove all items from cache.
-
-        :return: count of items removed
-
-        """
-        return self._remove('clear')
-
-
-    def _remove(self, name, args=()):
-        total = 0
-        for shard in self._shards:
-            method = getattr(shard, name)
-            while True:
-                try:
-                    count = method(*args)
-                    total += count
-                except Timeout as timeout:
-                    total += timeout.args[0]
-                else:
-                    break
-        return total
-
-
-    def stats(self, enable=True, reset=False):
-        """Return cache statistics hits and misses.
-
-        :param bool enable: enable collecting statistics (default True)
-        :param bool reset: reset hits and misses to 0 (default False)
-        :return: (hits, misses)
-
-        """
-        results = [shard.stats(enable, reset) for shard in self._shards]
-        return (sum(result[0] for result in results),
-                sum(result[1] for result in results))
-
-
-    def volume(self):
-        """Return estimated total size of cache on disk.
-
-        :return: size in bytes
-
-        """
-        return sum(shard.volume() for shard in self._shards)
-
-
-    def close(self):
-        "Close database connection."
-        for shard in self._shards:
-            shard.close()
-        self._deques.clear()
-        self._indexes.clear()
-
-
-    def __enter__(self):
-        return self
-
-
-    def __exit__(self, *exception):
-        self.close()
-
-
-    def __getstate__(self):
-        return (self._directory, self._count, self.timeout, type(self.disk))
-
-
-    def __setstate__(self, state):
-        self.__init__(*state)
-
-
-    def __iter__(self):
-        "Iterate keys in cache including expired items."
-        iterators = [iter(shard) for shard in self._shards]
-        return it.chain.from_iterable(iterators)
-
-
-    def __reversed__(self):
-        "Reverse iterate keys in cache including expired items."
-        iterators = [reversed(shard) for shard in self._shards]
-        return it.chain.from_iterable(reversed(iterators))
-
-
-    def __len__(self):
-        "Count of items in cache including expired items."
-        return sum(len(shard) for shard in self._shards)
-
-
-    def reset(self, key, value=ENOVAL):
-        """Reset `key` and `value` item from Settings table.
-
-        If `value` is not given, it is reloaded from the Settings
-        table. Otherwise, the Settings table is updated.
-
-        Settings attributes on cache objects are lazy-loaded and
-        read-only. Use `reset` to update the value.
-
-        Settings with the ``sqlite_`` prefix correspond to SQLite
-        pragmas. Updating the value will execute the corresponding PRAGMA
-        statement.
-
-        :param str key: Settings key for item
-        :param value: value for item (optional)
-        :return: updated value for item
-        :raises Timeout: if database timeout expires
-
-        """
-        for shard in self._shards:
-            while True:
-                try:
-                    result = shard.reset(key, value)
-                except Timeout:
-                    pass
-                else:
-                    break
-        return result
-
-
-    def deque(self, name):
-        """Return Deque with given `name` in subdirectory.
-
-        >>> cache = FanoutCache('/tmp/diskcache/fanoutcache')
-        >>> deque = cache.deque('test')
-        >>> deque.clear()
-        >>> deque.extend('abc')
-        >>> deque.popleft()
-        'a'
-        >>> deque.pop()
-        'c'
-        >>> len(deque)
-        1
-
-        :param str name: subdirectory name for Deque
-        :return: Deque with given name
-
-        """
-        _deques = self._deques
-
-        try:
-            return _deques[name]
-        except KeyError:
-            parts = name.split('/')
-            directory = op.join(self._directory, 'deque', *parts)
-            temp = Deque(directory=directory)
-            _deques[name] = temp
-            return temp
-
-
-    def index(self, name):
-        """Return Index with given `name` in subdirectory.
-
-        >>> cache = FanoutCache('/tmp/diskcache/fanoutcache')
-        >>> index = cache.index('test')
-        >>> index.clear()
-        >>> index['abc'] = 123
-        >>> index['def'] = 456
-        >>> index['ghi'] = 789
-        >>> index.popitem()
-        ('ghi', 789)
-        >>> del index['abc']
-        >>> len(index)
-        1
-        >>> index['def']
-        456
-
-        :param str name: subdirectory name for Index
-        :return: Index with given name
-
-        """
-        _indexes = self._indexes
-
-        try:
-            return _indexes[name]
-        except KeyError:
-            parts = name.split('/')
-            directory = op.join(self._directory, 'index', *parts)
-            temp = Index(directory)
-            _indexes[name] = temp
-            return temp

diskcache/memo.py

@@ -1,105 +0,0 @@
-"""Memoization utilities.
-
-"""
-
-from functools import wraps
-
-from .core import ENOVAL
-
-def memoize(cache, name=None, typed=False, expire=None, tag=None):
-    """Memoizing cache decorator.
-
-    Decorator to wrap callable with memoizing function using cache. Repeated
-    calls with the same arguments will lookup result in cache and avoid
-    function evaluation.
-
-    If name is set to None (default), the callable name will be determined
-    automatically.
-
-    If typed is set to True, function arguments of different types will be
-    cached separately. For example, f(3) and f(3.0) will be treated as distinct
-    calls with distinct results.
-
-    The original underlying function is accessible through the __wrapped__
-    attribute. This is useful for introspection, for bypassing the cache, or
-    for rewrapping the function with a different cache.
-
-    >>> from diskcache import FanoutCache
-    >>> cache = FanoutCache('/tmp/diskcache/fanoutcache')
-    >>> @cache.memoize(typed=True, expire=1, tag='fib')
-    ... def fibonacci(number):
-    ...     if number == 0:
-    ...         return 0
-    ...     elif number == 1:
-    ...         return 1
-    ...     else:
-    ...         return fibonacci(number - 1) + fibonacci(number - 2)
-    >>> print(sum(fibonacci(number=value) for value in range(100)))
-    573147844013817084100
-
-    Remember to call memoize when decorating a callable. If you forget, then a
-    TypeError will occur. Note the lack of parenthenses after memoize below:
-
-    >>> @cache.memoize
-    ... def test():
-    ...     pass
-    Traceback (most recent call last):
-        ...
-    TypeError: name cannot be callable
-
-    :param cache: cache to store callable arguments and return values
-    :param str name: name given for callable (default None, automatic)
-    :param bool typed: cache different types separately (default False)
-    :param float expire: seconds until arguments expire
-        (default None, no expiry)
-    :param str tag: text to associate with arguments (default None)
-    :return: callable decorator
-
-    """
-    if callable(name):
-        raise TypeError('name cannot be callable')
-
-    def decorator(function):
-        "Decorator created by memoize call for callable."
-        if name is None:
-            try:
-                reference = function.__qualname__
-            except AttributeError:
-                reference = function.__name__
-
-            reference = function.__module__ + reference
-        else:
-            reference = name
-
-        reference = (reference,)
-
-        @wraps(function)
-        def wrapper(*args, **kwargs):
-            "Wrapper for callable to cache arguments and return values."
-
-            key = reference + args
-
-            if kwargs:
-                key += (ENOVAL,)
-                sorted_items = sorted(kwargs.items())
-
-                for item in sorted_items:
-                    key += item
-
-            if typed:
-                key += tuple(type(arg) for arg in args)
-
-                if kwargs:
-                    key += tuple(type(value) for _, value in sorted_items)
-
-            result = cache.get(key, default=ENOVAL, retry=True)
-
-            if result is ENOVAL:
-                result = function(*args, **kwargs)
-                cache.set(key, result, expire=expire, tag=tag, retry=True)
-
-            return result
-
-        return wrapper
-
-    return decorator

diskcache/stampede.py

@@ -1,78 +0,0 @@
-"Stampede barrier implementation."
-
-import functools as ft
-import math
-import random
-import tempfile
-import time
-
-from .core import Cache, ENOVAL
-
-
-class StampedeBarrier(object):
-    """Stampede barrier mitigates cache stampedes.
-
-    Cache stampedes are also known as dog-piling, cache miss storm, cache
-    choking, or the thundering herd problem.
-
-    Based on research by Vattani, A.; Chierichetti, F.; Lowenstein, K. (2015),
-    Optimal Probabilistic Cache Stampede Prevention,
-    VLDB, pp. 886?897, ISSN 2150-8097
-
-    Example:
-
-    ```python
-    stampede_barrier = StampedeBarrier('/tmp/user_data', expire=3)
-
-    @stampede_barrier
-    def load_user_info(user_id):
-        return database.lookup_user_info_by_id(user_id)
-    ```
-
-    """
-    # pylint: disable=too-few-public-methods
-    def __init__(self, cache=None, expire=None):
-        if isinstance(cache, Cache):
-            pass
-        elif cache is None:
-            cache = Cache(tempfile.mkdtemp())
-        else:
-            cache = Cache(cache)
-
-        self._cache = cache
-        self._expire = expire
-
-    def __call__(self, func):
-        cache = self._cache
-        expire = self._expire
-
-        @ft.wraps(func)
-        def wrapper(*args, **kwargs):
-            "Wrapper function to cache function result."
-            key = (args, kwargs)
-
-            try:
-                result, expire_time, delta = cache.get(
-                    key, default=ENOVAL, expire_time=True, tag=True
-                )
-
-                if result is ENOVAL:
-                    raise KeyError
-
-                now = time.time()
-                ttl = expire_time - now
-
-                if (-delta * math.log(random.random())) < ttl:
-                    return result
-
-            except KeyError:
-                pass
-
-            now = time.time()
-            result = func(*args, **kwargs)
-            delta = time.time() - now
-            cache.set(key, result, expire=expire, tag=delta)
-
-            return result
-
-        return wrapper

ltcproxy.py

@@ -152,8 +152,13 @@ def get_live_chunk(key, ch, tail):
             stream_url = s[ch]
             mediaid= s["m"+ch]
         else:
-            print "No stream_url %s in cache" % path0
-            raise bottle.HTTPError(500)
+            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

playstreamproxy.py

@@ -135,10 +135,14 @@ class StreamHandler(BaseHTTPRequestHandler):
                     content = sources.get_streams(data)
                 elif cmd == "get_info":
                     content = sources.get_info(data)
+                elif cmd == "get_image":
+                    content = sources.get_image(data)
                 elif cmd == "is_video":
                     content = sources.is_video(data)
                 elif cmd == "options_read":
                     content = sources.options_read(data)
+                elif cmd == "options_write":
+                    content = sources.options_write(data)
                 else:
                     content = []
                 txt = json.dumps(content)

sources/lmt.py

@@ -130,7 +130,7 @@ Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
         r = requests.get(url,headers = headers)
         return r.content
         #result = self._http_request(url,params,headers=headers)
-        return result
+        # return result
 
     def get_streams(self,data):
         print "[lmt] get_streams:", data
@@ -150,9 +150,13 @@ Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
         if img.startswith("//"):
             img = "http:" + img
         desc = title + "\n" + re.search('<meta property="og:description" content="([^"]+)">', r, re.IGNORECASE | re.DOTALL).group(1)
+
         m = re.search('file: "([^"]+)"', r, re.IGNORECASE)
         if m:
+            #  LMT file
             data2 = m.group(1)
+            if not data2.startswith("http"):
+                data2 = "http:" + data2
             stream = util.item()
             stream["name"] = title
             stream["url"] = data2
@@ -160,9 +164,11 @@ Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
             stream["desc"] = desc
             stream["resolver"] = "lmt"
             return [stream]
-        elif re.search('src="http*://www.youtube.com/embed/([\w-]+).*"',r):
-            m = re.search('src="http*://www.youtube.com/embed/([\w-]+).*"',r)
-            video_id = m.group(1)
+
+        elif re.search(r'src="(http*:)*//www.youtube.com/embed/([\w-]+).*"', r):
+            #  Youtube
+            m = re.search(r'src="(http*:)*//www.youtube.com/embed/([\w-]+).*"', r)
+            video_id = m.group(2)
             #http://www.youtube.com/embed/RUyQ_JJ6A84?rel=0&fs=1&wmode=transparent
             data2 = YouTubeVideoUrl().extract(video_id)
             s = util.item()
@@ -219,6 +225,22 @@ Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
             sdata = js["data"]["versions"][ver]
             s["url"] = "http:" + sdata[1]["src"]
             return [s]
+        elif re.search('src="(https://www.facebook.com/plugins/video.php[^"]+)', r):
+            m = re.search('src="(https://www.facebook.com/plugins/video.php[^"]+)', r)
+            url = m.group(1)
+            r2 = self._http_request(url)
+            if not r2:
+                raise Exception("No stream found")
+            streams = []
+            for it in re.findall('"(sd|hd)_src":"([^"]+)', r2):
+                s = util.item()
+                s["name"] = tite
+                s["desc"] = desc
+                s["img"] = img
+                s["resolver"] = "lmt"
+                s["url"] = it[1].replace("\\", "")
+                s["quality"] = it[0]
+            return [s]
 
         else:
             raise Exception("No stream found")

test_url.py

@@ -1,23 +0,0 @@
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
-
-from util import streamproxy_encode3, streamproxy_decode3
-dt2ts = lambda dt: int(time.mktime(dt.timetuple()))
-ts2dt = lambda ts: datetime.datetime.fromtimestamp(ts)
-import time, datetime, pytz
-from datetime import datetime as dt
-
-# "20190302203000 +0200" panorāma
-print dt2ts(dt.now())
-print dt2ts(dt(2019, 3, 2, 20, 30))
-#print urlp
-# ltc::content/live-streams/101?include=quality
-print streamproxy_encode3("playstream", "ltc::content/catchup/101?start=1551551400")
-# http://localhost:8880/playstream/ltc%3A%3Acontent%2Fcatchup%2F101%3Fstart%3D1551551400/
-
-print streamproxy_encode3("playstream", "replay::tiesraide/ltv1")
-print streamproxy_encode3("playstream", "tvdom::tiesraides/ltv1/")
-print streamproxy_encode3("playstream", "tvplay::asset/10311641")
-print streamproxy_encode3("playstream", "xtv::rigatv24/video/Zw4pVPqr7OX-festivals_mainam_pasauli_sakam_ar_sevi")
-print streamproxy_encode3("playstream", "iplayer::episodes/b094f49s")
-#cmd, data, headers, qs = streamproxy_decode3(urlp)