xdoc.py

#!/usr/local/bin/python3
# -*- coding: utf-8 -*-
#
# Copyright 2020 Loopring Org. All Rights Reserved.

__author__ = 'chao@loopring.org (Ma Chao)'

import argparse
import http.client
import json
import logging
import os
import re
import subprocess

from functools import partial
from jinja2 import Environment, FileSystemLoader


logging.basicConfig(level=logging.DEBUG,
                    format="%(asctime)s - %(levelname)s - %(message)s",
                    datefmt="%Y-%m-%d %H:%M:%S")

LOGGER = logging.getLogger(__name__)

PURGE_DIR = '.generated'
OUTPUT_DIR = 'generated'
PURGE_IGNORE = ['swp', 'tpl']
OUTPUT_IGNORE = ['_book', 'docs', 'node_modules']

IN_DOCS_PATH = 'in_docs'

SWAGGER_JSON_PATH = '/api'

VARS = {}

path = '{}/tpls/'.format(os.path.dirname(__file__))
loader = FileSystemLoader(path)
ENV = Environment(loader=loader)

INDENT = 2
SEG_SIZE = 12
DESCRIPTION_SIZE = 48

EXAM_HEADERS = {
    'X-API-KEY' : 'sra1aavfa',
    'X-API-SIG' : 'dkkfinfasdf',
}

REDIRECTION_HEADERS = {
    'X-EDDSA-SIG' : 'X-API-SIG',
    'X-ECDSA-SIG' : 'X-API-SIG'
}

TPS_CONFIG = 'tps_config'
DEFAULT_KEY_TPS = {'count': 1, 'interval': 1}


def get_request_parames(params, method):
    if method == 'GET':
        return params
    elif method == 'POST':
        if (len(params) == 0):
            return []
        modelName = params[0]['$ref']
        return VARS['models'][modelName]['properties']
    else:
        return params

def get_response_fields(response):
    modelName = response['$ref']
    return VARS['models'][modelName]['properties']

def get_link(ref):
    # return '<a href="%s#%s">%s</a>'%(
    #     '../REST_APIS.md' if ref == 'ResultInfo' else '', ref, re.sub('[a-z]', '', ref))
    return '<a href="%s#%s">%s</a>'%(
        '../REST_APIS.md' if ref == 'ResultInfo' else '', ref, seg_obj(ref, 8))

def create_html_type(field):
    if (field.get('type') is None):
        if (field.get('$ref') is not None):
            cleanRef = field['$ref']
            return get_link(cleanRef)
        else:
            return '/'
    else:
        if (field['type'] == 'array'):
            cleanRef = ''
            if (field.get('$ref') is not None):
                cleanRef = field['$ref']
                return 'List[' * field['count'] + \
                    get_link(cleanRef) + \
                    ']' * field['count']
            else:
                return 'List[' * field['count'] + '%s'%(field['itemType']) + \
                    ']' * field['count']
        elif (field.get('$ref') is not None):
            cleanRef = field['$ref']
            return get_link(cleanRef)
        else:
            return field['type']

def run_command_with_return_info(cmd):
    try:
        return (True, subprocess.check_output([cmd], shell = True))
    except:
        LOGGER.error('Command %s failed.'%(cmd))
        return (False, None)

def sync_out():
    if not os.path.exists(OUTPUT_DIR):
        run_command_with_return_info('mkdir %s'%(OUTPUT_DIR))
    forward_sync(PURGE_DIR, OUTPUT_DIR, ['.'])
    nodes = get_first_layer_nodes(OUTPUT_DIR, OUTPUT_IGNORE)
    backward_sync(OUTPUT_DIR, PURGE_DIR, nodes)

def is_wanted(node, blackList):
    for ignore in blackList:
        if node.endswith(ignore):
            return False
    return True


def get_first_layer_nodes(root, black):
    nodes = filter(partial(is_wanted, blackList = black),
                   os.listdir(root))
    return nodes

def forward_sync(sourceDir, targetDir, nodes):
    for node in nodes:
        fullSourcePath = os.path.join(sourceDir, node)
        fullTargetPath = os.path.join(targetDir, node)
        if os.path.isfile(fullSourcePath):
            run_command_with_return_info('cp %s %s'%(fullSourcePath,
                                                     fullTargetPath))
        else:
            if (not node == '.'):
                if not os.path.exists(fullTargetPath):
                    run_command_with_return_info('mkdir %s'%(fullTargetPath))
            forward_sync(fullSourcePath, fullTargetPath,
                         os.listdir(fullSourcePath))

