Ejemplo n.º 1
0
    def filmaffinity_create_fxd(self, arg=None, menuw=None):
        """
        create fxd file for the item
        """
        box = PopupBox(text=_('Fetching movie information'))
        box.show()

        #if this exists we got a cdrom/dvdrom
        if self.item.media and self.item.media.devicename:
            devicename = self.item.media.devicename
        else:
            devicename = None

        self.getFilmAffinityPage(arg[0])

        if self.disc_set:
            self.setDiscset(devicename, None)
        else:
            if self.item.subitems:
                for i in range(len(self.item.subitems)):
                    video = makeVideo('file', 'f%s' % i,
                                      os.path.basename(self.item.subitems[i].filename),
                                      device=devicename)
                    self.setVideo(video)
            else:
                video = makeVideo('file', 'f1', os.path.basename(self.item.filename),
                                  device=devicename)
                self.setVideo(video)
            self.setFxdFile(os.path.splitext(self.item.filename)[0])

        self.writeFxd()
        self.filmaffinity_menu_back(menuw)
        box.destroy()
Ejemplo n.º 2
0
def _create_fxd(prog, filename, start_time):
    """
    Create a .fxd file with the specified program information in.
    """
    from util.fxdimdb import FxdImdb, makeVideo
    fxd = FxdImdb()

    (filebase, fileext) = os.path.splitext(filename)
    fxd.setFxdFile(filebase, overwrite=True)

    video = makeVideo('file', 'f1', os.path.basename(filename))
    fxd.setVideo(video)
    if prog:
        fxd.title = prog.title
        fxd.info['tagline'] = fxd.str2XML(prog.sub_title)
        desc = prog.desc.replace('\n\n', '\n').replace('\n', '
')
        fxd.info['plot'] = fxd.str2XML(desc)
    else:
        fxd.title = _('Manual Recording')
    fxd.info['recording_timestamp'] = str(start_time)
    fxd.info['runtime'] = None
    # bad use of the movie year field :)
    try:
        fxd.info['year'] = time.strftime(config.TV_RECORD_YEAR_FORMAT,
                                         time.localtime(start_time))
    except:
        fxd.info['year'] = '2007'

    if plugin.is_active('tv.recordings_manager'):
        fxd.info['watched'] = 'False'
        fxd.info['keep'] = 'False'
    fxd.writeFxd()
Ejemplo n.º 3
0
    def imdb_add_to_fxd(self, arg=None, menuw=None):
        """
        add item to fxd file
        BROKEN, PLEASE FIX
        """

        #if this exists we got a cdrom/dvdrom
        if self.item.media and self.item.media.devicename:
            devicename = self.item.media.devicename
        else:
            devicename = None

        fxd = FxdImdb()
        fxd.setFxdFile(arg[0].fxd_file)

        if self.item.mode in ('dvd', 'vcd'):
            fxd.setDiscset(devicename, None)
        else:
            num = len(fxd.video) + 1
            video = makeVideo('file',
                              'f%s' % num,
                              self.item.filename,
                              device=devicename)
            fxd.setVideo(video)

            if arg[1] == 'variant':
                part = makePart('Variant %d' % num, 'f%s' % num)

                if fxd.variant:
                    part = [makePart('Variant 1', 'f1'), part]

                fxd.setVariants(part)

        fxd.writeFxd()
        self.imdb_menu_back(menuw)
Ejemplo n.º 4
0
def _create_fxd(prog, filename, start_time):
    """
    Create a .fxd file with the specified program information in.
    """
    from util.fxdimdb import FxdImdb, makeVideo
    fxd = FxdImdb()

    (filebase, fileext) = os.path.splitext(filename)
    fxd.setFxdFile(filebase, overwrite=True)

    video = makeVideo('file', 'f1', os.path.basename(filename))
    fxd.setVideo(video)
    if prog:
        fxd.title = prog.title
        fxd.info['tagline'] = fxd.str2XML(prog.sub_title)
        desc = prog.desc.replace('\n\n','\n').replace('\n','
')
        fxd.info['plot'] = fxd.str2XML(desc)
    else:
        fxd.title = _('Manual Recording')
    fxd.info['recording_timestamp'] = str(start_time)
    fxd.info['runtime'] = None
    # bad use of the movie year field :)
    try:
        fxd.info['year'] = time.strftime(config.TV_RECORD_YEAR_FORMAT, time.localtime(start_time))
    except:
        fxd.info['year'] = '2007'

    if plugin.is_active('tv.recordings_manager'):
        fxd.info['watched'] = 'False'
        fxd.info['keep'] = 'False'
    fxd.writeFxd()
Ejemplo n.º 5
0
    def imdb_create_fxd(self, arg=None, menuw=None):
        """
        create fxd file for the item
        """
        fxd = FxdImdb()

        box = PopupBox(text=_('getting data...'))
        box.show()

        #if this exists we got a cdrom/dvdrom
        if self.item.media and self.item.media.devicename:
            devicename = self.item.media.devicename
        else:
            devicename = None

        # restore season/episode if we have it
        fxd.setImdbId(arg[0], self.season, self.episode)

        if self.disc_set:
            fxd.setDiscset(devicename, None)
        else:
            if self.item.subitems:
                for i in range(len(self.item.subitems)):
                    video = makeVideo('file',
                                      'f%s' % i,
                                      os.path.basename(
                                          self.item.subitems[i].filename),
                                      device=devicename)
                    fxd.setVideo(video)
            else:
                video = makeVideo('file',
                                  'f1',
                                  os.path.basename(self.item.filename),
                                  device=devicename)
                fxd.setVideo(video)
            fxd.setFxdFile(os.path.splitext(self.item.filename)[0])

        fxd.writeFxd()
        self.imdb_menu_back(menuw)
        box.destroy()
Ejemplo n.º 6
0
    def create_fxd(self):
        from util.fxdimdb import FxdImdb, makeVideo
        fxd = FxdImdb()

        (filebase, fileext) = os.path.splitext(self.filename)
        fxd.setFxdFile(filebase, overwrite=True)

        desc = self.desc.replace('\n', '
')
        video = makeVideo('file', 'f1', os.path.basename(self.filename))
        fxd.setVideo(video)
        fxd.info['tagline'] = fxd.str2XML(self.episode)
        fxd.info['plot'] = fxd.str2XML(self.desc)
        fxd.title = self.title
        fxd.writeFxd()
Ejemplo n.º 7
0
    def create_fxd(self):
        from util.fxdimdb import FxdImdb, makeVideo

        fxd = FxdImdb()

        (filebase, fileext) = os.path.splitext(self.filename)
        fxd.setFxdFile(filebase, overwrite=True)

        desc = self.desc.replace("\n", "
")
        video = makeVideo("file", "f1", os.path.basename(self.filename))
        fxd.setVideo(video)
        fxd.info["tagline"] = fxd.str2XML(self.episode)
        fxd.info["plot"] = fxd.str2XML(self.desc)
        fxd.title = self.title
        fxd.writeFxd()
Ejemplo n.º 8
0
    fxd = FxdImdb()

    if task == 'add':
        if len(args) == 2:
            usage()
        fxd.setFxdFile(arg[0])
        if fxd.isDiscset() == TRUE:
            fxd.setDiscset(drive, None)
        elif fxd.isDiscset() == FALSE:
            type = 'file'
            if arg[1].find('[dvd]') != -1: type = 'dvd'
            if arg[1].find('[vcd]') != -1: type = 'vcd'

            id = abs(Random() * 100)
            if driveset == TRUE:
                video = makeVideo(type, 'f' + str(id), arg[1], device=drive)
            else:
                video = makeVideo(type, 'f' + str(id), arg[1])
            fxd.setVideo(video)
        else:
            print 'Fxd file is not valid, updating failed'
            sys.exit(1)
        fxd.writeFxd()
        sys.exit(0)

    if task == 'search':
        if len(args) != 0:
            usage()

        filename = search_arg
        print "searching " + filename
Ejemplo n.º 9
0
    if opts.add:
        fxd.setFxdFile(args[0])
        fxd.setFxdFile(arg[0])
        if fxd.isDiscset() is None:
            sys.exit(u'Fxd file is not valid, updating failed')
        elif fxd.isDiscset():
            fxd.setDiscset(opts.rom_drive, None)
        else:
            type = 'file'
            if arg[1].find('[dvd]') != -1: type = 'dvd'
            if arg[1].find('[vcd]') != -1: type = 'vcd'

            id = abs( Random() * 100 )
            if driveset:
                video = makeVideo(type, 'f'+str(id), arg[1], device=opts.rom_drive)
            else:
                video = makeVideo(type, 'f'+str(id), arg[1])
            fxd.setVideo(video)
        fxd.writeFxd()
        sys.exit(0)

    if opts.search:
        title = tv_marker + ' '.join(args) + tv_marker
        print "Searching IMDB for '%s'..." % title
        results = fxd.searchImdb(title, opts.season, opts.episode)
        if not results:
            print 'No results'

        # Print the results.
        print '%s result%s for "%s":' % (len(results), ('', 's')[len(results) != 1], title.encode(opts.encoding, 'replace'))
Ejemplo n.º 10
0
class PluginInterface(plugin.ItemPlugin):
    """
    You can add IMDB information for video items with the plugin.

    Make sure you have imdbpy installed, on Debian do:
    | apt-get install python-imdbpy
    
    Check out http://imdbpy.sourceforge.net/?page=download for imdbpy package for your distribution
    
    Activate with:
    | plugin.activate('video.imdb2')

    You can also set imdb_search on a key (e.g. '1') by setting
    | EVENTS['menu']['1'] = Event(MENU_CALL_ITEM_ACTION, arg='imdb_search_or_cover_search')
    """
    def __init__(self, license=None):
        if not config.SYS_USE_NETWORK:
            self.reason = 'SYS_USE_NETWORK not enabled'
            return
        self.fxd = FxdImdb()
        plugin.ItemPlugin.__init__(self)

    def imdb_get_disc_searchstring(self, item):
        name = item.media.label
        name = re.sub('([a-z])([A-Z])', point_maker, name)
        name = re.sub('([a-zA-Z])([0-9])', point_maker, name)
        name = re.sub('([0-9])([a-zA-Z])', point_maker, name.lower())
        for r in config.IMDB_REMOVE_FROM_LABEL:
            name = re.sub(r, '', name)
        parts = re.split('[\._ -]', name)

        name = ''
        for p in parts:
            if p:
                name += '%s ' % p
        if name:
            return name[:-1]
        else:
            return ''

    def actions(self, item):
        self.item = item

        if item.type == 'video' and (not item.files
                                     or not item.files.fxd_file):
            if item.mode == 'file' or (item.mode in ('dvd', 'vcd') and \
                                       item.info.has_key('tracks') and not \
                                       item.media):
                self.disc_set = False
                return [(self.imdb_search, _('Search IMDB for this file'),
                         'imdb_search_or_cover_search')]

            elif item.mode in ('dvd', 'vcd') and item.info.has_key('tracks'):
                self.disc_set = True
                s = self.imdb_get_disc_searchstring(self.item)
                if s:
                    return [(self.imdb_search, _('Search IMDB for [%s]') % s,
                             'imdb_search_or_cover_search')]

        if item.type == 'dir' and item.media and item.media.mountdir.find(
                item.dir) == 0:
            self.disc_set = True
            s = self.imdb_get_disc_searchstring(self.item)
            if s:
                return [(self.imdb_search, _('Search IMDB for [%s]') % s,
                         'imdb_search_or_cover_search')]
        return []

    def imdb_search(self, arg=None, menuw=None):
        """
        search imdb for this item
        """

        items = []
        dlg = dialog.show_working_indicator(_('Searching IMDB...'))

        if self.disc_set:
            self.searchstring = self.item.media.label
        else:
            self.searchstring = self.item['title']

        try:
            #guess the title from the filename
            lock = kaa.ThreadCallable(self.fxd.guessImdb, self.searchstring,
                                      self.disc_set)()
            lock.wait()
            results = lock.result

            # loop through the results and create menu
            # should not use imdbpy objects here as imdbpy should be encapsulated by FxdImdb
            # but for now it's to much work to do this the right way.
            # It works so let's deal with it later.
            for movie in results:
                try:
                    # OK, we have a regular movie here, no nested episodes
                    items.append(menu.MenuItem('%s (%s) (%s)' % \
                                (movie['long imdb title'], movie['kind'], movie.movieID),
                                 self.imdb_create_fxd, (movie.movieID, movie['kind'])))
                except Unicode, e:
                    print e

        except (FxdImdb_Error) as error:
            logger.warning('%s', error)
            dlg.hide()
            dialog.show_message(_('Connection to IMDB failed'))
            return

        dlg.hide()

        if config.IMDB_AUTOACCEPT_SINGLE_HIT and len(items) == 1:
            self.imdb_create_fxd(arg=items[0].arg, menuw=menuw)
            return

        if items:
            moviemenu = menu.Menu(_('IMDB Query'),
                                  items,
                                  self.item.skin_fxd,
                                  item_types='%s default' % self.item.type)
            # we see if the item has individual skin and load it if so
            menuw.pushmenu(moviemenu)
            return

        dialog.show_message(_('No information available from IMDB'))
        return

    def imdb_menu_back(self, menuw):
        """
        check how many menus we have to go back to see the item
        """
        import directory

        # check if we have to go one menu back (called directly) or
        # two (called from the item menu)
        back = 1
        if menuw.menustack[-2].selected != self.item:
            back = 2

        # maybe we called the function directly because there was only one
        # entry and we called it with an event
        if menuw.menustack[-1].selected == self.item:
            back = 0

        # update the directory
        if directory.dirwatcher:
            directory.dirwatcher.scan()

        # go back in menustack
        for i in range(back):
            menuw.delete_menu()
        menuw.refresh()

    def imdb_create_fxd(self, arg=None, menuw=None):
        """
        create fxd file for the item
        """
        dlg = dialog.show_working_indicator(_('Getting data...'))

        try:
            lock = kaa.ThreadCallable(self.fxd.retrieveImdbData, arg[0],
                                      self.fxd.ctitle[1], self.fxd.ctitle[2])()
            lock.wait()

        except FxdImdb_Error, error:
            logger.warning('%s', error)
            dlg.hide()
            return

        #if this exists we got a cdrom/dvdrom
        if self.item.media and self.item.media.devicename:
            devicename = self.item.media.devicename
        else:
            devicename = None

        if self.disc_set:
            self.fxd.setDiscset(devicename, None)
        else:
            if self.item.subitems:
                for i in range(len(self.item.subitems)):
                    video = makeVideo('file',
                                      'f%s' % i,
                                      os.path.basename(
                                          self.item.subitems[i].filename),
                                      device=devicename)
                    self.fxd.setVideo(video)
            else:
                video = makeVideo('file',
                                  'f1',
                                  os.path.basename(self.item.filename),
                                  device=devicename)
                self.fxd.setVideo(video)
            self.fxd.setFxdFile(os.path.splitext(self.item.filename)[0])

        self.fxd.writeFxd()
        self.fxd = FxdImdb()
        self.imdb_menu_back(menuw)
        dlg.hide()