def __exit__(self, type, value, traceback):
xbmc.log("HandleAbort exit")
settings = util.getSettings()
settings.setSetting(util.SETTING_RCB_SCRAPEONSTARTUPACTION, 'nothing')
#restore original scraping mode
settings.setSetting(util.SETTING_RCB_SCRAPINGMODE, self.orig_scraping_mode)
def run():
print("Initializing settings")
initSettings.run()
settings = getSettings()
print("Making output file")
if not os.path.exists(settings["videoOut"]):
os.mkdir(settings["videoOut"])
install("pyopenssl")
def __enter__(self):
xbmc.log("HandleAbort enter")
settings = util.getSettings()
settings.setSetting(util.SETTING_RCB_SCRAPEONSTARTUPACTION, 'update')
#set scraping mode to accurate
self.orig_scraping_mode = settings.getSetting(util.SETTING_RCB_SCRAPINGMODE)
settings.setSetting(util.SETTING_RCB_SCRAPINGMODE, util.SCRAPING_OPTION_AUTO_ACCURATE_TXT)
return True
def launchGame(self, param):
import launcher, util
from gamedatabase import GameDataBase
from config import Config
gdb = GameDataBase(util.getAddonDataPath())
gdb.connect()
gameId = int(param.replace('launchid=', ''))
config = Config(None)
statusOk, errorMsg = config.readXml()
settings = util.getSettings()
gui = dummyGUI()
launcher.launchEmu(gdb, gui, gameId, config, settings, None)
def gatherWidgetData(self, param):
print 'start gatherWidgetData'
import util, helper
from gamedatabase import Game, GameDataBase, File
from config import Config, RomCollection
gdb = GameDataBase(util.getAddonDataPath())
gdb.connect()
doImport, errorMsg = gdb.checkDBStructure()
if(doImport) > 0:
print "RCB: No database available. Won't gather any data."
gdb.close()
return
#cache lookup tables
yearDict = helper.cacheYears(gdb)
publisherDict = helper.cachePublishers(gdb)
developerDict = helper.cacheDevelopers(gdb)
reviewerDict = helper.cacheReviewers(gdb)
genreDict = helper.cacheGenres(gdb)
limit = int(param.replace('limit=', ''))
games = Game(gdb).getMostPlayedGames(limit)
print 'most played games: %s' %games
config = Config(None)
statusOk, errorMsg = config.readXml()
settings = util.getSettings()
import xbmcgui
count = 0
for gameRow in games:
count += 1
try:
print "Gathering data for rom no %i: %s" %(count, gameRow[util.ROW_NAME])
romCollection = config.romCollections[str(gameRow[util.GAME_romCollectionId])]
#get artwork that is chosen to be shown in gamelist
files = File(gdb).getFilesByParentIds(gameRow[util.ROW_ID], gameRow[util.GAME_romCollectionId], gameRow[util.GAME_publisherId], gameRow[util.GAME_developerId])
fileDict = helper.cacheFiles(files)
files = helper.getFilesByControl_Cached(gdb, romCollection.imagePlacingMain.fileTypesForGameList, gameRow[util.ROW_ID], gameRow[util.GAME_publisherId], gameRow[util.GAME_developerId], gameRow[util.GAME_romCollectionId], fileDict)
if(files != None and len(files) != 0):
thumb = files[0]
else:
thumb = ""
files = helper.getFilesByControl_Cached(gdb, romCollection.imagePlacingMain.fileTypesForMainViewBackground, gameRow[util.ROW_ID], gameRow[util.GAME_publisherId], gameRow[util.GAME_developerId], gameRow[util.GAME_romCollectionId], fileDict)
if(files != None and len(files) != 0):
fanart = files[0]
else:
fanart = ""
description = gameRow[util.GAME_description]
if(description == None):
description = ""
year = helper.getPropertyFromCache(gameRow, yearDict, util.GAME_yearId, util.ROW_NAME)
publisher = helper.getPropertyFromCache(gameRow, publisherDict, util.GAME_publisherId, util.ROW_NAME)
developer = helper.getPropertyFromCache(gameRow, developerDict, util.GAME_developerId, util.ROW_NAME)
genre = genreDict[gameRow[util.ROW_ID]]
maxplayers = helper.saveReadString(gameRow[util.GAME_maxPlayers])
rating = helper.saveReadString(gameRow[util.GAME_rating])
votes = helper.saveReadString(gameRow[util.GAME_numVotes])
url = helper.saveReadString(gameRow[util.GAME_url])
region = helper.saveReadString(gameRow[util.GAME_region])
media = helper.saveReadString(gameRow[util.GAME_media])
perspective = helper.saveReadString(gameRow[util.GAME_perspective])
controllertype = helper.saveReadString(gameRow[util.GAME_controllerType])
originaltitle = helper.saveReadString(gameRow[util.GAME_originalTitle])
alternatetitle = helper.saveReadString(gameRow[util.GAME_alternateTitle])
translatedby = helper.saveReadString(gameRow[util.GAME_translatedBy])
version = helper.saveReadString(gameRow[util.GAME_version])
playcount = helper.saveReadString(gameRow[util.GAME_launchCount])
#get launch command
filenameRows = File(gdb).getRomsByGameId(gameRow[util.ROW_ID])
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Id" %count, str(gameRow[util.ROW_ID]))
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Console" %count, romCollection.name)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Title" %count, gameRow[util.ROW_NAME])
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Thumb" %count, thumb)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Fanart" %count, fanart)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Plot" %count, description)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Year" %count, year)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Publisher" %count, publisher)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Developer" %count, developer)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Genre" %count, genre)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Maxplayers" %count, maxplayers)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Region" %count, region)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Media" %count, media)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Perspective" %count, perspective)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Controllertype" %count, controllertype)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Playcount" %count, playcount)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Rating" %count, rating)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Votes" %count, votes)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Url" %count, url)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Originaltitle" %count, originaltitle)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Alternatetitle" %count, alternatetitle)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Translatedby" %count, translatedby)
xbmcgui.Window(10000).setProperty("MostPlayedROM.%d.Version" %count, version)
except Exception, (exc):
print 'RCB: Error while getting most played games: ' +str(exc)
util.install("python-dateutil")
from dateutil import tz
try:
import psutil
except:
util.install("psutil")
import psutil
try:
import cv2
except:
util.install("opencv-contrib-python")
import cv2
settings = util.getSettings()
startDelay = settings["startDelay"]
recordingTime = settings["recordingTime"]
showImages = settings["showImages"]
timezone = tz.gettz(settings["timeZone"])
cap = cv2.VideoCapture(0)
backSub = cv2.createBackgroundSubtractorKNN()
activeState = False
active = False
armed = False
timer = None
startDelayTimer = None
notifacationThread = None
out = None
frame = None
class NfoWriter(RcbXmlReaderWriter):
Settings = util.getSettings()
def __init__(self):
pass
def exportLibrary(self, gdb, romCollections):
Logutil.log("Begin exportLibrary", util.LOG_LEVEL_INFO)
progressDialog = dialogprogress.ProgressDialogGUI()
#32169 = Export library...
progressDialog.create(util.localize(32169))
continueExport = True
rccount = 1
for romCollection in list(romCollections.values()):
#32170 = Exporting Rom Collection
messageRomCollections = "%s (%i / %i): %s" % (util.localize(
32170), rccount, len(romCollections), romCollection.name)
rccount = rccount + 1
Logutil.log("export Rom Collection: " + romCollection.name,
util.LOG_LEVEL_INFO)
gameCount = 1
#get all games for this Rom Collection
games = GameView(gdb).getFilteredGames(romCollection.id, 0, 0, 0,
0, 0, 0, 0, 0, '0 = 0', '',
0)
progressDialog.itemCount = len(games) + 1
for game in games:
#32171 = Export game
message = "%s[CR]%s: %s" % (messageRomCollections,
util.localize(32171),
str(game[GameView.COL_NAME]))
continueExport = progressDialog.writeMsg(message, gameCount)
if not continueExport:
Logutil.log('Game export canceled by user',
util.LOG_LEVEL_INFO)
break
gameCount = gameCount + 1
romfiles = File(gdb).getRomsByGameId(game[GameView.COL_ID])
first_rom = romfiles[0]
gamenameFromFile = romCollection.getGamenameFromFilename(
first_rom[0])
artworkfiles = {}
artworkurls = []
self.createNfoFromDesc(game, romCollection.name, first_rom[0],
gamenameFromFile, artworkfiles,
artworkurls)
progressDialog.writeMsg("", -1)
del progressDialog
def createNfoFromDesc(self, game, platform, romFile, gameNameFromFile,
artworkfiles, artworkurls):
Logutil.log("Begin createNfoFromDesc", util.LOG_LEVEL_INFO)
nfoFile = self.getNfoFilePath(platform, romFile, gameNameFromFile)
if nfoFile == '':
log.debug(u"Not writing NFO file for {0}".format(gameNameFromFile))
return
root = ET.Element('game')
#reference to eventually existing nfo
existing_nfo = None
#Read info from existing nfo file. New info and existing info will be merged
if xbmcvfs.exists(nfoFile):
fh = xbmcvfs.File(nfoFile)
existing_nfo = ET.fromstring(fh.read())
fh.close()
self.write_from_db_or_nfo(game[GameView.COL_NAME], existing_nfo, root,
'title')
self.write_from_db_or_nfo(game[GameView.COL_originalTitle],
existing_nfo, root, 'originalTitle')
self.write_from_db_or_nfo(game[GameView.COL_alternateTitle],
existing_nfo, root, 'alternateTitle')
self.write_from_db_or_nfo(platform, existing_nfo, root, 'platform')
self.write_from_db_or_nfo(game[GameView.COL_description], existing_nfo,
root, 'plot')
self.write_from_db_or_nfo(game[GameView.COL_publisher], existing_nfo,
root, 'publisher')
self.write_from_db_or_nfo(game[GameView.COL_developer], existing_nfo,
root, 'developer')
self.write_from_db_or_nfo(game[GameView.COL_year], existing_nfo, root,
'year')
self.write_from_db_or_nfo(game[GameView.COL_url], existing_nfo, root,
'detailUrl')
self.write_from_db_or_nfo(game[GameView.COL_maxPlayers], existing_nfo,
root, 'maxPlayer')
self.write_from_db_or_nfo(game[GameView.COL_region], existing_nfo,
root, 'region')
self.write_from_db_or_nfo(game[GameView.COL_media], existing_nfo, root,
'media')
self.write_from_db_or_nfo(game[GameView.COL_perspective], existing_nfo,
root, 'perspective')
self.write_from_db_or_nfo(game[GameView.COL_controllerType],
existing_nfo, root, 'controller')
self.write_from_db_or_nfo(game[GameView.COL_version], existing_nfo,
root, 'version')
self.write_from_db_or_nfo(game[GameView.COL_rating], existing_nfo,
root, 'rating')
self.write_from_db_or_nfo(game[GameView.COL_numVotes], existing_nfo,
root, 'votes')
self.write_from_db_or_nfo(game[GameView.COL_isFavorite], existing_nfo,
root, 'isFavorite')
self.write_from_db_or_nfo(game[GameView.COL_launchCount], existing_nfo,
root, 'launchCount')
"""
for elem in ['title', 'originalTitle', 'alternateTitle', 'platform', 'plot', 'publisher', 'developer', 'year',
'detailUrl', 'maxPlayer', 'region', 'media', 'perspective', 'controller', 'version', 'rating',
'votes', 'isFavorite', 'launchCount']:
elemText = locals()[elem]
#if new info is empty, check if the existing file has it
if existing_nfo and not elemText:
try:
elemText = existing_nfo.find(elem).text
except:
pass
ET.SubElement(root, elem).text = elemText
"""
genreList = []
if game[GameView.COL_genre]:
for genre in game[GameView.COL_genre].split(', '):
if genre != 'None':
genreList.append(genre)
#if no genre was given, use genres from existing file
if existing_nfo and len(genreList) == 0:
for genre in existing_nfo.findall("genre"):
genreList.append(genre.text)
for genre in genreList:
ET.SubElement(root, 'genre').text = genre
for artworktype in list(artworkfiles.keys()):
local = ''
online = ''
try:
local = artworkfiles[artworktype][0]
online = artworkurls[artworktype.name]
except:
pass
try:
SubElement(root, 'thumb', {
'type': artworktype.name,
'local': local
}).text = online
except Exception as exc:
Logutil.log('Error writing artwork url: ' + str(exc),
util.LOG_LEVEL_WARNING)
self.writeNfoElementToFile(root, platform, romFile, gameNameFromFile,
nfoFile)
def write_from_db_or_nfo(self, value_from_db, existing_nfo, root,
elementname):
val = ''
if value_from_db:
val = value_from_db
else:
if existing_nfo:
try:
val = existing_nfo.find(elementname).text
except:
pass
ET.SubElement(root, elementname).text = val
def writeNfoElementToFile(self, root, platform, romFile, gameNameFromFile,
nfoFile):
# write file
try:
self.indentXml(root)
tree = ElementTree(root)
log.info(u"Writing NFO file {0}".format(nfoFile))
localFile = util.joinPath(util.getTempDir(),
os.path.basename(nfoFile))
tree.write(localFile, encoding="UTF-8", xml_declaration=True)
xbmcvfs.copy(localFile, nfoFile)
xbmcvfs.delete(localFile)
except Exception as exc:
log.warn(u"Error: Cannot write game nfo for {0}: {1}".format(
gameNameFromFile, exc))
def getNfoFilePath(self, romCollectionName, romFile, gameNameFromFile):
nfoFile = ''
nfoFolder = self.Settings.getSetting(util.SETTING_RCB_NFOFOLDER)
if nfoFolder != '' and nfoFolder != None:
# Add the trailing slash that xbmcvfs.exists expects
nfoFolder = os.path.join(os.path.dirname(nfoFolder), '')
if not xbmcvfs.exists(nfoFolder):
Logutil.log("Path to nfoFolder does not exist: " + nfoFolder,
util.LOG_LEVEL_WARNING)
else:
nfoFolder = os.path.join(nfoFolder, romCollectionName)
if not os.path.exists(nfoFolder):
os.mkdir(nfoFolder)
nfoFile = os.path.join(nfoFolder, gameNameFromFile + '.nfo')
if nfoFile == '':
romDir = os.path.dirname(romFile)
Logutil.log('Romdir: ' + romDir, util.LOG_LEVEL_INFO)
nfoFile = os.path.join(romDir, gameNameFromFile + '.nfo')
log.debug(
u"%s returns %s for %s (%s) on platform %s" %
(__name__, nfoFile, gameNameFromFile, romFile, romCollectionName))
return nfoFile
class NfoWriter:
Settings = util.getSettings()
def __init__(self):
pass
def exportLibrary(self, gui):
Logutil.log("Begin exportLibrary", util.LOG_LEVEL_INFO)
gdb = gui.gdb
romCollections = gui.config.romCollections
progressDialog = dialogprogress.ProgressDialogGUI()
progressDialog.writeMsg(util.localize(32169), "", "")
continueExport = True
rccount = 1
for romCollection in gui.config.romCollections.values():
progDialogRCHeader = util.localize(32170) + " (%i / %i): %s" % (
rccount, len(romCollections), romCollection.name)
rccount = rccount + 1
Logutil.log("export Rom Collection: " + romCollection.name,
util.LOG_LEVEL_INFO)
gameCount = 1
#get all games for this Rom Collection
games = Game(gdb).getFilteredGames(romCollection.id, 0, 0, 0,
False, '0 = 0')
progressDialog.itemCount = len(games) + 1
for gameRow in games:
gamename = self.getGameProperty(gameRow[util.ROW_NAME])
continueExport = progressDialog.writeMsg(
progDialogRCHeader,
util.localize(32171) + ": " + str(gamename), "", gameCount)
if (not continueExport):
Logutil.log('Game export canceled by user',
util.LOG_LEVEL_INFO)
break
gameCount = gameCount + 1
plot = self.getGameProperty(gameRow[util.GAME_description])
publisher = self.getGamePropertyFromCache(
gameRow, gui.publisherDict, util.GAME_publisherId,
util.ROW_NAME)
developer = self.getGamePropertyFromCache(
gameRow, gui.developerDict, util.GAME_developerId,
util.ROW_NAME)
year = self.getGamePropertyFromCache(gameRow, gui.yearDict,
util.GAME_yearId,
util.ROW_NAME)
genreList = []
try:
cachingOptionStr = self.Settings.getSetting(
util.SETTING_RCB_CACHINGOPTION)
if (cachingOptionStr == 'CACHEALL'):
genre = gui.genreDict[gameRow[util.ROW_ID]]
else:
genres = Genre(gdb).getGenresByGameId(
gameRow[util.ROW_ID])
if (genres != None):
for i in range(0, len(genres)):
genreRow = genres[i]
genreList.append(genreRow[util.ROW_NAME])
except:
pass
players = self.getGameProperty(gameRow[util.GAME_maxPlayers])
rating = self.getGameProperty(gameRow[util.GAME_rating])
votes = self.getGameProperty(gameRow[util.GAME_numVotes])
url = self.getGameProperty(gameRow[util.GAME_url])
region = self.getGameProperty(gameRow[util.GAME_region])
media = self.getGameProperty(gameRow[util.GAME_media])
perspective = self.getGameProperty(
gameRow[util.GAME_perspective])
controller = self.getGameProperty(
gameRow[util.GAME_controllerType])
originalTitle = self.getGameProperty(
gameRow[util.GAME_originalTitle])
alternateTitle = self.getGameProperty(
gameRow[util.GAME_alternateTitle])
version = self.getGameProperty(gameRow[util.GAME_version])
#user settings
isFavorite = self.getGameProperty(
gameRow[util.GAME_isFavorite])
launchCount = self.getGameProperty(
gameRow[util.GAME_launchCount])
romFiles = File(gdb).getRomsByGameId(gameRow[util.ROW_ID])
romFile = ''
if (romFiles != None and len(romFiles) > 0):
romFile = romFiles[0][0]
gamenameFromFile = helper.getGamenameFromFilename(
romFile, romCollection)
artworkfiles = {}
artworkurls = []
self.createNfoFromDesc(
gamename, plot, romCollection.name, publisher, developer,
year, players, rating, votes, url, region, media,
perspective, controller, originalTitle, alternateTitle,
version, genreList, isFavorite, launchCount, romFile,
gamenameFromFile, artworkfiles, artworkurls)
progressDialog.writeMsg("", "", "", -1)
del progressDialog
def createNfoFromDesc(self, gamename, plot, romCollectionName, publisher,
developer, year, players, rating, votes, url, region,
media, perspective, controller, originalTitle,
alternateTitle, version, genreList, isFavorite,
launchCount, romFile, gameNameFromFile, artworkfiles,
artworkurls):
Logutil.log("Begin createNfoFromDesc", util.LOG_LEVEL_INFO)
root = Element('game')
SubElement(root, 'title').text = gamename
SubElement(root, 'originalTitle').text = originalTitle
SubElement(root, 'alternateTitle').text = alternateTitle
SubElement(root, 'platform').text = romCollectionName
SubElement(root, 'plot').text = plot
SubElement(root, 'publisher').text = publisher
SubElement(root, 'developer').text = developer
SubElement(root, 'year').text = year
for genre in genreList:
SubElement(root, 'genre').text = str(genre)
SubElement(root, 'detailUrl').text = url
SubElement(root, 'maxPlayer').text = players
SubElement(root, 'region').text = region
SubElement(root, 'media').text = media
SubElement(root, 'perspective').text = perspective
SubElement(root, 'controller').text = controller
SubElement(root, 'version').text = version
SubElement(root, 'rating').text = rating
SubElement(root, 'votes').text = votes
SubElement(root, 'isFavorite').text = isFavorite
SubElement(root, 'launchCount').text = launchCount
for artworktype in artworkfiles.keys():
local = ''
online = ''
try:
local = artworkfiles[artworktype][0]
online = str(artworkurls[artworktype.name])
except:
pass
try:
SubElement(root, 'thumb', {
'type': artworktype.name,
'local': local
}).text = online
except Exception, (exc):
Logutil.log('Error writing artwork url: ' + str(exc),
util.LOG_LEVEL_WARNING)
pass
#write file
try:
util.indentXml(root)
tree = ElementTree(root)
nfoFile = self.getNfoFilePath(romCollectionName, romFile,
gameNameFromFile)
if (nfoFile != ''):
if (nfoFile.startswith('smb://')):
localFile = util.joinPath(util.getTempDir(),
os.path.basename(nfoFile))
tree.write(localFile)
xbmcvfs.copy(localFile, nfoFile)
xbmcvfs.delete(localFile)
else:
tree.write(nfoFile)
except Exception, (exc):
Logutil.log("Error: Cannot write file game.nfo: " + str(exc),
util.LOG_LEVEL_WARNING)
parser.add_option("-n", "--center", action="store_true", dest="center", default=False)
parser.add_option("-i", "--image", action="store_true", dest="image", default=False)
options, args = parser.parse_args()
# Make sure required arguments are present
for req in ("width", "height", "tool"):
if getattr(options, req, None) is None:
print "ERROR: Missing required argument '%s'" % req
print USAGE.strip() % argv[0]
exit(1)
# Check positional arguments
if len(args) <> 1:
print "ERROR: Missing output file"
print USAGE.strip() % argv[0]
exit(1)
# Load defaults
getSettings(CONTROL, options)
# Show current settings
print "Selected options:"
for k in sorted(CONTROL.keys()):
if not (k in ("prefix", "suffix")):
print " %-10s: %s" % (k, str(CONTROL[k]))
# Get the filename
name, ext = splitext(args[0])
if ext == "":
ext = ".ngc"
filename = name + ext
# Generate the gcode
print "\nCreating file '%s'" % args[0]
gcode = GCode()
if options.center:
centerCut(gcode)
dest="image",
default=False)
options, args = parser.parse_args()
# Make sure required arguments are present
for req in ("width", "height", "tool"):
if getattr(options, req, None) is None:
print "ERROR: Missing required argument '%s'" % req
print USAGE.strip() % argv[0]
exit(1)
# Check positional arguments
if len(args) <> 1:
print "ERROR: Missing output file"
print USAGE.strip() % argv[0]
exit(1)
# Load defaults
getSettings(CONTROL, options)
# Show current settings
print "Selected options:"
for k in sorted(CONTROL.keys()):
if not (k in ("prefix", "suffix")):
print " %-10s: %s" % (k, str(CONTROL[k]))
# Get the filename
name, ext = splitext(args[0])
if ext == "":
ext = ".ngc"
filename = name + ext
# Generate the gcode
print "\nCreating file '%s'" % args[0]
gcode = GCode()
if options.center:
centerCut(gcode)
class NfoWriter(RcbXmlReaderWriter):
Settings = util.getSettings()
def __init__(self):
pass
def exportLibrary(self, gdb, romCollections):
Logutil.log("Begin exportLibrary", util.LOG_LEVEL_INFO)
progressDialog = dialogprogress.ProgressDialogGUI()
progressDialog.writeMsg(util.localize(32169), "", "")
continueExport = True
rccount = 1
for romCollection in romCollections.values():
progDialogRCHeader = util.localize(32170) + " (%i / %i): %s" % (
rccount, len(romCollections), romCollection.name)
rccount = rccount + 1
Logutil.log("export Rom Collection: " + romCollection.name,
util.LOG_LEVEL_INFO)
gameCount = 1
#get all games for this Rom Collection
games = GameView(gdb).getFilteredGames(romCollection.id, 0, 0, 0,
0, 0, 0, 0, 0, '0 = 0', '',
0)
progressDialog.itemCount = len(games) + 1
for game in games:
continueExport = progressDialog.writeMsg(
progDialogRCHeader,
util.localize(32171) + ": " + str(game[GameView.COL_NAME]),
"", gameCount)
if not continueExport:
Logutil.log('Game export canceled by user',
util.LOG_LEVEL_INFO)
break
gameCount = gameCount + 1
romfiles = File(gdb).getRomsByGameId(game[GameView.COL_ID])
first_rom = romfiles[0]
gamenameFromFile = romCollection.getGamenameFromFilename(
first_rom[0])
artworkfiles = {}
artworkurls = []
self.createNfoFromDesc(game, romCollection.name, first_rom[0],
gamenameFromFile, artworkfiles,
artworkurls)
progressDialog.writeMsg("", "", "", -1)
del progressDialog
def createNfoFromDesc(self, game, platform, romFile, gameNameFromFile,
artworkfiles, artworkurls):
Logutil.log("Begin createNfoFromDesc", util.LOG_LEVEL_INFO)
nfoFile = self.getNfoFilePath(platform, romFile, gameNameFromFile)
if nfoFile == '':
log.debug(u"Not writing NFO file for {0}".format(gameNameFromFile))
return
root = ET.Element('game')
#reference to eventually existing nfo
existing_nfo = None
#Read info from existing nfo file. New info and existing info will be merged
if xbmcvfs.exists(nfoFile):
fh = xbmcvfs.File(nfoFile)
existing_nfo = ET.fromstring(fh.read())
fh.close()
self.write_from_db_or_nfo(game[GameView.COL_NAME], existing_nfo, root,
'title')
self.write_from_db_or_nfo(game[GameView.COL_originalTitle],
existing_nfo, root, 'originalTitle')
self.write_from_db_or_nfo(game[GameView.COL_alternateTitle],
existing_nfo, root, 'alternateTitle')
self.write_from_db_or_nfo(platform, existing_nfo, root, 'platform')
self.write_from_db_or_nfo(game[GameView.COL_description], existing_nfo,
root, 'plot')
self.write_from_db_or_nfo(game[GameView.COL_publisher], existing_nfo,
root, 'publisher')
self.write_from_db_or_nfo(game[GameView.COL_developer], existing_nfo,
root, 'developer')
self.write_from_db_or_nfo(game[GameView.COL_year], existing_nfo, root,
'year')
self.write_from_db_or_nfo(game[GameView.COL_url], existing_nfo, root,
'detailUrl')
self.write_from_db_or_nfo(game[GameView.COL_maxPlayers], existing_nfo,
root, 'maxPlayer')
self.write_from_db_or_nfo(game[GameView.COL_region], existing_nfo,
root, 'region')
self.write_from_db_or_nfo(game[GameView.COL_media], existing_nfo, root,
'media')
self.write_from_db_or_nfo(game[GameView.COL_perspective], existing_nfo,
root, 'perspective')
self.write_from_db_or_nfo(game[GameView.COL_controllerType],
existing_nfo, root, 'controller')
self.write_from_db_or_nfo(game[GameView.COL_version], existing_nfo,
root, 'version')
self.write_from_db_or_nfo(game[GameView.COL_rating], existing_nfo,
root, 'rating')
self.write_from_db_or_nfo(game[GameView.COL_numVotes], existing_nfo,
root, 'votes')
self.write_from_db_or_nfo(game[GameView.COL_isFavorite], existing_nfo,
root, 'isFavorite')
self.write_from_db_or_nfo(game[GameView.COL_launchCount], existing_nfo,
root, 'launchCount')
"""
for elem in ['title', 'originalTitle', 'alternateTitle', 'platform', 'plot', 'publisher', 'developer', 'year',
'detailUrl', 'maxPlayer', 'region', 'media', 'perspective', 'controller', 'version', 'rating',
'votes', 'isFavorite', 'launchCount']:
elemText = locals()[elem]
#if new info is empty, check if the existing file has it
if existing_nfo and not elemText:
try:
elemText = existing_nfo.find(elem).text
except:
pass
ET.SubElement(root, elem).text = elemText
"""
genreList = []
if game[GameView.COL_genre]:
for genre in game[GameView.COL_genre].split(', '):
if genre != 'None':
genreList.append(genre)
#if no genre was given, use genres from existing file
if existing_nfo and len(genreList) == 0:
for genre in existing_nfo.findall("genre"):
genreList.append(genre.text)
for genre in genreList:
ET.SubElement(root, 'genre').text = genre
for artworktype in artworkfiles.keys():
local = ''
online = ''
try:
local = artworkfiles[artworktype][0]
online = artworkurls[artworktype.name]
except:
pass
try:
SubElement(root, 'thumb', {
'type': artworktype.name,
'local': local
}).text = online
except Exception, (exc):
Logutil.log('Error writing artwork url: ' + str(exc),
util.LOG_LEVEL_WARNING)
self.writeNfoElementToFile(root, platform, romFile, gameNameFromFile,
nfoFile)
from copy import deepcopy
from sys import argv, exit
import algorithms
import memory
import util
import time
import timeit
import matplotlib.pyplot as plt
if __name__ == '__main__':
settings = []
if len(argv) == 3 and argv[1] == '-f':
file = open(argv[2], 'r')
settings = util.getSettings(file)
file.close()
elif len(argv) == 5 and argv[1] == '-g':
settings = util.generateSettings(int(argv[2]), int(argv[3]),
int(argv[4]))
elif len(argv) == 6 and argv[1] == '-g':
settings = util.generateSettings(int(argv[2]), int(argv[3]),
int(argv[4]), str(argv[5]))
else:
print('ERROR. Use core.py <settings file>')
exit()
if settings is None:
exit()
memory = memory.Memory(deepcopy(settings[0]), deepcopy(settings[1]))
startOptimalAlgorithm = time.perf_counter_ns()
def run():
settingsFileJson = util.getSettings()
#Can't figure out how to get list input to actually translate
settingsJson = json.loads("""{}""")
defaultsJson = json.loads("""{
\"videoOut\": \"../Recordings/\",
\"fileNameFormat\": \"%d-%m-%Y_%H%M\",
\"showImages\": false,
\"websiteOn\": true
}""")
settingsList = [
"emailAddress", #email to send alerts from
"alertEnabled", #whether or not to send alerts
"videoOut", #location of the video files recorded example: ../Recordings/
"fileNameFormat", #date format for filename https://www.tutorialkart.com/python/python-datetime/python-datetime-format/
"showImages", #whether or not to show the images
"alertMessage", #message sent in alert email
"websiteOn", #whether or not to run the website
"clearCommand", #not used anymore but os specific clear cmd
"timeZone", #IANA timezone
"websiteOffset", #all website pages will be based on this directory so that no rando can easily look at your camera.
"websitePassword"
]
settingsPasswordList = [
"emailPassword" #sender email passowrd
]
settingsNumberList = [
"recordingTime", #how long after motion is detected that the frames will keep getting written to a file
"startDelay", #how long after starting to arm
"outfileFramerate", #framerate of out files
"loopDelay" #delay in program looops
]
settingsListList = [
"alertGroup" #list of emails to send alert to, /stop to stop prompting
]
#need to implement way of making this list get taken as input
for item in settingsList:
if item in settingsFileJson:
settingsJson[item] = settingsFileJson[item]
else:
if item in defaultsJson:
settingsJson[item] = defaultsJson[item]
else:
userIn = input(item + ": ")
userIn = userIn.strip()
if (userIn == "true" or userIn == "yes") or userIn == "y":
settingsJson[item] = True
else:
if (userIn == "false" or userIn == "no") or userIn == "n":
settingsJson[item] = False
else:
settingsJson[item] = userIn
for item in settingsPasswordList:
if item in settingsFileJson:
settingsJson[item] = settingsFileJson[item]
else:
userIn = getpass.getpass(prompt=item + ": ")
settingsJson[item] = userIn
#NEED to encrypt this
for item in settingsNumberList:
if item in settingsFileJson:
settingsJson[item] = settingsFileJson[item]
else:
if item in defaultsJson:
seetingsJson[item] = defaultsJson[item]
else:
userIn = input(item + ": ")
settingsJson[item] = float(userIn)
outList = []
for item in settingsListList:
if item in settingsFileJson:
settingsJson[item] = settingsFileJson[item]
else:
if item in defaultsJson:
seetingsJson[item] = defaultsJson[item]
else:
while True:
userIn = input(item + ": ")
if userIn == "/stop":
break
outList += [userIn]
settingsJson[item] = outList
with open("settings.json", "w") as out:
json.dump(settingsJson, out, indent=4)
class NfoWriter(RcbXmlReaderWriter):
Settings = util.getSettings()
def __init__(self):
pass
def exportLibrary(self, gdb, romCollections):
Logutil.log("Begin exportLibrary", util.LOG_LEVEL_INFO)
progressDialog = dialogprogress.ProgressDialogGUI()
progressDialog.writeMsg(util.localize(32169), "", "")
continueExport = True
rccount = 1
for romCollection in romCollections.values():
progDialogRCHeader = util.localize(32170) + " (%i / %i): %s" % (
rccount, len(romCollections), romCollection.name)
rccount = rccount + 1
Logutil.log("export Rom Collection: " + romCollection.name,
util.LOG_LEVEL_INFO)
gameCount = 1
#get all games for this Rom Collection
games = Game(gdb).getGamesByFilter(romCollection.id, 0, 0, 0,
False, '0 = 0')
progressDialog.itemCount = len(games) + 1
for game in games:
continueExport = progressDialog.writeMsg(
progDialogRCHeader,
util.localize(32171) + ": " + str(game.name), "",
gameCount)
if (not continueExport):
Logutil.log('Game export canceled by user',
util.LOG_LEVEL_INFO)
break
gameCount = gameCount + 1
gamenameFromFile = romCollection.getGamenameFromFilename(
game.firstRom)
artworkfiles = {}
artworkurls = []
genreList = []
if game.genre:
for genre in game.genre.split(', '):
if genre != 'None':
genreList.append(genre)
self.createNfoFromDesc(
game.name, game.plot, romCollection.name, game.publisher,
game.developer, game.year, game.maxplayers, game.rating,
game.votes, game.url, game.region, game.media,
game.perspective, game.controllerType, game.originalTitle,
game.alternateTitle, game.version, genreList,
game.isFavorite, game.playcount, game.firstRom,
gamenameFromFile, artworkfiles, artworkurls)
progressDialog.writeMsg("", "", "", -1)
del progressDialog
def createNfoFromDesc(self, title, plot, platform, publisher, developer,
year, maxPlayer, rating, votes, detailUrl, region,
media, perspective, controller, originalTitle,
alternateTitle, version, genreList, isFavorite,
launchCount, romFile, gameNameFromFile, artworkfiles,
artworkurls):
Logutil.log("Begin createNfoFromDesc", util.LOG_LEVEL_INFO)
nfoFile = self.getNfoFilePath(platform, romFile, gameNameFromFile)
if nfoFile == '':
log.debug(u"Not writing NFO file for {0}".format(gameNameFromFile))
return
root = ET.Element('game')
#reference to eventually existing nfo
existing_nfo = None
#Read info from existing nfo file. New info and existing info will be merged
if xbmcvfs.exists(nfoFile):
existing_nfo = ET.ElementTree()
if sys.version_info >= (2, 7):
parser = ET.XMLParser(encoding='utf-8')
else:
parser = ET.XMLParser()
existing_nfo.parse(nfoFile, parser)
for elem in [
'title', 'originalTitle', 'alternateTitle', 'platform', 'plot',
'publisher', 'developer', 'year', 'detailUrl', 'maxPlayer',
'region', 'media', 'perspective', 'controller', 'version',
'rating', 'votes', 'isFavorite', 'launchCount'
]:
elemText = locals()[elem]
#if new info is empty, check if the existing file has it
if existing_nfo and not elemText:
try:
elemText = existing_nfo.find(elem).text
except:
pass
ET.SubElement(root, elem).text = elemText
#if no genre was given, use genres from existing file
if existing_nfo and len(genreList) == 0:
for genre in existing_nfo.findall("genre"):
genreList.append(genre.text)
for genre in genreList:
ET.SubElement(root, 'genre').text = genre
for artworktype in artworkfiles.keys():
local = ''
online = ''
try:
local = artworkfiles[artworktype][0]
online = artworkurls[artworktype.name]
except:
pass
try:
SubElement(root, 'thumb', {
'type': artworktype.name,
'local': local
}).text = online
except Exception, (exc):
Logutil.log('Error writing artwork url: ' + str(exc),
util.LOG_LEVEL_WARNING)
pass
self.writeNfoElementToFile(root, platform, romFile, gameNameFromFile,
nfoFile)
