Adds XSchemaDict constructor using named arguments

.circleci/config.yml

@@ -185,7 +185,7 @@ jobs:
           nodeNo: "3"
   node4:
     docker:
-      - image: fkrull/multi-python
+      - image: python:3.8
     working_directory: ~/OpenAPITools/openapi-json-schema-generator
     shell: /bin/bash --login
     environment:

samples/client/3_0_3_unit_test/python/.openapi-generator/FILES

@@ -2084,6 +2084,7 @@ src/unit_test_api/py.typed
 src/unit_test_api/rest.py
 src/unit_test_api/schemas/__init__.py
 src/unit_test_api/schemas/format.py
+src/unit_test_api/schemas/original_immutabledict.py
 src/unit_test_api/schemas/schema.py
 src/unit_test_api/schemas/schemas.py
 src/unit_test_api/schemas/validation.py

samples/client/3_0_3_unit_test/python/src/unit_test_api/components/schema/additionalproperties_allows_a_schema_which_should_validate.py

@@ -30,6 +30,41 @@ class AdditionalpropertiesAllowsASchemaWhichShouldValidateDict(schemas.immutable
         "foo",
         "bar",
     })
+    @staticmethod
+    def from_dict_(
+        arg: AdditionalpropertiesAllowsASchemaWhichShouldValidateDictInput,
+        configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None
+    ) -> AdditionalpropertiesAllowsASchemaWhichShouldValidateDict:
+        return AdditionalpropertiesAllowsASchemaWhichShouldValidate.validate(arg, configuration=configuration)
+
+    def __new__(
+        cls,
+        *,
+        foo: typing.Union[
+            schemas.INPUT_TYPES_ALL,
+            schemas.OUTPUT_BASE_TYPES,
+            schemas.Unset
+        ] = schemas.unset,
+        bar: typing.Union[
+            schemas.INPUT_TYPES_ALL,
+            schemas.OUTPUT_BASE_TYPES,
+            schemas.Unset
+        ] = schemas.unset,
+        configuration_: typing.Optional[schema_configuration.SchemaConfiguration] = None,
+        **kwargs: bool,
+    ):
+        arg_: typing.Dict[str, typing.Any] = {}
+        for key, val in (
+            ("foo", foo),
+            ("bar", bar),
+        ):
+            if isinstance(val, schemas.Unset):
+                continue
+            arg_[key] = val
+        arg_.update(kwargs)
+        used_arg_ = typing.cast(AdditionalpropertiesAllowsASchemaWhichShouldValidateDictInput, arg_)
+        return AdditionalpropertiesAllowsASchemaWhichShouldValidate.validate(used_arg_, configuration=configuration_)
+
 
     @property
     def foo(self) -> typing.Union[schemas.OUTPUT_BASE_TYPES, schemas.Unset]:
@@ -60,45 +95,16 @@ def get_additional_property_(self, name: str) -> typing.Union[bool, schemas.Unse
             bool,
             val
         )
-
-    def __new__(cls, arg: AdditionalpropertiesAllowsASchemaWhichShouldValidateDictInput, configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None):
-        return AdditionalpropertiesAllowsASchemaWhichShouldValidate.validate(arg, configuration=configuration)
 AdditionalpropertiesAllowsASchemaWhichShouldValidateDictInput = typing.Mapping[
     str,
     typing.Union[
         typing.Union[
-            dict,
-            schemas.immutabledict,
-            str,
-            datetime.date,
-            datetime.datetime,
-            uuid.UUID,
-            int,
-            float,
-            bool,
-            None,
-            list,
-            tuple,
-            bytes,
-            io.FileIO,
-            io.BufferedReader
+            schemas.INPUT_TYPES_ALL,
+            schemas.OUTPUT_BASE_TYPES
         ],
         typing.Union[
-            dict,
-            schemas.immutabledict,
-            str,
-            datetime.date,
-            datetime.datetime,
-            uuid.UUID,
-            int,
-            float,
-            bool,
-            None,
-            list,
-            tuple,
-            bytes,
-            io.FileIO,
-            io.BufferedReader
+            schemas.INPUT_TYPES_ALL,
+            schemas.OUTPUT_BASE_TYPES
         ],
         bool,
     ]

samples/client/3_0_3_unit_test/python/src/unit_test_api/components/schema/additionalproperties_are_allowed_by_default.py

@@ -29,6 +29,41 @@ class AdditionalpropertiesAreAllowedByDefaultDict(schemas.immutabledict[str, sch
         "foo",
         "bar",
     })
+    @staticmethod
+    def from_dict_(
+        arg: AdditionalpropertiesAreAllowedByDefaultDictInput,
+        configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None
+    ) -> AdditionalpropertiesAreAllowedByDefaultDict:
+        return AdditionalpropertiesAreAllowedByDefault.validate(arg, configuration=configuration)
+
+    def __new__(
+        cls,
+        *,
+        foo: typing.Union[
+            schemas.INPUT_TYPES_ALL,
+            schemas.OUTPUT_BASE_TYPES,
+            schemas.Unset
+        ] = schemas.unset,
+        bar: typing.Union[
+            schemas.INPUT_TYPES_ALL,
+            schemas.OUTPUT_BASE_TYPES,
+            schemas.Unset
+        ] = schemas.unset,
+        configuration_: typing.Optional[schema_configuration.SchemaConfiguration] = None,
+        **kwargs: schemas.INPUT_TYPES_ALL,
+    ):
+        arg_: typing.Dict[str, typing.Any] = {}
+        for key, val in (
+            ("foo", foo),
+            ("bar", bar),
+        ):
+            if isinstance(val, schemas.Unset):
+                continue
+            arg_[key] = val
+        arg_.update(kwargs)
+        used_arg_ = typing.cast(AdditionalpropertiesAreAllowedByDefaultDictInput, arg_)
+        return AdditionalpropertiesAreAllowedByDefault.validate(used_arg_, configuration=configuration_)
+
 
     @property
     def foo(self) -> typing.Union[schemas.OUTPUT_BASE_TYPES, schemas.Unset]:
@@ -53,9 +88,6 @@ def bar(self) -> typing.Union[schemas.OUTPUT_BASE_TYPES, schemas.Unset]:
     def get_additional_property_(self, name: str) -> typing.Union[schemas.OUTPUT_BASE_TYPES, schemas.Unset]:
         schemas.raise_if_key_known(name, self.__required_keys__, self.__optional_keys__)
         return self.get(name, schemas.unset)
-
-    def __new__(cls, arg: AdditionalpropertiesAreAllowedByDefaultDictInput, configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None):
-        return AdditionalpropertiesAreAllowedByDefault.validate(arg, configuration=configuration)
 AdditionalpropertiesAreAllowedByDefaultDictInput = typing.Mapping[str, schemas.INPUT_TYPES_ALL]
 
 

samples/client/3_0_3_unit_test/python/src/unit_test_api/components/schema/additionalproperties_can_exist_by_itself.py

@@ -19,6 +19,21 @@ class AdditionalpropertiesCanExistByItselfDict(schemas.immutabledict[str, bool])
     })
     __optional_keys__: typing.FrozenSet[str] = frozenset({
     })
