launchboxscreenscraper.py

# -*- coding: utf-8 -*-
# lb2am.py - https://github.com/sharkusk/lb2am
# Copyright (C) 2017 - Marcus Kellerman
#
# 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
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
import xml.etree.ElementTree as ET
import argparse
import os
import shutil
import codecs
import urllib2
import binascii
import zipfile
import fnmatch

# Local imports
import screenscraper as SS
import lb2am as LB

try:
    from ssmap import SS_SYSTEM_MAP
except:
    SS_SYSTEM_MAP = {}

SS_SYSTEM_XML_FILE = "screenscraper.fr-systemesListe.xml"

SS_MAP_HEADER = """#
# Generated by lb2am.py
# This file contains the mapping between screenscraper.fr and the platform /
# emulator names used by LaunchBox and Attractmode
#
# "Platform Name": "ScreenScaper ID",
SS_SYSTEM_MAP = {
"""

LB_TO_SS_MEDIA_MAP = {
        'Screenshot - Gameplay':    ["screenshot",],
        'Fanart - Background':      ["fanart",],
        'Video':                    ["video",],
        'Clear Logo':               ["wheel",],
        'Box - Front':              ["box2d",],
        'Box - 3D':                 ["box3d",],
        'Box - Back':               ["box2d-back",],
        'Arcade - Marquee':         ["marquee",],
        'Banner':                   ["screenmarquee",],
        'Manual':                   ["manuel", ],
        'Advertisement Flyer - Front': ["flyer",],
        'Cart - Front':             ["support2d",],
        }

ADDITIONAL_MAPPINGS = {
        'Super Nintendo': ['Super Nintendo Entertainment System',],
        'Mame': ['MAME', 'Final Burn Alpha',],
        'NES': ['Nintendo Entertainment System',],
        'Daphne': ['LaserDisc',],
        'Gamecube': ['Nintendo GameCube',],
        'Nintendo 64': ['Nintendo 64-VC',],
        }

SS_LOCALE_PREFERENCE = ['us','us1','wor','eu','jp',]