def backward_sync(sourceDir, targetDir, nodes):
    for node in nodes:
        fullSourcePath = os.path.join(sourceDir, node)
        fullTargetPath = os.path.join(targetDir, node)
        if not os.path.exists(fullTargetPath):
            run_command_with_return_info('rm -rf %s'%(fullSourcePath))
        else:
            if os.path.isdir(fullSourcePath):
                backward_sync(
                    fullSourcePath, fullTargetPath, os.listdir(fullSourcePath))

def recursive_generate(sourceDir, targetDir, nodes):
    for node in nodes:
        fullSourcePath = os.path.join(sourceDir, node)
        fullTargetPath = os.path.join(targetDir, node)
        if os.path.isfile(fullSourcePath):
            run_command_with_return_info(
                'cp %s %s'%(fullSourcePath, fullTargetPath))
        else:
            if not os.path.exists(fullTargetPath):
                run_command_with_return_info('mkdir %s'%(fullTargetPath))
            recursive_generate(fullSourcePath, fullTargetPath,
                              os.listdir(fullSourcePath))


def copy_static_files():
    run_command_with_return_info('cp ./.bookignore %s'%(PURGE_DIR))
    run_command_with_return_info('cp ./LANGS.md %s'%(PURGE_DIR))
    run_command_with_return_info('cp ./book.json %s'%(PURGE_DIR))

def set_field(f, t, field, tField = None,
              showMsgIfMiss = False, message = None):
    if (f.get(field) is not None):
        if not isinstance(f[field], str) or f[field].strip() != 'None':
            if (tField is None):
                tField = field
            t[tField] = f[field]
            if (field == '$ref'):
                t[tField] = t[tField].replace('#/definitions/', '')
            elif (field == 'example' or field == 'x-example'
                  or field == 'description'):
                if isinstance(t[tField], bool):
                    t[tField] = str(t[tField]).lower()
            return
    if (showMsgIfMiss):
        if message is None:
            LOGGER.error('%s has no %s'%(f, field))
        else:
            LOGGER.error(message)

# This function is used to seg long obj name
# for better shown in markdown table cell.
def seg_obj(word, segSize):
    def process(stack):
        seg = ''.join(stack)
        if len(seg) > segSize and len(stack) > 1:
            last = stack.pop()
            seg = ''.join(stack)
            return seg, [last]
        elif len(seg) > segSize:
            seg = ''.join(stack)
            return seg, []
        else:
            return "", stack

    words = [w for w in re.split("(?=[A-Z])", word) if w]
    assert(len(words) > 0)
    segs = []
    stack = []
    while(len(words) > 0):
        stack.append(words.pop(0))
        seg, stack = process(stack)
        if seg:
            segs.append(seg)

    # while (len(stack) > 0)
    segs.append(''.join(stack))
    print(f"seg obj {word} to {segs}")

    return '<br/>'.join(segs)

# This function is used to seg long word
# for better shown in markdown table cell.
def seg_str(word, segSize):
    length = len(word)
    if (length < segSize):
        return word
    segs = []
    i = 0
    while (i < length):
        segs.append(word[i : i + segSize])
        i += segSize
    return '<br/>'.join(segs)

def modifyStr(content, segSize):
    words = content.split(' ')
    return '"' + ' '.join([seg_str(word, segSize) for word in words]) + '"'

def parse_array(items):
    if (items.get('$ref') is not None or items.get('type') != 'array'):
        ref = items.get('$ref', None)
        if ref is not None:
            ref = ref.replace('#/definitions/', '')
        return (1, ref, items.get('type', None))
    else:
        (c, r, t) = parse_array(items['items'])
        return (c + 1, r, t)