+    def __new__(
+        cls,
+        configuration_: typing.Optional[schema_configuration.SchemaConfiguration] = None,
+        **kwargs: bool,
+    ):
+        used_kwargs = typing.cast(AdditionalpropertiesCanExistByItselfDictInput, kwargs)
+        return AdditionalpropertiesCanExistByItself.validate(used_kwargs, configuration=configuration_)
+
+    @staticmethod
+    def from_dict_(
+        arg: AdditionalpropertiesCanExistByItselfDictInput,
+        configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None
+    ) -> AdditionalpropertiesCanExistByItselfDict:
+        return AdditionalpropertiesCanExistByItself.validate(arg, configuration=configuration)
+
 
     def get_additional_property_(self, name: str) -> typing.Union[bool, schemas.Unset]:
         schemas.raise_if_key_known(name, self.__required_keys__, self.__optional_keys__)
@@ -29,9 +44,6 @@ def get_additional_property_(self, name: str) -> typing.Union[bool, schemas.Unse
             bool,
             val
         )
-
-    def __new__(cls, arg: AdditionalpropertiesCanExistByItselfDictInput, configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None):
-        return AdditionalpropertiesCanExistByItself.validate(arg, configuration=configuration)
 AdditionalpropertiesCanExistByItselfDictInput = typing.Mapping[
     str,
     bool,

samples/client/3_0_3_unit_test/python/src/unit_test_api/components/schema/additionalproperties_should_not_look_in_applicators.py

@@ -27,6 +27,35 @@ class _0Dict(schemas.immutabledict[str, schemas.OUTPUT_BASE_TYPES]):
     __optional_keys__: typing.FrozenSet[str] = frozenset({
         "foo",
     })
+    @staticmethod
+    def from_dict_(
+        arg: _0DictInput,
+        configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None
+    ) -> _0Dict:
+        return _0.validate(arg, configuration=configuration)
+
+    def __new__(
+        cls,
+        *,
+        foo: typing.Union[
+            schemas.INPUT_TYPES_ALL,
+            schemas.OUTPUT_BASE_TYPES,
+            schemas.Unset
+        ] = schemas.unset,
+        configuration_: typing.Optional[schema_configuration.SchemaConfiguration] = None,
+        **kwargs: schemas.INPUT_TYPES_ALL,
+    ):
+        arg_: typing.Dict[str, typing.Any] = {}
+        for key, val in (
+            ("foo", foo),
+        ):
+            if isinstance(val, schemas.Unset):
+                continue
+            arg_[key] = val
+        arg_.update(kwargs)
+        used_arg_ = typing.cast(_0DictInput, arg_)
+        return _0.validate(used_arg_, configuration=configuration_)
+
 
     @property
     def foo(self) -> typing.Union[schemas.OUTPUT_BASE_TYPES, schemas.Unset]:
@@ -41,9 +70,6 @@ def foo(self) -> typing.Union[schemas.OUTPUT_BASE_TYPES, schemas.Unset]:
     def get_additional_property_(self, name: str) -> typing.Union[schemas.OUTPUT_BASE_TYPES, schemas.Unset]:
         schemas.raise_if_key_known(name, self.__required_keys__, self.__optional_keys__)
         return self.get(name, schemas.unset)
-
-    def __new__(cls, arg: _0DictInput, configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None):
-        return _0.validate(arg, configuration=configuration)
 _0DictInput = typing.Mapping[str, schemas.INPUT_TYPES_ALL]
 
 
@@ -73,6 +99,21 @@ class AdditionalpropertiesShouldNotLookInApplicatorsDict(schemas.immutabledict[s
     })
     __optional_keys__: typing.FrozenSet[str] = frozenset({
     })
+    def __new__(
+        cls,
+        configuration_: typing.Optional[schema_configuration.SchemaConfiguration] = None,
+        **kwargs: bool,
+    ):
+        used_kwargs = typing.cast(AdditionalpropertiesShouldNotLookInApplicatorsDictInput, kwargs)
+        return AdditionalpropertiesShouldNotLookInApplicators.validate(used_kwargs, configuration=configuration_)
+
+    @staticmethod
+    def from_dict_(
+        arg: AdditionalpropertiesShouldNotLookInApplicatorsDictInput,
+        configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None
+    ) -> AdditionalpropertiesShouldNotLookInApplicatorsDict:
+        return AdditionalpropertiesShouldNotLookInApplicators.validate(arg, configuration=configuration)
+
 
     def get_additional_property_(self, name: str) -> typing.Union[bool, schemas.Unset]:
         schemas.raise_if_key_known(name, self.__required_keys__, self.__optional_keys__)
@@ -83,9 +124,6 @@ def get_additional_property_(self, name: str) -> typing.Union[bool, schemas.Unse
             bool,
             val
         )
-
-    def __new__(cls, arg: AdditionalpropertiesShouldNotLookInApplicatorsDictInput, configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None):
-        return AdditionalpropertiesShouldNotLookInApplicators.validate(arg, configuration=configuration)
 AdditionalpropertiesShouldNotLookInApplicatorsDictInput = typing.Mapping[
     str,
     bool,

samples/client/3_0_3_unit_test/python/src/unit_test_api/components/schema/allof.py

@@ -26,6 +26,27 @@ class _0Dict(schemas.immutabledict[str, int]):
     })
     __optional_keys__: typing.FrozenSet[str] = frozenset({
     })
