@darabonba/python-generator 2.0.0 → 2.0.2

package/tests/output/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/output/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/output/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/src/generator.js

@@ -1,231 +0,0 @@
-'use strict';
-
-const path = require('path');
-const fs = require('fs');
-const debug = require('./lib/debug');
-
-const { _deepClone } = require('./lib/helper');
-const ClientResolver = require('./resolver/client');
-const ModelResolver = require('./resolver/model');
-
-class Generator {
-  constructor(meta = {}, lang = 'python') {
-    if (!meta.outputDir) {
-      throw new Error('`option.outputDir` should not empty');
-    }
-    this.lang = lang;
-    this.typedef = meta[lang] && meta[lang].typedef ? meta[lang].typedef : {};
-    this.additionalPackage = meta[lang] && meta[lang].additionalPackage ? meta[lang].additionalPackage : [];
-    this.initConfig(meta);
-  }
-
-  visit(ast) {
-    this.imports = this.resolveImports(ast);
-    this.imports.typedef = this.typedef;
-    this.imports.additionalPackage = this.additionalPackage;
-    Object.keys(this.typedef).forEach((def) => {
-      if (this.typedef[def].package && !this.imports.requirePackage.includes(this.typedef[def].package)) {
-        this.imports.requirePackage.push(this.typedef[def].package);
-      }
-    });
-    const objects = [];
-
-    // combine client code
-    const clientObjectItem = this.resolve('client', ast, ast);
-    objects.push(clientObjectItem);
-
-    // combine model code
-    ast.moduleBody.nodes.filter((item) => {
-      return item.type === 'model';
-    }).forEach((model) => {
-      const modelName = model.modelName.lexeme;
-      const modelObjectItem = this.resolve('model', model, ast);
-      if (ast.models) {
-        Object.keys(ast.models).filter((key) => {
-          return key.startsWith(modelName + '.');
-        }).forEach((key) => {
-          const subModel = ast.models[key];
-          const subModelObjectItem = this.resolve('model', subModel, ast);
-          modelObjectItem.subObject.push(subModelObjectItem);
-        });
-      }
-      objects.push(modelObjectItem);
-    });
-
-    const combinator = this.getCombinator(this.config);
-    combinator.combine(objects);
-  }
-
-  resolve(type, ast, globalAST) {
-    const combinator = this.getCombinator(this.config);
-    let resolver;
-    switch (type) {
-    case 'client':
-      resolver = new ClientResolver(ast, combinator, ast);
-      break;
-    case 'model':
-      resolver = new ModelResolver(ast, combinator, globalAST);
-      break;
-    }
-    const objectItem = resolver.resolve();
-    objectItem.includeList = combinator.includeList;
-    objectItem.includeModelList = combinator.includeModelList;
-    return objectItem;
-  }
-
-  getCombinator(configOriginal) {
-    const config = _deepClone(configOriginal);
-
-    // init combinator
-    const Combinator = require(`./langs/${this.lang}/combinator`);
-    return new Combinator(config, this.imports);
-  }
-
-  initConfig(meta) {
-    const langDir = path.join(__dirname, `./langs/${this.lang}/`);
-    if (!fs.existsSync(langDir)) {
-      throw new Error(`Not supported language : ${this.lang}`);
-    }
-    const langConfig = require(`./langs/${this.lang}/config`);
-
-    const config = {
-      package: 'darabonba_sdk',
-      clientName: langConfig.client.defaultName,
-      include: [],
-      parent: [],
-      pkgDir: '',
-      output: true,
-      dir: meta.outputDir,
-      layer: '',
-    };
-    Object.assign(config,
-      langConfig,
-      meta,
-    );
-    if (meta[this.lang]) {
-      if (!meta[this.lang].package) {
-        debug.warning('Not found package in Darafile, default package name is "darabonba_sdk".');
-      }
-
-      if (!meta[this.lang].clientName) {
-        debug.warning('Not found clientName in Darafile, default clientName is "client".');
-      }
-
-      Object.assign(config,
-        meta[this.lang],
-      );
-    } else {
-      debug.warning('Not found python config in Darafile, default config will be used.');
-    }
-
-    this.config = config;
-  }
-
-  resolveImports(ast) {
-    const imports = ast.imports;
-
-    let requirePackage = [];
-    let thirdPackageNamespace = {};
-    let thirdPackageModel = {};
-    let thirdPackageClient = {};
-    let thirdPackageClientAlias = {};
-    let importsTypedef = {};
-
-    if (imports.length > 0) {
-      const lockPath = path.join(this.config.pkgDir, '.libraries.json');
-      const lock = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
-      let packageNameSet = [];
-      let clientNameSet = [];
-      ast.imports.forEach((item) => {
-        const aliasId = item.lexeme;
-        const moduleDir = this.config.libraries[aliasId];
-        let targetPath;
-        if (moduleDir.startsWith('/')) {
-          targetPath = moduleDir;
-        } else if (moduleDir.startsWith('./') || moduleDir.startsWith('../')) {
-          targetPath = path.join(this.config.pkgDir, moduleDir);
-        } else {
-          targetPath = path.join(this.config.pkgDir, lock[moduleDir]);
-        }
-        // get dara meta
-        const daraFilePath = fs.existsSync(path.join(targetPath, 'Teafile'))
-          ? path.join(targetPath, 'Teafile')
-          : path.join(targetPath, 'Darafile');
-        const daraMeta = JSON.parse(fs.readFileSync(daraFilePath));
-
-        // init package name,client name,modelDir name
-        let packageName, clientName, modelDir;
-        if (daraMeta[this.lang]) {
-          if (daraMeta[this.lang].package) {
-            packageName = daraMeta[this.lang].package;
-          } else {
-            debug.warning(`Not found package in ${daraMeta.name} Darafile, default package name is "${daraMeta.name}".`);
-            packageName = daraMeta.name;
-          }
-
-          clientName = daraMeta[this.lang].clientName
-            ? daraMeta[this.lang].clientName
-            : this.config.clientName;
-
-          modelDir = daraMeta[this.lang].modelDirName
-            ? daraMeta[this.lang].modelDirName
-            : this.config.model.dir;
-          if (daraMeta[this.lang].typedef) {
-            importsTypedef[aliasId] = {};
-            const moduleTypedef = daraMeta[this.lang].typedef;
-            Object.keys(moduleTypedef || {}).forEach((types) => {
-              if (!importsTypedef[aliasId][types]) {
-                importsTypedef[aliasId][types] = {};
-              }
-              importsTypedef[aliasId][types].import = moduleTypedef[types].import;
-              importsTypedef[aliasId][types].type = moduleTypedef[types].type;
-              if (moduleTypedef[types].package && !requirePackage.includes(moduleTypedef[types].package)) {
-                requirePackage.push(moduleTypedef[types].package);
-              }
-            });
-          }
-        } else {
-          packageName = daraMeta.name;
-          clientName = this.config.clientName;
-          modelDir = this.config.model.dir;
-        }
-
-        // resolve third package namespace
-        if (packageNameSet.indexOf(packageName.toLowerCase()) < 0) {
-          thirdPackageNamespace[aliasId] = packageName;
-          packageNameSet.push(packageName.toLowerCase());
-        } else {
-          debug.stack('Duplication namespace');
-        }
-
-        // resolve third package model client name
-        if (
-          clientNameSet.indexOf(clientName.toLowerCase()) > -1 ||
-          clientName.toLowerCase() === this.config.clientName.toLowerCase()
-        ) {
-          const alias = packageName.split('.').join('') + '->' + clientName.split('.').join('');
-          thirdPackageClientAlias[aliasId] = alias;
-          thirdPackageClient[aliasId] = clientName;
-        } else {
-          thirdPackageClient[aliasId] = clientName;
-          clientNameSet.push(clientName.toLowerCase());
-        }
-        if (daraMeta.releases && daraMeta.releases[this.lang]) {
-          requirePackage.push(daraMeta.releases[this.lang]);
-        }
-        // third package model dir name
-        thirdPackageModel[aliasId] = modelDir;
-      });
-    }
-    return {
-      requirePackage,
-      thirdPackageNamespace,
-      thirdPackageClient,
-      thirdPackageClientAlias,
-      thirdPackageModel,
-      importsTypedef,
-    };
-  }
-}
-
-module.exports = Generator;