def parse_model(name):
    modelInfo = VARS['definitions'][name]
    model = {}
    model['name'] = name
    model['type'] = modelInfo['type']
    model['description'] = modelInfo.get('description', '')
    required = modelInfo.get('required', [])
    properties = []
    if (modelInfo.get('properties') is not None):
        propjson = modelInfo['properties']
        for prop in propjson.keys():
            property_ = {}
            property_['name'] = prop
            if prop in required:
                property_['required'] = True
            else:
                property_['required'] = False

            set_field(propjson[prop], property_, '$ref')
            set_field(propjson[prop], property_, 'type',
                showMsgIfMiss = (property_.get('$ref') is None),
                message = 'Must set $ref or type for %s of %s'%(prop, name))
            if (property_.get('type', '') == 'object'
                and property_.get('$ref') is None):
                LOGGER.error('%s of %s has no $ref'%(prop, name))
                property_['$ref'] = 'ResultInfo'
            set_field(propjson[prop], property_, 'description')
            set_field(propjson[prop], property_, 'enum')
            set_field(propjson[prop], property_, 'example',
                showMsgIfMiss = (property_.get('type') is not None
                                 and property_['type'] != 'array'
                                 and property_['type'] != 'object'),
                message = '%s of %s has no example'%(prop, name))
            if (property_.get('type') is not None
                and property_['type'] == 'object'
                and property_.get('example') is not None):
                LOGGER.error('The type of %s in %s may wrong.'%(prop, name))
            if (property_.get('type') is not None and
                property_['type'] == 'array'):
                (count, ref, itemType) = parse_array(propjson[prop]['items'])
                property_['count'] = count
                if ref is not None:
                    property_['$ref'] = ref
                if itemType is not None:
                    property_['itemType'] = itemType
                if (itemType is not None and property_.get('example') is None):
                    LOGGER.error('%s of %s has no example.'%(prop, name))
                if (ref is None and itemType is None):
                    LOGGER.error('%s of %s miss $ref or itemType'%(prop, name))

            properties.append(property_)
    model['properties'] = properties
    return model

def parse_params(parameters):
    params = []
    refs = []
    for parameter in parameters:
        p = {}
        set_field(parameter, p, 'name', showMsgIfMiss = True)
        set_field(parameter, p, 'description', showMsgIfMiss = True)
        set_field(parameter, p, 'required', showMsgIfMiss = True)
        set_field(parameter, p, 'type')
        if p.get('type', '') == 'array':
            LOGGER.error('Didn\'t support array param: %s.'%(parameter))
        set_field(parameter, p, 'default')
        set_field(parameter, p, 'enum')
        set_field(parameter, p, 'x-example', 'example')
        if (parameter.get('schema') is not None):
            set_field(parameter['schema'], p, '$ref', showMsgIfMiss = True)
            if (p['$ref'] not in refs):
                refs.append(p['$ref'])
        else:
            if p.get('example') is None:
                LOGGER.error('%s has no example.'%(parameter))
        params.append(p)
    return (params, refs)

def parse_responses(responses):
    errorCodes = responses.keys()
    resps = {}
    codes = []
    refs = []
    for error in errorCodes:
        if (error == '0' or error == '200'):
            ret = {}
            set_field(responses[error], ret, 'description',
                      showMsgIfMiss = True)
            if (responses[error].get('schema') is not None):
                set_field(responses[error]['schema'], ret, '$ref',
                          showMsgIfMiss = True)
                if (ret['$ref'] not in refs):
                    refs.append(ret['$ref'])
            resps['ret'] = ret
        else:
            r = {}
            r['ec'] = error
            set_field(responses[error], r, 'description',
                      showMsgIfMiss = True)
            codes.append(r)
    resps['codes'] = codes
    return (resps, refs)

def parse_api(path, apiInfo):
    apis = []
    for method in apiInfo.keys():
        api = {}
        api['path'] = path
        api['method'] = method.upper()
        rawInfo = apiInfo[method]
        api['operationId'] = rawInfo['operationId']
        set_field(rawInfo, api, 'description')
        set_field(rawInfo, api, 'summary', showMsgIfMiss = True,
                  message = 'API %s has no summary'%(path))
        (api['params'], reqRefs) = parse_params(rawInfo['parameters'])
        (api['responses'], resRefs) = parse_responses(rawInfo['responses'])
        api['refs'] = reqRefs + resRefs
        apis.append(api)
    return apis

