def _get_data(self, url):
report = RCReport()
data = {
'editor': None,
'release_date': None,
'genre': None,
'rating': None,
'note': None,
'resume': None,
'image': None
}
if not self.is_first_request:
sleep(REQUEST_SLEEP_TIME)
try:
resp = self._request(url)
html = BeautifulSoup(resp, 'lxml')
# Sélection des champs qui nous intéresse.
note = html.select('#coreGameScore .scoreHi')
# Récupération du resume
desc_block = html.find(class_='col-md-8')
resume = ''
if desc_block != None:
if desc_block != None:
for elem in desc_block.find('h2').next_siblings:
if type(
elem
) != NavigableString and 'class' in elem.attrs and 'sideBarLinks' in elem[
'class']:
break
resume += elem.string or '\n'
data['resume'] = resume
if len(note) > 0:
data['note'] = note[0].text.strip()
else:
return -1
except RCException:
pass
self.is_first_request = False
return data
def search(self, game):
"""
Lance la recherche du jeu.
Renvoi -1 si aucune info' trouvée, -2 si un erreur HTTP survient.
"""
report = RCReport()
link = self._search_game(game)
data = None
if link == None:
return -1
elif link == -2:
return -2
else:
data = self._get_data(link)
return data
def _second_stage(self):
"""
2e étape : sélectionne la version d'un jeu qui correspond au mieux aux critères, parmis les différentes versions.
Sélection le jeu par ordre de préférence du pays. Si indiqué, la version du dump doit être la plus récente.
Avec ces critères, un score est calculé pour chaque version d'un jeu. La version qui a le score le plus élevé
est sélectionnée.
"""
report = RCReport()
for (game, editions) in self.temp_games.items():
report.log('\t' + game + ' : ' + str(len(editions)) + ' declinations.', 2)
highestScore = None
lastScore = 0
self.total_editions += len(editions)
# Calcule du score des éditions.
if len(editions) > 1:
for i, edition in enumerate(editions):
score = edition['score']
if edition['country'] != None:
score += self.countries.index(edition['country'])
else:
score -= 1
score += edition['version']
if score >= lastScore:
# On déplace le dernier jeu meilleur score, comme ce n'est plus lui.
if highestScore != None and self.move_temp_games:
self.move_games.append(editions[highestScore]['game_name'])
lastScore = score
highestScore = i
elif self.move_temp_games:
# On déplace le jeu, car son score n'est pas le meilleur.
self.move_games.append(edition['game_name'])
else:
highestScore = 0
self.games[game] = editions[highestScore]
report.log('\t\t>> Choice : ' + self.games[game]['game_name'], 2)
def _rename_game_files(self):
report = RCReport()
report.log('CHECKING FOR GAMES TO BE RENAMED ...')
for (i, game) in self.games.items():
if game['game_name'] != game['original_name']:
file_info = self.list[game['original_name']]
game_dir = os.path.normpath(file_info['dir'])
game_original_path = os.path.join(game_dir, game['original_name'] + '.' + file_info['ext'])
game_new_path = os.path.join(game_dir, game['game_name'] + '.' + file_info['ext'])
os.rename(game_original_path, game_new_path)
# On doit regénérer la base de données (pour CacheParser)
self.generate = True
report.log('\t"' + game['original_name'] + '" renamed to "' + game['game_name'] + '"', 2)
def _first_stage(self):
report = RCReport()
regex = re.compile(RCRomParser.regex, re.IGNORECASE)
for (game_name, game_file) in self.list.items():
filename = game_name
game_name = clean_filename(game_name)
country = None
version = None
hack = None
good = None
fixe = None
special = None
flag_ver = None
flags = None
media = None
media_n = None
side = None
ok_flags = None
move = False
report.log('\t' + game_name, 2)
for field in regex.finditer(game_name):
temp_country = field.group('field')
temp_flags = field.group('flags')
version = version or field.group('version')
hack = hack or field.group('hack1') or field.group('hack2')
good = good or field.group('good')
fixe = fixe or field.group('fixe')
special = special or field.group('special')
flag_ver = flag_ver or field.group('flag_version')
media = media or field.group('media')
media_n = media_n or (int(field.group('media_n')) if
field.group('media_n') != None else None)
side = side or field.group('side')
if temp_country in self.countries or temp_country in self.exclude_countries:
country = country or temp_country
if temp_flags in self.ok_flags and flags == None:
ok_flags = ok_flags or temp_flags
else:
flags = temp_flags
ok_flags = None
# On conserve que les meilleures dump
if special != None and not self.config.get(self.system, 'special'):
report.log('\t\t- Special game not allowed (' + special + ')',
3)
move = True
elif media_n != None and media_n > 1:
report.log('\t\t- Not the first media (' + str(media_n) + ')',
3)
continue # On ne déplace pas le jeu, celui-ci doit rester dans le dossier.
# Si c'est un hack, on vérifie si on les autorise
elif hack != None and self.config.get(self.system, 'only_legit'):
report.log('\t\t- Not legit', 3)
move = True
# Si il y a n'importe quel autre flag, on ne garde pas
elif good == None and fixe == None and ok_flags == None and flags != None:
report.log('\t\t- Bad dump', 3)
move = True
# On vérifie si on autorise le pays.
elif country == None and not self.config.get(
self.system, 'allow_no_country'):
report.log('\t\t- Country not found', 3)
move = True
elif country != None and country in self.exclude_countries:
report.log('\t\t- Excluded country (' + country + ')', 3)
move = True
# On déplace le jeu si besoin
if move:
self.move_games.append(game_name)
continue
# Nettoyage du nom du jeu
game_clean_name = clean_name(game_name) if not hack else game_name
# Ajout du jeu dans la liste temporaire
if game_clean_name not in self.temp_games:
self.temp_games[game_clean_name] = []
self.temp_games[game_clean_name].append({
'original_name':
filename,
'game_name':
game_name,
'country':
country,
'version':
norm_version(version),
'editor':
None,
'year':
None,
'genre':
None,
'resume':
None,
'note':
None,
'rating':
None,
'score':
100 if flags == None or hack != None else
self._calc_flag_score(good, fixe, flag_ver),
'onlineData': {
'state': False
}
})
report.log(
'\t\t+ Preselected game. Clean name : ' + game_clean_name, 2)
def _first_stage(self):
report = RCReport()
regex = re.compile(RCRomParser.regex, re.IGNORECASE)
for (game_name, game_file) in self.list.items():
filename = game_name
game_name = clean_filename(game_name)
country = None
version = None
hack = None
good = None
fixe = None
special = None
flag_ver = None
flags = None
media = None
media_n = None
side = None
ok_flags = None
move = False
report.log('\t' + game_name, 2)
for field in regex.finditer(game_name):
temp_country = field.group('field')
temp_flags = field.group('flags')
version = version or field.group('version')
hack = hack or field.group('hack1') or field.group('hack2')
good = good or field.group('good')
fixe = fixe or field.group('fixe')
special = special or field.group('special')
flag_ver = flag_ver or field.group('flag_version')
media = media or field.group('media')
media_n = media_n or (int(field.group('media_n')) if field.group('media_n') != None else None)
side = side or field.group('side')
if temp_country in self.countries or temp_country in self.exclude_countries:
country = country or temp_country
if temp_flags in self.ok_flags and flags == None:
ok_flags = ok_flags or temp_flags
else:
flags = temp_flags
ok_flags = None
# On conserve que les meilleures dump
if special != None and not self.config.get(self.system, 'special'):
report.log('\t\t- Special game not allowed (' + special + ')', 3)
move = True
elif media_n != None and media_n > 1:
report.log('\t\t- Not the first media (' + str(media_n) + ')', 3)
continue # On ne déplace pas le jeu, celui-ci doit rester dans le dossier.
# Si c'est un hack, on vérifie si on les autorise
elif hack != None and self.config.get(self.system, 'only_legit'):
report.log('\t\t- Not legit', 3)
move = True
# Si il y a n'importe quel autre flag, on ne garde pas
elif good == None and fixe == None and ok_flags == None and flags != None:
report.log('\t\t- Bad dump', 3)
move = True
# On vérifie si on autorise le pays.
elif country == None and not self.config.get(self.system, 'allow_no_country'):
report.log('\t\t- Country not found', 3)
move = True
elif country != None and country in self.exclude_countries:
report.log('\t\t- Excluded country (' + country + ')', 3)
move = True
# On déplace le jeu si besoin
if move:
self.move_games.append(game_name)
continue
# Nettoyage du nom du jeu
game_clean_name = clean_name(game_name) if not hack else game_name
# Ajout du jeu dans la liste temporaire
if game_clean_name not in self.temp_games:
self.temp_games[game_clean_name] = []
self.temp_games[game_clean_name].append({
'original_name': filename,
'game_name': game_name,
'country': country,
'version': norm_version(version),
'editor': None,
'year': None,
'genre': None,
'resume': None,
'note': None,
'rating': None,
'score': 100 if flags == None or hack != None else self._calc_flag_score(good, fixe, flag_ver),
'onlineData': { 'state': False }
})
report.log('\t\t+ Preselected game. Clean name : ' + game_clean_name, 2)
def main(args=sys.argv):
cmd = init_cmd_line()
system = cmd.system
hyperpause = cmd.hyperpause
cache = cmd.cache
csv = cmd.csv
strl = cmd.strl
config = RCConfig()
base_config = RCConfig()
try:
config_file = codecs.open('config.ini', 'r', 'utf-8')
config_parser = ConfigParser.ConfigParser()
# Parsage de la config'
config_parser.readfp(config_file)
config_file.close()
# On vérifie si le systeme est present dans la conf'
if system not in config_parser.sections():
raise RCException('"' + system + '" is not a registered system.')
elif system == BASE_CONFIG_SECTION:
raise RCException('"' + system + '" is not a valid system name.')
# Montage de la config
config.add_option(system, 'dir', '', str)
config.add_option(system, 'ext', '', str)
config.add_option(system, 'country', '', str)
config.add_option(system, 'exclude_country', '', str)
config.add_option(system, 'allow_no_country', True, bool)
config.add_option(system, 'only_legit', True, bool)
config.add_option(system, 'special', True, bool)
config.add_option(system, 'flags', '', str)
config.add_option(system, 'online_data', False, bool)
config.add_option(system, 'online_data_lang', '', str)
config.add_option(system, 'online_api', '', str)
config.add_option(system, 'download_covers', True, bool)
config.add_option(system, 'is_mame', False, bool)
config.add_option(system, 'dat_file', '', str)
config.add_option(system, 'cat_files', '', str)
config.add_option(system, 'ignore_cat', '', str)
config.add_option(system, 'exclude_cat', '', str)
config.add_option(system, 'move_files', False, bool)
base_config.add_option(BASE_CONFIG_SECTION, 'log_process', True, bool)
base_config.add_option(BASE_CONFIG_SECTION, 'log_level', 1, int)
base_config.add_option(BASE_CONFIG_SECTION, 'log_file', '', str)
base_config.add_option(BASE_CONFIG_SECTION, 'csv_long_string_suffix',
'...', str)
base_config.add_option(BASE_CONFIG_SECTION, 'csv_no_info_str', '???',
str)
# Synchro du fichier avec la config
config.read(config_parser, system)
base_config.read(config_parser, BASE_CONFIG_SECTION)
# On charge le dossier de jeux
cwd = os.path.normpath(config.get(system, 'dir').decode('utf-8'))
games = load_games_dir(cwd, config.get(
system, 'ext')) # NOTE peut-être ne pas charger si use_cache
os.chdir(cwd)
strl_suffix = base_config.get(BASE_CONFIG_SECTION,
'csv_long_string_suffix')
if cache:
cleaner = RCCacheParser(games,
config,
system,
hyperpause=hyperpause,
csv=csv,
strl=strl,
strl_suffix=strl_suffix,
csv_no_info_str=base_config.get(
BASE_CONFIG_SECTION,
'csv_no_info_str'))
elif config.get(system, 'is_mame'):
cleaner = RCMameParser(games,
config,
system,
hyperpause=hyperpause,
csv=csv,
strl=strl,
strl_suffix=strl_suffix,
csv_no_info_str=base_config.get(
BASE_CONFIG_SECTION, 'csv_no_info_str'))
else:
cleaner = RCRomParser(games,
config,
system,
hyperpause=hyperpause,
csv=csv,
strl=strl,
strl_suffix=strl_suffix,
csv_no_info_str=base_config.get(
BASE_CONFIG_SECTION, 'csv_no_info_str'))
report = RCReport(system, base_config)
report.log('ROMC : start cleaning "' + system + '"')
report.log('======================================')
cleaner.clean()
report.log('======================================')
report.log('Done !')
except IOError as e:
print 'ERROR : Unable to open the configuration file.'
except RCException as e:
print 'ERROR : ' + e.message.encode('utf-8')
def _first_stage(self):
""" Ouvre le fichier de base de données du système et enregistre les jeux. """
report = RCReport()
renamed = {}
try:
database = codecs.open(self.system + '.xml', 'r', 'utf-8')
xml = etree.fromstring(database.read())
database.close()
except IOError as e:
raise RCException('Unable to open database for "' + self.system +
'".')
for game in xml.findall('game'):
name = game.find('description').text
manufacturer = game.find('manufacturer')
year = game.find('year')
genre = game.find('genre')
resume = game.find('resume')
note = game.find('note')
rating = game.find('rating')
onlineData = game.find('onlineData')
filename = game.get('name')
game_name = clean_filename(filename)
# On vérifie si le jeu est nouveau
if filename in self.list:
# Le jeu a été renomé, on le sauvegarde temporairement
if filename != game_name:
renamed[filename] = self.list[filename]
del (self.list[filename])
# Le jeu a été supprimé. On ne l'ajoute pas dans la BDD
else:
report.log('\tDeleted game : "' + name + '"')
self.generate = True
continue
self.games[name] = {
'original_name': filename,
'game_name': game_name,
'country': None,
'version': None,
'editor': manufacturer.text if manufacturer != None else '',
'year': year.text if year != None else '',
'genre': genre.text if genre != None else '',
'resume': resume.text if resume != None else '',
'note': note.text if note != None else '',
'rating': rating.text if rating != None else '',
'score': None,
'onlineData': {
'state':
bool(strtobool(onlineData.get('state')))
if onlineData != None else False
}
}
for api in onlineData:
self.games[name]['onlineData'][api.tag] = bool(
strtobool(api.text))
# On ajoute les jeux qui n'étaient pas présent de la BDD
if len(self.list) > 0:
parser = None
if self.config.get(self.system, 'is_mame'):
parser = RCMameParser(self.list, self.config, self.system,
self.hyperpause, self.csv, self.strl,
self.strl_suffix, self.csv_no_info_str)
else:
parser = RCRomParser(self.list, self.config, self.system,
self.hyperpause, self.csv, self.strl,
self.strl_suffix, self.csv_no_info_str)
report.log('ADDING NEW GAMES TO THE DATABASE ...')
report.log('NEW GAMES : First stage ...')
parser._first_stage()
report.log('NEW GAMES : Second stage ...')
parser._second_stage()
# On fusionne les nouveaux jeux à la BDD
self.games.update(parser.games)
self.generate = True
# On ajoute à nouveaux les jeux renommés, afin que les fichiers associés soient renommés aussi
self.list.update(renamed)
def clean(self):
""" Exécute les processus de nettoyage. """
report = RCReport()
report.log('FIRST STAGE : selecting games that respond to the criteria.')
self._first_stage()
if not self.use_cache:
report.log('SECOND STAGE : choosing the best game.')
self._second_stage()
if self.config.get(self.system, 'move_files'):
report.log('MOVING ' + str(len(self.move_games)) + ' GAMES')
self._move_games()
# On renomme les jeux si besoin
self._rename_game_files()
if self.config.get(self.system, 'online_data'):
report.log('LOOKING FOR ONLINE DATA ...')
self._online_data()
if self.generate:
report.log('BUILDING HYPERSPIN DATABASE')
self._build_database()
# On génère le fichier INI HyperPause si besoin.
if self.hyperpause:
report.log('GENERATING HYPERPAUSE INI FILE')
self._hyperpause()
# On génère le fichier CSV.
if self.csv != None:
report.log('GENERATING CSV FILE')
self._csv()
# Rapport
report.log('=============== REPORT ===============')
report.log('\tInput : ' + str(len(self.list)) + ' games.')
report.log('\tPreselected : ' + str(self.total_editions) + ' games.')
report.log('\tOutput : ' + str(len(self.games)) + ' games.')
def _online_data(self):
"""
Lance la recherche des informations en ligne, via l'API choisie dans "online_api".
"""
report = RCReport()
try:
# Importe la bonne API.
api_name = self.config.get(self.system, 'online_api')
api_class_name = 'RC' + api_name.capitalize() + 'API'
api_mod = importlib.import_module('RCOnlineAPI.' + api_class_name)
api = getattr(api_mod, api_class_name)(self.system, self.config)
except ImportError as e:
report.log('\tOnline API "' + api_class_name + '" does not exist.')
return
except RCException as e:
report.log('\t' + e.message)
return
report.log('\tUsing "' + api_class_name + '" API', 2)
# On récupère les langues autorisées pour la recherche.
lang = self.config.get(self.system, 'online_data_lang').split(',')
self.generate = True
# On créé le dossier "covers" si besoin
if self.config.get(self.system, 'download_covers') and not os.path.exists(COVERS_DIR):
os.mkdir(COVERS_DIR)
for (game, infos) in self.games.items():
# On ne cherche pas de données si il y en a déjà ou si aucune donnée n'a été trouvée la fois précédente avec l'API utilisée.
if infos['onlineData']['state'] or (api_name in infos['onlineData'] and not infos['onlineData'][api_name]):
continue
elif len(lang) > 0 and lang[0] != '' and infos['country'] not in lang:
continue
report.log('\tGetting data for ' + game, 2)
data = api.search(game)
if data == -1:
infos['onlineData'][api_name] = False
report.log('\t\t>> Unable to find data.', 2)
elif data == -2:
report.log('\t\t>> HTTP Error, stop looking for online data.')
break
elif data != None:
release_date = data['release_date']
genre = data['genre']
editor = data['editor']
resume = data['resume']
note = data['note']
rating = data['rating']
image = data['image']
# Je procède comme ceci afin d'éviter de perdre des données qui peuvent être déjà présentes
infos['year'] = release_date or infos['year']
infos['genre'] = genre or infos['genre']
infos['editor'] = editor or infos['editor']
infos['resume'] = resume or infos['resume']
infos['note'] = note or infos['note']
infos['rating'] = rating or infos['rating']
# Récupération de la cover
if image != None:
file = open('covers/' + infos['game_name'] + image['ext'], 'wb')
file.write(image['file'].read())
file.close()
image['file'].close()
infos['onlineData']['state'] = True
infos['onlineData'][api_name] = True
def _first_stage(self):
""" Ouvre le fichier de base de données du système et enregistre les jeux. """
report = RCReport()
renamed = {}
try:
database = codecs.open(self.system + '.xml', 'r', 'utf-8')
xml = etree.fromstring(database.read())
database.close()
except IOError as e:
raise RCException('Unable to open database for "' + self.system + '".')
for game in xml.findall('game'):
name = game.find('description').text
manufacturer = game.find('manufacturer')
year = game.find('year')
genre = game.find('genre')
resume = game.find('resume')
note = game.find('note')
rating = game.find('rating')
onlineData = game.find('onlineData')
filename = game.get('name')
game_name = clean_filename(filename)
# On vérifie si le jeu est nouveau
if filename in self.list:
# Le jeu a été renomé, on le sauvegarde temporairement
if filename != game_name:
renamed[filename] = self.list[filename]
del(self.list[filename])
# Le jeu a été supprimé. On ne l'ajoute pas dans la BDD
else:
report.log('\tDeleted game : "' + name + '"')
self.generate = True
continue
self.games[name] = {
'original_name': filename,
'game_name': game_name,
'country': None,
'version': None,
'editor': manufacturer.text if manufacturer != None else '',
'year': year.text if year != None else '',
'genre': genre.text if genre != None else '',
'resume': resume.text if resume != None else '',
'note': note.text if note != None else '',
'rating': rating.text if rating != None else '',
'score': None,
'onlineData': { 'state': bool(strtobool(onlineData.get('state'))) if onlineData != None else False }
}
for api in onlineData:
self.games[name]['onlineData'][api.tag] = bool(strtobool(api.text))
# On ajoute les jeux qui n'étaient pas présent de la BDD
if len(self.list) > 0:
parser = None
if self.config.get(self.system, 'is_mame'):
parser = RCMameParser(self.list, self.config, self.system, self.hyperpause, self.csv, self.strl, self.strl_suffix, self.csv_no_info_str)
else:
parser = RCRomParser(self.list, self.config, self.system, self.hyperpause, self.csv, self.strl, self.strl_suffix, self.csv_no_info_str)
report.log('ADDING NEW GAMES TO THE DATABASE ...')
report.log('NEW GAMES : First stage ...')
parser._first_stage()
report.log('NEW GAMES : Second stage ...')
parser._second_stage()
# On fusionne les nouveaux jeux à la BDD
self.games.update(parser.games)
self.generate = True
# On ajoute à nouveaux les jeux renommés, afin que les fichiers associés soient renommés aussi
self.list.update(renamed)
def _first_stage(self):
report = RCReport()
ignore_cat = self.config.get(self.system, 'ignore_cat').split(',')
exclude_cat = self.config.get(self.system, 'exclude_cat').split(',')
genres = self.cat.sections()
re_group = re.compile(r'\((.+)\)')
re_infos = re.compile(RCMameParser.regex, re.IGNORECASE)
# Parcours du fichier .dat
for dat_game in self.dat.findall('game'):
goto_next = False
game_source_name = dat_game.get('name')
if game_source_name not in self.list:
continue
report.log('\t' + game_source_name, 2)
# On ignore le jeu s'il il se trouve dans l'une des catégories à ignorer
game_genre = None
for genre in genres:
if self.cat.has_option(genre, game_source_name):
game_genre = genre
if game_genre in ignore_cat:
report.log('\t\t- Genre ignored (' + game_genre + ')', 3)
goto_next = True
break
elif game_genre in exclude_cat:
report.log('\t\t- Genre excluded (' + game_genre + ')', 3)
self.move_games.append(game_source_name)
goto_next = True
break
# On ne quitte pas la boucle, car un jeu peut avoir plusieurs genres.
if goto_next:
continue
game_name = dat_game.find('description').text
editor = dat_game.find('manufacturer')
year = dat_game.find('year')
set_num = None
country = None
version = None
hack = None
# On récupère avant tout le contenu dans chaque groupe de parenthèses.
for group in re_group.findall(game_name):
# On exécute la regex sur le groupe.
for field in re_infos.finditer(group):
temp_country = field.group('field')
set_num = set_num or field.group('set')
version = version or field.group('version')
hack = hack or field.group('hack')
if temp_country in self.countries or temp_country in self.exclude_countries:
country = country or temp_country
if set_num != None and int(set_num) > 1:
report.log('\t\t- Not the first set (' + set_num + ')', 3)
continue
elif hack != None and self.config.get(self.system, 'only_legit'):
report.log('\t\t- Not legit', 3)
continue
elif country == None and not self.config.get(self.system, 'allow_no_country'):
report.log('\t\t- Country not found', 3)
continue
elif country != None and country in self.exclude_countries:
report.log('\t\t- Excluded country (' + country + ')', 3)
continue
# Nettoyage du nom du jeu
game_clean_name = clean_name(game_name)
# On enregistre le jeu temporairement
if game_clean_name not in self.temp_games:
self.temp_games[game_clean_name] = []
self.temp_games[game_clean_name].append({
'original_name': game_source_name,
'game_name': game_source_name,
'country': country,
'version': 1.0 if not version else norm_version(version),
'editor': editor.text if editor != None else 'Unknow',
'year': year.text if year != None else 'Unknow',
'genre': game_genre,
'resume': None,
'note': None,
'rating': None,
'score': 1,
'onlineData': { 'state': False }
})
report.log('\t\t+ Preselected game. Clean name : ' + game_clean_name + ' (from "' + game_name + '")', 2)
del self.dat
def main(args=sys.argv):
cmd = init_cmd_line()
system = cmd.system
hyperpause = cmd.hyperpause
cache = cmd.cache
csv = cmd.csv
strl = cmd.strl
config = RCConfig()
base_config = RCConfig()
try:
config_file = codecs.open('config.ini', 'r', 'utf-8')
config_parser = ConfigParser.ConfigParser()
# Parsage de la config'
config_parser.readfp(config_file)
config_file.close()
# On vérifie si le systeme est present dans la conf'
if system not in config_parser.sections():
raise RCException('"' + system + '" is not a registered system.')
elif system == BASE_CONFIG_SECTION:
raise RCException('"' + system + '" is not a valid system name.')
# Montage de la config
config.add_option(system, 'dir', '', str)
config.add_option(system, 'ext', '', str)
config.add_option(system, 'country', '', str)
config.add_option(system, 'exclude_country', '', str)
config.add_option(system, 'allow_no_country', True, bool)
config.add_option(system, 'only_legit', True, bool)
config.add_option(system, 'special', True, bool)
config.add_option(system, 'flags', '', str)
config.add_option(system, 'online_data', False, bool)
config.add_option(system, 'online_data_lang', '', str)
config.add_option(system, 'online_api', '', str)
config.add_option(system, 'download_covers', True, bool)
config.add_option(system, 'is_mame', False, bool)
config.add_option(system, 'dat_file', '', str)
config.add_option(system, 'cat_files', '', str)
config.add_option(system, 'ignore_cat', '', str)
config.add_option(system, 'exclude_cat', '', str)
config.add_option(system, 'move_files', False, bool)
base_config.add_option(BASE_CONFIG_SECTION, 'log_process', True, bool)
base_config.add_option(BASE_CONFIG_SECTION, 'log_level', 1, int)
base_config.add_option(BASE_CONFIG_SECTION, 'log_file', '', str)
base_config.add_option(BASE_CONFIG_SECTION, 'csv_long_string_suffix', '...', str)
base_config.add_option(BASE_CONFIG_SECTION, 'csv_no_info_str', '???', str)
# Synchro du fichier avec la config
config.read(config_parser, system)
base_config.read(config_parser, BASE_CONFIG_SECTION)
# On charge le dossier de jeux
cwd = os.path.normpath(config.get(system, 'dir').decode('utf-8'))
games = load_games_dir(cwd, config.get(system, 'ext')) # NOTE peut-être ne pas charger si use_cache
os.chdir(cwd)
strl_suffix = base_config.get(BASE_CONFIG_SECTION, 'csv_long_string_suffix')
if cache:
cleaner = RCCacheParser(games, config, system, hyperpause=hyperpause, csv=csv, strl=strl, strl_suffix=strl_suffix, csv_no_info_str=base_config.get(BASE_CONFIG_SECTION, 'csv_no_info_str'))
elif config.get(system, 'is_mame'):
cleaner = RCMameParser(games, config, system, hyperpause=hyperpause, csv=csv, strl=strl, strl_suffix=strl_suffix, csv_no_info_str=base_config.get(BASE_CONFIG_SECTION, 'csv_no_info_str'))
else:
cleaner = RCRomParser(games, config, system, hyperpause=hyperpause, csv=csv, strl=strl, strl_suffix=strl_suffix, csv_no_info_str=base_config.get(BASE_CONFIG_SECTION, 'csv_no_info_str'))
report = RCReport(system, base_config)
report.log('ROMC : start cleaning "' + system + '"')
report.log('======================================')
cleaner.clean()
report.log('======================================')
report.log('Done !')
except IOError as e:
print 'ERROR : Unable to open the configuration file.'
except RCException as e:
print 'ERROR : ' + e.message.encode('utf-8')