@darabonba/python-generator 1.2.16 → 1.2.18

package/src/langs/python2/combinator.js

@@ -31,7 +31,9 @@ const {
   _toSnakeCase,
   _toCamelCase,
   _avoidKeywords,
-  _isKeywords,
+  _avoidFuncKeywords,
+  _avoidClassKeywords,
+  _avoidVarKeywords,
   _exception,
   _symbol,
   _deepClone,
@@ -43,6 +45,14 @@ function _name(name) {
   return _avoidKeywords(_toSnakeCase(name));
 }
 
+function _varName(name){
+  return _avoidVarKeywords(_toSnakeCase(name));
+}
+
+function _funcName(name){
+  return _avoidFuncKeywords(_toSnakeCase(name));
+}
+
 function _type(type) {
   const config = _config();
   let t = type instanceof Object ? type.lexeme : type;
@@ -387,10 +397,7 @@ class Combinator extends CombinatorBase {
     } else {
       className = name.split('.').map(item => _upperFirst(item)).join('');
     }
-    if (_isKeywords(className)) {
-      className = _avoidKeywords(className);
-    }
-    return _toCamelCase(className);
+    return _toCamelCase(_avoidClassKeywords(className));
   }
 
   emitClass(emitter, object) {
@@ -444,7 +451,7 @@ class Combinator extends CombinatorBase {
               } else if (p instanceof PropItem) {
                 const type = this.typeHint(p.type);
                 if (type) {
-                  emitter.emitln(`${_name(p.name)} = None  # type: ${type}`, this.level);
+                  emitter.emitln(`${_varName(p.name)} = None  # type: ${type}`, this.level);
                 }
               }
             });
