jentic-openapi-datamodels 1.0.0a18__py3-none-any.whl → 1.0.0a19__py3-none-any.whl

jentic/apitools/openapi/datamodels/low/v30/components.py

@@ -0,0 +1,236 @@
+from dataclasses import dataclass, field, replace
+
+from ruamel import yaml
+
+from ..context import Context
+from ..fields import fixed_field
+from ..sources import FieldSource, KeySource, ValueSource, YAMLInvalidValue, YAMLValue
+from .builders import build_field_source, build_model
+from .callback import Callback
+from .example import Example, build_example_or_reference
+from .header import Header
+from .link import Link
+from .parameter import Parameter, build_parameter_or_reference
+from .reference import Reference
+from .request_body import RequestBody, build_request_body_or_reference
+from .response import Response, build_response_or_reference
+from .schema import Schema, build_schema_or_reference
+from .security_scheme import SecurityScheme, build_security_scheme_or_reference
+
+
+__all__ = ["Components", "build"]
+
+
+@dataclass(frozen=True, slots=True)
+class Components:
+    r"""
+    Components Object representation for OpenAPI 3.0.
+
+    Holds reusable objects for different aspects of the OAS. All objects defined within
+    the components object have no effect on the API unless they are explicitly referenced
+    from properties outside the components object.
+
+    All component keys MUST match the regex pattern: ^[a-zA-Z0-9\.\-_]+$
+    (Note: This is a validation concern and not enforced by this low-level model)
+
+    Attributes:
+        root_node: The top-level node representing the entire Components object in the original source file
+        schemas: Reusable Schema Objects or Reference Objects
+        responses: Reusable Response Objects or Reference Objects
+        parameters: Reusable Parameter Objects or Reference Objects
+        examples: Reusable Example Objects or Reference Objects
+        request_bodies: Reusable Request Body Objects or Reference Objects
+        headers: Reusable Header Objects or Reference Objects
+        security_schemes: Reusable Security Scheme Objects or Reference Objects
+        links: Reusable Link Objects or Reference Objects
+        callbacks: Reusable Callback Objects or Reference Objects
+        extensions: Specification extensions (x-* fields)
+    """
+
+    root_node: yaml.Node
+    schemas: FieldSource[dict[KeySource[str], Schema | Reference]] | None = fixed_field()
+    responses: FieldSource[dict[KeySource[str], Response | Reference]] | None = fixed_field()
+    parameters: FieldSource[dict[KeySource[str], Parameter | Reference]] | None = fixed_field()
+    examples: FieldSource[dict[KeySource[str], Example | Reference]] | None = fixed_field()
+    request_bodies: FieldSource[dict[KeySource[str], RequestBody | Reference]] | None = fixed_field(
+        metadata={"yaml_name": "requestBodies"}
+    )
+    headers: FieldSource[dict[KeySource[str], "Header | Reference"]] | None = fixed_field()
+    security_schemes: FieldSource[dict[KeySource[str], SecurityScheme | Reference]] | None = (
+        fixed_field(metadata={"yaml_name": "securitySchemes"})
+    )
+    links: FieldSource[dict[KeySource[str], "Link | Reference"]] | None = fixed_field()
+    callbacks: FieldSource[dict[KeySource[str], "Callback | Reference"]] | None = fixed_field()
+    extensions: dict[KeySource[str], ValueSource[YAMLValue]] = field(default_factory=dict)
+
+
+def build(
+    root: yaml.Node, context: Context | None = None
+) -> Components | ValueSource[YAMLInvalidValue]:
+    """
+    Build a Components object from a YAML node.
+
+    Preserves all source data as-is, regardless of type. This is a low-level/plumbing
+    model that provides complete source fidelity for inspection and validation.
+
+    Args:
+        root: The YAML node to parse (should be a MappingNode)
+        context: Optional parsing context. If None, a default context will be created.
+
+    Returns:
+        A Components object if the node is valid, or a ValueSource containing
+        the invalid data if the root is not a MappingNode (preserving the invalid data
+        and its source location for validation).
+
+    Example:
+        from ruamel.yaml import YAML
+        yaml = YAML()
+        root = yaml.compose('''
+        schemas:
+          User:
+            type: object
+            properties:
+              id:
+                type: integer
+              name:
+                type: string
+        responses:
+          NotFound:
+            description: Entity not found
+        ''')
+        components = build(root)
+        assert 'User' in {k.value for k in components.schemas.value.keys()}
+    """
+    context = context or Context()
+
+    # Use build_model for initial construction
+    components_obj = build_model(root, Components, context=context)
+
+    # If build_model returned ValueSource (invalid node), return it immediately
+    if not isinstance(components_obj, Components):
+        return components_obj
+
+    # Manually handle nested complex fields that aren't covered by build_model
+    replacements = {}
+    for key_node, value_node in root.value:
+        key = context.yaml_constructor.construct_yaml_str(key_node)
+
+        if key == "schemas":
+            # Handle schemas field - map of Schema or Reference objects
+            if isinstance(value_node, yaml.MappingNode):
+                schemas_dict = {}
+                for schema_key_node, schema_value_node in value_node.value:
+                    schema_key = context.yaml_constructor.construct_yaml_str(schema_key_node)
+                    schema_or_reference = build_schema_or_reference(schema_value_node, context)
+                    schemas_dict[KeySource(value=schema_key, key_node=schema_key_node)] = (
+                        schema_or_reference
+                    )
+                replacements["schemas"] = FieldSource(
+                    value=schemas_dict, key_node=key_node, value_node=value_node
+                )
+            else:
+                # Not a mapping - preserve as-is for validation
+                replacements["schemas"] = build_field_source(key_node, value_node, context)
+
+        elif key == "responses":
+            # Handle responses field - map of Response or Reference objects
+            if isinstance(value_node, yaml.MappingNode):
+                responses_dict = {}
+                for response_key_node, response_value_node in value_node.value:
+                    response_key = context.yaml_constructor.construct_yaml_str(response_key_node)
+                    response_or_reference = build_response_or_reference(
+                        response_value_node, context
+                    )
+                    responses_dict[KeySource(value=response_key, key_node=response_key_node)] = (
+                        response_or_reference
+                    )
+                replacements["responses"] = FieldSource(
+                    value=responses_dict, key_node=key_node, value_node=value_node
+                )
+            else:
+                # Not a mapping - preserve as-is for validation
+                replacements["responses"] = build_field_source(key_node, value_node, context)
+
+        elif key == "parameters":
+            # Handle parameters field - map of Parameter or Reference objects
+            if isinstance(value_node, yaml.MappingNode):
+                parameters_dict = {}
+                for parameter_key_node, parameter_value_node in value_node.value:
+                    parameter_key = context.yaml_constructor.construct_yaml_str(parameter_key_node)
+                    parameter_or_reference = build_parameter_or_reference(
+                        parameter_value_node, context
+                    )
+                    parameters_dict[KeySource(value=parameter_key, key_node=parameter_key_node)] = (
+                        parameter_or_reference
+                    )
+                replacements["parameters"] = FieldSource(
+                    value=parameters_dict, key_node=key_node, value_node=value_node
+                )
+            else:
+                # Not a mapping - preserve as-is for validation
+                replacements["parameters"] = build_field_source(key_node, value_node, context)
+
+        elif key == "examples":
+            # Handle examples field - map of Example or Reference objects
+            if isinstance(value_node, yaml.MappingNode):
+                examples_dict = {}
+                for example_key_node, example_value_node in value_node.value:
+                    example_key = context.yaml_constructor.construct_yaml_str(example_key_node)
+                    example_or_reference = build_example_or_reference(example_value_node, context)
+                    examples_dict[KeySource(value=example_key, key_node=example_key_node)] = (
+                        example_or_reference
+                    )
+                replacements["examples"] = FieldSource(
+                    value=examples_dict, key_node=key_node, value_node=value_node
+                )
+            else:
+                # Not a mapping - preserve as-is for validation
+                replacements["examples"] = build_field_source(key_node, value_node, context)
+
+        elif key == "requestBodies":
+            # Handle requestBodies field - map of RequestBody or Reference objects
+            if isinstance(value_node, yaml.MappingNode):
+                request_bodies_dict = {}
+                for request_body_key_node, request_body_value_node in value_node.value:
+                    request_body_key = context.yaml_constructor.construct_yaml_str(
+                        request_body_key_node
+                    )
+                    request_body_or_reference = build_request_body_or_reference(
+                        request_body_value_node, context
+                    )
+                    request_bodies_dict[
+                        KeySource(value=request_body_key, key_node=request_body_key_node)
+                    ] = request_body_or_reference
+                replacements["request_bodies"] = FieldSource(
+                    value=request_bodies_dict, key_node=key_node, value_node=value_node
+                )
+            else:
+                # Not a mapping - preserve as-is for validation
+                replacements["request_bodies"] = build_field_source(key_node, value_node, context)
+
+        elif key == "securitySchemes":
+            # Handle securitySchemes field - map of SecurityScheme or Reference objects
+            if isinstance(value_node, yaml.MappingNode):
+                security_schemes_dict = {}
+                for security_scheme_key_node, security_scheme_value_node in value_node.value:
+                    security_scheme_key = context.yaml_constructor.construct_yaml_str(
+                        security_scheme_key_node
+                    )
+                    security_scheme_or_reference = build_security_scheme_or_reference(
+                        security_scheme_value_node, context
+                    )
+                    security_schemes_dict[
+                        KeySource(value=security_scheme_key, key_node=security_scheme_key_node)
+                    ] = security_scheme_or_reference
+                replacements["security_schemes"] = FieldSource(
+                    value=security_schemes_dict, key_node=key_node, value_node=value_node
+                )
+            else:
+                # Not a mapping - preserve as-is for validation
+                replacements["security_schemes"] = build_field_source(key_node, value_node, context)
+
+    # Apply all replacements at once
+    if replacements:
+        components_obj = replace(components_obj, **replacements)
+
+    return components_obj

