@darabonba/python-generator 2.0.3 → 2.0.5

package/ChangeLog.md

@@ -1,5 +1,12 @@
 # ChangeLog
 
+# 2.0.5
+- Add the model generate config.
+- Fixed the model validate function error. 
+
+# 2.0.4
+- Fixed the writable & readable assert logic.
+
 # 2.0.3
 - Optimized the directory structure of models and exceptions.
 

package/lib/builtin.js

@@ -401,24 +401,18 @@ class Converter {
 
   readable(ast) {
     const expr = ast.args[0];
-    this.generator.usedTypes.push('StringIO');
-    this.generator.imports.push({
-      className: 'json',
-    });
-    this.generator.emit('StringIO(json.dumps(');
+    this.generator.imports.push(_getImport(`${CORE}Stream`));
+    this.generator.emit(`${CORE}Stream.to_readable(`);
     this.generator.visitExpr(expr);
-    this.generator.emit('))');
+    this.generator.emit(')');
   }
 
   writable(ast) {
     const expr = ast.args[0];
-    this.generator.usedTypes.push('BytesIO');
-    this.generator.imports.push({
-      className: 'json',
-    });
-    this.generator.emit('BytesIO(json.dumps(');
+    this.generator.imports.push(_getImport(`${CORE}Stream`));
+    this.generator.emit(`${CORE}Stream.to_writable(`);
     this.generator.visitExpr(expr);
-    this.generator.emit(').encode(\'utf-8\'))');
+    this.generator.emit(')');
   }
 }
 

package/lib/generator.js

@@ -1062,6 +1062,30 @@ setup(
 
   }
 
