@autorest/python 5.15.0 → 5.16.0

package/ChangeLog.md

@@ -1,5 +1,24 @@
 # Change Log
 
+### 2022-04-18 - 5.16.0
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.6.2`     |
+| `@autorest/modelerfour`                                                 | `4.19.1`    |
+| `azure-core` dep of generated code                                      | `1.23.0`    |
+| `msrest` dep of generated code                                          | `0.6.21`    |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`     |
+
+**Breaking Changes in Version Tolerant Generation**
+
+- We no longer generate operations for operations with multipart or urlencoded bodies. SDK writers must implement these operations in their customized patch file. See https://aka.ms/azsdk/python/dpcodegen/python/customize for how to customize generated code #1223
+
+**Bug Fixes**
+
+- Drop package dependency on "@azure-tools/extension", switch to "@autorest/system-requirements" #1229
+- Fix `content_type` generation in multiapi SDKs with multiple content types for bodies #1232
+
 ### 2022-04-07 - 5.15.0
 
 | Library                                                                 | Min Version |
@@ -15,6 +34,7 @@
 - Add support for security configurations in the swagger. For more information, see https://github.com/Azure/autorest/blob/main/docs/generate/authentication.md #1161
 - Add support for handwritten customizations of generated code. For more information, see https://aka.ms/azsdk/python/dpcodegen/python/customize #1153
 - Allow `header` and `params` as kwargs in operation and request-build function to hand over REST Header and Query parameters case insensitively #1183
+- Typing operation parameters as JSON, Primitives or Any for `--version-tolerant` #1210
 
 **Bug Fixes**
 

package/autorest/__init__.py

@@ -38,8 +38,7 @@ class Plugin(ABC):
 
 
 class YamlUpdatePlugin(Plugin):
-    """A plugin that update the YAML as input.
-    """
+    """A plugin that update the YAML as input."""
 
     def process(self) -> bool:
         # List the input file, should be only one

package/autorest/black/__init__.py

@@ -15,20 +15,25 @@ _LOGGER = logging.getLogger(__name__)
 _BLACK_MODE = black.Mode()
 _BLACK_MODE.line_length = 120
 
-class BlackScriptPlugin(Plugin):
 
+class BlackScriptPlugin(Plugin):
     def __init__(self, autorestapi):
-        super(BlackScriptPlugin, self).__init__(autorestapi)
+        super().__init__(autorestapi)
         output_folder_uri = self._autorestapi.get_value("outputFolderUri")
         if output_folder_uri.startswith("file:"):
             output_folder_uri = output_folder_uri[5:]
-        if os.name == 'nt' and output_folder_uri.startswith("///"):
+        if os.name == "nt" and output_folder_uri.startswith("///"):
             output_folder_uri = output_folder_uri[3:]
         self.output_folder = Path(output_folder_uri)
 
     def process(self) -> bool:
         # apply format_file on every file in the output folder
-        list(map(self.format_file, [f for f in self.output_folder.glob('**/*') if f.is_file()]))
+        list(
+            map(
+                self.format_file,
+                [f for f in self.output_folder.glob("**/*") if f.is_file()],
+            )
+        )
         return True
 
     def format_file(self, full_path) -> None:
@@ -38,7 +43,9 @@ class BlackScriptPlugin(Plugin):
             self._autorestapi.write_file(file, file_content)
             return
         try:
-            file_content = black.format_file_contents(file_content, fast=True, mode=_BLACK_MODE)
+            file_content = black.format_file_contents(
+                file_content, fast=True, mode=_BLACK_MODE
+            )
         except black.NothingChanged:
             pass
         self._autorestapi.write_file(file, file_content)

package/autorest/codegen/__init__.py

@@ -5,30 +5,37 @@
 # --------------------------------------------------------------------------
 import logging
 import sys
-from typing import Dict, Any, Set, Union, List, Type
+from typing import Dict, Any, Union, Type
 from pathlib import Path
 import yaml
 
 from .. import Plugin
 from .models.code_model import CodeModel
-from .models import build_schema
+from .models import build_schema, RequestBuilder
 from .models.operation_group import OperationGroup
 from .models.parameter import Parameter
 from .models.parameter_list import GlobalParameterList
-from .models.rest import Rest
 from .serializers import JinjaSerializer