jentic/apitools/openapi/datamodels/low/v30/contact.py

@@ -2,16 +2,10 @@ from dataclasses import dataclass, field
 
 from ruamel import yaml
 
-from jentic.apitools.openapi.datamodels.low.context import Context
-from jentic.apitools.openapi.datamodels.low.fields import fixed_field
-from jentic.apitools.openapi.datamodels.low.model_builder import build_model
-from jentic.apitools.openapi.datamodels.low.sources import (
-    FieldSource,
-    KeySource,
-    ValueSource,
-    YAMLInvalidValue,
-    YAMLValue,
-)
+from ..context import Context
+from ..fields import fixed_field
+from ..sources import FieldSource, KeySource, ValueSource, YAMLInvalidValue, YAMLValue
+from .builders import build_model
 
 
 __all__ = ["Contact", "build"]

jentic/apitools/openapi/datamodels/low/v30/discriminator.py

@@ -2,15 +2,10 @@ from dataclasses import dataclass
 
 from ruamel import yaml
 
-from jentic.apitools.openapi.datamodels.low.context import Context
-from jentic.apitools.openapi.datamodels.low.fields import fixed_field
-from jentic.apitools.openapi.datamodels.low.model_builder import build_model
-from jentic.apitools.openapi.datamodels.low.sources import (
-    FieldSource,
-    KeySource,
-    ValueSource,
-    YAMLInvalidValue,
-)
+from ..context import Context
+from ..fields import fixed_field
+from ..sources import FieldSource, KeySource, ValueSource, YAMLInvalidValue
+from .builders import build_model
 
 
 __all__ = ["Discriminator", "build"]