+  visitFieldValidate(fieldValue, fieldName, value, level) {
+    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'))) {
+      if(deep > 1) {
+        this.emit(` if ${value}:\n`, level);
+      }
+      this.emit(`${value}.validate()\n`, level + 2);
+    } else if (fieldValue.type === 'array' || fieldValue.fieldType === 'array') {
+      this.emit(`for v${deep} in ${value}:\n`, level);
+      this.visitFieldValidate(fieldValue.fieldItemType || fieldValue.subType, fieldName, `v${deep}`, level + 2);
+    } else if (fieldValue.fieldType === 'map' || fieldValue.type === 'map') {
+      this.emit(`for v${deep} in self.${fieldName}.values():\n`, level);
+      this.visitFieldValidate(fieldValue.valueType, fieldName, `v${deep}`, level + 2);
+    } else {
+      if(deep > 1) {
+        this.emit(` if ${value}:\n`, level);
+      }
+      this.emit(`${value}.validate()\n`, level + 2);
+    }
+  }
+
   visitModelValidate(ast, level) {
     let notPass = false;
     for (let i = 0; i < ast.nodes.length; i++) {
@@ -1080,47 +1104,16 @@ setup(
         this.emit(`self.validate_required(self.${param}, '${param}')\n`, level + 2);   
       }
       // 这里判断类中属性的结构
-      if(node.fieldValue.fieldType === 'array' && node.fieldValue.fieldItemType.type !== 'map' && node.fieldValue.fieldItemType.lexeme !== 'string') {
-        // 最底下是string的就不需要validate
-        if(this.checkFieldItemTypeAllString(node.fieldValue)){
-          continue;
-        }
-        notPass = true;
-        this.emit(`if self.${param}:\n`, level + 2);
-        this.emit(`for k in self.${param}:\n`, level + 4);
-        let baseLevel = level + 6;
-        // 二层数组
-        if(node.fieldValue.fieldItemType && node.fieldValue.fieldItemType.fieldType === 'array' || node.fieldValue.fieldItemType.fieldType === 'string') {
-          this.emit('for k1 in k:\n', baseLevel);
-          this.emit('if k1:\n', baseLevel += 2);
-          this.emit('k1.validate()\n', baseLevel += 2);
-        } else {
-          this.emit('if k:\n', baseLevel);   
-          this.emit('k.validate()\n', baseLevel + 2);
-        }
-      } else if(node.fieldValue.fieldType === 'map' && node.fieldValue.valueType.lexeme !== 'string') {
-        // TODO: 这里为array的时候不做validate
-        // $dara.Model.validateMap
-        if(this.checkFieldItemTypeAllString(node.fieldValue)){
+      if(node.fieldValue.fieldType === 'array' || node.fieldValue.fieldType === 'map' || 
+        node.fieldValue.type === 'array' || node.fieldValue.type === 'map'
+      ) {
+        // 下面不包含model的就不需要validate
+        if(!this.checkFieldHasModel(node.fieldValue)){
           continue;
         }
         notPass = true;
         this.emit(`if self.${param}:\n`, level + 2);
-        this.emit(`for v in self.${param}.values():\n`, level + 4);
-        let baseLevel = level + 6;
-        // 二层map 或 array 特殊操作
-        if(node.fieldValue.fieldItemType && node.fieldValue.fieldItemType.fieldType === 'array') {
-          this.emit('for v1 in k:\n', baseLevel);
-          this.emit('if v1:\n', baseLevel += 2);
-          this.emit('v1.validate()\n', baseLevel += 2);
-        } else if(node.fieldValue.valueType.type === 'array'){
-          this.emit('for k1 in v:\n', baseLevel);
-          this.emit('if k1:\n', baseLevel += 2);
-          this.emit('k1.validate()\n', baseLevel += 2);
-        } else {
-          this.emit('if v:\n', baseLevel);   
-          this.emit('v.validate()\n', baseLevel + 2);
-        }
+        this.visitFieldValidate(node.fieldValue, param, `self.${param}`, level + 4);
       } else if(node.fieldValue.fieldType && node.fieldValue.fieldType.idType === 'model' || node.fieldValue.type === 'modelBody'){
         notPass = true;
         this.emit(`if self.${param}:\n`, level + 2);
@@ -1154,7 +1147,7 @@ setup(
   }
 
   visitToMapField(fieldValue, fieldName, key, value, level, arr = false) {
-    const deep = Math.floor(level / 4);
+    const deep = Math.floor((level - 4) / 2);
     if (fieldValue.type === 'modelBody' || fieldValue.type === 'moduleModel' || 
     fieldValue.type === 'subModel' || fieldValue.idType === 'model' || 
     (fieldValue.fieldType && (fieldValue.fieldType.type === 'moduleModel' || 
@@ -1165,13 +1158,27 @@ setup(
       }
       this.emitFieldConvert(key, realVal, level, arr);
     } else if (fieldValue.type === 'array' || fieldValue.fieldType === 'array') {
-      this.emit(`${key} = []\n`, level);
+      let subKey  = key;
+      if(deep > 1) {
+        subKey = `l${deep - 1}`;
+        this.emit(`${subKey} = []\n`, level);
+      }
       this.emit(`for k${deep} in ${value}:\n`, level);
-      this.visitToMapField(fieldValue.fieldItemType || fieldValue.subType, fieldName, `${key}`, `k${deep}`, level + 2, true);
+      this.visitToMapField(fieldValue.fieldItemType || fieldValue.subType, fieldName, `${subKey}`, `k${deep}`, level + 2, true);
+      if(deep > 1) {
+        this.emitFieldConvert(key, subKey, level, arr);
+      }
     } else if (fieldValue.fieldType === 'map' || fieldValue.type === 'map') {
-      this.emit(`${key} = {}\n`, level);
+      let subKey  = key;
+      if(deep > 1) {
+        subKey = `d${deep - 1}`;
+        this.emit(`${subKey} = {}\n`, level);
+      }
       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);
+      this.visitToMapField(fieldValue.valueType, fieldName, `${subKey}[k${deep}]`, `v${deep}`, level + 2);
+      if(deep > 1) {
+        this.emitFieldConvert(key, subKey, level, arr);
+      }
     } else {
       this.emitFieldConvert(key, value, level, arr);
     }
@@ -1180,22 +1187,39 @@ setup(
 
   visitToMap(ast, level) {
     this.emit('def to_map(self):\n', level);
-    this.emit(`        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()\n`);
+    this.emit('result = dict()\n' , level + 2);
+    this.emit('_map = super().to_map()\n' , level + 2);
+    this.emit('if _map is not None:\n' , level + 2);
+    this.emit('result = _map\n', level + 4);
     for (let i = 0; i < ast.nodes.length; i++) {
       const node = ast.nodes[i];
       let realName = this.getRealName(node);
       let comments = DSL.comment.getFrontComments(this.comments, node.tokenRange[0]);
       this.visitComments(comments, level);
       let param = _avoidKeywords(_snakeCase(_escape(_name(node.fieldName))));
+      const hasModel = this.checkFieldHasModel(node.fieldValue);
+      let arr = false;
+      if(hasModel && !this.config.noneEmpty) {
+        if (node.fieldValue.type === 'array' || node.fieldValue.fieldType === 'array') {
+          this.emit(`result['${realName}'] = []\n`, level + 2);
+          arr = true;
+        } else if (node.fieldValue.fieldType === 'map' || node.fieldValue.type === 'map') {
+          this.emit(`result['${realName}'] = {}\n`, level + 2);
+        }
+      }
       this.emit(`if self.${param} is not None:\n`, level + 2);
-      if(!this.checkFieldHasModel(node.fieldValue)) {
-        this.emit(`result['${realName}'] = self.${param}`, level + 4);
+      if(!hasModel) {
+        this.emit(`result['${realName}'] = self.${param}\n`, level + 4);
       } else {
-        this.visitToMapField(node.fieldValue, param, `result['${realName}']`, `self.${param}`, level + 4);
+        if(this.config.noneEmpty) {
+          if (node.fieldValue.type === 'array' || node.fieldValue.fieldType === 'array') {
+            this.emit(`result['${realName}'] = []\n`, level + 4);
+            arr = true;
+          } else if (node.fieldValue.fieldType === 'map' || node.fieldValue.type === 'map') {
+            this.emit(`result['${realName}'] = {}\n`, level + 4);
+          }
+        }
+        this.visitToMapField(node.fieldValue, param, `result['${realName}']`, `self.${param}`, level + 4, arr);
       }
       this.emit('\n');
     }
@@ -1212,20 +1236,33 @@ setup(
   }
 
   visitFromField(fieldValue, fieldName, key, value, level, arr = false) {
-    const deep = Math.floor(level / 4);
+    const deep = Math.floor((level - 4) / 2);
     if (fieldValue.type === 'modelBody') {
       const subModelName = _subModelName(_camelCase(fieldName));
       this.emit(`temp_model = ${this.getModelName(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.visitFromField(fieldValue.fieldItemType || fieldValue.subType, fieldName, `${key}`, `k${deep}`, level + 2, true);
+      let subKey = key;
+      if(deep > 1) {
+        subKey = `l${deep - 1}`;
+        this.emit(`${subKey} = []\n`, level + 2);
+      }
+      this.visitFromField(fieldValue.fieldItemType || fieldValue.subType, fieldName, `${subKey}`, `k${deep}`, level + 2, true);
+      if(deep > 1) {
+        this.emitFieldConvert(key, subKey, level, arr);
+      }
     } 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);
-      this.visitFromField(fieldValue.valueType, fieldName, `${key}[k${deep}]`, `v${deep}`, level + 2);
+      let subKey = key;
+      if(deep > 1) {
+        subKey = `d${deep - 1}`;
+        this.emit(`${subKey} = {}\n`, level + 2);
+      }
+      this.visitFromField(fieldValue.valueType, fieldName, `${subKey}[k${deep}]`, `v${deep}`, level + 2);
+      if(deep > 1) {
+        this.emitFieldConvert(key, subKey, level, arr);
+      }
     } else if (fieldValue.type === 'moduleModel' || 
     (fieldValue.fieldType && fieldValue.fieldType.type === 'moduleModel')) {
       const [moduleId, ...rest] = fieldValue.path || fieldValue.fieldType.path;
@@ -1257,6 +1294,7 @@ setup(
     } else {
       this.emitFieldConvert(key, value, level, arr);
     }
+    
   }
 
   visitFromMap(ast, modelName, level) {
@@ -1269,11 +1307,31 @@ setup(
       let comments = DSL.comment.getFrontComments(this.comments, node.tokenRange[0]);
       this.visitComments(comments, level);
       let param = _avoidKeywords(_snakeCase(_escape(_name(node.fieldName))));
+      const hasModel = this.checkFieldHasModel(node.fieldValue);
+      let arr = false;
+      if(hasModel && !this.config.noneEmpty) {
+        if (node.fieldValue.type === 'array' || node.fieldValue.fieldType === 'array') {
+          this.emit(`self.${param} = []\n`, level + 2);
+          arr = true;
+        } else if (node.fieldValue.fieldType === 'map' || node.fieldValue.type === 'map') {
+          this.emit(`self.${param} = {}\n`, level + 2);
+          arr = false;
+        }
+      }
       this.emit(`if m.get('${realName}') is not None:\n`, level + 2);
-      if(!this.checkFieldHasModel(node.fieldValue)) {
-        this.emit(`self.${param} = m.get('${realName}')`, level + 4);
+      if(!hasModel) {
+        this.emit(`self.${param} = m.get('${realName}')\n`, level + 4);
       } else {
-        this.visitFromField(node.fieldValue, [modelName, param].join('.'), `self.${param}`, `m.get('${realName}')`, level + 4);
+        if(this.config.noneEmpty) {
+          if (node.fieldValue.type === 'array' || node.fieldValue.fieldType === 'array') {
+            this.emit(`self.${param} = []\n`, level + 4);
+            arr = true;
+          } else if (node.fieldValue.fieldType === 'map' || node.fieldValue.type === 'map') {
+            this.emit(`self.${param} = {}\n`, level + 4);
+            arr = false;
+          }
+        }
+        this.visitFromField(node.fieldValue, [modelName, param].join('.'), `self.${param}`, `m.get('${realName}')`, level + 4, arr);
       }
       this.emit('\n');
     }
@@ -1291,24 +1349,6 @@ setup(
     return attr.attrValue.string || attr.attrValue.lexeme || attr.attrValue.value;
   }
 
-  visitFieldValidate(value, level, name) {
-    if (value.type === 'array' || value.fieldType === 'array') {
-      this.emit(`if(Array.isArray(${name})) {\n`, level);
-      this.emit(`$dara.Model.validateArray(${name})\n`, level + 1);
-      this.emit('}\n', level);
-    } else if (value.fieldType === 'map' || value.type === 'map') {
-      this.emit(`if(${name}) {\n`, level);
-      this.emit(`$dara.Model.validateMap(${name})\n`, level + 1);
-      this.emit('}\n', level);
-    } else if (value.type === 'moduleModel' || value.type === 'modelBody'
-    || value.type === 'subModel' || value.fieldType.type === 'moduleModel'
-    || value.fieldType.idType === 'model' || value.fieldType.idType === 'module') {
-      this.emit(`if(${name} && typeof (${name} as any).validate === 'function') {\n`, level);
-      this.emit(`(${name} as any).validate()\n`, level + 1);
-      this.emit('}\n', level);
-    }
-  }
-
   extendBaseErr(extendOn){
     if (!extendOn) {
       return true;
@@ -1474,7 +1514,7 @@ setup(
       return;
     }
     this.emit('\n');
-    this.emit('self, *,\n', level + 2);
+    this.emit(`self,${ this.config.strictModel ? ' *,' : '' }\n`, level + 2);
     for (let i = 0; i < paramNodes.length; i++) {
       node = paramNodes[i];
       if(!node.extend) {

package/package.json

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

package/tests/expected/annotation/tea_python_tests/models/_test.py

@@ -10,7 +10,7 @@ from darabonba.model import DaraModel
 """
 class Test(DaraModel):
     def __init__(
-        self, *,
+        self,
         test: str = None,
     ):
         # Alichange app id
@@ -20,18 +20,19 @@ class Test(DaraModel):
         self.validate_required(self.test, 'test')
 
     def to_map(self):
+        result = dict()
         _map = super().to_map()
         if _map is not None:
-            return _map
-
-        result = dict()
+            result = _map
         if self.test is not None:
             result['test'] = self.test
+
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('test') is not None:
             self.test = m.get('test')
+
         return self
 

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

@@ -16,7 +16,7 @@ from darabonba.utils.stream import Stream as DaraStream
 from darabonba.url import Url as DaraURL 
 from darabonba.utils.xml import XML as DaraXML 
 import sys 
-from typing import List, Any, BytesIO, StringIO
+from typing import List, Any
 
 
 class Client:
@@ -618,8 +618,8 @@ class Client:
                 'key': 'value'
             }
             obj = maps
-            ws = BytesIO(json.dumps(obj).encode('utf-8'))
-            rs = StringIO(json.dumps(maps))
+            ws = DaraStream.to_writable(obj)
+            rs = DaraStream.to_readable(maps)
             data = rs.read(30)
             if not DaraCore.is_null(data):
                 ws.write(data)
@@ -669,8 +669,8 @@ class Client:
                 'key': 'value'
             }
             obj = maps
-            ws = BytesIO(json.dumps(obj).encode('utf-8'))
-            rs = StringIO(json.dumps(maps))
+            ws = DaraStream.to_writable(obj)
+            rs = DaraStream.to_readable(maps)
             data = rs.read(30)
             if not DaraCore.is_null(data):
                 ws.write(data)

package/tests/expected/comment/tea_python_tests/models/_test_1.py

@@ -14,7 +14,7 @@ from typing import List
 """
 class Test1(DaraModel):
     def __init__(
-        self, *,
+        self,
         test: str = None,
     # odel的test back comment
         test_2: str = None,
@@ -50,42 +50,53 @@ class Test1(DaraModel):
         self.validate_required(self.a_sts, 'a_sts')
 
     def to_map(self):
+        result = dict()
         _map = super().to_map()
         if _map is not None:
-            return _map
-
-        result = dict()
+            result = _map
         if self.test is not None:
             result['test'] = self.test
+
     # odel的test back comment
         if self.test_2 is not None:
             result['test2'] = self.test_2
+
     # odel的test2 back comment
         if self.test_3 is not None:
             result['test3'] = self.test_3
+
         if self.test_5 is not None:
             result['test5'] = self.test_5
+
         if self.sts is not None:
             result['sts'] = self.sts
+
         if self.a_sts is not None:
             result['asts'] = self.a_sts
+
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('test') is not None:
             self.test = m.get('test')
+
     # odel的test back comment
         if m.get('test2') is not None:
             self.test_2 = m.get('test2')
+
     # odel的test2 back comment
         if m.get('test3') is not None:
             self.test_3 = m.get('test3')
+
         if m.get('test5') is not None:
             self.test_5 = m.get('test5')
+
         if m.get('sts') is not None:
             self.sts = m.get('sts')
+
         if m.get('asts') is not None:
             self.a_sts = m.get('asts')
+
         return self
 

package/tests/expected/comment/tea_python_tests/models/_test_2.py

@@ -10,7 +10,7 @@ from darabonba.model import DaraModel
 """
 class Test2(DaraModel):
     def __init__(
-        self, *,
+        self,
     # model的test front comment
         test: str = None,
     # model的test front comment
@@ -30,17 +30,18 @@ class Test2(DaraModel):
         self.validate_required(self.test_2, 'test_2')
 
     def to_map(self):
+        result = dict()
         _map = super().to_map()
         if _map is not None:
-            return _map
-
-        result = dict()
+            result = _map
     # model的test front comment
         if self.test is not None:
             result['test'] = self.test
+
     # model的test front comment
         if self.test_2 is not None:
             result['test2'] = self.test_2
+
         return result
 
     def from_map(self, m: dict = None):
@@ -48,8 +49,10 @@ class Test2(DaraModel):
     # model的test front comment
         if m.get('test') is not None:
             self.test = m.get('test')
+
     # model的test front comment
         if m.get('test2') is not None:
             self.test_2 = m.get('test2')
+
         return self
 

package/tests/expected/comment/tea_python_tests/models/_test_3.py

@@ -10,7 +10,7 @@ from darabonba.model import DaraModel
 """
 class Test3(DaraModel):
     def __init__(
-        self, *,
+        self,
     # model的test front comment
         test: str = None,
     # empty comment1
@@ -33,18 +33,19 @@ class Test3(DaraModel):
         self.validate_required(self.test_1, 'test_1')
 
     def to_map(self):
+        result = dict()
         _map = super().to_map()
         if _map is not None:
-            return _map
-
-        result = dict()
+            result = _map
     # model的test front comment
         if self.test is not None:
             result['test'] = self.test
+
     # empty comment1
     # empy comment2
         if self.test_1 is not None:
             result['test1'] = self.test_1
+
         return result
 
     def from_map(self, m: dict = None):
@@ -52,10 +53,12 @@ class Test3(DaraModel):
     # model的test front comment
         if m.get('test') is not None:
             self.test = m.get('test')
+
     # empty comment1
     # empy comment2
         if m.get('test1') is not None:
             self.test_1 = m.get('test1')
+
         return self
 
     # odel的test back comment

package/tests/expected/complex/tea_python_tests/exceptions/_err_1.py

@@ -7,7 +7,7 @@ from typing import Dict
 
 class Err1Exception(DaraException):
     def __init__(
-        self, *,
+        self,
         message: str = None,
         code: str = None,
         stack: str = None,

package/tests/expected/complex/tea_python_tests/exceptions/_err_2.py

@@ -6,7 +6,7 @@ from darabonba.exceptions import DaraException
 
 class Err2Exception(DaraException):
     def __init__(
-        self, *,
+        self,
         message: str = None,
         code: str = None,
         stack: str = None,