初始化提交

boards/default_src/python_mixpy/converters/ai.js

@@ -0,0 +1,412 @@
+'use strict';
+
+
+pbc.assignD.get('AipImageClassify')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Attribute" || value.func.value._astname != "Name"){
+        return false;
+    }
+    var funcName = py2block.identifier(value.func.attr);
+    var moduleName = py2block.Name_str(value.func.value);
+    if(moduleName === "aip" && funcName === "AipImageClassify" && value.args.length === 2)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('AipImageClassify')['create_block'] = function(py2block, node, targets, value){
+    //var mode = py2block.Str_value(value.args[1]);
+    return block("AI_client", node.lineno, {
+        "CTYPE":"AipImageClassify"
+    }, {
+        //"APP_ID":py2block.convert(value.args[0]),
+        "API_KEY":py2block.convert(value.args[0]),
+        "SECRET_KEY":py2block.convert(value.args[1]),
+        "SUB":py2block.convert(targets[0])
+    });
+}
+
+pbc.assignD.get('AipSpeech')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Attribute" || value.func.value._astname != "Name"){
+        return false;
+    }
+    var funcName = py2block.identifier(value.func.attr);
+    var moduleName = py2block.Name_str(value.func.value);
+    if(moduleName === "aip" && funcName === "AipSpeech" && value.args.length === 2)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('AipSpeech')['create_block'] = function(py2block, node, targets, value){
+    //var mode = py2block.Str_value(value.args[1]);
+    return block("AI_client", node.lineno, {
+        "CTYPE":"AipSpeech"
+    }, {
+        //"APP_ID":py2block.convert(value.args[0]),
+        "API_KEY":py2block.convert(value.args[0]),
+        "SECRET_KEY":py2block.convert(value.args[1]),
+        "SUB":py2block.convert(targets[0])
+    });
+}
+
+pbc.assignD.get('AipImageCensor')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Attribute" || value.func.value._astname != "Name"){
+        return false;
+    }
+    var funcName = py2block.identifier(value.func.attr);
+    var moduleName = py2block.Name_str(value.func.value);
+    if(moduleName === "aip" && funcName === "AipImageCensor" && value.args.length === 2)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('AipImageCensor')['create_block'] = function(py2block, node, targets, value){
+    //var mode = py2block.Str_value(value.args[1]);
+    return block("AI_client", node.lineno, {
+        "CTYPE":"AipImageCensor"
+    }, {
+        //"APP_ID":py2block.convert(value.args[0]),
+        "API_KEY":py2block.convert(value.args[0]),
+        "SECRET_KEY":py2block.convert(value.args[1]),
+        "SUB":py2block.convert(targets[0])
+    });
+}
+
+pbc.assignD.get('AipOcr')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Attribute" || value.func.value._astname != "Name"){
+        return false;
+    }
+    var funcName = py2block.identifier(value.func.attr);
+    var moduleName = py2block.Name_str(value.func.value);
+    if(moduleName === "aip" && funcName === "AipOcr" && value.args.length === 2)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('AipOcr')['create_block'] = function(py2block, node, targets, value){
+    //var mode = py2block.Str_value(value.args[1]);
+    return block("AI_client", node.lineno, {
+        "CTYPE":"AipOcr"
+    }, {
+        //"APP_ID":py2block.convert(value.args[0]),
+        "API_KEY":py2block.convert(value.args[0]),
+        "SECRET_KEY":py2block.convert(value.args[1]),
+        "SUB":py2block.convert(targets[0])
+    });
+}
+
+pbc.assignD.get('AipNlp')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Attribute" || value.func.value._astname != "Name"){
+        return false;
+    }
+    var funcName = py2block.identifier(value.func.attr);
+    var moduleName = py2block.Name_str(value.func.value);
+    if(moduleName === "aip" && funcName === "AipNlp" && value.args.length === 2)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('AipNlp')['create_block'] = function(py2block, node, targets, value){
+    //var mode = py2block.Str_value(value.args[1]);
+    return block("AI_client", node.lineno, {
+        "CTYPE":"AipNlp"
+    }, {
+        //"APP_ID":py2block.convert(value.args[0]),
+        "API_KEY":py2block.convert(value.args[0]),
+        "SECRET_KEY":py2block.convert(value.args[1]),
+        "SUB":py2block.convert(targets[0])
+    });
+}
+
+pbc.assignD.get('AipFace')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Attribute" || value.func.value._astname != "Name"){
+        return false;
+    }
+    var funcName = py2block.identifier(value.func.attr);
+    var moduleName = py2block.Name_str(value.func.value);
+    if(moduleName === "aip" && funcName === "AipFace" && value.args.length === 2)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('AipFace')['create_block'] = function(py2block, node, targets, value){
+    //var mode = py2block.Str_value(value.args[1]);
+    return block("AI_client", node.lineno, {
+        "CTYPE":"AipFace"
+    }, {
+        //"APP_ID":py2block.convert(value.args[0]),
+        "API_KEY":py2block.convert(value.args[0]),
+        "SECRET_KEY":py2block.convert(value.args[1]),
+        "SUB":py2block.convert(targets[0])
+    });
+}
+
+function AIChooseAndGet(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 0) {
+            throw new Error("Incorrect number of arguments");
+        }
+        
+        return block("AI_ChooseAndGet", func.lineno, {"TYPE":mode}, {}, {
+        "inline": "true"
+    });
+    }
+    return converter;
+}
+
+pbc.moduleFunctionD.get('FileDialog')['getOneFile'] = AIChooseAndGet('getOneFile');
+pbc.moduleFunctionD.get('FileDialog')['getManyFiles'] = AIChooseAndGet('getManyFiles');
+pbc.moduleFunctionD.get('FileDialog')['getDirectory'] = AIChooseAndGet('getDirectory');
+
+pbc.objectFunctionD.get('synthesis')['Dict'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    var argument = py2block.convert(args[0]);
+    return block("AI_Speech_synthesis", func.lineno, {}, {
+        "SUB": objblock,
+        "STR": argument,
+        'ATTR':py2block.convert(keywords[0].value)
+    }, {
+        "inline": "false"
+    });
+};
+
+pbc.objectFunctionD.get('asr')['Dict'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    var argument = py2block.convert(args[0]);
+    return block("AI_Speech_asr", func.lineno, {}, {
+        "SUB": objblock,
+        "FILE": argument,
+        'ATTR':py2block.convert(keywords[0].value)
+    }, {
+        "inline": "false"
+    });
+};
+
+pbc.objectFunctionD.get('advancedGeneral')['Dict'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    var argument = py2block.convert(args[0]);
+    return block("AI_ImageClassify", func.lineno, {}, {
+        "SUB": objblock,
+        "FUNC": block("AI_ImageClassify_Func", func.lineno, {"TYPE":"advancedGeneral"}, {}),
+        "ADDR": argument,
+        'ATTR':py2block.convert(keywords[0].value)
+    }, {
+        "inline": "false"
+    });
+};
+
+pbc.objectFunctionD.get('match')['Dict'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    var argument = py2block.convert(args[0]);
+    var argument1 = py2block.convert(args[1]);
+    return block("AI_Face_match", func.lineno, {}, {
+        "SUB": objblock,
+        "VAR": argument,
+        "VAR2": argument1,
+        'ATTR':py2block.convert(keywords[0].value)
+    }, {
+        "inline": "false"
+    });
+};
+
+function AIImageClassify(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    var argument = py2block.convert(args[0]);
+    return block("AI_ImageClassify", func.lineno, {}, {
+        "SUB": objblock,
+        "FUNC": block("AI_ImageClassify_Func", func.lineno, {"TYPE":mode}, {}),
+        "ADDR": argument,
+        'ATTR':py2block.convert(keywords[0].value)
+    }, {
+        "inline": "false"
+    });
+    }
+    return converter;
+}
+
+pbc.objectFunctionD.get('advancedGeneral')['Dict'] = AIImageClassify('advancedGeneral');
+pbc.objectFunctionD.get('dishDetect')['Dict'] = AIImageClassify('dishDetect');
+pbc.objectFunctionD.get('carDetect')['Dict'] = AIImageClassify('carDetect');
+pbc.objectFunctionD.get('animalDetect')['Dict'] = AIImageClassify('animalDetect');
+pbc.objectFunctionD.get('plantDetect')['Dict'] = AIImageClassify('plantDetect');
+pbc.objectFunctionD.get('logoSearch')['Dict'] = AIImageClassify('logoSearch');
+
+function AIORC(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    var argument = py2block.convert(args[0]);
+    return block("AI_Ocr", func.lineno, {}, {
+        "SUB": objblock,
+        "FUNC": block("AI_Ocr_Func", func.lineno, {"TYPE":mode}, {}),
+        "ADDR": argument,
+        'ATTR':py2block.convert(keywords[0].value)
+    }, {
+        "inline": "false"
+    });
+    }
+    return converter;
+}
+
+pbc.objectFunctionD.get('basicGeneral')['Dict'] = AIORC('basicGeneral');
+pbc.objectFunctionD.get('webImage')['Dict'] = AIORC('webImage');
+pbc.objectFunctionD.get('idcard')['Dict'] = AIORC('idcard');
+pbc.objectFunctionD.get('bankcard')['Dict'] = AIORC('bankcard');
+pbc.objectFunctionD.get('drivingLicense')['Dict'] = AIORC('drivingLicense');
+pbc.objectFunctionD.get('vehicleLicense')['Dict'] = AIORC('vehicleLicense');
+pbc.objectFunctionD.get('licensePlate')['Dict'] = AIORC('licensePlate');
+pbc.objectFunctionD.get('businessLicense')['Dict'] = AIORC('businessLicense');
+pbc.objectFunctionD.get('receipt')['Dict'] = AIORC('receipt');
+pbc.objectFunctionD.get('trainTicket')['Dict'] = AIORC('trainTicket');
+pbc.objectFunctionD.get('taxiReceipt')['Dict'] = AIORC('taxiReceipt');
+pbc.objectFunctionD.get('tableRecognition')['Dict'] = AIORC('tableRecognition');
+pbc.objectFunctionD.get('vatInvoice')['Dict'] = AIORC('vatInvoice');
+pbc.objectFunctionD.get('passport')['Dict'] = AIORC('passport');
+pbc.objectFunctionD.get('handwriting')['Dict'] = AIORC('handwriting');
+
+function AINLP(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    var argument = py2block.convert(args[0]);
+    return block("AI_Nlp", func.lineno, {}, {
+        "SUB": objblock,
+        "FUNC": block("AI_Nlp_Func", func.lineno, {"TYPE":mode}, {}),
+        "STR": argument,
+        'ATTR':py2block.convert(keywords[0].value)
+    }, {
+        "inline": "false"
+    });
+    }
+    return converter;
+}
+
+pbc.objectFunctionD.get('lexer')['Dict'] = AINLP('lexer');
+pbc.objectFunctionD.get('depParser')['Dict'] = AINLP('depParser');
+pbc.objectFunctionD.get('wordEmbedding')['Dict'] = AINLP('wordEmbedding');
+pbc.objectFunctionD.get('dnnlm')['Dict'] = AINLP('dnnlm');
+pbc.objectFunctionD.get('commentTag')['Dict'] = AINLP('commentTag');
+pbc.objectFunctionD.get('sentimentClassify')['Dict'] = AINLP('sentimentClassify');
+pbc.objectFunctionD.get('keyword')['Dict'] = AINLP('keyword');
+//pbc.objectFunctionD.get('topic')['Dict'] = AINLP('topic');
+pbc.objectFunctionD.get('ecnet')['Dict'] = AINLP('ecnet');
+pbc.objectFunctionD.get('emotion')['Dict'] = AINLP('emotion');
+
+function AISIMILARITY(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    var argument = py2block.convert(args[0]);
+    var argument1 = py2block.convert(args[1]);
+    var a;
+    return block("AI_Nlp_Sim", func.lineno, {}, {
+        "SUB": objblock,
+        "FUNC": block("AI_Nlp_Func_sim", func.lineno, {"TYPE":mode}, {}),
+        "STR1": argument,
+        "STR2": argument1,
+        'ATTR':py2block.convert(keywords[0].value)
+    }, {
+        "inline": "false"
+    });
+    }
+    return converter;
+}
+
+pbc.objectFunctionD.get('wordSimEmbedding')['Dict'] = AISIMILARITY('wordSimEmbedding');
+pbc.objectFunctionD.get('simnet')['Dict'] = AISIMILARITY('simnet');
+
+
+pbc.objectFunctionD.get('newsSummary')['Dict'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    var argument = py2block.convert(args[0]);
+    var argument1 = py2block.convert(args[1]);
+    return block("AI_Nlp_newsSummary", func.lineno, {}, {
+        "SUB": objblock,
+        "STR": argument,
+        "LEN": argument1,
+        'ATTR':py2block.convert(keywords[0].value)
+    }, {
+        "inline": "false"
+    });
+};
+
+pbc.objectFunctionD.get('topic')['Dict'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (keywords.length > 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    if (keywords.length == 0){
+        var objblock = py2block.convert(func.value);
+        var argument = py2block.convert(args[0]);
+        var argument1 = py2block.convert(args[1]);
+        return block("AI_Nlp_Topic", func.lineno, {}, {
+            "SUB": objblock,
+            "STR1": argument,
+            "STR2": argument1,        
+        }, {
+            "inline": "false"
+        });
+    }
+    if (keywords.length == 1){
+        var objblock = py2block.convert(func.value);
+        var argument = py2block.convert(args[0]);
+        return block("AI_Nlp", func.lineno, {}, {
+            "SUB": objblock,
+            "FUNC": block("AI_Nlp_Func", func.lineno, {"TYPE":"topic"}, {}),
+            "STR": argument,
+            'ATTR':py2block.convert(keywords[0].value)
+        }, {
+            "inline": "false"
+        });
+    }
+};
+
+pbc.moduleFunctionD.get('audio')['audio_record'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var varblock = py2block.convert(args[0]);
+    var numblock = py2block.convert(args[1]);
+    return [block("AI_audio", func.lineno, {}, {
+        'VAR': varblock,
+        'TIME': numblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.moduleFunctionD.get('cam')['photo_capture'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var varblock = py2block.convert(args[0]);
+    var numblock = py2block.convert(args[1]);
+    return [block("AI_photo", func.lineno, {}, {
+        'VAR': varblock,
+        'BUT': numblock
+    }, {
+        "inline": "true"
+    })];
+}

boards/default_src/python_mixpy/converters/communicate.js

@@ -0,0 +1,86 @@
+'use strict';
+
+// pbc.assignD.get('Response')['check_assign'] = function (py2block, node, targets, value) {
+//     if(value.func._astname != "Attribute" || value.func.value._astname != "Name"){
+//         return false;
+//     }
+//     var moduleName = py2block.Name_str(value.func.value);
+//     var funcName = py2block.identifier(value.func.attr);
+//     if (value._astname === "Call" && moduleName === "requests"
+//         && funcName === "get" && value.args.length === 1)
+//         return true;
+//     return false;
+// }
+
+// pbc.assignD.get('Response')['create_block'] = function (py2block, node, targets, value) {
+//     var nameblock = py2block.Name_str(node.targets[0]);
+//     var argblock = py2block.convert(value.args[0]);
+//     return block('requests_get', node.lineno, {
+//             'VAR': nameblock
+//         }, {
+//             'DOMAIN':argblock
+//         });
+// }
+
+function communicateRequestmethod(mode) {
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length != 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var argblock = py2block.convert(args[0]);
+            return block("requests_get", func.lineno, {
+                'TYPE': mode,                
+            }, {
+                'URL': argblock
+            }, {
+                "inline": "true"
+            });
+    
+        }
+    return converter;
+
+}
+
+pbc.moduleFunctionD.get('requests')['get'] = communicateRequestmethod('get');
+pbc.moduleFunctionD.get('requests')['head'] = communicateRequestmethod('head');
+pbc.moduleFunctionD.get('requests')['delete'] = communicateRequestmethod('delete');
+
+function communicatePostmethod(mode) {
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length != 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var argblock = py2block.convert(args[0]);
+        var keyblock = py2block.convert(keywords[0].value)
+            return block("requests_post", func.lineno, {
+                'TYPE': mode,                
+            }, {
+                'URL': argblock,
+                'data':keyblock
+            }, {
+                "inline": "true"
+            });
+    
+        }
+    return converter;
+
+}
+
+pbc.moduleFunctionD.get('requests')['post'] = communicatePostmethod('post');
+pbc.moduleFunctionD.get('requests')['put'] = communicatePostmethod('put');
+pbc.moduleFunctionD.get('requests')['patch'] = communicatePostmethod('patch');
+
+function modelsResponse(py2block, node, value, attr) {
+    return block('requests_attribute', node.lineno, {
+        'ATTR': py2block.identifier(attr)
+    }, {
+        'VAL': py2block.convert(value)
+    });
+}
+
+pbc.objectAttrD.get('status_code')['Response'] = modelsResponse;
+pbc.objectAttrD.get('text')['Response'] = modelsResponse;
+pbc.objectAttrD.get('cookies')['Response'] = modelsResponse;
+pbc.objectAttrD.get('content')['Response'] = modelsResponse;
+pbc.objectAttrD.get('encoding')['Response'] = modelsResponse;
+

boards/default_src/python_mixpy/converters/cv.js

@@ -0,0 +1,244 @@
+'use strict';
+
+pbc.moduleFunctionD.get('cv2')['imread'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var arg1block = py2block.convert(args[0]);
+        return block("cv_read_image", func.lineno, {}, {
+                'FILE': arg1block
+        }, {
+                "inline": "true"
+            });
+}
+
+pbc.moduleFunctionD.get('cv2')['CascadeClassifier'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var arg1block = py2block.convert(args[0]);
+        return block("cv_face_classifier", func.lineno, {}, {
+                'FILE': arg1block
+        }, {
+                "inline": "true"
+            });
+}
+
+pbc.moduleFunctionD.get('cv2')['imshow'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var arg1block = py2block.convert(args[0]);
+        var arg2block = py2block.convert(args[1]);
+        return [block("cv_show_image", func.lineno, {}, {
+                'data': arg1block,
+                'FILE':arg2block
+        }, {
+                "inline": "true"
+            })];
+}
+
+pbc.moduleFunctionD.get('cv2')['imwrite'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var arg1block = py2block.convert(args[0]);
+        var arg2block = py2block.convert(args[1]);
+        return [block("cv_write_image", func.lineno, {}, {
+                'data': arg1block,
+                'FILE':arg2block
+        }, {
+                "inline": "true"
+            })];
+}
+
+pbc.moduleFunctionD.get('cv2')['waitKey'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var arg1block = py2block.convert(args[0]);        
+        return [block("cv_waitkey", func.lineno, {}, {
+                'data': arg1block
+        }, {
+                "inline": "true"
+            })];
+}
+
+pbc.moduleFunctionD.get('cv2')['destroyAllWindows'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 0) {
+        throw new Error("Incorrect number of arguments");
+    }      
+        return [block("cv_destroy_all", func.lineno, {}, {}, {
+                "inline": "true"
+            })];
+}
+
+
+function cvRectLine(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {    
+    if (args.length != 5) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var arg1block = py2block.convert(args[0]);
+    
+    var x1 = args[1].elts[0]
+    var y1 = args[1].elts[1]
+    var x2 = args[2].elts[0]
+    var y2 = args[2].elts[1]
+
+    var colorv='#'    
+    if(args[3].elts[2].n.v.toString(16).length==1){
+        colorv+='0'
+    }     
+    colorv+=args[3].elts[2].n.v.toString(16)
+    if(args[3].elts[1].n.v.toString(16).length==1){
+        colorv+='0'
+    }     
+    colorv+=args[3].elts[1].n.v.toString(16)
+    if(args[3].elts[0].n.v.toString(16).length==1){
+        colorv+='0'
+    }     
+    colorv+=args[3].elts[0].n.v.toString(16)
+    var color = {
+            _astname: "Str",
+            s: {
+                'v': colorv
+            }
+        }      
+    var x1block = py2block.convert(x1); 
+    var x2block = py2block.convert(x2); 
+    var y1block = py2block.convert(y1); 
+    var y2block = py2block.convert(y2);
+    var colorblock = py2block.Str_value(color);    
+    var arg5block = py2block.convert(args[4]);       
+    return [block("cv_line_rect", func.lineno, {
+        'DIR':mode,
+        'FIELDNAME':colorblock
+    }, {
+                'FILE': arg1block,
+                'x1':x1block,
+                'y1':y1block,
+                'x2':x2block,
+                'y2':y2block,
+                'thick':arg5block,
+                
+        }, {
+                "inline": "true"
+            })];
+}
+    return converter;
+}
+
+pbc.moduleFunctionD.get('cv2')['rectangle'] = cvRectLine('rectangle')
+pbc.moduleFunctionD.get('cv2')['line'] = cvRectLine('line')
+
+pbc.moduleFunctionD.get('cv2')['putText'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 7) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var arg1block = py2block.convert(args[0]);
+    var arg2block = py2block.convert(args[1]);
+    var x1 = args[2].elts[0]
+    var y1 = args[2].elts[1]
+    
+    var colorv='#'    
+    if(args[5].elts[2].n.v.toString(16).length==1){
+        colorv+='0'
+    }     
+    colorv+=args[5].elts[2].n.v.toString(16)
+    if(args[5].elts[1].n.v.toString(16).length==1){
+        colorv+='0'
+    }     
+    colorv+=args[5].elts[1].n.v.toString(16)
+    if(args[5].elts[0].n.v.toString(16).length==1){
+        colorv+='0'
+    }     
+    colorv+=args[5].elts[0].n.v.toString(16)
+    var color = {
+            _astname: "Str",
+            s: {
+                'v': colorv
+            }
+        }      
+    var x1block = py2block.convert(x1); 
+    var y1block = py2block.convert(y1); 
+    var colorblock = py2block.Str_value(color);    
+    var arg5block = py2block.convert(args[4]);
+    var arg7block = py2block.convert(args[6]);   
+    var font = args[3].attr.v.slice(13)    
+    return [block("cv_text", func.lineno, {
+        'font':font,
+        'FIELDNAME':colorblock
+    }, {
+                'FILE': arg1block,
+                'data':arg2block,
+                'x1':x1block,
+                'y1':y1block,
+                'size':arg5block,
+                'thick':arg7block,
+                
+        }, {
+                "inline": "true"
+            })];
+}
+
+pbc.objectFunctionD.get('detectMultiScale')['face'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 1 || keywords.length < 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+        var arg1block = py2block.convert(args[0]);
+        var faceblock = py2block.convert(func.value);
+    if(keywords.length == 2){
+        var keylist = new Array(2)
+        for(var i=0;i<keywords.length;i++){
+            var tag = py2block.identifier(keywords[i].arg)
+            if (tag=='scaleFactor'){
+                keylist[0]=py2block.convert(keywords[i].value);
+            }
+            else if(tag=='minNeighbors'){
+                keylist[1]=py2block.convert(keywords[i].value);
+            }
+        }
+
+    return block("cv_face_detect", func.lineno, {},{
+        'FILE': arg1block,
+        "FACE":faceblock,
+        'SCALE':keylist[0],
+        'NEIGHBOR':keylist[1]
+    
+    },{
+        "inline": "true"
+    });}
+    if(keywords.length == 4){
+        var keylist = new Array(6)
+        for(var i=0;i<keywords.length;i++){
+            var tag = py2block.identifier(keywords[i].arg)
+            if (tag=='scaleFactor'){
+                keylist[0]=py2block.convert(keywords[i].value);
+            }
+            else if(tag=='minNeighbors'){
+                keylist[1]=py2block.convert(keywords[i].value);
+            }
+            else if(tag=='minSize'){
+                keylist[2]=py2block.convert(keywords[i].value.elts[0]);
+                keylist[3]=py2block.convert(keywords[i].value.elts[1]);
+            }
+            else if(tag=='maxSize'){
+                keylist[4]=py2block.convert(keywords[i].value.elts[0]);
+                keylist[5]=py2block.convert(keywords[i].value.elts[1]);
+            }
+        }
+    
+    return block("cv_face_detect_all", func.lineno, {},{
+        'FILE': arg1block,
+        "FACE":faceblock,
+        'SCALE':keylist[0],
+        'NEIGHBOR':keylist[1],
+        'x1':keylist[2],
+        'y1':keylist[3],
+        'x2':keylist[4],
+        'y2':keylist[5]
+    },{
+        "inline": "true"
+    });}
+};

boards/default_src/python_mixpy/converters/datastructure.js

@@ -0,0 +1,342 @@
+'use strict';
+
+pbc.assignD.get('Series')['check_assign'] = function (py2block, node, targets, value) {
+    if(value.func._astname != "Attribute" || value.func.value._astname != "Name"){
+        return false;
+    }
+    var moduleName = py2block.Name_str(value.func.value);
+    var funcName = py2block.identifier(value.func.attr);
+    if (value._astname === "Call" && moduleName === "pandas"
+        && funcName === "Series" && value.args.length === 1)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('Series')['create_block'] = function (py2block, node, targets, value) {
+    var series = py2block.Name_str(node.targets[0]);
+    var argblock = py2block.convert(value.args[0]);
+    var param = value.keywords[0];
+    if (value.keywords.length == 0){
+        return block('series_create', node.lineno, {
+            'VAR': series            
+        }, {
+            'SER': argblock
+        });
+    }
+    else if(value.keywords.length == 1&&param.arg.v =="index"){
+        var listblock = py2block.convert(value.keywords[0].value);
+    return block('series_create_from_index', node.lineno, {
+            'VAR': series            
+        }, {
+            'SER': argblock,
+            'INDEX': listblock
+        });
+    }
+}
+
+pbc.moduleFunctionD.get('pylab')['show'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    return [block("pl_show", func.lineno, {}, {}, {
+            "inline": "true"
+        })];
+}
+
+pbc.moduleFunctionD.get('pylab')['legend'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    return [block("pl_legend", func.lineno, {}, {}, {
+            "inline": "true"
+        })];
+}
+
+pbc.moduleFunctionD.get('pylab')['title'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    return [block("pl_title", func.lineno, {}, {
+        'TITLE': argblock
+    }, {
+            "inline": "true"
+        })];
+}
+
+function dataxylabel(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var argblock = py2block.convert(args[0]);
+        return [block("pl_label", func.lineno, {
+            "DIR":mode
+        }, {
+        'LABEL': argblock
+    }, {
+            "inline": "true"
+        })];
+    }
+    return converter;
+}
+
+pbc.moduleFunctionD.get('pylab')['xlabel'] = dataxylabel('x');
+pbc.moduleFunctionD.get('pylab')['ylabel'] = dataxylabel('y');
+
+pbc.assignD.get('DataFrame')['check_assign'] = function (py2block, node, targets, value) {
+    if(value.func._astname != "Attribute" || value.func.value._astname != "Name"){
+        return false;
+    }
+    var moduleName = py2block.Name_str(value.func.value);
+    var funcName = py2block.identifier(value.func.attr);
+    if (value._astname === "Call" && moduleName === "pandas"
+        && funcName === "DataFrame" && value.args.length === 1)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('DataFrame')['create_block'] = function (py2block, node, targets, value) {
+    var series = py2block.Name_str(node.targets[0]);
+    var argblock = py2block.convert(value.args[0]);
+    var param = value.keywords[0];
+    if (value.keywords.length == 0){
+        return block('dataframe_create', node.lineno, {
+            'VAR': series            
+        }, {
+            'SER': argblock
+        });
+    }
+    else if(value.keywords.length == 1&&value.keywords[0].arg.v =="index"){
+        var listblock = py2block.convert(value.keywords[0].value);
+        return block('dataframe_create_from_one_index', node.lineno, {
+            'VAR': series,  
+            'COLUMN_RAW':"index"          
+        }, {
+            'SER': argblock,
+            'INDEX': listblock
+        });
+    }
+    else if(value.keywords.length == 1&&value.keywords[0].arg.v =="columns"){
+        var listblock = py2block.convert(value.keywords[0].value);
+        return block('dataframe_create_from_one_index', node.lineno, {
+            'VAR': series,
+            'COLUMN_RAW':"columns"           
+        }, {
+            'SER': argblock,
+            'INDEX': listblock
+        });
+    }
+    else if(value.keywords.length == 2&&((value.keywords[0].arg.v =="columns"&&value.keywords[1].arg.v =="index")||(value.keywords[1].arg.v =="columns"&&value.keywords[0].arg.v =="index"))){
+        var listblock0 = py2block.convert(value.keywords[0].value);
+        var listblock1 = py2block.convert(value.keywords[1].value);
+        if(value.keywords[0].arg.v =="columns"&&value.keywords[1].arg.v =="index"){ 
+            return block('dataframe_create_from_index', node.lineno, {
+                'VAR': series            
+            }, {
+                'SER': argblock,
+                'INDEX_COLUMN': listblock0,
+                'INDEX_RAW': listblock1
+            });
+        }
+        if(value.keywords[1].arg.v =="columns"&&value.keywords[0].arg.v =="index"){ 
+            return block('dataframe_create_from_index', node.lineno, {
+                'VAR': series            
+            }, {
+                'SER': argblock,
+                'INDEX_COLUMN': listblock1,
+                'INDEX_RAW': listblock0
+            });
+        }    
+    }
+}
+
+pbc.moduleFunctionD.get('pylab')['plot'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1&&args.length != 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    
+    var argblock = py2block.convert(args[0]);
+    if (args.length == 1){
+        return [block("pl_plot", func.lineno, {
+                'DOT':',',
+                'LINE':'-',
+                'COLOR':'b'
+        }, {
+                'SER': argblock
+        }, {
+                "inline": "true"
+            })];
+    }
+    else if(args.length == 2){
+        var lineblock = args[1].s.v;
+        if (lineblock.length>4) {
+        throw new Error("Incorrect number of arguments");
+    }
+        var dottype = ',';
+        var linetype = '-';
+        var colortype = 'b';
+        for(var i=0;i<lineblock.length;i++){
+            if(lineblock[i]=='-'&&(lineblock[i+1]=='-'||lineblock[i+1]=='.')){
+                linetype=lineblock[i]+lineblock[i+1];
+                i++;
+                break;
+            } 
+            else{
+                var operate=lineblock[i];
+            }
+            switch(operate){
+                case '-':
+                linetype=operate;
+                break;
+
+                case ':':
+                linetype=operate;
+                break;
+
+                case 'b':
+                colortype=operate;
+                break;
+
+                case 'g':
+                colortype=operate;
+                break;
+
+                case 'r':
+                colortype=operate;
+                break;
+
+                case 'c':
+                colortype=operate;
+                break;
+
+                case 'm':
+                colortype=operate;
+                break;
+
+                case 'y':
+                colortype=operate;
+                break;
+
+                case 'k':
+                colortype=operate;
+                break;
+
+                case 'w':
+                colortype=operate;
+                break;
+
+                case '.':
+                dottype=operate;
+                break;
+
+                case '^':
+                dottype=operate;
+                break;
+
+                case '2':
+                dottype=operate;
+                break;
+
+                case 'p':
+                dottype=operate;
+                break;
+
+                case '+':
+                dottype=operate;
+                break;
+
+                case '|':
+                dottype=operate;
+                break;
+
+                case ',':
+                dottype=operate;
+                break;
+
+                case '<':
+                dottype=operate;
+                break;
+
+                case '3':
+                dottype=operate;
+                break;
+
+                case '*':
+                dottype=operate;
+                break;
+
+                case 'x':
+                dottype=operate;
+                break;
+
+                case '_':
+                dottype=operate;
+                break;
+
+                case 'o':
+                dottype=operate;
+                break;
+
+                case '>':
+                dottype=operate;
+                break;
+
+                case '4':
+                dottype=operate;
+                break;
+
+                case 'h':
+                dottype=operate;
+                break;
+
+                case 'D':
+                dottype=operate;
+                break;
+
+                case 'v':
+                dottype=operate;
+                break;
+
+                case '1':
+                dottype=operate;
+                break;
+
+                case 's':
+                dottype=operate;
+                break;
+
+                case 'd':
+                dottype=operate;
+                break;
+
+                case 'H':
+                dottype=operate;
+                break;
+
+            }
+        }
+
+        return [block("pl_plot", func.lineno, {
+                'DOT':dottype,
+                'LINE':linetype,
+                'COLOR':colortype
+        }, {
+                'SER': argblock
+        }, {
+                "inline": "true"
+            })];
+    }
+}
+
+
+function series_index_value(py2block, node, value, attr) {
+    return block('series_index_value', node.lineno, {
+        'INDEX_VALUE': py2block.identifier(attr)
+    }, {
+        'SERIES': py2block.convert(value)
+    });
+}
+
+pbc.objectAttrD.get('index')['Series'] = series_index_value;
+pbc.objectAttrD.get('value')['Series'] = series_index_value;

boards/default_src/python_mixpy/converters/hardware.js

@@ -0,0 +1,93 @@
+'use strict';
+
+pbc.assignD.get('hardware')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" || value.func._astname != "Attribute" || value.func.value._astname != "Name"){
+        return false;
+    }
+    var moduleName = py2block.Name_str(value.func.value);
+    var funcName = py2block.identifier(value.func.attr);
+    if(value._astname === "Call" && moduleName === "s4alib"
+        && funcName === "s4a_start" && value.args.length === 1)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('hardware')['create_block'] = function(py2block, node, targets, value){
+    var argblock = py2block.convert(value.args[0]);
+    return block("hardware_arduino_start", node.lineno, {
+    }, {
+        // "PIN":argblock,
+        "SUB":py2block.convert(targets[0]),
+    });
+}
+
+pbc.objectFunctionD.get('digital_write')['s4a'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    pbc.pinType = "pins_digital_write";
+    var pinblock = py2block.convert(args[0]);
+    pbc.pinType = "pins_digital";
+    var argblock = py2block.convert(args[1]);
+    pbc.pinType = null;
+    var s4ablock=py2block.convert(func.value);
+    return [block("hardware_arduino_digital_write", func.lineno, {}, {
+        'SUB':s4ablock,
+        "PIN": pinblock,
+        "STAT": argblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.objectFunctionD.get('digital_read')['s4a'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    pbc.pinType = "pins_digital_read";
+    var pinblock = py2block.convert(args[0]);
+    pbc.pinType = null;
+    var s4ablock=py2block.convert(func.value);
+    return block("hardware_arduino_digital_read", func.lineno, {}, {
+        'SUB':s4ablock,
+        "PIN": pinblock,
+    }, {
+        "inline": "true"
+    });
+}
+
+pbc.objectFunctionD.get('analog_write')['s4a'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    pbc.pinType = "pins_analog_write";
+    var pinblock = py2block.convert(args[0]);
+    pbc.pinType = null;
+    var argblock = py2block.convert(args[1]);
+    var s4ablock=py2block.convert(func.value);
+    return [block("hardware_arduino_analog_write", func.lineno, {}, {
+        'SUB':s4ablock,
+        "PIN": pinblock,
+        "NUM": argblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+
+pbc.objectFunctionD.get('analog_read')['s4a'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    pbc.pinType = "pins_analog_read";
+    var pinblock = py2block.convert(args[0]);
+    pbc.pinType = null;
+    var s4ablock=py2block.convert(func.value);
+    return block("hardware_arduino_analog_read", func.lineno, {}, {
+        'SUB':s4ablock,
+        "PIN": pinblock,
+    }, {
+        "inline": "true"
+    });
+}
+

boards/default_src/python_mixpy/converters/inout.js

@@ -0,0 +1,98 @@
+'use strict';
+
+pbc.globalFunctionD['input'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1 && args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    if (args.length == 1){
+    var argblock = py2block.convert(args[0]);
+    return block("inout_type_input", func.lineno, {
+         "DIR":"str"
+    }, {
+        'VAR':argblock
+    }, {
+        "inline": "true"
+    });}
+    if (args.length == 0){
+    
+    return block("inout_type_input", func.lineno, {
+         "DIR":"str"
+    }, {
+        //'VAR':argblock
+    }, {
+        "inline": "true"
+    });}
+}
+
+pbc.moduleFunctionD.get('pyinput')['input'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1 && args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    if (args.length == 1){
+    var argblock = py2block.convert(args[0]);
+    return block("inout_type_input", func.lineno, {
+         "DIR":"str"
+    }, {
+        'VAR':argblock
+    }, {
+        "inline": "true"
+    });}
+    if (args.length == 0){
+    
+    return block("inout_type_input", func.lineno, {
+         "DIR":"str"
+    }, {
+        //'VAR':argblock
+    }, {
+        "inline": "true"
+    });}
+}
+
+
+//int(input('prompt'))在math.js中实现
+//float(input('prompt'))在lists.js中实现
+
+pbc.globalFunctionD['print'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length === 1 && keywords.length === 1
+        && py2block.identifier(keywords[0].arg) === "end"
+        && keywords[0].value._astname === "Str"
+        //&& py2block.Str_value(keywords[0].value) === ""
+    ) { if(py2block.Str_value(keywords[0].value) === ""){//print('Hello',end ="")
+            var argblock = py2block.convert(args[0]);
+            return [block("inout_print_inline", func.lineno, {}, {
+                'VAR':argblock
+            }, {
+                "inline": "false"
+            })];
+        }
+        else{
+            var argblock = py2block.convert(args[0]);
+            return [block("inout_print_end", func.lineno, {                
+            }, {
+                'VAR':argblock,
+                'END':py2block.convert(keywords[0].value)
+            }, {
+                "inline": "true"
+            })];
+        }
+    }else if (args.length === 1 && keywords.length === 0) { //print('Hello')
+        var argblock = py2block.convert(args[0]);
+        return [block("inout_print", func.lineno, {}, {
+            'VAR':argblock
+        }, {
+            "inline": "false"
+        })];
+    }else if (args.length != 1 && keywords.length === 0) { //print()
+        var d = py2block.convertElements("ADD", args);
+        
+        return [block("inout_print_many", node.lineno, {
+        }, d, {
+            "inline": "true",
+        }, {
+            "@items":args.length
+        })];
+        
+    }else{
+        throw new Error("Incorrect number of arguments");
+    }
+}

boards/default_src/python_mixpy/converters/iot.js

@@ -0,0 +1,162 @@
+'use strict';
+
+var mqtt_client = 'mixiot.MixIO';
+pbc.assignD.get('from_mixly_key')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Attribute" || value.func.value._astname != "Attribute"){
+        return false;
+    }
+    var funcName = py2block.identifier(value.func.attr);
+    var moduleName = py2block.identifier(value.func.value.attr);
+    if(moduleName === "MixIO" && funcName === "from_mixly_key" && value.args.length === 4)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('from_mixly_key')['create_block'] = function(py2block, node, targets, value){
+    var arg0block = py2block.convert(value.args[0]);
+    var arg2block = py2block.convert(value.args[2]);
+    return block("IOT_EMQX_INIT_AND_CONNECT_BY_MIXLY_CODE", node.lineno, {}, {
+        'SERVER': arg0block,
+        'KEY':arg2block,
+    });
+}
+
+pbc.assignD.get('from_share_key')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Attribute" || value.func.value._astname != "Attribute"){
+        return false;
+    }
+    var funcName = py2block.identifier(value.func.attr);
+    var moduleName = py2block.identifier(value.func.value.attr);
+    if(moduleName === "MixIO" && funcName === "from_share_key" && value.args.length === 4)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('from_share_key')['create_block'] = function(py2block, node, targets, value){
+    var arg0block = py2block.convert(value.args[0]);
+    var arg2block = py2block.convert(value.args[2]);
+    return block("IOT_EMQX_INIT_AND_CONNECT_BY_SHARE_CODE", node.lineno, {}, {
+        'SERVER': arg0block,
+        'KEY':arg2block,
+    });
+}
+
+pbc.assignD.get('MixIO')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Attribute" || value.func.value._astname != "Name"){
+        return false;
+    }
+    var funcName = py2block.identifier(value.func.attr);
+    var moduleName = py2block.Name_str(value.func.value);
+    if(moduleName === "mixiot" && funcName === "MixIO" && value.args.length === 6)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('MixIO')['create_block'] = function(py2block, node, targets, value){
+    var arg0block = py2block.convert(value.args[0]);
+    var arg2block = py2block.convert(value.args[2]);
+    var arg3block = py2block.convert(value.args[3]);
+    var arg4block = py2block.convert(value.args[4]);
+    return block("iot_mixio_connect", node.lineno, {}, {
+        'SERVER': arg0block,
+        'USERNAME':arg2block,
+        'PASSWORD': arg3block,
+        'PROJECT':arg4block
+    });
+}
+
+pbc.objectFunctionD.get('publish')[mqtt_client] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    var arg1block = py2block.convert(args[1]);
+     return [block('IOT_MIXIO_PUBLISH', func.lineno, {}, {
+        'TOPIC': argblock,
+        'MSG': arg1block
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.objectFunctionD.get('unsubscribe')[mqtt_client] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+     return [block('IOT_MIXIO_UNSUBSCRIBE', func.lineno, {}, {
+        'TOPIC': argblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.objectFunctionD.get('subscribe_and_set_callback')[mqtt_client] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    var arg1block = py2block.convert(args[1]);
+     return [block('IOT_MIXIO_SUBSCRIBE', func.lineno, {}, {
+        'TOPIC': argblock,
+        'METHOD': arg1block
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.objectFunctionD.get('check_msg')[mqtt_client] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    
+     return [block('iot_mixio_check', func.lineno, {}, {}, {
+        "inline": "true"
+    })];
+}
+
+pbc.objectFunctionD.get('connect')[mqtt_client] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    
+     return [block('iot_mixio_connect_only', func.lineno, {}, {}, {
+        "inline": "true"
+    })];
+}
+
+pbc.objectFunctionD.get('disconnect')[mqtt_client] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    
+     return [block('iot_mixio_disconnect', func.lineno, {}, {}, {
+        "inline": "true"
+    })];
+}
+
+pbc.moduleFunctionD.get('mixpy')['format_content'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    
+     return block('IOT_FORMATTING', func.lineno, {}, {
+        'VAR': argblock,
+     }, {
+        "inline": "true"
+    });
+}
+
+pbc.moduleFunctionD.get('mixpy')['format_str'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    
+     return block('IOT_FORMAT_STRING', func.lineno, {}, {
+        'VAR': argblock,
+     }, {
+        "inline": "true"
+    });
+}

boards/default_src/python_mixpy/converters/py2block_config.js

@@ -0,0 +1,82 @@
+function defDict(type) {
+    var dict = {};
+    return {
+        get: function (key) {
+            if (!dict[key]) {
+                dict[key] = type.constructor();
+            }
+            return dict[key];
+        },
+        dict: dict
+    };
+}
+
+function Py2blockConfig (){
+    this.initIgnoreS();
+    this.initModuleAttrD();
+    this.initKnownModuleS();
+    this.initObjectTypeD();
+}
+
+var pbc = Py2blockConfig.prototype;
+pbc.MIXPY = "MIXPY";
+pbc.board = pbc.MIXPY;
+pbc.objectFunctionD = defDict({});
+pbc.moduleFunctionD = defDict({});
+pbc.moduleAttrD = defDict({});
+pbc.objectAttrD = defDict({});
+pbc.globalFunctionD = {};
+pbc.assignD = defDict({});
+pbc.ifStatementD= defDict({});
+pbc.whileStatementD= defDict({});
+pbc.forStatementD= defDict({});
+pbc.reservedNameD= {};
+pbc.knownModuleS = new Set();
+pbc.objectTypeD = {}; //key：变量名，value：变量类型，如{'a':'List'}
+pbc.ignoreS = new Set();
+pbc.pinType = null;
+pbc.inScope = null;
+pbc.formatModuleKeyL = [];
+pbc.formatModuleL = [];
+
+//忽略某些方法、类、赋值
+pbc.initIgnoreS = function(){
+    var pythonIgnoreL = [
+    ];
+    var boardIgnoreL = [];
+
+    var ignoreL = pythonIgnoreL.concat(boardIgnoreL);
+    for (var i = 0; i < ignoreL.length; i++) {
+        this.ignoreS.add(ignoreL[i]);
+    }
+}
+
+
+pbc.initModuleAttrD = function(){
+}
+
+pbc.initKnownModuleS = function(){
+    var pythonModuleL = [
+        'math', 'random'
+    ];
+    var boardModuleL = [];
+
+    var moduleL = pythonModuleL.concat(boardModuleL);
+    for (var i = 0; i < moduleL.length; i++) {
+        this.knownModuleS.add(moduleL[i]);
+    }
+}
+
+pbc.initObjectTypeD = function () {
+    this.objectTypeD = {
+        'tina': 'turtle.Turtle',
+        'f': 'open'
+    }
+}
+
+pbc.reset = function(){
+    this.initObjectTypeD();
+}
+
+var py2block_config = new Py2blockConfig();
+

boards/default_src/python_mixpy/converters/serial.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var serialClass = 'serial.Serial';
+pbc.assignD.get('Serial')['check_assign'] = function (py2block, node, targets, value) {
+    if(value.func._astname != "Attribute" || value.func.value._astname != "Name"){
+        return false;
+    }
+    var moduleName = py2block.Name_str(value.func.value);
+    var funcName = py2block.identifier(value.func.attr);
+    if (value._astname === "Call" && moduleName === "serial"
+        && funcName === "Serial" && value.args.length === 2 && value.keywords.length === 1)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('Serial')['create_block'] = function (py2block, node, targets, value) {
+    var ser = py2block.Name_str(node.targets[0]);
+    if(value.keywords[0].arg.v == 'timeout')
+    {return block('serial_open', node.lineno, {
+            'SER': ser,
+            'BPS':value.args[1].n.v.toString()
+        }, {
+            "VAR":py2block.convert(value.keywords[0].value)
+        });}
+}
+
+pbc.objectFunctionD.get('close')[serialClass] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fileblock = py2block.convert(func.value);
+    return [block("serial_close", func.lineno, {}, {
+        "SER" : fileblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.objectFunctionD.get('write')[serialClass] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fileblock = py2block.convert(func.value);
+    return [block("serial_write", func.lineno, {}, {
+        "SER" : fileblock,
+        'VAR' : py2block.convert(args[0])
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.objectFunctionD.get('read')[serialClass] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fileblock = py2block.convert(func.value);
+    return block("serial_read_b", func.lineno, {}, {
+        "SER" : fileblock,
+        'VAR' : py2block.convert(args[0])
+    }, {
+        "inline": "true"
+    });
+}
+
+pbc.objectFunctionD.get('decode')['List'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    
+    return [block("lists_insert_value", func.lineno, {}, {
+        
+    }, {
+        "inline": "true"
+    })];
+};

boards/default_src/python_mixpy/converters/sklearn.js

@@ -0,0 +1,598 @@
+'use strict';
+
+//sklearn 生成分类样本
+pbc.globalFunctionD['make_classification'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length === 0 && keywords.length === 8) {
+        var key1block = py2block.convert(keywords[0].value);
+        var key2block = py2block.convert(keywords[1].value);
+        var key3block = py2block.convert(keywords[2].value);
+        var key4block = py2block.convert(keywords[3].value);
+        var key5block = py2block.convert(keywords[4].value);
+        var key6block = py2block.convert(keywords[5].value);
+        var key7block = py2block.convert(keywords[6].value);
+        var key8block = py2block.convert(keywords[7].value);
+        return block("sklearn_make_classification", func.lineno, {}, {
+            "n_samples": key1block,
+            "n_features": key2block,
+            "n_informative": key3block,
+            "n_redundant": key4block,
+            "n_repeated": key5block,
+            "n_classes": key6block,
+            "n_clusters_per_class": key7block,
+            "random_state": key8block
+        }, {
+            "inline": "false"
+        });
+    }
+    else
+    {
+        throw new Error("Incorrect number of arguments");
+    }
+    
+}
+
+//sklearn 生成回归样本
+pbc.globalFunctionD['make_regression'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length === 0 && keywords.length === 7) {
+        var key1block = py2block.convert(keywords[0].value);
+        var key2block = py2block.convert(keywords[1].value);
+        var key3block = py2block.convert(keywords[2].value);
+        var key4block = py2block.convert(keywords[3].value);
+        var key5block = py2block.convert(keywords[4].value);
+        var key6block = py2block.convert(keywords[5].value);
+        var key7block = py2block.convert(keywords[6].value);
+        return block("sklearn_make_regression", func.lineno, {}, {
+            "n_samples": key1block,
+            "n_features": key2block,
+            "n_informative": key3block,
+            "n_targets": key4block,
+            "bias": key5block,
+            "noise": key6block,
+            "random_state": key7block
+        }, {
+            "inline": "false"
+        });
+    }
+    else
+    {
+        throw new Error("Incorrect number of arguments");
+    }
+    
+}
+
+//sklearn 生成聚类样本
+pbc.globalFunctionD['make_blobs'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length === 0 && keywords.length === 7) {
+        var key1block = py2block.convert(keywords[0].value);
+        var key2block = py2block.convert(keywords[1].value);
+        var key3block = py2block.convert(keywords[2].value);
+        var key4block = py2block.convert(keywords[3].value);
+        var key5block = py2block.convert(keywords[4].value);
+        var key6block = py2block.convert(keywords[5].value);
+        var key7block = py2block.convert(keywords[6].value);
+        return block("sklearn_make_blobs", func.lineno, {}, {
+            "n_samples": key1block,
+            "n_features": key2block,
+            "centers": key3block,
+            "cluster_std": key4block,
+            "center_box": key5block,
+            "shuffle": key6block,
+            "random_state": key7block
+        }, {
+            "inline": "false"
+        });
+    }
+    else
+    {
+        throw new Error("Incorrect number of arguments");
+    }
+    
+}
+
+//sklearn 加载数据集
+function sklearn_load_check_assign(mode){
+    function converter(py2block, node, targets, value) {
+        if(value.func._astname != "Attribute" || value.func.value._astname != "Name"){
+            return false;
+        }
+        var moduleName = py2block.Name_str(value.func.value);
+        var funcName = py2block.identifier(value.func.attr);
+        value.args = value.args || [];
+        if (value._astname === "Call" && moduleName === "datasets"
+            && funcName === mode && !value.args.length)
+            return true;
+        return false;
+    }
+    return converter;
+}
+
+function sklearn_load_create_block(){
+    function converter(py2block, node, targets, value) {
+        var name = py2block.Name_str(node.targets[0]);
+        var type = py2block.identifier(value.func.attr);
+         //注意：赋值语句里，即使图形块上下可接，也不需要加[]
+        return block('sklearn_load', node.lineno, {
+                "name": name,
+                "type": type
+        }, {});
+    }
+    return converter;
+}
+
+pbc.assignD.get('load_iris')['check_assign'] = sklearn_load_check_assign('load_iris');
+pbc.assignD.get('load_boston')['check_assign'] = sklearn_load_check_assign('load_boston');
+pbc.assignD.get('load_diabetes')['check_assign'] = sklearn_load_check_assign('load_diabetes');
+pbc.assignD.get('load_breast_cancer')['check_assign'] = sklearn_load_check_assign('load_breast_cancer');
+pbc.assignD.get('load_linnerud')['check_assign'] = sklearn_load_check_assign('load_linnerud');
+pbc.assignD.get('load_digits')['check_assign'] = sklearn_load_check_assign('load_digits');
+
+pbc.assignD.get('load_iris')['create_block'] = sklearn_load_create_block();
+pbc.assignD.get('load_boston')['create_block'] = sklearn_load_create_block();
+pbc.assignD.get('load_diabetes')['create_block'] = sklearn_load_create_block();
+pbc.assignD.get('load_breast_cancer')['create_block'] = sklearn_load_create_block();
+pbc.assignD.get('load_linnerud')['create_block'] = sklearn_load_create_block();
+pbc.assignD.get('load_digits')['create_block'] = sklearn_load_create_block();
+
+//sklearn 获取特征值/标签值/标签/特征
+function sklearn_data_target(py2block, node, value, attr) {
+    return block('sklearn_data_target', node.lineno, {
+        "type": py2block.identifier(attr)
+    }, {
+        "name": py2block.convert(value)
+    });
+}
+pbc.objectAttrD.get('data')['sklearn.datasets'] = sklearn_data_target;
+pbc.objectAttrD.get('target')['sklearn.datasets'] = sklearn_data_target;
+pbc.objectAttrD.get('target_names')['sklearn.datasets'] = sklearn_data_target;
+pbc.objectAttrD.get('feature_names')['sklearn.datasets'] = sklearn_data_target;
+
+//sklearn 数据集分割
+pbc.globalFunctionD['train_test_split'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length === 2) {
+        var arg1block = py2block.convert(args[0]);
+        var arg2block = py2block.convert(args[1]);
+        var key1block = py2block.convert(keywords[0].value);
+        var key2block = py2block.convert(keywords[1].value);
+        return block("sklearn_train_test_split", func.lineno, {}, {
+            "train_data": arg1block,
+            "train_target": arg2block,
+            "test_size": key1block,
+            "rondom_state": key2block,
+        }, {
+            "inline": "false"
+        });
+    }
+    else if(args.length === 1)
+    {
+        var arg1block = py2block.convert(args[0]);
+        var key1block = py2block.convert(keywords[0].value);
+        var key2block = py2block.convert(keywords[1].value);
+        return block("sklearn_train_test_split_no_target", func.lineno, {}, {
+            "train_data": arg1block,
+            "test_size": key1block,
+            "rondom_state": key2block,
+        }, {
+            "inline": "false"
+        });
+    }
+    else
+    {
+        throw new Error("Incorrect number of arguments");
+    }
+    
+}
+
+//sklearn 初始化线性回归
+pbc.assignD.get('LinearRegression')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Name"){
+        return false;
+    }
+    var funcName = value.func.id.v;
+    value.args = value.args || [];
+    if(funcName === "LinearRegression" && !value.args.length)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('LinearRegression')['create_block'] = function(py2block, node, targets, value){
+    var name = py2block.convert(node.targets[0]);
+    var key1block = py2block.convert(value.keywords[0].value);
+    var key2block = py2block.convert(value.keywords[1].value);
+    var key3block = py2block.convert(value.keywords[2].value);
+    return block("sklearn_LinearRegression", node.lineno, {}, {
+        "model_name": name,
+        "fit_intercept": key1block,
+        "normalize": key2block,
+        "n_jobs": key3block
+    });
+}
+
+//sklearn 初始化岭回归
+pbc.assignD.get('Ridge')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Name"){
+        return false;
+    }
+    var funcName = value.func.id.v;
+    value.args = value.args || [];
+    if(funcName === "Ridge" && !value.args.length)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('Ridge')['create_block'] = function(py2block, node, targets, value){
+    var name = py2block.convert(node.targets[0]);
+    var key1block = py2block.convert(value.keywords[0].value);
+    var key2block = py2block.convert(value.keywords[1].value);
+    var key3block = py2block.convert(value.keywords[2].value);
+    var key4block = py2block.convert(value.keywords[3].value);
+    var key5block = py2block.convert(value.keywords[4].value);
+    return block("sklearn_Ridge", node.lineno, {}, {
+        "model_name": name,
+        "alpha": key1block,
+        "fit_intercept": key2block,
+        "normalize": key3block,
+        "max_iter": key4block,
+        "random_state": key5block
+    });
+}
+
+//sklearn 初始化决策树 分类算法
+pbc.assignD.get('DecisionTreeClassifier')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Name"){
+        return false;
+    }
+    var funcName = value.func.id.v;
+    value.args = value.args || [];
+    if(funcName === "DecisionTreeClassifier" && !value.args.length)
+        return true;
+    return false;
+}
+pbc.assignD.get('DecisionTreeClassifier')['create_block'] = function(py2block, node, targets, value){
+    var name = py2block.convert(node.targets[0]);
+    var key1block = py2block.convert(value.keywords[0].value);
+    var key2block = py2block.convert(value.keywords[1].value);
+    return block("sklearn_DecisionTreeClassifier_Regressor", node.lineno, {
+        "type": "DecisionTreeClassifier"
+    }, {
+        "model_name": name,
+        "max_depth": key1block,
+        "random_state": key2block
+    });
+}
+
+//sklearn 初始化决策树 回归算法
+pbc.assignD.get('DecisionTreeRegressor')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Name"){
+        return false;
+    }
+    var funcName = value.func.id.v;
+    value.args = value.args || [];
+    if(funcName === "DecisionTreeRegressor" && !value.args.length)
+        return true;
+    return false;
+}
+pbc.assignD.get('DecisionTreeRegressor')['create_block'] = function(py2block, node, targets, value){
+    var name = py2block.convert(node.targets[0]);
+    var key1block = py2block.convert(value.keywords[0].value);
+    var key2block = py2block.convert(value.keywords[1].value);
+    return block("sklearn_DecisionTreeClassifier_Regressor", node.lineno, {
+        "type": "DecisionTreeRegressor"
+    }, {
+        "model_name": name,
+        "max_depth": key1block,
+        "random_state": key2block
+    });
+}
+
+//sklearn 初始化随机森林 分类算法
+pbc.assignD.get('RandomForestClassifier')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Name"){
+        return false;
+    }
+    var funcName = value.func.id.v;
+    value.args = value.args || [];
+    if(funcName === "RandomForestClassifier" && !value.args.length)
+        return true;
+    return false;
+}
+pbc.assignD.get('RandomForestClassifier')['create_block'] = function(py2block, node, targets, value){
+    var name = py2block.convert(node.targets[0]);
+    var key1block = py2block.convert(value.keywords[0].value);
+    var key2block = py2block.convert(value.keywords[1].value);
+    var key3block = py2block.convert(value.keywords[2].value);
+    var key4block = py2block.convert(value.keywords[3].value);
+    return block("sklearn_RandomForestClassifier_Regressor", node.lineno, {
+        "type": "RandomForestClassifier"
+    }, {
+        "model_name": name,
+        "n_estimators": key1block,
+        "max_depth": key2block,
+        "n_jobs": key3block,
+        "random_state": key4block
+    });
+}
+
+//sklearn 初始化随机森林 回归算法
+pbc.assignD.get('RandomForestRegressor')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Name"){
+        return false;
+    }
+    var funcName = value.func.id.v;
+    value.args = value.args || [];
+    if(funcName === "RandomForestRegressor" && !value.args.length)
+        return true;
+    return false;
+}
+pbc.assignD.get('RandomForestRegressor')['create_block'] = function(py2block, node, targets, value){
+    var name = py2block.convert(node.targets[0]);
+    var key1block = py2block.convert(value.keywords[0].value);
+    var key2block = py2block.convert(value.keywords[1].value);
+    var key3block = py2block.convert(value.keywords[2].value);
+    var key4block = py2block.convert(value.keywords[3].value);
+    return block("sklearn_RandomForestClassifier_Regressor", node.lineno, {
+        "type": "RandomForestRegressor"
+    }, {
+        "model_name": name,
+        "n_estimators": key1block,
+        "max_depth": key2block,
+        "n_jobs": key3block,
+        "random_state": key4block
+    });
+}
+
+//sklearn 初始化K近邻 分类算法
+pbc.assignD.get('KNeighborsClassifier')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Name"){
+        return false;
+    }
+    var funcName = value.func.id.v;
+    value.args = value.args || [];
+    if(funcName === "KNeighborsClassifier" && !value.args.length)
+        return true;
+    return false;
+}
+pbc.assignD.get('KNeighborsClassifier')['create_block'] = function(py2block, node, targets, value){
+    var name = py2block.convert(node.targets[0]);
+    var key1block = py2block.convert(value.keywords[0].value);
+    var key2block = py2block.convert(value.keywords[1].value);
+    return block("sklearn_KNeighborsClassifier_Regressor", node.lineno, {
+        "type": "KNeighborsClassifier"
+    }, {
+        "model_name": name,
+        "K": key1block,
+        "n_jobs": key2block
+    });
+}
+
+//sklearn 初始化K近邻 回归算法
+pbc.assignD.get('KNeighborsRegressor')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Name"){
+        return false;
+    }
+    var funcName = value.func.id.v;
+    value.args = value.args || [];
+    if(funcName === "KNeighborsRegressor" && !value.args.length)
+        return true;
+    return false;
+}
+pbc.assignD.get('KNeighborsRegressor')['create_block'] = function(py2block, node, targets, value){
+    var name = py2block.convert(node.targets[0]);
+    var key1block = py2block.convert(value.keywords[0].value);
+    var key2block = py2block.convert(value.keywords[1].value);
+    return block("sklearn_KNeighborsClassifier_Regressor", node.lineno, {
+        "type": "KNeighborsRegressor"
+    }, {
+        "model_name": name,
+        "K": key1block,
+        "n_jobs": key2block
+    });
+}
+
+//sklearn 初始化高斯贝叶斯分类算法
+pbc.assignD.get('GaussianNB')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Name"){
+        return false;
+    }
+    var funcName = value.func.id.v;
+    value.args = value.args || [];
+    if(funcName === "GaussianNB" && !value.args.length)
+        return true;
+    return false;
+}
+pbc.assignD.get('GaussianNB')['create_block'] = function(py2block, node, targets, value){
+    var name = py2block.convert(node.targets[0]);
+    return block("sklearn_GaussianNB", node.lineno, {}, {
+        "model_name": name
+    });
+}
+
+//sklearn 初始K-均值聚类
+pbc.assignD.get('KMeans')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Name"){
+        return false;
+    }
+    var funcName = value.func.id.v;
+    value.args = value.args || [];
+    if(funcName === "KMeans" && !value.args.length)
+        return true;
+    return false;
+}
+
+pbc.assignD.get('KMeans')['create_block'] = function(py2block, node, targets, value){
+    var name = py2block.convert(node.targets[0]);
+    var key1block = py2block.convert(value.keywords[0].value);
+    var key2block = py2block.convert(value.keywords[1].value);
+    var key3block = py2block.convert(value.keywords[2].value);
+    var key4block = py2block.convert(value.keywords[3].value);
+    return block("sklearn_KMeans", node.lineno, {}, {
+        "model_name": name,
+        "n_clusters": key1block,
+        "max_iter": key2block,
+        "random_state": key3block,
+        "n_jobs": key4block
+    });
+}
+
+//sklearn 训练模型
+function sklearn_fit(){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if(args.length === 1) {
+            var objblock = py2block.convert(func.value);
+            var argblock1 = py2block.convert(args[0]);
+            return [block("sklearn_fit_no_target", func.lineno, {}, {
+                "model_name": objblock,
+                "train_data": argblock1
+            }, {
+                "inline": "true"
+            })];
+        }
+        else if(args.length === 2) {
+            var objblock = py2block.convert(func.value);
+            var argblock1 = py2block.convert(args[0]);
+            var argblock2 = py2block.convert(args[1]);
+            return [block("sklearn_fit", func.lineno, {
+            }, {
+                "model_name": objblock,
+                "train_data": argblock1,
+                "train_target": argblock2
+            }, {
+                "inline": "true"
+            })];
+        }
+        else
+        {
+            throw new Error("Incorrect number of arguments");
+        }
+    }
+    return converter;
+}
+pbc.objectFunctionD.get('fit')['sklearn.fit'] = sklearn_fit();
+
+//sklearn 模型预测
+function sklearn_predict(){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if(args.length === 1)
+        {
+            var objblock = py2block.convert(func.value);
+            var argblock1 = py2block.convert(args[0]);
+            return block("sklearn_predict", func.lineno, {
+            }, {
+                "model_name": objblock,
+                "train_data": argblock1
+            }, {
+                "inline": "true"
+            });
+        }
+        else
+        {
+            throw new Error("Incorrect number of arguments");
+        }
+    }
+    return converter;
+}
+pbc.objectFunctionD.get('predict')['sklearn'] = sklearn_predict();
+
+//sklearn 计算模型得分
+function sklearn_score(){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length === 2) {
+            var objblock = py2block.convert(func.value);
+            var argblock1 = py2block.convert(args[0]);
+            var argblock2 = py2block.convert(args[1]);
+            return block("sklearn_score", func.lineno, {}, {
+                "model_name": objblock,
+                "train_data": argblock1,
+                "train_target": argblock2
+            }, {
+                "inline": "true"
+            });
+        }
+        else if(args.length === 1)
+        {
+            var objblock = py2block.convert(func.value);
+            var argblock1 = py2block.convert(args[0]);
+            return block("sklearn_score_no_target", func.lineno, {}, {
+                "model_name": objblock,
+                "train_data": argblock1
+            }, {
+                "inline": "true"
+            });
+        }
+        else
+        {
+            throw new Error("Incorrect number of arguments");
+        } 
+    }
+    return converter;
+}
+pbc.objectFunctionD.get('score')['sklearn'] = sklearn_score();
+
+//sklearn 线性回归 模型获取 斜率/截距
+function sklearn_coef_intercept(py2block, node, value, attr) {
+    return block('sklearn_coef_intercept', node.lineno, {
+        "type": py2block.identifier(attr)
+    }, {
+        "model_name": py2block.convert(value)
+    });
+}
+pbc.objectAttrD.get('coef_')['sklearn.linear_model'] = sklearn_coef_intercept;
+pbc.objectAttrD.get('intercept_')['sklearn.linear_model'] = sklearn_coef_intercept;
+
+//sklearn K-均值聚类 模型获取 簇中心坐标/聚类后的标签/所有点到对应簇中心的距离平方和
+function sklearn_cluster_centers_labels_inertia(py2block, node, value, attr) {
+    return block('sklearn_cluster_centers_labels_inertia', node.lineno, {
+        "type": py2block.identifier(attr)
+    }, {
+        "model_name": py2block.convert(value)
+    });
+}
+pbc.objectAttrD.get('cluster_centers_')['sklearn.cluster'] = sklearn_cluster_centers_labels_inertia;
+pbc.objectAttrD.get('labels_')['sklearn.cluster'] = sklearn_cluster_centers_labels_inertia;
+pbc.objectAttrD.get('inertia_')['sklearn.cluster'] = sklearn_cluster_centers_labels_inertia;
+
+//sklearn 保存模型
+function sklearn_save_model(){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if(args.length === 2) {
+            var argblock1 = py2block.convert(args[0]);
+            var argblock2 = py2block.convert(args[1]);
+            var funcName = func.attr.v;
+            return [block("sklearn_save_load_model", func.lineno, {
+                "type" : funcName
+            }, {
+                "model_name": argblock1,
+                "address": argblock2
+            }, {
+                "inline": "true"
+            })];
+        }
+        else
+        {
+            throw new Error("Incorrect number of arguments");
+        }
+    }
+    return converter;
+}
+pbc.objectFunctionD.get('dump')['sklearn.externals'] = sklearn_save_model();
+
+//sklearn 加载模型
+pbc.assignD.get('load')['check_assign'] = function(py2block, node, targets, value) {
+    if(value._astname != "Call" ||  value.func._astname != "Attribute"){
+        return false;
+    }
+    var funcName = value.func.attr.v;
+    if(funcName === "load" && value.args.length === 1)
+        return true;
+    return false;
+}
+pbc.assignD.get('load')['create_block'] = function(py2block, node, targets, value){
+    var name = py2block.convert(node.targets[0]);
+    var key1block = py2block.convert(value.args[0]);
+    var funcName = value.func.attr.v;
+    return block("sklearn_save_load_model", node.lineno, {
+        "type" : funcName
+    }, {
+        "model_name" : name,
+        "address" : key1block
+    });
+}

boards/default_src/python_mixpy/converters/system.js

@@ -0,0 +1,45 @@
+'use strict';
+
+pbc.globalFunctionD['exit'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    return [block("controls_end_program", func.lineno, {}, {}, {
+            "inline": "true"
+        })];
+}
+
+
+
+pbc.moduleFunctionD.get('time')['time'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    return block("controls_millis", func.lineno, {}, {}, {
+            "inline": "true"
+        });
+}
+
+pbc.moduleFunctionD.get('time')['localtime'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    return block("time_localtime", func.lineno, {
+        "op":'all'
+    }, {}, {
+            "inline": "true"
+        });
+}
+
+pbc.moduleFunctionD.get('time')['sleep'] = function(py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    return [block("time_sleep", func.lineno, {}, {
+
+        "DELAY_TIME":argblock
+    }, {
+            "inline": "true"
+        })];
+}