jentic/apitools/openapi/datamodels/low/v30/encoding.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass, field
+
+from ruamel import yaml
+
+from ..context import Context
+from ..fields import fixed_field
+from ..sources import FieldSource, KeySource, ValueSource, YAMLInvalidValue, YAMLValue
+from .builders import build_model
+from .header import Header
+from .reference import Reference
+
+
+__all__ = ["Encoding", "build"]
+
+
+@dataclass(frozen=True, slots=True)
+class Encoding:
+    """
+    Encoding Object representation for OpenAPI 3.0.
+
+    A single encoding definition applied to a single schema property.
+
+    Attributes:
+        root_node: The top-level node representing the entire Encoding object in the original source file
+        contentType: The Content-Type for encoding a specific property. Default value depends on the property type:
+                     for string with format being binary – application/octet-stream;
+                     for other primitive types – text/plain;
+                     for object - application/json;
+                     for array – the default is defined based on the inner type.
+        headers: A map allowing additional information to be provided as headers. Content-Type is described
+                separately and SHALL be ignored if included.
+        style: Describes how a specific property value will be serialized depending on its type.
+        explode: When this is true, property values of type array or object generate separate parameters
+                for each value of the array, or key-value-pair of the map. For other data types this property
+                has no effect. Default value is true.
+        allowReserved: Determines whether the parameter value SHOULD allow reserved characters, as defined by
+                      RFC3986 :/?#[]@!$&'()*+,;= to be included without percent-encoding. The default value is false.
+        extensions: Specification extensions (x-* fields)
+    """
+
+    root_node: yaml.Node
+    contentType: FieldSource[str] | None = fixed_field()
+    headers: FieldSource[dict[KeySource[str], "Header | Reference"]] | None = fixed_field()
+    style: FieldSource[str] | None = fixed_field()
+    explode: FieldSource[bool] | None = fixed_field()
+    allowReserved: FieldSource[bool] | None = fixed_field()
+    extensions: dict[KeySource[str], ValueSource[YAMLValue]] = field(default_factory=dict)
+
+
+def build(
+    root: yaml.Node, context: Context | None = None
+) -> Encoding | ValueSource[YAMLInvalidValue]:
+    """
+    Build an Encoding object from a YAML node.
+
+    Preserves all source data as-is, regardless of type. This is a low-level/plumbing
+    model that provides complete source fidelity for inspection and validation.
+
+    Args:
+        root: The YAML node to parse (should be a MappingNode)
+        context: Optional parsing context. If None, a default context will be created.
+
+    Returns:
+        An Encoding object if the node is valid, or a ValueSource containing
+        the invalid data if the root is not a MappingNode (preserving the invalid data
+        and its source location for validation).
+
+    Example:
+        from ruamel.yaml import YAML
+        yaml = YAML()
+        root = yaml.compose('''
+        contentType: application/xml
+        headers:
+          X-Rate-Limit:
+            schema:
+              type: integer
+        ''')
+        encoding = build(root)
+        assert encoding.contentType.value == 'application/xml'
+    """
+    return build_model(root, Encoding, context=context)