-from .models.credential_schema_policy import CredentialSchemaPolicy, get_credential_schema_policy_type
-from .models.credential_schema_policy import BearerTokenCredentialPolicy, AzureKeyCredentialPolicy
+from .models.credential_schema_policy import (
+    CredentialSchemaPolicy,
+    get_credential_schema_policy_type,
+)
+from .models.credential_schema_policy import (
+    BearerTokenCredentialPolicy,
+    AzureKeyCredentialPolicy,
+)
 from .models.credential_model import CredentialModel
 
 _AAD_TYPE = "AADToken"
 _KEY_TYPE = "AzureKey"
 
+
 def _build_convenience_layer(yaml_data: Dict[str, Any], code_model: CodeModel) -> None:
     # Create operations
     if code_model.options["show_operations"] and yaml_data.get("operationGroups"):
         code_model.operation_groups = [
-            OperationGroup.from_yaml(code_model, op_group) for op_group in yaml_data["operationGroups"]
+            OperationGroup.from_yaml(op_group, code_model)
+            for op_group in yaml_data["operationGroups"]
         ]
     if yaml_data.get("schemas"):
         code_model.add_inheritance_to_models()
@@ -42,6 +49,7 @@ def _build_convenience_layer(yaml_data: Dict[str, Any], code_model: CodeModel) -
         code_model.format_lro_operations()
         code_model.remove_next_operation()
 
+
 def _validate_code_model_options(options: Dict[str, Any]) -> None:
 
     if options["builders_visibility"] not in ["public", "hidden", "embedded"]:
@@ -84,7 +92,10 @@ def _validate_code_model_options(options: Dict[str, Any]) -> None:
         )
 
     if options["package_mode"]:
-        if options["package_mode"] not in ("mgmtplane", "dataplane") and not Path(options["package_mode"]).exists():
+        if (
+            options["package_mode"] not in ("mgmtplane", "dataplane")
+            and not Path(options["package_mode"]).exists()
+        ):
             raise ValueError(
                 "--package-mode can only be 'mgmtplane' or 'dataplane' or directory which contains template files"
             )
@@ -101,7 +112,10 @@ def _validate_code_model_options(options: Dict[str, Any]) -> None:
             "We are working on creating a new multiapi SDK for version tolerant and it is not available yet."
         )
 
+
 _LOGGER = logging.getLogger(__name__)
+
+
 class CodeGenerator(Plugin):
     @staticmethod
     def remove_cloud_errors(yaml_data: Dict[str, Any]) -> None:
@@ -112,7 +126,11 @@ class CodeGenerator(Plugin):
                 i = 0
                 while i < len(operation["exceptions"]):
                     exception = operation["exceptions"][i]
-                    if exception.get("schema") and exception["schema"]["language"]["default"]["name"] == "CloudError":
+                    if (
+                        exception.get("schema")
+                        and exception["schema"]["language"]["default"]["name"]
+                        == "CloudError"
+                    ):
                         del operation["exceptions"][i]
                         i -= 1
                     i += 1
@@ -123,19 +141,6 @@ class CodeGenerator(Plugin):
                     del yaml_data["schemas"]["objects"][i]
                     break
 
-    @staticmethod
-    def _build_exceptions_set(yaml_data: List[Dict[str, Any]]) -> Set[int]:
-        exceptions_set = set()
-        for group in yaml_data:
-            for operation in group["operations"]:
-                if not operation.get("exceptions"):
-                    continue
-                for exception in operation["exceptions"]:
-                    if not exception.get("schema"):
-                        continue
-                    exceptions_set.add(id(exception["schema"]))
-        return exceptions_set
-
     @staticmethod
     def _build_package_dependency() -> Dict[str, str]:
         return {
@@ -145,7 +150,9 @@ class CodeGenerator(Plugin):
         }
 
     @staticmethod
-    def _build_with_security_definition(yaml_data: Dict[str, Any], credential_model: CredentialModel):
+    def _build_with_security_definition(
+        yaml_data: Dict[str, Any], credential_model: CredentialModel
+    ):
         security_yaml = yaml_data.get("security", {})
         if security_yaml.get("authenticationRequired"):
             for scheme in security_yaml.get("schemes"):
@@ -161,13 +168,17 @@ class CodeGenerator(Plugin):
             credential_model.policy_type = AzureKeyCredentialPolicy
 
     @staticmethod
-    def _build_credential_model(code_model: CodeModel, credential_model: CredentialModel):
+    def _build_credential_model(
+        code_model: CodeModel, credential_model: CredentialModel
+    ):
         if credential_model.policy_type:
             code_model.options["credential"] = True
             credential_model.build_authentication_policy()
             code_model.credential_model = credential_model
 
