@darabonba/python-generator 2.0.0 → 2.0.2

package/lib/generator.js

@@ -59,7 +59,6 @@ class Visitor {
     // 新增：用于存储已使用的类型
     this.isAsyncFunction = false; // 新增：用于标记是否为异步函数
     this.isStaticFunction = true; // 新增：用于标记是否为非静态函数
-    this.clientName = new Map(); // 新增：用于存储importName
     // this.moduleDir = this.config.modelDirName || 'Models'; // 新增，用于存储models文件
 
     this.output = '';
@@ -274,6 +273,8 @@ setup(
     this.notes = ast.notes;
     this.builtin = getBuiltin(this);
     ast.innerModule = new Map();
+
+    this.clientName = new Map();
     this.packageInfo = {};
     this.usedTypes = [];
     this.imports = [];
@@ -566,7 +567,9 @@ setup(
       this.emit('def __init__(self):\n', level + 2);
     }
     if (ast.initBody && ast.initBody.stmts.length !==0 ) {
+      this.isStaticFunction = false;
       this.visitStmts(ast.initBody, level + 4);
+      this.isStaticFunction = true;
     } else {
       this.emit('pass\n', level + 4);
     }
@@ -628,14 +631,15 @@ setup(
           throw new Error(`The '${aliasId}' has no Python supported.`);
         }
         let className = _camelCase(pyPkg.clientName || 'client');
+        let filename = _snakeCase(className);
         let classNamespace = pyPkg.package;
         let models = 'models';
         let exceptions = 'exceptions';
         if(inner && pkg.exports[inner]) {
           let pyPath = pkg.exports[inner];
-          const [ filename ] = pyPath.split(path.sep).slice(-1);
-          models = filename.replace(/(\.tea)$|(\.spec)$|(\.dara)$/gi, '') + '_models';
-          exceptions = filename.replace(/(\.tea)$|(\.spec)$|(\.dara)$/gi, '') + '_exceptions';
+          filename = pyPath.split(path.sep).slice(-1)[0].replace(/(\.tea)$|(\.spec)$|(\.dara)$/gi, '');
+          models = filename + '_models';
+          exceptions = filename + '_exceptions';
           const arr = pyPath.split(path.sep).slice(1, -1);
           arr.map(key => {
             classNamespace += '.' + _snakeCase(key);
@@ -646,7 +650,7 @@ setup(
         const aliasName = this.getAliasName(className, aliasId);
         this.packageInfo[aliasId] = {
           aliasName: aliasName || className,
-          fileName: _snakeCase(className),
+          fileName: filename,
           clientName: className,
           namemespace: classNamespace,
           models: models,
@@ -1124,29 +1128,27 @@ setup(
     }
   }
 
-  visitToMapField(fieldValue, key, value, level) {
+  visitToMapField(fieldValue, fieldName, key, value, level, arr = false) {
     const deep = Math.floor(level / 4);
     if (fieldValue.type === 'modelBody' || fieldValue.type === 'moduleModel' || 
     fieldValue.type === 'subModel' || fieldValue.idType === 'model' || 
     (fieldValue.fieldType && (fieldValue.fieldType.type === 'moduleModel' || 
     fieldValue.fieldType.idType === 'model' || fieldValue.fieldType.idType === 'builtin_model'))) {
-      this.emit(`${key} = ${value}.to_map()`, level);
+      let realVal = `${value}.to_map()`;
       if(deep > 1) {
-        this.emit(` if ${value} else None\n`);
+        realVal += ` if ${value} else None`;
       }
-      this.emit('\n');
+      this.emitFieldConvert(key, realVal, level, arr);
     } else if (fieldValue.type === 'array' || fieldValue.fieldType === 'array') {
-      this.emit(`l${deep} = 0\n`, level);
       this.emit(`${key} = []\n`, level);
       this.emit(`for k${deep} in ${value}:\n`, level);
-      this.emit(`l${deep} += 1\n`, level + 2);
-      this.visitToMapField(fieldValue.fieldItemType || fieldValue.subType, `${key}[l${deep}]`, `k${deep}`, level + 2);
+      this.visitToMapField(fieldValue.fieldItemType || fieldValue.subType, fieldName, `${key}`, `k${deep}`, level + 2, true);
     } else if (fieldValue.fieldType === 'map' || fieldValue.type === 'map') {
       this.emit(`${key} = {}\n`, level);
-      this.emit(`for k${deep}, v${deep} in k.items():\n`, level);
-      this.visitToMapField(fieldValue.valueType, `${key}[k${deep}]`, `v${deep}`, level + 2);
+      this.emit(`for k${deep}, v${deep} in self.${fieldName}.items():\n`, level);
+      this.visitToMapField(fieldValue.valueType, fieldName, `${key}[k${deep}]`, `v${deep}`, level + 2);
     } else {
-      this.emit(`${key} = ${value}\n`, level);
+      this.emitFieldConvert(key, value, level, arr);
     }
     
   }
@@ -1168,7 +1170,7 @@ setup(
       if(!this.checkFieldHasModel(node.fieldValue)) {
         this.emit(`result['${realName}'] = self.${param}`, level + 4);
       } else {
-        this.visitToMapField(node.fieldValue, `result['${realName}']`, `self.${param}`, level + 4);
+        this.visitToMapField(node.fieldValue, param, `result['${realName}']`, `self.${param}`, level + 4);
       }
       this.emit('\n');
     }
@@ -1176,18 +1178,25 @@ setup(
     this.emit('\n');
   }
 
-  visitFromField(fieldValue, fieldName, key, value, level) {
+  emitFieldConvert(key, value, level, arr) {
+    if(arr) {
+      this.emit(`${key}.append(${value})\n`, level);
+      return;
+    }
+    this.emit(`${key} = ${value}\n`, level);
+  }
+
+  visitFromField(fieldValue, fieldName, key, value, level, arr = false) {
     const deep = Math.floor(level / 4);
     if (fieldValue.type === 'modelBody') {
-      const subModelName = _subModelName(fieldName);
-      this.emit(`temp_model = ${subModelName}\n`, level);
-      this.emit(`${key} = temp_model.from_map(${value})\n`, level);
+      const subModelName = _subModelName(_camelCase(fieldName));
+      this.emit(`temp_model = ${subModelName}()\n`, level);
+      this.emitFieldConvert(key, `temp_model.from_map(${value})`, level, arr);
     } else if (fieldValue.type === 'array' || fieldValue.fieldType === 'array') {
       this.emit(`l${deep} = 0\n`, level);
       this.emit(`${key} = []\n`, level);
       this.emit(`for k${deep} in ${value}:\n`, level);
-      this.emit(`l${deep} += 1\n`, level + 2);
-      this.visitFromField(fieldValue.fieldItemType || fieldValue.subType, fieldName, `${key}[l${deep}]`, `k${deep}`, level + 2);
+      this.visitFromField(fieldValue.fieldItemType || fieldValue.subType, fieldName, `${key}`, `k${deep}`, level + 2, true);
     } else if (fieldValue.fieldType === 'map' || fieldValue.type === 'map') {
       this.emit(`${key} = {}\n`, level);
       this.emit(`for k${deep}, v${deep} in ${value}.items():\n`, level);
@@ -1198,25 +1207,30 @@ setup(
       const modelName = _subModelName(rest.map((item) => {
         return item.lexeme;
       }).join('.'));
-      this.emit(`${key} = ${this.getModelName(modelName, _name(moduleId), 'module')}.from_map(${value})\n`, level);
+      this.emit(`temp_model = ${this.getModelName(modelName, _name(moduleId), 'module')}()\n`, level);
+      this.emitFieldConvert(key, `temp_model.from_map(${value})`, level, arr);
     } else if (fieldValue.type === 'subModel') {
       const [moduleId, ...rest] = fieldValue.path;
       const subModelName = _subModelName([moduleId.lexeme, ...rest.map((item) => {
         return item.lexeme;
       })].join('.'));
-      this.emit(`${key} = ${subModelName}.from_map(${value})\n`, level);
+      this.emit(`temp_model = ${subModelName}()\n`, level);
+      this.emitFieldConvert(key, `temp_model.from_map(${value})`, level, arr);
     } else if (fieldValue.idType === 'model') {
       const modelName = _type(_name(fieldValue));
-      this.emit(`${key} = ${modelName}.from_map(${value})\n`, level);
+      this.emit(`temp_model = ${modelName}()\n`, level);
+      this.emitFieldConvert(key, `temp_model.from_map(${value})`, level, arr);
     } else if (fieldValue.fieldType && fieldValue.fieldType.idType === 'model') {
       const modelName = _type(_name(fieldValue.fieldType));
-      this.emit(`${key} = ${modelName}.from_map(${value})\n`, level);
+      this.emit(`temp_model = ${modelName}()\n`, level);
+      this.emitFieldConvert(key, `temp_model.from_map(${value})`, level, arr);
     } else if (fieldValue.fieldType && fieldValue.fieldType.idType === 'builtin_model') {
       const typeName = _type(_name(fieldValue.fieldType));
       this.pushImports(typeName);
-      this.emit(`${key} = ${typeName}.from_map(${value})\n`, level);
+      this.emit(`temp_model = ${typeName}()\n`, level);
+      this.emitFieldConvert(key, `temp_model.from_map(${value})`, level, arr);
     } else {
-      this.emit(`${key} = ${value}\n`, level);
+      this.emitFieldConvert(key, value, level, arr);
     }
   }
 
@@ -1954,7 +1968,7 @@ setup(
         current = ast.propertyPathTypes[i];
       }
     }
-    this.emit(`${expr}[`, level);
+    this.emit(`${expr}[`);
     this.visitExpr(ast.accessKey, level);
     this.emit(']');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darabonba/python-generator",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "The darabonba generator for Python",
   "main": "lib/generator.js",
   "directories": {

package/tests/expected/complex/tea_python_tests/client.py

@@ -29,8 +29,9 @@ class Client(SourceClient):
         source_config: source_models.Config,
     ):
         super().__init__(source_config)
-                self._configs[0] = source_config
+        self._configs[0] = source_config
         test = SourceClient(source_config)
+        self.print_data(DaraCore.to_map(source_config), 'test')
 
     def complex_1(
         self,
@@ -978,7 +979,7 @@ class Client(SourceClient):
             'b',
             'c'
         ]
-                configs[3] = config
+        configs[3] = config
         return configs
 
     @staticmethod
@@ -992,7 +993,7 @@ class Client(SourceClient):
                 'c'
             ]
         }
-                data["configs"][3] = config
+        data["configs"][3] = config
         return data.get("configs")
 
     @staticmethod
@@ -1000,7 +1001,7 @@ class Client(SourceClient):
         request: main_models.ComplexRequest,
         config: str,
     ) -> None:
-                request.configs.value[0] = config
+        request.configs.value[0] = config
 
     @staticmethod
     def map_access(

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

@@ -401,10 +401,9 @@ class ComplexRequest(DaraModel):
             result['numMap'] = self.num_map
         if self.model_map is not None:
             result['modelMap'] = {}
-            for k1, v1 in k.items():
+            for k1, v1 in self.model_map.items():
                 result['modelMap'][k1] = v1.to_map() if v1 else None
 
-
         if self.request is not None:
             result['request'] = self.request.to_map()
 
@@ -424,12 +423,9 @@ class ComplexRequest(DaraModel):
         if self.str is not None:
             result['srt'] = self.str
         if self.part is not None:
-            l1 = 0
             result['Part'] = []
             for k1 in self.part:
-                l1 += 1
-                result['Part'][l1] = k1.to_map() if k1 else None
-
+                result['Part'].append(k1.to_map() if k1 else None)
 
         return result
 
@@ -444,11 +440,11 @@ class ComplexRequest(DaraModel):
         if m.get('mapList') is not None:
             self.map_list = m.get('mapList')
         if m.get('header') is not None:
-            temp_model = ComplexRequestHeader
+            temp_model = ComplexRequestHeader()
             self.header = temp_model.from_map(m.get('header'))
 
         if m.get('configs') is not None:
-            temp_model = ComplexRequestConfigs
+            temp_model = ComplexRequestConfigs()
             self.configs = temp_model.from_map(m.get('configs'))
 
         if m.get('num') is not None:
@@ -500,10 +496,12 @@ class ComplexRequest(DaraModel):
         if m.get('byt') is not None:
             self.byt = m.get('byt')
         if m.get('req') is not None:
-            self.req = DaraRequest.from_map(m.get('req'))
+            temp_model = DaraRequest()
+            self.req = temp_model.from_map(m.get('req'))
 
         if m.get('resp') is not None:
-            self.resp = DaraResponse.from_map(m.get('resp'))
+            temp_model = DaraResponse()
+            self.resp = temp_model.from_map(m.get('resp'))
 
         if m.get('map') is not None:
             self.map = m.get('map')
@@ -512,15 +510,18 @@ class ComplexRequest(DaraModel):
         if m.get('modelMap') is not None:
             self.model_map = {}
             for k1, v1 in m.get('modelMap').items():
-                self.model_map[k1] = SourceClient.from_map(v1)
+                temp_model = SourceClient()
+                self.model_map[k1] = temp_model.from_map(v1)
 
         if m.get('request') is not None:
-            self.request = SourceClient.from_map(m.get('request'))
+            temp_model = SourceClient()
+            self.request = temp_model.from_map(m.get('request'))
 
         if m.get('client') is not None:
             self.client = m.get('client')
         if m.get('instance') is not None:
-            self.instance = SourceClient.from_map(m.get('instance'))
+            temp_model = SourceClient()
+            self.instance = temp_model.from_map(m.get('instance'))
 
         if m.get('from') is not None:
             self.from_ = m.get('from')
@@ -536,9 +537,8 @@ class ComplexRequest(DaraModel):
             l1 = 0
             self.part = []
             for k1 in m.get('Part'):
-                l1 += 1
-                temp_model = ComplexRequestPart
-                self.part[l1] = temp_model.from_map(k1)
+                temp_model = ComplexRequestPart()
+                self.part.append(temp_model.from_map(k1))
 
         return self
 

package/tests/expected/model/tea_python_tests/models.py

@@ -88,7 +88,7 @@ class MainFileModel(DaraModel):
         if m.get('str') is not None:
             self.str = m.get('str')
         if m.get('model') is not None:
-            temp_model = MainFileModelModel
+            temp_model = MainFileModelModel()
             self.model = temp_model.from_map(m.get('model'))
 
         return self
@@ -152,7 +152,7 @@ class MyModelModel(DaraModel):
         if m.get('str') is not None:
             self.str = m.get('str')
         if m.get('model') is not None:
-            temp_model = MyModelModelModel
+            temp_model = MyModelModelModel()
             self.model = temp_model.from_map(m.get('model'))
 
         return self
@@ -216,7 +216,7 @@ class MyModelSubmodel(DaraModel):
         if m.get('stringfield') is not None:
             self.stringfield = m.get('stringfield')
         if m.get('model') is not None:
-            temp_model = MyModelSubmodelModel
+            temp_model = MyModelSubmodelModel()
             self.model = temp_model.from_map(m.get('model'))
 
         return self
@@ -265,7 +265,7 @@ class M(DaraModel):
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('subM') is not None:
-            temp_model = MSub_m
+            temp_model = MSubM()
             self.sub_m = temp_model.from_map(m.get('subM'))
 
         return self
@@ -520,57 +520,39 @@ class MyModel(DaraModel):
 
         if self.submodel_map is not None:
             result['submodelMap'] = {}
-            for k1, v1 in k.items():
+            for k1, v1 in self.submodel_map.items():
                 result['submodelMap'][k1] = v1.to_map() if v1 else None
 
-
         if self.map_model is not None:
             result['mapModel'] = {}
-            for k1, v1 in k.items():
+            for k1, v1 in self.map_model.items():
                 result['mapModel'][k1] = v1.to_map() if v1 else None
 
-
         if self.subarraymodel is not None:
-            l1 = 0
             result['subarraymodel'] = []
             for k1 in self.subarraymodel:
-                l1 += 1
-                result['subarraymodel'][l1] = k1.to_map() if k1 else None
-
+                result['subarraymodel'].append(k1.to_map() if k1 else None)
 
         if self.subarray is not None:
-            l1 = 0
             result['subarray'] = []
             for k1 in self.subarray:
-                l1 += 1
-                result['subarray'][l1] = k1.to_map() if k1 else None
-
+                result['subarray'].append(k1.to_map() if k1 else None)
 
         if self.ssubarray is not None:
-            l1 = 0
             result['ssubarray'] = []
             for k1 in self.ssubarray:
-                l1 += 1
-                l2 = 0
-                result['ssubarray'][l1] = []
+                result['ssubarray'] = []
                 for k2 in k1:
-                    l2 += 1
-                    result['ssubarray'][l1][l2] = k2.to_map() if k2 else None
-
+                    result['ssubarray'].append(k2.to_map() if k2 else None)
 
         if self.ssubmarray is not None:
             result['ssubmarray'] = self.ssubmarray
         if self.ssubmmarray is not None:
-            l1 = 0
             result['ssubmmarray'] = []
             for k1 in self.ssubmmarray:
-                l1 += 1
-                l2 = 0
-                result['ssubmmarray'][l1] = []
+                result['ssubmmarray'] = []
                 for k2 in k1:
-                    l2 += 1
-                    result['ssubmmarray'][l1][l2] = k2.to_map() if k2 else None
-
+                    result['ssubmmarray'].append(k2.to_map() if k2 else None)
 
         if self.maparray is not None:
             result['maparray'] = self.maparray
@@ -578,22 +560,19 @@ class MyModel(DaraModel):
             result['mapsubmarray'] = self.mapsubmarray
         if self.module_model_map is not None:
             result['moduleModelMap'] = {}
-            for k1, v1 in k.items():
+            for k1, v1 in self.module_model_map.items():
                 result['moduleModelMap'][k1] = v1.to_map() if v1 else None
 
-
         if self.sub_model_map is not None:
             result['subModelMap'] = {}
-            for k1, v1 in k.items():
+            for k1, v1 in self.sub_model_map.items():
                 result['subModelMap'][k1] = v1.to_map() if v1 else None
 
-
         if self.model_map is not None:
             result['modelMap'] = {}
-            for k1, v1 in k.items():
+            for k1, v1 in self.model_map.items():
                 result['modelMap'][k1] = v1.to_map() if v1 else None
 
-
         if self.module_map is not None:
             result['moduleMap'] = self.module_map
         if self.object is not None:
@@ -645,7 +624,7 @@ class MyModel(DaraModel):
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('model') is not None:
-            temp_model = MyModelModel
+            temp_model = MyModelModel()
             self.model = temp_model.from_map(m.get('model'))
 
         if m.get('stringfield') is not None:
@@ -659,44 +638,44 @@ class MyModel(DaraModel):
         if m.get('realName') is not None:
             self.name = m.get('realName')
         if m.get('submodel') is not None:
-            temp_model = MyModelSubmodel
+            temp_model = MyModelSubmodel()
             self.submodel = temp_model.from_map(m.get('submodel'))
 
         if m.get('submodelMap') is not None:
             self.submodel_map = {}
             for k1, v1 in m.get('submodelMap').items():
-                self.submodel_map[k1] = MyModelSubmodel.from_map(v1)
+                temp_model = MyModelSubmodel()
+                self.submodel_map[k1] = temp_model.from_map(v1)
 
         if m.get('mapModel') is not None:
             self.map_model = {}
             for k1, v1 in m.get('mapModel').items():
-                self.map_model[k1] = M.from_map(v1)
+                temp_model = M()
+                self.map_model[k1] = temp_model.from_map(v1)
 
         if m.get('subarraymodel') is not None:
             l1 = 0
             self.subarraymodel = []
             for k1 in m.get('subarraymodel'):
-                l1 += 1
-                temp_model = MyModelSubarraymodel
-                self.subarraymodel[l1] = temp_model.from_map(k1)
+                temp_model = MyModelSubarraymodel()
+                self.subarraymodel.append(temp_model.from_map(k1))
 
         if m.get('subarray') is not None:
             l1 = 0
             self.subarray = []
             for k1 in m.get('subarray'):
-                l1 += 1
-                self.subarray[l1] = M.from_map(k1)
+                temp_model = M()
+                self.subarray.append(temp_model.from_map(k1))
 
         if m.get('ssubarray') is not None:
             l1 = 0
             self.ssubarray = []
             for k1 in m.get('ssubarray'):
-                l1 += 1
                 l2 = 0
-                self.ssubarray[l1] = []
+                self.ssubarray = []
                 for k2 in k1:
-                    l2 += 1
-                    self.ssubarray[l1][l2] = M.from_map(k2)
+                    temp_model = M()
+                    self.ssubarray.append(temp_model.from_map(k2))
 
         if m.get('ssubmarray') is not None:
             self.ssubmarray = m.get('ssubmarray')
@@ -704,12 +683,11 @@ class MyModel(DaraModel):
             l1 = 0
             self.ssubmmarray = []
             for k1 in m.get('ssubmmarray'):
-                l1 += 1
                 l2 = 0
-                self.ssubmmarray[l1] = []
+                self.ssubmmarray = []
                 for k2 in k1:
-                    l2 += 1
-                    self.ssubmmarray[l1][l2] = SourceClient.from_map(k2)
+                    temp_model = SourceClient()
+                    self.ssubmmarray.append(temp_model.from_map(k2))
 
         if m.get('maparray') is not None:
             self.maparray = m.get('maparray')
@@ -718,17 +696,20 @@ class MyModel(DaraModel):
         if m.get('moduleModelMap') is not None:
             self.module_model_map = {}
             for k1, v1 in m.get('moduleModelMap').items():
-                self.module_model_map[k1] = SourceClient.from_map(v1)
+                temp_model = SourceClient()
+                self.module_model_map[k1] = temp_model.from_map(v1)
 
         if m.get('subModelMap') is not None:
             self.sub_model_map = {}
             for k1, v1 in m.get('subModelMap').items():
-                self.sub_model_map[k1] = MSubM.from_map(v1)
+                temp_model = MSubM()
+                self.sub_model_map[k1] = temp_model.from_map(v1)
 
         if m.get('modelMap') is not None:
             self.model_map = {}
             for k1, v1 in m.get('modelMap').items():
-                self.model_map[k1] = M.from_map(v1)
+                temp_model = M()
+                self.model_map[k1] = temp_model.from_map(v1)
 
         if m.get('moduleMap') is not None:
             self.module_map = m.get('moduleMap')
@@ -739,10 +720,12 @@ class MyModel(DaraModel):
         if m.get('writable') is not None:
             self.writable = m.get('writable')
         if m.get('existModel') is not None:
-            self.exist_model = M.from_map(m.get('existModel'))
+            temp_model = M()
+            self.exist_model = temp_model.from_map(m.get('existModel'))
 
         if m.get('request') is not None:
-            self.request = DaraRequest.from_map(m.get('request'))
+            temp_model = DaraRequest()
+            self.request = temp_model.from_map(m.get('request'))
 
         if m.get('complexList') is not None:
             self.complex_list = m.get('complexList')

package/tests/expected/multi/tea_python_tests/model/user.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 # This file is auto-generated, don't edit it. Thanks.
 from __future__ import annotations
+from alibabacloud_tea_util.util import Utils 
 from tea_python_tests.lib.util import Util 
 from typing import Generator, AsyncGenerator
 
@@ -12,12 +13,14 @@ class Client:
 
     @staticmethod
     def test() -> Generator[str, None, None]:
+        Utils.test()
         it = Util.test_1()
         for test in it:
             yield  test
 
     @staticmethod
     async def test_async() -> AsyncGenerator[str, None, None]:
+        Utils.test()
         it = Util.test_1()
         for test in it:
             yield  test

package/tests/fixtures/complex/main.dara

@@ -13,6 +13,7 @@ init(sourceConfig: Source.Config){
   super(sourceConfig);
   @configs[0] = sourceConfig;
   var test : Source = new Source(sourceConfig);
+  printData(sourceConfig, 'test');
 }
 
 exception Err1 = {

package/tests/fixtures/multi/libraries/darabonba_Util_0.2.11/Teafile

@@ -3,6 +3,9 @@
 	"name": "Util",
 	"version": "0.2.11",
 	"main": "./main.tea",
+	"exports": {
+		"Util": "./util.tea"
+	},
 	"releases": {
 		"go": "github.com/alibabacloud-go/tea-utils/v2/service:v2.0.4",
 		"ts": "@alicloud/tea-util:^1.4.7",
@@ -29,7 +32,10 @@
 	},
 	"python": {
 		"package": "alibabacloud_tea_util",
-		"clientName": "client"
+		"clientName": "client",
+		"exports": {
+		  "Util": "Utils"
+		}
 	},
 	"python2": {
 		"package": "alibabacloud_tea_util",

package/tests/fixtures/multi/libraries/darabonba_Util_0.2.11/util.tea

@@ -0,0 +1,2 @@
+@clientName("Utils")
+static function test(): void;

package/tests/fixtures/multi/model/user.dara

@@ -1,4 +1,5 @@
 import DARAUtil;
+import DARAUtil.Util as Utils;
 import "../lib/util" Util;
 
 
@@ -13,6 +14,7 @@ model Info extends BaseInfo {
 
 
 static async function test(): asyncIterator[string]{
+ Utils.test();
  var it:iterator[string] = Util.test1();
  for(var test : it) {
     yield test;

package/tests/output/complex/tea_python_tests/client.py

@@ -29,8 +29,9 @@ class Client(SourceClient):
         source_config: source_models.Config,
     ):
         super().__init__(source_config)
-                self._configs[0] = source_config
+        self._configs[0] = source_config
         test = SourceClient(source_config)
+        self.print_data(DaraCore.to_map(source_config), 'test')
 
     def complex_1(
         self,
@@ -978,7 +979,7 @@ class Client(SourceClient):
             'b',
             'c'
         ]
-                configs[3] = config
+        configs[3] = config
         return configs
 
     @staticmethod
@@ -992,7 +993,7 @@ class Client(SourceClient):
                 'c'
             ]
         }
-                data["configs"][3] = config
+        data["configs"][3] = config
         return data.get("configs")
 
     @staticmethod
@@ -1000,7 +1001,7 @@ class Client(SourceClient):
         request: main_models.ComplexRequest,
         config: str,
     ) -> None:
-                request.configs.value[0] = config
+        request.configs.value[0] = config
 
     @staticmethod
     def map_access(