jentic-openapi-datamodels 1.0.0a15__tar.gz → 1.0.0a17__tar.gz

{jentic_openapi_datamodels-1.0.0a15 → jentic_openapi_datamodels-1.0.0a17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jentic-openapi-datamodels
-Version: 1.0.0a15
+Version: 1.0.0a17
 Summary: Jentic OpenAPI Data Models
 Author: Jentic
 Author-email: Jentic <hello@jentic.com>

{jentic_openapi_datamodels-1.0.0a15 → jentic_openapi_datamodels-1.0.0a17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jentic-openapi-datamodels"
-version = "1.0.0-alpha.15"
+version = "1.0.0-alpha.17"
 description = "Jentic OpenAPI Data Models"
 readme = "README.md"
 authors = [{ name = "Jentic", email = "hello@jentic.com" }]

{jentic_openapi_datamodels-1.0.0a15 → jentic_openapi_datamodels-1.0.0a17}/src/jentic/apitools/openapi/datamodels/low/model_builder.py

@@ -62,7 +62,7 @@ def build_model(
     }
 
     # Extract field values in a single pass (non-recursive, single layer only)
-    field_values: dict[str, Any] = {}
+    field_values: dict[str, FieldSource[Any]] = {}
     for key_node, value_node in root.value:
         key = context.yaml_constructor.construct_yaml_str(key_node)
 
@@ -98,6 +98,22 @@ def build_model(
                     field_values[field_name] = FieldSource(
                         value=value, key_node=key_node, value_node=value_node
                     )
+            elif field_type_args & {FieldSource[list[ValueSource[str]]]}:
+                # Handle list with ValueSource wrapping for each item
+                if isinstance(value_node, yaml.SequenceNode):
+                    value_list: list[ValueSource[str]] = []
+                    for item_node in value_node.value:
+                        item_value = context.yaml_constructor.construct_object(item_node, deep=True)
+                        value_list.append(ValueSource(value=item_value, value_node=item_node))
+                    field_values[field_name] = FieldSource(
+                        value=value_list, key_node=key_node, value_node=value_node
+                    )
+                else:
+                    # Not a sequence - preserve as-is for validation
+                    value = context.yaml_constructor.construct_object(value_node, deep=True)
+                    field_values[field_name] = FieldSource(
+                        value=value, key_node=key_node, value_node=value_node
+                    )
 
     # Build and return the dataclass instance
     # Conditionally include extensions field if dataclass supports it

jentic_openapi_datamodels-1.0.0a17/src/jentic/apitools/openapi/datamodels/low/v30/contact.py

@@ -0,0 +1,67 @@
+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,
+)
+
+
+__all__ = ["Contact", "build"]
+
+
+@dataclass(frozen=True, slots=True)
+class Contact:
+    """
+    Contact Object representation for OpenAPI 3.0.
+
+    Contact information for the exposed API.
+
+    Attributes:
+        root_node: The top-level node representing the entire Contact object in the original source file
+        name: The identifying name of the contact person/organization.
+        url: The URL pointing to the contact information. Value MUST be in the format of a URL.
+        email: The email address of the contact person/organization. Value MUST be in the format of an email address.
+        extensions: Specification extensions (x-* fields)
+    """
+
+    root_node: yaml.Node
+    name: FieldSource[str] | None = fixed_field()
+    url: FieldSource[str] | None = fixed_field()
+    email: FieldSource[str] | None = fixed_field()
+    extensions: dict[KeySource[str], ValueSource[YAMLValue]] = field(default_factory=dict)
+
+
+def build(
+    root: yaml.Node, context: Context | None = None
+) -> Contact | ValueSource[YAMLInvalidValue]:
+    """
+    Build a Contact 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 Contact 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("name: API Support\\nemail: support@example.com")
+        contact = build(root)
+        assert contact.name.value == 'API Support'
+    """
+    return build_model(root, Contact, context=context)

jentic_openapi_datamodels-1.0.0a17/src/jentic/apitools/openapi/datamodels/low/v30/info.py

@@ -0,0 +1,123 @@
+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
+
+
+__all__ = ["Info", "build"]
+
+
+@dataclass(frozen=True, slots=True)
+class Info:
+    """
+    Info Object representation for OpenAPI 3.0.
+
+    Provides metadata about the API. The metadata MAY be used by the clients if needed,
+    and MAY be presented in editing or documentation generation tools for convenience.
+
+    Attributes:
+        root_node: The top-level node representing the entire Info object in the original source file
+        title: REQUIRED. The title of the API.
+        description: A description of the API. CommonMark syntax MAY be used for rich text representation.
+        termsOfService: A URL to the Terms of Service for the API. This MUST be in the form of a URL.
+        contact: The contact information for the exposed API.
+        license: The license information for the exposed API.
+        version: REQUIRED. The version of the OpenAPI document (which is distinct from the OpenAPI Specification version or the API implementation version).
+        extensions: Specification extensions (x-* fields)
+    """
+
+    root_node: yaml.Node
+    title: FieldSource[str] | None = fixed_field()
+    description: FieldSource[str] | None = fixed_field()
+    termsOfService: FieldSource[str] | None = fixed_field()
+    contact: FieldSource[Contact] | None = fixed_field()
+    license: FieldSource[License] | None = fixed_field()
+    version: FieldSource[str] | None = fixed_field()
+    extensions: dict[KeySource[str], ValueSource[YAMLValue]] = field(default_factory=dict)
+
+
+def build(root: yaml.Node, context: Context | None = None) -> Info | ValueSource[YAMLInvalidValue]:
+    """
+    Build an Info 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 Info 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('''
+        title: Sample Pet Store App
+        version: 1.0.1
+        description: This is a sample server for a pet store.
+        contact:
+          name: API Support
+          email: support@example.com
+        license:
+          name: Apache 2.0
+          url: https://www.apache.org/licenses/LICENSE-2.0.html
+        ''')
+        info = build(root)
+        assert info.title.value == 'Sample Pet Store App'
+        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()
+
+    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
+    info = build_model(root, Info, context=context)
+
+    # Manually handle nested objects (contact, license)
+    for key_node, value_node in root.value:
+        key = context.yaml_constructor.construct_yaml_str(key_node)
+
+        if key == "contact":
+            # Handle nested Contact object - child builder handles invalid nodes
+            # FieldSource will auto-unwrap ValueSource if child returns it for invalid data
+            contact = FieldSource(
+                value=build_contact(value_node, context=context),
+                key_node=key_node,
+                value_node=value_node,
+            )
+            info = replace(info, contact=contact)
+        elif key == "license":
+            # Handle nested License object - child builder handles invalid nodes
+            # FieldSource will auto-unwrap ValueSource if child returns it for invalid data
+            license_obj = FieldSource(
+                value=build_license(value_node, context=context),
+                key_node=key_node,
+                value_node=value_node,
+            )
+            info = replace(info, license=license_obj)
+
+    return info

jentic_openapi_datamodels-1.0.0a17/src/jentic/apitools/openapi/datamodels/low/v30/license.py

@@ -0,0 +1,65 @@
+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,
+)
+
+
+__all__ = ["License", "build"]
+
+
+@dataclass(frozen=True, slots=True)
+class License:
+    """
+    License Object representation for OpenAPI 3.0.
+
+    License information for the exposed API.
+
+    Attributes:
+        root_node: The top-level node representing the entire License object in the original source file
+        name: REQUIRED. The license name used for the API.
+        url: A URL to the license used for the API. Value MUST be in the format of a URL.
+        extensions: Specification extensions (x-* fields)
+    """
+
+    root_node: yaml.Node
+    name: FieldSource[str] | None = fixed_field()
+    url: FieldSource[str] | None = fixed_field()
+    extensions: dict[KeySource[str], ValueSource[YAMLValue]] = field(default_factory=dict)
+
+
+def build(
+    root: yaml.Node, context: Context | None = None
+) -> License | ValueSource[YAMLInvalidValue]:
+    """
+    Build a License 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 License 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("name: MIT\\nurl: https://opensource.org/licenses/MIT")
+        license = build(root)
+        assert license.name.value == 'MIT'
+    """
+    return build_model(root, License, context=context)

{jentic_openapi_datamodels-1.0.0a15 → jentic_openapi_datamodels-1.0.0a17}/src/jentic/apitools/openapi/datamodels/low/v30/schema.py

@@ -113,8 +113,8 @@ class Schema:
     uniqueItems: FieldSource[bool] | None = fixed_field()
     maxProperties: FieldSource[int] | None = fixed_field()
     minProperties: FieldSource[int] | None = fixed_field()
-    required: FieldSource[list[str]] | None = fixed_field()
-    enum: FieldSource[list[YAMLValue]] | None = fixed_field()
+    required: FieldSource[list[ValueSource[str]]] | None = fixed_field()
+    enum: FieldSource[list[ValueSource[YAMLValue]]] | None = fixed_field()
 
     # JSON Schema Type and Structure (nested schemas)
     type: FieldSource[str] | None = fixed_field()
@@ -215,14 +215,32 @@ def build(
             FieldSource[int],
             FieldSource[int | float],
             FieldSource[YAMLValue],
-            FieldSource[list[str]],
-            FieldSource[list[YAMLValue]],
         }:
             value = context.yaml_constructor.construct_object(value_node, deep=True)
             field_values[field_name] = FieldSource(
                 value=value, key_node=key_node, value_node=value_node
             )
 
+        # Handle list with ValueSource wrapping for each item (e.g., required, enum fields)
+        elif field_type_args & {
+            FieldSource[list[ValueSource[str]]],
+            FieldSource[list[ValueSource[YAMLValue]]],
+        }:
+            if isinstance(value_node, yaml.SequenceNode):
+                value_list: list[ValueSource[Any]] = []
+                for item_node in value_node.value:
+                    item_value = context.yaml_constructor.construct_object(item_node, deep=True)
+                    value_list.append(ValueSource(value=item_value, value_node=item_node))
+                field_values[field_name] = FieldSource(
+                    value=value_list, key_node=key_node, value_node=value_node
+                )
+            else:
+                # Not a sequence - preserve as-is for validation
+                value = context.yaml_constructor.construct_object(value_node, deep=True)
+                field_values[field_name] = FieldSource(
+                    value=value, key_node=key_node, value_node=value_node
+                )
+
         # Recursive schema list fields (allOf, oneOf, anyOf)
         elif key in ("allOf", "oneOf", "anyOf"):
             if isinstance(value_node, yaml.SequenceNode):

jentic_openapi_datamodels-1.0.0a17/src/jentic/apitools/openapi/datamodels/low/v30/server_variable.py

@@ -0,0 +1,76 @@
+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,
+)
+
+
+__all__ = ["ServerVariable", "build"]
+
+
+@dataclass(frozen=True, slots=True)
+class ServerVariable:
+    """
+    Server Variable Object representation for OpenAPI 3.0.
+
+    An object representing a Server Variable for server URL template substitution.
+
+    Attributes:
+        root_node: The top-level node representing the entire ServerVariable object in the original source file
+        enum: An enumeration of string values to be used if the substitution options are from a limited set. The array SHOULD NOT be empty.
+        default: REQUIRED. The default value to use for substitution, which SHALL be sent if an alternate value is not supplied. If the enum is defined, the value SHOULD exist in the enum's values.
+        description: An optional description for the server variable. CommonMark syntax MAY be used for rich text representation.
+        extensions: Specification extensions (x-* fields)
+    """
+
+    root_node: yaml.Node
+    enum: FieldSource[list[ValueSource[str]]] | None = fixed_field()
+    default: FieldSource[str] | None = fixed_field()
+    description: FieldSource[str] | None = fixed_field()
+    extensions: dict[KeySource[str], ValueSource[YAMLValue]] = field(default_factory=dict)
+
+
+def build(
+    root: yaml.Node, context: Context | None = None
+) -> ServerVariable | ValueSource[YAMLInvalidValue]:
+    """
+    Build a ServerVariable 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 ServerVariable 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('''
+        default: production
+        enum:
+          - production
+          - staging
+          - development
+        description: The deployment environment
+        ''')
+        server_variable = build(root)
+        assert server_variable.default.value == 'production'
+        assert len(server_variable.enum.value) == 3
+        assert server_variable.enum.value[0].value == 'production'
+    """
+    return build_model(root, ServerVariable, context=context)