jentic/apitools/openapi/datamodels/low/v30/example.py

@@ -0,0 +1,91 @@
+from dataclasses import dataclass, field
+
+from ruamel import yaml
+
+from ..context import Context
+from ..fields import fixed_field
+from ..sources import FieldSource, KeySource, ValueSource, YAMLInvalidValue, YAMLValue
+from .builders import build_model
+from .reference import Reference
+from .reference import build as build_reference
+
+
+__all__ = ["Example", "build", "build_example_or_reference"]
+
+
+@dataclass(frozen=True, slots=True)
+class Example:
+    """
+    Example Object representation for OpenAPI 3.0.
+
+    Attributes:
+        root_node: The top-level node representing the entire Example object in the original source file
+        summary: A short description of the example.
+        description: A long description for the example. CommonMark syntax MAY be used for rich text representation.
+        value: Embedded literal example. The value field and externalValue field are mutually exclusive.
+        external_value: A URL that points to the literal example. This provides the capability to reference
+                       examples that cannot be inlined. The value field and externalValue field are mutually exclusive.
+        extensions: Specification extensions (x-* fields)
+    """
+
+    root_node: yaml.Node
+    summary: FieldSource[str] | None = fixed_field()
+    description: FieldSource[str] | None = fixed_field()
+    value: FieldSource[YAMLValue] | None = fixed_field()
+    external_value: FieldSource[str] | None = fixed_field(metadata={"yaml_name": "externalValue"})
+    extensions: dict[KeySource[str], ValueSource[YAMLValue]] = field(default_factory=dict)
+
+
+def build(
+    root: yaml.Node, context: Context | None = None
+) -> Example | ValueSource[YAMLInvalidValue]:
+    """
+    Build an Example object from a YAML node.
+
+    Preserves all source data as-is, regardless of type. This is a low-level/plumbing
+    model that provides complete source fidelity for inspection and validation.
+
+    Args:
+        root: The YAML node to parse (should be a MappingNode)
+        context: Optional parsing context. If None, a default context will be created.
+
+    Returns:
+        An Example object if the node is valid, or a ValueSource containing
+        the invalid data if the root is not a MappingNode (preserving the invalid data
+        and its source location for validation).
+
+    Example:
+        from ruamel.yaml import YAML
+        yaml = YAML()
+        root = yaml.compose("summary: A user example\\nvalue:\\n  id: 1\\n  name: John")
+        example = build(root)
+        assert example.summary.value == 'A user example'
+    """
+    return build_model(root, Example, context=context)
+
+
+def build_example_or_reference(
+    node: yaml.Node, context: Context
+) -> Example | Reference | ValueSource[YAMLInvalidValue]:
+    """
+    Build either an Example or Reference from a YAML node.
+
+    This helper handles the polymorphic nature of OpenAPI where many fields
+    can contain either an Example object or a Reference object ($ref).
+
+    Args:
+        node: The YAML node to parse
+        context: Parsing context
+
+    Returns:
+        An Example, Reference, or ValueSource if the node is invalid
+    """
+    # Check if it's a reference (has $ref key)
+    if isinstance(node, yaml.MappingNode):
+        for key_node, _ in node.value:
+            key = context.yaml_constructor.construct_yaml_str(key_node)
+            if key == "$ref":
+                return build_reference(node, context)
+
+    # Otherwise, try to build as Example
+    return build(node, context)