class LaunchBoxScreenScraper(object):
    """ """
    def __init__(self, lbpath, devid, devpassword, softname, ssid, sspassword, useGameTitle=False, verbose=False):
        self.ssparameters = {}
        self.ssparameters['devid'] = devid
        self.ssparameters['devpassword'] = devpassword
        self.ssparameters['softname'] = softname
        self.ssparameters['ssid'] = ssid
        self.ssparameters['sspassword'] = sspassword
        self.verbose = verbose
        self.lbPath = lbpath
        self.useGameTitle = useGameTitle

        if len(SS_SYSTEM_MAP) is 0:
            self.ssmap = self.CreateScreenScraperSystemMap('ssmap.py', False)
        else:
            self.ssmap = SS_SYSTEM_MAP

        self.artDirs = self.CreateLaunchBoxArtFolderMap()
        self.lbToSsMediaMap = LB_TO_SS_MEDIA_MAP
        self.ssLocalePreference = SS_LOCALE_PREFERENCE

    def CreateScreenScraperSystemMap(self, ssmapFileName, updateSystems):
        """
	Writes the ssmap.py file and returns a system map with entries like this:
        { "Sega Megadrive": "1", ... }
        """
        syslist = SS.SystemList( updateCache=updateSystems, **self.ssparameters)
        ssmap = syslist.GetSystemList()
        for ssplat in ADDITIONAL_MAPPINGS.keys():
            for lbplat in ADDITIONAL_MAPPINGS[ssplat]:
                ssmap[lbplat] = ssmap[ssplat]
        f = open('ssmap.py', 'w')
        f.write(SS_MAP_HEADER)
        for key in ssmap:
            f.write('    "%s": "%s",\n' % (key.encode('utf-8'), ssmap[key]))
        f.write('}')
        f.close()
        return ssmap

    def CreateLaunchBoxArtFolderMap( self ):
        """
        Returns a dictionary with the following format:
        artDirs = { platform: { 'Video': 'd:/...', 'Clear Logo': xxxx, ... }, ... }
        """
        artDirs = {}
        tree = ET.parse(os.path.join(self.lbPath, 'Data', 'Platforms.xml'))
        root = tree.getroot()
        for platformFolder in root.iter('PlatformFolder'):
            mediaType = platformFolder.find('MediaType').text
            platformName = platformFolder.find('Platform').text
            if platformName not in artDirs:
                artDirs[platformName] = {}
            artDirs[platformName][mediaType] = platformFolder.find('FolderPath').text
        return artDirs

    def ScrapeAllPlatforms( self ):
	""" """
	count = 0
        files = LB.GetLbPlatformFiles( self.lbPath)
        for file in files:
            platformName = LB.LbFilenameToPlatformName(file)
            count += self.ScrapePlatform(platformName)
	return count


    def ScrapePlatform( self, LbPlatformName, SsPlatformId=None ):
        """
        Returns number of items scraped
        """
        mediaCount = 0
        print("\nScraping: %s" % LbPlatformName)
        if SsPlatformId is None:
            try:
                SsPlatformId = self.ssmap[LbPlatformName]
            except:
                print("  Unable to find ScreenScraperId.")
                return mediaCount
        platFileName = os.path.join(self.lbPath, 'Data', 'Platforms', LbPlatformName)+'.xml'
        try:
            tree = ET.parse(platFileName)
        except:
            if self.verbose:
                print("  Unable to open LB platform file: '%s'"% platFileName)
            return mediaCount

        platArtDirs = self.artDirs[LbPlatformName]
        root = tree.getroot()
        for game in root.iter('Game'):
            gamePath = game.find("ApplicationPath").text
            gamePath = os.path.abspath(os.path.join(self.lbPath,gamePath))
            gameFileName = os.path.splitext(os.path.basename(gamePath))[0]
            gameTitle = game.find("Title").text

            print("  --- %s ---" % gameTitle.encode('utf-8'))

            # Search LB media directories for existing artwork
            mediaNeeded = []
            for mediaType in self.lbToSsMediaMap.keys():
                foundMedia = False
                ad = platArtDirs[mediaType]
                if len(find_files(os.path.join(self.lbPath,ad),gameTitle+'*.*')) > 0:
                    foundMedia = True
                elif len(find_files(os.path.join(self.lbPath,ad),gameFileName+'*.*')) > 0:
                    foundMedia = True
                if foundMedia is False:
                    if self.useGameTitle:
                        fn = os.path.join(self.lbPath,ad,gameTitle)
                    else:
                        fn = os.path.join(self.lbPath,ad,gameFileName)
                    mediaNeeded.append((mediaType,fn))
                    if self.verbose:
                        print("    Missing a %s" % mediaType)

            if len(mediaNeeded) > 0:
                systemid = self.ssmap[LbPlatformName]
                try:
                    ss = SS.GameInfo(systemId=systemid, romPath=gamePath, gameTitle=gameTitle, verbose=self.verbose, **self.ssparameters)
                except SS.RomNotFoundError:
                    print("    Not found in ScreenScraper")
                    continue
                availableMedia = ss.GetAvailableMedia()

                for mediaToCheck in mediaNeeded:
                    url = None
                    # LB media directory may map to multipe SS types
                    for mediaType in self.lbToSsMediaMap[mediaToCheck[0]]:
                        if mediaType in availableMedia:
                            locale = availableMedia[mediaType].keys()[0]
                            if len(availableMedia[mediaType]) > 1:
                                # Find our preferred locale
                                for locale in self.ssLocalePreference:
                                    if locale in availableMedia[mediaType]:
                                        break
                                else:
                                    print("    Did not find a preferred locale from list %s." % availableMedia[mediaType].keys())
                            url = availableMedia[mediaType][locale]['url']
                            if self.verbose:
                                print("    Getting %s (%s)!" % (mediaType,locale))
                            break
                    else:
                        # Didn't find what we needed, so move on to next
                        continue
                    ext = '.'+url.split('&mediaformat=')[1][:3]
                    filename = mediaToCheck[1]+ext 
                    if os.path.exists(filename) is False:
                        print("    Saving: %s" % filename.encode('utf-8'))
                        if not os.path.exists(os.path.dirname(filename)):
                            try:
                                os.makedirs(os.path.dirname(filename))
                            except OSError as exc: # Guard against race condition
                                if exc.errno != errno.EEXIST:
                                    raise
                        f = open(mediaToCheck[1]+ext,'wb')
                        response = urllib2.urlopen(url)
                        f.write(response.read())
                        f.close()
                        mediaCount += 1
        return mediaCount

###############################################################################
# GLOBAL FUNCTIONS
###############################################################################

def find_files(directory, pattern='*'):
    try:
        return [os.path.join(dirpath, f)
            for dirpath, dirnames, files in os.walk(directory)
            for f in fnmatch.filter(files, pattern)]
    except:
        return []

###############################################################################
# BASIC TESTS
###############################################################################

def main():
    import settings
    test = 2

    verbose = False

    # import ipdb; ipdb.set_trace()
    lbss = LaunchBoxScreenScraper('..\LaunchBox', settings.devid, settings.devpassword, settings.softname, settings.ssid, settings.sspassword, verbose)

    if test == 1:
        # lbss.ScrapePlatform("Sega Dreamcast")
        # lbss.ScrapePlatform("MAME")
        # lbss.ScrapePlatform("Atari 2600")
        # lbss.ScrapePlatform("Super Nintendo Entertainment System")
        # lbss.ScrapePlatform("Microsoft MSX2")
        lbss.ScrapePlatform("Nintendo GameCube")

    if test == 2:
        lbss.ScrapeAllPlatforms()

if __name__ == "__main__":
    main()