-    def _handle_credential_model(self, yaml_data: Dict[str, Any], code_model: CodeModel):
+    def _handle_credential_model(
+        self, yaml_data: Dict[str, Any], code_model: CodeModel
+    ):
         credential_model = CredentialModel(code_model.options["azure_arm"])
 
         # credential info with security definition will be overridded by credential flags
@@ -176,15 +187,19 @@ class CodeGenerator(Plugin):
 
         self._build_credential_model(code_model, credential_model)
 
-    def _create_code_model(self, yaml_data: Dict[str, Any], options: Dict[str, Union[str, bool]]) -> CodeModel:
+    def _create_code_model(
+        self, yaml_data: Dict[str, Any], options: Dict[str, Union[str, bool]]
+    ) -> CodeModel:
         # Create a code model
 
-        code_model = CodeModel(options=options)
+        code_model = CodeModel(yaml_data, options=options)
         self._handle_credential_model(yaml_data, code_model)
         code_model.module_name = yaml_data["info"]["python_title"]
         code_model.class_name = yaml_data["info"]["pascal_case_title"]
         code_model.description = (
-            yaml_data["info"]["description"] if yaml_data["info"].get("description") else ""
+            yaml_data["info"]["description"]
+            if yaml_data["info"].get("description")
+            else ""
         )
 
         # Get my namespace
@@ -195,23 +210,29 @@ class CodeGenerator(Plugin):
         code_model.namespace = namespace
 
         if yaml_data.get("schemas"):
-            exceptions_set = CodeGenerator._build_exceptions_set(yaml_data=yaml_data["operationGroups"])
-
             for type_list in yaml_data["schemas"].values():
                 for schema in type_list:
-                    build_schema(yaml_data=schema, exceptions_set=exceptions_set, code_model=code_model)
+                    build_schema(yaml_data=schema, code_model=code_model)
 
         # Global parameters
         code_model.global_parameters = GlobalParameterList(
             code_model,
-            [Parameter.from_yaml(param, code_model=code_model) for param in yaml_data.get("globalParameters", [])],
+            [
+                Parameter.from_yaml(param, code_model=code_model)
+                for param in yaml_data.get("globalParameters", [])
+            ],
         )
-        code_model.global_parameters.code_model = code_model
 
         # Custom URL
         code_model.setup_client_input_parameters(yaml_data)
 
-        code_model.rest = Rest.from_yaml(yaml_data, code_model=code_model)
+        # Build request builders
+        if yaml_data.get("operationGroups"):
+            code_model.request_builders = [
+                RequestBuilder.from_yaml(operation_yaml, code_model=code_model)
+                for og_group in yaml_data["operationGroups"]
+                for operation_yaml in og_group["operations"]
+            ]
         _build_convenience_layer(yaml_data=yaml_data, code_model=code_model)
 
         if options["credential"]:
@@ -222,12 +243,19 @@ class CodeGenerator(Plugin):
 
     def _get_credential_scopes(self, credential):
         credential_scopes_temp = self._autorestapi.get_value("credential-scopes")
-        credential_scopes = credential_scopes_temp.split(",") if credential_scopes_temp else None
+        credential_scopes = (
+            credential_scopes_temp.split(",") if credential_scopes_temp else None
+        )
         if credential_scopes and not credential:
-            raise ValueError("--credential-scopes must be used with the --add-credential flag")
+            raise ValueError(
+                "--credential-scopes must be used with the --add-credential flag"
+            )
 
         # check to see if user just passes in --credential-scopes with no value
-        if self._autorestapi.get_boolean_value("credential-scopes", False) and not credential_scopes:
+        if (
+            self._autorestapi.get_boolean_value("credential-scopes", False)
+            and not credential_scopes
+        ):
             raise ValueError(
                 "--credential-scopes takes a list of scopes in comma separated format. "
                 "For example: --credential-scopes=https://cognitiveservices.azure.com/.default"
@@ -238,13 +266,17 @@ class CodeGenerator(Plugin):
         self,
         code_model: CodeModel,
         credential_schema_policy: Type[CredentialSchemaPolicy],
-        credential_model: CredentialModel
+        credential_model: CredentialModel,
     ):
         credential_model.policy_type = credential_schema_policy