+    @staticmethod
+    def from_dict_(
+        arg: _0DictInput,
+        configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None
+    ) -> _0Dict:
+        return _0.validate(arg, configuration=configuration)
+
+    def __new__(
+        cls,
+        *,
+        bar: int,
+        configuration_: typing.Optional[schema_configuration.SchemaConfiguration] = None,
+        **kwargs: schemas.INPUT_TYPES_ALL,
+    ):
+        arg_: typing.Dict[str, typing.Any] = {
+            "bar": bar,
+        }
+        arg_.update(kwargs)
+        used_arg_ = typing.cast(_0DictInput, arg_)
+        return _0.validate(used_arg_, configuration=configuration_)
+
 
     @property
     def bar(self) -> int:
@@ -37,9 +58,6 @@ def bar(self) -> int:
     def get_additional_property_(self, name: str) -> typing.Union[schemas.OUTPUT_BASE_TYPES, schemas.Unset]:
         schemas.raise_if_key_known(name, self.__required_keys__, self.__optional_keys__)
         return self.get(name, schemas.unset)
-
-    def __new__(cls, arg: _0DictInput, configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None):
-        return _0.validate(arg, configuration=configuration)
 _0DictInput = typing.Mapping[str, schemas.INPUT_TYPES_ALL]
 
 
@@ -77,6 +95,27 @@ class _1Dict(schemas.immutabledict[str, str]):
     })
     __optional_keys__: typing.FrozenSet[str] = frozenset({
     })
+    @staticmethod
+    def from_dict_(
+        arg: _1DictInput,
+        configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None
+    ) -> _1Dict:
+        return _1.validate(arg, configuration=configuration)
+
+    def __new__(
+        cls,
+        *,
+        foo: str,
+        configuration_: typing.Optional[schema_configuration.SchemaConfiguration] = None,
+        **kwargs: schemas.INPUT_TYPES_ALL,
+    ):
+        arg_: typing.Dict[str, typing.Any] = {
+            "foo": foo,
+        }
+        arg_.update(kwargs)
+        used_arg_ = typing.cast(_1DictInput, arg_)
+        return _1.validate(used_arg_, configuration=configuration_)
+
 
     @property
     def foo(self) -> str:
@@ -88,9 +127,6 @@ def foo(self) -> str:
     def get_additional_property_(self, name: str) -> typing.Union[schemas.OUTPUT_BASE_TYPES, schemas.Unset]:
         schemas.raise_if_key_known(name, self.__required_keys__, self.__optional_keys__)
         return self.get(name, schemas.unset)
-
-    def __new__(cls, arg: _1DictInput, configuration: typing.Optional[schema_configuration.SchemaConfiguration] = None):
-        return _1.validate(arg, configuration=configuration)
 _1DictInput = typing.Mapping[str, schemas.INPUT_TYPES_ALL]