Maa Assistant operator export parse json for arknights

process_operators.py

import sys
import csv
import json
import requests
from os import path
from typing import Iterator
from enum import Enum

sys.stdin.reconfigure(encoding='utf-8')
sys.stdout.reconfigure(encoding='utf-8')

translated_names = []
ROOT_OPERATORS_FILE_URL = "https://raw.githubusercontent.com/MaaAssistantArknights/MaaAssistantArknights/dev/docs/glossary/"

OPERATORS_MD_FILENAME = path.basename(ROOT_OPERATORS_FILE_URL)
CURRENTLY_OWNED_OPERATORS = "currentlyowned.json"
KROOSTER_TEMPLATE_FILE = "krooster.json"


class Languages(Enum):
    US = "en-us.json"
    CN = "zh-cn.json"


def download_operators_file(subpath: str) -> json:
    file = ""
    response = requests.get(ROOT_OPERATORS_FILE_URL + subpath)
    if response.status_code == 200:
        file = response.json()
    else:
        raise Exception("Unable to get response with Code : %d " %
                        (response.status_code))
    return file


class OperatorsJSON:
    def __init__(self):
        self.data = dict()
        self.download_files()

    def download_files(self):
        for file_key in Languages:
            found_operators = download_operators_file(file_key.value)[
                "operators"]
            for _, rarity in found_operators.items():
                for operator_key, value in rarity.items():
                    self.data.setdefault(operator_key, {}).update(
                        {file_key: value})

    def lookup_eng_operator(self, operator_id) -> str:
        return self.data[operator_id.lower()][Languages.US]

    def lookup_eng_operator_from_cn(self, operator_cn_name) -> str:
        for op, operator_names in self.data.items():
            if operator_names[Languages.CN] == operator_cn_name.lower():
                return operator_names[Languages.US]
        print("No operator found for:", operator_cn_name)


class CurrentlyOwnedOperators:
    def __init__(self):
        operators_ref = OperatorsJSON()

        krooster = json.loads(
            open(KROOSTER_TEMPLATE_FILE, "r", encoding="utf-8").read())
        with open(CURRENTLY_OWNED_OPERATORS, "r", encoding="utf-8") as owned_characters:
            operators_owned = json.loads(owned_characters.read())
            operators_owned = sorted(operators_owned, key=sort_operators)
            for operator in operators_owned:
                operator_id = operator["id"]
                english_name = operators_ref.lookup_eng_operator(
                    operator["id"])
                elite_level = operator["elite"]
                operator_level = operator["level"]
                potential_level = operator["potential"]

                print(operators_ref.lookup_eng_operator(operator["id"]),
                      "E" + str(operator["elite"]), "level", operator["level"], "pot", operator["potential"])

                krooster[operator_id]["level"] = operator_level
                krooster[operator_id]["potential"] = potential_level
                krooster[operator_id]["promotion"] = elite_level
                krooster[operator_id]["owned"] = True

        with open("saved_krooster.json", "w+", encoding="utf-8") as f:
            f.write(json.dumps(krooster))


def sort_operators(k):
    return (-k['elite'], -k['level'])


if __name__ == '__main__':
    # CurrentlyOwnedOperators()
    ops = OperatorsJSON()
    for name in '但书", "能天使'.split('", "'):
        print(ops.lookup_eng_operator_from_cn(name))
    # for name in 'Proviso,'.split():
    #     print(ops.lookup_eng_operator(name))