-        credential_scopes = self._get_credential_scopes(code_model.options['credential'])
-        credential_key_header_name = self._autorestapi.get_value('credential-key-header-name')
-        azure_arm = code_model.options['azure_arm']
-        credential = code_model.options['credential']
+        credential_scopes = self._get_credential_scopes(
+            code_model.options["credential"]
+        )
+        credential_key_header_name = self._autorestapi.get_value(
+            "credential-key-header-name"
+        )
+        azure_arm = code_model.options["azure_arm"]
+        credential = code_model.options["credential"]
 
         if hasattr(credential_schema_policy, "credential_scopes"):
             if not credential_scopes:
@@ -258,7 +290,7 @@ class CodeGenerator(Plugin):
                         "but not the --credential-scopes flag set while generating non-management plane code. "
                         "This is not recommend because it forces the customer to pass credential scopes "
                         "through kwargs if they want to authenticate.",
-                        credential_schema_policy.name()
+                        credential_schema_policy.name(),
                     )
                     credential_scopes = []
 
@@ -287,84 +319,120 @@ class CodeGenerator(Plugin):
 
             credential_model.key_header_name = credential_key_header_name
 
-    def _build_with_credential_flags(self, code_model: CodeModel, credential_model: CredentialModel):
+    def _build_with_credential_flags(
+        self, code_model: CodeModel, credential_model: CredentialModel
+    ):
         if not code_model.options["credential"]:
             return
 
         credential_schema_policy_name = (
-            self._autorestapi.get_value("credential-default-policy-type") or
-            credential_model.default_authentication_policy.name()
+            self._autorestapi.get_value("credential-default-policy-type")
+            or credential_model.default_authentication_policy.name()
+        )
+        credential_schema_policy_type = get_credential_schema_policy_type(
+            credential_schema_policy_name
         )
-        credential_schema_policy_type = get_credential_schema_policy_type(credential_schema_policy_name)
         self._update_with_credential_flags(
             code_model, credential_schema_policy_type, credential_model
         )
 
     def _build_code_model_options(self) -> Dict[str, Any]:
-        """Build en options dict from the user input while running autorest.
-        """
+        """Build en options dict from the user input while running autorest."""
         azure_arm = self._autorestapi.get_boolean_value("azure-arm", False)
-        credential = (
-            self._autorestapi.get_boolean_value("add-credentials", False) or
-            self._autorestapi.get_boolean_value("add-credential", False)
-        )
+        credential = self._autorestapi.get_boolean_value(
+            "add-credentials", False
+        ) or self._autorestapi.get_boolean_value("add-credential", False)
 
         license_header = self._autorestapi.get_value("header-text")
         if license_header:
             license_header = license_header.replace("\n", "\n# ")
             license_header = (
-                "# --------------------------------------------------------------------------\n# " + license_header
+                "# --------------------------------------------------------------------------\n# "
+                + license_header
             )
             license_header += "\n# --------------------------------------------------------------------------"
 