jentic/apitools/openapi/datamodels/low/v30/external_documentation.py

@@ -2,16 +2,10 @@ from dataclasses import dataclass, field
 
 from ruamel import yaml
 
-from jentic.apitools.openapi.datamodels.low.context import Context
-from jentic.apitools.openapi.datamodels.low.fields import fixed_field
-from jentic.apitools.openapi.datamodels.low.model_builder import build_model
-from jentic.apitools.openapi.datamodels.low.sources import (
-    FieldSource,
-    KeySource,
-    ValueSource,
-    YAMLInvalidValue,
-    YAMLValue,
-)
+from ..context import Context
+from ..fields import fixed_field
+from ..sources import FieldSource, KeySource, ValueSource, YAMLInvalidValue, YAMLValue
+from .builders import build_model
 
 
 __all__ = ["ExternalDocumentation", "build"]

jentic/apitools/openapi/datamodels/low/v30/header.py

@@ -0,0 +1,120 @@
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from ruamel import yaml
+
+from ..context import Context
+from ..fields import fixed_field
+from ..sources import FieldSource, KeySource, ValueSource, YAMLInvalidValue, YAMLValue
+from .builders import build_model
+from .example import Example
+from .reference import Reference
+from .reference import build as build_reference
+from .schema import Schema
+
+
+if TYPE_CHECKING:
+    from .media_type import MediaType
+
+
+__all__ = ["Header", "build", "build_header_or_reference"]
+
+
+@dataclass(frozen=True, slots=True)
+class Header:
+    """
+    Header Object representation for OpenAPI 3.0.
+
+    The Header Object follows the structure of the Parameter Object, including determining its
+    serialization strategy based on whether schema or content is present, with the following changes:
+    - name MUST NOT be specified, it is given in the corresponding headers map.
+    - in MUST NOT be specified, it is implicitly in header.
+    - All traits that are affected by the location MUST be applicable to a location of header
+      (for example, style). This means that allowEmptyValue and allowReserved MUST NOT be used,
+      and style, if used, MUST be limited to "simple".
+
+    Attributes:
+        root_node: The top-level node representing the entire Header object in the original source file
+        description: A brief description of the header. CommonMark syntax MAY be used for rich text representation.
+        required: Determines whether this header is mandatory. Default value is false.
+        deprecated: Specifies that a header is deprecated and SHOULD be transitioned out of usage. Default value is false.
+        style: Describes how the header value will be serialized depending on the type of the header value.
+               If used, MUST be limited to "simple".
+        explode: When this is true, header values of type array or object generate separate parameters for each value of the array or key-value pair of the map. Default value is false.
+        schema: The schema defining the type used for the header.
+        example: Example of the header's potential value. The example SHOULD match the specified schema and encoding properties if present.
+        examples: Examples of the header's potential value. Each example SHOULD contain a value in the correct format as specified in the header encoding.
+        content: A map containing the representations for the header. The key is the media type and the value describes it.
+        extensions: Specification extensions (x-* fields)
+    """
+
+    root_node: yaml.Node
+    description: FieldSource[str] | None = fixed_field()
+    required: FieldSource[bool] | None = fixed_field()
+    deprecated: FieldSource[bool] | None = fixed_field()
+    style: FieldSource[str] | None = fixed_field()
+    explode: FieldSource[bool] | None = fixed_field()
+    schema: FieldSource["Schema | Reference"] | None = fixed_field()
+    example: FieldSource[YAMLValue] | None = fixed_field()
+    examples: FieldSource[dict[KeySource[str], "Example | Reference"]] | None = fixed_field()
+    content: FieldSource[dict[KeySource[str], "MediaType"]] | None = fixed_field()
+    extensions: dict[KeySource[str], ValueSource[YAMLValue]] = field(default_factory=dict)
+
+
+def build(
+    root: yaml.Node, context: Context | None = None
+) -> Header | ValueSource[YAMLInvalidValue]:
+    """
+    Build a Header object from a YAML node.
+
+    Preserves all source data as-is, regardless of type. This is a low-level/plumbing
+    model that provides complete source fidelity for inspection and validation.
+
+    Args:
+        root: The YAML node to parse (should be a MappingNode)
+        context: Optional parsing context. If None, a default context will be created.
+
+    Returns:
+        A Header object if the node is valid, or a ValueSource containing
+        the invalid data if the root is not a MappingNode (preserving the invalid data
+        and its source location for validation).
+
+    Example:
+        from ruamel.yaml import YAML
+        yaml = YAML()
+        root = yaml.compose('''
+        description: The number of allowed requests in the current period
+        schema:
+          type: integer
+        ''')
+        header = build(root)
+        assert header.description.value == 'The number of allowed requests in the current period'
+    """
+    return build_model(root, Header, context=context)
+
+
+def build_header_or_reference(
+    node: yaml.Node, context: Context
+) -> Header | Reference | ValueSource[YAMLInvalidValue]:
+    """
+    Build either a Header or Reference from a YAML node.
+
+    This helper handles the polymorphic nature of OpenAPI where many fields
+    can contain either a Header object or a Reference object ($ref).
+
+    Args:
+        node: The YAML node to parse
+        context: Parsing context
+
+    Returns:
+        A Header, Reference, or ValueSource if the node is invalid
+    """
+    # Check if it's a reference (has $ref key)
+    if isinstance(node, yaml.MappingNode):
+        for key_node, _ in node.value:
+            key = context.yaml_constructor.construct_yaml_str(key_node)
+            if key == "$ref":
+                return build_reference(node, context)
+
+    # Otherwise, try to build as Header
+    return build(node, context)

