p2j.py

import re
import json


ori = """{'java.class.version': '60.0',
 'java.home': '/usr/lib/jvm/java-16-openjdk',
 'java.runtime.name': 'OpenJDK Runtime Environment',
 'java.runtime.version': '16.0.2+7',
 'java.specification.name': 'Java Platform API Specification',
 'java.specification.vendor': 'Oracle Corporation',
 'java.specification.version': '16',
 'java.vendor.url.bug.b': 'https://bugreport.java.com/bugreport/',
 'java.version.date': '2021-07-20',
 'java.vm.name': 'OpenJDK 64-Bit Server VM',
 'java.vm.specification.name': 'Java Virtual Machine Specification',
 'java.vm.specification.vendor': 'Oracle Corporation',
 'java.vm.specification.version': '16',
 'java.vm.vendor': 'Oracle Corporation',
 'java.vm.version': '16.0.2+7',
 'sun.arch.data.model': '64'}"""


prop_regex = re.compile(r"'(?P<key>.*)':\s*'(?P<value>.*)'\s*")


def get_deepest_dict(dic: dict, keys: list) -> dict:
    return dic if not keys else get_deepest_dict(dic[keys.pop(0)], keys)


def prop2json_converter(src_str: str) -> str:
    """
    Convert property string to json string.
    :param src_str: source property string
    :return: a wrapped json string
    """
    try:
        regex_matched_dict = dict()
        ret_dict = dict()
        for ln in src_str.split("\n"):
            matched_k_v = prop_regex.search(ln)
            if matched_k_v:
                matched_k_v_gd_dict = matched_k_v.groupdict()
                regex_matched_dict[matched_k_v_gd_dict.get("key")] = matched_k_v_gd_dict.get("value")
        for matched_keys, matched_value in regex_matched_dict.items():
            split_keys = matched_keys.split(".")
            for cnt, split_key in enumerate(split_keys):
                current_key_list = split_keys[:cnt]
                if cnt != len(split_keys) - 1:
                    if not current_key_list:
                        ret_dict.setdefault(split_key, dict())
                    else:
                        get_deepest_dict(ret_dict, current_key_list).setdefault(split_key, dict())

                else:
                    if not current_key_list:
                        ret_dict.setdefault(split_key, matched_value)
                    else:
                        get_deepest_dict(ret_dict, current_key_list).setdefault(split_key, matched_value)

    except (TypeError, AttributeError):
        return json.dumps({"data": None, "err": "Invalid input string"}, ensure_ascii=False, indent=4)
    return json.dumps({"data": ret_dict, "err": ""}, ensure_ascii=False, indent=4)


if __name__ == '__main__':
    print(prop2json_converter(ori))