-        low_level_client = self._autorestapi.get_boolean_value("low-level-client", False)
-        version_tolerant = self._autorestapi.get_boolean_value("version-tolerant", False)
-        show_operations = self._autorestapi.get_boolean_value("show-operations", not low_level_client)
-        models_mode_default = "none" if low_level_client or version_tolerant else "msrest"
-        python3_only = self._autorestapi.get_boolean_value("python3-only", low_level_client or version_tolerant)
+        low_level_client = self._autorestapi.get_boolean_value(
+            "low-level-client", False
+        )
+        version_tolerant = self._autorestapi.get_boolean_value(
+            "version-tolerant", False
+        )
+        show_operations = self._autorestapi.get_boolean_value(
+            "show-operations", not low_level_client
+        )
+        models_mode_default = (
+            "none" if low_level_client or version_tolerant else "msrest"
+        )
+        python3_only = self._autorestapi.get_boolean_value(
+            "python3-only", low_level_client or version_tolerant
+        )
 
         options: Dict[str, Any] = {
             "azure_arm": azure_arm,
             "credential": credential,
-            "head_as_boolean": self._autorestapi.get_boolean_value("head-as-boolean", False),
+            "head_as_boolean": self._autorestapi.get_boolean_value(
+                "head-as-boolean", False
+            ),
             "license_header": license_header,
-            "keep_version_file": self._autorestapi.get_boolean_value("keep-version-file", False),
+            "keep_version_file": self._autorestapi.get_boolean_value(
+                "keep-version-file", False
+            ),
             "no_async": self._autorestapi.get_boolean_value("no-async", False),
-            "no_namespace_folders": self._autorestapi.get_boolean_value("no-namespace-folders", False),
-            "basic_setup_py": self._autorestapi.get_boolean_value("basic-setup-py", False),
+            "no_namespace_folders": self._autorestapi.get_boolean_value(
+                "no-namespace-folders", False
+            ),
+            "basic_setup_py": self._autorestapi.get_boolean_value(
+                "basic-setup-py", False
+            ),
             "package_name": self._autorestapi.get_value("package-name"),
             "package_version": self._autorestapi.get_value("package-version"),
-            "client_side_validation": self._autorestapi.get_boolean_value("client-side-validation", False),
+            "client_side_validation": self._autorestapi.get_boolean_value(
+                "client-side-validation", False
+            ),
             "tracing": self._autorestapi.get_boolean_value("trace", show_operations),
             "multiapi": self._autorestapi.get_boolean_value("multiapi", False),
-            "polymorphic_examples": self._autorestapi.get_value("polymorphic-examples") or 5,
-            "models_mode": (self._autorestapi.get_value("models-mode") or models_mode_default).lower(),
+            "polymorphic_examples": self._autorestapi.get_value("polymorphic-examples")
+            or 5,
+            "models_mode": (
+                self._autorestapi.get_value("models-mode") or models_mode_default
+            ).lower(),
             "builders_visibility": self._autorestapi.get_value("builders-visibility"),
             "show_operations": show_operations,
             "show_send_request": self._autorestapi.get_boolean_value(
                 "show-send-request", low_level_client or version_tolerant
             ),
             "only_path_and_body_params_positional": self._autorestapi.get_boolean_value(
-                "only-path-and-body-params-positional", low_level_client or version_tolerant
+                "only-path-and-body-params-positional",
+                low_level_client or version_tolerant,
             ),
             "add_python3_operation_files": self._autorestapi.get_boolean_value(
                 "add-python3-operation-files", python3_only and not low_level_client
             ),
             "version_tolerant": version_tolerant,
             "low_level_client": low_level_client,
-            "combine_operation_files": self._autorestapi.get_boolean_value("combine-operation-files", version_tolerant),
+            "combine_operation_files": self._autorestapi.get_boolean_value(
+                "combine-operation-files", version_tolerant
+            ),
             "python3_only": python3_only,
             "package_mode": self._autorestapi.get_value("package-mode"),
             "package_pprint_name": self._autorestapi.get_value("package-pprint-name"),
-            "package_configuration": self._autorestapi.get_value("package-configuration"),
+            "package_configuration": self._autorestapi.get_value(
+                "package-configuration"
+            ),
             "default_optional_constants_to_none": self._autorestapi.get_boolean_value(
-                "default-optional-constants-to-none", low_level_client or version_tolerant
+                "default-optional-constants-to-none",
+                low_level_client or version_tolerant,
+            ),
+            "reformat_next_link": self._autorestapi.get_boolean_value(
+                "reformat-next-link", not version_tolerant
             ),
-            "reformat_next_link": self._autorestapi.get_boolean_value("reformat-next-link", not version_tolerant)
         }
 
         if options["builders_visibility"] is None:
-            options["builders_visibility"] = "public" if low_level_client else "embedded"
+            options["builders_visibility"] = (
+                "public" if low_level_client else "embedded"
+            )
         else:
             options["builders_visibility"] = options["builders_visibility"].lower()
 
@@ -406,9 +474,13 @@ class CodeGenerator(Plugin):
 
 
 def main(yaml_model_file: str) -> None:
-    from ..jsonrpc.localapi import LocalAutorestAPI  # pylint: disable=import-outside-toplevel
+    from ..jsonrpc.localapi import (  # pylint: disable=import-outside-toplevel
+        LocalAutorestAPI,
+    )
 
-    code_generator = CodeGenerator(autorestapi=LocalAutorestAPI(reachable_files=[yaml_model_file]))
+    code_generator = CodeGenerator(
+        autorestapi=LocalAutorestAPI(reachable_files=[yaml_model_file])
+    )
     if not code_generator.process():
         raise SystemExit("Process didn't finish gracefully")
 

package/autorest/codegen/models/__init__.py

@@ -10,14 +10,24 @@ from .credential_schema import AzureKeyCredentialSchema, TokenCredentialSchema
 from .object_schema import ObjectSchema, get_object_schema, HiddenModelObjectSchema
 from .dictionary_schema import DictionarySchema
 from .list_schema import ListSchema
