@darabonba/python-generator 2.0.1 → 2.0.3

package/tests/expected/model/tea_python_tests/{models.py → models/_my_model.py}

@@ -9,324 +9,19 @@ from darabonba.request import DaraRequest
 from typing import List, Dict, Any, BinaryIO
 
 
-
-
-class MSubM(DaraModel):
-    def __init__(self):
-        pass
-    def validate(self):
-        pass
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        return result
-
-    def from_map(self, m: dict = None):
-        m = m or dict()
-        return self
-
-class MainFileModelModel(DaraModel):
-    def __init__(
-        self, 
-        str: str = None,
-    ):
-        self.str = str
-
-    def validate(self):
-        self.validate_required(self.str, 'str')
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        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
-
-class MainFileModel(DaraModel):
-    def __init__(
-        self, 
-        str: str = None,
-        model: MainFileModelModel = None,
-    ):
-        self.str = str
-        self.model = model
-
-    def validate(self):
-        self.validate_required(self.str, 'str')
-        self.validate_required(self.model, 'model')
-        if self.model:
-            self.model.validate()
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        if self.str is not None:
-            result['str'] = self.str
-        if self.model is not None:
-            result['model'] = self.model.to_map()
-
-        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')
-        if m.get('model') is not None:
-            temp_model = MainFileModelModel
-            self.model = temp_model.from_map(m.get('model'))
-
-        return self
-
-class MyModelModelModel(DaraModel):
-    def __init__(
-        self, 
-        str: str = None,
-    ):
-        self.str = str
-
-    def validate(self):
-        self.validate_required(self.str, 'str')
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        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
-
-class MyModelModel(DaraModel):
-    def __init__(
-        self, 
-        str: str = None,
-        model: MyModelModelModel = None,
-    ):
-        self.str = str
-        self.model = model
-
-    def validate(self):
-        self.validate_required(self.str, 'str')
-        self.validate_required(self.model, 'model')
-        if self.model:
-            self.model.validate()
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        if self.str is not None:
-            result['str'] = self.str
-        if self.model is not None:
-            result['model'] = self.model.to_map()
-
-        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')
-        if m.get('model') is not None:
-            temp_model = MyModelModelModel
-            self.model = temp_model.from_map(m.get('model'))
-
-        return self
-
-class MyModelSubmodelModel(DaraModel):
-    def __init__(
-        self, 
-        str: str = None,
-    ):
-        self.str = str
-
-    def validate(self):
-        self.validate_required(self.str, 'str')
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        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
-
-class MyModelSubmodel(DaraModel):
-    def __init__(
-        self, 
-        stringfield: str = None,
-        model: MyModelSubmodelModel = None,
-    ):
-        self.stringfield = stringfield
-        self.model = model
-
-    def validate(self):
-        self.validate_required(self.stringfield, 'stringfield')
-        self.validate_required(self.model, 'model')
-        if self.model:
-            self.model.validate()
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        if self.stringfield is not None:
-            result['stringfield'] = self.stringfield
-        if self.model is not None:
-            result['model'] = self.model.to_map()
-
-        return result
-
-    def from_map(self, m: dict = None):
-        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 = MyModelSubmodelModel
-            self.model = temp_model.from_map(m.get('model'))
-
-        return self
-
-class MyModelSubarraymodel(DaraModel):
-    def __init__(self):
-        pass
-    def validate(self):
-        pass
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        return result
-
-    def from_map(self, m: dict = None):
-        m = m or dict()
-        return self
-
-class M(DaraModel):
-    def __init__(
-        self, 
-        sub_m: MSubM = None,
-    ):
-        self.sub_m = sub_m
-
-    def validate(self):
-        self.validate_required(self.sub_m, 'sub_m')
-        if self.sub_m:
-            self.sub_m.validate()
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        if self.sub_m is not None:
-            result['subM'] = self.sub_m.to_map()
-
-        return result
-
-    def from_map(self, m: dict = None):
-        m = m or dict()
-        if m.get('subM') is not None:
-            temp_model = MSub_m
-            self.sub_m = temp_model.from_map(m.get('subM'))
-
-        return self
-
-class Class(DaraModel):
-    def __init__(self):
-        pass
-    def validate(self):
-        pass
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        return result
-
-    def from_map(self, m: dict = None):
-        m = m or dict()
-        return self
-
-class Model(DaraModel):
-    def __init__(
-        self, 
-        str: str = None,
-    ):
-        self.str = str
-
-    def validate(self):
-        self.validate_required(self.str, 'str')
-
-    def to_map(self):
-        _map = super().to_map()
-        if _map is not None:
-            return _map
-
-        result = dict()
-        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
-
 class MyModel(DaraModel):
     def __init__(
-        self, 
-        model: MyModelModel = None,
+        self, *,
+        model: main_models.MyModelModel = None,
         stringfield: str = None,
         bytesfield: bytes = None,
         stringarrayfield: List[str] = None,
         mapfield: Dict[str, str] = None,
         name: str = None,
-        submodel: MyModelSubmodel = None,
+        submodel: main_models.MyModelSubmodel = None,
         submodel_map: Dict[str, main_models.MyModelSubmodel] = None,
         map_model: Dict[str, main_models.M] = None,
-        subarraymodel: List[MyModelSubarraymodel] = None,
+        subarraymodel: List[main_models.MyModelSubarraymodel] = None,
         subarray: List[main_models.M] = None,
         ssubarray: List[List[main_models.M]] = None,
         ssubmarray: List[List[SourceClient]] = None,
@@ -520,57 +215,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 +255,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 +319,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 = main_models.MyModelModel()
             self.model = temp_model.from_map(m.get('model'))
 
         if m.get('stringfield') is not None:
@@ -659,44 +333,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 = main_models.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 = main_models.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 = main_models.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 = main_models.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 = main_models.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 = main_models.M()
+                    self.ssubarray.append(temp_model.from_map(k2))
 
         if m.get('ssubmarray') is not None:
             self.ssubmarray = m.get('ssubmarray')
@@ -704,12 +378,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 = source_models.Request()
+                    self.ssubmmarray.append(temp_model.from_map(k2))
 
         if m.get('maparray') is not None:
             self.maparray = m.get('maparray')
@@ -718,17 +391,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 = source_models.Request()
+                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 = main_models.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 = 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')
@@ -739,10 +415,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 = main_models.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/model/tea_python_tests/models/_my_model_model.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+# This file is auto-generated, don't edit it. Thanks.
+from __future__ import annotations
+from darabonba.model import DaraModel 
+from tea_python_tests import models as main_models 
+
+
+class MyModelModel(DaraModel):
+    def __init__(
+        self, *,
+        str: str = None,
+        model: main_models.MyModelModelModel = None,
+    ):
+        self.str = str
+        self.model = model
+
+    def validate(self):
+        self.validate_required(self.str, 'str')
+        self.validate_required(self.model, 'model')
+        if self.model:
+            self.model.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.str is not None:
+            result['str'] = self.str
+        if self.model is not None:
+            result['model'] = self.model.to_map()
+
+        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')
+        if m.get('model') is not None:
+            temp_model = main_models.MyModelModelModel()
+            self.model = temp_model.from_map(m.get('model'))
+
+        return self
+

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

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+# This file is auto-generated, don't edit it. Thanks.
+from __future__ import annotations
+from darabonba.model import DaraModel 
+
+
+class MyModelModelModel(DaraModel):
+    def __init__(
+        self, *,
+        str: str = None,
+    ):
+        self.str = str
+
+    def validate(self):
+        self.validate_required(self.str, 'str')
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        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

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+# This file is auto-generated, don't edit it. Thanks.
+from __future__ import annotations
+from darabonba.model import DaraModel 
+
+
+class MyModelSubarraymodel(DaraModel):
+    def __init__(self):
+        pass
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        return self
+

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

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+# This file is auto-generated, don't edit it. Thanks.
+from __future__ import annotations
+from darabonba.model import DaraModel 
+from tea_python_tests import models as main_models 
+
+
+class MyModelSubmodel(DaraModel):
+    def __init__(
+        self, *,
+        stringfield: str = None,
+        model: main_models.MyModelSubmodelModel = None,
+    ):
+        self.stringfield = stringfield
+        self.model = model
+
+    def validate(self):
+        self.validate_required(self.stringfield, 'stringfield')
+        self.validate_required(self.model, 'model')
+        if self.model:
+            self.model.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.stringfield is not None:
+            result['stringfield'] = self.stringfield
+        if self.model is not None:
+            result['model'] = self.model.to_map()
+
+        return result
+
+    def from_map(self, m: dict = None):
+        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'))
+
+        return self
+