def load_api_desc(lang):

    inf = open('./meta/swagger_%s.json'%(lang))
    swagger = json.loads(inf.read())
    inf.close()

    apis = {}

    paths = swagger['paths']

    refModels = []
    for path in VARS['v']['enable_apis']:
        if path not in paths.keys():
            LOGGER.error('API %s not found.'%(path))
        else:
            for parsedApi in parse_api(path, paths[path]):
                apis[parsedApi['operationId']] = parsedApi
                refModels += apis[parsedApi['operationId']]['refs']
    refModels = set(refModels)

    VARS['apis'] = apis

    VARS['definitions'] = swagger['definitions']
    VARS['models'] = {}

    while (len(refModels) > 0):
        model = refModels.pop()
        VARS['models'][model] = parse_model(model)
        for newRef in expend_models(model):
            if (newRef not in VARS['models']):
                refModels.add(newRef)


def load_message(lang):
    inf = open('./i18n/messages.%s'%(lang))
    l = json.loads(inf.read())
    inf.close()
    VARS['l'] = l

def load_info_with_lang(lang):
    load_message(lang)
    load_api_desc(lang)

def prop_to_json(prop, spaceNum):
    valStr = ''
    if (prop.get('type') is None):
        valStr = model_to_json(
            prop['$ref'],
            spaceNum).lstrip()
    else:
        if (prop['type'] == 'string'):
            valStr = '"%s"'%(prop.get('example', ''))
        else:
            if (prop.get('example') is not None):
                valStr = prop['example']
            elif (prop['type'] == 'object'):
                valStr = model_to_json(
                    prop['$ref'],
                    spaceNum).lstrip()
            elif (prop['type'] == 'array'):
                valStr = '[' * prop['count'] + '\n'
                if (prop.get('$ref') is not None):
                    valStr += model_to_json(
                        prop['$ref'],
                        spaceNum + INDENT) + '\n'
                else:
                    valStr += ' ' * (spaceNum + INDENT) + \
                            prop['itemType'] + '\n'
                valStr += ' ' * spaceNum + ']' * prop['count']
            else:
                valStr = prop['type']
    return ' ' * spaceNum + '"%s"'%(prop['name']) + ' : ' + str(valStr)

def model_to_json(modelName, spaceNum = 0):
    model = VARS['models'][modelName]
    ret = ' ' * spaceNum + '{\n'
    ret += prop_to_json(model['properties'][0], spaceNum + INDENT)
    for prop in model['properties'][1:]:
        ret += ',\n'
        ret += prop_to_json(prop, spaceNum + INDENT)
    ret += '\n' + ' ' * spaceNum + '}'
    return ret

def create_response_example(api):
    return model_to_json(api['responses']['ret']['$ref'])

def create_request_http_example(apiObj):
    hostUrl = VARS['v']['hosturl']
    apiObj['hosturl'] = hostUrl[hostUrl.index('://') + 3 :]
    url = '%s%s'%(hostUrl, apiObj['path'])
    headers = []
    for header in get_request_headers(apiObj['operationId']):
        if header in REDIRECTION_HEADERS.keys():
            redir_header = REDIRECTION_HEADERS[header]
            headers.append({'key' : redir_header, 'value' : EXAM_HEADERS[redir_header]})
        else:
            headers.append({'key' : header, 'value' : EXAM_HEADERS[header]})

    if (apiObj['method'] == 'POST'):
        apiObj['payload'] = model_to_json(apiObj['params'][0]['$ref'])
        headers.append({'key':'Content-Type', 'value':'application/json'})
    else:
        param = ''
        for p in apiObj['params']:
            param += p['name'] + '=' + str(p['example']) + '&'
        if (param != ''):
            url += '?' + param[0 : -1]
    apiObj['pathWithParams'] = url
    apiObj['headers'] = headers
    httpTpl = ENV.get_template('http.tpl')
    return httpTpl.render(api = apiObj)

def create_request_curl_headers(operationId):
    ret = ''
    for header in get_request_headers(operationId):
        if header in REDIRECTION_HEADERS.keys():
            redir_header = REDIRECTION_HEADERS[header]
            ret += ' -H "%s:%s"'%(redir_header, EXAM_HEADERS[redir_header])
        else:
            ret += ' -H "%s:%s"'%(header, EXAM_HEADERS[header])

    return ret

