update

addon.py

@@ -1,16 +1,30 @@
-import os,os.path,sys, urllib
-from xbmcswift2 import Plugin, ListItem
-from xbmcswift2 import xbmc, xbmcgui, xbmcplugin
+# -*- coding: utf-8 -*-
+import os,os.path,sys, urllib, traceback
+from kodiswift import Plugin, ListItem
+from kodiswift import xbmc, xbmcgui, xbmcplugin, xbmcvfs, CLI_MODE
 from resources.lib import ContentSources, util
 
 plugin = Plugin()
+plugin.load_addon_settings()
+
 sources = ContentSources.ContentSources(os.path.join(os.path.dirname(__file__),"resources","lib","sources"))
+for source in sources.plugins:
+    if not ("options" in dir(sources.plugins[source]) and sources.plugins[source].options): continue
+    options = sources.plugins[source].options
+    if not options: continue
+    for option in options:
+        key="%s_%s"%(source,option)
+        if key in ("viaplay_device"): continue # exception list,
+        value = plugin.get_setting(key)
+        options[option] = value
+    sources.plugins[source].options_write(options)
 prefix = ""
 
 @plugin.route(".+" )
 def main():
     global prefix
     prefix = "%s://%s/"%(plugin.request.scheme,plugin.request.netloc)
+    plugin.set_content("movies")
     data = plugin.request.url.replace(prefix,"")
     data = urllib.unquote(data)
     if not data:
@@ -19,22 +33,27 @@ def main():
         try:
             streams = sources.get_streams(data)
         except Exception,e:
-            plugin.notify(str(e),"",10000)
-            return None
+            #xbmcgui.Dialog().ok("Error",unicode(e))
+            plugin.notify(unicode(e),"Error",10000, xbmcgui.NOTIFICATION_ERROR)
+            traceback.print_exc()
+            return plugin.set_resolved_url(None)
         if streams:
             return play_video(streams)
         else:
-            plugin.notify("No streams found!",10000)
-            return None
+            plugin.notify("No streams found!","Error",10000,xbmcgui.NOTIFICATION_ERROR)
+            return plugin.set_resolved_url(None)
     else:
         if "{0}" in data:
-            q = plugin.keyboard(default=None, heading=None, hidden=False)
+            q = plugin.keyboard(default=None, heading="Search for", hidden=False)
             data = data.format(q)
         try:
             items = get_list(data)
         except Exception,e:
-            plugin.notify(str(e),"")
-            return None
+            plugin.notify(unicode(e),"Error",10000,xbmcgui.NOTIFICATION_ERROR)
+            traceback.print_exc()
+            return []
+        #xbmc.executebuiltin('Container.SetViewMode(500)')
+        plugin.set_view_mode(50)
         return items
 
 def get_list(data):
@@ -47,49 +66,51 @@ def get_list(data):
         is_playable = True if  sources.is_video(item[1]) else False
         img = item[2]
         desc = item[3].decode("utf8")
+        context_menu = [("Add to PlayStream favorites",
+                         'RunScript(special://home/addons/%s/context_menu.py,"add","%s","%s","%s","%s")'%(plugin.id, title,  data2,img, desc))]
         items.append({
             "label": title,
             "path": data2,
             "thumbnail":img,
             "info":{"plot":desc},
-            "is_playable":is_playable
+            "is_playable":is_playable,
+            "context_menu": context_menu,
         })
     return items
 
 def play_video(streams):
-    stream = streams[0]
+    if len(streams)>1:
+        slist = []
+        for s in streams:
+            slist.append("%s [%s,%s]"%(s["name"],s["quality"],s["lang"]))
+        res = xbmcgui.Dialog().select("Select stream",slist) if not CLI_MODE else 0
+        #res = xbmcgui.Dialog().contextmenu(slist) if not CLI_MODE else 0
+        stream = streams[res]
+    else:
+        stream = streams[0]
     subfiles = []
-    print "play_video ",stream["url"]
+    stream = util.stream_change(stream)
+    print "play_video ", stream["url"]
     if "subs" in stream and stream["subs"]:
         for sub in stream["subs"]:
             suburl = sub["url"]
             subs = util.Captions(suburl)
             srt = subs.get_srt()
-            subfile = plugin.temp_fn("subtitles.srt")
+            #subfile = plugin.temp_fn("subtitles.srt")
             subfile = os.path.join(os.path.dirname(__file__),sub["lang"]+".srt")
             f = open(subfile, "w")
             f.write(srt)
-            # TODO nestrada uz ltc.lv subtititliem!
-            # import codecs
-            #f = codecs.open(subfile, 'w', "utf-8-sig")
-            #f.write(srt.decode("utf8"))
             f.close()
             subfiles.append(subfile)
     item = ListItem(label=stream["name"], thumbnail=stream["img"], path=stream["url"])
     item.set_info("video",{"plot":stream["desc"]})
     item.set_is_playable(True)
-
-    item = plugin._listitemify(item)
-    item.set_played(True)
-    succeeded = True
-    xbmcplugin.setResolvedUrl(plugin.handle, succeeded, item.as_xbmc_listitem())
-
-    #plugin.play_video(item)
-    for subfile in subfiles:
-        print "Add subtitle file - ", subfile
-        plugin._add_subtitles(subfile)
-        #break # TODO multipe subtitles?
-    return [item]
+    return plugin.set_resolved_url(item,subfiles)
+    #return plugin.play_video(item)
 
 if __name__ == '__main__':
-    plugin.run()
+    if CLI_MODE:
+        from kodiswift.cli.cli import main as start
+        start()
+    else:
+        plugin.run()

addon.xml

@@ -1,8 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<addon version="0.1.3" id="plugin.video.playstream" name="PlayStream" provider-name="ivars777"  >
+<addon version="0.1.25" id="plugin.video.playstream" name="PlayStream" provider-name="ivars777"  >
   <requires>
     <import addon="xbmc.python" version="2.1.0"/>
-    <import addon="script.module.xbmcswift2" version="2.4.0" />
     <import addon="script.module.requests" />
     <import addon="script.module.simplejson" />
   </requires>

changelog.md

@@ -1,5 +1,5 @@
 **0.1.2** (12.02.2016):
 - initial exprerimental version
 
-**0.1.3** (14.02.2016):
+**0.1.5** (14.02.2016):
 - addon settings added

deploy.bat

@@ -0,0 +1,59 @@
+@echo off
+if (abox)==(%1%) (
+	set TARGET=b:\sdcard\Android\data\org.xbmc.kodi\files\.kodi\addons\plugin.video.playstream\
+) else (
+    set TARGET=C:\Users\User\AppData\Roaming\Kodi\addons\plugin.video.playstream\
+)
+
+
+for %%f in (
+readme.md
+changelog.md
+addon.xml
+addon.py
+context_menu.py
+icon.png
+kodiswift\*.py
+resources\__init__.py
+resources\settings.xml
+resources\icon.png
+resources\language\English\*
+resources\lib\__init__.py
+resources\lib\ContentSources.py
+resources\lib\resolver.py
+resources\lib\util.py
+resources\lib\demjson.py
+resources\lib\ordereddict.py
+resources\lib\sources\__init__.py
+resources\lib\sources\SourceBase.py
+resources\lib\sources\cinemalive.py
+resources\lib\sources\config.py
+resources\lib\sources\euronews.py
+resources\lib\sources\filmix.py
+resources\lib\sources\filmon.py
+resources\lib\sources\iplayer.py
+resources\lib\sources\movieplace.py
+resources\lib\sources\ltc.py
+resources\lib\sources\mtgplay.py
+resources\lib\sources\play24.py
+resources\lib\sources\replay.py
+resources\lib\sources\serialguru.py
+resources\lib\sources\tvdom.py
+resources\lib\sources\ustvnow.py
+resources\lib\sources\viaplay.py
+resources\lib\sources\filmas.py
+resources\lib\sources\YouTubeVideoUrl.py
+resources\lib\sources\jsinterp.py
+resources\lib\sources\swfinterp.py
+resources\lib\sources\streams.cfg
+resources\lib\resolvers\__init__.py
+resources\lib\resolvers\aadecode.py
+resources\lib\resolvers\hqqresolver.py
+resources\lib\resolvers\openload3.py
+resources\lib\resolvers\hdgo.py
+resources\lib\resolvers\kapnob.py
+resources\lib\resolvers\kodik.py
+resources\lib\resolvers\youtuberesolver.py
+) do echo f | xcopy /y /d  %%f %TARGET%%%f
+
+pause

kmake.bat

@@ -1,4 +1,4 @@
-@echo off
+@echo on
 :=== Parameters ===
 
 python get_version.py addon.xml >version.txt
@@ -19,20 +19,23 @@ set TAR=\MinGW\msys\1.0\bin\tar.exe
 rem set ZIP=\Program Files (x86)\Gow\bin\zip.exe
 
 :=== data files ===
-if exist %pack_name% rm -r -f "%pack_name%""
+if exist "%pack_name%" rm -r -f "%pack_name%"
 mkdir "%pack_name%""
 if not exist %release_dir% mkdir %release_dir%
 if not exist %repo_dir% mkdir %repo_dir%
 if not exist  %repo_dir%%pack_name% mkdir  %repo_dir%%pack_name%
-if not exist  %release_dir% mkdir %release_dir%
+
 
 for %%f in (
 readme.md
 changelog.md
 addon.xml
 addon.py
+context_menu.py
 icon.png
+kodiswift\*.py
 resources\__init__.py
+resources\settings.xml
 resources\icon.png
 resources\language\English\*
 resources\lib\__init__.py
@@ -40,6 +43,7 @@ resources\lib\ContentSources.py
 resources\lib\resolver.py
 resources\lib\util.py
 resources\lib\demjson.py
+resources\lib\ordereddict.py
 resources\lib\sources\__init__.py
 resources\lib\sources\SourceBase.py
 resources\lib\sources\cinemalive.py
@@ -57,6 +61,7 @@ resources\lib\sources\serialguru.py
 resources\lib\sources\tvdom.py
 resources\lib\sources\ustvnow.py
 resources\lib\sources\viaplay.py
+resources\lib\sources\viaplay.py
 resources\lib\sources\YouTubeVideoUrl.py
 resources\lib\sources\jsinterp.py
 resources\lib\sources\swfinterp.py
@@ -73,7 +78,7 @@ resources\lib\resolvers\youtuberesolver.py
 
 if exist  %release_dir%%pack_name%-%ver%.zip rm %release_dir%%pack_name%-%ver%.zip
 rem zip  -r %release_dir%%pack_name%-%ver%.zip %pack_name%
-"C:\Program Files\WinRAR\winrar.exe" a -afzip -r %release_dir%%pack_name%-%ver%.zip plugin.video.playstream
+"C:\Program Files\WinRAR\winrar.exe" a -afzip -r %release_dir%%pack_name%-%ver%.zip %pack_name%
 copy  addon.xml  %repo_dir%%pack_name%\addon.xml /Y
 copy  %release_dir%%pack_name%-%ver%.zip  %repo_dir%%pack_name%\%pack_name%-%ver%.zip /Y
 python -c "import hashlib; print hashlib.md5(open(r'%repo_dir%%pack_name%\%pack_name%-%ver%.zip','r').read()).hexdigest()" >%repo_dir%%pack_name%\%pack_name%-%ver%.zip.md5
@@ -84,4 +89,5 @@ pushd  %repo_dir%..
 call update_repo.bat
 xcopy /s /y repo %feed_dir%
 popd
+pause
 

kodiswift/__init__.py

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift
+----------
+
+A micro framework to enable rapid development of Kodi plugins.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import absolute_import
+
+from types import ModuleType
+
+try:
+    import xbmc
+    import xbmcgui
+    import xbmcplugin
+    import xbmcaddon
+    import xbmcvfs
+
+    CLI_MODE = False
+except ImportError:
+    CLI_MODE = True
+    import sys
+    from kodiswift.logger import log
+
+    # Mock the Kodi modules
+    from kodiswift.mockxbmc import xbmc, xbmcgui, xbmcplugin, xbmcaddon, xbmcvfs
+
+    class _Module(ModuleType):
+        """A wrapper class for a module used to override __getattr__.
+        This class will behave normally for any existing module attributes.
+        For any attributes which do not exist in the wrapped module, a mock
+        function will be returned. This function will also return itself
+        enabling multiple mock function calls.
+        """
+
+        def __init__(self, wrapped=None):
+            self.wrapped = wrapped
+            if wrapped:
+                self.__dict__.update(wrapped.__dict__)
+
+        def __getattr__(self, name):
+            """Returns any existing attr for the wrapped module or returns a
+            mock function for anything else. Never raises an AttributeError.
+            """
+            try:
+                return getattr(self.wrapped, name)
+            except AttributeError:
+                # noinspection PyUnusedLocal
+                # pylint disable=unused-argument
+                def func(*args, **kwargs):
+                    """A mock function which returns itself, enabling chainable
+                    function calls.
+                    """
+                    log.warning('The %s method has not been implemented on '
+                                'the CLI. Your code might not work properly '
+                                'when calling it.', name)
+                    return self
+
+                return func
+
+    xbmc = _Module(xbmc)
+    xbmcgui = _Module(xbmcgui)
+    xbmcplugin = _Module(xbmcplugin)
+    xbmcaddon = _Module(xbmcaddon)
+    xbmcvfs = _Module(xbmcvfs)
+    for m in (xbmc, xbmcgui, xbmcplugin, xbmcaddon, xbmcvfs):
+        name = reversed(m.__name__.rsplit('.', 1)).next()
+        sys.modules[name] = m
+
+from kodiswift.storage import TimedStorage
+from kodiswift.request import Request
+from kodiswift.common import (kodi_url, clean_dict, pickle_dict, unpickle_args,
+                              unpickle_dict, download_page)
+from kodiswift.constants import SortMethod
+from kodiswift.listitem import ListItem
+from kodiswift.logger import setup_log
+from kodiswift.module import Module
+from kodiswift.urls import AmbiguousUrlException, NotFoundException, UrlRule
+from kodiswift.xbmcmixin import XBMCMixin
+from kodiswift.plugin import Plugin

kodiswift/actions.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift.actions
+------------------
+
+This module contains wrapper functions for Kodi built-in functions.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+
+__all__ = ['background', 'update_view']
+
+
+def background(url):
+    """This action will run an addon in the background for the provided URL.
+
+    See 'RunPlugin()' at
+    http://kodi.wiki/view/List_of_built-in_functions
+
+    Args:
+        url (str): Full path must be specified.
+            Does not work for folder plugins.
+
+    Returns:
+        str: String of the builtin command
+    """
+    return 'RunPlugin(%s)' % url
+
+
+def update_view(url):
+    """This action will update the current container view with provided url.
+
+    See 'Container.Update()' at
+    http://kodi.wiki/view/List_of_built-in_functions
+    """
+    return 'Container.Update(%s)' % url

kodiswift/cli/__init__.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+"""
+    kodiswift.cli
+    ----------------
+
+    This package contains modules that are used only when running kodiswift in
+    CLI mode. Nothing from this package should be called from addon code.
+
+    :copyright: (c) 2012 by Jonathan Beluch
+    :license: GPLv3, see LICENSE for more details.
+"""
+
+
+def Option(*args, **kwargs):
+    """Returns a tuple of args, kwargs passed to the function. Useful for
+    recording arguments for future function calls.
+    """
+    return args, kwargs

kodiswift/cli/app.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift.cli.app
+----------------
+
+This package contains the code which runs plugins from the command line.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import absolute_import
+
+import logging
+import os
+import sys
+from xml.etree import ElementTree as Et
+
+from kodiswift import Plugin, ListItem, logger
+from kodiswift.cli import Option
+from kodiswift.cli.console import (display_listitems, continue_or_quit,
+                                   get_user_choice)
+from kodiswift.common import Modes
+
+__all__ = ['get_addon_module_name', 'crawl', 'RunCommand', 'PluginManager',
+           'setup_options', 'patch_sysargv', 'patch_plugin', 'once',
+           'interactive']
+
+
+class RunCommand(object):
+    """A CLI command to run a plugin."""
+
+    command = 'run'
+    usage = '%prog run [once|interactive|crawl] [url]'
+    option_list = (
+        Option('-q', '--quiet', action='store_true',
+               help='set logging level to quiet'),
+        Option('-v', '--verbose', action='store_true',
+               help='set logging level to verbose'),
+    )
+
+    @staticmethod
+    def run(opts, args):
+        """The run method for the 'run' command. Executes a plugin from the
+        command line.
+        """
+        setup_options(opts)
+
+        mode = Modes.ONCE
+        if len(args) > 0 and hasattr(Modes, args[0].upper()):
+            _mode = args.pop(0).upper()
+            mode = getattr(Modes, _mode)
+
+        url = None
+        if len(args) > 0:
+            # A url was specified
+            url = args.pop(0)
+
+        plugin_mgr = PluginManager.load_plugin_from_addon_xml(mode, url)
+        plugin_mgr.run()
+
+
+def setup_options(opts):
+    """Takes any actions necessary based on command line options"""
+    if opts.quiet:
+        logger.log.setLevel(logging.WARNING)
+        logger.GLOBAL_LOG_LEVEL = logging.WARNING
+
+    if opts.verbose:
+        logger.log.setLevel(logging.DEBUG)
+        logger.GLOBAL_LOG_LEVEL = logging.DEBUG
+
+
+def get_addon_module_name(addon_xml_filename):
+    """Attempts to extract a module name for the given addon's addon.xml file.
+    Looks for the 'xbmc.python.pluginsource' extension node and returns the
+    addon's filename without the .py suffix.
+    """
+    try:
+        xml = Et.parse(addon_xml_filename).getroot()
+    except IOError:
+        sys.exit('Cannot find an addon.xml file in the current working '
+                 'directory. Please run this command from the root directory '
+                 'of an addon.')
+
+    try:
+        plugin_source = (ext for ext in xml.findall('extension') if
+                         ext.get('point') == 'xbmc.python.pluginsource').next()
+    except StopIteration:
+        sys.exit('ERROR, no pluginsource in addonxml')
+
+    return plugin_source.get('library').split('.')[0]
+
+
+class PluginManager(object):
+    """A class to handle running a plugin in CLI mode. Handles setup state
+    before calling plugin.run().
+    """
+
+    @classmethod
+    def load_plugin_from_addon_xml(cls, mode, url):
+        """Attempts to import a plugin's source code and find an instance of
+        :class:`~kodiswift.Plugin`. Returns an instance of PluginManager if
+        successful.
+        """
+        cwd = os.getcwd()
+        sys.path.insert(0, cwd)
+        module_name = get_addon_module_name(os.path.join(cwd, 'addon.xml'))
+        addon = __import__(module_name)
+
+        # Find the first instance of kodiswift.Plugin
+        try:
+            plugin = (attr_value for attr_value in vars(addon).values()
+                      if isinstance(attr_value, Plugin)).next()
+        except StopIteration:
+            sys.exit('Could not find a Plugin instance in %s.py' % module_name)
+
+        return cls(plugin, mode, url)
+
+    def __init__(self, plugin, mode, url):
+        self.plugin = plugin
+        self.mode = mode
+        self.url = url
+
+    def run(self):
+        """This method runs the the plugin in the appropriate mode parsed from
+        the command line options.
+        """
+        handle = 0
+        handlers = {
+            Modes.ONCE: once,
+            Modes.CRAWL: crawl,
+            Modes.INTERACTIVE: interactive,
+        }
+        handler = handlers[self.mode]
+        patch_sysargv(self.url or 'plugin://%s/' % self.plugin.id, handle)
+        return handler(self.plugin)
+
+
+def patch_sysargv(*args):
+    """Patches sys.argv with the provided args"""
+    sys.argv = args[:]
+
+
+def patch_plugin(plugin, path, handle=None):
+    """Patches a few attributes of a plugin instance to enable a new call to
+    plugin.run()
+    """
+    if handle is None:
+        handle = plugin.request.handle
+    patch_sysargv(path, handle)
+    plugin._end_of_directory = False
+
+
+def once(plugin, parent_stack=None):
+    """A run mode for the CLI that runs the plugin once and exits."""
+    plugin.clear_added_items()
+    items = plugin.run()
+
+    # if update_listing=True, we need to remove the last url from the parent
+    # stack
+    if parent_stack and plugin._update_listing:
+        del parent_stack[-1]
+
+    # if we have parent items, include the most recent in the display
+    if parent_stack:
+        items.insert(0, parent_stack[-1])
+
+    display_listitems(items, plugin.request.url)
+    return items
+
+
+def interactive(plugin):
+    """A run mode for the CLI that runs the plugin in a loop based on user
+    input.
+    """
+    items = [item for item in once(plugin) if not item.get_played()]
+    parent_stack = []  # Keep track of parents so we can have a '..' option
+
+    selected_item = get_user_choice(items)
+    while selected_item is not None:
+        if parent_stack and selected_item == parent_stack[-1]:
+            # User selected the parent item, remove from list
+            parent_stack.pop()
+        else:
+            # User selected non parent item, add current url to parent stack
+            parent_stack.append(ListItem.from_dict(label='..',
+                                                   path=plugin.request.url))
+        patch_plugin(plugin, selected_item.get_path())
+
+        items = [item for item in once(plugin, parent_stack=parent_stack)
+                 if not item.get_played()]
+        selected_item = get_user_choice(items)
+
+
+def crawl(plugin):
+    """Performs a breadth-first crawl of all possible routes from the
+    starting path. Will only visit a URL once, even if it is referenced
+    multiple times in a plugin. Requires user interaction in between each
+    fetch.
+    """
+    # TODO: use OrderedSet?
+    paths_visited = set()
+    paths_to_visit = set(item.get_path() for item in once(plugin))
+
+    while paths_to_visit and continue_or_quit():
+        path = paths_to_visit.pop()
+        paths_visited.add(path)
+
+        # Run the new listitem
+        patch_plugin(plugin, path)
+        new_paths = set(item.get_path() for item in once(plugin))
+
+        # Filter new items by checking against urls_visited and
+        # urls_tovisit
+        paths_to_visit.update(path for path in new_paths
+                              if path not in paths_visited)

kodiswift/cli/cli.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift.cli.cli
+------------------
+
+The main entry point for the kodiswift console script. CLI commands can be
+registered in this module.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import absolute_import
+
+import sys
+from optparse import OptionParser
+
+from kodiswift.cli.app import RunCommand
+from kodiswift.cli.create import CreateCommand
+
+# TODO: Make an ABC for Command
+COMMANDS = {
+    RunCommand.command: RunCommand,
+    CreateCommand.command: CreateCommand,
+}
+
+
+# TODO: Make this usage dynamic based on COMMANDS dict
+USAGE = """%prog <command>
+
+Commands:
+    create
+        Create a new plugin project.
+
+    run
+        Run an kodiswift plugin from the command line.
+
+Help:
+    To see options for a command, run `kodiswift <command> -h`
+"""
+
+
+def main():
+    """The entry point for the console script kodiswift.
+
+    The 'xbcmswift2' script is command bassed, so the second argument is always
+    the command to execute. Each command has its own parser options and usages.
+    If no command is provided or the -h flag is used without any other
+    commands, the general help message is shown.
+    """
+    parser = OptionParser()
+    if len(sys.argv) == 1:
+        parser.set_usage(USAGE)
+        parser.error('At least one command is required.')
+
+    # spy sys.argv[1] in order to use correct opts/args
+    command = sys.argv[1]
+
+    if command == '-h':
+        parser.set_usage(USAGE)
+        opts, args = parser.parse_args()
+
+    if command not in COMMANDS.keys():
+        parser.error('Invalid command')
+
+    # We have a proper command, set the usage and options list according to the
+    # specific command
+    manager = COMMANDS[command]
+    if hasattr(manager, 'option_list'):
+        for args, kwargs in manager.option_list:
+            parser.add_option(*args, **kwargs)
+    if hasattr(manager, 'usage'):
+        parser.set_usage(manager.usage)
+
+    opts, args = parser.parse_args()
+
+    # Since we are calling a specific comamnd's manager, we no longer need the
+    # actual command in sys.argv so we slice from position 1
+    manager.run(opts, args[1:])

kodiswift/cli/console.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+"""
+    kodiswift.cli.console
+    ----------------------
+
+    This module contains code to handle CLI interaction.
+
+    :copyright: (c) 2012 by Jonathan Beluch
+    :license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import print_function, absolute_import
+
+
+def get_max_len(items):
+    """Returns the max of the lengths for the provided items"""
+    try:
+        return max(len(item) for item in items)
+    except ValueError:
+        return 0
+
+
+def display_listitems(items, url):
+    """Displays a list of items along with the index to enable a user
+    to select an item.
+
+    Args:
+        items (list[kodiswift.ListItem]):
+        url (str):
+    """
+    if len(items) == 2 and items[0].label == '..' and items[1].played:
+        display_video(items)
+    else:
+        label_width = get_max_len(item.label for item in items)
+        num_width = len(str(len(items)))
+        output = []
+        for i, item in enumerate(items):
+            output.append('[%s] %s (%s)' % (
+                str(i).rjust(num_width),
+                item.label.ljust(label_width),
+                item.path))
+
+        line_width = get_max_len(output)
+        output.append('-' * line_width)
+
+        header = [
+            '',
+            '=' * line_width,
+            'Current URL: %s' % url,
+            '-' * line_width,
+            '%s %s Path' % ('#'.center(num_width + 2),
+                            'Label'.ljust(label_width)),
+            '-' * line_width,
+        ]
+        print('\n'.join(header + output))
+
+
+def display_video(items):
+    """Prints a message for a playing video and displays the parent
+    listitem.
+    """
+    parent_item, played_item = items
+
+    title_line = 'Playing Media %s (%s)' % (played_item.label,
+                                            played_item.path)
+    parent_line = '[0] %s (%s)' % (parent_item.label,
+                                   parent_item.path)
+    line_width = get_max_len([title_line, parent_line])
+
+    output = [
+        '-' * line_width,
+        title_line,
+        '-' * line_width,
+        parent_line.encode("utf8") if isinstance(parent_line, unicode) else parent_line ,
+    ]
+    print('\n'.join(output))
+
+
+def get_user_choice(items):
+    """Returns the selected item from provided items or None if 'q' was
+    entered for quit.
+    """
+    choice = raw_input('Choose an item or "q" to quit: ')
+    while choice != 'q':
+        try:
+            item = items[int(choice)]
+            print()  # Blank line for readability between interactive views
+            return item
+        except ValueError:
+            # Passed something that couldn't be converted with int()
+            choice = raw_input('You entered a non-integer. Choice must be an'
+                               ' integer or "q": ')
+        except IndexError:
+            # Passed an integer that was out of range of the list of urls
+            choice = raw_input('You entered an invalid integer. Choice must '
+                               'be from above url list or "q": ')
+    return None
+
+
+def continue_or_quit():
+    """Prints an exit message and returns False if the user wants to
+    quit.
+    """
+    return raw_input('Enter to continue or "q" to quit') != 'q'

kodiswift/cli/create.py

@@ -0,0 +1,192 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift.cli.create
+---------------------
+
+This module contains the code to initialize a new Kodi addon project.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import print_function, absolute_import
+
+import os
+import readline
+import string
+from getpass import getpass
+from optparse import OptionParser
+from os import getcwd
+from shutil import copytree, ignore_patterns
+from xml.sax import saxutils
+
+
+class CreateCommand(object):
+    """A CLI command to initialize a new Kodi addon project."""
+    command = 'create'
+    usage = '%prog create'
+
+    # noinspection PyUnusedLocal
+    @staticmethod
+    def run(opts, args):
+        """Required run function for the 'create' CLI command."""
+        create_new_project()
+
+
+# Path to skeleton file templates dir
+SKEL = os.path.join(os.path.dirname(__file__), 'data')
+
+
+def error_msg(msg):
+    """A decorator that sets the error_message attribute of the decorated
+    function to the provided value.
+    """
+    def decorator(func):
+        """Sets the error_message attribute on the provided function"""
+        func.error_message = msg
+        return func
+    return decorator
+
+
+def parse_cli():
+    """Currently only one positional arg, create."""
+    parser = OptionParser()
+    return parser.parse_args()
+
+
+@error_msg('** Value must be non-blank.')
+def validate_nonblank(value):
+    """A callable that retunrs the value passed"""
+    return value
+
+
+@error_msg('** Value must contain only letters or underscores.')
+def validate_pluginid(value):
+    """Returns True if the provided value is a valid plugin id"""
+    valid = string.ascii_letters + string.digits + '.' + '_'
+    return all(c in valid for c in value)
+
+
+@error_msg('** The provided path must be an existing folder.')
+def validate_isfolder(value):
+    """Returns true if the provided path is an existing directory"""
+    return os.path.isdir(value)
+
+
+def get_valid_value(prompt, validator, default=None):
+    """Displays the provided prompt and gets input from the user. This behavior
+    loops indefinitely until the provided validator returns True for the user
+    input. If a default value is provided, it will be used only if the user
+    hits Enter and does not provide a value.
+
+    If the validator callable has an error_message attribute, it will be
+    displayed for an invalid value, otherwise a generic message is used.
+    """
+    ans = get_value(prompt, default)
+    while not validator(ans):
+        try:
+            print(validator.error_message)
+        except AttributeError:
+            print('Invalid value.')
+        ans = get_value(prompt, default)
+
+    return ans
+
+
+def get_value(prompt, default=None, hidden=False):
+    """Displays the provided prompt and returns the input from the user. If the
+    user hits Enter and there is a default value provided, the default is
+    returned.
+    """
+    _prompt = '%s : ' % prompt
+    if default:
+        _prompt = '%s [%s]: ' % (prompt, default)
+
+    if hidden:
+        ans = getpass(_prompt)
+    else:
+        ans = raw_input(_prompt)
+
+    # If user hit Enter and there is a default value
+    if not ans and default:
+        ans = default
+    return ans
+
+
+def update_file(filename, items):
+    """Edits the given file in place, replacing any instances of {key} with the
+    appropriate value from the provided items dict. If the given filename ends
+    with ".xml" values will be quoted and escaped for XML.
+    """
+    # TODO: Implement something in the templates to denote whether the value
+    # being replaced is an XML attribute or a value. Perhaps move to dyanmic
+    # XML tree building rather than string replacement.
+    should_escape = filename.endswith('addon.xml')
+
+    with open(filename, 'r') as inp:
+        text = inp.read()
+
+    for key, val in items.items():
+        if should_escape:
+            val = saxutils.quoteattr(val)
+        text = text.replace('{%s}' % key, val)
+    output = text
+
+    with open(filename, 'w') as out:
+        out.write(output)
+
+
+def create_new_project():
+    """Creates a new Kodi Plugin directory based on user input"""
+    readline.parse_and_bind('tab: complete')
+
+    print("""
+    kodiswift - A micro-framework for creating Kodi plugins.
+    xbmc@jonathanbeluch.com
+    --
+""")
+    print('I\'m going to ask you a few questions to get this project started.')
+
+    opts = {}
+
+    # Plugin Name
+    opts['plugin_name'] = get_valid_value(
+        'What is your plugin name?',
+        validate_nonblank
+    )
+
+    # Plugin ID
+    opts['plugin_id'] = get_valid_value(
+        'Enter your plugin id.',
+        validate_pluginid,
+        'plugin.video.%s' % (opts['plugin_name'].lower().replace(' ', ''))
+    )
+
+    # Parent Directory
+    opts['parent_dir'] = get_valid_value(
+        'Enter parent folder (where to create project)',
+        validate_isfolder,
+        getcwd()
+    )
+
+    # Parent Directory
+    opts['plugin_dir'] = os.path.join(opts['parent_dir'], opts['plugin_id'])
+    assert not os.path.isdir(opts['plugin_dir']), \
+        'A folder named %s already exists in %s.' % (opts['plugin_id'],
+                                                     opts['parent_dir'])
+
+    # Provider
+    opts['provider_name'] = get_valid_value(
+        'Enter provider name',
+        validate_nonblank,
+    )
+
+    # Create the project folder by copying over skel
+    copytree(SKEL, opts['plugin_dir'], ignore=ignore_patterns('*.pyc'))
+
+    # Walk through all the new files and fill in with out options
+    for root, _, files in os.walk(opts['plugin_dir']):
+        for filename in files:
+            update_file(os.path.join(root, filename), opts)
+
+    print('Projects successfully created in %s.' % opts['plugin_dir'])
+    print('Done.')

kodiswift/cli/data/addon.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+from kodiswift import Plugin
+
+
+plugin = Plugin()
+
+
+@plugin.route('/')
+def index():
+    item = {
+        'label': 'Hello Kodi!',
+        'path': 'http://example.com/video.mp4',
+        'is_playable': True
+    }
+    return [item]
+
+
+if __name__ == '__main__':
+    plugin.run()

kodiswift/cli/data/addon.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<addon id={plugin_id} name={plugin_name} version="0.0.1" provider-name={provider_name}>
+  <requires>
+    <import addon="xbmc.python" version="2.24.0" />
+    <import addon="script.module.kodiswift" version="0.0.1" />
+  </requires>
+  <extension point="xbmc.python.pluginsource" library="addon.py">
+    <provides>video</provides>
+  </extension>
+  <extension point="xbmc.addon.metadata">
+    <platform>all</platform>
+    <language>en</language>
+    <summary lang="en">Summary for {plugin_name}</summary>
+    <description lang="en">Description for {plugin_name}</description>
+    <disclaimer lang="en">Disclaimer for {plugin_name}</disclaimer>
+  </extension>
+</addon>

kodiswift/cli/data/resources/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

kodiswift/cli/data/resources/language/English/strings.po

@@ -0,0 +1,26 @@
+# Kodi Media Center language file
+# Addon Name: {plugin_name}
+# Addon id: {plugin_id}
+# Addon Provider: {provider_name}
+msgid ""
+msgstr ""
+"Project-Id-Version: Kodi Addons\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: \n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: en\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+# strings 30000 thru 30999 reserved for plugins and plugin settings
+# strings 31000 thru 31999 reserved for skins
+# strings 32000 thru 32999 reserved for scripts
+# strings 33000 thru 33999 reserved for common strings used in add-ons
+
+msgctxt "#33000"
+msgid "Hello Kodi"
+msgstr ""

kodiswift/cli/data/resources/lib/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

kodiswift/common.py

@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift.common
+-----------------
+
+This module contains some common helpful functions.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import absolute_import
+
+import urllib
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+
+__all__ = ['clean_dict', 'kodi_url', 'unpickle_args', 'pickle_dict',
+           'unpickle_dict', 'download_page', 'Modes']
+
+
+class Modes(object):
+    ONCE = 'ONCE'
+    CRAWL = 'CRAWL'
+    INTERACTIVE = 'INTERACTIVE'
+
+
+def kodi_url(url, **options):
+    """Appends key/val pairs to the end of a URL. Useful for passing arbitrary
+    HTTP headers to Kodi to be used when fetching a media resource, e.g.
+    cookies.
+
+    Args:
+        url (str):
+        **options (dict):
+
+    Returns:
+        str:
+    """
+    options = urllib.urlencode(options)
+    if options:
+        return url + '|' + options
+    return url
+
+
+def clean_dict(data):
+    """Remove keys with a value of None
+
+    Args:
+        data (dict):
+
+    Returns:
+        dict:
+    """
+    return dict((k, v) for k, v in data.items() if v is not None)
+
+
+def pickle_dict(items):
+    """Convert `items` values into pickled values.
+
+    Args:
+        items (dict): A dictionary
+
+    Returns:
+        dict: Values which aren't instances of basestring are pickled. Also,
+            a new key '_pickled' contains a comma separated list of keys
+            corresponding to the pickled values.
+    """
+    ret = {}
+    pickled_keys = []
+    for k, v in items.items():
+        if isinstance(v, basestring):
+            ret[k] = v
+        else:
+            pickled_keys.append(k)
+            ret[k] = pickle.dumps(v)
+    if pickled_keys:
+        ret['_pickled'] = ','.join(pickled_keys)
+    return ret
+
+
+def unpickle_args(items):
+    """Takes a dict and un-pickles values whose keys are found in a '_pickled'
+    key.
+
+    >>> unpickle_args({'_pickled': ['foo'], 'foo': ['I3%0A.']})
+    {'foo': 3}
+
+    Args:
+        items (dict): A pickled dictionary.
+
+    Returns:
+        dict: Dict with values un-pickled.
+    """
+    # Technically there can be more than one _pickled value. At this point
+    # we'll just use the first one
+    pickled = items.pop('_pickled', None)
+    if pickled is None:
+        return items
+
+    pickled_keys = pickled[0].split(',')
+    ret = {}
+    for k, v in items.items():
+        if k in pickled_keys:
+            ret[k] = [pickle.loads(val) for val in v]
+        else:
+            ret[k] = v
+    return ret
+
+
+def unpickle_dict(items):
+    """un-pickles a dictionary that was pickled with `pickle_dict`.
+
+    Args:
+        items (dict): A pickled dictionary.
+
+    Returns:
+        dict: An un-pickled dictionary.
+    """
+    pickled_keys = items.pop('_pickled', '').split(',')
+    ret = {}
+    for k, v in items.items():
+        if k in pickled_keys:
+            ret[k] = pickle.loads(v)
+        else:
+            ret[k] = v
+    return ret
+
+
+def download_page(url, data=None):
+    """Returns the response for the given url. The optional data argument is
+    passed directly to urlopen.
+
+    Args:
+        url (str): The URL to read.
+        data (Optional[any]): If given, a POST request will be made with
+            :param:`data` as the POST body.
+
+    Returns:
+        str: The results of requesting the URL.
+    """
+    conn = urllib.urlopen(url, data)
+    resp = conn.read()
+    conn.close()
+    return resp

kodiswift/constants.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift.constants
+--------------------
+
+This module contains some helpful constants which ease interaction
+with Kodi.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import absolute_import
+
+from kodiswift import xbmcplugin
+
+__all__ = ['SortMethod']
+
+
+class SortMethod(object):
+    """Static class to hold all of the available sort methods. The prefix
+    of 'SORT_METHOD_' is stripped.
+
+    e.g. SORT_METHOD_TITLE becomes SortMethod.TITLE
+    """
+    ALBUM = xbmcplugin.SORT_METHOD_ALBUM
+    ALBUM_IGNORE_THE = xbmcplugin.SORT_METHOD_ALBUM_IGNORE_THE
+    ARTIST = xbmcplugin.SORT_METHOD_ARTIST
+    ARTIST_IGNORE_THE = xbmcplugin.SORT_METHOD_ARTIST_IGNORE_THE
+    BITRATE = xbmcplugin.SORT_METHOD_BITRATE
+    CHANNEL = xbmcplugin.SORT_METHOD_CHANNEL
+    COUNTRY = xbmcplugin.SORT_METHOD_COUNTRY
+    DATE = xbmcplugin.SORT_METHOD_DATE
+    DATEADDED = xbmcplugin.SORT_METHOD_DATEADDED
+    DATE_TAKEN = xbmcplugin.SORT_METHOD_DATE_TAKEN
+    DRIVE_TYPE = xbmcplugin.SORT_METHOD_DRIVE_TYPE
+    DURATION = xbmcplugin.SORT_METHOD_DURATION
+    EPISODE = xbmcplugin.SORT_METHOD_EPISODE
+    FILE = xbmcplugin.SORT_METHOD_FILE
+    FULLPATH = xbmcplugin.SORT_METHOD_FULLPATH
+    GENRE = xbmcplugin.SORT_METHOD_GENRE
+    LABEL = xbmcplugin.SORT_METHOD_LABEL
+    LABEL_IGNORE_FOLDERS = xbmcplugin.SORT_METHOD_LABEL_IGNORE_FOLDERS
+    LABEL_IGNORE_THE = xbmcplugin.SORT_METHOD_LABEL_IGNORE_THE
+    LASTPLAYED = xbmcplugin.SORT_METHOD_LASTPLAYED
+    LISTENERS = xbmcplugin.SORT_METHOD_LISTENERS
+    MPAA_RATING = xbmcplugin.SORT_METHOD_MPAA_RATING
+    NONE = xbmcplugin.SORT_METHOD_NONE
+    PLAYCOUNT = xbmcplugin.SORT_METHOD_PLAYCOUNT
+    PLAYLIST_ORDER = xbmcplugin.SORT_METHOD_PLAYLIST_ORDER
+    PRODUCTIONCODE = xbmcplugin.SORT_METHOD_PRODUCTIONCODE
+    PROGRAM_COUNT = xbmcplugin.SORT_METHOD_PROGRAM_COUNT
+    SIZE = xbmcplugin.SORT_METHOD_SIZE
+    SONG_RATING = xbmcplugin.SORT_METHOD_SONG_RATING
+    STUDIO = xbmcplugin.SORT_METHOD_STUDIO
+    STUDIO_IGNORE_THE = xbmcplugin.SORT_METHOD_STUDIO_IGNORE_THE
+    TITLE = xbmcplugin.SORT_METHOD_TITLE
+    TITLE_IGNORE_THE = xbmcplugin.SORT_METHOD_TITLE_IGNORE_THE
+    TRACKNUM = xbmcplugin.SORT_METHOD_TRACKNUM
+    UNSORTED = xbmcplugin.SORT_METHOD_UNSORTED
+    VIDEO_RATING = xbmcplugin.SORT_METHOD_VIDEO_RATING
+    VIDEO_RUNTIME = xbmcplugin.SORT_METHOD_VIDEO_RUNTIME
+    VIDEO_SORT_TITLE = xbmcplugin.SORT_METHOD_VIDEO_SORT_TITLE
+    VIDEO_SORT_TITLE_IGNORE_THE = xbmcplugin.SORT_METHOD_VIDEO_SORT_TITLE_IGNORE_THE
+    VIDEO_TITLE = xbmcplugin.SORT_METHOD_VIDEO_TITLE
+    VIDEO_USER_RATING = xbmcplugin.SORT_METHOD_VIDEO_USER_RATING
+    VIDEO_YEAR = xbmcplugin.SORT_METHOD_VIDEO_YEAR
+
+    @classmethod
+    def from_string(cls, sort_method):
+        """Returns the sort method specified. sort_method is case insensitive.
+        Will raise an AttributeError if the provided sort_method does not
+        exist.
+
+        >>> SortMethod.from_string('title')
+        """
+        return getattr(cls, sort_method.upper())

kodiswift/listitem.py

@@ -0,0 +1,339 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift.listitem
+------------------
+
+This module contains the ListItem class, which acts as a wrapper
+for xbmcgui.ListItem.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import absolute_import
+
+import warnings
+
+from kodiswift import xbmcgui
+
+__all__ = ['ListItem']
+
+
+class ListItem(object):
+    """A wrapper for the xbmcgui.ListItem class. The class keeps track
+    of any set properties that xbmcgui doesn't expose getters for.
+    """
+
+    def __init__(self, label=None, label2=None, icon=None, thumbnail=None,
+                 path=None):
+        """Defaults are an emtpy string since xbmcgui.ListItem will not
+        accept None.
+        """
+        self._listitem = xbmcgui.ListItem(label=label, label2=label2, path=path)
+
+        # The docs have the thumbnail property set as thumb
+        # http://mirrors.kodi.tv/docs/python-docs/16.x-jarvis/xbmcgui.html#ListItem-setArt
+        self._art = {'icon': icon, 'thumb': thumbnail}
+        self._icon = icon
+        self._path = path
+        self._thumbnail = thumbnail
+        self._context_menu_items = []
+        self._played = False
+        self._playable = False
+        self.is_folder = True
+
+    def get_context_menu_items(self):
+        """Returns the list of currently set context_menu items."""
+        return self._context_menu_items
+
+    def add_context_menu_items(self, items, replace_items=False):
+        """Adds context menu items. If replace_items is True all
+        previous context menu items will be removed.
+        """
+        for label, action in items:
+            assert isinstance(label, basestring)
+            assert isinstance(action, basestring)
+        if replace_items:
+            self._context_menu_items = []
+        self._context_menu_items.extend(items)
+        self._listitem.addContextMenuItems(items, replace_items)
+
+    @property
+    def label(self):
+        """
+        Returns:
+            str:
+        """
+        return self._listitem.getLabel()
+
+    @label.setter
+    def label(self, value):
+        """
+        Args:
+            value (str):
+        """
+        self._listitem.setLabel(value)
+
+    def get_label(self):
+        warnings.warn('get_label is deprecated, use label property',
+                      DeprecationWarning)
+        return self.label
+
+    def set_label(self, value):
+        warnings.warn('set_label is deprecated, use label property',
+                      DeprecationWarning)
+        return self._listitem.setLabel(value)
+
+    @property
+    def label2(self):
+        return self._listitem.getLabel2()
+
+    @label2.setter
+    def label2(self, value):
+        self._listitem.setLabel2(value)
+
+    def get_label2(self):
+        warnings.warn('get_label2 is deprecated, use label2 property',
+                      DeprecationWarning)
+        return self.label2
+
+    def set_label2(self, value):
+        warnings.warn('set_label2 is deprecated, use label2 property',
+                      DeprecationWarning)
+        return self._listitem.setLabel2(value)
+
+    @property
+    def selected(self):
+        return self._listitem.isSelected()
+
+    @selected.setter
+    def selected(self, value):
+        self._listitem.select(value)
+
+    def is_selected(self):
+        warnings.warn('is_selected is deprecated, use selected property',
+                      DeprecationWarning)
+        return self._listitem.isSelected()
+
+    def select(self, selected_status=True):
+        warnings.warn('select is deprecated, use selected property',
+                      DeprecationWarning)
+        return self._listitem.select(selected_status)
+
+    @property
+    def icon(self):
+        return self._art.get('icon')
+
+    @icon.setter
+    def icon(self, value):
+        self._art['icon'] = value
+        self._listitem.setArt(self._art)
+
+    def get_icon(self):
+        warnings.warn('get_icon is deprecated, use icon property',
+                      DeprecationWarning)
+        return self.icon
+
+    def set_icon(self, icon):
+        warnings.warn('set_icon is deprecated, use icon property',
+                      DeprecationWarning)
+        self.icon = icon
+        return self.icon
+
+    @property
+    def thumbnail(self):
+        return self._art.get('thumb')
+
+    @thumbnail.setter
+    def thumbnail(self, value):
+        self._art['thumb'] = value
+        self._listitem.setArt(self._art)
+
+    def get_thumbnail(self):
+        warnings.warn('get_thumbnail is deprecated, use thumbnail property',
+                      DeprecationWarning)
+        return self.thumbnail
+
+    def set_thumbnail(self, thumbnail):
+        warnings.warn('set_thumbnail is deprecated, use thumbnail property',
+                      DeprecationWarning)
+        self.thumbnail = thumbnail
+        return self.thumbnail
+
+    @property
+    def poster(self):
+        return self._art.get('poster')
+
+    @poster.setter
+    def poster(self, value):
+        self._art['poster'] = value
+        self._listitem.setArt(self._art)
+
+    @property
+    def path(self):
+        return self._path
+
+    @path.setter
+    def path(self, value):
+        self._path = value
+        self._listitem.setPath(value)
+
+    def get_path(self):
+        warnings.warn('get_path is deprecated, use path property',
+                      DeprecationWarning)
+        return self._path
+
+    def set_path(self, path):
+        warnings.warn('set_path is deprecated, use path property',
+                      DeprecationWarning)
+        self._path = path
+        return self._listitem.setPath(path)
+
+    @property
+    def playable(self):
+        return self._playable
+
+    @playable.setter
+    def playable(self, value):
+        self._playable = value
+        is_playable = 'true' if self._playable else 'false'
+        self.set_property('isPlayable', is_playable)
+
+    def get_is_playable(self):
+        warnings.warn('get_is_playable is deprecated, use playable property',
+                      DeprecationWarning)
+        return self._playable
+
+    def set_is_playable(self, is_playable):
+        warnings.warn('set_is_playable is deprecated, use playable property',
+                      DeprecationWarning)
+        self._playable = is_playable
+        value = 'false'
+        if is_playable:
+            value = 'true'
+        self.set_property('isPlayable', value)
+
+    @property
+    def played(self):
+        return self._played
+
+    @played.setter
+    def played(self, value):
+        self._played = value
+
+    def set_played(self, was_played):
+        """Sets the played status of the listitem.
+
+        Used to differentiate between a resolved video versus a playable item.
+        Has no effect on Kodi, it is strictly used for kodiswift.
+        """
+        warnings.warn('set_played is deprecated, use played property',
+                      DeprecationWarning)
+        self._played = was_played
+
+    def get_played(self):
+        warnings.warn('get_played is deprecated, use played property',
+                      DeprecationWarning)
+        return self._played
+
+    @property
+    def art(self):
+        return self._art
+
+    @art.setter
+    def art(self, value):
+        self._art = value
+        self._listitem.setArt(value)
+
+    def set_art(self, value):
+        self._art = value
+        self._listitem.setArt(value)
+
+    def set_info(self, info_type, info_labels):
+        """Sets the listitem's info"""
+        return self._listitem.setInfo(info_type, info_labels)
+
+    def get_property(self, key):
+        """Returns the property associated with the given key"""
+        return self._listitem.getProperty(key)
+
+    def set_property(self, key, value):
+        """Sets a property for the given key and value"""
+        return self._listitem.setProperty(key, value)
+
+    def add_stream_info(self, stream_type, stream_values):
+        """Adds stream details"""
+        return self._listitem.addStreamInfo(stream_type, stream_values)
+
+    def as_tuple(self):
+        """Returns a tuple of list item properties:
+            (path, the wrapped xbmcgui.ListItem, is_folder)
+        """
+        return self.path, self._listitem, self.is_folder
+
+    def as_xbmc_listitem(self):
+        """Returns the wrapped xbmcgui.ListItem"""
+        return self._listitem
+
+    @classmethod
+    def from_dict(cls, label=None, label2=None, icon=None, thumbnail=None,
+                  path=None, selected=None, info=None, properties=None,
+                  context_menu=None, replace_context_menu=False,
+                  is_playable=None, info_type='video', stream_info=None,
+                  **kwargs):
+        """A ListItem constructor for setting a lot of properties not
+        available in the regular __init__ method. Useful to collect all
+        the properties in a dict and then use the **dct to call this
+        method.
+        """
+        # TODO(Sinap): Should this just use **kwargs? or should art be a dict?
+        listitem = cls(label, label2, path=path)
+        listitem.art = {
+            'icon': icon,
+            'thumb': thumbnail,
+            'poster': kwargs.get('poster'),
+            'banner': kwargs.get('banner'),
+            'fanart': kwargs.get('fanart'),
+            'landscape': kwargs.get('landscape'),
+        }
+
+        if selected is not None:
+            listitem.selected = selected
+
+        if info:
+            listitem.set_info(info_type, info)
+
+        if is_playable:
+            listitem.playable = True
+            listitem.is_folder = False # III
+
+        if properties:
+            # Need to support existing tuples, but prefer to have a dict for
+            # properties.
+            if hasattr(properties, 'items'):
+                properties = properties.items()
+            for key, val in properties:
+                listitem.set_property(key, val)
+
+        if stream_info:
+            for stream_type, stream_values in stream_info.items():
+                listitem.add_stream_info(stream_type, stream_values)
+
+        if context_menu:
+            listitem.add_context_menu_items(context_menu, replace_context_menu)
+
+        return listitem
+
+    def __eq__(self, other):
+        if not isinstance(other, ListItem):
+            raise NotImplementedError
+        self_props = (self.label, self.label2, self.art, self.path,
+                      self.playable, self.selected, self.played,)
+        other_props = (other.label, other.label2, other.art, other.path,
+                       other.playable, other.selected, other.played,)
+        return self_props == other_props
+
+    def __str__(self):
+        return ('%s (%s)' % (self.label, self.path)).encode('utf-8')
+
+    def __repr__(self):
+        return ("<ListItem '%s'>" % self.label).encode('utf-8')

kodiswift/logger.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift.log
+--------------
+
+This module contains the kodiswift logger as well as a convenience
+method for creating new loggers.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import absolute_import
+
+import logging
+
+from kodiswift import CLI_MODE
+
+__all__ = ['setup_log', 'GLOBAL_LOG_LEVEL', 'log']
+
+# TODO: Add logging to a file as well when on CLI with lowest threshold
+#       possible
+# fh = logging.FileHandler('log_filename.txt')
+# fh.setLevel(logging.DEBUG)
+# fh.setFormatter(formatter)
+# log.addHandler(fh)
+# TODO: Allow a global flag to set logging level when dealing with Kodi
+# TODO: Add -q and -v flags to CLI to quiet or enable more verbose logging
+
+
+class XBMCFilter(object):
+    """A logging filter that streams to STDOUT or to the xbmc log if
+    running inside Kodi.
+    """
+    python_to_xbmc = {
+        'DEBUG': 'LOGDEBUG',
+        'INFO': 'LOGNOTICE',
+        'WARNING': 'LOGWARNING',
+        'ERROR': 'LOGERROR',
+        'CRITICAL': 'LOGSEVERE',
+    }
+
+    xbmc_levels = {
+        'LOGDEBUG': 0,
+        'LOGINFO': 1,
+        'LOGNOTICE': 2,
+        'LOGWARNING': 3,
+        'LOGERROR': 4,
+        'LOGSEVERE': 5,
+        'LOGFATAL': 6,
+        'LOGNONE': 7,
+    }
+
+    def __init__(self, prefix):
+        self.prefix = prefix
+
+    def filter(self, record):
+        """Returns True for all records if running in the CLI, else returns
+        True.
+
+        When running inside Kodi it calls the xbmc.log() method and prevents
+        the message from being double printed to STDOUT.
+        """
+
+        # When running in Kodi, any logged statements will be double printed
+        # since we are calling xbmc.log() explicitly. Therefore we return False
+        # so every log message is filtered out and not printed again.
+        if CLI_MODE:
+            return True
+        else:
+            # Must not be imported until here because of import order issues
+            # when running in CLI
+            from kodiswift import xbmc
+            xbmc_level = XBMCFilter.xbmc_levels.get(
+                XBMCFilter.python_to_xbmc.get(record.levelname))
+            xbmc.log('%s%s' % (self.prefix, record.getMessage()), xbmc_level)
+            return False
+
+
+if CLI_MODE:
+    GLOBAL_LOG_LEVEL = logging.INFO
+else:
+    GLOBAL_LOG_LEVEL = logging.DEBUG
+
+
+def setup_log(name):
+    """Returns a logging instance for the provided name. The returned
+    object is an instance of logging.Logger. Logged messages will be
+    printed to stderr when running in the CLI, or forwarded to Kodi's
+    log when running in Kodi mode.
+    """
+    _log = logging.getLogger(name)
+    _log.setLevel(GLOBAL_LOG_LEVEL)
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter(
+        '%(asctime)s - %(levelname)s - [%(name)s] %(message)s')
+    handler.setFormatter(formatter)
+    _log.addHandler(handler)
+    _log.addFilter(XBMCFilter('[%s] ' % name))
+    return _log
+
+
+# The kodiswift log
+# Plugin writers should use plugin.log instead.
+log = setup_log('kodiswift')

kodiswift/mockxbmc/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

kodiswift/mockxbmc/utils.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+import os
+from xml.dom.minidom import parse
+
+import kodiswift.mockxbmc.polib as polib
+
+
+def load_addon_strings(addon, filename):
+    """This is not an official Kodi method, it is here to facilitate
+    mocking up the other methods when running outside of Kodi."""
+    def get_strings(fn):
+        if os.path.exists(filename):
+            po = polib.pofile(fn)
+            return {entry.msgctxt[1:]: entry.msgid for entry in po}
+        else:
+            fn = os.path.splitext(fn)[0] + '.xml'
+            xml = parse(fn)
+            strings = {tag.getAttribute('id'): tag.firstChild.data
+                       for tag in xml.getElementsByTagName('string')}
+            return strings
+    addon._strings = get_strings(filename)
+
+
+def get_addon_id(addon_xml):
+    """Parses an addon id from the given addon.xml filename."""
+    xml = parse(addon_xml)
+    addon_node = xml.getElementsByTagName('addon')[0]
+    return addon_node.getAttribute('id')
+
+
+def get_addon_name(addon_xml):
+    """Parses an addon name from the given addon.xml filename."""
+    xml = parse(addon_xml)
+    addon_node = xml.getElementsByTagName('addon')[0]
+    return addon_node.getAttribute('name')

kodiswift/mockxbmc/xbmc.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+from __future__ import print_function, absolute_import
+
+import errno
+import os
+import tempfile
+
+import kodiswift
+from kodiswift.cli.create import get_value
+
+TEMP_DIR = os.path.join(tempfile.gettempdir(), 'kodiswift_debug')
+kodiswift.log.info('Using temp directory %s', TEMP_DIR)
+
+
+def _create_dir(path):
+    """Creates necessary directories for the given path or does nothing
+    if the directories already exist.
+    """
+    try:
+        os.makedirs(path)
+    except OSError as exc:
+        if exc.errno == errno.EEXIST:
+            pass
+        else:
+            raise
+
+
+def log(msg, level=0):
+    levels = [
+        'LOGDEBUG',
+        'LOGINFO',
+        'LOGNOTICE',
+        'LOGWARNING',
+        'LOGERROR',
+        'LOGSEVERE',
+        'LOGFATAL',
+        'LOGNONE',
+    ]
+    print('%s - %s' % (levels[level], msg))
+
+
+# noinspection PyPep8Naming
+def translatePath(path):
+    """Creates folders in the OS's temp directory. Doesn't touch any
+    possible Kodi installation on the machine. Attempting to do as
+    little work as possible to enable this function to work seamlessly.
+    """
+    valid_dirs = ['xbmc', 'home', 'temp', 'masterprofile', 'profile',
+                  'subtitles', 'userdata', 'database', 'thumbnails',
+                  'recordings', 'screenshots', 'musicplaylists',
+                  'videoplaylists', 'cdrips', 'skin', ]
+
+    # TODO: Remove asserts
+    assert path.startswith('special://'), 'Not a valid special:// path.'
+    parts = path.split('/')[2:]
+    assert len(parts) > 1, 'Need at least a single root directory'
+    assert parts[0] in valid_dirs, '%s is not a valid root dir.' % parts[0]
+
+    # We don't want to swallow any potential IOErrors here, so only makedir for
+    # the root dir, the user is responsible for making any further child dirs
+    _create_dir(os.path.join(TEMP_DIR, parts[0]))
+
+    return os.path.join(TEMP_DIR, *parts)
+
+
+# noinspection PyPep8Naming
+class Keyboard(object):
+    def __init__(self, default='', heading='', hidden=False):
+        self._heading = heading
+        self._default = default
+        self._hidden = hidden
+        self._confirmed = False
+        self._input = None
+
+    def setDefault(self, default):
+        self._default = default
+
+    def setHeading(self, heading):
+        self._heading = heading
+
+    def setHiddenInput(self, hidden):
+        self._hidden = hidden
+
+    def doModal(self):
+        self._confirmed = False
+        try:
+            self._input = get_value(
+                self._heading, self._default, hidden=self._hidden)
+            self._confirmed = True
+        except(KeyboardInterrupt, EOFError):
+            pass
+
+    def isConfirmed(self):
+        return self._confirmed
+
+    def getText(self):
+        return self._input

kodiswift/mockxbmc/xbmcaddon.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+import os
+
+from kodiswift.logger import log
+from kodiswift.mockxbmc import utils
+
+__all__ = ['Addon']
+
+
+def _get_env_setting(name):
+    return os.getenv('KODISWIFT_%s' % name.upper())
+
+
+# noinspection PyPep8Naming
+class Addon(object):
+    def __init__(self, id=None):
+        # In CLI mode, kodiswift must be run from the root of the addon
+        # directory, so we can rely on getcwd() being correct.
+        addon_xml = os.path.join(os.getcwd(), 'addon.xml')
+        _id = None
+        if os.path.exists(addon_xml):
+            _id = utils.get_addon_id(addon_xml)
+        self._info = {
+            'id': id or _id,
+            'name': utils.get_addon_name(addon_xml),
+            'profile': 'special://profile/addon_data/%s/' % _id,
+            'path': 'special://home/addons/%s' % _id
+        }
+        self._strings = {}
+        self._settings = {}
+        strings_fn = os.path.join(
+            os.getcwd(), 'resources', 'language', 'English', 'strings.po')
+        utils.load_addon_strings(self, strings_fn)
+
+    def getAddonInfo(self, prop):
+        properties = ['author', 'changelog', 'description', 'disclaimer',
+                      'fanart', 'icon', 'id', 'name', 'path', 'profile',
+                      'stars', 'summary', 'type', 'version']
+        if prop not in properties:
+            raise ValueError('%s is not a valid property.' % prop)
+        return self._info.get(prop, 'Unavailable')
+
+    def getLocalizedString(self, str_id):
+        key = str(str_id)
+        if key not in self._strings:
+            raise KeyError('id not found in English/strings.po or '
+                           'strings.xml.')
+        return self._strings[key]
+
+    def getSetting(self, key):
+        log.warning('xbmcaddon.Plugin.getSetting() has not been implemented '
+                    'in CLI mode.')
+        try:
+            value = self._settings[key]
+        except KeyError:
+            # see if we have an env var
+            value = _get_env_setting(key)
+            if _get_env_setting(key) is None:
+                value = raw_input(
+                    '* Please enter a temporary value for %s: ' % key)
+            self._settings[key] = value
+        return value
+
+    def setSetting(self, key, value):
+        self._settings[key] = value
+
+    def openSettings(self):
+        pass

kodiswift/mockxbmc/xbmcgui.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+
+
+# noinspection PyPep8Naming,PyUnusedLocal
+class ListItem(object):
+    def __init__(self, label=None, label2=None, iconImage=None,
+                 thumbnailImage=None, path=None):
+        self.label = label
+        self.label2 = label2
+        self.iconImage = iconImage
+        self.thumbnailImage = thumbnailImage
+        self.path = path
+        self.properties = {}
+        self.stream_info = {}
+        self.art = {}
+        self.selected = False
+        self.context_menu_items = None
+        self.infolabels = {}
+
+    def addContextMenuItems(self, items, replaceItems=False):
+        self.context_menu_items = items
+
+    def getLabel(self):
+        return self.label
+
+    def getLabel2(self):
+        return self.label2
+
+    def getProperty(self, key):
+        return self.properties[key.lower()]
+
+    def isSelected(self):
+        return self.selected
+
+    def select(self, selected):
+        self.selected = selected
+
+    def setIconImage(self, icon):
+        self.iconImage = icon
+
+    def setInfo(self, info_type, infoLabels):
+        #assert info_type in ['video', 'music', 'pictures']
+        self.infolabels.update(infoLabels)
+
+    def setLabel(self, label):
+        self.label = label
+
+    def setLabel2(self, label2):
+        self.label2 = label2
+
+    def setPath(self, path):
+        self.path = path
+
+    def setProperty(self, key, value):
+        self.properties[key.lower()] = value
+
+    def addStreamInfo(self, stream_type, stream_values):
+        self.stream_info.update({stream_type: stream_values})
+
+    def setThumbnailImage(self, thumb):
+        self.thumbnailImage = thumb
+
+    def setArt(self, values):
+        self.art = values
+
+class WindowXMLDialog:
+    pass

kodiswift/mockxbmc/xbmcplugin.py

@@ -0,0 +1,44 @@
+# -*- code: utf-8 -*-
+
+SORT_METHOD_ALBUM = 14
+SORT_METHOD_ALBUM_IGNORE_THE = 15
+SORT_METHOD_ARTIST = 11
+SORT_METHOD_ARTIST_IGNORE_THE = 13
+SORT_METHOD_BITRATE = 42
+SORT_METHOD_CHANNEL = 40
+SORT_METHOD_COUNTRY = 17
+SORT_METHOD_DATE = 3
+SORT_METHOD_DATEADDED = 21
+SORT_METHOD_DATE_TAKEN = 43
+SORT_METHOD_DRIVE_TYPE = 6
+SORT_METHOD_DURATION = 8
+SORT_METHOD_EPISODE = 24
+SORT_METHOD_FILE = 5
+SORT_METHOD_FULLPATH = 34
+SORT_METHOD_GENRE = 16
+SORT_METHOD_LABEL = 1
+SORT_METHOD_LABEL_IGNORE_FOLDERS = 35
+SORT_METHOD_LABEL_IGNORE_THE = 2
+SORT_METHOD_LASTPLAYED = 36
+SORT_METHOD_LISTENERS = 38
+SORT_METHOD_MPAA_RATING = 30
+SORT_METHOD_NONE = 0
+SORT_METHOD_PLAYCOUNT = 37
+SORT_METHOD_PLAYLIST_ORDER = 23
+SORT_METHOD_PRODUCTIONCODE = 28
+SORT_METHOD_PROGRAM_COUNT = 22
+SORT_METHOD_SIZE = 4
+SORT_METHOD_SONG_RATING = 29
+SORT_METHOD_STUDIO = 32
+SORT_METHOD_STUDIO_IGNORE_THE = 33
+SORT_METHOD_TITLE = 9
+SORT_METHOD_TITLE_IGNORE_THE = 10
+SORT_METHOD_TRACKNUM = 7
+SORT_METHOD_UNSORTED = 39
+SORT_METHOD_VIDEO_RATING = 19
+SORT_METHOD_VIDEO_RUNTIME = 31
+SORT_METHOD_VIDEO_SORT_TITLE = 26
+SORT_METHOD_VIDEO_SORT_TITLE_IGNORE_THE = 27
+SORT_METHOD_VIDEO_TITLE = 25
+SORT_METHOD_VIDEO_USER_RATING = 20
+SORT_METHOD_VIDEO_YEAR = 18

kodiswift/mockxbmc/xbmcvfs.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+
+def exists(target):
+    return os.path.exists(target)
+
+
+def rename(origin, target):
+    return os.rename(origin, target)
+
+
+def delete(target):
+    if os.path.isfile(target) and not os.path.isdir(target):
+        return os.unlink(target)
+    return False
+
+
+def mkdir(target):
+    os.mkdir(target)
+
+
+def listdir(target):
+    return os.listdir(target)

kodiswift/module.py

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift.module
+-----------------
+
+This module contains the Module Class.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import absolute_import
+
+from kodiswift import setup_log
+from kodiswift.xbmcmixin import XBMCMixin
+
+__all__ = ['Module']
+
+
+class Module(XBMCMixin):
+    """Modules are basically mini plugins except they don't have any
+    functionality until they are registered with a Plugin.
+    """
+
+    def __init__(self, namespace):
+        # Get rid of package prefixes
+        self._namespace = namespace.split('.')[-1]
+        self._view_functions = {}
+        self._routes = []
+        self._register_funcs = []
+        self._plugin = None
+        self._url_prefix = None
+        self._log = setup_log(namespace)
+
+    @property
+    def plugin(self):
+        """Returns the plugin this module is registered to, or
+
+        Returns:
+            kodiswift.Plugin:
+
+        Raises:
+            RuntimeError: If not registered
+        """
+        if self._plugin is None:
+            raise RuntimeError('Module must be registered in order to call'
+                               'this method.')
+        return self._plugin
+
+    @plugin.setter
+    def plugin(self, value):
+        self._plugin = value
+
+    @property
+    def cache_path(self):
+        """Returns the module's cache_path."""
+        return self.plugin.storage_path
+
+    @property
+    def addon(self):
+        """Returns the module's addon"""
+        return self.plugin.addon
+
+    @property
+    def added_items(self):
+        """Returns this module's added_items"""
+        return self.plugin.added_items
+
+    @property
+    def handle(self):
+        """Returns this module's handle"""
+        return self.plugin.handle
+
+    @property
+    def request(self):
+        """Returns the current request"""
+        return self.plugin.request
+
+    @property
+    def log(self):
+        """Returns the registered plugin's log."""
+        return self._log
+
+    @property
+    def url_prefix(self):
+        """Sets or gets the url prefix of the module.
+
+        Raises an Exception if this module is not registered with a
+        Plugin.
+
+        Returns:
+            str:
+
+        Raises:
+            RuntimeError:
+        """
+        if self._url_prefix is None:
+            raise RuntimeError(
+                'Module must be registered in order to call this method.')
+        return self._url_prefix
+
+    @url_prefix.setter
+    def url_prefix(self, value):
+        self._url_prefix = value
+
+    @property
+    def register_funcs(self):
+        return self._register_funcs
+
+    def route(self, url_rule, name=None, options=None):
+        """A decorator to add a route to a view. name is used to
+        differentiate when there are multiple routes for a given view."""
+        def decorator(func):
+            """Adds a url rule for the provided function"""
+            view_name = name or func.__name__
+            self.add_url_rule(url_rule, func, name=view_name, options=options)
+            return func
+        return decorator
+
+    def url_for(self, endpoint, explicit=False, **items):
+        """Returns a valid Kodi plugin URL for the given endpoint name.
+        endpoint can be the literal name of a function, or it can
+        correspond to the name keyword arguments passed to the route
+        decorator.
+
+        Currently, view names must be unique across all plugins and
+        modules. There are not namespace prefixes for modules.
+        """
+        # TODO: Enable items to be passed with keywords of other var names
+        #       such as endpoing and explicit
+        # TODO: Figure out how to handle the case where a module wants to
+        #       call a parent plugin view.
+        if not explicit and not endpoint.startswith(self._namespace):
+            endpoint = '%s.%s' % (self._namespace, endpoint)
+        return self._plugin.url_for(endpoint, **items)
+
+    def add_url_rule(self, url_rule, view_func, name, options=None):
+        """This method adds a URL rule for routing purposes. The
+        provided name can be different from the view function name if
+        desired. The provided name is what is used in url_for to build
+        a URL.
+
+        The route decorator provides the same functionality.
+        """
+        name = '%s.%s' % (self._namespace, name)
+
+        def register_rule(plugin, url_prefix):
+            """Registers a url rule for the provided plugin and
+            url_prefix.
+            """
+            full_url_rule = url_prefix + url_rule
+            plugin.add_url_rule(full_url_rule, view_func, name, options)
+
+        # Delay actual registration of the url rule until this module is
+        # registered with a plugin
+        self._register_funcs.append(register_rule)

kodiswift/plugin.py

@@ -0,0 +1,356 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift.plugin
+-----------------
+
+This module contains the Plugin class. This class handles all of the url
+routing and interaction with Kodi for a plugin.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import absolute_import
+
+import collections
+import inspect
+import os
+import sys
+
+import kodiswift
+from kodiswift import xbmc, xbmcaddon, Request
+from kodiswift.logger import log, setup_log
+from kodiswift.urls import UrlRule, NotFoundException, AmbiguousUrlException
+from kodiswift.xbmcmixin import XBMCMixin
+
+__all__ = ['Plugin']
+
+
+class Plugin(XBMCMixin):
+    """The Plugin objects encapsulates all the properties and methods necessary
+    for running an Kodi plugin. The plugin instance is a central place for
+    registering view functions and keeping track of plugin state.
+
+    Usually the plugin instance is created in the main plugin.py file for the
+    plugin. Typical creation looks like this::
+
+        >>> from kodiswift import Plugin
+        >>> plugin = Plugin('Hello Kodi')
+    """
+
+    def __init__(self, name=None, addon_id=None, plugin_file=None,
+                 info_type=None):
+        """
+        Args:
+            name (Optional[str]): The name of the plugin, e.g. 'Hello Kodi'.
+            addon_id (Optional[str): The Kodi addon ID for the plugin,
+                e.g. 'plugin.video.hellokodi'. This parameter is now optional
+                and is really only useful for testing purposes. If it is not
+                provided, the correct value will be parsed from the
+                addon.xml file.
+            plugin_file (Optional[str]): If provided, it should be the path
+                to the plugin.py file in the root of the addon directory.
+                This only has an effect when kodiswift is running on the
+                command line. Will default to the current working directory
+                since kodiswift requires execution in the root addon directory
+                anyway. The parameter still exists to ease testing.
+            info_type (Optional[str):
+        """
+        self._name = name
+        self._routes = []
+        self._view_functions = {}
+        self._addon = xbmcaddon.Addon()
+
+        self._addon_id = addon_id or self._addon.getAddonInfo('id')
+        self._name = name or self._addon.getAddonInfo('name')
+
+        self._info_type = info_type
+        if not self._info_type:
+            types = {
+                'video': 'video',
+                'audio': 'music',
+                'image': 'pictures',
+            }
+            self._info_type = types.get(self._addon_id.split('.')[1], 'video')
+
+        # Keeps track of the added list items
+        self._current_items = []
+
+        # Gets initialized when self.run() is called
+        self._request = None
+
+        # A flag to keep track of a call to xbmcplugin.endOfDirectory()
+        self._end_of_directory = False
+
+        # Keep track of the update_listing flag passed to
+        # xbmcplugin.endOfDirectory()
+        self._update_listing = False
+
+        # The plugin's named logger
+        self._log = setup_log(self._addon_id)
+
+        # The path to the storage directory for the addon
+        self._storage_path = xbmc.translatePath(
+            'special://profile/addon_data/%s/.storage/' % self._addon_id)
+        if not os.path.isdir(self._storage_path):
+            os.makedirs(self._storage_path)
+
+        # If we are running in CLI, we need to load the strings.xml manually
+        # Since kodiswift currently relies on execution from an addon's root
+        # directly, we can rely on cwd for now...
+        if kodiswift.CLI_MODE:
+            from kodiswift.mockxbmc import utils
+            if plugin_file:
+                plugin_dir = os.path.dirname(plugin_file)
+            else:
+                plugin_dir = os.getcwd()
+            strings_fn = os.path.join(
+                plugin_dir, 'resources', 'language', 'English', 'strings.po')
+            utils.load_addon_strings(self._addon, strings_fn)
+
+    @property
+    def info_type(self):
+        return self._info_type
+
+    @property
+    def log(self):
+        """The log instance for the plugin.
+
+        Returns an instance of the stdlib's ``logging.Logger``.
+        This log will print to STDOUT when running in CLI mode and will
+        forward messages to Kodi's log when running in Kodi.
+
+        Examples:
+            ``plugin.log.debug('Debug message')``
+            ``plugin.log.warning('Warning message')``
+            ``plugin.log.error('Error message')``
+
+        Returns:
+            logging.Logger:
+        """
+        return self._log
+
+    @property
+    def id(self):
+        """The id for the addon instance.
+        """
+        return self._addon_id
+
+    @property
+    def storage_path(self):
+        """A full path to the storage folder for this plugin's addon data.
+        """
+        return self._storage_path
+
+    @property
+    def addon(self):
+        """This addon's wrapped instance of xbmcaddon.Plugin.
+        """
+        return self._addon
+
+    @property
+    def added_items(self):
+        """The list of currently added items.
+
+        Even after repeated calls to :meth:`~kodiswift.Plugin.add_items`, this
+        property will contain the complete list of added items.
+        """
+        return self._current_items
+
+    @property
+    def handle(self):
+        """The current plugin's handle. Equal to ``plugin.request.handle``.
+        """
+        return self.request.handle
+
+    @property
+    def request(self):
+        """The current :class:`~kodiswift.Request`.
+
+        Raises:
+            Exception: if the request hasn't been initialized yet via
+                :meth:`~kodiswift.Plugin.run()`.
+
+        Returns:
+            kodiswift.Request:
+        """
+        if self._request is None:
+            raise Exception('It seems the current request has not been '
+                            'initialized yet. Please ensure that '
+                            '`plugin.run()` has been called before attempting '
+                            'to access the current request.')
+        return self._request
+
+    @property
+    def name(self):
+        """The addon's name.
+
+        Returns:
+            str:
+        """
+        return self._name
+
+    def clear_added_items(self):
+        self._current_items = []
+
+    def register_module(self, module, url_prefix):
+        """Registers a module with a plugin. Requires a url_prefix that will
+        then enable calls to url_for.
+
+        Args:
+            module (kodiswift.Module):
+            url_prefix (str): A url prefix to use for all module urls,
+                e.g. '/mymodule'
+        """
+        module.plugin = self
+        module.url_prefix = url_prefix
+        for func in module.register_funcs:
+            func(self, url_prefix)
+
+    def cached_route(self, url_rule, name=None, options=None, ttl=None):
+        """A decorator to add a route to a view and also apply caching. The
+        url_rule, name and options arguments are the same arguments for the
+        route function. The TTL argument if given will passed along to the
+        caching decorator.
+        """
+        route_decorator = self.route(url_rule, name=name, options=options)
+        if ttl:
+            cache_decorator = self.cached(ttl)
+        else:
+            cache_decorator = self.cached()
+
+        def new_decorator(func):
+            return route_decorator(cache_decorator(func))
+
+        return new_decorator
+
+    def route(self, url_rule=None, name=None, root=False, options=None):
+        """A decorator to add a route to a view. name is used to
+        differentiate when there are multiple routes for a given view."""
+
+        def decorator(f):
+            view_name = name or f.__name__
+            if root:
+                url = '/'
+            elif not url_rule:
+                url = '/' + view_name + '/'
+                args = inspect.getargspec(f)[0]
+                if args:
+                    url += '/'.join('%s/<%s>' % (p, p) for p in args)
+            else:
+                url = url_rule
+            self.add_url_rule(url, f, name=view_name, options=options)
+            return f
+
+        return decorator
+
+    def add_url_rule(self, url_rule, view_func, name, options=None):
+        """This method adds a URL rule for routing purposes. The
+        provided name can be different from the view function name if
+        desired. The provided name is what is used in url_for to build
+        a URL.
+
+        The route decorator provides the same functionality.
+        """
+        rule = UrlRule(url_rule, view_func, name, options)
+        if name in self._view_functions.keys():
+            # TODO: Raise exception for ambiguous views during registration
+            log.warning('Cannot add url rule "%s" with name "%s". There is '
+                        'already a view with that name', url_rule, name)
+            self._view_functions[name] = None
+        else:
+            log.debug('Adding url rule "%s" named "%s" pointing to function '
+                      '"%s"', url_rule, name, view_func.__name__)
+            self._view_functions[name] = rule
+        self._routes.append(rule)
+
+    def url_for(self, endpoint, **items):
+        """Returns a valid Kodi plugin URL for the given endpoint name.
+        endpoint can be the literal name of a function, or it can
+        correspond to the name keyword arguments passed to the route
+        decorator.
+
+        Raises AmbiguousUrlException if there is more than one possible
+        view for the given endpoint name.
+        """
+        try:
+            rule = self._view_functions[endpoint]
+        except KeyError:
+            try:
+                rule = (rule for rule in self._view_functions.values()
+                        if rule.view_func == endpoint).next()
+            except StopIteration:
+                raise NotFoundException(
+                    '%s does not match any known patterns.' % endpoint)
+
+        # rule can be None since values of None are allowed in the
+        # _view_functions dict. This signifies more than one view function is
+        # tied to the same name.
+        if not rule:
+            # TODO: Make this a regular exception
+            raise AmbiguousUrlException
+
+        path_qs = rule.make_path_qs(items)
+        return 'plugin://%s%s' % (self._addon_id, path_qs)
+
+    def redirect(self, url):
+        """Used when you need to redirect to another view, and you only
+        have the final plugin:// url."""
+        # TODO: Should we be overriding self.request with the new request?
+        new_request = self._parse_request(url=url, handle=self.request.handle)
+        log.debug('Redirecting %s to %s', self.request.path, new_request.path)
+        return self._dispatch(new_request.path)
+
+    def run(self):
+        """The main entry point for a plugin."""
+        self._request = self._parse_request()
+        log.debug('Handling incoming request for %s', self.request.path)
+        items = self._dispatch(self.request.path)
+
+        # Close any open storages which will persist them to disk
+        if hasattr(self, '_unsynced_storage'):
+            for storage in self._unsynced_storage.values():
+                log.debug('Saving a %s storage to disk at "%s"',
+                          storage.file_format, storage.file_path)
+                storage.close()
+
+        return items
+
+    def _dispatch(self, path):
+        for rule in self._routes:
+            try:
+                view_func, items = rule.match(path)
+            except NotFoundException:
+                continue
+            log.info('Request for "%s" matches rule for function "%s"',
+                     path, view_func.__name__)
+            resp = view_func(**items)
+
+            # Only call self.finish() for UI container listing calls to plugin
+            # (handle will be >= 0). Do not call self.finish() when called via
+            # RunPlugin() (handle will be -1).
+            if not self._end_of_directory and self.handle >= 0:
+                if isinstance(resp, dict):
+                    resp['items'] = self.finish(**resp)
+                elif isinstance(resp, collections.Iterable):
+                    resp = self.finish(items=resp)
+            return resp
+
+        raise NotFoundException('No matching view found for %s' % path)
+
+    @staticmethod
+    def _parse_request(url=None, handle=None):
+        """Handles setup of the plugin state, including request
+        arguments, handle, mode.
+
+        This method never needs to be called directly. For testing, see
+        plugin.test()
+        """
+        # To accommodate self.redirect, we need to be able to parse a full
+        # url as well
+        if url is None:
+            url = sys.argv[0]
+            if len(sys.argv) == 3:
+                url += sys.argv[2]
+        if handle is None:
+            handle = sys.argv[1]
+        return Request(url, handle)

kodiswift/request.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift.request
+------------------
+
+This module contains the Request class. This class represents an incoming
+request from Kodi.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import absolute_import
+
+import urlparse
+
+from kodiswift.common import unpickle_args
+
+__all__ = ['Request']
+
+
+class Request(object):
+
+    def __init__(self, url, handle):
+        """The request objects contains all the arguments passed to the plugin via
+        the command line.
+
+        Args:
+            url (str): The complete plugin URL being requested. Since Kodi
+                typically passes the URL query string in a separate argument
+                from the base URL, they must be joined into a single string
+                before being provided.
+            handle (Union[int, str]): The handle associated with the current
+                request.
+        """
+        self.url = url
+
+        #: The current request's handle, an integer.
+        self.handle = int(handle)
+
+        # urlparse doesn't like the 'plugin' scheme, so pass a protocol
+        # relative url, e.g. //plugin.video.helloxbmc/path
+        self.scheme, remainder = url.split(':', 1)
+        parts = urlparse.urlparse(remainder)
+        self.netloc, self.path, self.query_string = (
+            parts[1], parts[2], parts[4])
+        self.args = unpickle_args(urlparse.parse_qs(self.query_string))

kodiswift/storage.py

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift.storage
+-----------------
+
+This module contains persistent storage classes.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import absolute_import
+
+import collections
+import json
+import os
+import time
+import shutil
+from datetime import datetime
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+
+__all__ = ['Formats', 'PersistentStorage', 'TimedStorage', 'UnknownFormat']
+
+
+class UnknownFormat(Exception):
+    pass
+
+
+class Formats(object):
+    PICKLE = 'pickle'
+    JSON = 'json'
+
+
+class PersistentStorage(collections.MutableMapping):
+    def __init__(self, file_path, file_format=Formats.PICKLE):
+        """
+        Args:
+            file_path (str):
+            file_format (Optional[kodiswift.Formats]):
+        """
+        super(PersistentStorage, self).__init__()
+        self.file_path = file_path
+        self.file_format = file_format
+        self._store = {}
+        self._loaded = False
+
+    def __getitem__(self, key):
+        return self._store[key]
+
+    def __setitem__(self, key, value):
+        self._store[key] = value
+
+    def __delitem__(self, key):
+        del self._store[key]
+
+    def __iter__(self):
+        return iter(self._store)
+
+    def __len__(self):
+        return len(self._store)
+
+    def __enter__(self):
+        self.load()
+        self.sync()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.sync()
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__.__name__, self._store)
+
+    def items(self):
+        return self._store.items()
+
+    def load(self):
+        """Load the file from disk.
+
+        Returns:
+            bool: True if successfully loaded, False if the file
+                doesn't exist.
+
+        Raises:
+            UnknownFormat: When the file exists but couldn't be loaded.
+        """
+
+        if not self._loaded and os.path.exists(self.file_path):
+            with open(self.file_path, 'rb') as f:
+                for loader in (pickle.load, json.load):
+                    try:
+                        f.seek(0)
+                        self._store = loader(f)
+                        self._loaded = True
+                        break
+                    except pickle.UnpicklingError:
+                        pass
+            # If the file exists and wasn't able to be loaded, raise an error.
+            if not self._loaded:
+                raise UnknownFormat('Failed to load file')
+        return self._loaded
+
+    def close(self):
+        self.sync()
+
+    def sync(self):
+        temp_file = self.file_path + '.tmp'
+        try:
+            with open(temp_file, 'wb') as f:
+                if self.file_format == Formats.PICKLE:
+                    pickle.dump(self._store, f, 2)
+                elif self.file_format == Formats.JSON:
+                    json.dump(self._store, f, separators=(',', ':'))
+                else:
+                    raise NotImplementedError(
+                        'Unknown file format ' + repr(self.file_format))
+        except Exception:
+            if os.path.exists(temp_file):
+                os.remove(temp_file)
+            raise
+        shutil.move(temp_file, self.file_path)
+
+
+class TimedStorage(PersistentStorage):
+    """A dict with the ability to persist to disk and TTL for items."""
+
+    def __init__(self, file_path, ttl=None, **kwargs):
+        """
+        Args:
+            file_path (str):
+            ttl (Optional[int]):
+        """
+        super(TimedStorage, self).__init__(file_path, **kwargs)
+        self.ttl = ttl
+
+    def __setitem__(self, key, value):
+        self._store[key] = (value, time.time())
+
+    def __getitem__(self, item):
+        val, timestamp = self._store[item]
+        ttl_diff = datetime.utcnow() - datetime.utcfromtimestamp(timestamp)
+        if self.ttl and ttl_diff > self.ttl:
+            del self._store[item]
+            raise KeyError
+        return val
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__.__name__,
+                           dict((k, v[0]) for k, v in self._store.items()))
+
+    def items(self):
+        items = []
+        for k in self._store.keys():
+            try:
+                items.append((k, self[k]))
+            except KeyError:
+                pass
+        return items
+
+    def sync(self):
+        super(TimedStorage, self).sync()

kodiswift/urls.py

@@ -0,0 +1,212 @@
+# -*- coding: utf-8 -*-
+"""
+kodiswift.urls
+---------------
+
+This module contains URLRule class for dealing with url patterns.
+
+:copyright: (c) 2012 by Jonathan Beluch
+:license: GPLv3, see LICENSE for more details.
+"""
+from __future__ import absolute_import
+
+import re
+from urllib import urlencode, unquote_plus, quote_plus
+
+from kodiswift.common import pickle_dict, unpickle_dict
+
+__all__ = ['UrlRule', 'AmbiguousUrlException', 'NotFoundException']
+
+
+class AmbiguousUrlException(Exception):
+    pass
+
+
+class NotFoundException(Exception):
+    pass
+
+
+class UrlRule(object):
+    """A class the encapsulates a URL
+    """
+
+    def __init__(self, url_rule, view_func, name, options):
+        """Stores the various properties related to a routing URL rule.
+
+        It also provides a few methods to create URLs from the rule or to
+        match a given URL against a rule.
+
+        Args:
+            url_rule: The relative url pattern for the rule.
+                It may include <var_name> to denote where dynamic variables
+                should be matched.
+            view_func: The function that should be bound to this rule.
+                This should be an actual function object.
+            name: The name of the url rule. This is used in the reverse
+                process of creating urls for a given rule.
+            options: A dict containing any default values for the url rule.
+
+        Warnings:
+            view_func: The function signature should match any variable
+                names in the provided url_rule.
+        """
+        self._name = name
+        self._url_rule = url_rule
+        self._view_func = view_func
+        self._options = options or {}
+        self._keywords = re.findall(r'<(.+?)>', url_rule)
+
+        # change <> to {} for use with str.format()
+        self._url_format = self._url_rule.replace('<', '{').replace('>', '}')
+
+        # Make a regex pattern for matching incoming URLs
+        rule = self._url_rule
+        if rule != '/':
+            # Except for a path of '/', the trailing slash is optional.
+            rule = self._url_rule.rstrip('/') + '/?'
+        p = rule.replace('<', '(?P<').replace('>', '>[^/]+?)')
+
+        try:
+            self._regex = re.compile('^' + p + '$')
+        except re.error:
+            raise ValueError('There was a problem creating this URL rule. '
+                             'Ensure you do not have any unpaired angle '
+                             'brackets: "<" or ">"')
+
+    def __eq__(self, other):
+        if isinstance(other, UrlRule):
+            return (
+                (self._name, self._url_rule, self._view_func, self._options) ==
+                (other._name, other._url_rule, other._view_func, other._options)
+            )
+        else:
+            raise NotImplementedError
+
+    def __ne__(self, other):
+        return not self == other
+
+    def match(self, path):
+        """Attempts to match a url to the given path.
+
+        If successful, a tuple is returned. The first item is the matched
+        function and the second item is a dictionary containing items to be
+        passed to the function parsed from the provided path.
+
+        Args:
+            path (str): The URL path.
+
+        Raises:
+            NotFoundException: If the provided path does not match this
+                url rule.
+        """
+        m = self._regex.search(path)
+        if not m:
+            raise NotFoundException
+
+        # urlunencode the values
+        items = dict((key, unquote_plus(val))
+                     for key, val in m.groupdict().items())
+
+        # unpickle any items if present
+        items = unpickle_dict(items)
+
+        # We need to update our dictionary with default values provided in
+        # options if the keys don't already exist.
+        [items.setdefault(key, val) for key, val in self._options.items()]
+        return self._view_func, items
+
+    def _make_path(self, items):
+        """Returns a relative path for the given dictionary of items.
+
+        Uses this url rule's url pattern and replaces instances of <var_name>
+        with the appropriate value from the items dict.
+        """
+        for key, val in items.items():
+            if not isinstance(val, basestring):
+                raise TypeError('Value "%s" for key "%s" must be an instance'
+                                ' of basestring' % (val, key))
+            items[key] = quote_plus(val)
+
+        try:
+            path = self._url_format.format(**items)
+        except AttributeError:
+            # Old version of python
+            path = self._url_format
+            for key, val in items.items():
+                path = path.replace('{%s}' % key, val)
+        return path
+
+    def _make_qs(self, items):
+        """Returns a query string for the given dictionary of items. All keys
+        and values in the provided items will be urlencoded. If necessary, any
+        python objects will be pickled before being urlencoded.
+        """
+        return urlencode(pickle_dict(items))
+
+    def make_path_qs(self, items):
+        """Returns a relative path complete with query string for the given
+        dictionary of items.
+
+        Any items with keys matching this rule's url pattern will be inserted
+        into the path. Any remaining items will be appended as query string
+        parameters.
+
+        All items will be urlencoded. Any items which are not instances of
+        basestring, or int/long will be pickled before being urlencoded.
+
+        .. warning:: The pickling of items only works for key/value pairs which
+                     will be in the query string. This behavior should only be
+                     used for the simplest of python objects. It causes the
+                     URL to get very lengthy (and unreadable) and Kodi has a
+                     hard limit on URL length. See the caching section if you
+                     need to persist a large amount of data between requests.
+        """
+        # Convert any ints and longs to strings
+        for key, val in items.items():
+            if isinstance(val, (int, long)):
+                items[key] = str(val)
+
+        # First use our defaults passed when registering the rule
+        url_items = dict((key, val) for key, val in self._options.items()
+                         if key in self._keywords)
+
+        # Now update with any items explicitly passed to url_for
+        url_items.update((key, val) for key, val in items.items()
+                         if key in self._keywords)
+
+        # Create the path
+        path = self._make_path(url_items)
+
+        # Extra arguments get tacked on to the query string
+        qs_items = dict((key, val) for key, val in items.items()
+                        if key not in self._keywords)
+        qs = self._make_qs(qs_items)
+
+        if qs:
+            return '?'.join([path, qs])
+        return path
+
+    @property
+    def regex(self):
+        """The regex for matching paths against this url rule."""
+        return self._regex
+
+    @property
+    def view_func(self):
+        """The bound function"""
+        return self._view_func
+
+    @property
+    def url_format(self):
+        """The url pattern"""
+        return self._url_format
+
+    @property
+    def name(self):
+        """The name of this url rule."""
+        return self._name
+
+    @property
+    def keywords(self):
+        """The list of path keywords for this url rule."""
+        return self._keywords

kodiswift/xbmcmixin.py

@@ -0,0 +1,572 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+import os
+import warnings
+from datetime import timedelta
+from functools import wraps
+
+import kodiswift
+from kodiswift import xbmc, xbmcplugin, xbmcgui, CLI_MODE
+from kodiswift.constants import SortMethod
+from kodiswift.logger import log
+from kodiswift.storage import TimedStorage, UnknownFormat
+
+__all__ = ['XBMCMixin']
+
+# TODO(Sinap): Need to either break the single mixin into multiple or just use
+#              a parent class.
+
+
+# noinspection PyUnresolvedReferences,PyAttributeOutsideInit
+class XBMCMixin(object):
+    """A mixin to add Kodi helper methods. In order to use this mixin,
+    the child class must implement the following methods and
+    properties:
+
+        # Also, the child class is responsible for ensuring that this path
+        # exists.
+        self.storage_path
+
+        self.added_items
+
+        self.request
+
+        self.addon
+
+        _end_of_directory = False
+
+        _update_listing
+
+        self.handle
+
+    # optional
+    self.info_type: should be in ['video', 'music', 'pictures']
+    _memoized_storage = None
+    _unsynced_storage = None
+    # TODO: Ensure above is implemented
+    """
+
+    _function_cache_name = '.functions'
+
+    def cached(self, ttl=60 * 24):
+        """A decorator that will cache the output of the wrapped function.
+
+        The key used for the cache is the function name as well as the
+        `*args` and `**kwargs` passed to the function.
+
+        Args:
+            ttl: Time to live in minutes.
+
+        Notes:
+            ttl: For route caching, you should use
+                :meth:`kodiswift.Plugin.cached_route`.
+        """
+        def decorating_function(function):
+            storage = self.get_storage(
+                self._function_cache_name, file_format='pickle', ttl=ttl)
+            kwd_mark = 'f35c2d973e1bbbc61ca60fc6d7ae4eb3'
+
+            @wraps(function)
+            def wrapper(*args, **kwargs):
+                key = (function.__name__, kwd_mark) + args
+                if kwargs:
+                    key += (kwd_mark,) + tuple(sorted(kwargs.items()))
+
+                try:
+                    result = storage[key]
+                    log.debug('Storage hit for function "%s" with args "%s" '
+                              'and kwargs "%s"', function.__name__, args,
+                              kwargs)
+                except KeyError:
+                    log.debug('Storage miss for function "%s" with args "%s" '
+                              'and kwargs "%s"', function.__name__, args,
+                              kwargs)
+                    result = function(*args, **kwargs)
+                    storage[key] = result
+                    storage.sync()
+                return result
+
+            return wrapper
+
+        return decorating_function
+
+    def clear_function_cache(self):
+        """Clears the storage that caches results when using
+        :meth:`kodiswift.Plugin.cached_route` or
+        :meth:`kodiswift.Plugin.cached`.
+        """
+        self.get_storage(self._function_cache_name).clear()
+
+    def list_storage(self):
+        """Returns a list of existing stores.
+
+        The returned names can then be used to call get_storage().
+        """
+        # Filter out any storage used by kodiswift so caller doesn't corrupt
+        # them.
+        return [name for name in os.listdir(self.storage_path)
+                if not name.startswith('.')]
+
+    def get_storage(self, name='main', file_format='pickle', ttl=None):
+        """Returns a storage for the given name.
+
+        The returned storage is a fully functioning python dictionary and is
+        designed to be used that way. It is usually not necessary for the
+        caller to load or save the storage manually. If the storage does
+        not already exist, it will be created.
+
+        See Also:
+            :class:`kodiswift.TimedStorage` for more details.
+
+        Args:
+            name (str): The name  of the storage to retrieve.
+            file_format (str): Choices are 'pickle', 'csv', and 'json'.
+                Pickle is recommended as it supports python objects.
+
+                Notes: If a storage already exists for the given name, the
+                    file_format parameter is ignored. The format will be
+                    determined by the existing storage file.
+
+            ttl (int): The time to live for storage items specified in minutes
+                or None for no expiration. Since storage items aren't expired
+                until a storage is loaded form disk, it is possible to call
+                get_storage() with a different TTL than when the storage was
+                created. The currently specified TTL is always honored.
+
+        Returns:
+            kodiswift.storage.TimedStorage:
+        """
+        if not hasattr(self, '_unsynced_storage'):
+            self._unsynced_storage = {}
+        filename = os.path.join(self.storage_path, name)
+        try:
+            storage = self._unsynced_storage[filename]
+            log.debug('Loaded storage "%s" from memory', name)
+        except KeyError:
+            if ttl:
+                ttl = timedelta(minutes=ttl)
+            try:
+                storage = TimedStorage(filename, ttl, file_format=file_format)
+                storage.load()
+            except UnknownFormat:
+                # Thrown when the storage file is corrupted and can't be read.
+                # Prompt user to delete storage.
+                choices = ['Clear storage', 'Cancel']
+                ret = xbmcgui.Dialog().select(
+                    'A storage file is corrupted. It'
+                    ' is recommended to clear it.', choices)
+                if ret == 0:
+                    os.remove(filename)
+                    storage = TimedStorage(filename, ttl,
+                                           file_format=file_format)
+                else:
+                    raise Exception('Corrupted storage file at %s' % filename)
+
+            self._unsynced_storage[filename] = storage
+            log.debug('Loaded storage "%s" from disk', name)
+        return storage
+
+    def get_string(self, string_id):
+        """Returns the localized string from strings.po or strings.xml for the
+        given string_id.
+        """
+        string_id = int(string_id)
+        if not hasattr(self, '_strings'):
+            self._strings = {}
+        if string_id not in self._strings:
+            self._strings[string_id] = self.addon.getLocalizedString(string_id)
+        return self._strings[string_id]
+
+    def set_content(self, content):
+        """Sets the content type for the plugin."""
+        contents = ['files', 'songs', 'artists', 'albums', 'movies', 'tvshows',
+                    'episodes', 'musicvideos']
+        if content not in contents:
+            self.log.warning('Content type "%s" is not valid', content)
+        xbmcplugin.setContent(self.handle, content)
+
+    def get_setting(self, key, converter=None, choices=None):
+        """Returns the settings value for the provided key.
+
+        If converter is str, unicode, bool or int the settings value will be
+        returned converted to the provided type. If choices is an instance of
+        list or tuple its item at position of the settings value be returned.
+
+        Args:
+            key (str): The ID of the setting defined in settings.xml.
+            converter (Optional[str, unicode, bool, int]): How to convert the
+                setting value.
+                TODO(Sinap): Maybe this should just be a callable object?
+            choices (Optional[list,tuple]):
+
+        Notes:
+            converter: It is suggested to always use unicode for
+                text-settings because else xbmc returns utf-8 encoded strings.
+
+        Examples:
+            * ``plugin.get_setting('per_page', int)``
+            * ``plugin.get_setting('password', unicode)``
+            * ``plugin.get_setting('force_viewmode', bool)``
+            * ``plugin.get_setting('content', choices=('videos', 'movies'))``
+        """
+        # TODO: allow pickling of settings items?
+        # TODO: STUB THIS OUT ON CLI
+        value = self.addon.getSetting(key)
+        if converter is str:
+            return value
+        elif converter is unicode:
+            return value.decode('utf-8')
+        elif converter is bool:
+            return value == 'true'
+        elif converter is int:
+            return int(value)
+        elif isinstance(choices, (list, tuple)):
+            return choices[int(value)]
+        elif converter is None:
+            log.warning('No converter provided, unicode should be used, '
+                        'but returning str value')
+            return value
+        else:
+            raise TypeError('Acceptable converters are str, unicode, bool and '
+                            'int. Acceptable choices are instances of list '
+                            ' or tuple.')
+
+    def set_setting(self, key, val):
+        # TODO: STUB THIS OUT ON CLI - setSetting takes id=x, value=x throws an error otherwise
+        return self.addon.setSetting(id=key, value=val)
+
+    def load_addon_settings(self):
+        """ Mock loading addon settings from user_data/settings.xml file.
+        If settings.xml does no exists, create using default values"""
+        if not CLI_MODE:
+            return
+        from xml.dom.minidom import parse
+        xml = parse(os.path.join("resources","language","English","strings.xml"))
+        self.addon._strings = dict((tag.getAttribute('id'), tag.firstChild.data) for tag in xml.getElementsByTagName('string'))
+        settings_file = os.path.join("addon_data","settings.xml")
+        if not os.path.exists(settings_file):
+            xml = parse(os.path.join("resources","settings.xml"))
+            self.addon._settings = dict((tag.getAttribute('id'), tag.attributes["default"].value)for tag in xml.getElementsByTagName('setting') if "id" in tag.attributes.keys())
+            if not os.path.exists("addon_data"):
+                os.mkdir("addon_data")
+            with open(settings_file,"w") as f:
+                f.write("<settings>\n")
+                for s in self.addon._settings:
+                    f.write('    <setting id="%s" value="%s" />\n'%(s,self.addon._settings[s]))
+                f.write("</settings>\n")
+        else:
+            xml = parse(settings_file)
+            self.addon._settings = dict((tag.getAttribute('id'), tag.attributes["value"].value) for tag in xml.getElementsByTagName('setting'))
+
+    def open_settings(self):
+        """Opens the settings dialog within Kodi"""
+        self.addon.openSettings()
+
+    @staticmethod
+    def add_to_playlist(items, playlist='video'):
+        """Adds the provided list of items to the specified playlist.
+        Available playlists include *video* and *music*.
+        """
+        playlists = {'music': 0, 'video': 1}
+        if playlist not in playlists:
+            raise ValueError('Playlist "%s" is invalid.' % playlist)
+
+        selected_playlist = xbmc.PlayList(playlists[playlist])
+        _items = []
+        for item in items:
+            if not hasattr(item, 'as_xbmc_listitem'):
+                if 'info_type' in item:
+                    log.warning('info_type key has no affect for playlist '
+                                'items as the info_type is inferred from the '
+                                'playlist type.')
+                # info_type has to be same as the playlist type
+                item['info_type'] = playlist
+                item = kodiswift.ListItem.from_dict(**item)
+            _items.append(item)
+            selected_playlist.add(item.get_path(), item.as_xbmc_listitem())
+        return _items
+
+    @staticmethod
+    def get_view_mode_id(view_mode):
+        warnings.warn('get_view_mode_id is deprecated.', DeprecationWarning)
+        return None
+
+    @staticmethod
+    def set_view_mode(view_mode_id):
+        """Calls Kodi's Container.SetViewMode. Requires an integer
+        view_mode_id"""
+        xbmc.executebuiltin('Container.SetViewMode(%d)' % view_mode_id)
+
+    def keyboard(self, default=None, heading=None, hidden=False):
+        """Displays the keyboard input window to the user. If the user does not
+        cancel the modal, the value entered by the user will be returned.
+
+        :param default: The placeholder text used to prepopulate the input
+                        field.
+        :param heading: The heading for the window. Defaults to the current
+                        addon's name. If you require a blank heading, pass an
+                        empty string.
+        :param hidden: Whether or not the input field should be masked with
+                       stars, e.g. a password field.
+        """
+        if heading is None:
+            heading = self.addon.getAddonInfo('name')
+        if default is None:
+            default = ''
+        keyboard = xbmc.Keyboard(default, heading, hidden)
+        keyboard.doModal()
+        if keyboard.isConfirmed():
+            return keyboard.getText()
+
+    def notify(self, msg='', title=None, delay=5000, image=''):
+        """Displays a temporary notification message to the user. If
+        title is not provided, the plugin name will be used. To have a
+        blank title, pass '' for the title argument. The delay argument
+        is in milliseconds.
+        """
+        if not image:
+            image = xbmcgui.NOTIFICATION_INFO
+        if not msg:
+            log.warning('Empty message for notification dialog')
+        if title is None:
+            title = self.addon.getAddonInfo('name')
+        if isinstance(msg,unicode):
+            msg = msg.encode("utf8")
+        if isinstance(title,unicode):
+            title = title.encode("utf8")
+        xbmcgui.Dialog().notification(title, msg, image, delay)
+        #xbmc.executebuiltin('Notification("%s", "%s", "%s", "%s")' % (msg, title, delay, image))
+
+    def set_resolved_url(self, item=None, subtitles=None):
+        """Takes a url or a listitem to be played. Used in conjunction with a
+        playable list item with a path that calls back into your addon.
+
+        :param item: A playable list item or url. Pass None to alert Kodi of a
+                     failure to resolve the item.
+
+                     .. warning:: When using set_resolved_url you should ensure
+                                  the initial playable item (which calls back
+                                  into your addon) doesn't have a trailing
+                                  slash in the URL. Otherwise it won't work
+                                  reliably with Kodi's PlayMedia().
+        :param subtitles: A URL to a remote subtitles file or a local filename
+                          for a subtitles file to be played along with the
+                          item.
+        """
+        if self._end_of_directory:
+            raise Exception('Current Kodi handle has been removed. Either '
+                            'set_resolved_url(), end_of_directory(), or '
+                            'finish() has already been called.')
+        self._end_of_directory = True
+
+        succeeded = True
+        if item is None:
+            # None item indicates the resolve url failed.
+            item = {}
+            succeeded = False
+
+        if isinstance(item, basestring):
+            # caller is passing a url instead of an item dict
+            item = {'path': item}
+
+        item = self._listitemify(item)
+        item.set_played(True)
+        xbmcplugin.setResolvedUrl(self.handle, succeeded,
+                                  item.as_xbmc_listitem())
+
+        # call to _add_subtitles must be after setResolvedUrl
+        if subtitles:
+            if isinstance(subtitles,list):
+                for subtitle in subtitles:
+                    self._add_subtitles(subtitle)
+            else:
+                self._add_subtitles(subtitles)
+
+        return [item]
+
+    def play_video(self, item, player=None):
+        if isinstance(item, dict):
+            item['info_type'] = 'video'
+
+        item = self._listitemify(item)
+        item.set_played(True)
+        if player:
+            _player = xbmc.Player(player)
+        else:
+            _player = xbmc.Player()
+        _player.play(item.get_path(), item.as_xbmc_listitem())
+        return [item]
+
+    def add_items(self, items):
+        """Adds ListItems to the Kodi interface.
+
+        Each item in the provided list should either be instances of
+        kodiswift.ListItem, or regular dictionaries that will be passed
+        to kodiswift.ListItem.from_dict.
+
+        Args:
+            items: An iterable of items where each item is either a
+                dictionary with keys/values suitable for passing to
+                :meth:`kodiswift.ListItem.from_dict` or an instance of
+                :class:`kodiswift.ListItem`.
+
+        Returns:
+            kodiswift.ListItem: The list of ListItems.
+        """
+        _items = [self._listitemify(item) for item in items]
+        tuples = [item.as_tuple() for item in _items if hasattr(item, 'as_tuple')]
+        xbmcplugin.addDirectoryItems(self.handle, tuples, len(tuples))
+
+        # We need to keep track internally of added items so we can return them
+        # all at the end for testing purposes
+        self.added_items.extend(_items)
+
+        # Possibly need an if statement if only for debug mode
+        return _items
+
+    def add_sort_method(self, sort_method, label2_mask=None):
+        """A wrapper for `xbmcplugin.addSortMethod()
+        <http://mirrors.xbmc.org/docs/python-docs/xbmcplugin.html#-addSortMethod>`_.
+        You can use ``dir(kodiswift.SortMethod)`` to list all available sort
+        methods.
+
+        Args:
+            sort_method: A valid sort method. You can provided the constant
+                from xbmcplugin, an attribute of SortMethod, or a string name.
+                For instance, the following method calls are all equivalent:
+                 * ``plugin.add_sort_method(xbmcplugin.SORT_METHOD_TITLE)``
+                 * ``plugin.add_sort_method(SortMethod.TITLE)``
+                 * ``plugin.add_sort_method('title')``
+            label2_mask: A mask pattern for label2. See the `Kodi
+                documentation <http://mirrors.xbmc.org/docs/python-docs/xbmcplugin.html#-addSortMethod>`_
+                for more information.
+        """
+        try:
+            # Assume it's a string and we need to get the actual int value
+            sort_method = SortMethod.from_string(sort_method)
+        except AttributeError:
+            # sort_method was already an int (or a bad value)
+            pass
+
+        if label2_mask:
+            xbmcplugin.addSortMethod(self.handle, sort_method, label2_mask)
+        else:
+            xbmcplugin.addSortMethod(self.handle, sort_method)
+
+    def end_of_directory(self, succeeded=True, update_listing=False,
+                         cache_to_disc=True):
+        """Wrapper for xbmcplugin.endOfDirectory. Records state in
+        self._end_of_directory.
+
+        Typically it is not necessary to call this method directly, as
+        calling :meth:`~kodiswift.Plugin.finish` will call this method.
+        """
+        self._update_listing = update_listing
+        if not self._end_of_directory:
+            self._end_of_directory = True
+            # Finalize the directory items
+            return xbmcplugin.endOfDirectory(self.handle, succeeded,
+                                             update_listing, cache_to_disc)
+        else:
+            raise Exception('Already called endOfDirectory.')
+
+    def finish(self, items=None, sort_methods=None, succeeded=True,
+               update_listing=False, cache_to_disc=True, view_mode=None):
+        """Adds the provided items to the Kodi interface.
+
+        Args:
+            items (List[Dict[str, str]]]): an iterable of items where each
+                item is either a dictionary with keys/values suitable for
+                passing to :meth:`kodiswift.ListItem.from_dict` or an
+                instance of :class:`kodiswift.ListItem`.
+
+            sort_methods (Union[List[str], str]): A list of valid Kodi
+                sort_methods. Each item in the list can either be a sort
+                method or a tuple of `sort_method, label2_mask`.
+                See :meth:`add_sort_method` for more detail concerning
+                valid sort_methods.
+
+            succeeded (bool):
+            update_listing (bool):
+            cache_to_disc (bool): Whether to tell Kodi to cache this folder
+                to disk.
+            view_mode (Union[str, int]): Can either be an integer
+                (or parsable integer string) corresponding to a view_mode or
+                the name of a type of view. Currently the only view type
+                supported is 'thumbnail'.
+
+        Returns:
+            List[kodiswift.listitem.ListItem]: A list of all ListItems added
+                to the Kodi interface.
+        """
+        # If we have any items, add them. Items are optional here.
+        if items:
+            self.add_items(items)
+        if sort_methods:
+            for sort_method in sort_methods:
+                if isinstance(sort_method, (list, tuple)):
+                    self.add_sort_method(*sort_method)
+                else:
+                    self.add_sort_method(sort_method)
+
+        # Attempt to set a view_mode if given
+        if view_mode is not None:
+            # First check if we were given an integer or parsable integer
+            try:
+                view_mode_id = int(view_mode)
+            except ValueError:
+                view_mode_id = None
+            if view_mode_id is not None:
+                self.set_view_mode(view_mode_id)
+
+        # Finalize the directory items
+        self.end_of_directory(succeeded, update_listing, cache_to_disc)
+
+        # Return the cached list of all the list items that were added
+        return self.added_items
+
+    def _listitemify(self, item):
+        """Creates an kodiswift.ListItem if the provided value for item is a
+        dict. If item is already a valid kodiswift.ListItem, the item is
+        returned unmodified.
+        """
+        info_type = self.info_type if hasattr(self, 'info_type') else 'video'
+
+        # Create ListItems for anything that is not already an instance of
+        # ListItem
+        if not hasattr(item, 'as_tuple') and hasattr(item, 'keys'):
+            if 'info_type' not in item:
+                item['info_type'] = info_type
+            item = kodiswift.ListItem.from_dict(**item)
+        return item
+
+    @staticmethod
+    def _add_subtitles(subtitles):
+        """Adds subtitles to playing video.
+
+        Warnings:
+            You must start playing a video before calling this method or it
+            will raise and Exception after 30 seconds.
+
+        Args:
+            subtitles (str): A URL to a remote subtitles file or a local
+                filename for a subtitles file.
+        """
+        # This method is named with an underscore to suggest that callers pass
+        # the subtitles argument to set_resolved_url instead of calling this
+        # method directly. This is to ensure a video is played before calling
+        # this method.
+        player = xbmc.Player()
+        monitor = xbmc.Monitor()
+        while not monitor.abortRequested():
+            if monitor.waitForAbort(30):
+                # Abort requested, so exit.
+                break
+            elif player.isPlaying():
+                # No abort requested after 30 seconds and a video is playing
+                # so add the subtitles and exit.
+                player.setSubtitles(subtitles)
+                break
+            else:
+                raise Exception('No video playing. Aborted after 30 seconds.')

resources/lib/ContentSources.py

@@ -6,10 +6,10 @@
 # Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
 #
 
-import sys,os,re
-import glob
-sys.path.insert(0,os.path.dirname(os.path.abspath(__file__)))
-from  sources.SourceBase import stream_type
+import sys, os, re
+import glob, traceback
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from sources.SourceBase import stream_type
 import util
 
 
@@ -24,7 +24,7 @@ class ContentSources(object):
         #for f in os.listdir(plugin_path):
         #for f in next(os.walk(plugin_path))[2]:
         print "ContentSources: Importing sources from "+plugin_path
-        files = glob.glob(os.path.join(plugin_path,"*.py"))
+        files = glob.glob(os.path.join(plugin_path, "*.py"))
         for f in files:
             fname, ext = os.path.splitext(f)
             fname = os.path.split(fname)[1]
@@ -105,10 +105,31 @@ class ContentSources(object):
                 for k in s:
                     if isinstance(s[k],unicode):
                         s[k] = s[k].encode("utf8")
+                if not "resolver" in s:
+                    s["resolver"] = source
+                if not "surl" in s or not s["surl"]:
+                    s["surl"] = data
+                if not "nfo" in s:
+                    s["nfo"]={"movie":{"title":s["name"],"thumb":s["img"],"plot":s["desc"]}}
             return streams
         else:
             return []
 
+    def get_info(self,data):
+        nfo = {}
+        if self.is_video(data):
+            source = data.split("::")[0]
+            if source in self.plugins:
+                if "get_info" in dir(self.plugins[source]):
+                    streams = self.get_streams(data)
+                    nfo = streams[0]["nfo"] if streams and "nfo" in streams[0] else {}
+                else:
+                    nfo = self.plugins[source].get_info(data)
+        else:
+            pass    # TODO create nfo for listing
+        return nfo
+
+
     def stream_type(self,data):
         return stream_type(data)
 
@@ -155,7 +176,7 @@ if __name__ == "__main__":
     while True:
         print
         for i,item in enumerate(content):
-            s = "%i: %s - %s %s %s "%(i+1,item[0],item[1],item[2],item[3])
+            s = "%i: %s - %s %s"%(i,item[0],item[1],item[2])
             print s #.encode(sys.stdout.encoding,"replace")
 
         while True:
@@ -170,7 +191,7 @@ if __name__ == "__main__":
             except:
                 print "Not number!"
         if exit_loop: break
-        cur2 = content[n-1]
+        cur2 = content[n]
 
         data0 = cur2[1].split("::")[1] if "::" in cur2[1] else cur2[1]
         if not data0:
@@ -185,11 +206,11 @@ if __name__ == "__main__":
                 stream["name"] = cur2[0]
                 streams = [stream]
             else:
-                streams = sources.get_streams(cur2[1])
                 try:
                     streams = sources.get_streams(cur2[1])
                 except Exception as e:
-                    print str(e)
+                    print unicode(e)
+                    traceback.print_exc()
                     streams = []
             if streams:
                 util.play_video(streams)
@@ -209,7 +230,8 @@ if __name__ == "__main__":
         try:
             content = sources.get_content(cur[1])
         except Exception as e:
-            print str(e)
+            print unicode(e)
+            traceback.print_exc()
             raw_input("Continue?")
 
 

resources/lib/ordereddict.py

@@ -0,0 +1,127 @@
+# Copyright (c) 2009 Raymond Hettinger
+#
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+#     The above copyright notice and this permission notice shall be
+#     included in all copies or substantial portions of the Software.
+#
+#     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+#     OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+#     HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+#     WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+#     FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+#     OTHER DEALINGS IN THE SOFTWARE.
+
+from UserDict import DictMixin
+
+class OrderedDict(dict, DictMixin):
+
+    def __init__(self, *args, **kwds):
+        if len(args) > 1:
+            raise TypeError('expected at most 1 arguments, got %d' % len(args))
+        try:
+            self.__end
+        except AttributeError:
+            self.clear()
+        self.update(*args, **kwds)
+
+    def clear(self):
+        self.__end = end = []
+        end += [None, end, end]         # sentinel node for doubly linked list
+        self.__map = {}                 # key --> [key, prev, next]
+        dict.clear(self)
+
+    def __setitem__(self, key, value):
+        if key not in self:
+            end = self.__end
+            curr = end[1]
+            curr[2] = end[1] = self.__map[key] = [key, curr, end]
+        dict.__setitem__(self, key, value)
+
+    def __delitem__(self, key):
+        dict.__delitem__(self, key)
+        key, prev, next = self.__map.pop(key)
+        prev[2] = next
+        next[1] = prev
+
+    def __iter__(self):
+        end = self.__end
+        curr = end[2]
+        while curr is not end:
+            yield curr[0]
+            curr = curr[2]
+
+    def __reversed__(self):
+        end = self.__end
+        curr = end[1]
+        while curr is not end:
+            yield curr[0]
+            curr = curr[1]
+
+    def popitem(self, last=True):
+        if not self:
+            raise KeyError('dictionary is empty')
+        if last:
+            key = reversed(self).next()
+        else:
+            key = iter(self).next()
+        value = self.pop(key)
+        return key, value
+
+    def __reduce__(self):
+        items = [[k, self[k]] for k in self]
+        tmp = self.__map, self.__end
+        del self.__map, self.__end
+        inst_dict = vars(self).copy()
+        self.__map, self.__end = tmp
+        if inst_dict:
+            return (self.__class__, (items,), inst_dict)
+        return self.__class__, (items,)
+
+    def keys(self):
+        return list(self)
+
+    setdefault = DictMixin.setdefault
+    update = DictMixin.update
+    pop = DictMixin.pop
+    values = DictMixin.values
+    items = DictMixin.items
+    iterkeys = DictMixin.iterkeys
+    itervalues = DictMixin.itervalues
+    iteritems = DictMixin.iteritems
+
+    def __repr__(self):
+        if not self:
+            return '%s()' % (self.__class__.__name__,)
+        return '%s(%r)' % (self.__class__.__name__, self.items())
+
+    def copy(self):
+        return self.__class__(self)
+
+    @classmethod
+    def fromkeys(cls, iterable, value=None):
+        d = cls()
+        for key in iterable:
+            d[key] = value
+        return d
+
+    def __eq__(self, other):
+        if isinstance(other, OrderedDict):
+            if len(self) != len(other):
+                return False
+            for p, q in  zip(self.items(), other.items()):
+                if p != q:
+                    return False
+            return True
+        return dict.__eq__(self, other)
+
+    def __ne__(self, other):
+        return not self == other

resources/lib/resolver.py

@@ -56,15 +56,11 @@ RESOLVERS = sorted(RESOLVERS, key=lambda m: -m.__priority__)
 def resolve(url):
     """
         resolves given url by asking all resolvers
-
-        returns None if no resolver advised to be able to resolve this url
-        returns False if resolver did his job, but did not return any value (thus failed)
         returns Array of resolved objects in positive usecase
     """
     url = util.decode_html(url)
     util.info('Resolving ' + url)
     resolver = _get_resolver(url)
-    value = None
     if resolver is None:
         return []
     util.info('Using resolver \'%s\'' % str(resolver.__name__));
@@ -87,7 +83,7 @@ def resolve(url):
                 if "=" in h:
                     i["headers"][h.split("=")[0]] = h.split("=")[1]
 
-    return sorted(value, key=lambda i: i['quality'], reverse=True)
+    return sorted(value, key=lambda i: i['quality'], reverse=True) # TODO sorted by order?
 
 
 def _get_resolver(url):

resources/lib/resolvers/hdgo.py

@@ -30,6 +30,11 @@ except:
     import util
 import urllib2
 import requests
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
 #from aadecode import AADecoder
 
 if __name__ <> "__main__":
@@ -90,6 +95,6 @@ if __name__ == "__main__":
     util.play_video(streams)
 
 
-    #print streams[0]["url"]    
+    #print streams[0]["url"]
     #call([r"gst-launch-1.0.exe",'uri="%s""'%streams[0]["url"]])
     pass

resources/lib/resolvers/hqqresolver.py

@@ -24,6 +24,11 @@ except:
     sys.path.insert(0, os.sep.join(pp.split(os.sep)[:-1]))
     import util
 import requests
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
 
 __author__ = 'ivars777'
 if __name__ <> "__main__":

resources/lib/resolvers/kapnob.py

@@ -29,6 +29,11 @@ except:
     sys.path.insert(0,os.sep.join(pp.split(os.sep)[:-1]))
     import util
 import requests
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
 
 __author__ = 'ivars777'
 if __name__ <> "__main__":
@@ -89,6 +94,6 @@ if __name__ == "__main__":
         sys.exit()
     for s in streams:
         print s
-    print streams[0]["url"]    
+    print streams[0]["url"]
     util.play_video(streams)
     pass

resources/lib/resolvers/kodik.py

@@ -29,6 +29,11 @@ except:
     sys.path.insert(0,os.sep.join(pp.split(os.sep)[:-1]))
     import util
 import requests
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
 
 __author__ = 'ivars777'
 if __name__ <> "__main__":
@@ -90,6 +95,6 @@ if __name__ == "__main__":
         sys.exit()
     for s in streams:
         print s
-    print streams[0]["url"]    
+    print streams[0]["url"]
     util.play_video(streams)
     pass

resources/lib/resolvers/openload3.py

@@ -30,6 +30,11 @@ except:
     import util
 import urllib2
 import requests
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
 #from aadecode import AADecoder
 
 __author__ = 'Jose Riha/Lubomir Kucera'
@@ -49,7 +54,7 @@ def resolve(url):
         'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
         'Accept-Encoding': 'none',
         'Accept-Language': 'en-US,en;q=0.8',
-        'Referer': url}  # 'Connection': 'keep-alive'    
+        'Referer': url}  # 'Connection': 'keep-alive'
 
     stream = util.item()
     m = re.search('https*://openload\.\w+/embed/([^/]+)', url)
@@ -68,11 +73,11 @@ def resolve(url):
     stream["url"] = res["url"]
     stream["name"]= res["url"]
     ### Retrieve subtitles ####
-    html = requests.get(url, headers=HTTP_HEADER).content 
+    html = requests.get(url, headers=HTTP_HEADER).content
     m = re.search('<track kind="captions" src="([^"]+)" srclang="([^"]+)" label="([^"]+)"', html)
     if m:
         stream["subs"] = m.group(1)
-        stream["lang"] = m.group(2)   
+        stream["lang"] = m.group(2)
 
     return [stream]
 
@@ -90,8 +95,8 @@ if __name__ == "__main__":
     #url = "https://kinostok.tv/embed/731f3437e3c53104dd56d04039a0b15a"
     #url = "http://vk.com/video_ext.php?oid=246066565&id=169244575&hash=d430ab0e76c9f7a1&hd=3"
     #url ="https://openload.co/embed/rPMXJYPTkw4/"
-    #url = "https://openload.co/embed/bE7WfZ-vz_A/" 
-    #url = "https://openload.co/embed/bE7WfZ/" 
+    #url = "https://openload.co/embed/bE7WfZ-vz_A/"
+    #url = "https://openload.co/embed/bE7WfZ/"
     #url = "https://openload.co/embed/OuskaKyC2GU/"
     url = "http://hqq.tv/player/embed_player.php?vid=235238210241210222228241233208212245&autoplay=no"
     url = "https://openload.co/embed/rmNcP-0QopE/"
@@ -104,6 +109,6 @@ if __name__ == "__main__":
     for s in streams:
         print s
 
-    print streams[0]["url"]    
+    print streams[0]["url"]
     call([r"c:\Program Files\VideoLAN\VLC\vlc.exe",streams[0]["url"]])
     pass

resources/lib/resolvers0/__init__.py

@@ -0,0 +1,31 @@
+#/*
+# *      Copyright (C) 2011 Libor Zoubek
+# *
+# *
+# *  This Program is free software; you can redistribute it and/or modify
+# *  it under the terms of the GNU General Public License as published by
+# *  the Free Software Foundation; either version 2, or (at your option)
+# *  any later version.
+# *
+# *  This Program is distributed in the hope that it will be useful,
+# *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+# *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# *  GNU General Public License for more details.
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# */
+
+
+##########################################################3
+# all resolvers modules in this directory must have following methods:
+
+# __name__ - name of the resolver module - can override module filename
+# def supports(url) - returns true iff resolver is able to resolve url to stream otherwise false
+# def resolve(url) - returns array of all hashmaps that were resolved
+#   - if resolving fails, nothing is returned
+#   - a hash MUST contain key 'url' - it's value is stream URL
+#   - optional keys are 'subs' (link to subtitle), 'quality' (quality string like '240p' or just 'HD'

resources/lib/resolvers0/aadecode.py

@@ -0,0 +1,209 @@
+#-*- coding: utf-8 -*-
+#
+# author : Djeman
+# Updated by Shani-08 (https://github.com/Shani-08/ShaniXBMCWork2)
+
+import re
+
+class AADecoder(object):
+    def __init__(self, aa_encoded_data):
+        self.encoded_str = aa_encoded_data.replace('/*´∇｀*/','')
+
+        self.b = ["(c^_^o)", "(ﾟΘﾟ)", "((o^_^o) - (ﾟΘﾟ))", "(o^_^o)",
+                  "(ﾟｰﾟ)", "((ﾟｰﾟ) + (ﾟΘﾟ))", "((o^_^o) +(o^_^o))", "((ﾟｰﾟ) + (o^_^o))",
+                  "((ﾟｰﾟ) + (ﾟｰﾟ))", "((ﾟｰﾟ) + (ﾟｰﾟ) + (ﾟΘﾟ))", "(ﾟДﾟ) .ﾟωﾟﾉ", "(ﾟДﾟ) .ﾟΘﾟﾉ",
+                  "(ﾟДﾟ) ['c']", "(ﾟДﾟ) .ﾟｰﾟﾉ", "(ﾟДﾟ) .ﾟДﾟﾉ", "(ﾟДﾟ) [ﾟΘﾟ]"]
+
+    def is_aaencoded(self):
+        idx = self.encoded_str.find("ﾟωﾟﾉ= /｀ｍ´）ﾉ ~┻━┻   //*´∇｀*/ ['_']; o=(ﾟｰﾟ)  =_=3; c=(ﾟΘﾟ) =(ﾟｰﾟ)-(ﾟｰﾟ); ")
+        if idx == -1:
+            return False
+
+        if self.encoded_str.find("(ﾟДﾟ)[ﾟoﾟ]) (ﾟΘﾟ)) ('_');", idx) == -1:
+            return False
+
+        return True
+
+    def base_repr(self, number, base=2, padding=0):
+        digits = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+        if base > len(digits):
+            base = len(digits)
+
+        num = abs(number)
+        res = []
+        while num:
+            res.append(digits[num % base])
+            num //= base
+        if padding:
+            res.append('0' * padding)
+        if number < 0:
+            res.append('-')
+        return ''.join(reversed(res or '0'))
+
+    def decode_char(self, enc_char, radix):
+        end_char = "+ "
+        str_char = ""
+        while enc_char != '':
+            found = False
+
+            if not found:
+                for i in range(len(self.b)):             
+                    enc_char=enc_char.replace(self.b[i], str(i))
+                
+                startpos=0
+                findClose=True
+                balance=1
+                result=[]
+                if enc_char.startswith('('):
+                    l=0
+                    
+                    for t in enc_char[1:]:
+                        l+=1
+                        if findClose and t==')':
+                            balance-=1;
+                            if balance==0:
+                                result+=[enc_char[startpos:l+1]]
+                                findClose=False
+                                continue
+                        elif not findClose and t=='(':
+                            startpos=l
+                            findClose=True
+                            balance=1
+                            continue
+                        elif t=='(':
+                            balance+=1
+                 
+
+                if result is None or len(result)==0:
+                    return ""
+                else:
+                    
+                    for r in result:
+                        value = self.decode_digit(r, radix)
+                        if value == "":
+                            return ""
+                        else:
+                            str_char += value
+                            
+                    return str_char
+
+            enc_char = enc_char[len(end_char):]
+
+        return str_char
+
+        
+              
+    def decode_digit(self, enc_int, radix):
+
+        rr = '(\(.+?\)\))\+'
+        rerr=enc_int.split('))+')
+        v = ''
+        
+        #new mode
+
+        for c in rerr:
+            
+            if len(c)>0:
+                if c.strip().endswith('+'):
+                    c=c.strip()[:-1]
+
+                startbrackets=len(c)-len(c.replace('(',''))
+                endbrackets=len(c)-len(c.replace(')',''))
+                    
+                if startbrackets>endbrackets:
+                    c+=')'*startbrackets-endbrackets
+                    
+                c = c.replace('!+[]','1')
+                c = c.replace('-~','1+')
+                c = c.replace('[]','0')
+                    
+                v+=str(eval(c))
+                    
+        return v
+         
+        mode = 0
+        value = 0
+
+        while enc_int != '':
+            found = False
+            for i in range(len(self.b)):
+                if enc_int.find(self.b[i]) == 0:
+                    if mode == 0:
+                        value += i
+                    else:
+                        value -= i
+                    enc_int = enc_int[len(self.b[i]):]
+                    found = True
+                    break
+
+            if not found:
+                return ""
+
+            enc_int = re.sub('^\s+|\s+$', '', enc_int)
+            if enc_int.find("+") == 0:
+                mode = 0
+            else:
+                mode = 1
+
+            enc_int = enc_int[1:]
+            enc_int = re.sub('^\s+|\s+$', '', enc_int)
+
+        return self.base_repr(value, radix)
+
+    def decode(self):
+
+        self.encoded_str = re.sub('^\s+|\s+$', '', self.encoded_str)
+
+        # get data
+        pattern = (r"\(ﾟДﾟ\)\[ﾟoﾟ\]\+ (.+?)\(ﾟДﾟ\)\[ﾟoﾟ\]\)")
+        result = re.search(pattern, self.encoded_str, re.DOTALL)
+        if result is None:
+            print "AADecoder: data not found"
+            return False
+
+        data = result.group(1)
+
+        # hex decode string
+        begin_char = "(ﾟДﾟ)[ﾟεﾟ]+"
+        alt_char = "(oﾟｰﾟo)+ "
+
+        out = ''
+
+        while data != '':
+            # Check new char
+            if data.find(begin_char) != 0:
+                print "AADecoder: data not found"
+                return False
+
+            data = data[len(begin_char):]
+
+            # Find encoded char
+            enc_char = ""
+            if data.find(begin_char) == -1:
+                enc_char = data
+                data = ""
+            else:
+                enc_char = data[:data.find(begin_char)]
+                data = data[len(enc_char):]
+
+            
+            radix = 8
+            # Detect radix 16 for utf8 char
+            if enc_char.find(alt_char) == 0:
+                enc_char = enc_char[len(alt_char):]
+                radix = 16
+
+            str_char = self.decode_char(enc_char, radix)
+            
+            if str_char == "":
+                print "no match :  "
+                print  data + "\nout = " + out + "\n"
+                return False
+            
+            out += chr(int(str_char, radix))
+
+        if out == "":
+            print "no match : " + data
+            return False
+
+        return out

resources/lib/resolvers0/hdgo.py

@@ -0,0 +1,97 @@
+# -*- coding: UTF-8 -*-
+# /*
+# *      Copyright (C) 2016 ivars777
+# *
+# *
+# *  This Program is free software; you can redistribute it and/or modify
+# *  it under the terms of the GNU General Public License as published by
+# *  the Free Software Foundation; either version 2, or (at your option)
+# *  any later version.
+# *
+# *  This Program is distributed in the hope that it will be useful,
+# *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+# *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# *  GNU General Public License for more details.
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# */
+
+import re,os,sys
+import json
+try:
+    import util
+except:
+    pp = os.path.dirname(os.path.abspath(__file__))
+    sys.path.insert(0,os.sep.join(pp.split(os.sep)[:-1]))
+    import util
+import urllib2
+import requests
+from requests.packages.urllib3.exceptions import InsecureRequestWarning
+requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+#from aadecode import AADecoder
+
+if __name__ <> "__main__":
+    __name__ = 'hqq'
+
+def supports(url):
+    m = re.search(r"https?://hdgo\.\w+/(.+?)$", url, re.DOTALL)
+    if m:
+        return True
+    else:
+        return False
+
+def resolve(url):
+    HTTP_HEADER = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:39.0) Gecko/20100101 Firefox/39.0',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
+        'Accept-Encoding': 'none',
+        'Accept-Language': 'en-US,en;q=0.8',
+        'Referer': url}  # 'Connection': 'keep-alive'
+    streams = []
+    m = re.search(r"https?://hdgo\.\w+/(.+?)$", url, re.DOTALL)
+    vid=m.group(1)
+    url2 = "http://couber.be/"+vid
+    r = requests.get(url2,headers=HTTP_HEADER)
+    if r.status_code <> 200:
+        return streams
+    m = re.search('<iframe src="([^"]+)"', r.content, re.DOTALL)
+    if not m: return streams
+    url3 = m.group(1)
+    HTTP_HEADER["Rererer"] = url2
+    r = requests.get(url3,headers=HTTP_HEADER)
+    m = re.search(r"else{\s+setFlash\('([^']+)'\);", r.content, re.DOTALL)
+    if not m: return streams
+    q = ["1080p","720p","480p","360p"]
+    for i,ss in enumerate(m.group(1).split(",")):
+        s = ss.split(" or ")
+        if not s[0]: continue
+        stream = util.item()
+        stream["url"] = s[0]
+        stream["name"] = s[0]
+        stream["quality"] = q[i]
+        streams.append(stream)
+    return streams
+
+
+if __name__ == "__main__":
+
+    from subprocess import call
+    url = "http://hdgo.cc/video/t/Qrz0riUvA65GtkTpDvmlD9TBOn56HSm2/127280/"
+    url = "http://hdgo.cc/video/t/Qrz0riUvA65GtkTpDvmlD9TBOn56HSm2/34879/"
+    streams = resolve(url)
+    if not streams:
+        print "No streams found"
+        sys.exit()
+    for s in streams:
+        print s
+    util.play_video(streams)
+
+
+    #print streams[0]["url"]
+    #call([r"gst-launch-1.0.exe",'uri="%s""'%streams[0]["url"]])
+    pass

resources/lib/resolvers0/hqqresolver.py

@@ -0,0 +1,234 @@
+# -*- coding: UTF-8 -*-
+# *  GNU General Public License for more details.
+# *
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# *
+# *  based on https://gitorious.org/iptv-pl-dla-openpli/ urlresolver
+# */
+from StringIO import StringIO
+import json
+import re
+import base64
+import urllib
+import sys,os
+
+try:
+    import util
+except:
+    pp = os.path.dirname(os.path.abspath(__file__))
+    sys.path.insert(0, os.sep.join(pp.split(os.sep)[:-1]))
+    import util
+import requests
+
+__author__ = 'ivars777'
+if __name__ <> "__main__":
+    __name__ = 'hqq'
+
+
+def supports(url):
+    #return False
+    return _regex(url) is not None
+
+
+def _decode(data):
+    def O1l(string):
+        ret = ""
+        i = len(string) - 1
+        while i >= 0:
+            ret += string[i]
+            i -= 1
+        return ret
+
+    def l0I(string):
+        enc = ""
+        dec = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
+        i = 0
+        while True:
+            h1 = dec.find(string[i])
+            i += 1
+            h2 = dec.find(string[i])
+            i += 1
+            h3 = dec.find(string[i])
+            i += 1
+            h4 = dec.find(string[i])
+            i += 1
+            bits = h1 << 18 | h2 << 12 | h3 << 6 | h4
+            o1 = bits >> 16 & 0xff
+            o2 = bits >> 8 & 0xff
+            o3 = bits & 0xff
+            if h3 == 64:
+                enc += unichr(o1)
+            else:
+                if h4 == 64:
+                    enc += unichr(o1) + unichr(o2)
+                else:
+                    enc += unichr(o1) + unichr(o2) + unichr(o3)
+            if i >= len(string):
+                break
+        return enc
+
+    escape = re.search("var _escape=\'([^\']+)", l0I(O1l(data))).group(1)
+    return escape.replace('%', '\\').decode('unicode-escape')
+
+
+def _decode2(file_url):
+    def K12K(a, typ='b'):
+        codec_a = ["G", "L", "M", "N", "Z", "o", "I", "t", "V", "y", "x", "p", "R", "m", "z", "u",
+                   "D", "7", "W", "v", "Q", "n", "e", "0", "b", "="]
+        codec_b = ["2", "6", "i", "k", "8", "X", "J", "B", "a", "s", "d", "H", "w", "f", "T", "3",
+                   "l", "c", "5", "Y", "g", "1", "4", "9", "U", "A"]
+        if 'd' == typ:
+            tmp = codec_a
+            codec_a = codec_b
+            codec_b = tmp
+        idx = 0
+        while idx < len(codec_a):
+            a = a.replace(codec_a[idx], "___")
+            a = a.replace(codec_b[idx], codec_a[idx])
+            a = a.replace("___", codec_b[idx])
+            idx += 1
+        return a
+
+    def _xc13(_arg1):
+        _lg27 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
+        _local2 = ""
+        _local3 = [0, 0, 0, 0]
+        _local4 = [0, 0, 0]
+        _local5 = 0
+        while _local5 < len(_arg1):
+            _local6 = 0
+            while _local6 < 4 and (_local5 + _local6) < len(_arg1):
+                _local3[_local6] = _lg27.find(_arg1[_local5 + _local6])
+                _local6 += 1
+            _local4[0] = ((_local3[0] << 2) + ((_local3[1] & 48) >> 4))
+            _local4[1] = (((_local3[1] & 15) << 4) + ((_local3[2] & 60) >> 2))
+            _local4[2] = (((_local3[2] & 3) << 6) + _local3[3])
+
+            _local7 = 0
+            while _local7 < len(_local4):
+                if _local3[_local7 + 1] == 64:
+                    break
+                _local2 += chr(_local4[_local7])
+                _local7 += 1
+            _local5 += 4
+        return _local2
+
+    return _xc13(K12K(file_url, 'e'))
+
+
+def resolve(url):
+    m = _regex(url)
+    if m:
+        headers = {'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                   'Content-Type': 'text/html; charset=utf-8'}
+        if "goo.gl" in url:
+            data = util.request(url, headers)
+            player_url = re.search("var ppage = '(.+?)'",data).group(1)
+            player_url = urllib.unquote(player_url)
+        else:
+            vid = m.group('vid')
+            player_url = "http://hqq.tv/player/embed_player.php?vid=%s&autoplay=no" % vid
+            data = util.request(player_url, headers)
+        b64enc = re.search('base64([^\"]+)', data, re.DOTALL)
+        b64dec = b64enc and base64.decodestring(b64enc.group(1))
+        enc = b64dec and re.search("\'([^']+)\'", b64dec).group(1)
+        if enc:
+            data = re.findall('<input name="([^"]+?)" [^>]+? value="([^"]+?)">', _decode(enc))
+            post_data = {}
+            for idx in range(len(data)):
+                post_data[data[idx][0]] = data[idx][1]
+            data = util.post(player_url, post_data, headers)
+            b64enc = re.search('base64([^\"]+)', data, re.DOTALL)
+            b64dec = b64enc and base64.decodestring(b64enc.group(1))
+            enc = b64dec and re.search("\'([^']+)\'", b64dec).group(1)
+            if enc:
+                data = re.findall('<input name="([^"]+?)" [^>]+? value="([^"]*)">', _decode(enc))
+                post_data = {}
+                for idx in range(len(data)):
+                    post_data[data[idx][0]] = data[idx][1]
+                data = urllib.unquote(util.request("http://hqq.tv/sec/player/embed_player.php?" +
+                                                   urllib.urlencode(post_data), headers))
+                server_1 = re.search("server_1: (\w+)",data).group(1)
+                link_1 = re.search("link_1: (\w+)",data).group(1)
+                vid_server = re.search(r'var\s*%s\s*=\s*"([^"]*?)"'%server_1, data)
+                vid_link = re.search(r'var\s*%s\s*=\s*"([^"]*?)"'%link_1, data)
+                at = re.search(r'var\s*at\s*=\s*"([^"]*?)"', data)
+                vid = re.search('vid: "([^"]+)"',data)
+                sub_url = re.search('sub:"(.+?)"',data).group(1) if re.search('sub:"(.+?)"',data) else ""
+                subs_lang = re.search('sublangs:"(.+?)"',data).group(1) if re.search('sub:"(.+?)"',data) else ""
+                if sub_url:
+                    subs=[{"url":sub_url,'name':subs_lang,"lang":subs_lang}]
+                else:
+                    subs = []
+                if vid_server and vid_link and at:
+                    get_data = {'server_1': vid_server.group(1),
+                                'link_1': vid_link.group(1),
+                                'at': at.group(1),
+                                'adb': '0/',
+                                'b':'1',
+                                'vid': vid.group(1)}
+                    # X-Requested-With: XMLHttpRequest
+                    headers["X-Requested-With"] = "XMLHttpRequest"
+                    html = util.request("http://hqq.tv/player/get_md5.php?"+urllib.urlencode(get_data), headers)
+                    data = json.load(StringIO(html))
+                    if 'file' in data:
+                        file_url = _decode2(data['file'])
+                        file_url = re.sub(r'\?socket=?$', '.mp4.m3u8',file_url)
+                        stream  = {
+                            'url': file_url,
+                            'name': file_url,
+                            'subs':subs,
+                            'quality': 'hqq',
+                            'resolver': 'hqq',
+                            "headers":{"User-Agent":"Mozilla/5.0 (iPhone; CPU iPhone OS 9_2 like Mac OS X) AppleWebKit/601.1 (KHTML, like Gecko) CriOS/47.0.2526.70 Mobile/13C71 Safari/601.1.46"}
+                        }
+                        return [stream]
+    return []
+
+
+def _regex(url):
+    # https://goo.gl/yMTzqf
+    match = re.search("(hqq|netu)\.tv/watch_video\.php\?v=(?P<vid>[0-9A-Z]+)", url)
+    if match:
+        return match
+    match = re.search(r'(hqq|netu)\.tv/player/embed_player\.php\?vid=(?P<vid>[0-9A-Za-z]+)', url)
+    if match:
+        return match
+    match = re.search(r'(hqq|netu)\.tv/player/hash\.php\?hash=\d+', url)
+    if match:
+        match = re.search(r'var\s+vid\s*=\s*\'(?P<vid>[^\']+)\'', urllib.unquote(util.request(url)))
+        if match:
+            return match
+    # https://goo.gl/yMTzqf
+    match = re.search("(goo)\.gl/(?P<vid>[\w]+)", url)
+    if match:
+        return match
+
+    b64enc = re.search(r'data:text/javascript\;charset\=utf\-8\;base64([^\"]+)', url)
+    b64dec = b64enc and base64.decodestring(b64enc.group(1))
+    enc = b64dec and re.search(r"\'([^']+)\'", b64dec).group(1)
+    if enc:
+        decoded = _decode(enc)
+        match = re.search(r'<input name="vid"[^>]+? value="(?P<vid>[^"]+?)">', decoded)
+        if re.search(r'<form(.+?)action="[^"]*(hqq|netu)\.tv/player/embed_player\.php"[^>]*>',
+                     decoded) and match:
+            return match
+    return None
+
+if __name__ == "__main__":
+
+    url = "http://hqq.tv/player/embed_player.php?vid=nYAKgzBAf7ll"
+    streams = resolve(url)
+    if not streams:
+        print "No streams found"
+        sys.exit()
+    for s in streams:
+        print s
+    print streams[0]["url"]
+    util.play_video(streams)
+    pass

resources/lib/resolvers0/kapnob.py

@@ -0,0 +1,94 @@
+# -*- coding: UTF-8 -*-
+# /*
+# *      Copyright (C) 2016 Ivars777
+# *
+# *
+# *  This Program is free software; you can redistribute it and/or modify
+# *  it under the terms of the GNU General Public License as published by
+# *  the Free Software Foundation; either version 2, or (at your option)
+# *  any later version.
+# *
+# *  This Program is distributed in the hope that it will be useful,
+# *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+# *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# *  GNU General Public License for more details.
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# */
+
+import re,os,sys
+import json
+try:
+    import util
+except:
+    pp = os.path.dirname(os.path.abspath(__file__))
+    sys.path.insert(0,os.sep.join(pp.split(os.sep)[:-1]))
+    import util
+import requests
+
+__author__ = 'ivars777'
+if __name__ <> "__main__":
+    __name__ = 'kapnob'
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-US,en;q=0.5
+""")
+
+
+def supports(url):
+    return True if "kapnob.ru" in url else False
+
+def resolve(url):
+    HTTP_HEADER = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:39.0) Gecko/20100101 Firefox/39.0',
+        'Referer': url}  # 'Connection': 'keep-alive'
+    stream = util.item()
+    data = requests.get(url,headers = HTTP_HEADER).content
+    m = re.search(r'subtitles: \[\s+{\s+src: "(.+?)",\s+label: "(.+?)",\s+language: "(.+?)"', data, re.DOTALL)
+    if m:
+        sub = {}
+        sub["url"] = m.group(1)
+        sub["name"] = m.group(2)
+        sub["lang"] = m.group(3)
+        sub["type"] = "srt"
+        stream["subs"]=[sub]
+
+    video_token = re.search("video_token: '(.+?)'",data).group(1)
+    content_type = re.search("content_type: '(.+?)'",data).group(1)
+    mw_key = re.search("mw_key: '(.+?)'",data).group(1)
+    mw_domain_id = re.search("mw_domain_id: (\d+)",data).group(1)
+    uuid = re.search("uuid: '(.+?)'",data).group(1)
+    params = "video_token=%s&content_type=%s&mw_key=%s&mw_pid=&mw_domain_id=%s&ad_attr=0&debug=false&uuid=%s"%(
+        video_token,content_type,mw_key,mw_domain_id,uuid)
+    headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:50.0) Gecko/20100101 Firefox/50.0
+Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+X-Iframe-Option: Direct
+X-Requested-With: XMLHttpRequest
+""")
+    data = requests.post("http://cdn.kapnob.ru/sessions/new_session", data=params,headers=headers).content
+    js = json.loads(data)
+    stream["url"] = js["mans"]["manifest_m3u8"]
+    stream["name"]= stream["url"]
+    return [stream]
+
+
+if __name__ == "__main__":
+
+    url = "http://cdn.kapnob.ru/video/5e67c8b1ad018ffa/iframe"
+    streams = resolve(url)
+    if not streams:
+        print "No streams found"
+        sys.exit()
+    for s in streams:
+        print s
+    print streams[0]["url"]    
+    util.play_video(streams)
+    pass

resources/lib/resolvers0/kodik.py

@@ -0,0 +1,95 @@
+# -*- coding: UTF-8 -*-
+# /*
+# *      Copyright (C) 2016 Ivars777
+# *
+# *
+# *  This Program is free software; you can redistribute it and/or modify
+# *  it under the terms of the GNU General Public License as published by
+# *  the Free Software Foundation; either version 2, or (at your option)
+# *  any later version.
+# *
+# *  This Program is distributed in the hope that it will be useful,
+# *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+# *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# *  GNU General Public License for more details.
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# */
+
+import re,os,sys
+import json
+try:
+    import util
+except:
+    pp = os.path.dirname(os.path.abspath(__file__))
+    sys.path.insert(0,os.sep.join(pp.split(os.sep)[:-1]))
+    import util
+import requests
+
+__author__ = 'ivars777'
+if __name__ <> "__main__":
+    __name__ = 'kodik'
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+headers0 = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:50.0) Gecko/20100101 Firefox/50.0
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Upgrade-Insecure-Requests: 1
+DNT: 1
+Connection: keep-alive
+Upgrade-Insecure-Requests: 1
+Cache-Control: max-age=0
+
+""")
+
+
+def supports(url):
+    return True if "kodik.cc" in url else False
+
+def resolve(url):
+    global headers0
+    streams = []
+    try:
+        r = requests.get(url,headers=headers0)
+    except:
+        return []
+    if r.status_code<>200:
+        return []
+    data = r.content
+    hash = re.search('hash: "(.+?)"',data).group(1)
+    vid = re.search('id: "(.+?)"',data).group(1)
+    quality = re.search('quality: "(.+?)"',data).group(1)
+    params = "domain=&url=&type=database&hash=%s&id=%s&quality=%s"%(hash,vid,quality)
+    headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:50.0) Gecko/20100101 Firefox/50.0
+Accept: application/json, text/javascript, */*; q=0.01
+Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+X-Requested-With: XMLHttpRequest
+Referer: %s
+"""%url)
+    data = requests.post("http://kodik.cc/get-video", data=params,headers=headers).content
+    js = json.loads(data)
+    for st in js["qualities"]:
+        stream = util.item()
+        stream["url"] = js["qualities"][st]["src"]
+        stream["quality"]=int(st)
+        stream["name"]= stream["url"]
+        streams.append(stream)
+    return streams
+
+if __name__ == "__main__":
+
+    url = "http://kodik.cc/video/10830/4269a802d1a9d9bdc53fe38488d53a52/720p"
+    streams = resolve(url)
+    if not streams:
+        print "No streams found"
+        sys.exit()
+    for s in streams:
+        print s
+    print streams[0]["url"]    
+    util.play_video(streams)
+    pass

resources/lib/resolvers0/openload3.py

@@ -0,0 +1,109 @@
+# -*- coding: UTF-8 -*-
+# /*
+# *      Copyright (C) 2015 Lubomir Kucera
+# *
+# *
+# *  This Program is free software; you can redistribute it and/or modify
+# *  it under the terms of the GNU General Public License as published by
+# *  the Free Software Foundation; either version 2, or (at your option)
+# *  any later version.
+# *
+# *  This Program is distributed in the hope that it will be useful,
+# *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+# *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# *  GNU General Public License for more details.
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# */
+
+import re,os,sys
+import json
+try:
+    import util
+except:
+    pp = os.path.dirname(os.path.abspath(__file__))
+    sys.path.insert(0,os.sep.join(pp.split(os.sep)[:-1]))
+    import util
+import urllib2
+import requests
+#from aadecode import AADecoder
+
+__author__ = 'Jose Riha/Lubomir Kucera'
+__name__ = 'openload3'
+
+
+def supports(url):
+    return re.search(r'openload\.\w+/embed/.+', url) is not None
+
+
+#INFO_URL = API_BASE_URL + '/streaming/info'
+
+def resolve(url):
+    HTTP_HEADER = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:39.0) Gecko/20100101 Firefox/39.0',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
+        'Accept-Encoding': 'none',
+        'Accept-Language': 'en-US,en;q=0.8',
+        'Referer': url}  # 'Connection': 'keep-alive'    
+
+    stream = util.item()
+    m = re.search('https*://openload\.\w+/embed/([^/]+)', url)
+    if not m:
+        return stream
+    vid=m.group(1)
+    url2 = "https://api.openload.co/1/streaming/get?file="+vid
+    r = requests.get(url2,headers=HTTP_HEADER)
+    try:
+        js = json.loads(r.content)
+    except:
+        return stream
+    if js["status"] <>200:
+        raise Exception(js["msg"])
+    res = js["result"]
+    stream["url"] = res["url"]
+    stream["name"]= res["url"]
+    ### Retrieve subtitles ####
+    html = requests.get(url, headers=HTTP_HEADER).content 
+    m = re.search('<track kind="captions" src="([^"]+)" srclang="([^"]+)" label="([^"]+)"', html)
+    if m:
+        stream["subs"] = m.group(1)
+        stream["lang"] = m.group(2)   
+
+    return [stream]
+
+
+if __name__ == "__main__":
+
+    from subprocess import call
+    #url = "http://hqq.tv/player/embed_player.php?vid=235238210241210222228241233208212245&autoplay=no"
+    #url = "http://hqq.tv/player/embed_player.php?vid=243221241234244238208213206212211231&autoplay=no"
+    url = "http://hqq.tv/player/embed_player.php?vid=208231211231207221227243206206221244&autoplay=no"
+    #url = "https://openload.co/embed/TMthIdpy4PI/"
+    #url = "https://www.youtube.com/watch?v=Tx1K51_F99o"
+    #url = "https://www.youtube.com/watch?v=8BkcX7O1890"
+    #url = "https://www.youtube.com/watch?v=Se07R8SYsg0"
+    #url = "https://kinostok.tv/embed/731f3437e3c53104dd56d04039a0b15a"
+    #url = "http://vk.com/video_ext.php?oid=246066565&id=169244575&hash=d430ab0e76c9f7a1&hd=3"
+    #url ="https://openload.co/embed/rPMXJYPTkw4/"
+    #url = "https://openload.co/embed/bE7WfZ-vz_A/" 
+    #url = "https://openload.co/embed/bE7WfZ/" 
+    #url = "https://openload.co/embed/OuskaKyC2GU/"
+    url = "http://hqq.tv/player/embed_player.php?vid=235238210241210222228241233208212245&autoplay=no"
+    url = "https://openload.co/embed/rmNcP-0QopE/"
+    url = "https://openload.co/embed/oQLXcU1ITAY/"
+    streams = resolve(url)
+    if not streams:
+        print "No streams found"
+        sys.exit()
+
+    for s in streams:
+        print s
+
+    print streams[0]["url"]    
+    call([r"c:\Program Files\VideoLAN\VLC\vlc.exe",streams[0]["url"]])
+    pass

resources/lib/resolvers0/youtuberesolver.py

@@ -0,0 +1,347 @@
+# -*- coding: UTF-8 -*-
+
+import urllib2
+# source from https://github.com/rg3/youtube-dl/issues/1208
+# removed some unnecessary debug messages..
+class CVevoSignAlgoExtractor:
+    # MAX RECURSION Depth for security
+    MAX_REC_DEPTH = 5
+
+    def __init__(self):
+        self.algoCache = {}
+        self._cleanTmpVariables()
+
+    def _cleanTmpVariables(self):
+        self.fullAlgoCode = ''
+        self.allLocalFunNamesTab = []
+        self.playerData = ''
+
+    def _jsToPy(self, jsFunBody):
+        pythonFunBody = jsFunBody.replace('function', 'def').replace('{', ':\n\t').replace('}', '').replace(';', '\n\t').replace('var ', '')
+        pythonFunBody = pythonFunBody.replace('.reverse()', '[::-1]')
+
+        lines = pythonFunBody.split('\n')
+        for i in range(len(lines)):
+            # a.split("") -> list(a)
+            match = re.search('(\w+?)\.split\(""\)', lines[i])
+            if match:
+                lines[i] = lines[i].replace(match.group(0), 'list(' + match.group(1) + ')')
+            # a.length -> len(a)
+            match = re.search('(\w+?)\.length', lines[i])
+            if match:
+                lines[i] = lines[i].replace(match.group(0), 'len(' + match.group(1) + ')')
+            # a.slice(3) -> a[3:]
+            match = re.search('(\w+?)\.slice\(([0-9]+?)\)', lines[i])
+            if match:
+                lines[i] = lines[i].replace(match.group(0), match.group(1) + ('[%s:]' % match.group(2)))
+            # a.join("") -> "".join(a)
+            match = re.search('(\w+?)\.join\(("[^"]*?")\)', lines[i])
+            if match:
+                lines[i] = lines[i].replace(match.group(0), match.group(2) + '.join(' + match.group(1) + ')')
+        return "\n".join(lines)
+
+    def _getLocalFunBody(self, funName):
+        # get function body
+        match = re.search('(function %s\([^)]+?\){[^}]+?})' % funName, self.playerData)
+        if match:
+            # return jsFunBody
+            return match.group(1)
+        return ''
+
+    def _getAllLocalSubFunNames(self, mainFunBody):
+        match = re.compile('[ =(,](\w+?)\([^)]*?\)').findall(mainFunBody)
+        if len(match):
+            # first item is name of main function, so omit it
+            funNameTab = set(match[1:])
+            return funNameTab
+        return set()
+
+    def decryptSignature(self, s, playerUrl):
+        playerUrl = playerUrl[:4] != 'http' and 'http:' + playerUrl or playerUrl
+        util.debug("decrypt_signature sign_len[%d] playerUrl[%s]" % (len(s), playerUrl))
+
+        # clear local data
+        self._cleanTmpVariables()
+
+        # use algoCache
+        if playerUrl not in self.algoCache:
+            # get player HTML 5 sript
+            request = urllib2.Request(playerUrl)
+            try:
+                self.playerData = urllib2.urlopen(request).read()
+                self.playerData = self.playerData.decode('utf-8', 'ignore')
+            except:
+                util.debug('Unable to download playerUrl webpage')
+                return ''
+
+            # get main function name
+            match = re.search("signature=(\w+?)\([^)]\)", self.playerData)
+            if match:
+                mainFunName = match.group(1)
+                util.debug('Main signature function name = "%s"' % mainFunName)
+            else:
+                util.debug('Can not get main signature function name')
+                return ''
+
+            self._getfullAlgoCode(mainFunName)
+
+            # wrap all local algo function into one function extractedSignatureAlgo()
+            algoLines = self.fullAlgoCode.split('\n')
+            for i in range(len(algoLines)):
+                algoLines[i] = '\t' + algoLines[i]
+            self.fullAlgoCode = 'def extractedSignatureAlgo(param):'
+            self.fullAlgoCode += '\n'.join(algoLines)
+            self.fullAlgoCode += '\n\treturn %s(param)' % mainFunName
+            self.fullAlgoCode += '\noutSignature = extractedSignatureAlgo( inSignature )\n'
+
+            # after this function we should have all needed code in self.fullAlgoCode
+            try:
+                algoCodeObj = compile(self.fullAlgoCode, '', 'exec')
+            except:
+                util.debug('decryptSignature compile algo code EXCEPTION')
+                return ''
+        else:
+            # get algoCodeObj from algoCache
+            util.debug('Algo taken from cache')
+            algoCodeObj = self.algoCache[playerUrl]
+
+        # for security alow only flew python global function in algo code
+        vGlobals = {"__builtins__": None, 'len': len, 'list': list}
+
+        # local variable to pass encrypted sign and get decrypted sign
+        vLocals = { 'inSignature': s, 'outSignature': '' }
+
+        # execute prepared code
+        try:
+            exec(algoCodeObj, vGlobals, vLocals)
+        except:
+            util.debug('decryptSignature exec code EXCEPTION')
+            return ''
+
+        util.debug('Decrypted signature = [%s]' % vLocals['outSignature'])
+        # if algo seems ok and not in cache, add it to cache
+        if playerUrl not in self.algoCache and '' != vLocals['outSignature']:
+            util.debug('Algo from player [%s] added to cache' % playerUrl)
+            self.algoCache[playerUrl] = algoCodeObj
+
+        # free not needed data
+        self._cleanTmpVariables()
+
+        return vLocals['outSignature']
+
+    # Note, this method is using a recursion
+    def _getfullAlgoCode(self, mainFunName, recDepth=0):
+        if self.MAX_REC_DEPTH <= recDepth:
+            util.debug('_getfullAlgoCode: Maximum recursion depth exceeded')
+            return
+
+        funBody = self._getLocalFunBody(mainFunName)
+        if '' != funBody:
+            funNames = self._getAllLocalSubFunNames(funBody)
+            if len(funNames):
+                for funName in funNames:
+                    if funName not in self.allLocalFunNamesTab:
+                        self.allLocalFunNamesTab.append(funName)
+                        util.debug("Add local function %s to known functions" % mainFunName)
+                        self._getfullAlgoCode(funName, recDepth + 1)
+
+            # conver code from javascript to python
+            funBody = self._jsToPy(funBody)
+            self.fullAlgoCode += '\n' + funBody + '\n'
+        return
+
+decryptor = CVevoSignAlgoExtractor()
+
+'''
+   YouTube plugin for XBMC
+    Copyright (C) 2010-2012 Tobias Ussing And Henrik Mosgaard Jensen
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+'''
+
+import sys
+import urllib
+import cgi
+import simplejson as json
+
+
+class YoutubePlayer(object):
+    fmt_value = {
+            5: "240p",
+            18: "360p",
+            22: "720p",
+            26: "???",
+            33: "???",
+            34: "360p",
+            35: "480p",
+            37: "1080p",
+            38: "720p",
+            43: "360p",
+            44: "480p",
+            45: "720p",
+            46: "520p",
+            59: "480",
+            78: "400",
+            82: "360p",
+            83: "240p",
+            84: "720p",
+            85: "520p",
+            100: "360p",
+            101: "480p",
+            102: "720p",
+            120: "hd720",
+            121: "hd1080"
+            }
+
+    # YouTube Playback Feeds
+    urls = {}
+    urls['video_stream'] = "http://www.youtube.com/watch?v=%s&safeSearch=none"
+    urls['embed_stream'] = "http://www.youtube.com/get_video_info?video_id=%s"
+    urls['video_info'] = "http://gdata.youtube.com/feeds/api/videos/%s"
+
+    def __init__(self):
+        pass
+
+    def removeAdditionalEndingDelimiter(self, data):
+        pos = data.find("};")
+        if pos != -1:
+            data = data[:pos + 1]
+        return data
+
+    def extractFlashVars(self, data, assets):
+        flashvars = {}
+        found = False
+
+        for line in data.split("\n"):
+            if line.strip().find(";ytplayer.config = ") > 0:
+                found = True
+                p1 = line.find(";ytplayer.config = ") + len(";ytplayer.config = ") - 1
+                p2 = line.rfind(";")
+                if p1 <= 0 or p2 <= 0:
+                    continue
+                data = line[p1 + 1:p2]
+                break
+        data = self.removeAdditionalEndingDelimiter(data)
+
+        if found:
+            data = json.loads(data)
+            if assets:
+                flashvars = data["assets"]
+            else:
+                flashvars = data["args"]
+        return flashvars
+
+    def scrapeWebPageForVideoLinks(self, result, video):
+        links = {}
+        flashvars = self.extractFlashVars(result, 0)
+        if not flashvars.has_key(u"url_encoded_fmt_stream_map"):
+            return links
+
+        if flashvars.has_key(u"ttsurl"):
+            video[u"ttsurl"] = flashvars[u"ttsurl"]
+        if flashvars.has_key("title"):
+            video["title"] = flashvars["title"]
+
+        for url_desc in flashvars[u"url_encoded_fmt_stream_map"].split(u","):
+            url_desc_map = cgi.parse_qs(url_desc)
+            if not (url_desc_map.has_key(u"url") or url_desc_map.has_key(u"stream")):
+                continue
+
+            key = int(url_desc_map[u"itag"][0])
+            url = u""
+            if url_desc_map.has_key(u"url"):
+                url = urllib.unquote(url_desc_map[u"url"][0])
+            elif url_desc_map.has_key(u"conn") and url_desc_map.has_key(u"stream"):
+                url = urllib.unquote(url_desc_map[u"conn"][0])
+                if url.rfind("/") < len(url) - 1:
+                    url = url + "/"
+                url = url + urllib.unquote(url_desc_map[u"stream"][0])
+            elif url_desc_map.has_key(u"stream") and not url_desc_map.has_key(u"conn"):
+                url = urllib.unquote(url_desc_map[u"stream"][0])
+
+            if url_desc_map.has_key(u"sig"):
+                url = url + u"&signature=" + url_desc_map[u"sig"][0]
+            elif url_desc_map.has_key(u"s"):
+                sig = url_desc_map[u"s"][0]
+                flashvars = self.extractFlashVars(result, 1)
+                js = flashvars[u"js"]
+                url = url + u"&signature=" + self.decrypt_signature(sig, js)
+
+            links[key] = url
+
+        return links
+
+    def decrypt_signature(self, s, js):
+        return decryptor.decryptSignature(s, js)
+
+
+    def extractVideoLinksFromYoutube(self, url, videoid, video):
+        result = util.request(self.urls[u"video_stream"] % videoid)
+        links = self.scrapeWebPageForVideoLinks(result, video)
+        if len(links) == 0:
+            util.error(u"Couldn't find video url- or stream-map.")
+        return links
+# /*
+# *      Copyright (C) 2011 Libor Zoubek
+# *
+# *
+# *  This Program is free software; you can redistribute it and/or modify
+# *  it under the terms of the GNU General Public License as published by
+# *  the Free Software Foundation; either version 2, or (at your option)
+# *  any later version.
+# *
+# *  This Program is distributed in the hope that it will be useful,
+# *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+# *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# *  GNU General Public License for more details.
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# */
+import re, util, urllib
+__name__ = 'youtube'
+
+
+def supports(url):
+    return not _regex(url) == None
+
+def resolve(url):
+    m = _regex(url)
+    if not m == None:
+        player = YoutubePlayer()
+        video = {'title':'žádný název'}
+        index = url.find('&')  # strip out everytihing after &
+        if index > 0:
+            url = url[:index]
+        links = player.extractVideoLinksFromYoutube(url, m.group('id'), video)
+        resolved = []
+        for q in links:
+            if q in player.fmt_value.keys():
+                quality = player.fmt_value[q]
+                item = {}
+                item['name'] = __name__
+                item['url'] = links[q]
+                item['quality'] = quality
+                item['surl'] = url
+                item['subs'] = ''
+                item['title'] = video['title']
+                item['fmt'] = q
+                resolved.append(item)
+        return resolved
+
+def _regex(url):
+    return re.search('www\.youtube\.com/(watch\?v=|v/|embed/)(?P<id>.+?)(\?|$|&)', url, re.IGNORECASE | re.DOTALL)

resources/lib/sources/SourceBase.py

@@ -9,6 +9,11 @@
 import urllib2, urllib
 import datetime, re, sys,os
 import requests
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
 from collections import OrderedDict
 import ConfigParser
 try:
@@ -64,6 +69,10 @@ User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWeb
         stream["type"] = stream_type(content[1]).encode("utf8")
         return[stream]
 
+    def get_epg(self,data):
+        ### Normally to be overrided in child class
+        return [self.get_info(data)]
+
     def options_read(self):
         if not ("options" in dir(self) and self.options): # process options only if self.options defined, self.config_file should be defined too
             return None
@@ -103,9 +112,9 @@ User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWeb
             headers = self.headers if "headers" in dir(self) else headers2dict("User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:49.0) Gecko/20100101 Firefox/49.0")
         try:
             if params:
-                r = requests.post(url, data=params, headers=headers)
+                r = requests.post(url, data=params, headers=headers,verify=False)
             else:
-                r = requests.get(url, headers=headers)
+                r = requests.get(url, headers=headers,verify=False)
             return r.content
         except Exception as ex:
             if "read" in ex:
@@ -138,7 +147,7 @@ def stream_type(data):
     data = data.lower()
     m = re.search(r"^(\w+)://", data)
     prefix = m.group(1) if m else ""
-    if prefix in ("http","https") and "m3u8" in data:
+    if prefix in ("http","https") and ".m3u8" in data:
         return "hls"
     elif prefix == "http":
         return "http"

resources/lib/sources/cinemalive.py

@@ -162,7 +162,7 @@ Accept-Language: en-US,en;q=0.8
         
         #m = re.search('<div class="viboom-overroll"><iframe src="([^"]+)"', r)
         #if m:
-        result = re.findall('<div id="video_container"><iframe src="(.+?)"', r)
+        result = re.findall('<div id="video_container"><iframe.+?src="(.+?)"', r)
         if result:
             streams = resolve(result[0])
             for s in streams:

resources/lib/sources/config.py

@@ -11,15 +11,16 @@ from SourceBase import SourceBase
 
 os.path.dirname(os.path.abspath(__file__))
 class Source(SourceBase):
-    
+
     def __init__(self,country="lv"):
         self.name = "config"
         self.country=country
         cur_directory = os.path.dirname(os.path.abspath(__file__))
         self.streams_file = os.path.join(cur_directory,"streams.cfg")
         self.lists = collections.OrderedDict()
+        self.titles = {}
         self.read_streams()
-         
+
     def get_content(self, data):
         self.read_streams()
         if "::" in data:
@@ -30,7 +31,7 @@ class Source(SourceBase):
 
     def is_video(self,data):
         return False
-    
+
     def read_streams(self):
         for line in open(self.streams_file,"r"):
             r = re.search("^\[(\w+)\]", line)
@@ -38,12 +39,14 @@ class Source(SourceBase):
                 name = r.group(1)
                 self.lists[name] = []
             else:
-                if len(line)<10 or line[0] in ("#"): continue
+                if line[0] in ("#"): continue
                 items = tuple(line.strip().split("|"))
-                if len(items)<2:
-                    continue
-                self.lists[name].append(items)
-                
+                if not items[0]: continue
+                if len(items)==1:
+                    self.titles[name] = items[0]
+                else:
+                    self.lists[name].append(items)
+
     def write_streams(self):
         f = open(self.streams_file,"w")
         for l in self.lists.keys():
@@ -52,48 +55,54 @@ class Source(SourceBase):
                 f.write("%s|%s|%s|%s\n"%(item[0],item[1],item[2],item[3]))
             f.write("\n")
         f.close()
-    
+
     def get_lists(self):
         return self.lists.keys()
-    
+
     def get_list_items(self,name):
         return self.lists[name]
-    
+
+    def get_title(self,name):
+        if name in self.titles:
+            return self.titles[name]
+        else:
+            return name
+
     def add_list(self,name):
         if not name in self.lists.keys():
             self.lists[name] = []
-            
+
     def del_list(self,name):
         if name in self.lists.keys():
             del self.lists[name]
-            
+
     def add_item(self,name,item,pos=None):
         if name in self.lists.keys():
             if pos==None:
                 self.lists[name].append(item)
             else:
                 self.lists[name].insert(pos,item)
-                
+
     def del_item(self,name,pos):
         self.lists[name].pop(pos)
-    
+
     def replace_item(self,name,item,pos):
         self.lists[name][pos]=item
-            
-                           
+
+
 if __name__ == "__main__":
     c = Source()
     content = c.get_content("home")
     for item in content: print item
     #c.del_item("home",0)
     #c.del_list("favorites")
-    
+
     #c.add_item("home",("My Streams","config::favorites","","Mani saglabātie TV kanāli un video"),0)
     c.replace_item("home",("My Streams","config::my_streams","default","Mani saglabātie TV kanāli un video"),0)
     #c.add_list("favorites")
-    #c.add_item("favorites",("..return","back","","Atgriezties atpakaļ"))    
+    #c.add_item("favorites",("..return","back","","Atgriezties atpakaļ"))
     #c.add_item("favorites",("LTV1","http://streamltv.cloudy.services/ltv/LTV02.smil/playlist.m3u8","picons/latvia1.png", "Latvijas televīzijas 1.kanāls"))
-    
+
     c.write_streams()
     for item in content: print item
-    
+

resources/lib/sources/filmix.py

@@ -105,8 +105,19 @@ Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
             desc = desc0 =  util.unescape(m.group(1).strip()) if m else ""
             vid = plist[-1]
             js = self.get_movie_info(vid)
-            pl_link = js["message"]["translations"]["flash"].values()[0] # TODO process several players
-            pl_link = self.decode_uppod_text(pl_link)
+            translations = js["message"]["translations"]["flash"]
+            for pl  in translations:
+                if translations[pl].startswith("http"):
+                    continue
+                pl_link = translations[pl]
+                lang = pl.encode("utf8")
+                break
+            else:
+                raise Exception("No episodes list found!")
+            #pl_link = js["message"]["translations"]["flash"].values()[0]
+            #  TODO process several players, currently taking the first
+            if not pl_link.startswith("http"):
+                pl_link = self.decode_uppod_text(pl_link)
             js = self._http_request(pl_link)
             js = self.decode_uppod_text(js)
             js = json.loads(js)
@@ -144,7 +155,7 @@ Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
                 if m:
                     title = title + "/"+m.group(1)
                 m = re.search('<img src="([^"]+.jpg)"', r2, re.DOTALL)
-                img = "http://filmix.me"+m.group(1) if m else self.img
+                img = m.group(1) if m else self.img
                 m = re.search(r'<a itemprop="copyrightYear".+?>(\d+)<', r2, re.DOTALL)
                 if m:
                     year = m.group(1) if m else ""
@@ -212,21 +223,26 @@ Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
         desc = desc0 =  util.unescape(m.group(1).strip()) if m else ""
         m = re.search('itemprop="contentUrl" content="(.+?)"', r, re.IGNORECASE | re.DOTALL)
         if not m:
-        #    #raise Exception("Can not find video link")
-            return []
+            raise Exception("Can not find video link")
+            #return []
         video_link = m.group(1)
         series = True if video_link == '{video-link}' else False
         vid = plist[1]
         js = self.get_movie_info(vid)
-        if js["message"]["translations"]["flash"]:
-            video_link = js["message"]["translations"]["flash"].values()[0].encode("utf8")
-            video_link = self.decode_uppod_text(video_link)
-            lang = js["message"]["translations"]["flash"].keys()[0].encode("utf8") # TODO process several players/streams
+        translations = js["message"]["translations"]["flash"]
+        for pl in translations:
+            if translations[pl].startswith("http"):
+                continue
+            pl_link = translations[pl]
+            lang = pl.encode("utf8")
+            break
         else:
-            return []
+            raise Exception("No episodes list found!")
+        if not pl_link.startswith("http"):
+            pl_link = self.decode_uppod_text(pl_link)
 
         if not series : # Filma
-            url0 = video_link
+            url0 = pl_link
             streams2 = self.get_streams2(url0)
             for st in streams2:
                 stream = util.item()
@@ -239,7 +255,7 @@ Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
             return streams
 
         else: # Seriāls
-            pl_link = video_link
+            #pl_link = video_link
             js = self._http_request(pl_link)
             js = self.decode_uppod_text(js)
             js = json.loads(js)
@@ -298,14 +314,15 @@ Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
         return result
 
     def get_streams2(self,url0):
-        m = re.search("\[([\d,]+)]",url0)
+        m = re.search("\[([\d\w,]+)\]",url0)
         if not m:
             return [("?",url0)]
         res = m.group(1)
         streams=[]
         for res in res.split(","):
             if not res: continue
-            url=re.sub("\[[\d,]+]",res,url0)
+            if res in ["1080p"]: continue #TODO fullhd only in PRO+ version
+            url=re.sub("\[[\d\w,]+\]",res,url0)
             streams.append((res,url))
         return streams
 

resources/lib/sources/iplayer.py

@@ -239,11 +239,11 @@ Connection: Keep-Alive
         cmd = data.split("/")
         vid = cmd[1].split("?")[0]
         if cmd[0] == "live":
-            title,img,desc = self.get_epg_live(vid)
+            title,img,desc,nfo = self.get_epg_live(vid)
         else:
-            data_ = "episodes/%s"%vid
-            r = self.call(data_)
-            title,img,desc,vid = self.get_epg_video(vid)
+            #data_ = "episodes/%s"%vid
+            #r = self.call(data_)
+            title,img,desc,vid,nfo = self.get_epg_video(vid)
         url = "http://open.live.bbc.co.uk/mediaselector/5/select/version/2.0/format/json/mediaset/iptv-all/vpid/%s"%vid
         print "vid=%s"%vid
         print url
@@ -288,6 +288,7 @@ Connection: Keep-Alive
                     stream["lang"]="en"
                     stream["subs"]=captions
                     stream["order"]=int(s["bitrate"])
+                    stream["nfo"] = nfo
                     streams.append(stream)
                 else:
                     for cc in slist:
@@ -310,6 +311,7 @@ Connection: Keep-Alive
                         stream["lang"]="en"
                         stream["subs"]=captions
                         stream["order"]=int(bitrate)
+                        stream["nfo"] = nfo
                         streams.append(stream)
         if captions:
             for s in streams:
@@ -360,6 +362,7 @@ Connection: Keep-Alive
 
     def get_epg_video(self,vid):
         data = "episodes/%s"%vid
+        nfo = {}
         r = self.call(data)
         if "episodes" in r :
             ep = r["episodes"][0]
@@ -371,18 +374,37 @@ Connection: Keep-Alive
             desc = desc
             ver = ep["versions"][0]
             vid = ver["id"]
-            remaining = ver["availability"]["remaining"]["text"]
-            duration = ver["duration"]
+            remaining = ver["availability"]["end"].split("T")[0] #["remaining"]["text"]
+            duration = ver["duration"]["text"]
             first_broadcast = ver["first_broadcast"]
             desc =u"%s\n%s\%s\n%s\n%s"%(title,duration,remaining,first_broadcast,desc)
             img = ep["images"]["standard"].replace("{recipe}","512x288")
-            return title.encode("utf8"),img.encode("utf8"),desc.encode("utf8"),vid.encode("utf8")
+
+            #Create nfo dictionary
+            tt = lambda dd,k,d: dd[k] if k in dd else d
+            nfo_type = "movie" if True else "tvswhow" # TODO
+            t = OrderedDict()
+            t["title"] = title
+            t["originaltitle"] = tt(ep,"original_title","")
+            t["thumb"] = img
+            t["id"] = vid
+            t["outline"] = ep["synopses"]["small"] if "small" in ep["synopses"] else ep["synopses"]["editorial"] if "editorial" in ep["synopses"] else ""
+            t["plot"] = ep["synopses"]["large"] if "large" in ep["synopses"] else ep["synopses"]["medium"] if "medium" in ep["synopses"] else p["synopses"]["small"] if "small" in ep["synopses"] else title
+            t["tagline"] = ep["synopses"]["editorial"] if "editorial" in ep["synopses"] else ""
+            t["runtime"] = tt(ver["duration"],"text","")
+            t["premiered"] = tt(ep,"release_date","")
+            t["aired"] = ver["availability"]["start"].split("T")[0] if "start" in ver["availability"] else ""
+            if "parent_position" in ep: t["episode"] = ep["parent_position"]
+            nfo[nfo_type] = t
+
+            return title.encode("utf8"),img.encode("utf8"),desc.encode("utf8"),vid.encode("utf8"),nfo
         else:
             raise Exception("No video info")
 
     def get_epg_live(self,channelid):
         data = "channels/%s/highlights?live=true"%channelid
         r = self.call(data)
+        nfo = {}
         if "channel_highlights" in r and r["channel_highlights"]["elements"][0]["id"] == "live":
             epg = r["channel_highlights"]["elements"][0]["initial_children"][0].copy()
             t1 = gt(epg['scheduled_start'])
@@ -403,7 +425,7 @@ Connection: Keep-Alive
             img = ""
             desc = title
 
-        return title.encode("utf8"),img.encode("utf8"),desc.encode("utf8")
+        return title.encode("utf8"),img.encode("utf8"),desc.encode("utf8"),nfo
 
     def get_channels(self):
         if self.ch:
@@ -465,6 +487,11 @@ Connection: Keep-Alive
     def _http_request(self, url,params = None, headers=None):
         if not headers: headers = self.headers
         import requests
+        try:
+            from requests.packages.urllib3.exceptions import InsecureRequestWarning
+            requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+        except:
+            pass
         try:
             r = requests.get(url, headers=headers)
             return r.content

resources/lib/sources/ltc.cfg

@@ -1,3 +1,4 @@
 [ltc]
-user=ivars777
-password=kaskade7
+user = ivars777
+password = kaskade7
+

resources/lib/sources/ltc.py

@@ -750,20 +750,62 @@ Host: manstv.lattelecom.tv
             #data2 = self.get_noma_url(video_id)
         r = self.call2(data)
         m = re.search('<meta name="dr:say:title" content="([^"]+)">', r, re.IGNORECASE)
-        if m:
-            title = m.group(1)
-        else:
-            title = ""
-        desc = title
+        nfo = {}
+        tt = lambda p,r,d: re.search(p,r).group(1) if re.search(p,r) else d
+        tt2 = lambda p,r,d: (re.sub("<.+?>","",re.search(p,r).group(1))).split(",") if re.search(p,r) else d
+        r2 = r[r.find('<div class="movie_details">'):]
+        nfo["title"] = tt('<div class="lv">([^<]+)</div>', r2,"")
+        nfo["originaltitle"] = tt('<div class="en">([^<]+)</div>', r2,"")
+        if nfo["originaltitle"] and not nfo["title"]:
+                nfo["title"] = nfo["originaltitle"]
+                #nfo["originaltitle"] = ""
+        if "raidijumi" in data:
+            nfo["set"] = nfo["title"]
+            m = re.search('class="movie_informatio">(.+?)<br>(.+?)<br>', r)
+            ep2,ep1 = m.groups()
+            #nfo["title"]
+            s_nr = tt('<span id="current_season_nr">(\d+)</span>',r,"")
+            for it in  re.findall(r'<span class="epizode_number">(\d+)</span>.+?<span class="titlez">(.+?)</span>', r):
+                if it[1] == ep1:
+                    ep_nr = it[0]
+                    break
+            else:
+                ep_nr=""
+            if s_nr:
+                nfo["season"] = s_nr
+            if ep_nr:
+                nfo["eposode"] = ep_nr
+            se = "S%02i"%int(s_nr) if s_nr else ""
+            se += "E%02i"%int(ep_nr) if ep_nr else ""
+            nfo["title"] += " - %s"%ep1 if ep1 else ""
+            nfo["originaltitle"] += " - %s"%ep2 if ep2 else ""
+            nfo["title"] += "(%s)"%se if se else ""
+            nfo["originaltitle"] += "(%s)"%se if se else ""
+
+
+        nfo["thumb"] = tt('<meta name="og:image" content="([^"]+)"', r,"")
+        nfo["year"] = tt("Gads: ([^<]+)<", r2, "")
+        nfo["runtime"] = tt("Garums: ([^<]+)<", r2, "")
+        nfo["quality"] = tt("Kvalitāte: ([^<]+)<", r2, "")
+        nfo["genre"]=tt2("Žanr.: (.+?)<br", r2, "")
+        nfo["director"] = tt("Režisors: ([^<]+)<", r2, "")
+        nfo["actor"] = tt2("Lomās: ([^<]+)<", r2, "")
+        nfo["language"] = tt2("Valodas: ([^<]+)<", r2, "")
+        nfo["subtitles"] = tt2("Subtitri: ([^<]+)<", r2, "")
+        nfo["plot"] = tt('"introduction">(.+?)<', r2,"")
+        nfo["tagline"] = nfo["plot"]
+        title = util.nfo2title(nfo)
+        desc = util.nfo2desc(nfo)
+        img = nfo["thumb"]
+        #xml = util.nfo2xml(nfo)
 
         url = "https://www.lattelecom.tv/xmls/%s.xml"%video_id
         headers = self.headers2
         headers["Cookie"] = self.session_id
         response = urllib2.urlopen(urllib2.Request(url, headers=headers))
-
         r = response.read()
         servers = re.findall("(?s)<origin>([^<]+)</origin>", r)
-        streams_xml = re.findall('<stream quality="\w+">(mp4:\w+_(\w\w)_(\w\w).mp4)</stream>',r)
+        streams_xml = re.findall('<stream quality="\w+">(mp4:\w+(\w\w)_(\w\w).mp4)</stream>',r)
         resource_id = re.search("(?s)<resource_id>([^<]+)</resource_id>", r).group(1)
         token = re.search("(?s)<auth_token>([^<]+)</auth_token>", r).group(1)
         streams=[]
@@ -788,6 +830,8 @@ Host: manstv.lattelecom.tv
                 stream["quality"]=s[2]
                 stream["name"]=title
                 stream["desc"]=desc
+                stream["img"] = img
+                stream["nfo"] = {"movie":nfo}
                 stream["type"]="hls" #stream_type(url)
                 stream["subs"] = []
                 for c in captions:

resources/lib/sources/streams.cfg

@@ -1,4 +1,5 @@
 [home]
+Home
 My TV|config::my_tv|default|Mani TV kanāli (tiešraide)
 My TV archive|config::my_archive|default|Mani TV arhīvu video
 My Video|config::my_video||Mani video
@@ -19,9 +20,10 @@ SerialGURU.ru|serialguru::home|http://serialguru.ru/images/xlogo_new.png.pagespe
 USTVNow|ustvnow::home|http://watch.ustvnow.com/assets/ustvnow/img/ustvnow_og_image.png|USTVNow kanālu tiešraide
 FilmOn|filmon::home|http://behindthegloves.com/wp-content/uploads/2016/01/FilmOn-logo1.jpg|FilmOn - tiešraides un video (dažādās valodās)
 MTGPlay|config::mtg|https://www.mtg.com/wp-content/uploads/2015/11/MTG-Logo-Medium-Red-PNG.png|Other countries MTG media portals content
-
+Filmas.lv|filmas::home|https://www.filmas.lv/wp-content/uploads/2013/06/LVfilmas-logo-jauns21.png|Filmas.lv - Latvijas filmas
 
 [my_tv]
+My Tv
 ..return|back|default|Atgriezties atpakaļ
 LTV1|replay::tiesraide/ltv1/|http://replay.lsm.lv/resources/logo/large_ltv1.png|LTV1 tiesraide (video )
 LTV7|replay::tiesraide/ltv7/|http://replay.lsm.lv/resources/logo/large_ltv7.png|LTV7 tiesraide (video )
@@ -43,6 +45,7 @@ Canadian live (FilmOn)|filmon::group?id=44|https://static.filmon.com/assets/grou
 Sport stream|rtmp://184.172.124.216/live/test111||
 
 [my_archive]
+My Archive
 ..return|back||Atgriezties atpakaļ
 LTV arhīvs LV|replay::visi/jaunakie/?source=ltv&lang=lv|http://replay.lsm.lv/apple-touch-icon.png|LTV1, LTV2 pārraižu arhīvs LV
 LTV arhīvs RU|replay::vse/novie/?source=ltv&lang=ru|http://replay.lsm.lv/apple-touch-icon.png|LTV1, LTV2 pārraižu arhīvs RU
@@ -55,11 +58,13 @@ Category - News|euronews::content/getVertical?lang=en&byPage=40&page=1&vId=1|htt
 Latest programs|euronews::content/getLatestPrograms?lang=en&byPage=40&page=1|http://pbs.twimg.com/profile_images/732665354242150400/tZsCnjuh_400x400.jpg|Latest programs
 
 [my_video]
+My Video
 ..return|back||Atgriezties atpakaļ
 Все фильмы|filmix::films|http://cs5324.vk.me/g33668783/a_903fcc63.jpg|Все фильмы
 Все сериалы|filmix::serialy|http://cs5324.vk.me/g33668783/a_903fcc63.jpg|Все сериалы
 
 [my_kids]
+My Kids
 ..return|back|default|Atgriezties atpakaļ
 Bērnu TV|config::my_kids_tv||Bērnu TV kanāli
 Bērnu video|config::my_kids_video||Saglabātie bērnu video
@@ -74,6 +79,7 @@ Filmix bērnu seriāli|filmix::detskij/s7|http://cs5324.vk.me/g33668783/a_903fcc
 SerialGURU multenes|serialguru::mult||SerialGURU multenes
 
 [my_kids_tv]
+My Kids TV
 ..return|back|default|Atgriezties atpakaļ
 Kidzone|ltc::content/live-streams/951?include=quality|https://manstv.lattelecom.tv/images/01_Bildes/02_Kanalu_raidijumu_default/kidzone2_new.png|Kidzone
 Nickelodeon|ltc::content/live-streams/302?include=quality|https://manstv.lattelecom.tv/images/01_Bildes/02_Kanalu_raidijumu_default/Nickelodeon.png|Nickelodeon
@@ -86,9 +92,11 @@ CBBC (FilmOn)|filmon::channel?id=29|http://static.filmon.com/assets/channels/29/
 Om Nom (FilmOn)|filmon::channel?id=3824|http://static.filmon.com/assets/channels/3824/big_logo.png|The series chronicles Om Nom's adventures with a young boy named Evan, beginning  with the little monster's mysterious appearance on the boy's doorstep in Episode 1. The animation series goes on to reveal Om Nom's mischievous, yet endearing personality as he and Evan bond over day-to-day activities such as playing games, exploring house-hold items and celebrating holidays.
 
 [my_kids_video]
+My Kids Video
 ..return|back|default|Atgriezties atpakaļ
 
 [my_radio]
+My Radio
 ..return|back|default|Atgriezties atpakaļ
 LR1|replay::tiesraide/lr1/|http://replay.lsm.lv/resources/logo/lr1_logo.png|LR1 tiesraide (audio)
 LR2|replay::tiesraide/lr2/|http://replay.lsm.lv/resources/logo/lr2_logo.png|LR2 tiesraide (audio)
@@ -98,6 +106,7 @@ LR5|replay::tiesraide/lr5/|http://replay.lsm.lv/resources/logo/lr5_logo.png|LR5
 LR6|replay::tiesraide/lr6/|http://replay.lsm.lv/resources/logo/lr6_logo.png|LR6 tiesraide (audio)
 
 [mtg]
+MTG
 ..return|back|default|Atgriezties atpakaļ
 Estonia (tv3play.ee)|mtgplay::home?country=ee||MTG Estonia media portal content
 Lithuania (play.tv3.lt/)|mtgplay::home?country=lt||MTG Lithuania media portal content

resources/lib/sources/tvdom.py

@@ -42,7 +42,7 @@ class Source(SourceBase):
         self.options_read()
 
     def login(self,user="",password=""):
-        self.options_read()        
+        self.options_read()
         if not user: user=self.options["user"]
         if not password: password = self.options["password"]
         headers = headers2dict("""
@@ -57,10 +57,15 @@ Referer: https://tvdom.tv/
         url = "https://tvdom.tv/infinity/on_register_user"
         params = "email=%s&password=%s&remember=false&auth_type=login"%(user,password)
         import requests
-        r = requests.post(url, data=params, headers=headers)	
+        try:
+            from requests.packages.urllib3.exceptions import InsecureRequestWarning
+            requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+        except:
+            pass
+        r = requests.post(url, data=params, headers=headers)
         js = json.loads(r.content)
         if 'success' in r.content:
-            self.token = js["access_token"] 
+            self.token = js["access_token"]
             if 'PHPSESSID' in r.cookies:
                 self.session = r.cookies["PHPSESSID"]
             return True
@@ -98,7 +103,7 @@ Referer: https://tvdom.tv/
                 title =  h.unescape(title.decode("utf8")).encode("utf8")
                 img = "https://tvdom.tv"+item[2]
                 data2 = "tiesraides/%s/"%item[1]
-                desc = "%s\n%s\n%s"%(title,item[3],item[4])		    
+                desc = "%s\n%s\n%s"%(title,item[3],item[4])
                 channels[item[1]]={"title":title,"img":img,"desc":desc}
                 #content.append((title,self.name+"::"+data2,img,desc))
 
@@ -137,9 +142,9 @@ Referer: https://tvdom.tv/
             m = re.search('<div id="panel">([^<]+)<', r, re.DOTALL)
             desc = m.group(1) if m else title
             m = re.search('<div id="panel">([^<]+)<', r, re.DOTALL)
-            desc = m.group(1) if m else title 
+            desc = m.group(1) if m else title
             m = re.search('var promo_image *= "([^"]+)', r, re.DOTALL)
-            img = m.group(1) if m else ""            
+            img = m.group(1) if m else ""
             return (title,data2,img,desc)
 
         ### Search ###
@@ -196,10 +201,10 @@ Referer: https://tvdom.tv/
             m = re.search('<div id="panel">([^<]+)<', r, re.DOTALL)
             desc = m.group(1) if m else title
             m = re.search('<div id="panel">([^<]+)<', r, re.DOTALL)
-            desc = m.group(1) if m else title 
+            desc = m.group(1) if m else title
             m = re.search('var share_image *= "([^"]+)', r, re.DOTALL)
-            img = m.group(1) if m else ""            
-            content.append((title,self.name+"::"+data2,img,desc)) 
+            img = m.group(1) if m else ""
+            content.append((title,self.name+"::"+data2,img,desc))
             i = r.find('<span class="slider-top-title"')
             if i>0: r = r[:i]
             for item in re.findall('<div class="col-md-9 redirect-to-url same-event" data-href="/([^"]+)">.+?image" src="([^"]+)".+?<h3 class="same-title">([^<]+)</h3>.*?<h5 class="same-online">([^<]+)</h5>', r, re.DOTALL):
@@ -230,9 +235,9 @@ Referer: https://tvdom.tv/
             m = re.search('<div id="panel">([^<]+)<', r, re.DOTALL)
             desc = m.group(1) if m else title
             m = re.search('<div id="panel">([^<]+)<', r, re.DOTALL)
-            desc = m.group(1) if m else title 
+            desc = m.group(1) if m else title
             m = re.search('var share_image *= "([^"]+)', r, re.DOTALL)
-            img = m.group(1) if m else ""            
+            img = m.group(1) if m else ""
             return (title,data2,img,desc)
 
 

resources/lib/sources/ustvnow.py

@@ -12,6 +12,7 @@ except:
 
 import urllib2, urllib
 import datetime, re, sys,os
+import traceback
 from collections import OrderedDict
 from SourceBase import SourceBase
 
@@ -43,9 +44,9 @@ class Source(SourceBase):
         self.options_read()
 
     def login(self,user="",password=""):
+        self.options_read()
         if not user: user=self.options["user"]
         if not password: password = self.options["password"]
-        self.options_read()        
         headers = headers2dict("""
         Host: m-api.ustvnow.com
         Accept-Language: en-US,en;q=0.5
@@ -64,9 +65,9 @@ class Source(SourceBase):
             return False
 
     def get_content(self, data):
-        print "[tvdom] get_content:", data
+        print "[ustvnow] get_content:", data
         if "::" in data:
-            data = data.split("::")[1] 
+            data = data.split("::")[1]
         path = data.split("?")[0]
         clist = path.split("/")[0]
         params = data[data.find("?"):] if "?" in data else ""
@@ -100,7 +101,7 @@ class Source(SourceBase):
             if not self.r:
                 return content
             for item in self.r["results"]:
-                if item["order"] == 1:    
+                if item["order"] == 1:
                     title = item["stream_code"]
                     title =  h.unescape(title.decode("utf8")).encode("utf8")
                     img = "http://m-api.ustvnow.com/"+item["prg_img"] #item["img"]
@@ -116,6 +117,10 @@ class Source(SourceBase):
             if not r:
                 return ("No stream found %s"%data,"","","No stream found")
             r = json.loads(r)
+            if not "r" in dir(self):
+                if not self.token:
+                    self.login()
+                self.r = self.call("live/channelguide?token=%s"%self.token)
             if self.r:
                 ch = qs["scode"]
                 for item in self.r["results"]:
@@ -129,8 +134,8 @@ class Source(SourceBase):
                 title = data
             data2 = r["stream"]
             desc = title
-            img = ""          
-            return (title,data2,img,desc)               
+            img = "" # img TODO
+            return (title,data2,img,desc)
 
     def is_video(self,data):
         if "::" in data:

resources/lib/sources/viaplay.cfg

@@ -1,5 +1,5 @@
 [viaplay]
 user = ivars777@gmail.com
 password = kaskade7
-device = c3e3d2fb312d28f8f150772c9098c5eab40df72a-499b21d2-e6ec-4973-b57c-6db7cf43bdd0=36f25da2-3bb7-4a8e-9782-ba0cdc416973
+device = 
 

resources/lib/sources/viaplay.py

@@ -10,7 +10,13 @@ try:
 except:
     import simplejson as json
 
-import requests, urlparse, urllib
+import requests
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
+import urlparse, urllib
 import datetime, time,re, sys,os
 from collections import OrderedDict
 from SourceBase import SourceBase

resources/lib/sources0/SourceBase.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+
+import urllib2, urllib
+import datetime, re, sys,os
+import requests
+from collections import OrderedDict
+import ConfigParser
+try:
+    import util
+except:
+    parent = os.path.dirname(os.path.abspath(__file__))
+    parent = os.sep.join(parent.split(os.sep)[:-1])
+    sys.path.insert(0,parent)
+    import util
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+
+class SourceBase(object):
+    """Stream source base class"""
+
+    def __init__(self,country="lv"):
+        self.name = "name"
+        self.title = "Title"
+        self.img = ""
+        self.desc = ""
+        self.options = OrderedDict()
+        self.config_file = ""
+        self.url = "http://www.bbb.com/"
+        self.headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWebkit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+""")
+
+    def login(self,user="",password=""):
+        return False
+
+    def logout(self):
+        return True
+
+    def get_content(self,data):
+        ### To be overriden in child class
+        return [("..atpakaļ","back",None,"Kļūda, atgriezties atpakaļ")]
+
+    def is_video(self,data):
+        ### To be overriden in child class
+        return False
+
+    def get_streams(self,data):
+        ### Normally to be overrided in child class
+
+        if not self.is_video(data):
+            return []
+        content = self.get_content(data)
+        stream = util.item()
+        stream["name"] = content[0].encode("utf8") if isinstance(content[0],unicode) else content[0]
+        stream["url"] = content[1].encode("utf8") if isinstance(content[1],unicode) else content[1]
+        stream["img"] = content[2].encode("utf8") if isinstance(content[2],unicode) else content[2]
+        stream["desc"] = content[3].encode("utf8") if isinstance(content[3],unicode) else content[3]
+        stream["type"] = stream_type(content[1]).encode("utf8")
+        return[stream]
+
+    def options_read(self):
+        if not ("options" in dir(self) and self.options): # process options only if self.options defined, self.config_file should be defined too
+            return None
+        config = ConfigParser.ConfigParser()
+        if os.path.exists(self.config_file):
+            config.read(self.config_file)
+            self.options = OrderedDict(config.items(self.name))
+        else:
+            self.options_write(self.options)
+        return self.options
+
+    def options_write(self,options):
+        config = ConfigParser.ConfigParser()
+        config.add_section(self.name)
+        for k in options.keys():
+            config.set(self.name, k,options[k])
+        with open(self.config_file,"w") as f:
+            config.write(f)
+        self.options = OrderedDict(config.items(self.name))
+
+    def call(self, data,params=None,headers=None,lang=""):
+        if not headers: headers = self.headers
+        url = self.url+data
+        result = self._http_request(url,params,headers=headers)
+        return result
+
+    def call_json(self, data,params=None,headers=None,lang=""):
+        result = self.call(url,params,headers=headers)
+        if result:
+            result = json.loads(content)
+            return result
+        else:
+            raise "No data returned"
+
+    def _http_request(self, url,params = None, headers=None):
+        if not headers:
+            headers = self.headers if "headers" in dir(self) else headers2dict("User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:49.0) Gecko/20100101 Firefox/49.0")
+        try:
+            if params:
+                r = requests.post(url, data=params, headers=headers)
+            else:
+                r = requests.get(url, headers=headers)
+            return r.content
+        except Exception as ex:
+            if "read" in ex:
+                content = ex.read()
+            else:
+                content = None
+            return content
+
+    @staticmethod
+    def stream_type(data):
+        return stream_type(data)
+
+    @staticmethod
+    def parse_data(data):
+        if "::" in data:
+            source = data.split("::")[0]
+            data = data.split("::")[1]
+        else:
+            source = ""
+        path = data.split("?")[0]
+        plist = path.split("/")
+        clist = plist[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        qs = dict(map(lambda x:x.split("="),re.findall("\w+=\w+",params)))
+        return source,data,path,plist,clist,params,qs
+
+def stream_type(data):
+    if "::" in data:
+        data = data.split("::")[1]
+    data = data.lower()
+    m = re.search(r"^(\w+)://", data)
+    prefix = m.group(1) if m else ""
+    if prefix in ("http","https") and "m3u8" in data:
+        return "hls"
+    elif prefix == "http":
+        return "http"
+    else:
+        return prefix
+
+if __name__ == "__main__":
+    pass

resources/lib/sources0/YouTubeVideoUrl.py

@@ -0,0 +1,404 @@
+# -*- coding: UTF-8 -*-
+# This video extraction code based on youtube-dl: https://github.com/rg3/youtube-dl
+
+import codecs
+import json
+import re
+
+from urllib import urlencode
+from urllib2 import urlopen, URLError
+import sys
+
+#from Components.config import config
+
+#from . import sslContext
+sslContext = None
+if sys.version_info >= (2, 7, 9):
+	try:
+		import ssl
+		sslContext = ssl._create_unverified_context()
+	except:
+		pass 
+from jsinterp import JSInterpreter
+from swfinterp import SWFInterpreter
+
+
+PRIORITY_VIDEO_FORMAT = []
+maxResolution =  '22'
+
+
+def createPriorityFormats():
+	global PRIORITY_VIDEO_FORMAT,maxResolution
+	PRIORITY_VIDEO_FORMAT = []
+	use_format = False
+	for itag_value in ['38', '37', '96', '22', '95', '120',
+		'35', '94', '18', '93', '5', '92', '132', '17']:
+		if itag_value == maxResolution: #config.plugins.YouTube.maxResolution.value:
+			use_format = True
+		if use_format:
+			PRIORITY_VIDEO_FORMAT.append(itag_value)
+
+createPriorityFormats()
+
+IGNORE_VIDEO_FORMAT = [
+		'43',  # webm
+		'44',  # webm
+		'45',  # webm
+		'46',  # webm
+		'100',  # webm
+		'101',  # webm
+		'102'  # webm
+	]
+
+
+def uppercase_escape(s):
+	unicode_escape = codecs.getdecoder('unicode_escape')
+	return re.sub(
+		r'\\U[0-9a-fA-F]{8}',
+		lambda m: unicode_escape(m.group(0))[0],
+		s)
+
+
+def compat_urllib_parse_unquote(string, encoding='utf-8', errors='replace'):
+	if string == '':
+		return string
+	res = string.split('%')
+	if len(res) == 1:
+		return string
+	if encoding is None:
+		encoding = 'utf-8'
+	if errors is None:
+		errors = 'replace'
+	# pct_sequence: contiguous sequence of percent-encoded bytes, decoded
+	pct_sequence = b''
+	string = res[0]
+	for item in res[1:]:
+		try:
+			if not item:
+				raise ValueError
+			pct_sequence += item[:2].decode('hex')
+			rest = item[2:]
+			if not rest:
+				# This segment was just a single percent-encoded character.
+				# May be part of a sequence of code units, so delay decoding.
+				# (Stored in pct_sequence).
+				continue
+		except ValueError:
+			rest = '%' + item
+		# Encountered non-percent-encoded characters. Flush the current
+		# pct_sequence.
+		string += pct_sequence.decode(encoding, errors) + rest
+		pct_sequence = b''
+	if pct_sequence:
+		# Flush the final pct_sequence
+		string += pct_sequence.decode(encoding, errors)
+	return string
+
+
+def _parse_qsl(qs, keep_blank_values=False, strict_parsing=False,
+			encoding='utf-8', errors='replace'):
+	qs, _coerce_result = qs, unicode
+	pairs = [s2 for s1 in qs.split('&') for s2 in s1.split(';')]
+	r = []
+	for name_value in pairs:
+		if not name_value and not strict_parsing:
+			continue
+		nv = name_value.split('=', 1)
+		if len(nv) != 2:
+			if strict_parsing:
+				raise ValueError("bad query field: %r" % (name_value,))
+			# Handle case of a control-name with no equal sign
+			if keep_blank_values:
+				nv.append('')
+			else:
+				continue
+		if len(nv[1]) or keep_blank_values:
+			name = nv[0].replace('+', ' ')
+			name = compat_urllib_parse_unquote(
+				name, encoding=encoding, errors=errors)
+			name = _coerce_result(name)
+			value = nv[1].replace('+', ' ')
+			value = compat_urllib_parse_unquote(
+				value, encoding=encoding, errors=errors)
+			value = _coerce_result(value)
+			r.append((name, value))
+	return r
+
+
+def compat_parse_qs(qs, keep_blank_values=False, strict_parsing=False,
+					encoding='utf-8', errors='replace'):
+	parsed_result = {}
+	pairs = _parse_qsl(qs, keep_blank_values, strict_parsing,
+					encoding=encoding, errors=errors)
+	for name, value in pairs:
+		if name in parsed_result:
+			parsed_result[name].append(value)
+		else:
+			parsed_result[name] = [value]
+	return parsed_result
+
+
+class YouTubeVideoUrl():
+
+	def _download_webpage(self, url):
+		""" Returns a tuple (page content as string, URL handle) """
+		try:
+			if sslContext:
+				urlh = urlopen(url, context = sslContext)
+			else:
+				urlh = urlopen(url)
+		except URLError, e:
+			#raise Exception(e.reason)
+			return ""
+		return urlh.read()
+
+	def _search_regex(self, pattern, string):
+		"""
+		Perform a regex search on the given string, using a single or a list of
+		patterns returning the first matching group.
+		"""
+		mobj = re.search(pattern, string, 0)
+		if mobj:
+			# return the first matching group
+			return next(g for g in mobj.groups() if g is not None)
+		else:
+			raise Exception('Unable extract pattern from string!')
+
+	def _decrypt_signature(self, s, player_url):
+		"""Turn the encrypted s field into a working signature"""
+
+		if player_url is None:
+			raise Exception('Cannot decrypt signature without player_url!')
+
+		if player_url[:2] == '//':
+			player_url = 'https:' + player_url
+		try:
+			func = self._extract_signature_function(player_url)
+			return func(s)
+		except:
+			raise Exception('Signature extraction failed!')
+
+	def _extract_signature_function(self, player_url):
+		id_m = re.match(
+			r'.*?-(?P<id>[a-zA-Z0-9_-]+)(?:/watch_as3|/html5player(?:-new)?|/base)?\.(?P<ext>[a-z]+)$',
+			player_url)
+		if not id_m:
+			raise Exception('Cannot identify player %r!' % player_url)
+		player_type = id_m.group('ext')
+		code = self._download_webpage(player_url)
+		if player_type == 'js':
+			return self._parse_sig_js(code)
+		elif player_type == 'swf':
+			return self._parse_sig_swf(code)
+		else:
+			raise Exception('Invalid player type %r!' % player_type)
+
+	def _parse_sig_js(self, jscode):
+		funcname = self._search_regex(r'\.sig\|\|([a-zA-Z0-9$]+)\(', jscode)
+		jsi = JSInterpreter(jscode)
+		initial_function = jsi.extract_function(funcname)
+		return lambda s: initial_function([s])
+
+	def _parse_sig_swf(self, file_contents):
+		swfi = SWFInterpreter(file_contents)
+		TARGET_CLASSNAME = 'SignatureDecipher'
+		searched_class = swfi.extract_class(TARGET_CLASSNAME)
+		initial_function = swfi.extract_function(searched_class, 'decipher')
+		return lambda s: initial_function([s])
+
+	def _extract_from_m3u8(self, manifest_url):
+		url_map = {}
+
+		def _get_urls(_manifest):
+			lines = _manifest.split('\n')
+			urls = filter(lambda l: l and not l.startswith('#'), lines)
+			return urls
+
+		manifest = self._download_webpage(manifest_url)
+		formats_urls = _get_urls(manifest)
+		for format_url in formats_urls:
+			itag = self._search_regex(r'itag/(\d+?)/', format_url)
+			url_map[itag] = format_url
+		return url_map
+
+	def _get_ytplayer_config(self, webpage):
+		# User data may contain arbitrary character sequences that may affect
+		# JSON extraction with regex, e.g. when '};' is contained the second
+		# regex won't capture the whole JSON. Yet working around by trying more
+		# concrete regex first keeping in mind proper quoted string handling
+		# to be implemented in future that will replace this workaround (see
+		# https://github.com/rg3/youtube-dl/issues/7468,
+		# https://github.com/rg3/youtube-dl/pull/7599)
+		patterns = [
+			r';ytplayer\.config\s*=\s*({.+?});ytplayer',
+			r';ytplayer\.config\s*=\s*({.+?});',
+		]
+		for pattern in patterns:
+			config = self._search_regex(pattern, webpage)
+			if config:
+				return json.loads(uppercase_escape(config))
+
+	def extract(self, video_id):
+		url = 'https://www.youtube.com/watch?v=%s&gl=US&hl=en&has_verified=1&bpctr=9999999999' % video_id
+
+		# Get video webpage
+		video_webpage = self._download_webpage(url)
+		if not video_webpage:
+			#raise Exception('Video webpage not found!')
+			return ""
+
+		# Attempt to extract SWF player URL
+		mobj = re.search(r'swfConfig.*?"(https?:\\/\\/.*?watch.*?-.*?\.swf)"', video_webpage)
+		if mobj is not None:
+			player_url = re.sub(r'\\(.)', r'\1', mobj.group(1))
+		else:
+			player_url = None
+
+		# Get video info
+		embed_webpage = None
+		if re.search(r'player-age-gate-content">', video_webpage) is not None:
+			age_gate = True
+			# We simulate the access to the video from www.youtube.com/v/{video_id}
+			# this can be viewed without login into Youtube
+			url = 'https://www.youtube.com/embed/%s' % video_id
+			embed_webpage = self._download_webpage(url)
+			data = urlencode({
+				'video_id': video_id,
+				'eurl': 'https://youtube.googleapis.com/v/' + video_id,
+				'sts': self._search_regex(r'"sts"\s*:\s*(\d+)', embed_webpage),
+			})
+			video_info_url = 'https://www.youtube.com/get_video_info?' + data
+			video_info_webpage = self._download_webpage(video_info_url)
+			video_info = compat_parse_qs(video_info_webpage)
+		else:
+			age_gate = False
+			video_info = None
+			# Try looking directly into the video webpage
+			ytplayer_config = self._get_ytplayer_config(video_webpage)
+			if ytplayer_config:
+				args = ytplayer_config['args']
+				if args.get('url_encoded_fmt_stream_map'):
+					# Convert to the same format returned by compat_parse_qs
+					video_info = dict((k, [v]) for k, v in args.items())
+
+			if not video_info:
+				# We also try looking in get_video_info since it may contain different dashmpd
+				# URL that points to a DASH manifest with possibly different itag set (some itags
+				# are missing from DASH manifest pointed by webpage's dashmpd, some - from DASH
+				# manifest pointed by get_video_info's dashmpd).
+				# The general idea is to take a union of itags of both DASH manifests (for example
+				# video with such 'manifest behavior' see https://github.com/rg3/youtube-dl/issues/6093)
+				for el_type in ['&el=info', '&el=embedded', '&el=detailpage', '&el=vevo', '']:
+					video_info_url = (
+						'https://www.youtube.com/get_video_info?&video_id=%s%s&ps=default&eurl=&gl=US&hl=en'
+						% (video_id, el_type))
+					video_info_webpage = self._download_webpage(video_info_url)
+					video_info = compat_parse_qs(video_info_webpage)
+					if 'token' in video_info:
+						break
+		if 'token' not in video_info:
+			if 'reason' in video_info:
+				print '[YouTubeVideoUrl] %s' % video_info['reason'][0]
+			else:
+				print '[YouTubeVideoUrl] "token" parameter not in video info for unknown reason'
+
+		# Start extracting information
+		if 'conn' in video_info and video_info['conn'][0][:4] == 'rtmp':
+			url = video_info['conn'][0]
+		elif len(video_info.get('url_encoded_fmt_stream_map', [''])[0]) >= 1 or \
+			len(video_info.get('adaptive_fmts', [''])[0]) >= 1:
+			encoded_url_map = video_info.get('url_encoded_fmt_stream_map', [''])[0] + \
+				',' + video_info.get('adaptive_fmts', [''])[0]
+			if 'rtmpe%3Dyes' in encoded_url_map:
+				raise Exception('rtmpe downloads are not supported, see https://github.com/rg3/youtube-dl/issues/343')
+
+			# Find the best format from our format priority map
+			encoded_url_map = encoded_url_map.split(',')
+			url_map_str = None
+			# If format changed in config, recreate priority list
+			if PRIORITY_VIDEO_FORMAT[0] != maxResolution: #config.plugins.YouTube.maxResolution.value:
+				createPriorityFormats()
+			for our_format in PRIORITY_VIDEO_FORMAT:
+				our_format = 'itag=' + our_format
+				for encoded_url in encoded_url_map:
+					if our_format in encoded_url and 'url=' in encoded_url:
+						url_map_str = encoded_url
+						break
+				if url_map_str:
+					break
+			# If anything not found, used first in the list if it not in ignore map
+			if not url_map_str:
+				for encoded_url in encoded_url_map:
+					if 'url=' in encoded_url:
+						url_map_str = encoded_url
+						for ignore_format in IGNORE_VIDEO_FORMAT:
+							ignore_format = 'itag=' + ignore_format
+							if ignore_format in encoded_url:
+								url_map_str = None
+								break
+					if url_map_str:
+						break
+			if not url_map_str:
+				url_map_str = encoded_url_map[0]
+
+			url_data = compat_parse_qs(url_map_str)
+			url = url_data['url'][0]
+			if 'sig' in url_data:
+				url += '&signature=' + url_data['sig'][0]
+			elif 's' in url_data:
+				encrypted_sig = url_data['s'][0]
+				ASSETS_RE = r'"assets":.+?"js":\s*("[^"]+")'
+
+				jsplayer_url_json = self._search_regex(ASSETS_RE,
+					embed_webpage if age_gate else video_webpage)
+				if not jsplayer_url_json and not age_gate:
+					# We need the embed website after all
+					if embed_webpage is None:
+						embed_url = 'https://www.youtube.com/embed/%s' % video_id
+						embed_webpage = self._download_webpage(embed_url)
+					jsplayer_url_json = self._search_regex(ASSETS_RE, embed_webpage)
+
+				player_url = json.loads(jsplayer_url_json)
+				if player_url is None:
+					player_url_json = self._search_regex(
+						r'ytplayer\.config.*?"url"\s*:\s*("[^"]+")',
+						video_webpage)
+					player_url = json.loads(player_url_json)
+
+				signature = self._decrypt_signature(encrypted_sig, player_url)
+				url += '&signature=' + signature
+			if 'ratebypass' not in url:
+				url += '&ratebypass=yes'
+		elif video_info.get('hlsvp'):
+			url = None
+			manifest_url = video_info['hlsvp'][0]
+			url_map = self._extract_from_m3u8(manifest_url)
+
+			# Find the best format from our format priority map
+			for our_format in PRIORITY_VIDEO_FORMAT:
+				if url_map.get(our_format):
+					url = url_map[our_format]
+					break
+			# If anything not found, used first in the list if it not in ignore map
+			if not url:
+				for url_map_key in url_map.keys():
+					if url_map_key not in IGNORE_VIDEO_FORMAT:
+						url = url_map[url_map_key]
+						break
+			if not url:
+				url = url_map.values()[0]
+		else:
+			#raise Exception('No supported formats found in video info!')
+			return ""
+
+		return str(url)
+
+if __name__ == "__main__":
+
+	#yt = YouTubeVideoUrl()
+	if len(sys.argv)>1:
+		video_id= sys.argv[1]
+	else:
+		video_id = "2rlTF6HiMGg"
+	e = YouTubeVideoUrl().extract(video_id)
+	print e

resources/lib/sources0/cinemalive.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+import urllib2, urllib
+import datetime, re, sys,os
+import ConfigParser
+from SourceBase import SourceBase
+#from collections import OrderedDict
+import os
+
+#sys.path.insert(0,os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) 
+from resolver import resolve
+import util
+
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+import HTMLParser
+h = HTMLParser.HTMLParser()
+    
+class Source(SourceBase):
+    
+    def __init__(self,country=""):
+        self.name = "cinemalive"
+        self.title = "cinemalive.tv"
+        self.img = "picons/cinemalive.png" #"https://cinemalive.tv/assets/img/logo.png"
+        self.desc = "cinemalive.tv satura skatīšanās"
+        self.country=country
+        self.headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:48.0) Gecko/20100101 Firefox/48.0
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8,application/json
+""")
+        self.headers2 = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36
+Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+Accept-Language: en-US,en;q=0.8
+""")
+        self.url = "https://cinemalive.tv/"
+        #self.login()
+        
+            
+    ######### Entry point ########
+    def get_content(self, data):
+        print "[cinemalive] get_content:", data
+        source,data,path,plist,clist,params,qs = self.parse_data(data)     
+        content=[]
+        content.append(("..return", "back","","Return back"))
+        
+        if clist=="home":
+            content.extend([
+                ("Search", "cinemalive::scripts/search.php?search={0}","","Search"),            
+                ("Filmas latviski - visas", "cinemalive::filmaslatviski/visas/lapa/1","","Filmas latviski - visas"),
+                ("Filmas angliski", "cinemalive::home_en","","Filmas angliski"),
+                ("Filmas latviski - jaunākās", "cinemalive::filmaslatviski/jaunakas/lapa/1","","Filmas latviski - jaunākās"),
+                ("Filmas latviski - vertētākās", "cinemalive::filmaslatviski/vertetakas/lapa/1","","Filmas latviski - vērtētākās"),
+                ("Filmas latviski - skatitakās", "cinemalive::filmaslatviski/skatitakas/lapa/1","","Filmas latviski - skatītākās"),
+            ])
+            r = self.call("filmaslatviski")
+            for item in re.findall(r'<li class="nav-submenu-item"><a href="/([\w/]+)">(.+?)</a></li>', r):
+                title = "Filmas latviski - "+item[1]
+                data2 = item[0]+"/lapa/1"
+                img = self.img
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))      
+            return content
+
+        elif clist=="home_en":
+            content.extend([
+                ("Search", "cinemalive::scripts/search.php?search={0}","","Search"),            
+                ("Movies English - all", "cinemalive::moviesenglish/all/page/1","","Movies English - all"),
+                ("Movies Latvian", "cinemalive::home","","Filmas latviski"),
+                ("Movies English - newest", "cinemalive::moviesenglish/newestmovies/page/1","","Movies English - newest"),
+                ("Movies English - top rated", "cinemalive::moviesenglish/toprated/page/1","","Movies English - top rated"),
+                ("Movies English - most watched", "cinemalive::moviesenglish/mostwatched/page/1","","Movies English - most watched"),
+            ])
+            r = self.call("moviesenglish")
+            for item in re.findall(r'<li class="nav-submenu-item"><a href="/([\w/]+)">(.+?)</a></li>', r):
+                title = "Movies English - "+item[1]
+                data2 = item[0]+"/page/1"
+                img = self.img
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))      
+            return content
+
+    
+        elif "search.php" in data:
+            
+            r=self.call(path,params=params[1:],headers=self.headers2)
+            result = re.findall(r'<div class="results.+?<a href="https://cinemalive\.tv/(.+?)">.+?<img src="(.+?)".+?<span style="color:#bcbcbc">([^<]+)</span> <span style="color:#5a606d;font-size:12px;">([^<]+)</span><br/>.+?<p class="dec" style="font-size:12px; color:#777;line-height:14px;">([^<]+)</p>', r, re.DOTALL)            
+            for item in result:
+                title = item[2]
+                title0 = re.sub(" \(\d+\)","",title)
+                if title0 == item[3]:
+                    title = title+" [EN]"
+                else:
+                    title = title + "/"+ item[3]+" [LV]"
+                title = util.unescape(title)
+                data2 = item[0]
+                img = item[1].replace("xs.","sm.")
+                desc = util.unescape(item[4])
+                content.append((title,self.name+"::"+data2,img,desc))            
+            return content
+
+        elif clist in ("filmaslatviski","moviesenglish"):
+            r = self.call(data)
+            if not r:
+                return content
+            result = re.findall(r'<div class="base-used">.+?<a href="https://cinemalive.tv/([^"]+)">.+?<img class="img-thumbnail" src="/([^"]+)" alt="([^"]+)"/>.+?<p class="year">(\d+)</p>', r, re.DOTALL)
+            for item in result:
+                title = item[2] + " (%s)"%item[3]
+                data2 = item[0]
+                img = "https://cinemalive.tv/"+item[1]
+                title = util.unescape(title)
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc)) 
+            m = re.search(r"""<a href='https://cinemalive\.tv/([^']+)' style="border-right:none;">»</a>""", r, re.DOTALL)
+            if m:
+                data2 = m.group(1)
+                content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))                                  
+            return content      
+         
+        else:
+            return content                            
+              
+    def is_video(self,data):
+        source,data,path,plist,clist,params,qs = self.parse_data(data)        
+        if clist=="movie":
+            return True
+        else:
+            return False
+                        
+    def get_streams(self, data):
+        print "[cinemalive] get_streams:", data
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        r = self.call(path)
+        if not r:
+            return []
+        streams = []
+        title0 = re.search("<title>([^<]+)</title>", r).group(1)
+        lang = "LV" if "Filma Online Latviski" in title0 else "EN"
+        title = title0.replace(" - Filma Online Latviski","").replace(" - Movie Online English HD","")
+        desc = re.search('<p class="plot">(.+?)</p>', r).group(1)
+        img = "http://cinemalive.tv"+re.search('<img src="(.+?)" class="img-thumbnail"', r).group(1)
+        
+        m = re.search(r'<video id=.+?<source src="([^"]+\.mp4)"', r, re.DOTALL)
+        if m:
+            s = util.item()
+            s["url"] = m.group(1)
+            s["name"] = util.unescape(title)
+            s["desc"] = util.unescape(desc)
+            s["img"] = img
+            s["type"] = self.stream_type(s["url"])
+            s["lang"] = lang 
+            return [s]
+        
+        #m = re.search('<div class="viboom-overroll"><iframe src="([^"]+)"', r)
+        #if m:
+        result = re.findall('<div id="video_container"><iframe src="(.+?)"', r)
+        if result:
+            streams = resolve(result[0])
+            for s in streams:
+                s["name"] = util.unescape(title)
+                s["desc"] = util.unescape(desc)
+                s["img"] = img
+                s["type"] = self.stream_type(s["url"])
+                s["lang"] = lang
+            if len(result)>1:
+                lang2 = "EN" if lang=="LV" else "LV"
+                streams2 = resolve(result[1])
+                for s in streams2:
+                    s["name"] = util.unescape(title)
+                    s["desc"] = util.unescape(desc)
+                    s["img"] = img
+                    s["type"]= self.stream_type(s["url"])
+                    s["lang"] = lang2
+                    streams.append(s)  
+            return streams
+        else:
+            return []
+
+                    
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

resources/lib/sources0/config.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+import os.path,re
+import collections
+from SourceBase import SourceBase
+
+os.path.dirname(os.path.abspath(__file__))
+class Source(SourceBase):
+    
+    def __init__(self,country="lv"):
+        self.name = "config"
+        self.country=country
+        cur_directory = os.path.dirname(os.path.abspath(__file__))
+        self.streams_file = os.path.join(cur_directory,"streams.cfg")
+        self.lists = collections.OrderedDict()
+        self.read_streams()
+         
+    def get_content(self, data):
+        self.read_streams()
+        if "::" in data:
+            data = data.split("::")[1]
+        if not data in self.lists:
+            return []
+        return self.lists[data]
+
+    def is_video(self,data):
+        return False
+    
+    def read_streams(self):
+        for line in open(self.streams_file,"r"):
+            r = re.search("^\[(\w+)\]", line)
+            if r:
+                name = r.group(1)
+                self.lists[name] = []
+            else:
+                if len(line)<10 or line[0] in ("#"): continue
+                items = tuple(line.strip().split("|"))
+                if len(items)<2:
+                    continue
+                self.lists[name].append(items)
+                
+    def write_streams(self):
+        f = open(self.streams_file,"w")
+        for l in self.lists.keys():
+            f.write("[%s]\n"%l)
+            for item in self.lists[l]:
+                f.write("%s|%s|%s|%s\n"%(item[0],item[1],item[2],item[3]))
+            f.write("\n")
+        f.close()
+    
+    def get_lists(self):
+        return self.lists.keys()
+    
+    def get_list_items(self,name):
+        return self.lists[name]
+    
+    def add_list(self,name):
+        if not name in self.lists.keys():
+            self.lists[name] = []
+            
+    def del_list(self,name):
+        if name in self.lists.keys():
+            del self.lists[name]
+            
+    def add_item(self,name,item,pos=None):
+        if name in self.lists.keys():
+            if pos==None:
+                self.lists[name].append(item)
+            else:
+                self.lists[name].insert(pos,item)
+                
+    def del_item(self,name,pos):
+        self.lists[name].pop(pos)
+    
+    def replace_item(self,name,item,pos):
+        self.lists[name][pos]=item
+            
+                           
+if __name__ == "__main__":
+    c = Source()
+    content = c.get_content("home")
+    for item in content: print item
+    #c.del_item("home",0)
+    #c.del_list("favorites")
+    
+    #c.add_item("home",("My Streams","config::favorites","","Mani saglabātie TV kanāli un video"),0)
+    c.replace_item("home",("My Streams","config::my_streams","default","Mani saglabātie TV kanāli un video"),0)
+    #c.add_list("favorites")
+    #c.add_item("favorites",("..return","back","","Atgriezties atpakaļ"))    
+    #c.add_item("favorites",("LTV1","http://streamltv.cloudy.services/ltv/LTV02.smil/playlist.m3u8","picons/latvia1.png", "Latvijas televīzijas 1.kanāls"))
+    
+    c.write_streams()
+    for item in content: print item
+    

resources/lib/sources0/euronews.cfg

@@ -0,0 +1,3 @@
+[euronews]
+language = en
+

resources/lib/sources0/euronews.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import urllib2, urllib
+import datetime, time,re, sys,os
+from collections import OrderedDict
+from SourceBase import SourceBase
+import util
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+import HTMLParser
+h = HTMLParser.HTMLParser()
+
+class Source(SourceBase):
+
+    def __init__(self,language="en"):
+        self.name = "euronews"
+        self.title = "Euronews"
+        self.img = "http://pbs.twimg.com/profile_images/732665354242150400/tZsCnjuh_400x400.jpg"
+        self.desc = "Euronews live and archive"
+        self.headers = headers2dict("""
+User-Agent: Euronews/4.0.126
+Content-Type: application/json
+Connection: keep-alive
+        """)
+        #self.language=language
+        cur_directory = os.path.dirname(os.path.abspath(__file__))
+        self.config_file = os.path.join(cur_directory,self.name+".cfg")
+        self.options = OrderedDict([("language","en")])
+        self.options_read()
+        self.vid={"1": "News", "2": "European Affairs", "3": "Lifestyle", "4": "Knowledge"}
+        self.languages = []
+        try:
+            self.get_languages()
+        except:
+            pass
+
+    def login(self,user="",password=""):
+        return True
+
+    def get_content(self, data):
+        print "[%s] get_content:"%self.name, data
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        #lang = qs["lang"] if "lang" in qs else self.language
+        lang = self.options["language"]
+        if not lang in self.get_languages():
+            raise Exception("Not valid default language - '%s'"%lang)
+
+        content=[]
+        content.append(("..return", "back","","Return back"))
+
+        if clist=="home":
+            content.extend([
+                ("Search", "euronews::content/getSearch?lang=%s&byPage=40&page=1&text={0}"%lang,self.img,"Top stories timeline"),
+                ("Live stream", "euronews::live?lang=%s"%lang,self.img,"Euronews live stream"),
+                ("Just in", "euronews::content/getTimeline?lang=%s&byPage=40&page=1"%lang,self.img,"News timeline"),
+                ("Top stories", "euronews::content/getTopStories?lang=%s"%lang,self.img,"Top stories timeline"),
+                ("Category - News", "euronews::content/getVertical?lang=%s&byPage=40&page=1&vId=1"%lang,self.img,"Category - News"),
+                ("Category - European Affairs", "euronews::content/getVertical?lang=%s&byPage=40&page=1&vId=2"%lang,self.img,"Category - European Affairs"),
+                ("Category - Lifestyle", "euronews::content/getVertical?lang=%s&byPage=40&page=1&vId=3"%lang,self.img,"Category - Lifestyle"),
+                ("Category - Knowledge", "euronews::content/getVertical?lang=%s&byPage=40&page=1&vId=4"%lang,self.img,"Category - Knowledge"),
+                ("Latest programs", "euronews::content/getLatestPrograms?lang=%s&byPage=40&page=1"%lang,self.img,"Latest programs"),
+                ("Programs list", "euronews::content/getPrograms?lang=%s"%lang,self.img,"Programs list"),
+             ])
+            return content
+
+
+        ### Video arhīvs ###
+        elif clist=="content":
+            if "lang" in qs:
+                del qs["lang"]
+            params = json.dumps(qs)
+
+            req = '{"methodName":"content.%s","apiKey":"androidPhoneEuronews-1.0","params":%s,"language":"%s"}'%(plist[1],params,lang)
+            r = self.call(req)
+            if not r:
+                return content
+            lst = r["timeline"] if "timeline" in r else\
+                r["topstorieslist"] if "topstorieslist" in r else\
+                r["programs"] if "programs" in r else\
+                r["programDetailsList"] if "programDetailsList" in r else\
+                r["programlist"] if "programlist" in r else\
+                r["articlelist"] if "articlelist" in r else\
+                r["verticals"] if "verticals" in r else\
+                []
+            if not lst:
+                return content
+
+            for item in lst:
+                if plist[1] in ("getTimeline"):
+                    article = item["article"]
+                    atype = item["type"]
+                    #if item["type"] == "wire":
+                        #continue # TODO
+                else:
+                    article = item
+                    atype = "article"
+                if plist[1]=="getPrograms":
+                    title = article["title"]
+                    id = article["pId"]
+                    desc = title
+                    img = "http://static.euronews.com/articles/programs/533x360_%s"%article["img"]
+                    data2 = "content/getProgramDetails?lang=%s&byPage=40&page=1&pId=%s"%(lang,id)
+                    content.append((title,self.name+"::"+data2,img,desc))
+                else:
+                    title = article["title"] if "title" in article else article["text"] if "text" in article else "No title"
+                    if atype <> "article":
+                        title = "[%s] %s"%(atype,title)
+                    atime = datetime.datetime.fromtimestamp(int(article["uts"]))
+                    #atime = datetime.datetime.fromtimestamp(int(article["uts"])-time.altzone)
+                    atime = atime.strftime("%Y-%m-%d %H:%M")
+                    vert = self.vid[article["vId"]] if "vId" in article else ""
+                    ptitle = article["pTitle"] if "pTitle" in article else ""
+                    id = article["id"]
+                    desc = "%s\n%s\n%s %s"%(title,atime,vert,ptitle)
+                    img = "http://static.euronews.com/articles/%s/399x225_%s.jpg"%(id,id)
+                    if not atype in ("breakingnews","wire"):
+                        data2 = "content/getArticle?lang=%s&id=%s"%(lang,id)
+                    else:
+                        data2 = ""
+                    content.append((title,self.name+"::"+data2,img,desc))
+            if "page=" in data:
+                data2 = re.sub("page=\d+","page=%s"%(int(qs["page"])+1),data)
+                content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))
+            return content
+
+
+    def is_video(self,data):
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        if path == "live":
+            return True
+        elif clist=="content" and plist[1]=="getArticle":
+            return True
+        else:
+            return False
+
+    def get_streams(self, data):
+        print "[euronews] get_streams:", data
+        if not self.is_video(data):
+            return []
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        #lang = qs["lang"] if "lang" in qs else self.language
+        lang = self.options["language"]
+        if not lang in self.get_languages():
+            raise Exception("Not valid default language - '%s'"%lang)
+
+        streams = []
+
+        if path == "live":
+            url = "http://www.euronews.com/api/watchlive.json"
+            r = self._http_request(url)
+            try:
+                js = json.loads(r)
+                url = js["url"]
+            except:
+                raise Exception("No live stream found")
+            r = self._http_request(url)
+            try:
+                js = json.loads(r)
+                if not js["status"]=="ok":
+                    raise Exception("No live stream found")
+            except:
+                raise Exception("No live stream found")
+
+            slist = js["primary"]
+
+            for l in slist:
+                stream = util.item()
+                stream["url"]=slist[l]["hls"]
+                stream["lang"]=l
+                stream["quality"]="variant"
+                stream["name"]="Euronews live [%s]"%l
+                stream["desc"]=stream["name"]
+                stream["type"]="hls" #stream_type(url)
+                streams.append(stream)
+
+        elif clist=="content" and plist[1] == "getArticle":
+            if "lang" in qs:
+                del qs["lang"]
+            languages = self.get_languages()
+            for lang in languages:
+                id = qs["id"]
+                req = '{"methodName":"content.getArticle","apiKey":"androidPhoneEuronews-1.0","params":{"id":"%s"},"language":"%s"}'%(id,lang)
+                r = self.call(req)
+                if not r:
+                    raise Exception("No live stream found")
+                if not "articlelist" in r:
+                    msg = r["label"] if "label" in r else "No article finde"
+                    raise Exception(msg)
+                article = r["articlelist"]
+                stream = util.item()
+                stream["url"]=article["videoUri"] if "videoUri" in article else ""
+                if not stream["url"]:
+                    return []
+                stream["lang"]=lang
+                stream["quality"]="?"
+                stream["name"]= article["title"]
+                stream["desc"]=article["text"] if "text" in article else article["title"]
+                stream["type"]="http" #stream_type(url)
+                streams.append(stream)
+
+        else:
+            raise Exception("No live stream found")
+
+        ### TODO - sakārtot sarakstu, lai pirmais ir labakais video
+        qlist = ["???","lq","mq","hq","hd","variant"]
+        llist = ["fr","en","ru","lv"]
+        for s in streams:
+            if s["lang"]==self.options["language"]:
+                s["order"] = 10000
+                continue
+            lv = llist.index(s["lang"])*10 if s["lang"] in llist else 0
+            qv=qlist.index(s["quality"]) if s["quality"] in qlist else 0
+            s["order"] = lv+qv
+        streams = sorted(streams,key=lambda item: item["order"],reverse=True)
+        return streams
+    def get_languages(self):
+        if self.languages: return self.languages
+        url = "http://www.euronews.com/api/watchlive.json"
+        r = self._http_request(url)
+        try:
+            js = json.loads(r)
+            url = js["url"]
+        except:
+            raise Exception("Can not get languages list")
+        r = self._http_request(url)
+        try:
+            js = json.loads(r)
+            if not js["status"]=="ok":
+                raise Exception("Can not get languages list")
+        except:
+            raise Exception("Can not get languages list")
+
+        slist = js["primary"]
+        self.languages=slist.keys()
+        return self.languages
+
+    def call(self, data,params = None, headers=None):
+        if not headers: headers = self.headers
+        #if not lang: lang = self.country
+        url = "http://api.euronews.com/ipad/"
+        headers = headers2dict("""
+User-Agent: Euronews/4.0.126
+Content-Type: multipart/form-data, boundary=AaB03xBounDaRy; charset=UTF-8
+Host: api.euronews.com
+Connection: Keep-Alive
+        """)
+        params = """
+--AaB03xBounDaRy
+content-disposition: form-data; name=request
+
+%s
+--AaB03xBounDaRy--
+"""%data
+        content = self._http_request(url, params, headers)
+        if content:
+            try:
+                result = json.loads(content)
+                return result
+            except Exception, ex:
+                return None
+        else:
+            return None
+
+
+if __name__ == "__main__":
+    language= "en"
+    c = Source(language)
+    data = '{"methodName":"content.getTimeline","apiKey":"androidPhoneEuronews-1.0","params":{"page":"1","byPage":"30"},"language":"en"}'
+    r = c.call(data)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    pass

resources/lib/sources0/filmix.py

@@ -0,0 +1,336 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import urllib2, urllib
+import datetime, re, sys,os
+import ConfigParser
+from SourceBase import SourceBase
+import base64
+from collections import OrderedDict
+import sys
+try:
+    import util
+except:
+    sys.path.insert(0,'..')
+    import util
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+
+class Source(SourceBase):
+
+    def __init__(self,country=""):
+        self.name = "filmix"
+        self.title = "filmix.me"
+        self.img = "http://cs5324.vk.me/g33668783/a_903fcc63.jpg"
+        self.desc = "filmix.me satura skatīšanās"
+        self.country=country
+        self.headers = headers2dict("""
+Host: filmix.me
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-US,en;q=0.5
+""")
+        self.headers2 = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0
+X-Requested-With: XMLHttpRequest
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+""")
+        self.url = "https://filmix.me/"
+        #self.login()
+
+    def login(self,user="",password=""):
+        return True
+
+    def get_content(self, data):
+        print "[filmix] get_content:", data
+        source, data, path, plist, clist, params, qs = self.parse_data(data)
+        content=[]
+        content.append(("..return", "back","","Return back"))
+
+        if clist=="home":
+            content.extend([
+                ("Search", "filmix::search/{0}","","Search"),
+                ("Movies", "filmix::movies","","Movies"),
+                ("Series", "filmix::series","","TV Series"),
+                ("Cartoons", "filmix::cartoons","","Cartoons"),
+            ])
+            return content
+
+        #elif clist=="search":
+            # TODO
+            #return content
+
+        elif data in ("movies","series","cartoons"):
+            r = self.call("")
+            r = r.decode("cp1251").encode("utf8")
+            if data == "movies":
+                sname = "Фильмы"
+            elif data=="series":
+                sname = "Сериалы"
+            else:
+                sname = "Мультфильмы"
+            # <span class="menu-title">Фильмы</span>
+            m = re.search('<span class="menu-title">%s</span>(.+?)<li>\s+?<span'%sname, r, re.DOTALL|re.UNICODE)
+            if not m: return content
+            r2 = m.group(1)
+            result = re.findall(r'<a .*?href="https://filmix\.me/([^"]+)".*?>([^<]+)</', r2, re.DOTALL)
+            for item in result:
+                if "catalog" in item[0]: continue
+                title = item[1]
+                data2 = item[0]
+                img = self.img
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ## Seriāls
+        elif clist=="play":
+            r = self.call(path)
+            r = r.decode("cp1251").encode("utf8")
+            title = title0 = util.unescape(re.search("titlePlayer = '([^']+)'", r, re.DOTALL).group(1))
+            m = re.search('<meta itemprop="thumbnailUrl" content="([^"]+)',r,re.DOTALL)
+            img = m.group(1) if m else self.img
+            m = re.search('<meta itemprop="duration" content="([^"]+)" />', r, re.DOTALL)
+            duration = "(%s)"%m.group(1) if m else ""
+            m = re.search('<p itemprop="description"[^>]+>([^<]+)<', r, re.DOTALL)
+            desc = desc0 =  util.unescape(m.group(1).strip()) if m else ""
+            vid = plist[-1]
+            js = self.get_movie_info(vid)
+            pl_link = js["message"]["translations"]["flash"].values()[0] # TODO process several players
+            pl_link = self.decode_uppod_text(pl_link)
+            js = self._http_request(pl_link)
+            js = self.decode_uppod_text(js)
+            js = json.loads(js)
+            if "s" in qs:
+                s = int(qs["s"])
+                for i,ep in enumerate(js["playlist"][s-1]["playlist"]):
+                    title = title0+" - "+js["playlist"][s-1]["playlist"][i]["comment"].encode("utf8")
+                    serie = js["playlist"][s-1]["playlist"][i]["comment"].encode("utf8")
+                    data2 = data+"&e=%s"%(i+1)
+                    desc = serie +"\n"+desc0
+                    content.append((title,self.name+"::"+data2,img,desc))
+            else:
+                for i,ep in enumerate(js["playlist"]):
+                    title = title0 +" - "+js["playlist"][i]["comment"].encode("utf8")
+                    serie = js["playlist"][i]["comment"].encode("utf8")
+                    data2 = data+"?s=%s"%(i+1)
+                    desc = serie +"\n"+desc0
+                    content.append((title,self.name+"::"+data2,img,desc))
+            return content
+            #r = self._http_request(url)
+
+
+        ### saraksts ###
+        else:
+            r = self.call(data)
+            r = r.decode("cp1251").encode("utf8")
+            for r2 in re.findall('<article class="shortstory line".+?</article>', r, re.DOTALL):
+                m = re.search(r'<a href="https://filmix\.me/play/(\d+)" class="watch icon-play">', r2, re.DOTALL)
+                if not m: continue
+                vid = m.group(1)
+                data2 = "play/%s"%vid
+                #title = re.search('itemprop="name">([^<]+)</div>', r2, re.DOTALL).group(1)
+                title = re.search('itemprop="name" content="([^"]+)"', r2, re.DOTALL).group(1)
+                m = re.search('itemprop="alternativeHeadline" content="([^"]+)"', r2, re.DOTALL)
+                if m:
+                    title = title + "/"+m.group(1)
+                m = re.search('<img src="([^"]+.jpg)"', r2, re.DOTALL)
+                img = "http://filmix.me"+m.group(1) if m else self.img
+                m = re.search(r'<a itemprop="copyrightYear".+?>(\d+)<', r2, re.DOTALL)
+                if m:
+                    year = m.group(1) if m else ""
+                    title = "%s (%s)"%(title,year)
+                title = util.unescape(title)
+                genre = re.findall('<a itemprop="genre"[^>]+?">([^<]+)</a>', r2, re.DOTALL)
+                genre = ",".join(genre)
+                m = re.search('<p itemprop="description">([^<]+)</p>', r2, re.DOTALL)
+                desc0 = util.unescape(m.group(1)) if m else ""
+                m = re.search('<div class="quality">([^<]+)</div>', r2, re.DOTALL)
+                quality = m.group(1) if m else ""
+                actors = re.findall('itemprop="actor">([^<]+)<', r2, re.DOTALL)
+                actors = ",".join(actors)
+                desc="%s\n%s\n%s\n%s\n%s"%(title,genre,desc0,actors,quality)
+                content.append((title,self.name+"::"+data2,img,desc))
+            if '<div class="navigation">' in r:
+                m = re.search(r'href="https://filmix\.me/([^"]+)" class="next icon-arowRight btn-tooltip"', r, re.DOTALL)
+                if m:
+                    data2 = m.group(1)
+                else:
+                    m = re.search("/page/(\d)+",data)
+                    if m:
+                        page = int(m.group(1))+1
+                        data2 = re.sub("/page/(\d)+", "/page/%s"%page, data)
+                    else:
+                        data2 = data + "/page/2"
+                content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))
+
+            return content
+
+    def is_video(self,data):
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        if clist == "play" and "s=" in data and "e=" in data:
+            return True
+        elif clist=="play" and not params:
+            r = self.call(path)
+            #r = r.decode("cp1251").encode("utf8")
+            m = re.search('itemprop="contentUrl" content="(.+?)"', r, re.IGNORECASE | re.DOTALL)
+            if not m:
+                raise Exception("Can not find video link")
+                #return False
+            video_link = m.group(1)
+            if video_link=='{video-link}':
+                return False
+            else:
+                return True
+        else:
+            return False
+
+    def get_streams(self, data):
+        print "[filmix] get_streams:", data
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+
+        r = self.call(path)
+        if not r:
+            return []
+        streams = []
+        r = r.decode("cp1251").encode("utf8")
+        title = title0 = util.unescape(re.search("titlePlayer = '([^']+)'", r, re.DOTALL).group(1))
+        m = re.search('<meta itemprop="thumbnailUrl" content="([^"]+)',r,re.DOTALL)
+        img = m.group(1) if m else self.img
+        m = re.search('<meta itemprop="duration" content="([^"]+)" />', r, re.DOTALL)
+        duration = "(%s)"%m.group(1) if m else ""
+        m = re.search('<p itemprop="description"[^>]+>([^<]+)<', r, re.DOTALL)
+        desc = desc0 =  util.unescape(m.group(1).strip()) if m else ""
+        m = re.search('itemprop="contentUrl" content="(.+?)"', r, re.IGNORECASE | re.DOTALL)
+        if not m:
+        #    #raise Exception("Can not find video link")
+            return []
+        video_link = m.group(1)
+        series = True if video_link == '{video-link}' else False
+        vid = plist[1]
+        js = self.get_movie_info(vid)
+        if js["message"]["translations"]["flash"]:
+            video_link = js["message"]["translations"]["flash"].values()[0].encode("utf8")
+            video_link = self.decode_uppod_text(video_link)
+            lang = js["message"]["translations"]["flash"].keys()[0].encode("utf8") # TODO process several players/streams
+        else:
+            return []
+
+        if not series : # Filma
+            url0 = video_link
+            streams2 = self.get_streams2(url0)
+            for st in streams2:
+                stream = util.item()
+                stream["url"]=st[1]
+                stream["lang"]=lang
+                stream["quality"]=st[0]
+                stream["name"]= title
+                stream["desc"]=desc
+                streams.append(stream)
+            return streams
+
+        else: # Seriāls
+            pl_link = video_link
+            js = self._http_request(pl_link)
+            js = self.decode_uppod_text(js)
+            js = json.loads(js)
+            if "s" in qs and "e" in qs:
+                s = int(qs["s"])
+                e = int(qs["e"])
+                serie = js["playlist"][s-1]["playlist"][e-1]["comment"].encode("utf8")
+                title = title0+" - "+ serie
+                url0 = js["playlist"][s-1]["playlist"][e-1]["file"].encode("utf8")
+                streams2 = self.get_streams2(url0)
+                for st in streams2:
+                    stream = util.item()
+                    stream["url"]=st[1]
+                    stream["lang"]=lang
+                    stream["quality"]=st[0]
+                    stream["name"]= title
+                    stream["desc"]=desc
+                    streams.append(stream)
+                return streams
+
+    def call(self, data,params=None,headers=None,lang=""):
+        if not headers: headers = self.headers
+        url = self.url+data
+        result = self._http_request(url,params,headers=headers)
+        return result
+
+    def get_movie_info(self,vid):
+        headers = headers2dict("""
+    User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:50.0) Gecko/20100101 Firefox/50.0
+    Accept: application/json, text/javascript, */*; q=0.01
+    Accept-Language: en-US,en;q=0.5
+    Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+    X-Requested-With: XMLHttpRequest
+    Referer: https://filmix.me/play/%s
+    """%vid )
+        post_data = {"post_id":vid}
+        r = util.post("https://filmix.me/api/movies/player_data", data=post_data, headers = headers)
+        if not r:
+            raise Exception("Can not get movie info")
+            #return []
+        js = json.loads(r)
+        return js
+
+    def decode_uppod_text(self, text):
+        Client_codec_a = ["l", "u", "T", "D", "Q", "H", "0", "3", "G", "1", "f", "M", "p", "U", "a", "I", "6", "k", "d", "s", "b", "W", "5", "e", "y", "="]
+        Client_codec_b = ["w", "g", "i", "Z", "c", "R", "z", "v", "x", "n", "N", "2", "8", "J", "X", "t", "9", "V", "7", "4", "B", "m", "Y", "o", "L", "h"]
+        text = text.replace("\n", "").strip()
+        for i in range(len(Client_codec_a)):
+            char1 = Client_codec_b[i]
+            char2 = Client_codec_a[i]
+            text = text.replace(char1, "___")
+            text = text.replace(char2, char1)
+            text = text.replace("___", char2)
+        result = base64.b64decode(text)
+        print result
+        return result
+
+    def get_streams2(self,url0):
+        m = re.search("\[([\d,]+)]",url0)
+        if not m:
+            return [("?",url0)]
+        res = m.group(1)
+        streams=[]
+        for res in res.split(","):
+            if not res: continue
+            url=re.sub("\[[\d,]+]",res,url0)
+            streams.append((res,url))
+        return streams
+
+
+if __name__ == "__main__":
+
+    c = Source()
+    #s = "ZnVuY3Rpb24gc2VuZE1lc3NhZ2U2MDc3ODkoZSl7dmFyIGg9bWdfd3M2MDc3ODkub25tZXNzYWdlOyBtZ193czYwNzc4OS5yZWFkeVN0YXRlPT1tZ193czYwNzc4OS5DTE9TRUQmJihtZ193czYwNzc4OT1uZXcgV2ViU29ja2V0KG1nX3dzNjA3Nzg5X2xvY2F0aW9uKSksbWdfd3M2MDc3ODkub25tZXNzYWdlPWgsd2FpdEZvclNvY2tldENvbm5lY3Rpb242MDc3ODkobWdfd3M2MDc3ODksZnVuY3Rpb24oKXttZ193czYwNzc4OS5zZW5kKGUpfSl9ZnVuY3Rpb24gd2FpdEZvclNvY2tldENvbm5lY3Rpb242MDc3ODkoZSx0KXtzZXRUaW1lb3V0KGZ1bmN0aW9uKCl7cmV0dXJuIDE9PT1lLnJlYWR5U3RhdGU/dm9pZChudWxsIT10JiZ0KCkpOnZvaWQgd2FpdEZvclNvY2tldENvbm5lY3Rpb242MDc3ODkoZSx0KX0sNSl9OyB2YXIgbWdfd3M2MDc3ODlfbG9jYXRpb24gPSAid3NzOi8vd3NwLm1hcmtldGdpZC5jb20vd3MiOyBtZ193czYwNzc4OSA9IG5ldyBXZWJTb2NrZXQobWdfd3M2MDc3ODlfbG9jYXRpb24pLCBtZ193czYwNzc4OS5vbm1lc3NhZ2UgPSBmdW5jdGlvbiAodCkge3Bvc3RNZXNzYWdlKHQuZGF0YSk7fSwgb25tZXNzYWdlID0gZnVuY3Rpb24oZSl7c2VuZE1lc3NhZ2U2MDc3ODkoZS5kYXRhKX0="
+
+    #txt = c.decode_uppod_text(s)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

resources/lib/sources0/filmon.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import urllib2, urllib
+import datetime, re, sys
+from SourceBase import SourceBase
+
+API_URL = 'http://www.filmon.com/'
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+#User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0
+headers0 = headers2dict("""
+User-Agent: Mozilla/5.0 (iPhone; CPU iPhone OS 9_2 like Mac OS X) AppleWebKit/601.1 (KHTML, like Gecko) CriOS/47.0.2526.70 Mobile/13C71 Safari/601.1.46
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-US,en;q=0.5
+Accept-Encoding: deflate
+Connection: keep-alive
+""")
+import HTMLParser
+h = HTMLParser.HTMLParser()
+
+class Source(SourceBase):
+
+    def __init__(self,country="lv"):
+        self.name = "filmon"
+        self.title = "FilmOn"
+        self.img = "http://behindthegloves.com/wp-content/uploads/2016/01/FilmOn-logo1.jpg"
+        self.desc = "FilmOn portāla satura skatīšanās"
+        self.headers = headers0
+
+        self.country=country
+        self.jstv = None
+        self.session_key = None
+        self.cookie = None
+
+    def get_content(self, data):
+        print "[filmon] get_content:", data
+        if "::" in data:
+            data = data.split("::")[1] 
+        path = data.split("?")[0]
+        clist = path.split("/")[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        qs = dict(map(lambda x:x.split("="),re.findall("\w+=\w+",params)))
+        lang = qs["lang"] if "lang" in qs else self.country
+
+        if not self.jstv:
+            self.jstv = self.get_tv_channels()
+        #if not self.session_key: # TODO izskatās, ka strādā bez, vismaz ja nelogojas iekšā,  jānočeko
+        #    html = self._http_request("http://www.filmon.com/api/init")
+        #    js = json.loads(html)
+        #    self.session_key = js["session_key"]
+
+        content=[]
+        content.append(("..return", "back","","Return back"))
+
+        if clist=="home":
+            content.extend([
+                ("Live streams", "filmon::tv","","TV live streams"),
+                ("Video on demand", "filmon::vod","","Last videos"),
+            ])
+            return content
+
+        ### TV Groups ###
+        elif clist in ("tv","home"):
+            for gr in self.jstv:
+                title = gr["name"].encode("utf8")
+                data2 = "group?id=%s"%gr["id"]
+                img = gr["logo_148x148_uri"].encode("utf8")
+                desc = gr["description"].encode("utf8")
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### TV group channels ###
+        elif clist=="group":
+            if "id" in qs:
+                group_id = qs["id"] 
+            else:
+                return content
+            group = None
+            for gr in self.jstv:
+                if gr["id"]==group_id:
+                    group = gr
+                    break
+            if not group:
+                return content
+            for ch in group["channels"]:
+                title = ch["title"].encode("utf8")
+                data2 = "channel?id=%s"%ch["id"]
+                img = ch["big_logo"].encode("utf8")
+                desc = ch["description"].encode("utf8") if ch["description"] else title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### TV Channel ###
+        elif clist == "channel" or clist == "video":
+            if "id" in qs:
+                ch_id = qs["id"] 
+            else:
+                return ("No stream found %s"%data,"","","No stream found")
+            ch = self.get_tv_channel_info(ch_id)
+            if ch["now_playing"]:
+                current_event = ch["now_playing"]["programme_name"] if "programme_name" in ch["now_playing"] else ""
+            else:
+                current_event = ""
+            title = u"%s - %s"%(ch["title"],current_event)
+            title = title.encode("utf8")
+            if current_event:
+                desc = ch["now_playing"]["programme_description"].encode("utf8")
+            else:
+                desc = title
+            data2 = ""
+            for t in ("SD","HD"):
+                for s in ch["streams"]:
+                    if s["name"]==t:
+                        data2 = s["url"].encode("utf8")
+                        break
+                if data2: break
+            return (title,data2,"",desc)
+
+        ### VOD genres ###
+        elif path in ("vod","vod/genres"):
+            data = "vod/genres"
+            js = self.call(data)
+            for gr in js["response"]:
+                title = gr["name"].encode("utf8")
+                data2 = "vod/search?genre=%s&max_results=30&no_episode=true&start_index=0"%(gr["slug"].encode("utf8"))
+                img = gr["images"][0]["url"].encode("utf8")
+                desc = gr["description"].encode("utf8") if gr["description"] else title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content           
+
+        ### VOD genre videos ###
+        elif path == "vod/search":
+            js = self.call(data)
+            for vid in js["response"]:
+                title = vid["title"].encode("utf8")
+                if vid["type"]=="series":
+                    title = "[Series] "+title
+                data2 = "vod/movie?id=%s&type=%s"%(vid["id"],vid["type"].encode("utf8"))
+                img = "http://static.filmon.com/assets/"+vid["poster"]["couchdb_url"].encode("utf8")
+                desc = vid["description"].encode("utf8") if vid["description"] else title
+                content.append((title,self.name+"::"+data2,img,desc))
+            start_index = int(qs["start_index"]) if "start_index" in qs else 0
+            if start_index+js["total"]<js["total_found"]:
+                start_index += 30
+                data2 = re.sub("start_index=\d+","start_index=%s"%start_index,data) if "start_index" in qs else data +"&start_index=30"
+                content.append(("Next page",self.name+"::"+data2,"","Next page"))                                            
+            return content
+
+        ### VOD video sigle/series ###
+        elif path == "vod/movie":
+            js = self.call(data)
+            if js["response"]["type"] == "series":
+                ids = ",".join(js["response"]["episodes"])
+                data2 = "vod/movies?ids=%s"%ids
+                js2 = self.call(data2)
+                for vid in js2["response"]:
+                    title = vid["title"].encode("utf8")
+                    if vid["type"]=="series":
+                        title = "[Series] "+title
+                    data2 = "vod/movie?id=%s&type=%s"%(vid["id"],vid["type"].encode("utf8"))
+                    img = "http://static.filmon.com/assets/"+vid["poster"]["couchdb_url"].encode("utf8")
+                    desc = vid["description"].encode("utf8") if vid["description"] else title
+                    content.append((title,self.name+"::"+data2,img,desc))
+                return content
+            else:
+                title = js["response"]["title"].encode("utf8")
+                desc = js["response"]["description"].encode("utf8") if js["response"]["description"] else title
+                data2 = js["response"]["streams"]["low"]["url"].encode("utf8")
+                return (title,data2,"",desc)
+
+    def is_video(self,data):
+        if "::" in data:
+            data = data.split("::")[1]
+        cmd = data.split("?")
+        if cmd[0] in ("video","channel"):
+            return True
+        elif cmd[0] == "vod/movie" and "type=movie" in data:
+            return True
+        else:
+            return False
+
+    def call(self, data,headers=headers0,lang=""):
+        if not lang: lang = self.country
+        url = "http://www.filmon.com/api/" + data
+        #if not "?" in url: url += "?session_key=%s"%self.session_key
+        #if not "session_key=" in url: url += "&session_key=%s"%self.session_key
+        #print "[TVPlay Api] url: ",url
+        result = []
+        content = self._http_request(url)
+        if content:
+            try:
+                result = json.loads(content)
+            except Exception, ex:
+                return None
+        return result
+
+    #----------------------------------------------------------------------
+    def get_tv_channel_info(self,id):
+        url = "http://www.filmon.com/ajax/getChannelInfo"
+        headers = headers2dict("""
+Host: www.filmon.com
+User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:41.0) Gecko/20100101 Firefox/41.0
+Accept: application/json, text/javascript, */*; q=0.01
+Accept-Language: en-US,en;q=0.5
+Accept-Encoding: deflate
+DNT: 1
+Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+X-Requested-With: XMLHttpRequest
+Referer: http://www.filmon.com/tv/live
+Connection: keep-alive
+Pragma: no-cache
+Cache-Control: no-cache
+""")
+        headers["Cookie"] = self.cookie
+        data = "channel_id=%s&quality=low"%id
+        response = urllib2.urlopen(urllib2.Request(url, headers=headers,data=data))
+        html =  response.read()
+        js = json.loads(html)
+        return js
+
+    #----------------------------------------------------------------------
+    def get_tv_channels(self):
+        """Get tv channels list"""
+        headers = headers2dict("""
+Host: www.filmon.com
+User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:41.0) Gecko/20100101 Firefox/41.0
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-US,en;q=0.5
+Accept-Encoding: deflate
+DNT: 1
+Connection: keep-alive
+    """)
+
+        url = "http://www.filmon.com/tv"
+        response = urllib2.urlopen(urllib2.Request(url, headers=headers))
+        if "set-cookie" in response.headers:
+            self.cookie = response.headers["set-cookie"]
+        html =  response.read()
+        s = re.search("(?i)var groups = (.*);", html).groups(1)[0]
+        js = json.loads(s)
+        return js
+
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

resources/lib/sources0/iplayer.cfg

@@ -0,0 +1,4 @@
+[iplayer]
+user = lietotajs
+password = parole
+

resources/lib/sources0/iplayer.py

@@ -0,0 +1,524 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+import sys, os, os.path, re, sys
+import urllib,urllib2
+from xml.sax.saxutils import unescape,escape
+from urllib import quote, unquote
+import datetime
+import HTMLParser
+import json
+import datetime,time
+from SourceBase import SourceBase, stream_type
+import util
+from collections import OrderedDict
+
+API_URL = 'https://m.lattelecom.tv/'
+user_agent = "Mozilla/5.0 (iPhone; U; CPU iPhone OS 5_1_1 like Mac OS X; da-dk) AppleWebKit/534.46.0 (KHTML, like Gecko) CriOS/19.0.1084.60 Mobile/9B206 Safari/7534.48.3"
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+h = HTMLParser.HTMLParser()
+
+class Source(SourceBase):
+
+    def __init__(self):
+        self.name = "iplayer"
+        self.title = "BBC iPlayer"
+        self.img = "http://www.userlogos.org/files/logos/inductiveload/BBC_iPlayer_logo.png"
+        self.desc = "BBC iPlayer portal content"
+
+        self.api_url = "http://ibl.api.bbci.co.uk/ibl/v1/"
+        self.headers = headers2dict("""
+User-Agent: BBCiPlayer/4.19.0.3021 (SM-G900FD; Android 4.4.2)
+Connection: Keep-Alive
+        """)
+        self.headers2 = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36
+Connection: Keep-Alive
+        """)
+
+        self.ch = []
+        self.ch_id={}
+        self.ch_id2={}
+        self.ch_name={}
+        self.logos ={
+            "bbc_one_london":"http://www.lyngsat-logo.com/hires/bb/bbc_one.png",
+            "bbc_two_england":"http://www.lyngsat-logo.com/hires/bb/bbc_two_uk.png",
+            "bbc_three":"http://www.lyngsat-logo.com/hires/bb/bbc_three_uk.png",
+            "bbc_four":"http://www.lyngsat-logo.com/hires/bb/bbc_four_uk.png",
+            "bbc_radio_one":"http://www.lyngsat-logo.com/hires/bb/bbc_radio1.png",
+            "cbbc":"http://www.lyngsat-logo.com/hires/bb/bbc_cbbc.png",
+            "cbeebies":"http://www.lyngsat-logo.com/hires/bb/bbc_cbeebies_uk.png",
+            "bbc_news24":"http://www.lyngsat-logo.com/hires/bb/bbc_news.png",
+            "bbc_parliament":"http://www.lyngsat-logo.com/hires/bb/bbc_parliament.png",
+            "bbc_alba":"http://www.lyngsat-logo.com/hires/bb/bbc_alba.png",
+            "s4cpbs":"http://www.lyngsat-logo.com/hires/ss/s4c_uk.png"
+        }
+        cur_directory = os.path.dirname(os.path.abspath(__file__))
+        self.config_file = os.path.join(cur_directory,self.name+".cfg")
+        self.options = OrderedDict([("user","lietotajs"),("password","parole")])
+        self.options_read()
+
+    def get_content(self, data):
+        print "[iplayer] get_content:", data
+        if "::" in data:
+            data = data.split("::")[1]
+        path = data.split("?")[0]
+        clist = path.split("/")[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        qs = dict(map(lambda x:x.split("="),re.findall("\w+=[\w-]+",params)))
+        #lang = qs["lang"] if "lang" in qs else self.country
+
+        content=[]
+        content.append(("..return", "back","","Return back"))
+
+        ### Home ###
+        if data=="home":
+            content.extend([
+                ("Search TV", "iplayer::search/{0}","","Search in iPlayer"),
+                ("Live streams", "iplayer::live","","TV live streams"),
+                ("Channels", "iplayer::channels","","Programmes by channel/date"),
+                ("Categories", "iplayer::categories","","Programmes by categories"),
+                ("A-Z", "iplayer::a-z","","All programmes by name"),
+                ("Highlights", "iplayer::home/highlights","","Current highlights"),
+                ("Most popular", "iplayer::groups/popular/episodes?per_page=40&page=1","","Most popular programmes")
+            ])
+            return content
+
+        ### Search ###
+        elif clist=="search":
+            data_ = "search-suggest/?q=%s&rights=mobile&initial_child_count=1"%data.split("/")[1]
+            r = self.call(data_)
+            for item in r["search_suggest"]["results"]:
+                title,data2,img,desc = self.get_data_element(item)
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+
+        ### Live main ###
+        elif data=="live":
+            for ch in self.get_channels():
+                title = ch["title"]
+                img = self.logos[ch["id"]] if ch["id"] in self.logos else  "http://static.bbci.co.uk/mobileiplayerappbranding/1.9/android/images/channels/tv-guide-wide-logo/layout_normal/xxhdpi/%s_tv-guide-wide-logo.png"%ch["id"]
+                desc = title
+                data2 = "live/%s"%ch["id"]
+                ee = self.get_epg_live(ch["id"])
+                desc = ee[2]
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Categories ###
+        elif data == "categories":
+            r = self.call(data)
+            if not "categories":
+                raise Exception("Error reading categories")
+            for item in r["categories"]:
+                data2 = "categories/%s"%(item["id"])
+                title = item["title"]
+                desc = title
+                img = self.img
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Catetory root ###
+        elif clist == "categories" and len(data.split("/"))==2:
+            r = self.call(data)
+            title = "%s - highlights"%r["category"]["title"]
+            content.append((title,self.name+"::"+data+"/highlights?lang=en&rights=mobile&availability=available",self.img,title))
+            title = "%s - recent (%s programmes, %s episodes)"%(r["category"]["title"],r["category"]["child_programme_count"],r["category"]["child_episode_count"])
+            content.append((title,self.name+"::"+data+"/programmes?rights=mobile&page=1&per_page=40&sort=recent&sort_direction=asc&initial_child_count=1&availability=available",self.img,title))
+            title = "%s - a-z (%s programmes, %s episodes)"%(r["category"]["title"],r["category"]["child_programme_count"],r["category"]["child_episode_count"])
+            content.append((title,self.name+"::"+data+"/programmes?rights=mobile&page=1&per_page=40&sort=title&sort_direction=asc&initial_child_count=1&availability=available",self.img,title))
+            return content
+
+        ### Program/episodes list ###
+        elif   re.search("categories/([\w\-]+)/(highlights|programmes).+",data) or\
+               re.search("programmes/(\w+)/episodes.+",data) or\
+               re.search("groups/(\w+)/episodes.+",data) or\
+               re.search("atoz/([\w]+)/programmes.+",data) or\
+               re.search("channels/(\w+)/schedule/[\d\-].+",data) or\
+               re.search("channels/(\w+)/programmes.+",data) or\
+               re.search("channels/(\w+)/highlights.+",data) or\
+               data == "home/highlights":
+            r = self.call(data)
+            lst = r["category_highlights"] if "category_highlights" in r else\
+                  r["category_programmes"] if "category_programmes" in r else\
+                  r["programme_episodes"] if "programme_episodes" in r else\
+                  r["atoz_programmes"] if "atoz_programmes" in r else\
+                  r["group_episodes"] if "group_episodes" in r else\
+                  r["schedule"] if "schedule" in r else\
+                  r["channel_highlights"] if "channel_highlights" in r else\
+                  r["channel_programmes"] if "channel_programmes" in r else\
+                  r["home_highlights"] if "home_highlights" in r else\
+                  []
+            if not lst:
+                return content
+            for el in lst["elements"]:
+                if el["type"] == "broadcast":
+                    if not len(el["episode"]["versions"]):continue
+                    title,data2,img,desc = self.get_data_element(el["episode"])
+                    t1 = gt(el['scheduled_start'])
+                    t2 = gt(el['scheduled_end'])
+                    title = "[%s-%s]%s"%(t1.strftime("%d.%m.%Y %H:%M"),t2.strftime("%H:%M"),title)
+                else:
+                    title,data2,img,desc = self.get_data_element(el)
+                content.append((title,self.name+"::"+data2,img,desc))
+
+            if "&page=" in data and lst["page"]*lst["per_page"]<lst["count"]:
+                data2 = re.sub("&page=\d+","&page=%s"%(lst["page"]+1),data)
+                content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))
+            return content
+
+        ### A-z root ###
+        elif data=="a-z":
+            url = "http://www.bbc.co.uk/programmes/a-z/by/x/all.json?page=1"
+            r = self._http_request(url)
+            if not r:
+                raise Exception("Can not read %s"%s)
+            js = json.loads(r)
+            for ch in js["atoz"]["letters"]:
+                title = ch.upper()
+                desc = "Programmes beginning with %s"%title
+                img = self.img
+                data2 = "atoz/%s/programmes?rights=mobile&page=1&per_page=40&initial_child_count=1&sort=title&sort_direction=asc&availability=available"%ch
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ###  Channels home ###
+        elif data=="channels":
+            for ch in self.get_channels():
+                title = ch["title"]
+                img = self.logos[ch["id"]] if ch["id"] in self.logos else  "http://static.bbci.co.uk/mobileiplayerappbranding/1.9/android/images/channels/tv-guide-wide-logo/layout_normal/xxhdpi/%s_tv-guide-wide-logo.png"%ch["id"]
+                desc = title
+                data2 = "channels/%s"%ch["id"]
+                #ee = self.get_epg_live(ch["id"])
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Channel higlihts/progrmmes/days ###
+        elif clist=="channels" and len(data.split("/"))==2:
+            r = self.call(data)
+            chid = data.split("/")[1]
+            ch = self.get_channel_by_id(chid)
+
+            # Highlights
+            title = ch["title"] + " - highlights"
+            img = "http://static.bbci.co.uk/mobileiplayerappbranding/1.9/android/images/channels/tv-guide-wide-logo/layout_normal/xxhdpi/%s_tv-guide-wide-logo.png"%ch["id"]
+            data2 = "channels/%s/highlights?lang=en&rights=mobile&availability=available"%ch["id"]
+            desc = title
+            content.append((title,self.name+"::"+data2,img,desc))
+
+            #AtoZ
+            title = ch["title"] + " - programmes AtoZ"
+            data2 = "channels/%s/programmes?rights=mobile&page=1&per_page=40&sort=recent&sort_direction=asc&initial_child_count=1&availability=available"%ch["id"]
+            desc = title
+            content.append((title,self.name+"::"+data2,img,desc))
+
+            day0 = datetime.date.today()
+            for i in range(10):
+                day = day0-datetime.timedelta(days=i)
+                days = day.strftime("%Y-%m-%d")
+                title = ch["title"] + " - " + days
+                img = "http://static.bbci.co.uk/mobileiplayerappbranding/1.9/android/images/channels/tv-guide-wide-logo/layout_normal/xxhdpi/%s_tv-guide-wide-logo.png"%ch["id"]
+                data2 = "channels/%s/schedule/%s?availability=available"%(ch["id"],days)
+                #ee = self.get_epg_live(ch["id"])
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+
+    def get_streams(self, data):
+        print "[iplayer] get_streams:", data
+        if "::" in data: data = data.split("::")[1]
+        if not self.is_video(data):
+            return []
+        cmd = data.split("/")
+        vid = cmd[1].split("?")[0]
+        if cmd[0] == "live":
+            title,img,desc = self.get_epg_live(vid)
+        else:
+            data_ = "episodes/%s"%vid
+            r = self.call(data_)
+            title,img,desc,vid = self.get_epg_video(vid)
+        url = "http://open.live.bbc.co.uk/mediaselector/5/select/version/2.0/format/json/mediaset/iptv-all/vpid/%s"%vid
+        print "vid=%s"%vid
+        print url
+        r = self._http_request(url) #,headers=self.headers2
+        if not r:
+            raise Exception("No streams found")
+        js = json.loads(r)
+        if "result" in js and js["result"]=="geolocation":
+            raise Exception("BBC iPlayer service available only from UK")
+        if not "media" in js:
+            raise Exception("No streams found")
+        streams = []
+        captions = []
+        for s in js["media"]:
+            if s["kind"] == "captions":
+                if s["connection"][0]["href"]:
+                    sub = {}
+                    sub["url"] = s["connection"][0]["href"].encode('utf8')
+                    sub["type"] = s["type"]
+                    sub["name"] = s["service"] if "service" in s else "captions (taff)"
+                    sub["lang"] = "en"
+                    captions.append(sub)
+
+            if s["kind"] <> "video":
+                continue
+            for c in s["connection"]:
+                if c["transferFormat"] <> "hls": continue
+                #if not (c["supplier"].startswith("mf_") or c["supplier"].startswith("ll_")) : continue # TODO ir kaut kādas VPN problēmas ar akamaihd
+                #if c["priority"] <> "1": continue
+                url=c["href"].encode("utf8")
+                r2 = self._http_request(url)
+                if not r2: continue
+                slist = re.findall("#EXT-X-STREAM-INF:([^\n]+)\n([^\n]+)", r2, re.DOTALL)
+                if not slist:
+                    stream = util.item()
+                    stream["url"]=url
+                    stream["name"]=title
+                    stream["desc"]=desc
+                    stream["img"]=img
+                    stream["type"]="hls"
+                    stream["quality"]=("%s %sx%s %s,%s"%(s["bitrate"],s["width"],s["height"],c["supplier"],c["priority"])).encode("utf8")
+                    stream["lang"]="en"
+                    stream["subs"]=captions
+                    stream["order"]=int(s["bitrate"])
+                    streams.append(stream)
+                else:
+                    for cc in slist:
+                        m = re.search("RESOLUTION=([\dx]+)",cc[0])
+                        resolution = m.group(1) if m else "%sx%s"%(s["width"],s["height"])
+                        m = re.search("BANDWIDTH=([\d]+)",cc[0])
+                        bitrate = m.group(1) if m else s["bitrate"]
+                        url2 = cc[1].encode("utf8")
+                        if not url2.startswith("http"):
+                            uu = url.split("/")[:-1]
+                            uu.append(url2)
+                            url2 = "/".join(uu)
+                        stream = util.item()
+                        stream["url"]=url2
+                        stream["name"]=title
+                        stream["desc"]=desc
+                        stream["img"]=img
+                        stream["type"]="hls"
+                        stream["quality"]=("%s %s %s,%s"%(bitrate,resolution,c["supplier"],c["priority"])).encode("utf8")
+                        stream["lang"]="en"
+                        stream["subs"]=captions
+                        stream["order"]=int(bitrate)
+                        streams.append(stream)
+        if captions:
+            for s in streams:
+                s["subs"]=captions
+        streams = sorted(streams,key=lambda item: item["order"],reverse=True)
+        return streams
+
+    def is_video(self,data):
+        if "::" in data:
+            data = data.split("::")[1]
+        cmd = data.split("/")
+        if cmd[0]=="live" and  len(cmd)==2:
+            return True
+        elif cmd[0]=="episodes" and len(cmd)==2:
+            return True
+        else:
+            return False
+
+    def get_data_element(self,item):
+        if ("programme" in item["type"] or "group" in item["type"]) and item["count"]>1:
+            ep = item.copy()
+        elif ("programme" in item["type"] or "group" in item["type"]) and item["count"]==1:
+            ep = item["initial_children"][0].copy()
+        elif item["type"] == "episode":
+            ep = item.copy()
+        elif item["type"] == "broadcast":
+            ep = item["episode"].copy()
+        else:
+            ep = item.copy()
+        title = ep["title"]
+        if "subtitle" in ep and ep["subtitle"]:
+            title = title+". "+ ep["subtitle"]
+        desc = ep["synopses"]["large"] if "large" in ep["synopses"] else ep["synopses"]["medium"] if "medium" in ep["synopses"] else ep["synopses"]["small"]
+        #TODO papildus info pie apraksta
+        img = ep["images"]["standard"].replace("{recipe}","512x288") if "images" in ep else self.img
+        if ep["type"] == "episode":
+            data2 = "episodes/%s"%ep["id"]
+        elif "programme" in ep["type"]:
+            data2 = "programmes/%s/episodes?per_page=40&page=1"%ep["id"]
+            title = "%s [%s episodes]"%(title,ep["count"])
+        elif "group" in ep["type"]:
+            data2 = "groups/%s/episodes?per_page=40&page=1"%ep["id"]
+            title = "%s [%s episodes]"%(title,ep["count"])
+        else:
+            data2 = "programmes/%s/episodes?per_page=40&page=1"%ep["id"]
+            title = "%s [%s episodes]"%(title,ep["count"])
+        return title,data2,img,desc
+
+    def get_epg_video(self,vid):
+        data = "episodes/%s"%vid
+        r = self.call(data)
+        if "episodes" in r :
+            ep = r["episodes"][0]
+            title = ep["title"]
+            if "subtitle" in ep:
+                title = title +". "+ ep["subtitle"]
+            title = title
+            desc = ep["synopses"]["medium"] if "medium" in ep["synopses"] else p["synopses"]["small"] if "small" in ep["synopses"] else title
+            desc = desc
+            ver = ep["versions"][0]
+            vid = ver["id"]
+            remaining = ver["availability"]["remaining"]["text"]
+            duration = ver["duration"]
+            first_broadcast = ver["first_broadcast"]
+            desc =u"%s\n%s\%s\n%s\n%s"%(title,duration,remaining,first_broadcast,desc)
+            img = ep["images"]["standard"].replace("{recipe}","512x288")
+            return title.encode("utf8"),img.encode("utf8"),desc.encode("utf8"),vid.encode("utf8")
+        else:
+            raise Exception("No video info")
+
+    def get_epg_live(self,channelid):
+        data = "channels/%s/highlights?live=true"%channelid
+        r = self.call(data)
+        if "channel_highlights" in r and r["channel_highlights"]["elements"][0]["id"] == "live":
+            epg = r["channel_highlights"]["elements"][0]["initial_children"][0].copy()
+            t1 = gt(epg['scheduled_start'])
+            t2 = gt(epg['scheduled_end'])
+            ep = epg["episode"]
+            title = ep["title"]
+            if "subtitle" in ep:
+                title = title +". "+ ep["subtitle"]
+            title = "%s (%s-%s)"%(title,t1.strftime("%H:%M"),t2.strftime("%H:%M"))
+            title = title
+            desc = ep["synopses"]["medium"] if "medium" in ep["synopses"] else p["synopses"]["small"] if "small" in ep["synopses"] else title
+            desc = desc
+            desc ="%s\n%s"%(title,desc)
+            img = ep["images"]["standard"].replace("{recipe}","512x288")
+            #return title,img,desc
+        else:
+            title = r["channel_highlights"]["channel"]["title"]
+            img = ""
+            desc = title
+
+        return title.encode("utf8"),img.encode("utf8"),desc.encode("utf8")
+
+    def get_channels(self):
+        if self.ch:
+            return self.ch
+        r= self.call("channels")
+        self.ch=[]
+        for i,item in enumerate(r["channels"]):
+            self.ch.append(item)
+            self.ch_id[item["id"]]=i
+            self.ch_id2[item["master_brand_id"]]=i
+            self.ch_name[item["title"]]=i
+        return self.ch
+
+    def get_channel_by_id(self,chid):
+        if not self.ch:
+            self.get_channels()
+        if not self.ch:
+            return None
+        return self.ch[self.ch_id[chid]] if self.ch_id.has_key(chid) else None
+
+    def get_channel_by_id2(self,chid):
+        if not self.ch:
+            self.get_channels()
+        if not self.ch:
+            return None
+        return self.ch[self.ch_id2[chid]] if self.ch_id2.has_key(chid) else None
+
+    def get_channel_by_name(self,name):
+        if not self.ch:
+            self.get_channels()
+        ch2 = self.get_channel_by_name2(name)
+        if not ch2:
+            return None
+        ch = self.get_channel_by_id2(ch2["id2"])
+        return ch
+
+
+    def call(self, data,params = None, headers=None):
+        if not headers: headers = self.headers
+        #if not lang: lang = self.country
+        url = self.api_url + data
+        content = self._http_request(url,params, headers)
+        if content:
+            try:
+                result = json.loads(content)
+                return result
+            except Exception, ex:
+                return None
+        else:
+            return None
+
+    def call2(self, data,params = None, headers=None):
+        if not headers: headers = self.headers2
+        #if not lang: lang = self.country
+        url = self.api_url2 + data
+        content = self._http_request(url,params, headers)
+        return content
+
+    def _http_request(self, url,params = None, headers=None):
+        if not headers: headers = self.headers
+        import requests
+        try:
+            r = requests.get(url, headers=headers)
+            return r.content
+
+        except Exception as ex:
+            if ex.code==403:
+                return ex.read()
+            else:
+                return None
+
+def gt(dt_str):
+    dt, _, us= dt_str.partition(".")
+    dt= datetime.datetime.strptime(dt, "%Y-%m-%dT%H:%M:%S")
+    dt = dt - datetime.timedelta(seconds=time.altzone)
+    #us= int(us.rstrip("Z"), 10)
+    #r = dt + datetime.timedelta(microseconds=us)a
+    return dt
+
+if __name__ == "__main__":
+    c = Source()
+    from subprocess import call
+    #ch = c.get_channels()
+    #c.get_epg_live("bbc_two_england")
+
+    if len(sys.argv)>1 and  not "iplayer::" in sys.argv[1]:
+
+        vid = sys.argv[1]
+        print "login - %s"%c.login("ivars777","xxx")
+        vid = "1069"
+        vid = "1462566072086"
+        channelid="101"
+        vid = "1350462656767"
+        #data = c.get_stream_url(vid,"vod")
+        #call([r"c:\Program Files\VideoLAN\VLC\vlc.exe",data["stream"]])
+        pass
+
+
+
+    else:
+        if len(sys.argv)>1:
+            data= sys.argv[1]
+        else:
+            data = "iplayer::home"
+        content = c.get_content(data)
+        for item in content:
+            print item
+        #cat = api.get_categories(country)
+        #chan = api.get_channels("lv")
+        #prog = api.get_programs(channel=6400)
+        #prog = api.get_programs(category=55)
+        #seas = api.get_seasons(program=6453)
+        #str = api.get_streams(660243)
+        #res = api.get_videos(802)
+        #formats = api.getAllFormats()
+        #det = api.detailed("1516")
+        #vid = api.getVideos("13170")
+        pass

resources/lib/sources0/jsinterp.py

@@ -0,0 +1,261 @@
+# This code comes from youtube-dl: https://github.com/rg3/youtube-dl/blob/master/youtube_dl/jsinterp.py
+
+from __future__ import unicode_literals
+
+import json
+import operator
+import re
+
+
+_OPERATORS = [
+    ('|', operator.or_),
+    ('^', operator.xor),
+    ('&', operator.and_),
+    ('>>', operator.rshift),
+    ('<<', operator.lshift),
+    ('-', operator.sub),
+    ('+', operator.add),
+    ('%', operator.mod),
+    ('/', operator.truediv),
+    ('*', operator.mul),
+]
+_ASSIGN_OPERATORS = [(op + '=', opfunc) for op, opfunc in _OPERATORS]
+_ASSIGN_OPERATORS.append(('=', lambda cur, right: right))
+
+_NAME_RE = r'[a-zA-Z_$][a-zA-Z_$0-9]*'
+
+
+class JSInterpreter(object):
+    def __init__(self, code, objects=None):
+        if objects is None:
+            objects = {}
+        self.code = code
+        self._functions = {}
+        self._objects = objects
+
+    def interpret_statement(self, stmt, local_vars, allow_recursion=100):
+        if allow_recursion < 0:
+            print '[JSInterpreter] Recursion limit reached'
+            return None
+
+        should_abort = False
+        stmt = stmt.lstrip()
+        stmt_m = re.match(r'var\s', stmt)
+        if stmt_m:
+            expr = stmt[len(stmt_m.group(0)):]
+        else:
+            return_m = re.match(r'return(?:\s+|$)', stmt)
+            if return_m:
+                expr = stmt[len(return_m.group(0)):]
+                should_abort = True
+            else:
+                # Try interpreting it as an expression
+                expr = stmt
+
+        v = self.interpret_expression(expr, local_vars, allow_recursion)
+        return v, should_abort
+
+    def interpret_expression(self, expr, local_vars, allow_recursion):
+        expr = expr.strip()
+
+        if expr == '':  # Empty expression
+            return None
+
+        if expr.startswith('('):
+            parens_count = 0
+            for m in re.finditer(r'[()]', expr):
+                if m.group(0) == '(':
+                    parens_count += 1
+                else:
+                    parens_count -= 1
+                    if parens_count == 0:
+                        sub_expr = expr[1:m.start()]
+                        sub_result = self.interpret_expression(
+                            sub_expr, local_vars, allow_recursion)
+                        remaining_expr = expr[m.end():].strip()
+                        if not remaining_expr:
+                            return sub_result
+                        else:
+                            expr = json.dumps(sub_result) + remaining_expr
+                        break
+            else:
+                print '[JSInterpreter] Premature end of parens in %r' % expr
+                return None
+
+        for op, opfunc in _ASSIGN_OPERATORS:
+            m = re.match(r'''(?x)
+                (?P<out>%s)(?:\[(?P<index>[^\]]+?)\])?
+                \s*%s
+                (?P<expr>.*)$''' % (_NAME_RE, re.escape(op)), expr)
+            if not m:
+                continue
+            right_val = self.interpret_expression(
+                m.group('expr'), local_vars, allow_recursion - 1)
+
+            if m.groupdict().get('index'):
+                lvar = local_vars[m.group('out')]
+                idx = self.interpret_expression(
+                    m.group('index'), local_vars, allow_recursion)
+                assert isinstance(idx, int)
+                cur = lvar[idx]
+                val = opfunc(cur, right_val)
+                lvar[idx] = val
+                return val
+            else:
+                cur = local_vars.get(m.group('out'))
+                val = opfunc(cur, right_val)
+                local_vars[m.group('out')] = val
+                return val
+
+        if expr.isdigit():
+            return int(expr)
+
+        var_m = re.match(
+            r'(?!if|return|true|false)(?P<name>%s)$' % _NAME_RE,
+            expr)
+        if var_m:
+            return local_vars[var_m.group('name')]
+
+        try:
+            return json.loads(expr)
+        except ValueError:
+            pass
+
+        m = re.match(
+            r'(?P<var>%s)\.(?P<member>[^(]+)(?:\(+(?P<args>[^()]*)\))?$' % _NAME_RE,
+            expr)
+        if m:
+            variable = m.group('var')
+            member = m.group('member')
+            arg_str = m.group('args')
+
+            if variable in local_vars:
+                obj = local_vars[variable]
+            else:
+                if variable not in self._objects:
+                    self._objects[variable] = self.extract_object(variable)
+                obj = self._objects[variable]
+
+            if arg_str is None:
+                # Member access
+                if member == 'length':
+                    return len(obj)
+                return obj[member]
+
+            assert expr.endswith(')')
+            # Function call
+            if arg_str == '':
+                argvals = tuple()
+            else:
+                argvals = tuple([
+                    self.interpret_expression(v, local_vars, allow_recursion)
+                    for v in arg_str.split(',')])
+
+            if member == 'split':
+                assert argvals == ('',)
+                return list(obj)
+            if member == 'join':
+                assert len(argvals) == 1
+                return argvals[0].join(obj)
+            if member == 'reverse':
+                assert len(argvals) == 0
+                obj.reverse()
+                return obj
+            if member == 'slice':
+                assert len(argvals) == 1
+                return obj[argvals[0]:]
+            if member == 'splice':
+                assert isinstance(obj, list)
+                index, howMany = argvals
+                res = []
+                for i in range(index, min(index + howMany, len(obj))):
+                    res.append(obj.pop(index))
+                return res
+
+            return obj[member](argvals)
+
+        m = re.match(
+            r'(?P<in>%s)\[(?P<idx>.+)\]$' % _NAME_RE, expr)
+        if m:
+            val = local_vars[m.group('in')]
+            idx = self.interpret_expression(
+                m.group('idx'), local_vars, allow_recursion - 1)
+            return val[idx]
+
+        for op, opfunc in _OPERATORS:
+            m = re.match(r'(?P<x>.+?)%s(?P<y>.+)' % re.escape(op), expr)
+            if not m:
+                continue
+            x, abort = self.interpret_statement(
+                m.group('x'), local_vars, allow_recursion - 1)
+            if abort:
+                print '[JSInterpreter] Premature left-side return of %s in %r' % (op, expr)
+                return None
+            y, abort = self.interpret_statement(
+                m.group('y'), local_vars, allow_recursion - 1)
+            if abort:
+                print '[JSInterpreter] Premature right-side return of %s in %r' % (op, expr)
+                return None
+            return opfunc(x, y)
+
+        m = re.match(
+            r'^(?P<func>%s)\((?P<args>[a-zA-Z0-9_$,]+)\)$' % _NAME_RE, expr)
+        if m:
+            fname = m.group('func')
+            argvals = tuple([
+                int(v) if v.isdigit() else local_vars[v]
+                for v in m.group('args').split(',')])
+            if fname not in self._functions:
+                self._functions[fname] = self.extract_function(fname)
+            return self._functions[fname](argvals)
+
+        print '[JSInterpreter] Unsupported JS expression %r' % expr
+        return None
+
+    def extract_object(self, objname):
+        obj = {}
+        obj_m = re.search(
+            (r'(?:var\s+)?%s\s*=\s*\{' % re.escape(objname)) +
+            r'\s*(?P<fields>([a-zA-Z$0-9]+\s*:\s*function\(.*?\)\s*\{.*?\}(?:,\s*)?)*)' +
+            r'\}\s*;',
+            self.code)
+        fields = obj_m.group('fields')
+        # Currently, it only supports function definitions
+        fields_m = re.finditer(
+            r'(?P<key>[a-zA-Z$0-9]+)\s*:\s*function'
+            r'\((?P<args>[a-z,]+)\){(?P<code>[^}]+)}',
+            fields)
+        for f in fields_m:
+            argnames = f.group('args').split(',')
+            obj[f.group('key')] = self.build_function(argnames, f.group('code'))
+
+        return obj
+
+    def extract_function(self, funcname):
+        func_m = re.search(
+            r'''(?x)
+                (?:function\s+%s|[{;,]%s\s*=\s*function|var\s+%s\s*=\s*function)\s*
+                \((?P<args>[^)]*)\)\s*
+                \{(?P<code>[^}]+)\}''' % (
+                re.escape(funcname), re.escape(funcname), re.escape(funcname)),
+            self.code)
+        if func_m is None:
+            print '[JSInterpreter] Could not find JS function %r' % funcname
+            return None
+        argnames = func_m.group('args').split(',')
+
+        return self.build_function(argnames, func_m.group('code'))
+
+    def call_function(self, funcname, *args):
+        f = self.extract_function(funcname)
+        return f(args)
+
+    def build_function(self, argnames, code):
+        def resf(args):
+            local_vars = dict(zip(argnames, args))
+            for stmt in code.split(';'):
+                res, abort = self.interpret_statement(stmt, local_vars)
+                if abort:
+                    break
+            return res
+        return resf

resources/lib/sources0/ltc.cfg

@@ -0,0 +1,4 @@
+[ltc]
+user = lietotajs
+password = parole
+

resources/lib/sources0/movieplace.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+import urllib2, urllib
+import datetime, re, sys,os
+import ConfigParser
+from collections import OrderedDict
+from SourceBase import SourceBase
+import resolver
+try:
+    import util
+except:
+    sys.path.insert(0,'..')
+    import util
+
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+import HTMLParser
+h = HTMLParser.HTMLParser()
+
+class Source(SourceBase):
+
+    def __init__(self, country=""):
+        self.name = "movieplace"
+        self.title = "MoviePlace.lv"
+        self.img = "http://movieplace.lv/images/logo.png"
+        self.desc = "Movieplace.lv - filmas latviesu valodā"
+        self.headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-US,en;q=0.5
+""")
+        self.headers2 = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0
+X-Requested-With: XMLHttpRequest
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+""")
+        self.url = "http://movieplace.lv/"
+
+
+    ######### Entry point ########
+    def get_content(self, data):
+        print "[movieplace] get_content:", data
+        source, data, path, plist, clist, params, qs = self.parse_data(data)
+        content = []
+        content.append(("..return", "back","","Return back"))
+
+        if clist=="home":
+            content.extend([
+                ("Meklēt", "movieplace::search/?q={0}","","Meklēt"),
+                ("Jaunākās filmas", "movieplace::load/?page1","","Visu žanru jaunākās filmas"),
+                ("Jaunākie seriāli", "movieplace::dir/?page1","","Visu žanru jaunākās filmas"),
+                #("Top50 filmas", "movieplace::index/top_50_filmas/0-4","","Top 50 filmas"),
+            ])
+            r = self.call("load/")
+            #i = r.find('<div class="cat-title">Meklēt pēc žanriem</div>')
+            #if i<=0:
+            #    return content
+            i = 0
+            for item in re.findall('<a href="/([^"]+)" class="catName">([^>]+)</a>', r[i:]):
+                title = item[1]
+                data2 = item[0]+"-1"
+                img = self.img
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        elif clist=="search":
+            # TODO
+            r=self.call(data)
+            result = re.findall('<a href="([^"]+)"> (.+?) </a></div>.+?> (.+?)</div>', r, re.DOTALL)
+            for item in result:
+                title = item[1].replace("<b>","").replace("</b>","")
+                data2 = item[0].replace("http://movieplace.lv/","")
+                img = self.img
+                desc = item[2].replace("<b>","").replace("</b>","")
+                content.append((title,self.name+"::"+data2,img,desc))
+            if '<span>&raquo;</span>' in r:
+                m = re.search("p=(\d+)",data)
+                if m:
+                    page = int(m.group(1))+1
+                    data2 = re.sub(r"p=\d+", r"p=%s"%page, data)
+                    content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))
+            return content
+
+        # Filmu saraksti ##
+        elif clist in ["load","dir"] and len(plist)<=3:
+            if clist == "jaunakas":
+                r = self.call("")
+            else:
+                r = self.call(data)
+            #r = r.decode("cp1251").encode("utf8")
+            if clist == "load":
+                result = re.findall(r' <a href="/([^"]+)" alt="([^"]+)"><img src="/([^"]+)" title="([^"]+)">.+?<div class="years">([^<]+)</div>\s+<div class="country">([^<]+)</div>', r, re.DOTALL)
+            else:
+                result = re.findall(r' <a href="/([^"]+)" alt="([^"]+)"><img src="/([^"]+)" title="[^"]+">.+?<span>([^<]+)</span>\s*<div class="country">([^<]+)</div>', r, re.IGNORECASE | re.DOTALL)
+            for item in result:
+                title = item[1]+" [%s]"%item[4] if clist=="load" else item[1]+" / %s [%s]"%(item[3],item[4])
+                img = "http://movieplace.lv/"+item[2]
+                data2 = item[0]
+                desc = "%s\n%s"%(title,item[5]) if clist=="load" else title
+                content.append((title,self.name+"::"+data2,img,desc))
+            m = re.search('<[ab] class="swchItemA*1"( href="/([^"]+)" onclick="[^"]+")*><span>([^<]+)</span></[ab]> </span>', r, re.DOTALL)
+            if m:
+                if m.group(1):
+                    page = int(re.search("\d+$",data).group())
+                    page = page+1
+                    data2 = re.sub("\d$","%s"%page,data)
+                    content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))
+            return content
+
+        ### Seriāls ###
+        elif clist=="dir" and len(plist)==4:
+            r = self.call(path)
+            title0 = re.search('<h2 class="title" itemprop="name">(.+?)</h2>', r, re.DOTALL).group(1)
+            m = re.search(r'<span>VALODA:</span> <b><em itemprop="alternativeHeadline"><a href="[^"]*" class="entAllCats">([^<]+)</a></em></b></div>\s+?<div><span>SEZONA:</span> <b>([^<]+)</b></div>', r, re.IGNORECASE | re.DOTALL)
+            if m:
+                title0 = "%s / Season %s [%s]"%(title0,m.group(2),m.group(1))
+            desc0 = title0
+            img0 = "http://movieplace.lv" + re.search('<img src="(.+?)".+?itemprop="image">', r, re.DOTALL).group(1)
+            #TODO
+            result = re.findall(r'<summary>([^<]+)</summary><iframe src="https://openload\.co/embed/[^/]+/"', r, re.DOTALL)
+            i = 1
+            for item in result:
+                title = title0+" - " + item
+                data2 = data+"?e=%s"%i
+                img = img0
+                desc = desc0
+                content.append((title,self.name+"::"+data2,img,desc))
+                i += 1
+            return content
+
+        ### kaut kas neparedzets ###
+        else:
+            return content
+
+    def is_video(self,data):
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        if clist=="dir" and len(plist) == 4 and "e"in qs: # sērija
+            return True
+        elif clist=="load" and len(plist) == 4:
+            return True
+        else:
+            return False
+
+    def call(self, data,params=None,headers=None,lang=""):
+        if not headers: headers = self.headers
+        url = self.url+data
+        result = self._http_request(url,params,headers=headers)
+        return result
+
+    def get_streams(self,data):
+        print "[movieplace] get_streams:", data
+        if not self.is_video(data):
+            return []
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        r = self.call(path)
+        if clist=="load":
+            m = re.search('<h2 class="title" itemprop="name">([^<]+)</h2>', r, re.DOTALL)
+            title = re.search('<itemprop="name">(.+?)</itemprop="name">', r, re.DOTALL).group(1)
+            m = re.search(r'<div role="tabpanel" class="tab-pane fade in active" id="heading-tab4">\s*(.+?)\s*</div>', r, re.DOTALL)
+            desc = m.group(1) if m else title
+            m = re.search('<meta property="og:image" content="([^"]+)" />', r, re.DOTALL)
+            img = m.group(1) if m else ""
+            rr = []
+            for m in re.finditer("(RU|ENG|LAT|LAT SUB)<BR( /)*>.*?>?<BR( /)*>.*?<iframe", r, re.IGNORECASE | re.DOTALL):
+                if len(rr)>0:
+                    rr[-1]["end"] = m.start()
+                rr.append({"lang":m.group(1),"start":m.start(),"end":len(r)})
+            streams = []
+            for m in re.finditer(r'src="(https*://(goo\.gl|songs2dl|kodik|cdn\.kapnob|hqq|openload|sv1.servkino|vidwatch|online\.kinozz).+?)"', r, re.IGNORECASE | re.DOTALL):
+                url = m.group(1)
+                lang = "?"
+                for rrr in rr:
+                    if m.start()>rrr["start"] and m.start()<rrr["end"]:
+                        lang = rrr["lang"]
+                        break
+                for s in resolver.resolve(url):
+                    s["name"] = title
+                    s["desc"] = desc
+                    s["img"] = img
+                    s["type"] = self.stream_type(s["url"])
+                    s["lang"] = lang
+                    streams.append(s)
+            return streams
+
+
+        elif clist=="dir" and "e" in qs: # serialā sērija
+            #TODO
+            result = re.findall(r'<summary>([^<]+)</summary><iframe src="([^"]+)"', r, re.DOTALL)
+            i = int(qs["s"])-1
+            url0 = result[i][1]
+            title = title + " - " + result[i][0]
+        else:
+            #iframe src="https://openload.co/embed/wlw6Vl9zwL0/"
+            result = re.findall(r'<iframe src="([^"]+)"', r, re.DOTALL)
+            if not result:
+                return []
+            url0 = result[0]
+        return streams
+
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

resources/lib/sources0/mtgplay.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+
+
+try:
+    import json
+except:
+    import simplejson as json
+#!/usr/bin/env python
+# coding=utf8
+import urllib2, urllib
+import datetime, re, sys
+from SourceBase import SourceBase
+
+API_URL = 'http://playapi.mtgx.tv/v3/'
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+headers0 = headers2dict("""
+User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWebkit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+""")
+
+REGIONS = [
+    ("Latvia",None,"lv",""),
+    ("Estonia",None,"ee",""),
+    ("Lituania",None,"lt",""),
+    ("Sweden",None,"se",""),
+    ("Denmark",None,"dk",""),
+    ("Norway",None,"no",""),
+    ("Bulgaria",None,"bg","")
+]
+
+
+class Source(SourceBase):
+    
+    def __init__(self,country="lv"):
+        self.name = "mtgplay"
+        self.title = "Skaties.lv (TV3)"
+        self.img = "http://skaties.lv/touch-icon-192x192.png"
+        self.desc = "MTG skaties.lv satura skatīšanās (LNT,TV3, TV6 u.c.)"
+        
+        self.country=country
+        self.pic_size = "327x250" #"1000x765"
+        
+    def get_content(self, data):
+        print "[mtgplay] get_content:", data
+        if "::" in data:
+            data = data.split("::")[1]        
+        if "/" in data:
+            citem,cid = data.split("/")
+            clist = ""
+        else:
+            clist = data.split("?")[0]
+            qs = dict(map(lambda x:x.split("="),re.findall("\w+=\w+",data)))
+            citem,cid = ("","")
+            self.country = qs["country"] if "country" in qs else "lv"
+        
+        content=[]
+        content.append(("..return", "back","","Return back"))
+        
+        if clist=="home":
+            content.extend([
+                #("Search", "mtgplay::meklet?country=%s&term={0}"%self.country,"","Search videos"), ### TODO                
+                ("TV Live", "mtgplay::videos?country=%s&order=title&type=live"%self.country,"","TV live streams(not always available)"),
+                ("Last videos", "mtgplay::videos?country=%s&order=-airdate"%self.country,"","Last aired videos"),
+                ("Categories", "mtgplay::categories?country=%s&order=name"%self.country,"","Categories"),
+                ("Channels", "mtgplay::channels?country=%s&order=id"%self.country,"","TV channels"),
+                ("Programs by name", "mtgplay::formats?country=%s&order=-title"%self.country,"","Programs by name"),             
+                ("Programs by popularity", "mtgplay::formats?country=%s&order=-popularity"%self.country,"","Programs by popularity")             
+            ])
+            return content
+        
+        r = self.call(data)
+        if not r:
+            content.append(("Error", "","","Error reading '%s'"%data))
+            return content
+        
+        if clist:
+            if r["_links"].has_key("prev"):
+                data2 = r["_links"]["prev"]["href"].replace(API_URL,"")
+                content.append(("Previous page", self.name+"::"+data2.encode("utf8"),"", "Goto previous page"))
+                
+            if "_embedded" in r:
+                for item in r["_embedded"][clist]:
+                    if "title" in item:
+                        title = item["title"]
+                    elif "name" in item:
+                        title = item["name"]
+                    #data2 = self.name+"::"+"%s/%s"%(clist,item["id"]) 
+                    img = item["_links"]["image"]["href"].replace("{size}",self.pic_size) if "image" in item["_links"] else ""
+                    desc = item["summary"] if "summary" in item and item["summary"] else ""
+                    
+                    ### Video ###
+                    if clist=="videos":
+                        data2 = "videos/%s"%item["id"]                            
+                        summary = item["summary"] if item["summary"] else ""
+                        air_at = item["broadcasts"][0]["air_at"] if "broadcasts" in item and len(item["broadcasts"])>0 and "air_at" in item["broadcasts"][0] else ""
+                        if not air_at:
+                            air_at = item["publish_at"] if "publish_at" in item else ""
+                        air_at = air_at[0:16].replace("T"," ") if air_at else ""
+                        try: playable_to = item["broadcasts"][0]["playable_to"]
+                        except: playable_to =""
+                        playable_to = "(till "+playable_to[0:10].replace("T"," ")+")" if playable_to else ""
+                        duration = item["duration"] if "duration" in item else ""
+                        duration = str(datetime.timedelta(seconds=int(duration))) if duration else ""
+                        try:
+                            views = item["views"]["total"] if "views" in item and "total" in item["views"] else ""
+                            views = views+" views"
+                        except: views = ""
+                        desc = "Aired: %s %s\nDuration: %s %s\n\n%s"%(air_at, playable_to,duration,views,summary)
+                        
+                    ### Categories ###     
+                    elif clist == "categories":
+                        #data2 = item["_links"]["formats"]["href"].replace(API_URL,"")
+                        data2 = "formats?category=%s"%item["id"]
+                        if "country" in qs: data2 += "&country="+qs["country"]
+                        if "category" in qs: data2 += "&category="+qs["category"]
+                        if "channel" in qs: data2 += "&channel="+qs["channel"]
+                        data2 += "&order=title"
+                        
+                    ### Channels ###     
+                    elif clist == "channels":
+                        #data2 = item["_links"]["categories"]["href"].replace(API_URL,"")
+                        data2 = "categories?channel=%s"%item["id"]
+                        if "country" in qs: data2 += "&country="+qs["country"]
+                        if "category" in qs: data2 += "&category="+qs["category"]
+                        if "channel" in qs: data2 += "&channel="+qs["channel"]
+                        data2 += "&order=name"
+                        
+                    ### Formats (programs) ###     
+                    elif clist == "formats":
+                        #data2 = item["_links"]["videos"]["href"].replace(API_URL,"")
+                        data2 = "seasons?format=%s"%item["id"]
+                        #if "country" in qs: data2 += "&country="+qs["country"]
+                        #if "category" in qs: data2 += "&category="+qs["category"]
+                        #if "channel" in qs: data2 += "&channel="+qs["channel"]
+                        data2 += "&order=title"
+                        air_at = item["latest_video"]["publish_at"] if "publish_at" in item["latest_video"] else ""
+                        air_at = air_at[0:16].replace("T"," ") if air_at else ""
+                        if air_at:
+                            desc = "Last video: %s\n"%air_at + desc                        
+                        
+                    ### Seasons ###     
+                    elif clist == "seasons":
+                        #data2 = item["_links"]["videos"]["href"].replace(API_URL,"")
+                        data2 = "videos?season=%s"%item["id"]
+                        #if "country" in qs: data2 += "&country="+qs["country"]
+                        #if "category" in qs: data2 += "&category="+qs["category"]
+                        #if "channel" in qs: data2 += "&channel="+qs["channel"]
+                        data2 += "&order=title"
+                        
+                        summary = item["summary"] if "summary" in item and item["summary"] else ""
+                        try:
+                            latest_video = item["latest_video"]["publish_at"]
+                            latest_video = latest_video[0:16].replace("T"," ")
+                        except: latest_video = ""
+                        desc = ("%s\nLatest video: %s"%(summary,latest_video))
+                                      
+                    content.append((title.encode("utf8"),self.name+"::"+data2.encode("utf8"),img.encode("utf8"),desc.encode("utf8")))
+                    
+            if r["_links"].has_key("next"):
+                data2 = r["_links"]["next"]["href"].replace(API_URL,"").encode("utf8")
+                content.append(("Next page", self.name+"::"+data2.encode("utf8"),"","Goto next page"))
+                
+        elif citem:
+            item = r
+            if "title" in item:
+                title = item["title"]
+            elif "name" in item:
+                title = r["name"]
+            #data2 = self.name+"::"+"%s/%s"%(clist,item["id"]) 
+            img = item["_links"]["image"]["href"].replace("{size}",self.pic_size) if "image" in item["_links"] else ""
+            desc = item["summary"] if "summary" in item and item["summary"] else ""
+            
+            dd = "videos/stream/%s"%cid
+            r2 = self.call(dd)
+            if "streams" in r2 and "hls" in r2["streams"]:
+                data2 = r2["streams"]["hls"]
+                content = (title.encode("utf8"),data2.encode("utf8"),img.encode("utf8"),desc.encode("utf8"))
+            elif "msg" in r2:
+                content = (r2["msg"].encode("utf8"),"","","")
+            else: 
+                content = ("Error getting stream","","","")            
+            
+        else:
+            pass
+        return content
+    
+    def is_video(self,data):
+        if "::" in data:
+            data = data.split("::")[1]
+        cmd = data.split("/")
+        if cmd[0]=="videos":
+            return True
+        else:
+            return False
+    
+    def get_stream(self,id):   
+        dd = "videos/stream/%s"%id
+        r2 = self.call(dd)
+        if "streams" in r2 and "hls" in r2["streams"]:
+            data2 = r2["streams"]["hls"]
+        else:
+            data2 = ""
+        return data2.encode("utf8")
+        
+    def call_all(self, endpoint, params = None):
+        url = API_URL % (endpoint)
+        if params:
+            url += '?' + params
+        print "[TVPlay Api] url: ",url
+        result = []
+        while True:
+            content = self._http_request(url)
+            if content:
+                try:
+                    content = json.loads(content)
+                except Exception, ex:
+                    return {" Error " : "in call_api: %s" % ex}
+            else: break
+            if content.has_key("_embedded") and content["_embedded"].has_key(endpoint):
+                result.extend(content["_embedded"][endpoint])
+                pass
+            else: break
+            if content.has_key("_links") and content["_links"].has_key("next"):
+                url = content["_links"]["next"]["href"]
+            else: break
+        return result
+    
+    def call(self, data,headers=headers0):
+        url = API_URL + data
+        #print "[TVPlay Api] url: ",url
+        result = []
+        content = self._http_request(url)
+        if content:
+            try:
+                result = json.loads(content)
+            except Exception, ex:
+                return None
+        return result
+
+    def _http_request0(self, url,headers=headers0):
+        try:
+            r = urllib2.Request(url, headers=headers)
+            u = urllib2.urlopen(r)
+            content = u.read()
+            u.close()
+            return content
+        except Exception as ex:
+            if "read" in ex:
+                content = ex.read()
+            else:
+                content = None
+            return content
+
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

resources/lib/sources0/play24.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import urllib2, urllib
+import datetime, re, sys
+from SourceBase import SourceBase
+
+API_URL = 'http://replay.lsm.lv/'
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+headers0 = headers2dict("""
+User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWebkit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+""")
+import HTMLParser
+h = HTMLParser.HTMLParser()
+    
+class Source(SourceBase):
+    
+    def __init__(self,country="lv"):
+        self.name = "play24"
+        self.title = "Play24.lv"
+        self.img = "http://play24.lv/images/play24-logo-black.png"
+        self.desc = "play24.lv (Riga24TV) satura skatīšanās"
+        
+        self.country=country
+        
+    def get_content(self, data):
+        print "[play24] get_content:", data
+        if "::" in data:
+            data = data.split("::")[1] 
+        path = data.split("?")[0]
+        clist = path.split("/")[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        qs = dict(map(lambda x:x.split("="),re.findall("\w+=\w+",params)))
+        lang = qs["lang"] if "lang" in qs else self.country
+    
+        content=[]
+        content.append(("..return", "back","","Return back"))
+        
+        if clist=="home":
+            content.extend([
+                ("Live stream", "play24::tiesraide","","TV live streams"),
+                ("Last videos", "play24::jaunakie","","Last videos"),
+                ("Categories", "play24::kategorijas","","Categories"),
+                ("Programs", "play24::raidijumi","","Programs"),             
+             ])
+            return content
+  
+        ### Jaunākie video ###
+        elif clist=="jaunakie":
+            url = "http://play24.lv/"
+            r = self._http_request(url)
+            for item in re.findall(' <div class="top-article__image">.*?<a class="top-article__image-link" href="([^"]+)">.*?<img.+?src="([^"]+)".+?alt="([^"]+)" />.+?</picture>', r, re.DOTALL):
+                title = item[2]
+                title =  h.unescape(title.decode("utf8")).encode("utf8")
+                img = item[1]
+                data2 = item[0].replace("http://play24.lv/","")
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+                
+        ### Kategorijas ###
+        elif clist=="kategorijas":
+            url = "http://play24.lv/"
+            r = self._http_request(url)
+            r2 = r[r.find('<div class="footer-navigation">'):]
+            for item in re.findall('<a href="http://play24.lv/(kategorija/[^"]+)" class="navigation__link">([^<]+)</a>', r2, re.DOTALL):
+                title = item[1]
+                data2 = item[0]
+                img = ""
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+       
+        elif clist=="kategorija":
+            url = "http://play24.lv/"+data
+            r = self._http_request(url)
+            for article in re.findall(r"<article\b[^>]*>(.+?)</article>", r, re.DOTALL):
+                m = re.search('<a class="masonry-item__link" href="http://play24\.lv/([^"]+)">', article, re.DOTALL)
+                data2 = m.group(1) if m else ""
+                m = re.search('<img src="([^"]+)" alt="([^"]+)" />', article, re.DOTALL)
+                if m:
+                    img = m.group(1)
+                    title = m.group(2)
+                    title =  h.unescape(title.decode("utf8")).encode("utf8")
+                else:
+                    img = ""
+                    title = ""
+                m = re.search(r'<span class="masonry-item__tags">\s+<a href="([^"]+)">([^<]+)</a>.*?</span>', article, re.DOTALL)
+                progr = m.group(2) if m else ""
+                m = re.search('<span class="masonry-item__date">([^<]+)</span>', article, re.DOTALL)
+                date = m.group(1).strip() if m else ""
+                         
+                if date:
+                    title = title + " (%s %s)"%(date,progr)
+                desc = title + "\n%s - %s"%(progr,date)
+                content.append((title,self.name+"::"+data2,img,desc))
+            m = re.search(r'<li><a href="http://play24\.lv/([^"]+)" rel="next">&raquo;</a></li>', r, re.DOTALL)
+            if m:
+                data2 = m.group(1)
+                content.append(("Next page",self.name+"::"+data2,"","Next page"))                                            
+            return content
+        
+        ### Raidijumi (programmas)
+        elif clist=="raidijumi":
+            url = "http://play24.lv/"
+            r = self._http_request(url)
+            for item in re.findall(r'<li class="tag-box__item">.*?<a href="http://play24\.lv/(birka/[^"]+)">([^<]+)</a>.*?</li>', r, re.DOTALL):
+                title = item[1]
+                title =  h.unescape(title.decode("utf8")).encode("utf8")
+                data2 = item[0]
+                img = ""
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Programmas (video saraksts)
+        elif clist=="birka":
+            url = "http://play24.lv/"+data
+            r = self._http_request(url)
+            for item in re.findall(r'<article\b[^>]*>.+?<a class="masonry-item__link" href="http://play24.lv/([^"]+)">.*?<img src="([^"]+)" alt="([^"]+)" />.*?<span class="masonry-item__tags">.+?<a href="([^"]+)">([^<]+)</a>.*?<span class="masonry-item__date">([^<]+)</span>.*?</article>', r, re.DOTALL):
+                title = item[2]
+                title =  h.unescape(title.decode("utf8")).encode("utf8")
+                title = title + " (%s)"%item[5].strip()
+                img = item[1]
+                data2 = item[0]
+                desc = title + "\n%s - %s"%(item[4],item[5].strip())
+                content.append((title,self.name+"::"+data2,img,desc))
+            m = re.search(r'<li><a href="http://play24\.lv/([^"]+)" rel="next">&raquo;</a></li>', r, re.DOTALL)
+            if m:
+                data2 = m.group(1)
+                content.append(("Next page",self.name+"::"+data2,"","Next page"))                                            
+            return content
+
+        elif clist == "video" or clist == "tiesraide":
+            if clist == "video":  
+                url = "http://play24.lv/"+data
+                r = self._http_request(url)
+                # var ov_video_id = '59422';
+                m = re.search(r"var ov_video_id = '(\d+)';", r, re.DOTALL)
+                if m:
+                    id = m.group(1)
+                else:
+                    return ("No stream found %s"%data,"","","No stream found")
+                m = re.search('<meta name="description" content="([^"]+)" />', r, re.DOTALL)
+                desc = m.group(1) if m else ""
+                desc = h.unescape(desc.decode("utf8")).encode("utf8")
+                
+                url = "http://player.tvnet.lv/v/%s"%id
+            else:
+                url = "http://player.tvnet.lv/l/11"
+                desc = ""
+            r = self._http_request(url)
+            m = re.search('<h1 class="static title">.+?<a href="[^"]+">([^<]+)</a>', r, re.DOTALL)
+            title = m.group(1) if m else ""   
+            s = {}
+            for item in re.findall('source src="([^"]+)" data-stream="([^"]+)" data-quality="([^"]+)"', r, re.DOTALL):
+                s[item[1]] = (item[0],item[2])
+            data2 = ""
+            for t in ("hls","http","rtmp"):
+                if t in s:
+                    data2 = s[t][0]
+                    break
+            return (title,data2,"",desc)
+               
+    
+    def is_video(self,data):
+        if "::" in data:
+            data = data.split("::")[1]
+        cmd = data.split("/")
+        if cmd[0] in ("video","tiesraide"):
+            return True
+        else:
+            return False
+    
+    def call(self, data,headers=headers0,lang=""):
+        if not lang: lang = self.country
+        url = API_URL%lang + data
+        #print "[TVPlay Api] url: ",url
+        result = []
+        content = self._http_request(url)
+        return content
+
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

resources/lib/sources0/replay.py

@@ -0,0 +1,305 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import urllib2, urllib
+import datetime, re, sys
+from SourceBase import SourceBase
+import util
+
+API_URL = 'http://replay.lsm.lv/%s/'
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+headers0 = headers2dict("""
+User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWebkit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+""")
+import HTMLParser
+h = HTMLParser.HTMLParser()
+from YouTubeVideoUrl import YouTubeVideoUrl
+
+class Source(SourceBase):
+
+    def __init__(self,country="lv"):
+        self.name = "replay"
+        self.title = "Replay.lv (LTV)"
+        self.img = "http://replay.lsm.lv/apple-touch-icon.png"
+        self.desc = "LSM replay.lv satura skatīšanās"
+
+        self.country=country
+        self.pic_size = "327x250" #"1000x765"
+
+    def get_content(self, data):
+        print "[replay] get_content:", data
+        if "::" in data:
+            data = data.split("::")[1]
+        path = data.split("?")[0]
+        clist = path.split("/")[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        qs = dict(map(lambda x:x.split("="),re.findall("\w+=\w+",params)))
+        lang = qs["lang"] if "lang" in qs else self.country
+
+        content=[]
+        content.append(("..return", "back","","Return back"))
+
+        if clist=="home":
+            content.extend([
+                ("Live streams", "replay::tiesraide","","TV live streams"),
+                ("Search LV", "replay::search/?term={0}&lang=lv","","Search content LV"),
+                ("Last videos LV", "replay::visi/jaunakie/?source=ltv&lang=lv","","Last aired videos LV"),
+                ("Last videos by categories LV", "replay::kategorijas/?lang=lv","","Last videos by categories LV"),
+                ("All programs LV", "replay::raidijumi/?type=video","","All programs by name LV"),
+                ("Programs by categories LV", "replay::categories?lang=lv","","All programs by categories LV"),
+                #("Channels", "replay::channels?language=%s"%self.country,"","TV channels"),
+                ("Videos by popularity LV", "replay::visi/popularie/?source=ltv&lang=lv","","Programs by popularity"),
+
+                ("Search RU", "replay::search/?term={0}&lang=ru","","Search content RU"),
+                ("Last videos RU", "replay::vse/novie/?source=ltv&lang=ru","","Last aired videos RU"),
+                ("Last videos by categories RU", "replay::kategorijas/?lang=ru","","Last videos by categories RU"),
+                ("All programs RU", "replay::peredachi/?lang=ru&type=video","","All programs by name"),
+                ("Programs by categories RU", "replay::categories?lang=ru","","Programs by categories RU")
+            ])
+            return content
+
+        ### programmu kategorijas ###
+        elif clist=="categories":
+            url = "http://replay.lsm.lv/lv/raidijumi/?lang=lv&type=video" if lang =="lv" else "http://replay.lsm.lv/ru/peredachi/?lang=ru&type=video"
+            r = self._http_request(url)
+            for item in re.findall(r'<a .+href="(\?lang=\w+&type=video&theme=\d+)">([^<]+)</a>\t', r):
+                title = item[1]
+                data2 = url.split("?")[0]+item[0]
+                data2 = data2.replace(API_URL%lang,"")
+                img = ""
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### jaunāko raidijumu kategorijas ###
+        elif clist=="kategorijas":
+            url = "http://replay.lsm.lv/lv/" if lang =="lv" else "http://replay.lsm.lv/ru/"
+            r = self._http_request(url)
+            for item in re.findall(r'<a href="/(lv|ru)/kategorija/(\w+)/">.+?<i class="[^"]+"></i>.+?<span>([^<]+)</span>', r, re.DOTALL):
+                title = item[2]
+                data2 = "kategorija/%s/?lang=%s"%(item[1],item[0])
+                img = ""
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Tiešraides kanānālu saraksts
+        elif path=="tiesraide":
+            url = "http://replay.lsm.lv/styles/main.css"
+            r= self._http_request(url)
+            for item in re.findall(r'channel-logo--(\w+)\{background-image:url\("([^"]+\.png)"', r):
+                ch = item[0]
+                title = ch.upper()
+                data2 = "tiesraide/%s/"%ch
+                img = "http://replay.lsm.lv"+item[1]
+                veids = "video "if "tv" in ch else "audio"
+                desc = title+" tiesraide (%s)"%veids
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Kanāla tiesraide
+        elif clist == "tiesraide" and "/" in data:
+            ch = data.split('/')[1]
+            veids = "video" if "tv" in ch else "audio"
+            #url = "http://replay.lsm.lv/lv/tiesraide/ltv7/"
+            url = "http://replay.lsm.lv/lv/tiesraide/%s/"%ch
+            r= self._http_request(url)
+
+            m = re.search('%s/">.+?<h5>([^<]+)+</h5>.*?<time>([^<]+)</time>'%ch, r, re.DOTALL)
+            tagad = m.group(1).strip() if m else ""
+            laiks = m.group(2).strip() if m else ""
+            laiks = h.unescape(laiks).encode("utf8")
+            m = re.search("<h1>([^<]+)</h1>", r)
+            title = m.group(1).strip() if m else path.split("/")[1].upper()
+            title = "%s - %s (%s)"%(title,tagad,laiks)
+
+            if veids == "video":
+                m = re.search('<div class="video"><iframe.+src="([^"]+)"', r)
+                if not m:
+                    content=("No stream found %s"%data,"","","No stream found")
+                    return content
+                url = m.group(1)
+                headers = headers2dict("""
+            User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWebkit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+            Referer: http://replay.lsm.lv/lv/ieraksts/ltv/70398/tiesa-runa.-lielbritanija-gatavojas-referendumam-par-tu/
+                    """)
+                r = self._http_request(url,headers=headers)
+
+                m = re.search('<div class="video-player"><iframe.+src="([^"]+)"', r)
+                if not m:
+                    content=("No stream found %s"%data,"","","No stream found")
+                    return content
+                url = m.group(1)
+
+                r = self._http_request(url,headers=headers)
+                m = re.search('"([^"]+m3u8[^"]+)"', r)
+                if not m:
+                    content=("No stream found %s"%data,"","","No stream found")
+                    return content
+                data2 = m.group(1).replace("\\","")
+
+            else: # audio
+                lrn = ch.replace("lr","")
+                url = "http://www.latvijasradio.lsm.lv/lv/tiesraide/?channel=%s"%lrn
+                r = self._http_request(url)
+                m = re.search('"file":"([^"]+?m3u8.*?)"', r)
+                if not m:
+                    content=("No stream found %s"%data,"","","No stream found")
+                    return content
+                data2 = m.group(1).replace("\\","")
+
+            img = ""
+            desc = ""
+            content =(title,data2,img,desc)
+            return content
+
+        #m = re.search(r'(\?page=\d+)" class=" paging__prev', r, re.IGNORECASE)
+        #if m:
+        #    data = re.sub("\?page=\d+", "", data)
+        #    data2 = data+m.group(1)
+        #    content.append(("Previous page",self.name+"::"+data2,"","Previous page"))
+
+        r = self.call(data, lang=lang)
+        if not r:
+            return content
+
+        if clist == "search":
+            #for r2 in re.findall('<article itemtype="http://schema.org/Article" itemscope class="thumbnail thumbnail--default ">(.+?)</article>', r2, re.DOTALL):
+            for item in re.findall('itemprop="image" data-image="([^"]+)".+?<figcaption><h5 itemprop="name"><a itemprop="url" href="([^<]+)">([^<]+)</a></h5></figcaption>', r):
+                title = item[2]
+                data2 = item[1].replace("/%s/"%lang,"")+"?lang=%s"%lang
+                img = "http://replay.lsm.lv" + item[0]
+                desc  = title
+                content.append((title,self.name+"::"+data2,img,desc))
+
+            #for item in re.findall('itemprop="image" data-image="([^"]+)".+?<figcaption><h4 itemprop="about"><a href="([^"]+)">([^<]+)</a></h4>.*?<h5 itemprop="name"><a itemprop="url" href="([^"]+)">([^<]+)</a></h5>.+?datetime="([^"]+)" class="thumbnail__date ">([^<]+)</time>', r2):
+            for item in re.findall('itemprop="image" data-image="([^"]+)".+? class="icon-(ltv|lr).+?<figcaption><h4 itemprop="about"><a href="([^"]+)">([^<]+)</a></h4>.*?<h5 itemprop="name"><a itemprop="url" href="([^"]+)">([^<]+)</a></h5>.+?datetime="([^"]+)" class="thumbnail__date ">([^<]+)</time>', r):
+                if item[1]=="lr":continue
+                title = "%s - %s (%s)"%(item[3],item[5],item[7])
+                data2 = item[4].replace("/%s/"%lang,"")+"?lang=%s"%lang
+                img = item[0].replace("https:","http:")
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+
+        ### Raidijumi (programmas) ###
+        elif clist in ( "raidijumi","peredachi"):
+            for item in re.findall('<li itemprop="name"><a href="([^"]+)" itemprop="url">([^<]+)', r):
+            #for item in re.findall('<li itemprop="name"><a href="([^"]+)" itemprop="url">([^<]+)</a></li>', r):
+                title = item[1]
+                data2 = item[0].replace("/%s/"%lang,"")+"?lang=%s"%lang
+                img = ""
+                desc  = ""
+                content.append((title,self.name+"::"+data2,img,desc))
+
+        ### Raidijuma ieraksti speciālie###
+        elif clist in ( "visi","vse",):
+            for item in re.findall('(?i)<figure><a href="([^"]+)" itemprop="image" data-image="([^"]+)".+class="thumbnail__duration">([^<]+)</time></figure><figcaption><h4 itemprop="about"><a href="[^"]+">([^<]+)</a></h4>.+>([^<]+).*</h5>.+>([^<]+)</time></figcaption>', r):
+                title = item[3]
+                data2 = item[0].replace("/%s/"%lang,"")+"?lang=%s"%lang
+                img = item[1].replace("https:","http:")
+                desc  = "%s - %s\n%s"%(item[5],item[2],item[4])
+                content.append((title,self.name+"::"+data2,img,desc))
+
+        ### Raidijuma ieraksti (videos)
+        elif clist in ("raidijums","peredacha","kategorija"):
+            for item in re.findall('<article .+ href="([^"]+)".+image="([^"]+)".+class="thumbnail__duration">([^<]+).+">([^<]+).+class="thumbnail__date ">([^"]+)</time></figcaption></article>', r):
+                title = item[3]
+                data2 = item[0].replace("/%s/"%lang,"")+"?lang=%s"%lang
+                img = item[1].replace("https:","http:")
+                desc = "%s - %s"%(item[4],item[2])
+                content.append((title,self.name+"::"+data2,img,desc))
+
+        ### Ieraksts (video) ###
+        elif clist in ("ieraksts","statja"):
+            m = re.search('src="([^"]+)"></iframe>', r)
+            if m:
+                url2 = m.group(1)
+                headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWebkit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+Referer: http://replay.lsm.lv/lv/ieraksts/ltv/70398/tiesa-runa.-lielbritanija-gatavojas-referendumam-par-tu/
+            """)
+                r2 = self._http_request(url2,headers=headers)
+                m = re.search('"file":"([^"]+)', r2)
+                if m:
+                    data2 = m.group(1).replace("\\","")
+                    m = re.search('"idstring":"([^"]+)', r2)
+                    title = m.group(1) if m else ""
+                    title = title.decode("unicode-escape").encode("utf8")
+                    title = title.replace("\n","")
+                    img = ""
+                    desc = ""
+                    if "youtube" in data2:
+                        video_id = re.search(r"/watch\?v=([^&]+)",data2).group(1)
+                        data2 = YouTubeVideoUrl().extract(video_id)
+                        if not data2:
+                            content=("No stream found %s"%data,"","","No stream found")
+                            return content
+                    content =(title,data2,img,desc)
+                    return content
+            content=("No stream found %s"%data,"","","No stream found")
+            return content
+
+        m = re.search(r'href="\?([^"]+)" class=" paging__next', r)
+        if m:
+            page = int(re.search("page=(\d+)",m.group(1)).group(1))
+            if "page="in data:
+                data2 = re.sub("page=\d+","page=%i"%page,data)
+            else:
+                if "?" in data:
+                    data2 =data+"&page=%i"%page
+                else:
+                    data2 =data+"?page=%i"%page
+            content.append(("Next page",self.name+"::"+data2,"","Next page"))
+
+        return content
+
+    def is_video(self,data):
+        if "::" in data:
+            data = data.split("::")[1]
+        cmd = data.split("/")
+        if cmd[0] in ("ieraksts","statja"):
+            return True
+        elif cmd[0]=="tiesraide" and len(cmd)>1:
+            return True
+        else:
+            return False
+
+    def call(self, data,headers=headers0,lang=""):
+        if not lang: lang = self.country
+        url = API_URL%lang + data
+        #print "[TVPlay Api] url: ",url
+        result = []
+        content = self._http_request(url,headers=headers0)
+        return content
+
+
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass