validator.py

import os
import sys
import json
import requests
import operator

os.chdir('official_devices')
SUGGESTIONS = []
ALLOWED_VERSIONS = ['eleven', 'eleven_plus', 'ten', 'ten_plus']
REQUIRED_PARAMS_DEVICE = ['name', 'brand', 'codename', 'supported_versions', 'repositories']
REQUIRED_PARAMS_DEVICE_LIST = ['supported_versions', 'repositories']
REQUIRED_PARAMS_TEAM_MEMBER = ['name', 'country', 'github_username', 'devices', 'ci_username']
REQUIRED_PARAMS_TEAM_MEMBER_DEVICE = ['codename', 'versions']
DEPRECATED_VERSIONS = ['ten', 'ten_plus']


def test_integrity_devices():
    global SUGGESTIONS
    try:
        devices = json.loads(open('devices.json', 'r').read())
    except:
        SUGGESTIONS.append('devices.json is not a valid JSON.')
        return

    for device in devices:
        device_index = devices.index(device)
        for param in REQUIRED_PARAMS_DEVICE:
            if param not in device:
                SUGGESTIONS.append(
                    f"'{param}' key not found in devices.json for device index value {device_index}")
        if 'codename' in device:
            codename = device.get('codename')
            if not os.path.isfile(f"images/{codename}.png"):
                SUGGESTIONS.append(
                    f"images/{codename}.png not found for codename {codename} in devices.json and device index value {device_index}")

        for param in REQUIRED_PARAMS_DEVICE_LIST:
            if not isinstance(device[param], list):
                SUGGESTIONS.append(
                    f"'{param}' key is not a valid param in devices.json for device index value {device_index}")

        if isinstance(device["supported_versions"], list):
            supported_versions = device['supported_versions']
            for supported_version in supported_versions:
                version_index = supported_versions.index(supported_version)
                if 'version_code' not in supported_version:
                    SUGGESTIONS.append(
                        f"'version_code' key not found in devices.json for device index value {device_index} and version index value {version_index}")
                elif supported_version['version_code'] not in ALLOWED_VERSIONS:
                    SUGGESTIONS.append(
                        f"'version_code' version is not allowed in devices.json for device index value {device_index} and version index value {version_index}")


def test_integrity_team():
    global SUGGESTIONS
    for team_role in ['lead', 'core', 'maintainers']:
        json_file = 'team/' + team_role + '.json'
        try:
            members = json.loads(open('team/' + team_role + '.json', 'r').read())
        except:
            SUGGESTIONS.append(json_file + ' is not a valid JSON.')
            return
        if team_role == "lead":
            members = [members]
        for member in members:
            member_index = members.index(member)

            for param in REQUIRED_PARAMS_TEAM_MEMBER:
                if param not in member:
                    SUGGESTIONS.append(
                        f"'{param}' key not found in {json_file} for member index value {member_index}")

            if 'devices' in member:
                devices = member['devices']
                for device in devices:
                    device_index = devices.index(device)

                    for param in REQUIRED_PARAMS_TEAM_MEMBER_DEVICE:
                        if param not in device:
                            SUGGESTIONS.append(
                                f"{param} key not found in {json_file} for member index value {member_index} and device index value {device_index}")

                    if 'versions' in device:
                        versions = device['versions']
                        for version in versions:
                            if version not in ALLOWED_VERSIONS:
                                SUGGESTIONS.append(
                                    f"{version} version is not allowed in {json_file} for device index value {device_index} and member index value {member_index}")

def sanitize_username(username):
    return ''.join(ch for ch in username.lower() if ch.isalnum())

def is_device_deprecated(device_codename, version, devices):
    for device in devices:
        if device["codename"] == device_codename:
            for supported_version in device["supported_versions"]:
                if supported_version["version_code"] == version:
                    return "deprecated" in supported_version and supported_version["deprecated"]
    return False
            

def format_json():
    # Load JSON's
    devices = json.loads(open('devices.json', 'r').read())
    lead = json.loads(open('team/lead.json', 'r').read())
    core = json.loads(open('team/core.json', 'r').read())
    maintainers = json.loads(open('team/maintainers.json', 'r').read())

    # Sanitize ci_username
    for roles in [core, maintainers]:
        for member in roles:
            member["ci_username"] = sanitize_username(member["ci_username"])

    # Sanitize github_username
    for roles in [core, maintainers]:
        for member in roles:
            member["github_username"] = sanitize_username(member["github_username"])

    # Sanitize deprecated versions
    for roles in [core, maintainers]:
        for member in roles:
            devices_to_remove = []
            for device in member["devices"]:
                versions_to_remove = []
                for version in device["versions"]:
                    if version not in versions_to_remove:
                        if is_device_deprecated(device["codename"], version, devices):
                            versions_to_remove.append(version)
                        elif version in DEPRECATED_VERSIONS:
                            versions_to_remove.append(version)
                for version in versions_to_remove:
                    device["versions"].remove(version)
                if not device["versions"]:
                    devices_to_remove.append(device)
            for device in devices_to_remove:
                member["devices"].remove(device)

    # Sort JSON alphabetically with selected keys
    devices = sorted(devices, key=operator.itemgetter('codename', 'brand'))
    core = sorted(core, key=operator.itemgetter('name', 'country'))
    maintainers = sorted(
        maintainers, key=operator.itemgetter('name', 'country'))

    # Dump them
    devices = json.dumps(devices, indent=3, sort_keys=False, ensure_ascii=False)
    lead = json.dumps(lead, indent=3, sort_keys=False, ensure_ascii=False)
    core = json.dumps(core, indent=3, sort_keys=False, ensure_ascii=False)
    maintainers = json.dumps(maintainers, indent=3, sort_keys=False, ensure_ascii=False)

    # Open JSON's
    devices_json = open('devices.json', 'w')
    lead_json = open('team/lead.json', 'w')
    core_json = open('team/core.json', 'w')
    maintainers_json = open('team/maintainers.json', 'w')

    # Write dump's
    devices_json.write(devices + '\n')
    lead_json.write(lead + '\n')
    core_json.write(core + '\n')
    maintainers_json.write(maintainers + '\n')

    # Close JSON's
    devices_json.close()
    lead_json.close()
    core_json.close()
    maintainers_json.close()

    return 0


def main():
    print('Running Integrity tests for all the JSON\'s.')
    test_integrity_devices()
    test_integrity_team()

    if len(SUGGESTIONS) > 0:
        print('Integrity test for one or more JSON\'s failed. Cannot proceed with JSON formatter.\n\n')
        print('Below might be the reasons for test failure.')
        for SUGGESTION in SUGGESTIONS:
            print(SUGGESTION)
        sys.exit(1)
    else:
        print('Integrity test passed successfully. Now formatting all the JSON\'s')
        format_json()
        sys.exit(0)


if __name__ == "__main__":
    main()