-from .primitive_schemas import get_primitive_schema, AnySchema, PrimitiveSchema, IOSchema
+from .primitive_schemas import (
+    get_primitive_schema,
+    AnySchema,
+    PrimitiveSchema,
+    IOSchema,
+)
 from .enum_schema import EnumSchema, HiddenModelEnumSchema, get_enum_schema
 from .base_schema import BaseSchema
 from .constant_schema import ConstantSchema
 from .imports import FileImport, ImportType, TypingSection
 from .lro_operation import LROOperation
 from .paging_operation import PagingOperation
-from .parameter import Parameter, ParameterStyle, ParameterLocation
+from .parameter import (
+    Parameter,
+    ParameterStyle,
+    ParameterLocation,
+    ParameterMethodLocation,
+)
 from .operation import Operation
 from .property import Property
 from .operation_group import OperationGroup
@@ -64,24 +74,23 @@ __all__ = [
     "ParameterStyle",
     "IOSchema",
     "GlobalParameterList",
+    "ParameterMethodLocation",
 ]
 
+
 def _generate_as_object_schema(yaml_data: Dict[str, Any]) -> bool:
     if (
-        yaml_data.get('properties') or
-        yaml_data.get('discriminator') or
-        yaml_data.get('parents') and yaml_data['parents'].get('immediate')
+        yaml_data.get("properties")
+        or yaml_data.get("discriminator")
+        or yaml_data.get("parents")
+        and yaml_data["parents"].get("immediate")
     ):
         return True
     return False
 
 
-def build_schema(yaml_data: Dict[str, Any], **kwargs) -> BaseSchema:
-    code_model = kwargs.get("code_model", None)
-    if not code_model:
-        raise ValueError("CodeModel not passed through kwargs")
+def build_schema(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseSchema:
     yaml_id = id(yaml_data)
-    namespace = code_model.namespace
     try:
         return code_model.lookup_schema(yaml_id)
     except KeyError:
@@ -90,33 +99,35 @@ def build_schema(yaml_data: Dict[str, Any], **kwargs) -> BaseSchema:
     schema: BaseSchema
     schema_type = yaml_data["type"]
     if schema_type == "constant":
-        schema = ConstantSchema.from_yaml(namespace=namespace, yaml_data=yaml_data)
+        schema = ConstantSchema.from_yaml(yaml_data=yaml_data, code_model=code_model)
         code_model.primitives[yaml_id] = schema
 
     elif schema_type in ["choice", "sealed-choice"]:
-        schema = get_enum_schema(code_model).from_yaml(namespace=namespace, yaml_data=yaml_data, **kwargs)
+        schema = get_enum_schema(code_model).from_yaml(
+            yaml_data=yaml_data, code_model=code_model
+        )
         code_model.enums[yaml_id] = schema
 
     elif schema_type == "array":
-        schema = ListSchema.from_yaml(namespace=namespace, yaml_data=yaml_data, **kwargs)
+        schema = ListSchema.from_yaml(yaml_data=yaml_data, code_model=code_model)
         code_model.primitives[yaml_id] = schema
 
     elif schema_type == "dictionary":
-        schema = DictionarySchema.from_yaml(namespace=namespace, yaml_data=yaml_data, **kwargs)
+        schema = DictionarySchema.from_yaml(yaml_data=yaml_data, code_model=code_model)
         code_model.primitives[yaml_id] = schema
 
     elif schema_type in ["object", "and", "group", "any-object"]:
         if _generate_as_object_schema(yaml_data):
             # To avoid infinite loop, create the right instance in memory,
             # put it in the index, and then parse the object.
-            schema = get_object_schema(code_model)(namespace, yaml_data, "_", "")
+            schema = get_object_schema(code_model)(yaml_data, code_model, "_", "")
             code_model.schemas[yaml_id] = schema
-            schema.fill_instance_from_yaml(namespace=namespace, yaml_data=yaml_data, **kwargs)
+            schema.fill_instance_from_yaml(yaml_data=yaml_data, code_model=code_model)
         else:
-            schema = AnySchema.from_yaml(namespace=namespace, yaml_data=yaml_data)
+            schema = AnySchema.from_yaml(yaml_data=yaml_data, code_model=code_model)
             code_model.primitives[yaml_id] = schema
     else:
-        schema = get_primitive_schema(namespace=namespace, yaml_data=yaml_data)
+        schema = get_primitive_schema(yaml_data=yaml_data, code_model=code_model)
         code_model.primitives[yaml_id] = schema
 
     return schema