def create_request_curl_example(api):
    ret = 'curl' + '%s' + '%s' + ' %s%s'%(VARS['v']['hosturl'], api['path'])
    headers = create_request_curl_headers(api['operationId'])
    param = ''
    if (api['method'] == 'GET'):
        for p in api['params']:
            param += p['name'] + '\=' + str(p['example']) + '\&'
        if (param == ''):
            return ret%('', headers)
        else:
            return ret%('', headers) + '\?' + param[0 : -2]
    elif (api['method'] == 'DELETE'):
        for p in api['params']:
            param += p['name'] + '\=' + str(p['example']) + '\&'
        if (param == ''):
            return ret%(' -X DELETE', headers)
        else:
            return ret%(' -X DELETE', headers) + '\?' + param[0: -2]
    elif (api['method'] == 'POST'):
        if (len(api['params']) == 0):
            LOGGER.error('%s has no parameters.'%(api['operationId']))
            return 'error'
        payload = model_to_json(api['params'][0]['$ref'])
        if (payload == ''):
            return ret%(' -X POST', headers)
        else:
            headers += ' -H "Content-Type:application/json"'
            return ret%(' -X POST', headers) + ' -d' + \
                    ' \\\n\'%s\''%(payload)
    else:
        LOGGER.error('%s is not supported with method %s'%(api['path'],
                                                           api['method']))

def expend_models(modelName):
    modelNames = []
    for prop in VARS['models'][modelName]['properties']:
        if prop.get('$ref') is not None:
            name = prop.get('$ref')
            if (name not in modelNames):
                modelNames.append(name)
                if (name not in VARS['models']):
                    VARS['models'][name] = parse_model(name)
                    modelNames += expend_models(name)
    return modelNames


def get_ref_models(api):
    modelNames = []
    for ref in api['refs']:
        m = VARS['models'][ref]
        for prop in m['properties']:
            if prop.get('$ref') is not None:
                name = prop.get('$ref')
                if (name not in modelNames):
                    modelNames.append(name)
                    modelNames += expend_models(name)
    ret = [VARS['models'][x] for x in modelNames if x != 'ResultInfo']
    return ret

def get_description(api):
    if (api.get('description') is not None and api['description'] != ''):
        return api['description']
    descFilePath = os.path.join('./tpls', VARS['currentLang'], 'segments',
        api['operationId'] + '_desc.md')
    if os.path.exists(descFilePath):
        return '{% include "../segments/' + api['operationId'] + '_desc.md" %}'
    else:
        LOGGER.error('API %s has no description.'%(api['operationId']))
        return '/'

def get_example(example):
    if example == 0:
        return example
    if not example:
        return '/'
    if not isinstance(example, str):
        return example
    if example.strip() != '':
        return modifyStr(example.strip(), SEG_SIZE)
    else:
        return '/'

def get_request_headers(operationId):
    ret = []
    if operationId not in VARS['v']['no_key']:
        ret.append('X-API-KEY')
    if operationId in VARS['v']['has_eddsa_sig']:
        ret.append('X-EDDSA-SIG')
    if operationId in VARS['v']['has_ecdsa_sig']:
        ret.append('X-ECDSA-SIG')
    return ret

def get_tps(api):
    tps = VARS['tps'].get(
        (api['path'], api['method'].lower()), 5)
    return tps

def generate_api_doc(operationId, path, filename):
    apiTpl = ENV.get_template('api_doc.tpl')
    apidoc = apiTpl.render(
        l = VARS['l'],
        api = VARS['apis'][operationId],
        c_type = create_html_type,
        c_request_curl_example = create_request_curl_example,
        c_request_http_example = create_request_http_example,
        g_response_fields = get_response_fields,
        g_request_params = get_request_parames,
        c_response_example = create_response_example,
        g_ref_models = get_ref_models,
        g_desc = get_description,
        g_example = get_example,
        g_request_headers = get_request_headers,
        g_tps = get_tps)

    output_file(apidoc, os.path.join(
        './', PURGE_DIR, VARS['currentLang'], path, filename + '.md'))

    return os.path.join(path, filename + '.md')

def output_file(content, fullpath):
    dirpath = os.path.dirname(os.path.realpath(fullpath))
    if not os.path.exists(dirpath):
        run_command_with_return_info('mkdir -p %s'%(dirpath))

    outf = open(fullpath, 'w')
    outf.write(content)
    outf.close()