@@ -472,9 +479,9 @@ class Combinator extends CombinatorBase {
           this.emitComplexValidate(emitter, `k${depth}`, fieldType.itemType, depth + 1);
           this.levelDown();
         } else {
-          emitter.emitln(`if self.${_name(name)}:`, this.level);
+          emitter.emitln(`if self.${_varName(name)}:`, this.level);
           this.levelUp();
-          emitter.emitln(`for k in self.${_name(name)}:`, this.level);
+          emitter.emitln(`for k in self.${_varName(name)}:`, this.level);
           this.levelUp();
           this.emitComplexValidate(emitter, 'k', fieldType.itemType, depth + 1);
           this.levelDown();
@@ -487,9 +494,9 @@ class Combinator extends CombinatorBase {
           this.emitComplexValidate(emitter, `v${depth}`, fieldType.valType, depth + 1);
           this.levelDown();
         } else {
-          emitter.emitln(`if self.${_name(name)}:`, this.level);
+          emitter.emitln(`if self.${_varName(name)}:`, this.level);
           this.levelUp();
-          emitter.emitln(`for v in self.${_name(name)}.values():`, this.level);
+          emitter.emitln(`for v in self.${_varName(name)}.values():`, this.level);
           this.levelUp();
           this.emitComplexValidate(emitter, 'v', fieldType.valType, depth + 1);
           this.levelDown();
@@ -521,29 +528,29 @@ class Combinator extends CombinatorBase {
 
       if (required.length > 0) {
         emitter.emitln(
-          `self.validate_required(self.${_name(prop.name)}, '${_name(prop.name)}')`,
+          `self.validate_required(self.${_varName(prop.name)}, '${_varName(prop.name)}')`,
           this.level
         );
         haveValidate = true;
       }
       if (maxLength.length > 0 || pattern.length > 0 || maximum.length > 0 || minimum.length > 0) {
-        emitter.emitln(`if self.${_name(prop.name)} is not None:`, this.level);
+        emitter.emitln(`if self.${_varName(prop.name)} is not None:`, this.level);
         this.levelUp();
 
         if (maxLength.length > 0) {
-          emitter.emitln(`self.validate_max_length(self.${_name(prop.name)}, '${_name(prop.name)}', ${maxLength[0].value})`, this.level);
+          emitter.emitln(`self.validate_max_length(self.${_varName(prop.name)}, '${_varName(prop.name)}', ${maxLength[0].value})`, this.level);
         }
 
         if (pattern.length > 0) {
-          emitter.emitln(`self.validate_pattern(self.${_name(prop.name)}, '${_name(prop.name)}', '${pattern[0].value}')`, this.level);
+          emitter.emitln(`self.validate_pattern(self.${_varName(prop.name)}, '${_varName(prop.name)}', '${pattern[0].value}')`, this.level);
         }
 
         if (maximum.length > 0) {
-          emitter.emitln(`self.validate_maximum(self.${_name(prop.name)}, '${_name(prop.name)}', ${maximum[0].value})`, this.level);
+          emitter.emitln(`self.validate_maximum(self.${_varName(prop.name)}, '${_varName(prop.name)}', ${maximum[0].value})`, this.level);
         }
 
         if (minimum.length > 0) {
-          emitter.emitln(`self.validate_minimum(self.${_name(prop.name)}, '${_name(prop.name)}', ${minimum[0].value})`, this.level);
+          emitter.emitln(`self.validate_minimum(self.${_varName(prop.name)}, '${_varName(prop.name)}', ${minimum[0].value})`, this.level);
         }
         this.levelDown();
         haveValidate = true;
@@ -558,9 +565,9 @@ class Combinator extends CombinatorBase {
           emitter.emit(emt.output);
         }
       } else if (prop.type.objectType === 'model') {
-        emitter.emitln(`if self.${_name(prop.name)}:`, this.level);
+        emitter.emitln(`if self.${_varName(prop.name)}:`, this.level);
         this.levelUp();
-        emitter.emitln(`self.${_name(prop.name)}.validate()`, this.level);
+        emitter.emitln(`self.${_varName(prop.name)}.validate()`, this.level);
         this.levelDown();
         haveValidate = true;
       }
@@ -600,9 +607,9 @@ class Combinator extends CombinatorBase {
         }
       } else {
         emitter.emitln(`result['${fieldName}'] = []`, this.level);
-        emitter.emitln(`if self.${_name(name)} is not None:`, this.level);
+        emitter.emitln(`if self.${_varName(name)} is not None:`, this.level);
         this.levelUp();
-        emitter.emitln(`for k in self.${_name(name)}:`, this.level);
+        emitter.emitln(`for k in self.${_varName(name)}:`, this.level);
         this.levelUp();
         if (type.itemType.valType || type.itemType.itemType) {
           const propInfo = {
@@ -611,7 +618,7 @@ class Combinator extends CombinatorBase {
             type: type.itemType,
             parentType: type.lexeme
           };
-          this.emitComplexToMap(emitter, propInfo, `result['${name}']`, depth + 1);
+          this.emitComplexToMap(emitter, propInfo, `result['${fieldName}']`, depth + 1);
         } else {
           if (type.itemType.objectType === 'model') {
             emitter.emitln(`result['${fieldName}'].append(k.to_map() if k else None)`, this.level);
@@ -644,9 +651,9 @@ class Combinator extends CombinatorBase {
         }
       } else {
         emitter.emitln(`result['${fieldName}'] = {}`, this.level);
-        emitter.emitln(`if self.${_name(name)} is not None:`, this.level);
+        emitter.emitln(`if self.${_varName(name)} is not None:`, this.level);
         this.levelUp();
-        emitter.emitln(`for k, v in self.${_name(name)}.items():`, this.level);
+        emitter.emitln(`for k, v in self.${_varName(name)}.items():`, this.level);
         this.levelUp();
         if (type.valType.valType || type.valType.itemType) {
           const propInfo = {
@@ -655,7 +662,7 @@ class Combinator extends CombinatorBase {
             type: type.valType,
             parentType: type.lexeme
           };
-          this.emitComplexToMap(emitter, propInfo, `result['${name}']`, depth + 1);
+          this.emitComplexToMap(emitter, propInfo, `result['${fieldName}']`, depth + 1);
         } else {
           if (type.valType.objectType === 'model') {
             emitter.emitln(`result['${fieldName}'][k] = v.to_map()`, this.level);
@@ -703,19 +710,19 @@ class Combinator extends CombinatorBase {
         if (emt.needSave === true) {
           emitter.emit(emt.output);
         } else {
-          emitter.emitln(`if self.${_name(prop.name)} is not None:`, this.level);
+          emitter.emitln(`if self.${_varName(prop.name)} is not None:`, this.level);
           this.levelUp();
-          emitter.emitln(`result['${name}'] = self.${_name(prop.name)}`, this.level);
+          emitter.emitln(`result['${name}'] = self.${_varName(prop.name)}`, this.level);
           this.levelDown();
         }
 
       } else {
-        emitter.emitln(`if self.${_name(prop.name)} is not None:`, this.level);
+        emitter.emitln(`if self.${_varName(prop.name)} is not None:`, this.level);
         this.levelUp();
         if (prop.type.objectType === 'model') {
-          emitter.emitln(`result['${name}'] = self.${_name(prop.name)}.to_map()`, this.level);
+          emitter.emitln(`result['${name}'] = self.${_varName(prop.name)}.to_map()`, this.level);
         } else {
-          emitter.emitln(`result['${name}'] = self.${_name(prop.name)}`, this.level);
+          emitter.emitln(`result['${name}'] = self.${_varName(prop.name)}`, this.level);
         }
         this.levelDown();
       }
@@ -753,7 +760,7 @@ class Combinator extends CombinatorBase {
           emitter.emitln(`${carrier}['k${num}'] = l${depth}`, this.level);
         }
       } else {
-        emitter.emitln(`self.${_name(name)} = []`, this.level);
+        emitter.emitln(`self.${_varName(name)} = []`, this.level);
         emitter.emitln(`if m.get('${fieldName}') is not None:`, this.level);
         this.levelUp();
         emitter.emitln(`for k in m.get('${fieldName}'):`, this.level);
@@ -765,11 +772,11 @@ class Combinator extends CombinatorBase {
             type: type.itemType,
             parentType: type.lexeme
           };
-          this.emitComplexFromMap(emitter, propInfo, `self.${_name(name)}`, depth + 1);
+          this.emitComplexFromMap(emitter, propInfo, `self.${_varName(name)}`, depth + 1);
         } else {
           if (type.itemType.objectType === 'model') {
             emitter.emitln(`temp_model = ${type.itemType.lexeme}()`, this.level);
-            emitter.emitln(`self.${_name(name)}.append(temp_model.from_map(k))`, this.level);
+            emitter.emitln(`self.${_varName(name)}.append(temp_model.from_map(k))`, this.level);
             emitter.needSave = true;
           } else {
             emitter.needSave = false;
@@ -799,7 +806,7 @@ class Combinator extends CombinatorBase {
           emitter.emitln(`${carrier}[k${num}] = d${depth}`, this.level);
         }
       } else {
-        emitter.emitln(`self.${_name(name)} = {}`, this.level);
+        emitter.emitln(`self.${_varName(name)} = {}`, this.level);
         emitter.emitln(`if m.get('${fieldName}') is not None:`, this.level);
         this.levelUp();
         emitter.emitln(`for k, v in m.get('${fieldName}').items():`, this.level);
@@ -811,11 +818,11 @@ class Combinator extends CombinatorBase {
             type: type.valType,
             parentType: type.lexeme
           };
-          this.emitComplexFromMap(emitter, propInfo, `self.${_name(name)}`, depth + 1);
+          this.emitComplexFromMap(emitter, propInfo, `self.${_varName(name)}`, depth + 1);
         } else {
           if (type.valType.objectType === 'model') {
             emitter.emitln(`temp_model = ${type.valType.lexeme}()`, this.level);
-            emitter.emitln(`self.${_name(name)}[k] = temp_model.from_map(v)`, this.level);
+            emitter.emitln(`self.${_varName(name)}[k] = temp_model.from_map(v)`, this.level);
             emitter.needSave = true;
           } else {
             emitter.needSave = false;
@@ -869,7 +876,7 @@ class Combinator extends CombinatorBase {
         } else {
           emitter.emitln(`if m.get('${name}') is not None:`, this.level);
           this.levelUp();
-          emitter.emitln(`self.${_name(prop.name)} = m.get('${name}')`, this.level);
+          emitter.emitln(`self.${_varName(prop.name)} = m.get('${name}')`, this.level);
           this.levelDown();
         }
       } else {
@@ -878,9 +885,9 @@ class Combinator extends CombinatorBase {
         if (prop.type.objectType === 'model') {
           let type = _type(prop.type);
           emitter.emitln(`temp_model = ${type}()`, this.level);
-          emitter.emitln(`self.${_name(prop.name)} = temp_model.from_map(m['${name}'])`, this.level);
+          emitter.emitln(`self.${_varName(prop.name)} = temp_model.from_map(m['${name}'])`, this.level);
         } else {
-          emitter.emitln(`self.${_name(prop.name)} = m.get('${name}')`, this.level);
+          emitter.emitln(`self.${_varName(prop.name)} = m.get('${name}')`, this.level);
         }
         this.levelDown();
       }
@@ -896,9 +903,9 @@ class Combinator extends CombinatorBase {
       let constructParams = [];
       construct.params.forEach(param => {
         if (param.value !== null && param.value !== 'null') {
-          constructParams.push(`${_name(param.key)}=${param.value}`);
+          constructParams.push(`${_varName(param.key)}=${param.value}`);
         } else {
-          constructParams.push(`${_name(param.key)}`);
+          constructParams.push(`${_varName(param.key)}`);
         }
       });
       emitter.emit('def __init__(self', this.level);
@@ -914,7 +921,7 @@ class Combinator extends CombinatorBase {
         let curr_length = 0;
         props.forEach((prop) => {
           if (prop instanceof PropItem) {
-            let str = ` ${_name(prop.name)}=None`;
+            let str = ` ${_varName(prop.name)}=None`;
             if(curr_length+str.length>=max_length){
               str =  emitter.eol + emitter.indent(this.level + 3) + str;
               curr_length = 0;
@@ -958,7 +965,7 @@ class Combinator extends CombinatorBase {
       }
 
       const fieldType = this.typeHint(prop.type);
-      emitter.emitln(`self.${_name(prop.name)} = ${_name(prop.name)}  # type: ${fieldType}`, this.level);
+      emitter.emitln(`self.${_varName(prop.name)} = ${_varName(prop.name)}  # type: ${fieldType}`, this.level);
     });
     if (construct.body.length > 0) {
       construct.body.forEach(gram => {
@@ -1014,17 +1021,17 @@ class Combinator extends CombinatorBase {
     }
     if (func.params.length > 0) {
       let selfVar = this.func_static ? '' : 'self, ';
-      emitter.emit(`def ${_name(func.name)}(${selfVar}`, this.level);
+      emitter.emit(`def ${_funcName(func.name)}(${selfVar}`, this.level);
       if (func.params.length > 0) {
         let params = [];
         func.params.forEach(p => {
-          params.push(`${_name(p.key)}`);
+          params.push(`${_varName(p.key)}`);
         });
         emitter.emit(params.join(', '));
       }
     } else {
       let selfVar = this.func_static ? '' : 'self';
-      emitter.emit(`def ${_name(func.name)}(${selfVar}`, this.level);
+      emitter.emit(`def ${_funcName(func.name)}(${selfVar}`, this.level);
     }
     emitter.emitln('):');
     this.levelUp();
@@ -1216,24 +1223,24 @@ class Combinator extends CombinatorBase {
             pre += `.${_name(path.name)}`;
           }
         } else if (path.type === 'object' || path.type === 'object_async') {
-          pre += `${_name(_convertStaticParam(pathName))}`;
+          pre += `${_varName(_convertStaticParam(pathName))}`;
         } else if (path.type === 'object_static' || path.type === 'object_static_async') {
           pre += `${_convertStaticParam(pathName)}`;
         } else if (path.type === 'call' || path.type === 'call_static') {
-          pre += `.${_name(pathName)}(${params})`;
+          pre += `.${_funcName(pathName)}(${params})`;
         } else if (path.type === 'call_async' || path.type === 'call_static_async') {
-          pre += `.${_name(pathName)}(${params})`;
+          pre += `.${_funcName(pathName)}(${params})`;
         } else if (path.type === 'prop') {
           pre += `.${_name(pathName)}`;
         } else if (path.type === 'prop_static') {
           pre += `.${_name(pathName)}`;
         } else if (path.type === 'map') {
-          pre += path.isVar ? `.get(${_name(pathName)})` : `.get('${pathName}')`;
+          pre += path.isVar ? `.get(${_varName(pathName)})` : `.get('${pathName}')`;
         } else if (path.type === 'map_set') {
           const quote = this._adaptedQuotes(pathName, emitter);
           pre += `[${quote}${pathName}${quote}]`;
         } else if (path.type === 'list') {
-          pre += path.isVar ? `[${_name(pathName)}]` : `[${pathName}]`;
+          pre += path.isVar ? `[${_varName(pathName)}]` : `[${pathName}]`;
         } else {
           debug.stack(gram);
         }
@@ -1276,7 +1283,7 @@ class Combinator extends CombinatorBase {
       emitter.emit(`${name}()`);
     } else if (gram.varType === 'var' || gram.varType === 'const') {
       const name = gram.name ? gram.name : gram.key;
-      emitter.emit(`${_convertStaticParam(_name(name))}`);
+      emitter.emit(`${_convertStaticParam(_varName(name))}`);
     } else {
       debug.stack(gram);
     }
@@ -1288,7 +1295,7 @@ class Combinator extends CombinatorBase {
         const quote = this._adaptedQuotes(gram.key, emitter);
         emitter.emit(`${quote}${gram.key}${quote}: `);
       } else {
-        emitter.emit(`${_name(gram.key)}=`, this.level);
+        emitter.emit(`${_varName(gram.key)}=`, this.level);
       }
     }
     if (gram instanceof GrammerCall) {
@@ -1404,7 +1411,7 @@ class Combinator extends CombinatorBase {
       const quote = this._adaptedQuotes(gram.value, emitter);
       emitter.emit(`${quote}${gram.value}${quote}`);
     } else if (gram.type === 'param') {
-      emitter.emit(`${_convertStaticParam(_name(gram.value))}`);
+      emitter.emit(`${_convertStaticParam(_varName(gram.value))}`);
     } else if (gram.type === 'call') {
       this.grammerCall(emitter, gram.value);
     } else if (gram.type === 'number') {
@@ -1618,7 +1625,7 @@ class Combinator extends CombinatorBase {
         gram.params.forEach(p => {
           let emit = new Emitter();
           if (p.key) {
-            emit.emit(`${_name(p.key)}`);
+            emit.emit(`${_varName(p.key)}`);
             emit.emit('=');
           }
           if (typeof (p.value) === 'string') {
@@ -1648,7 +1655,7 @@ class Combinator extends CombinatorBase {
     this.grammerCall(emit, behavior.call);
 
     if (behavior.isVar) {
-      emitter.emit(`${emit.output}[${_name(behavior.key)}] = `, this.level);
+      emitter.emit(`${emit.output}[${_varName(behavior.key)}] = `, this.level);
     } else {
       const quote = this._adaptedQuotes(behavior.key, emitter);
       emitter.emit(`${emit.output}[${quote}${behavior.key}${quote}] = `, this.level);

package/src/langs/python2/config.js

@@ -6,40 +6,49 @@ module.exports = {
   ...defaultConfig,
   indent: '    ',
   ext: '.py',
-  keywords: [
-    'and',
-    'as',
-    'assert',
-    'break',
-    'class',
-    'continue',
-    'def',
-    'del',
-    'elif',
-    'else',
-    'except',
-    'finally',
-    'for',
-    'from',
-    'False',
-    'global',
-    'if',
-    'import',
-    'in',
-    'is',
-    'lambda',
-    'not',
-    'None',
-    'or',
-    'pass',
-    'raise',
-    'return',
-    'try',
-    'True',
-    'while',
-    'with',
-    'yield'
-  ],
+  keywords: {
+    general: [
+      'and',
+      'as',
+      'assert',
+      'break',
+      'class',
+      'continue',
+      'def',
+      'del',
+      'elif',
+      'else',
+      'except',
+      'finally',
+      'for',
+      'from',
+      'False',
+      'global',
+      'if',
+      'import',
+      'in',
+      'is',
+      'lambda',
+      'not',
+      'None',
+      'or',
+      'pass',
+      'raise',
+      'return',
+      'try',
+      'True',
+      'while',
+      'with',
+      'yield'
+    ],
+    function: [],
+    class: [],
+    param_variables: [
+      'exec',
+      'print',
+      'self'
+    ]
+  },
   symbolMap: {
     'ASSIGN': '=',
     'EQ': '==',

package/src/lib/helper.js

@@ -53,7 +53,31 @@ function _deepClone(obj) {
 }
 
 function _avoidKeywords(str) {
-  if (config.keywords.indexOf(str.toLowerCase()) > -1) {
+  if (config.keywords.general.indexOf(str.toLowerCase()) > -1) {
+    return str + '_';
+  }
+  return str;
+}
+
+function _avoidFuncKeywords(str) {
+  if (config.keywords.general.indexOf(str.toLowerCase()) > -1
+    || config.keywords.function.indexOf(str.toLowerCase()) > -1) {
+    return str + '_';
+  }
+  return str;
+}
+
+function _avoidClassKeywords(str) {
+  if (config.keywords.general.indexOf(str.toLowerCase()) > -1
+    || config.keywords.class.indexOf(str.toLowerCase()) > -1) {
+    return str + '_';
+  }
+  return str;
+}
+
+function _avoidVarKeywords(str) {
+  if (config.keywords.general.indexOf(str.toLowerCase()) > -1
+    || config.keywords.param_variables.indexOf(str.toLowerCase()) > -1) {
     return str + '_';
   }
   return str;
@@ -69,7 +93,7 @@ function _convertStaticParam(param) {
 }
 
 function _isKeywords(str) {
-  return config.keywords.indexOf(str.toLowerCase()) > -1;
+  return config.keywords.general.indexOf(str.toLowerCase()) > -1;
 }
 
 function _modify(modify) {
@@ -159,6 +183,9 @@ module.exports = {
   _isBasicType,
   _deepClone,
   _avoidKeywords,
+  _avoidFuncKeywords,
+  _avoidClassKeywords,
+  _avoidVarKeywords,
   _convertStaticParam,
   _isKeywords,
   _modify,

package/tests/expected/python2/complex/tea_python_tests/models.py

@@ -118,9 +118,33 @@ class ComplexRequestComplexList(TeaModel):
         return self
 
 
+class ComplexRequestComplexList2(TeaModel):
+    def __init__(self, any=None):
+        self.any = any  # type: any
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super(ComplexRequestComplexList2, self).to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.any is not None:
+            result['Name'] = self.any
+        return result
+
+    def from_map(self, m=None):
+        m = m or dict()
+        if m.get('Name') is not None:
+            self.any = m.get('Name')
+        return self
+
+
 class ComplexRequest(TeaModel):
     def __init__(self, access_key=None, body=None, strs=None, header=None, num=None, configs=None, part=None,
-                 complex_list=None, complex_list_1=None, from_=None):
+                 complex_list=None, complex_list_1=None, complex_list_2=None, from_=None, self_=None, print_=None, exec_=None):
         self.access_key = access_key  # type: str
         # Body
         self.body = body  # type: READABLE
@@ -134,8 +158,15 @@ class ComplexRequest(TeaModel):
         self.part = part  # type: list[ComplexRequestPart]
         self.complex_list = complex_list  # type: list[list[list[ComplexRequestComplexList]]]
         self.complex_list_1 = complex_list_1  # type: list[list[dict[str, str]]]
+        self.complex_list_2 = complex_list_2  # type: list[list[list[ComplexRequestComplexList2]]]
         # test keywords
         self.from_ = from_  # type: str
+        # test keywords
+        self.self_ = self_  # type: str
+        # test keywords
+        self.print_ = print_  # type: str
+        # test keywords
+        self.exec_ = exec_  # type: str
 
     def validate(self):
         self.validate_required(self.access_key, 'access_key')
@@ -160,7 +191,17 @@ class ComplexRequest(TeaModel):
                         if k2:
                             k2.validate()
         self.validate_required(self.complex_list_1, 'complex_list_1')
+        self.validate_required(self.complex_list_2, 'complex_list_2')
+        if self.complex_list_2:
+            for k in self.complex_list_2:
+                for k1 in k:
+                    for k2 in k1:
+                        if k2:
+                            k2.validate()
         self.validate_required(self.from_, 'from_')
+        self.validate_required(self.self_, 'self_')
+        self.validate_required(self.print_, 'print_')
+        self.validate_required(self.exec_, 'exec_')
 
     def to_map(self):
         _map = super(ComplexRequest, self).to_map()
@@ -196,8 +237,24 @@ class ComplexRequest(TeaModel):
                 result['complexList'].append(l1)
         if self.complex_list_1 is not None:
             result['complexList1'] = self.complex_list_1
+        result['ComplexList2'] = []
+        if self.complex_list_2 is not None:
+            for k in self.complex_list_2:
+                l1 = []
+                for k1 in k:
+                    l2 = []
+                    for k2 in k1:
+                        l2.append(k2.to_map() if k2 else None)
+                    l1.append(l2)
+                result['ComplexList2'].append(l1)
         if self.from_ is not None:
             result['from'] = self.from_
+        if self.self_ is not None:
+            result['self'] = self.self_
+        if self.print_ is not None:
+            result['print'] = self.print_
+        if self.exec_ is not None:
+            result['exec'] = self.exec_
         return result
 
     def from_map(self, m=None):
@@ -234,8 +291,25 @@ class ComplexRequest(TeaModel):
                 self.complex_list.append(l1)
         if m.get('complexList1') is not None:
             self.complex_list_1 = m.get('complexList1')
+        self.complex_list_2 = []
+        if m.get('ComplexList2') is not None:
+            for k in m.get('ComplexList2'):
+                l1 = []
+                for k1 in k:
+                    l2 = []
+                    for k2 in k1:
+                        temp_model = ComplexRequestComplexList2()
+                        l2.append(temp_model.from_map(k2))
+                    l1.append(l2)
+                self.complex_list_2.append(l1)
         if m.get('from') is not None:
             self.from_ = m.get('from')
+        if m.get('self') is not None:
+            self.self_ = m.get('self')
+        if m.get('print') is not None:
+            self.print_ = m.get('print')
+        if m.get('exec') is not None:
+            self.exec_ = m.get('exec')
         return self
 
 

package/tests/expected/python2/import/setup.py

@@ -25,7 +25,7 @@ from setuptools import setup, find_packages
 """
 setup module for tea_python_tests.
 
-Created on 13/09/2023
+Created on *
 
 @author: Alibaba
 """