@darabonba/python-generator 2.0.4 → 2.0.6

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

@@ -11,7 +11,7 @@ from typing import List, Dict, Any, BinaryIO
 
 class MyModel(DaraModel):
     def __init__(
-        self, *,
+        self,
         model: main_models.MyModelModel = None,
         stringfield: str = None,
         bytesfield: bytes = None,
@@ -25,10 +25,14 @@ class MyModel(DaraModel):
         subarray: List[main_models.M] = None,
         ssubarray: List[List[main_models.M]] = None,
         ssubmarray: List[List[SourceClient]] = None,
+        sssubmarray: List[List[SourceClient]] = None,
         ssubmmarray: List[List[source_models.Request]] = None,
+        sssubmmarray: List[List[List[source_models.Request]]] = None,
         maparray: List[Dict[str, Any]] = None,
         mapsubmarray: List[Dict[str, SourceClient]] = None,
         module_model_map: Dict[str, source_models.Request] = None,
+        arr_module_model_map: List[Dict[str, source_models.Request]] = None,
+        arrs_module_model_map: List[List[Dict[str, source_models.Request]]] = None,
         sub_model_map: Dict[str, main_models.MSubM] = None,
         model_map: Dict[str, main_models.M] = None,
         module_map: Dict[str, SourceClient] = None,
@@ -67,10 +71,14 @@ class MyModel(DaraModel):
         self.subarray = subarray
         self.ssubarray = ssubarray
         self.ssubmarray = ssubmarray
+        self.sssubmarray = sssubmarray
         self.ssubmmarray = ssubmmarray
+        self.sssubmmarray = sssubmmarray
         self.maparray = maparray
         self.mapsubmarray = mapsubmarray
         self.module_model_map = module_model_map
+        self.arr_module_model_map = arr_module_model_map
+        self.arrs_module_model_map = arrs_module_model_map
         self.sub_model_map = sub_model_map
         self.model_map = model_map
         self.module_map = module_map
@@ -110,64 +118,76 @@ class MyModel(DaraModel):
             self.submodel.validate()
         self.validate_required(self.submodel_map, 'submodel_map')
         if self.submodel_map:
-            for v in self.submodel_map.values():
-                if v:
-                    v.validate()
+            for v1 in self.submodel_map.values():
+                 if v1:
+                    v1.validate()
         self.validate_required(self.map_model, 'map_model')
         if self.map_model:
-            for v in self.map_model.values():
-                if v:
-                    v.validate()
+            for v1 in self.map_model.values():
+                 if v1:
+                    v1.validate()
         self.validate_required(self.subarraymodel, 'subarraymodel')
         if self.subarraymodel:
-            for k in self.subarraymodel:
-                if k:
-                    k.validate()
+            for v1 in self.subarraymodel:
+                 if v1:
+                    v1.validate()
         self.validate_required(self.subarray, 'subarray')
         if self.subarray:
-            for k in self.subarray:
-                if k:
-                    k.validate()
+            for v1 in self.subarray:
+                 if v1:
+                    v1.validate()
         self.validate_required(self.ssubarray, 'ssubarray')
         if self.ssubarray:
-            for k in self.ssubarray:
-                for k1 in k:
-                    if k1:
-                        k1.validate()
+            for v1 in self.ssubarray:
+                for v2 in v1:
+                     if v2:
+                        v2.validate()
         self.validate_required(self.ssubmarray, 'ssubmarray')
-        if self.ssubmarray:
-            for k in self.ssubmarray:
-                for k1 in k:
-                    if k1:
-                        k1.validate()
+        self.validate_required(self.sssubmarray, 'sssubmarray')
         self.validate_required(self.ssubmmarray, 'ssubmmarray')
         if self.ssubmmarray:
-            for k in self.ssubmmarray:
-                for k1 in k:
-                    if k1:
-                        k1.validate()
+            for v1 in self.ssubmmarray:
+                for v2 in v1:
+                     if v2:
+                        v2.validate()
+        self.validate_required(self.sssubmmarray, 'sssubmmarray')
+        if self.sssubmmarray:
+            for v1 in self.sssubmmarray:
+                for v2 in v1:
+                    for v2 in v2:
+                         if v2:
+                            v2.validate()
         self.validate_required(self.maparray, 'maparray')
         self.validate_required(self.mapsubmarray, 'mapsubmarray')
         self.validate_required(self.module_model_map, 'module_model_map')
         if self.module_model_map:
-            for v in self.module_model_map.values():
-                if v:
-                    v.validate()
+            for v1 in self.module_model_map.values():
+                 if v1:
+                    v1.validate()
+        self.validate_required(self.arr_module_model_map, 'arr_module_model_map')
+        if self.arr_module_model_map:
+            for v1 in self.arr_module_model_map:
+                for v2 in self.arr_module_model_map.values():
+                     if v2:
+                        v2.validate()
+        self.validate_required(self.arrs_module_model_map, 'arrs_module_model_map')
+        if self.arrs_module_model_map:
+            for v1 in self.arrs_module_model_map:
+                for v2 in v1:
+                    for v2 in self.arrs_module_model_map.values():
+                         if v2:
+                            v2.validate()
         self.validate_required(self.sub_model_map, 'sub_model_map')
         if self.sub_model_map:
-            for v in self.sub_model_map.values():
-                if v:
-                    v.validate()
+            for v1 in self.sub_model_map.values():
+                 if v1:
+                    v1.validate()
         self.validate_required(self.model_map, 'model_map')
         if self.model_map:
-            for v in self.model_map.values():
-                if v:
-                    v.validate()
+            for v1 in self.model_map.values():
+                 if v1:
+                    v1.validate()
         self.validate_required(self.module_map, 'module_map')
-        if self.module_map:
-            for v in self.module_map.values():
-                if v:
-                    v.validate()
         self.validate_required(self.object, 'object')
         self.validate_required(self.readable, 'readable')
         self.validate_required(self.writable, 'writable')
@@ -192,90 +212,136 @@ class MyModel(DaraModel):
         self.validate_required(self.uint_64field, 'uint_64field')
 
     def to_map(self):
+        result = dict()
         _map = super().to_map()
         if _map is not None:
-            return _map
-
-        result = dict()
+            result = _map
         if self.model is not None:
             result['model'] = self.model.to_map()
 
         if self.stringfield is not None:
             result['stringfield'] = self.stringfield
+
         if self.bytesfield is not None:
             result['bytesfield'] = self.bytesfield
+
         if self.stringarrayfield is not None:
             result['stringarrayfield'] = self.stringarrayfield
+
         if self.mapfield is not None:
             result['mapfield'] = self.mapfield
+
         if self.name is not None:
             result['realName'] = self.name
+
         if self.submodel is not None:
             result['submodel'] = self.submodel.to_map()
 
+        result['submodelMap'] = {}
         if self.submodel_map is not None:
-            result['submodelMap'] = {}
             for k1, v1 in self.submodel_map.items():
                 result['submodelMap'][k1] = v1.to_map() if v1 else None
 
+        result['mapModel'] = {}
         if self.map_model is not None:
-            result['mapModel'] = {}
             for k1, v1 in self.map_model.items():
                 result['mapModel'][k1] = v1.to_map() if v1 else None
 
+        result['subarraymodel'] = []
         if self.subarraymodel is not None:
-            result['subarraymodel'] = []
             for k1 in self.subarraymodel:
                 result['subarraymodel'].append(k1.to_map() if k1 else None)
 
+        result['subarray'] = []
         if self.subarray is not None:
-            result['subarray'] = []
             for k1 in self.subarray:
                 result['subarray'].append(k1.to_map() if k1 else None)
 
+        result['ssubarray'] = []
         if self.ssubarray is not None:
-            result['ssubarray'] = []
             for k1 in self.ssubarray:
-                result['ssubarray'] = []
+                l1 = []
                 for k2 in k1:
-                    result['ssubarray'].append(k2.to_map() if k2 else None)
+                    l1.append(k2.to_map() if k2 else None)
+                result['ssubarray'].append(l1)
 
         if self.ssubmarray is not None:
             result['ssubmarray'] = self.ssubmarray
+
+        if self.sssubmarray is not None:
+            result['sssubmarray'] = self.sssubmarray
+
+        result['ssubmmarray'] = []
         if self.ssubmmarray is not None:
-            result['ssubmmarray'] = []
             for k1 in self.ssubmmarray:
-                result['ssubmmarray'] = []
+                l1 = []
+                for k2 in k1:
+                    l1.append(k2.to_map() if k2 else None)
+                result['ssubmmarray'].append(l1)
+
+        result['sssubmmarray'] = []
+        if self.sssubmmarray is not None:
+            for k1 in self.sssubmmarray:
+                l1 = []
                 for k2 in k1:
-                    result['ssubmmarray'].append(k2.to_map() if k2 else None)
+                    l2 = []
+                    for k3 in k2:
+                        l2.append(k3.to_map() if k3 else None)
+                    l1.append(l2)
+                result['sssubmmarray'].append(l1)
 
         if self.maparray is not None:
             result['maparray'] = self.maparray
+
         if self.mapsubmarray is not None:
             result['mapsubmarray'] = self.mapsubmarray
+
+        result['moduleModelMap'] = {}
         if self.module_model_map is not None:
-            result['moduleModelMap'] = {}
             for k1, v1 in self.module_model_map.items():
                 result['moduleModelMap'][k1] = v1.to_map() if v1 else None
 
+        result['arrModuleModelMap'] = []
+        if self.arr_module_model_map is not None:
+            for k1 in self.arr_module_model_map:
+                d1 = {}
+                for k2, v2 in self.arr_module_model_map.items():
+                    d1[k2] = v2.to_map() if v2 else None
+                result['arrModuleModelMap'].append(d1)
+
+        result['arrsModuleModelMap'] = []
+        if self.arrs_module_model_map is not None:
+            for k1 in self.arrs_module_model_map:
+                l1 = []
+                for k2 in k1:
+                    d2 = {}
+                    for k3, v3 in self.arrs_module_model_map.items():
+                        d2[k3] = v3.to_map() if v3 else None
+                    l1.append(d2)
+                result['arrsModuleModelMap'].append(l1)
+
+        result['subModelMap'] = {}
         if self.sub_model_map is not None:
-            result['subModelMap'] = {}
             for k1, v1 in self.sub_model_map.items():
                 result['subModelMap'][k1] = v1.to_map() if v1 else None
 
+        result['modelMap'] = {}
         if self.model_map is not None:
-            result['modelMap'] = {}
             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:
             result['object'] = self.object
+
         if self.readable is not None:
             result['readable'] = self.readable
+
         if self.writable is not None:
             result['writable'] = self.writable
+
         if self.exist_model is not None:
             result['existModel'] = self.exist_model.to_map()
 
@@ -284,36 +350,52 @@ class MyModel(DaraModel):
 
         if self.complex_list is not None:
             result['complexList'] = self.complex_list
+
         if self.numberfield is not None:
             result['numberfield'] = self.numberfield
+
         if self.integer_field is not None:
             result['integerField'] = self.integer_field
+
         if self.float_field is not None:
             result['floatField'] = self.float_field
+
         if self.double_field is not None:
             result['doubleField'] = self.double_field
+
         if self.long_field is not None:
             result['longField'] = self.long_field
+
         if self.ulong_field is not None:
             result['ulongField'] = self.ulong_field
+
         if self.int_8field is not None:
             result['int8Field'] = self.int_8field
+
         if self.int_16field is not None:
             result['int16Field'] = self.int_16field
+
         if self.int_32field is not None:
             result['int32Field'] = self.int_32field
+
         if self.int_64field is not None:
             result['int64Field'] = self.int_64field
+
         if self.uint_8field is not None:
             result['uint8Field'] = self.uint_8field
+
         if self.uint_16field is not None:
             result['uint16Field'] = self.uint_16field
+
         if self.uint_32field is not None:
             result['uint32Field'] = self.uint_32field
+
         if self.uint_64field is not None:
             result['uint64Field'] = self.uint_64field
+
         if self.link is not None:
             result['link'] = self.link
+
         return result
 
     def from_map(self, m: dict = None):
@@ -324,96 +406,140 @@ class MyModel(DaraModel):
 
         if m.get('stringfield') is not None:
             self.stringfield = m.get('stringfield')
+
         if m.get('bytesfield') is not None:
             self.bytesfield = m.get('bytesfield')
+
         if m.get('stringarrayfield') is not None:
             self.stringarrayfield = m.get('stringarrayfield')
+
         if m.get('mapfield') is not None:
             self.mapfield = m.get('mapfield')
+
         if m.get('realName') is not None:
             self.name = m.get('realName')
+
         if m.get('submodel') is not None:
             temp_model = main_models.MyModelSubmodel()
             self.submodel = temp_model.from_map(m.get('submodel'))
 
+        self.submodel_map = {}
         if m.get('submodelMap') is not None:
-            self.submodel_map = {}
             for k1, v1 in m.get('submodelMap').items():
                 temp_model = main_models.MyModelSubmodel()
                 self.submodel_map[k1] = temp_model.from_map(v1)
 
+        self.map_model = {}
         if m.get('mapModel') is not None:
-            self.map_model = {}
             for k1, v1 in m.get('mapModel').items():
                 temp_model = main_models.M()
                 self.map_model[k1] = temp_model.from_map(v1)
 
+        self.subarraymodel = []
         if m.get('subarraymodel') is not None:
-            l1 = 0
-            self.subarraymodel = []
             for k1 in m.get('subarraymodel'):
                 temp_model = main_models.MyModelSubarraymodel()
                 self.subarraymodel.append(temp_model.from_map(k1))
 
+        self.subarray = []
         if m.get('subarray') is not None:
-            l1 = 0
-            self.subarray = []
             for k1 in m.get('subarray'):
                 temp_model = main_models.M()
                 self.subarray.append(temp_model.from_map(k1))
 
+        self.ssubarray = []
         if m.get('ssubarray') is not None:
-            l1 = 0
-            self.ssubarray = []
             for k1 in m.get('ssubarray'):
-                l2 = 0
-                self.ssubarray = []
                 for k2 in k1:
+                    l1 = []
                     temp_model = main_models.M()
-                    self.ssubarray.append(temp_model.from_map(k2))
+                    l1.append(temp_model.from_map(k2))
+                self.ssubarray.append(l1)
 
         if m.get('ssubmarray') is not None:
             self.ssubmarray = m.get('ssubmarray')
+
+        if m.get('sssubmarray') is not None:
+            self.sssubmarray = m.get('sssubmarray')
+
+        self.ssubmmarray = []
         if m.get('ssubmmarray') is not None:
-            l1 = 0
-            self.ssubmmarray = []
             for k1 in m.get('ssubmmarray'):
-                l2 = 0
-                self.ssubmmarray = []
                 for k2 in k1:
+                    l1 = []
                     temp_model = source_models.Request()
-                    self.ssubmmarray.append(temp_model.from_map(k2))
+                    l1.append(temp_model.from_map(k2))
+                self.ssubmmarray.append(l1)
+
+        self.sssubmmarray = []
+        if m.get('sssubmmarray') is not None:
+            for k1 in m.get('sssubmmarray'):
+                for k2 in k1:
+                    l1 = []
+                    for k3 in k2:
+                        l2 = []
+                        temp_model = source_models.Request()
+                        l2.append(temp_model.from_map(k3))
+                    l1.append(l2)
+                self.sssubmmarray.append(l1)
 
         if m.get('maparray') is not None:
             self.maparray = m.get('maparray')
+
         if m.get('mapsubmarray') is not None:
             self.mapsubmarray = m.get('mapsubmarray')
+
+        self.module_model_map = {}
         if m.get('moduleModelMap') is not None:
-            self.module_model_map = {}
             for k1, v1 in m.get('moduleModelMap').items():
                 temp_model = source_models.Request()
                 self.module_model_map[k1] = temp_model.from_map(v1)
 
+        self.arr_module_model_map = []
+        if m.get('arrModuleModelMap') is not None:
+            for k1 in m.get('arrModuleModelMap'):
+                for k2, v2 in k1.items():
+                    d1 = {}
+                    temp_model = source_models.Request()
+                    d1[k2] = temp_model.from_map(v2)
+                self.arr_module_model_map.append(d1)
+
+        self.arrs_module_model_map = []
+        if m.get('arrsModuleModelMap') is not None:
+            for k1 in m.get('arrsModuleModelMap'):
+                for k2 in k1:
+                    l1 = []
+                    for k3, v3 in k2.items():
+                        d2 = {}
+                        temp_model = source_models.Request()
+                        d2[k3] = temp_model.from_map(v3)
+                    l1.append(d2)
+                self.arrs_module_model_map.append(l1)
+
+        self.sub_model_map = {}
         if m.get('subModelMap') is not None:
-            self.sub_model_map = {}
             for k1, v1 in m.get('subModelMap').items():
                 temp_model = main_models.MSubM()
                 self.sub_model_map[k1] = temp_model.from_map(v1)
 
+        self.model_map = {}
         if m.get('modelMap') is not None:
-            self.model_map = {}
             for k1, v1 in m.get('modelMap').items():
                 temp_model = main_models.M()
                 self.model_map[k1] = temp_model.from_map(v1)
 
         if m.get('moduleMap') is not None:
             self.module_map = m.get('moduleMap')
+
         if m.get('object') is not None:
             self.object = m.get('object')
+
         if m.get('readable') is not None:
             self.readable = m.get('readable')
+
         if m.get('writable') is not None:
             self.writable = m.get('writable')
+
         if m.get('existModel') is not None:
             temp_model = main_models.M()
             self.exist_model = temp_model.from_map(m.get('existModel'))
@@ -424,35 +550,51 @@ class MyModel(DaraModel):
 
         if m.get('complexList') is not None:
             self.complex_list = m.get('complexList')
+
         if m.get('numberfield') is not None:
             self.numberfield = m.get('numberfield')
+
         if m.get('integerField') is not None:
             self.integer_field = m.get('integerField')
+
         if m.get('floatField') is not None:
             self.float_field = m.get('floatField')
+
         if m.get('doubleField') is not None:
             self.double_field = m.get('doubleField')
+
         if m.get('longField') is not None:
             self.long_field = m.get('longField')
+
         if m.get('ulongField') is not None:
             self.ulong_field = m.get('ulongField')
+
         if m.get('int8Field') is not None:
             self.int_8field = m.get('int8Field')
+
         if m.get('int16Field') is not None:
             self.int_16field = m.get('int16Field')
+
         if m.get('int32Field') is not None:
             self.int_32field = m.get('int32Field')
+
         if m.get('int64Field') is not None:
             self.int_64field = m.get('int64Field')
+
         if m.get('uint8Field') is not None:
             self.uint_8field = m.get('uint8Field')
+
         if m.get('uint16Field') is not None:
             self.uint_16field = m.get('uint16Field')
+
         if m.get('uint32Field') is not None:
             self.uint_32field = m.get('uint32Field')
+
         if m.get('uint64Field') is not None:
             self.uint_64field = m.get('uint64Field')
+
         if m.get('link') is not None:
             self.link = m.get('link')
+
         return self
 

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

@@ -7,7 +7,7 @@ from tea_python_tests import models as main_models
 
 class MyModelModel(DaraModel):
     def __init__(
-        self, *,
+        self,
         str: str = None,
         model: main_models.MyModelModelModel = None,
     ):
@@ -21,13 +21,13 @@ class MyModelModel(DaraModel):
             self.model.validate()
 
     def to_map(self):
+        result = dict()
         _map = super().to_map()
         if _map is not None:
-            return _map
-
-        result = dict()
+            result = _map
         if self.str is not None:
             result['str'] = self.str
+
         if self.model is not None:
             result['model'] = self.model.to_map()
 
@@ -37,6 +37,7 @@ class MyModelModel(DaraModel):
         m = m or dict()
         if m.get('str') is not None:
             self.str = m.get('str')
+
         if m.get('model') is not None:
             temp_model = main_models.MyModelModelModel()
             self.model = temp_model.from_map(m.get('model'))

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

@@ -6,7 +6,7 @@ from darabonba.model import DaraModel
 
 class MyModelModelModel(DaraModel):
     def __init__(
-        self, *,
+        self,
         str: str = None,
     ):
         self.str = str
@@ -15,18 +15,19 @@ class MyModelModelModel(DaraModel):
         self.validate_required(self.str, 'str')
 
     def to_map(self):
+        result = dict()
         _map = super().to_map()
         if _map is not None:
-            return _map
-
-        result = dict()
+            result = _map
         if self.str is not None:
             result['str'] = self.str
+
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('str') is not None:
             self.str = m.get('str')
+
         return self
 

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

@@ -11,11 +11,10 @@ class MyModelSubarraymodel(DaraModel):
         pass
 
     def to_map(self):
+        result = dict()
         _map = super().to_map()
         if _map is not None:
-            return _map
-
-        result = dict()
+            result = _map
         return result
 
     def from_map(self, m: dict = None):

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

@@ -7,7 +7,7 @@ from tea_python_tests import models as main_models
 
 class MyModelSubmodel(DaraModel):
     def __init__(
-        self, *,
+        self,
         stringfield: str = None,
         model: main_models.MyModelSubmodelModel = None,
     ):
@@ -21,13 +21,13 @@ class MyModelSubmodel(DaraModel):
             self.model.validate()
 
     def to_map(self):
+        result = dict()
         _map = super().to_map()
         if _map is not None:
-            return _map
-
-        result = dict()
+            result = _map
         if self.stringfield is not None:
             result['stringfield'] = self.stringfield
+
         if self.model is not None:
             result['model'] = self.model.to_map()
 
@@ -37,6 +37,7 @@ class MyModelSubmodel(DaraModel):
         m = m or dict()
         if m.get('stringfield') is not None:
             self.stringfield = m.get('stringfield')
+
         if m.get('model') is not None:
             temp_model = main_models.MyModelSubmodelModel()
             self.model = temp_model.from_map(m.get('model'))