def render_with_lang(lang):
    VARS['currentLang'] = lang
    load_info_with_lang(lang)

    summaryTpl = ENV.get_template('SUMMARY.tpl')
    summary = summaryTpl.render(
        l = VARS['l'],
        apis = VARS['apis'].values(),
        g_api_doc = generate_api_doc)

    output_file(summary, os.path.join('./', PURGE_DIR, lang, 'SUMMARY.md'))

    commonTpl = ENV.get_template('common.tpl')
    common = commonTpl.render(l = VARS['l'], v = VARS['v'])

    output_file(common, os.path.join('./', PURGE_DIR, lang, 'common.md'))

def generate_structs():
    run_command_with_return_info('rm -rf %s'%(PURGE_DIR))
    run_command_with_return_info('mkdir %s'%(PURGE_DIR))
    copy_static_files()
    for lang in VARS['v']['langs']:
        render_with_lang(lang)

    recursive_generate(
        './tpls', PURGE_DIR, get_first_layer_nodes('./tpls', PURGE_IGNORE))

def parse_tps(config):
    default = {}
    if (config.get('default') is None
        or config['default'].get('keyRate') is None):
        default = DEFAULT_KEY_TPS
    else:
        default = config['default']['keyRate']
    tps = {}
    tps['default'] = default
    for apitps in config.get('apis', []):
        name = apitps.get('api')
        keyRate = apitps.get('keyRate', default)
        if (apitps.get('method') is None):
            tps[(name, 'get')] = keyRate
            tps[(name, 'post')] = keyRate
        else:
            tps[(name, apitps['method'].lower())] = keyRate
    return tps

def load_info():
    global VARS
    inf = open('./meta/vars.json')
    VARS['v'] = json.loads(inf.read())
    inf.close()

def load_tps_config():
    global VARS
    inf = open('./%s/gatewayconf/limit_rate.json'%(TPS_CONFIG))
    VARS['tps'] = parse_tps(json.loads(inf.read()))
    inf.close()

def build_doc():
    load_info()
    load_tps_config()
    LOGGER.info('Creating gitbook files...')
    generate_structs()
    LOGGER.info('Syncing gitbook files...')
    sync_out()

def fetch_and_save_swagger_json(lang):
    fetchLang = lang
    if (lang == 'zh-hans'):
        fetchLang = 'zh'
    conn = None

    if VARS['v']['fetchurl'].startswith('https://'):
        host = VARS['v']['fetchurl'].replace('https://', '')
        conn = http.client.HTTPSConnection(host)
    else:
        host = VARS['v']['fetchurl'].replace('http://', '')
        conn = http.client.HTTPConnection(host)

    LOGGER.info('Fetching swagger.json with lang %s...'%(lang))
    conn.request("GET", SWAGGER_JSON_PATH + '?hl=%s'%(fetchLang))
    swagger = json.dumps(json.loads(conn.getresponse().read()))

    LOGGER.info('Writing swagger.json with lang %s...'%(lang))
    output_file(swagger, './meta/swagger_%s.json'%(lang))

def fetch_tps_config():
    if os.path.exists(TPS_CONFIG):
        run_command_with_return_info('rm -rf %s'%(TPS_CONFIG))
    run_command_with_return_info(
        'git clone %s %s'%(VARS['v']['tpsConfig'], TPS_CONFIG))

def refresh_swagger():
    load_info()
    for lang in VARS['v']['langs']:
        fetch_and_save_swagger_json(lang)
    # fetch_tps_config()

def windup():
    if not os.path.exists('./docs'):
        LOGGER.error('No docs dir found.')
        return
    run_command_with_return_info('cp -rf ./%s/* ./docs'%(IN_DOCS_PATH))
def main():
    """Main for xdoc"""

    parser = argparse.ArgumentParser(
        description = 'This tool is used for' +
        ' generating API docs (gitbook hosted).',
        fromfile_prefix_chars = '@',
        formatter_class = argparse.RawTextHelpFormatter)
    parser.add_argument(
        'command', type = str, nargs = '+', default = 'build',
        choices = ['refresh', 'build', 'windup'], help =
        'refresh: get new swagger json as well as tps config\n' +
        'build: generate docs\n' +
        'windup: do something after generated docs')

    args = parser.parse_args()

    if 'refresh' in args.command:
        refresh_swagger()
    if 'build' in args.command:
        build_doc()
    if 'windup' in args.command:
        windup()

if __name__ == '__main__':
    main()