jentic/apitools/openapi/datamodels/low/v30/info.py

@@ -2,20 +2,14 @@ from dataclasses import dataclass, field, replace
 
 from ruamel import yaml
 
-from jentic.apitools.openapi.datamodels.low.context import Context
-from jentic.apitools.openapi.datamodels.low.fields import fixed_field
-from jentic.apitools.openapi.datamodels.low.model_builder import build_model
-from jentic.apitools.openapi.datamodels.low.sources import (
-    FieldSource,
-    KeySource,
-    ValueSource,
-    YAMLInvalidValue,
-    YAMLValue,
-)
-from jentic.apitools.openapi.datamodels.low.v30.contact import Contact
-from jentic.apitools.openapi.datamodels.low.v30.contact import build as build_contact
-from jentic.apitools.openapi.datamodels.low.v30.license import License
-from jentic.apitools.openapi.datamodels.low.v30.license import build as build_license
+from ..context import Context
+from ..fields import fixed_field
+from ..sources import FieldSource, KeySource, ValueSource, YAMLInvalidValue, YAMLValue
+from .builders import build_model
+from .contact import Contact
+from .contact import build as build_contact
+from .license import License
+from .license import build as build_license
 
 
 __all__ = ["Info", "build"]
@@ -85,18 +79,15 @@ def build(root: yaml.Node, context: Context | None = None) -> Info | ValueSource
         assert info.version.value == '1.0.1'
         assert info.contact.value.name.value == 'API Support'
     """
-    # Initialize context once at the beginning
-    if context is None:
-        context = Context()
+    context = context or Context()
 
-    if not isinstance(root, yaml.MappingNode):
-        # Preserve invalid root data instead of returning None
-        value = context.yaml_constructor.construct_object(root, deep=True)
-        return ValueSource(value=value, value_node=root)
-
-    # Use build_model to handle most fields
+    # Use build_model for initial construction
     info = build_model(root, Info, context=context)
 
+    # If build_model returned ValueSource (invalid node), return it immediately
+    if not isinstance(info, Info):
+        return info
+
     # Manually handle nested objects (contact, license)
     for key_node, value_node in root.value:
         key = context.yaml_constructor.construct_yaml_str(key_node)

jentic/apitools/openapi/datamodels/low/v30/license.py

@@ -2,16 +2,10 @@ from dataclasses import dataclass, field
 
 from ruamel import yaml
 
-from jentic.apitools.openapi.datamodels.low.context import Context
-from jentic.apitools.openapi.datamodels.low.fields import fixed_field
-from jentic.apitools.openapi.datamodels.low.model_builder import build_model
-from jentic.apitools.openapi.datamodels.low.sources import (
-    FieldSource,
-    KeySource,
-    ValueSource,
-    YAMLInvalidValue,
-    YAMLValue,
-)
+from ..context import Context
+from ..fields import fixed_field
+from ..sources import FieldSource, KeySource, ValueSource, YAMLInvalidValue, YAMLValue
+from .builders import build_model
 
 
 __all__ = ["License", "build"]