@darabonba/python-generator 1.2.18 → 1.2.19

package/ChangeLog.md

@@ -1,5 +1,8 @@
 # ChangeLog
 
+## 1.2.19 - 2025-01-13
+* Adjust field name for object.
+
 ## 1.2.18 - 2024-02-29
 * Fix: avoid keywords in variables.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darabonba/python-generator",
-  "version": "1.2.18",
+  "version": "1.2.19",
   "description": "The darabonba generator for Python",
   "main": "src/generator.js",
   "directories": {
@@ -30,7 +30,7 @@
   "author": "Alibaba Cloud OpenAPI Team",
   "license": "Apache-2.0",
   "dependencies": {
-    "@darabonba/parser": "^1.2.10",
+    "@darabonba/parser": "^1.4.7",
     "enum": "^3.0.4"
   }
 }

package/src/lib/helper.js

@@ -41,7 +41,12 @@ function _subModelName(name) {
 }
 
 function _string(str) {
-  return str.string;
+  if (str.string === '""') {
+    return '\\"\\"';
+  }
+  return str.string.replace(/([^\\])"+|^"/g, function (str) {
+    return str.replace(/"/g, '\\"');
+  });
 }
 
 function _isBasicType(type) {
@@ -172,9 +177,14 @@ function _toSnakeCase(str) {
   return res;
 }
 
+function _escape(str) {
+  return str.includes('-') ? `${str}` : str;
+}
+
 
 module.exports = {
   _config,
+  _escape,
   _upperFirst,
   _camelCase,
   _string,

package/src/resolver/base.js

@@ -3,6 +3,8 @@
 const debug = require('../lib/debug');
 
 const {
+  _string,
+  _escape,
   _isBasicType
 } = require('../lib/helper');
 
@@ -176,7 +178,7 @@ class BaseResolver {
       } else if (typeNode.type === 'modelBody') {
         // is sub model
         typeInfo['objectType'] = 'model';
-        typeInfo['lexeme'] = this.combinator.addModelInclude([this.object.name, sourceNode.fieldName.lexeme].join('.'));
+        typeInfo['lexeme'] = this.combinator.addModelInclude([this.object.name, _escape(sourceNode.fieldName.lexeme) || _string(sourceNode.fieldName)].join('.'));
         return typeInfo;
       } else if (_isBasicType(typeNode.type)) {
         return this.resolveType(typeNode.type, typeNode);

package/src/resolver/client.js

@@ -43,7 +43,10 @@ const {
 } = require('../langs/common/enum');
 
 const {
-  _isBasicType
+  _isBasicType,
+  _string,
+  _escape
+
 } = require('../lib/helper');
 
 const systemPackage = ['Util'];
@@ -158,7 +161,7 @@ class ClientResolver extends BaseResolver {
     ast.params.params.forEach(p => {
       var param = new GrammerValue();
       param.type = this.resolveType(p.paramType, p);
-      param.key = p.paramName.lexeme;
+      param.key = _escape(p.paramName.lexeme || _string(p.paramName));
       if (p.needValidate) {
         func.addBodyNode(new GrammerCall('method', [
           { type: 'object', name: param.key },
@@ -450,8 +453,8 @@ class ClientResolver extends BaseResolver {
           valGrammer.needCast = true;
           exprChild.isExpand = true;
         }
-        if (field.fieldName && field.fieldName.lexeme) {
-          exprChild.key = field.fieldName.lexeme;
+        if (field.fieldName && (field.fieldName.lexeme || field.fieldName.string)) {
+          exprChild.key = (field.fieldName.lexeme) || _string(field.fieldName);
         }
         this.renderGrammerValue(exprChild, field.expr, expectedType);
         this.findComments(valGrammer, field);

package/src/resolver/model.js

@@ -6,7 +6,9 @@ const assert = require('assert');
 const BaseResolver = require('./base');
 
 const {
-  _isBasicType
+  _string,
+  _escape,
+  _isBasicType,  
 } = require('../lib/helper');
 
 const {
@@ -95,7 +97,7 @@ class ModelResolver extends BaseResolver {
 
       const prop = new PropItem();
       prop.belong = object.index;
-      prop.name = node.fieldName.lexeme;
+      prop.name = _escape(node.fieldName.lexeme) || _string(node.fieldName);
       prop.type = this.resolveType(node.fieldValue, node);
       
       prop.modify.push(Modify.public());
@@ -141,7 +143,7 @@ class ModelResolver extends BaseResolver {
   }
 
   findSubModelsUsed(node, subModelUsed = [], pre = '') {
-    let name = node.fieldName.lexeme;
+    let name = _escape(node.fieldName.lexeme) || _string(node.fieldName);
     if (pre !== '') {
       name = pre + '.' + name;
     }

package/tests/expected/python2/function/tea_python_tests/client.py

@@ -18,7 +18,9 @@ class Client(object):
         m = {}
         return TeaCore.merge({
             'key': 'value',
-            'key-1': 'value-1'
+            'key-1': 'value-1',
+            'key-2': 'value-2',
+            '\"\"': 'value-3'
         }, m)
 
     @staticmethod

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

@@ -145,7 +145,8 @@ class MyModel(TeaModel):
     def __init__(self, stringfield=None, bytesfield=None, stringarrayfield=None, mapfield=None, name=None,
                  submodel=None, subarray=None, maparray=None, object=None, numberfield=None, readable=None, exist_model=None,
                  class_end_time=None, max_length=None, min_length=None, maximum=None, minimum=None, test_3=None,
-                 array_array_model=None, array_map_model=None, map_model=None, submodel_map=None, sub_model_model=None):
+                 array_array_model=None, array_map_model=None, map_model=None, submodel_map=None, sub_model_model=None,
+                 map_array_map=None, map_array_model=None):
         self.stringfield = stringfield  # type: str
         self.bytesfield = bytesfield  # type: bytes
         self.stringarrayfield = stringarrayfield  # type: list[str]
@@ -175,6 +176,8 @@ class MyModel(TeaModel):
         self.map_model = map_model  # type: dict[str, M]
         self.submodel_map = submodel_map  # type: dict[str, MyModelSubmodel]
         self.sub_model_model = sub_model_model  # type: MyModelSubModelModel
+        self.map_array_map = map_array_map  # type: dict[str, list[dict[str, str]]]
+        self.map_array_model = map_array_model  # type: dict[str, list[M]]
 
     def validate(self):
         self.validate_required(self.stringfield, 'stringfield')
@@ -226,6 +229,11 @@ class MyModel(TeaModel):
         self.validate_required(self.sub_model_model, 'sub_model_model')
         if self.sub_model_model:
             self.sub_model_model.validate()
+        if self.map_array_model:
+            for v in self.map_array_model.values():
+                for k1 in v:
+                    if k1:
+                        k1.validate()
 
     def to_map(self):
         _map = super(MyModel, self).to_map()
@@ -244,13 +252,13 @@ class MyModel(TeaModel):
         if self.name is not None:
             result['realName'] = self.name
         if self.submodel is not None:
-            result['submodel'] = self.submodel.to_map()
-        result['subarray'] = []
+            result['SubModel'] = self.submodel.to_map()
+        result['SubArray'] = []
         if self.subarray is not None:
             for k in self.subarray:
-                result['subarray'].append(k.to_map() if k else None)
+                result['SubArray'].append(k.to_map() if k else None)
         if self.maparray is not None:
-            result['maparray'] = self.maparray
+            result['MapArray'] = self.maparray
         if self.object is not None:
             result['object'] = self.object
         if self.numberfield is not None:
@@ -271,30 +279,39 @@ class MyModel(TeaModel):
             result['minimum'] = self.minimum
         if self.test_3 is not None:
             result['test3'] = self.test_3
-        result['arrayArrayModel'] = []
+        result['ArrayArrayModel'] = []
         if self.array_array_model is not None:
             for k in self.array_array_model:
                 l1 = []
                 for k1 in k:
                     l1.append(k1.to_map() if k1 else None)
-                result['arrayArrayModel'].append(l1)
-        result['arrayMapModel'] = []
+                result['ArrayArrayModel'].append(l1)
+        result['ArrayMapModel'] = []
         if self.array_map_model is not None:
             for k in self.array_map_model:
                 d1 = {}
                 for k1 ,v1 in k.items():
                     d1[k1] = v1.to_map()
-                result['arrayMapModel'].append(d1)
-        result['mapModel'] = {}
+                result['ArrayMapModel'].append(d1)
+        result['MapModel'] = {}
         if self.map_model is not None:
             for k, v in self.map_model.items():
-                result['mapModel'][k] = v.to_map()
-        result['submodelMap'] = {}
+                result['MapModel'][k] = v.to_map()
+        result['SubmodelMap'] = {}
         if self.submodel_map is not None:
             for k, v in self.submodel_map.items():
-                result['submodelMap'][k] = v.to_map()
+                result['SubmodelMap'][k] = v.to_map()
         if self.sub_model_model is not None:
-            result['subModelModel'] = self.sub_model_model.to_map()
+            result['SubModelModel'] = self.sub_model_model.to_map()
+        if self.map_array_map is not None:
+            result['MapArrayMap'] = self.map_array_map
+        result['MapArrayModel'] = {}
+        if self.map_array_model is not None:
+            for k, v in self.map_array_model.items():
+                l1 = []
+                for k1 in v:
+                    l1.append(k1.to_map() if k1 else None)
+                result['MapArrayModel'][k] = l1
         return result
 
     def from_map(self, m=None):
@@ -309,16 +326,16 @@ class MyModel(TeaModel):
             self.mapfield = m.get('mapfield')
         if m.get('realName') is not None:
             self.name = m.get('realName')
-        if m.get('submodel') is not None:
+        if m.get('SubModel') is not None:
             temp_model = MyModelSubmodel()
-            self.submodel = temp_model.from_map(m['submodel'])
+            self.submodel = temp_model.from_map(m['SubModel'])
         self.subarray = []
-        if m.get('subarray') is not None:
-            for k in m.get('subarray'):
+        if m.get('SubArray') is not None:
+            for k in m.get('SubArray'):
                 temp_model = M()
                 self.subarray.append(temp_model.from_map(k))
-        if m.get('maparray') is not None:
-            self.maparray = m.get('maparray')
+        if m.get('MapArray') is not None:
+            self.maparray = m.get('MapArray')
         if m.get('object') is not None:
             self.object = m.get('object')
         if m.get('numberfield') is not None:
@@ -341,34 +358,44 @@ class MyModel(TeaModel):
         if m.get('test3') is not None:
             self.test_3 = m.get('test3')
         self.array_array_model = []
-        if m.get('arrayArrayModel') is not None:
-            for k in m.get('arrayArrayModel'):
+        if m.get('ArrayArrayModel') is not None:
+            for k in m.get('ArrayArrayModel'):
                 l1 = []
                 for k1 in k:
                     temp_model = M()
                     l1.append(temp_model.from_map(k1))
                 self.array_array_model.append(l1)
         self.array_map_model = []
-        if m.get('arrayMapModel') is not None:
-            for k in m.get('arrayMapModel'):
+        if m.get('ArrayMapModel') is not None:
+            for k in m.get('ArrayMapModel'):
                 d1 = {}
                 for k1 ,v1 in k.items():
                     temp_model = M()
                     d1[k1] = temp_model.from_map(v1)
                 self.array_map_model.append(d1)
         self.map_model = {}
-        if m.get('mapModel') is not None:
-            for k, v in m.get('mapModel').items():
+        if m.get('MapModel') is not None:
+            for k, v in m.get('MapModel').items():
                 temp_model = M()
                 self.map_model[k] = temp_model.from_map(v)
         self.submodel_map = {}
-        if m.get('submodelMap') is not None:
-            for k, v in m.get('submodelMap').items():
+        if m.get('SubmodelMap') is not None:
+            for k, v in m.get('SubmodelMap').items():
                 temp_model = MyModelSubmodel()
                 self.submodel_map[k] = temp_model.from_map(v)
-        if m.get('subModelModel') is not None:
+        if m.get('SubModelModel') is not None:
             temp_model = MyModelSubModelModel()
-            self.sub_model_model = temp_model.from_map(m['subModelModel'])
+            self.sub_model_model = temp_model.from_map(m['SubModelModel'])
+        if m.get('MapArrayMap') is not None:
+            self.map_array_map = m.get('MapArrayMap')
+        self.map_array_model = {}
+        if m.get('MapArrayModel') is not None:
+            for k, v in m.get('MapArrayModel').items():
+                l1 = []
+                for k1 in v:
+                    temp_model = M()
+                    l1.append(temp_model.from_map(k1))
+                self.map_array_model['k'] = l1
         return self
 
 

package/tests/expected/python3/function/tea_python_tests/client.py

@@ -17,7 +17,9 @@ class Client:
         m = {}
         return TeaCore.merge({
             'key': 'value',
-            'key-1': 'value-1'
+            'key-1': 'value-1',
+            'key-2': 'value-2',
+            '\"\"': 'value-3'
         }, m)
 
     @staticmethod

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

@@ -197,6 +197,8 @@ class MyModel(TeaModel):
         map_model: Dict[str, M] = None,
         submodel_map: Dict[str, MyModelSubmodel] = None,
         sub_model_model: MyModelSubModelModel = None,
+        map_array_map: Dict[str, List[Dict[str, str]]] = None,
+        map_array_model: Dict[str, List[M]] = None,
     ):
         self.stringfield = stringfield
         self.bytesfield = bytesfield
@@ -227,6 +229,8 @@ class MyModel(TeaModel):
         self.map_model = map_model
         self.submodel_map = submodel_map
         self.sub_model_model = sub_model_model
+        self.map_array_map = map_array_map
+        self.map_array_model = map_array_model
 
     def validate(self):
         self.validate_required(self.stringfield, 'stringfield')
@@ -278,6 +282,11 @@ class MyModel(TeaModel):
         self.validate_required(self.sub_model_model, 'sub_model_model')
         if self.sub_model_model:
             self.sub_model_model.validate()
+        if self.map_array_model:
+            for v in self.map_array_model.values():
+                for k1 in v:
+                    if k1:
+                        k1.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -296,13 +305,13 @@ class MyModel(TeaModel):
         if self.name is not None:
             result['realName'] = self.name
         if self.submodel is not None:
-            result['submodel'] = self.submodel.to_map()
-        result['subarray'] = []
+            result['SubModel'] = self.submodel.to_map()
+        result['SubArray'] = []
         if self.subarray is not None:
             for k in self.subarray:
-                result['subarray'].append(k.to_map() if k else None)
+                result['SubArray'].append(k.to_map() if k else None)
         if self.maparray is not None:
-            result['maparray'] = self.maparray
+            result['MapArray'] = self.maparray
         if self.object is not None:
             result['object'] = self.object
         if self.numberfield is not None:
@@ -323,30 +332,39 @@ class MyModel(TeaModel):
             result['minimum'] = self.minimum
         if self.test_3 is not None:
             result['test3'] = self.test_3
-        result['arrayArrayModel'] = []
+        result['ArrayArrayModel'] = []
         if self.array_array_model is not None:
             for k in self.array_array_model:
                 l1 = []
                 for k1 in k:
                     l1.append(k1.to_map() if k1 else None)
-                result['arrayArrayModel'].append(l1)
-        result['arrayMapModel'] = []
+                result['ArrayArrayModel'].append(l1)
+        result['ArrayMapModel'] = []
         if self.array_map_model is not None:
             for k in self.array_map_model:
                 d1 = {}
                 for k1 ,v1 in k.items():
                     d1[k1] = v1.to_map()
-                result['arrayMapModel'].append(d1)
-        result['mapModel'] = {}
+                result['ArrayMapModel'].append(d1)
+        result['MapModel'] = {}
         if self.map_model is not None:
             for k, v in self.map_model.items():
-                result['mapModel'][k] = v.to_map()
-        result['submodelMap'] = {}
+                result['MapModel'][k] = v.to_map()
+        result['SubmodelMap'] = {}
         if self.submodel_map is not None:
             for k, v in self.submodel_map.items():
-                result['submodelMap'][k] = v.to_map()
+                result['SubmodelMap'][k] = v.to_map()
         if self.sub_model_model is not None:
-            result['subModelModel'] = self.sub_model_model.to_map()
+            result['SubModelModel'] = self.sub_model_model.to_map()
+        if self.map_array_map is not None:
+            result['MapArrayMap'] = self.map_array_map
+        result['MapArrayModel'] = {}
+        if self.map_array_model is not None:
+            for k, v in self.map_array_model.items():
+                l1 = []
+                for k1 in v:
+                    l1.append(k1.to_map() if k1 else None)
+                result['MapArrayModel'][k] = l1
         return result
 
     def from_map(self, m: dict = None):
@@ -361,16 +379,16 @@ class MyModel(TeaModel):
             self.mapfield = m.get('mapfield')
         if m.get('realName') is not None:
             self.name = m.get('realName')
-        if m.get('submodel') is not None:
+        if m.get('SubModel') is not None:
             temp_model = MyModelSubmodel()
-            self.submodel = temp_model.from_map(m['submodel'])
+            self.submodel = temp_model.from_map(m['SubModel'])
         self.subarray = []
-        if m.get('subarray') is not None:
-            for k in m.get('subarray'):
+        if m.get('SubArray') is not None:
+            for k in m.get('SubArray'):
                 temp_model = M()
                 self.subarray.append(temp_model.from_map(k))
-        if m.get('maparray') is not None:
-            self.maparray = m.get('maparray')
+        if m.get('MapArray') is not None:
+            self.maparray = m.get('MapArray')
         if m.get('object') is not None:
             self.object = m.get('object')
         if m.get('numberfield') is not None:
@@ -393,34 +411,44 @@ class MyModel(TeaModel):
         if m.get('test3') is not None:
             self.test_3 = m.get('test3')
         self.array_array_model = []
-        if m.get('arrayArrayModel') is not None:
-            for k in m.get('arrayArrayModel'):
+        if m.get('ArrayArrayModel') is not None:
+            for k in m.get('ArrayArrayModel'):
                 l1 = []
                 for k1 in k:
                     temp_model = M()
                     l1.append(temp_model.from_map(k1))
                 self.array_array_model.append(l1)
         self.array_map_model = []
-        if m.get('arrayMapModel') is not None:
-            for k in m.get('arrayMapModel'):
+        if m.get('ArrayMapModel') is not None:
+            for k in m.get('ArrayMapModel'):
                 d1 = {}
                 for k1, v1 in k.items():
                     temp_model = M()
                     d1[k1] = temp_model.from_map(v1)
                 self.array_map_model.append(d1)
         self.map_model = {}
-        if m.get('mapModel') is not None:
-            for k, v in m.get('mapModel').items():
+        if m.get('MapModel') is not None:
+            for k, v in m.get('MapModel').items():
                 temp_model = M()
                 self.map_model[k] = temp_model.from_map(v)
         self.submodel_map = {}
-        if m.get('submodelMap') is not None:
-            for k, v in m.get('submodelMap').items():
+        if m.get('SubmodelMap') is not None:
+            for k, v in m.get('SubmodelMap').items():
                 temp_model = MyModelSubmodel()
                 self.submodel_map[k] = temp_model.from_map(v)
-        if m.get('subModelModel') is not None:
+        if m.get('SubModelModel') is not None:
             temp_model = MyModelSubModelModel()
-            self.sub_model_model = temp_model.from_map(m['subModelModel'])
+            self.sub_model_model = temp_model.from_map(m['SubModelModel'])
+        if m.get('MapArrayMap') is not None:
+            self.map_array_map = m.get('MapArrayMap')
+        self.map_array_model = {}
+        if m.get('MapArrayModel') is not None:
+            for k, v in m.get('MapArrayModel').items():
+                l1 = []
+                for k1 in v:
+                    temp_model = M()
+                    l1.append(temp_model.from_map(k1))
+                self.map_array_model['k'] = l1
         return self
 
 

package/tests/fixtures/function/main.dara

@@ -10,6 +10,8 @@ static function helloMap(): map[string]string {
   return {
     key = 'value',
     key-1 = 'value-1',
+    'key-2' = 'value-2',
+    '""' = 'value-3',
     ...m,
   };
 }

package/tests/fixtures/model/main.dara

@@ -16,9 +16,9 @@ model MyModel = {
   name: string(name='realName'),
   submodel: {
     stringfield: string,
-  },
-  subarray: [ M ],
-  maparray: [ map[string]any ],
+  } (name='SubModel'),
+  subarray: [ M ] (name='SubArray'),
+  maparray: [ map[string]any ] (name='MapArray'),
   object: object,
   numberfield: integer,
   readable: readable,
@@ -29,15 +29,17 @@ model MyModel = {
   maximum?: long(description='校验最大值', example='10000', maximum='99000000'),
   minimum?: long(description='校验最小值', example='10000', minimum='0'),
   test3: [[string]](description='test3 desc', name='test3'),
-  arrayArrayModel: [[M]],
-  arrayMapModel: [ map[string]M ],
+  arrayArrayModel: [[M]] (name='ArrayArrayModel'),
+  arrayMapModel: [ map[string]M ] (name='ArrayMapModel'),
 
-  mapModel: map[string]M,
-  submodelMap: map[string]MyModel.submodel,
+  mapModel: map[string]M (name='MapModel'),
+  submodelMap: map[string]MyModel.submodel (name='SubmodelMap'),
 
   subModelModel: {
     subModel: [ M ]
-  }
+  } (name='SubModelModel'),
+  mapArrayMap?: map[string][ map[string]string ] (name='MapArrayMap'),
+  mapArrayModel?: map[string][ M ] (name='MapArrayModel'),
 };
 
 model M = {