def dump_data(args):
input_dir = args.input_dir
output_dir = args.output_dir
save_region_files(output_dir, Server.jp, padtools.regions.japan.server)
save_region_files(output_dir, Server.kr, padtools.regions.north_america.server)
save_region_files(output_dir, Server.na, padtools.regions.korea.server)
if args.image_data_only:
exit(0)
print('Processing JP')
jp_db = merged_database.Database(Server.jp, input_dir)
jp_db.load_database(skip_extra=True)
print('Processing NA')
na_db = merged_database.Database(Server.na, input_dir)
na_db.load_database(skip_extra=True)
print('Processing KR')
kr_db = merged_database.Database(Server.kr, input_dir)
kr_db.load_database(skip_extra=True)
print('Merging and saving')
if args.server.lower() == "jp":
server = Server.jp
elif args.server.lower() == "na":
server = Server.na
elif args.server.lower() == "kr":
server = Server.kr
else:
raise ValueError("Server must be JP, NA, or KR")
cross_db = CrossServerDatabase(jp_db, na_db, kr_db, server)
save_cross_database(output_dir, cross_db)
def dump_data(args):
input_dir = args.input_dir
output_dir = args.output_dir
save_region_files(output_dir, Server.jp, padtools.regions.japan.server)
save_region_files(output_dir, Server.kr,
padtools.regions.north_america.server)
save_region_files(output_dir, Server.na, padtools.regions.korea.server)
if args.image_data_only:
exit(0)
print('Processing JP')
jp_db = merged_database.Database(Server.jp, input_dir)
jp_db.load_database(skip_extra=True)
print('Processing NA')
na_db = merged_database.Database(Server.na, input_dir)
na_db.load_database(skip_extra=True)
print('Processing KR')
kr_db = merged_database.Database(Server.kr, input_dir)
kr_db.load_database(skip_extra=True)
print('Merging and saving')
cross_db = CrossServerDatabase(jp_db, na_db, kr_db)
save_cross_database(output_dir, cross_db)
def load_data(args):
dry_run = not args.doupdates
input_dir = args.input_dir
logger.info('Loading data')
jp_database = merged_database.Database(Server.jp, input_dir)
jp_database.load_database()
na_database = merged_database.Database(Server.na, input_dir)
na_database.load_database()
kr_database = merged_database.Database(Server.kr, input_dir)
kr_database.load_database()
cs_database = crossed_data.CrossServerDatabase(jp_database, na_database, kr_database)
logger.info('Connecting to database')
with open(args.db_config) as f:
db_config = json.load(f)
db_wrapper = DbWrapper(dry_run)
db_wrapper.connect(db_config)
do_migration(cs_database, db_wrapper)
print('Not migration, but consider running:')
print('UPDATE dungeons SET visible = false WHERE dungeon_id NOT IN (select dungeon_id from encounters group by 1)')
def run(args):
behavior_data_dir = os.path.join(args.output_dir, 'behavior_data')
os.makedirs(behavior_data_dir, exist_ok=True)
behavior_text_dir = os.path.join(args.output_dir, 'behavior_text')
os.makedirs(behavior_text_dir, exist_ok=True)
jp_db = merged_database.Database(Server.jp, args.input_dir)
na_db = merged_database.Database(Server.na, args.input_dir)
jp_db.load_database(skip_skills=True, skip_bonus=True, skip_extra=True)
na_db.load_database(skip_skills=True, skip_bonus=True, skip_extra=True)
print('merging data')
# Skipping KR database; we don't need it to compute ES
cross_db = CrossServerDatabase(jp_db, na_db, na_db)
combined_cards = cross_db.all_cards
fixed_card_id = args.card_id
if args.interactive:
fixed_card_id = input("enter a card id:").strip()
count = 0
for csc in combined_cards:
merged_card = csc.na_card
card = merged_card.card
if fixed_card_id and csc.monster_id != int(fixed_card_id):
continue
try:
count += 1
if count % 100 == 0:
print('processing {} of {}'.format(count, len(combined_cards)))
monster_behavior = process_card(csc)
if monster_behavior is None:
continue
# Do some sanity cleanup on the behavior
monster_behavior = clean_monster_behavior(monster_behavior)
behavior_data_file = os.path.join(behavior_data_dir, '{}.textproto'.format(csc.monster_id))
safe_save_to_file(behavior_data_file, monster_behavior)
behavior_text_file = os.path.join(behavior_text_dir, '{}.txt'.format(csc.monster_id))
save_monster_behavior(behavior_text_file, csc, monster_behavior)
# TODO: Add raw behavior dump
except Exception as ex:
print('failed to process', csc.monster_id, card.name)
print(ex)
# if 'unsupported operation' not in str(ex):
import traceback
traceback.print_exc()
exit(0)
def main(args):
input_dir = args.input_dir
logger.info('Loading data')
jp_database = merged_database.Database(Server.jp, input_dir)
jp_database.load_database()
na_database = merged_database.Database(Server.na, input_dir)
na_database.load_database()
csd = crossed_data.CrossServerDatabase(jp_database, na_database, na_database)
current_dungeons = active_dungeons.extract_active_dungeons(csd)
for cd in current_dungeons:
print(cd.na_dungeon.clean_name)
def load_data(args):
server = Server.from_str(args.server)
if os.name != 'nt':
fail_logger.addHandler(
logging.FileHandler('/tmp/autodungeon_processor_issues.txt',
mode='w'))
pad_db = merged_database.Database(server, args.input_dir)
pad_db.load_database(skip_skills=True, skip_extra=True)
with open(args.db_config) as f:
db_config = json.load(f)
dry_run = not args.doupdates
db_wrapper = db_util.DbWrapper(dry_run)
db_wrapper.connect(db_config)
dungeons = identify_dungeons(pad_db, args.group)
if server == Server.na:
endpoint = pad_api.ServerEndpoint.NA
elif server == Server.jp:
endpoint = pad_api.ServerEndpoint.JA
else:
raise Exception('unexpected server:' + args.server)
api_client = pad_api.PadApiClient(endpoint, args.user_uuid,
args.user_intid)
api_client.login()
print('load_player_data')
api_client.load_player_data()
load_dungeons(args, db_wrapper, dungeons, api_client)
def run(args):
enemy_skillset_dump.set_data_dir(args.output_dir)
raw_input_dir = os.path.join(args.input_dir, 'raw')
jp_db = merged_database.Database(Server.jp, raw_input_dir)
na_db = merged_database.Database(Server.na, raw_input_dir)
jp_db.load_database(skip_skills=True, skip_bonus=True, skip_extra=True)
na_db.load_database(skip_skills=True, skip_bonus=True, skip_extra=True)
print('merging data')
cross_db = CrossServerDatabase(jp_db, na_db, na_db)
combined_cards = cross_db.all_cards
fixed_card_id = args.card_id
if args.interactive:
fixed_card_id = input("enter a card id:").strip()
count = 0
for csc in combined_cards:
merged_card = csc.na_card
card = merged_card.card
if fixed_card_id and csc.monster_id != int(fixed_card_id):
continue
try:
count += 1
if count % 100 == 0:
print('processing {} of {}'.format(count, len(combined_cards)))
process_card(csc)
except Exception as ex:
print('failed to process', card.name)
print(ex)
# if 'unsupported operation' not in str(ex):
import traceback
traceback.print_exc()
exit(0)
def load_es_quick_and_die(args):
with open(args.db_config) as f:
db_config = json.load(f)
jp_database = merged_database.Database(Server.jp, args.input_dir)
jp_database.load_database()
cs_database = crossed_data.CrossServerDatabase(jp_database, jp_database, jp_database)
db_wrapper = DbWrapper(False)
db_wrapper.connect(db_config)
es_processor = EnemySkillProcessor(db_wrapper, cs_database)
es_processor.load_enemy_data(args.es_dir)
print('done loading ES')
exit(0)
def load_data(args):
server = Server.from_str(args.server)
pad_db = merged_database.Database(server, args.input_dir)
pad_db.load_database(skip_skills=True, skip_extra=True)
with open(args.db_config) as f:
db_config = json.load(f)
dry_run = not args.doupdates
db_wrapper = db_util.DbWrapper(dry_run)
db_wrapper.connect(db_config)
dungeons = identify_dungeons(pad_db, args.group)
load_dungeons(args, db_wrapper, dungeons)
def load_data(args):
if args.server == 'jp':
server = Server.jp
elif args.server == 'na':
server = Server.na
elif args.server == 'kr':
server = Server.kr
else:
raise ValueError('unexpected argument: ' + args.server)
pad_db = merged_database.Database(server, args.input_dir)
pad_db.load_database(skip_skills=True, skip_extra=True)
with open(args.db_config) as f:
db_config = json.load(f)
dry_run = not args.doupdates
db_wrapper = db_util.DbWrapper(dry_run)
db_wrapper.connect(db_config)
dungeons = identify_dungeons(pad_db, args.group)
load_dungeons(args, db_wrapper, dungeons)
def run_test(args):
esd.set_data_dir(args.es_input_dir)
raw_input_dir = os.path.join(args.input_dir, 'raw')
processed_input_dir = os.path.join(args.input_dir, 'processed')
output_dir = args.output_dir
new_output_dir = os.path.join(output_dir, 'new')
pathlib.Path(new_output_dir).mkdir(parents=True, exist_ok=True)
golden_output_dir = os.path.join(output_dir, 'golden')
pathlib.Path(golden_output_dir).mkdir(parents=True, exist_ok=True)
db = merged_database.Database(Server.na, raw_input_dir)
print('loading')
db.load_database(skip_skills=True, skip_bonus=True, skip_extra=True)
dungeon_id_to_wavedata = defaultdict(set)
wave_summary_data = wave.load_wave_summary(processed_input_dir)
for w in wave_summary_data:
dungeon_id_to_wavedata[w.dungeon_id].add(w)
split_dungeons = [
# Marks dungeons which are enormous and should be broken into subfiles
110, # Endless Corridors
]
golden_dungeons = [
116, # Gunma
158, # Goemon
172, # Taiko
176, # Valkyrie
307, # Hera-Is
308, # Gung-ho
318, # Zeus-Dios
317, # ECO
331, # Hera-Ur
337, # Dragon Zombie
354, # Takeminakata
]
for dungeon_id, wave_data in dungeon_id_to_wavedata.items():
dungeon = db.dungeon_by_id(dungeon_id)
if not dungeon:
print('skipping', dungeon_id)
continue
print('processing', dungeon_id, dungeon.clean_name)
file_output_dir = golden_output_dir if dungeon_id in golden_dungeons else new_output_dir
if dungeon_id in split_dungeons:
# Disable endless for now it takes a long time to run
continue
# for floor in dungeon.floors:
# floor_id = floor.floor_number
# file_name = '{}_{}.txt'.format(dungeon_id, floor_id)
# with open(os.path.join(file_output_dir, file_name), encoding='utf-8', mode='w') as f:
# f.write(flatten_data(wave_data, dungeon, db, limit_floor_id=floor_id))
else:
file_name = '{}.txt'.format(dungeon_id)
with open(os.path.join(file_output_dir, file_name),
encoding='utf-8',
mode='w') as f:
f.write(flatten_data(wave_data, dungeon, db))
def run(args):
behavior_data_dir = os.path.join(args.output_dir, 'behavior_data')
os.makedirs(behavior_data_dir, exist_ok=True)
behavior_text_dir = os.path.join(args.output_dir, 'behavior_text')
os.makedirs(behavior_text_dir, exist_ok=True)
behavior_plain_dir = os.path.join(args.output_dir, 'behavior_plain')
os.makedirs(behavior_plain_dir, exist_ok=True)
jp_db = merged_database.Database(Server.jp, args.input_dir)
na_db = merged_database.Database(Server.na, args.input_dir)
jp_db.load_database(skip_bonus=True, skip_extra=True)
na_db.load_database(skip_bonus=True, skip_extra=True)
print('merging data')
if args.server.lower() == "jp":
server = Server.jp
elif args.server.lower() == "na":
server = Server.na
elif args.server.lower() == "kr":
server = Server.kr
else:
raise ValueError("Server must be JP, NA, or KR")
# Skipping KR database; we don't need it to compute ES
cross_db = CrossServerDatabase(jp_db, na_db, na_db, server)
combined_cards = cross_db.all_cards
fixed_card_id = args.card_id
if args.interactive:
fixed_card_id = input("enter a card id:").strip()
count = 0
for csc in combined_cards[count:]:
merged_card = csc.na_card
card = merged_card.card
if fixed_card_id and csc.monster_id != int(fixed_card_id):
continue
try:
count += 1
if count % 100 == 0:
print('processing {:4d} of {}'.format(count,
len(combined_cards)))
monster_behavior = process_card(csc)
if monster_behavior is None:
continue
# Do some sanity cleanup on the behavior
monster_behavior = clean_monster_behavior(monster_behavior)
behavior_data_file = os.path.join(
behavior_data_dir, '{}.textproto'.format(csc.monster_id))
safe_save_to_file(behavior_data_file, monster_behavior)
behavior_text_file = os.path.join(behavior_text_dir,
'{}.txt'.format(csc.monster_id))
save_monster_behavior(behavior_text_file, csc, monster_behavior)
enemy_behavior = [x.na_skill for x in csc.enemy_behavior]
behavior_plain_file = os.path.join(behavior_plain_dir,
'{}.txt'.format(csc.monster_id))
save_behavior_plain(behavior_plain_file, csc, enemy_behavior)
except Exception as ex:
print('failed to process', csc.monster_id, card.name)
print(ex)
# if 'unsupported operation' not in str(ex):
import traceback
traceback.print_exc()
exit(0)
sattr_imgs[t] = templates_img.crop(box=(xstart, ystart, xend, yend))
card_types = []
attr_map = {
-1: '',
0: 'r',
1: 'b',
2: 'g',
3: 'l',
4: 'd',
}
server = Server.from_str(args.server)
pad_db = merged_database.Database(server, args.data_dir)
pad_db.load_database(skip_skills=True, skip_extra=True)
for merged_card in pad_db.cards:
card = merged_card.card
card_id = card.monster_no
released = card.released_status
# Prevent loading junk entries (fake enemies) and also limit to data which has
# been officially released.
if card_id > 9999 or not released:
continue
card_types.append(
[card_id, attr_map[card.attr_id], attr_map[card.sub_attr_id]])
def run_test(args):
input_dir = args.input_dir
output_dir = args.output_dir
new_output_dir = os.path.join(output_dir, 'new')
pathlib.Path(new_output_dir).mkdir(parents=True, exist_ok=True)
golden_output_dir = os.path.join(output_dir, 'golden')
pathlib.Path(golden_output_dir).mkdir(parents=True, exist_ok=True)
jp_db = merged_database.Database(Server.jp, input_dir)
na_db = merged_database.Database(Server.na, input_dir)
kr_db = merged_database.Database(Server.kr, input_dir)
print('loading JP')
jp_db.load_database(skip_extra=True)
print('loading NA')
na_db.load_database(skip_extra=True)
print('loading KR')
kr_db.load_database(skip_extra=True)
print('merging data')
cross_db = CrossServerDatabase(jp_db, na_db, kr_db)
print('saving merged data')
cross_db.save_all(new_output_dir, True)
# Add sort by something, bonuses seem to be non-deterministicly ordered.
files = {
'all_cards.json': cross_db.all_cards,
'dungeons.json': cross_db.dungeons,
'active_skills.json': cross_db.active_skills,
'leader_skills.json': cross_db.leader_skills,
'enemy_skills.json': cross_db.enemy_skills,
# 'jp_bonuses.json': cross_db.jp_bonuses,
# 'na_bonuses.json': cross_db.na_bonuses,
# 'kr_bonuses.json': cross_db.kr_bonuses,
}
failed_comparisons = 0
bad_records = 0
print('starting diff')
for file, data in files.items():
new_file = os.path.join(new_output_dir, file)
golden_file = os.path.join(golden_output_dir, file)
if not os.path.exists(golden_file):
print('golden file does not exist, creating', golden_file)
shutil.copy(new_file, golden_file)
continue
print('diffing', golden_file, 'against', new_file)
with open(golden_file, encoding="utf-8") as f:
golden_data = json.load(f)
if len(golden_data) != len(data):
print('ERROR')
print(
'ERROR: file lengths differed ({} vs {}), indicates old golden data for {}'
.format(len(golden_data), len(data), file))
print('ERROR')
failed_comparisons += 1
continue
failures = []
for i in range(len(golden_data)):
gold_row = golden_data[i]
new_row = data[i]
gold_str = json_string_dump(gold_row, pretty=True)
new_str = json_string_dump(new_row, pretty=True)
if gold_str != new_str:
failures.append([gold_str, new_str])
if not failures:
continue
fail_count = len(failures)
disp_count = min(fail_count, 6)
print('encountered', fail_count, 'errors, displaying the first',
disp_count)
failed_comparisons += 1
bad_records += fail_count
failure_ids = []
for failure in failures:
gold_str = failure[0]
failure_ids.append(find_ids(gold_str))
print('All failing ids:\n' + '\n'.join(failure_ids))
for i in range(disp_count):
gold_str = failures[i][0]
new_str = failures[i][1]
print('row identifiers:\n{}\n'.format(find_ids(gold_str)))
diff_lines = difflib.context_diff(gold_str.split('\n'),
new_str.split('\n'),
fromfile='golden',
tofile='new',
n=1)
print('\n'.join(diff_lines))
if failed_comparisons:
print('Bad files:', failed_comparisons)
print('Bad records:', bad_records)
exit(1)
def load_data(args):
if args.logsql:
logging.getLogger('database').setLevel(logging.DEBUG)
dry_run = not args.doupdates
logger.info('Loading data')
jp_database = merged_database.Database(Server.jp, args.input_dir)
jp_database.load_database()
na_database = merged_database.Database(Server.na, args.input_dir)
na_database.load_database()
kr_database = merged_database.Database(Server.kr, args.input_dir)
kr_database.load_database()
if input_args.server.lower() == "combined":
cs_database = crossed_data.CrossServerDatabase(jp_database,
na_database,
kr_database, Server.jp)
elif input_args.server.lower() == "jp":
cs_database = crossed_data.CrossServerDatabase(jp_database,
jp_database,
jp_database, Server.jp)
elif input_args.server.lower() == "na":
cs_database = crossed_data.CrossServerDatabase(na_database,
na_database,
na_database, Server.na)
elif input_args.server.lower() == "kr":
cs_database = crossed_data.CrossServerDatabase(kr_database,
kr_database,
kr_database, Server.kr)
else:
raise ValueError()
if args.media_dir:
cs_database.load_extra_image_info(args.media_dir)
if not args.skipintermediate:
logger.info('Storing intermediate data')
# This is supported for https://pad.chesterip.cc/ and PadSpike, until we can support it better in the dg db
jp_database.save_all(args.output_dir, args.pretty)
na_database.save_all(args.output_dir, args.pretty)
# kr_database.save_all(args.output_dir, args.pretty)
logger.info('Connecting to database')
with open(args.db_config) as f:
db_config = json.load(f)
db_wrapper = DbWrapper(dry_run)
db_wrapper.connect(db_config)
if args.processors:
for processor in args.processors.split(","):
processor = processor.strip()
logger.info('Running specific processor {}'.format(processor))
class_type = type_name_to_processor[processor]
processor = class_type(cs_database)
processor.process(db_wrapper)
logger.info('done')
return
# Load dimension tables
DimensionProcessor().process(db_wrapper)
# # Load rank data
RankRewardProcessor().process(db_wrapper)
# # Ensure awakenings
AwakeningProcessor().process(db_wrapper)
# # Ensure tags
SkillTagProcessor().process(db_wrapper)
# # Load enemy skills
es_processor = EnemySkillProcessor(db_wrapper, cs_database)
es_processor.load_static()
es_processor.load_enemy_skills()
if args.es_dir:
es_processor.load_enemy_data(args.es_dir)
# Load basic series data
series_processor = SeriesProcessor(cs_database)
series_processor.pre_process(db_wrapper)
# # Load monster data
MonsterProcessor(cs_database).process(db_wrapper)
# Auto-assign monster series
series_processor.post_process(db_wrapper)
# Egg machines
EggMachineProcessor(cs_database).process(db_wrapper)
# Load dungeon data
dungeon_processor = DungeonProcessor(cs_database)
dungeon_processor.process(db_wrapper)
if not args.skip_long:
# Load dungeon data derived from wave info
DungeonContentProcessor(cs_database).process(db_wrapper)
# Toggle any newly-available dungeons visible
dungeon_processor.post_encounter_process(db_wrapper)
# Load event data
ScheduleProcessor(cs_database).process(db_wrapper)
# Load exchange data
ExchangeProcessor(cs_database).process(db_wrapper)
# Load purchase data
PurchaseProcessor(cs_database).process(db_wrapper)
# Update timestamps
TimestampProcessor().process(db_wrapper)
PurgeDataProcessor().process(db_wrapper)
logger.info('done')
def load_data(args):
if args.logsql:
logging.getLogger('database').setLevel(logging.DEBUG)
dry_run = not args.doupdates
logger.info('Loading data')
jp_database = merged_database.Database(Server.jp, args.input_dir)
jp_database.load_database()
na_database = merged_database.Database(Server.na, args.input_dir)
na_database.load_database()
kr_database = merged_database.Database(Server.kr, args.input_dir)
kr_database.load_database()
cs_database = crossed_data.CrossServerDatabase(jp_database, na_database,
kr_database)
if args.media_dir:
cs_database.load_extra_image_info(args.media_dir)
if not args.skipintermediate:
logger.info('Storing intermediate data')
jp_database.save_all(args.output_dir, args.pretty)
na_database.save_all(args.output_dir, args.pretty)
kr_database.save_all(args.output_dir, args.pretty)
logger.info('Connecting to database')
with open(args.db_config) as f:
db_config = json.load(f)
db_wrapper = DbWrapper(dry_run)
db_wrapper.connect(db_config)
# Load dimension tables
DimensionProcessor().process(db_wrapper)
# Load rank data
RankRewardProcessor().process(db_wrapper)
# Ensure awakenings
AwakeningProcessor().process(db_wrapper)
# Ensure tags
SkillTagProcessor().process(db_wrapper)
# Load enemy skills
es_processor = EnemySkillProcessor(db_wrapper, cs_database)
es_processor.load_static()
es_processor.load_enemy_skills()
if args.es_dir:
es_processor.load_enemy_data(args.es_dir)
# Load basic series data
series_processor = SeriesProcessor(cs_database)
series_processor.pre_process(db_wrapper)
# Load monster data
MonsterProcessor(cs_database).process(db_wrapper)
# Auto-assign monster series
series_processor.post_process(db_wrapper)
# Egg machines
EggMachineProcessor(cs_database).process(db_wrapper)
# Load dungeon data
dungeon_processor = DungeonProcessor(cs_database)
dungeon_processor.process(db_wrapper)
if not args.skip_long:
# Load dungeon data derived from wave info
DungeonContentProcessor(cs_database).process(db_wrapper)
# Toggle any newly-available dungeons visible
dungeon_processor.post_encounter_process(db_wrapper)
# Load event data
ScheduleProcessor(cs_database).process(db_wrapper)
# Load exchange data
ExchangeProcessor(cs_database).process(db_wrapper)
# Load purchase data
PurchaseProcessor(cs_database).process(db_wrapper)
# Update timestamps
TimestampProcessor().process(db_wrapper)
# Purge old schedule items and deleted_rows
# This is dangerous, so we won't do it yet
# PurgeDataProcessor().process(db_wrapper)
print('done')
def load_data(args):
if args.processors == "None":
return
if args.logsql:
logging.getLogger('database').setLevel(logging.DEBUG)
dry_run = not args.doupdates
logger.info('Loading data')
jp_database = merged_database.Database(Server.jp, args.input_dir)
jp_database.load_database()
na_database = merged_database.Database(Server.na, args.input_dir)
na_database.load_database()
kr_database = merged_database.Database(Server.kr, args.input_dir)
kr_database.load_database()
if input_args.server.lower() == "combined":
cs_database = crossed_data.CrossServerDatabase(jp_database, na_database, kr_database, Server.jp)
elif input_args.server.lower() == "jp":
cs_database = crossed_data.CrossServerDatabase(jp_database, jp_database, jp_database, Server.jp)
elif input_args.server.lower() == "na":
cs_database = crossed_data.CrossServerDatabase(na_database, na_database, na_database, Server.na)
elif input_args.server.lower() == "kr":
cs_database = crossed_data.CrossServerDatabase(kr_database, kr_database, kr_database, Server.kr)
else:
raise ValueError()
if args.media_dir:
cs_database.load_extra_image_info(args.media_dir)
if not args.skipintermediate:
logger.info('Storing intermediate data')
# This is supported for https://pad.chesterip.cc/ and PadSpike, until we can support it better in the dg db
jp_database.save_all(args.output_dir, args.pretty)
na_database.save_all(args.output_dir, args.pretty)
# kr_database.save_all(args.output_dir, args.pretty)
logger.info('Connecting to database')
with open(args.db_config) as f:
db_config = json.load(f)
db_wrapper = DbWrapper(dry_run)
db_wrapper.connect(db_config)
processors = []
for proc in args.processors.split(","):
proc = proc.strip()
if proc in type_name_to_processor:
processors.extend(type_name_to_processor[proc])
else:
logger.warning("Unknown processor: {}\nSkipping...".format(proc))
# Load dimension tables
if DimensionProcessor in processors:
DimensionProcessor().process(db_wrapper)
# # Load rank data
if RankRewardProcessor in processors:
RankRewardProcessor().process(db_wrapper)
# # Ensure awakenings
if AwokenSkillProcessor in processors:
AwokenSkillProcessor().process(db_wrapper)
# # Ensure tags
if SkillTagProcessor in processors:
SkillTagProcessor().process(db_wrapper)
# # Load enemy skills
if EnemySkillProcessor in processors:
es_processor = EnemySkillProcessor(db_wrapper, cs_database)
es_processor.load_static()
es_processor.load_enemy_skills()
if args.es_dir:
es_processor.load_enemy_data(args.es_dir)
# Load basic series data
if SeriesProcessor in processors:
SeriesProcessor(cs_database).process(db_wrapper)
# # Load monster data
if MonsterProcessor in processors:
MonsterProcessor(cs_database).process(db_wrapper)
# Egg machines
if EggMachineProcessor in processors:
EggMachineProcessor(cs_database).process(db_wrapper)
# Load dungeon data
dungeon_processor = None
if DungeonProcessor in processors:
dungeon_processor = DungeonProcessor(cs_database)
dungeon_processor.process(db_wrapper)
if DungeonContentProcessor in processors and input_args.server.lower() == "combined":
# Load dungeon data derived from wave info
DungeonContentProcessor(cs_database).process(db_wrapper)
# Toggle any newly-available dungeons visible
if dungeon_processor is not None:
dungeon_processor.post_encounter_process(db_wrapper)
# Load event data
if ScheduleProcessor in processors:
ScheduleProcessor(cs_database).process(db_wrapper)
# Load exchange data
if ExchangeProcessor in processors:
ExchangeProcessor(cs_database).process(db_wrapper)
# Load purchase data
if PurchaseProcessor in processors:
PurchaseProcessor(cs_database).process(db_wrapper)
# Update timestamps
if ExchangeProcessor in processors:
TimestampProcessor().process(db_wrapper)
if PurgeDataProcessor in processors:
PurgeDataProcessor().process(db_wrapper)
logger.info('Done')
