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

jentic_openapi_datamodels-1.0.0a20.dist-info/METADATA

@@ -0,0 +1,379 @@
+Metadata-Version: 2.4
+Name: jentic-openapi-datamodels
+Version: 1.0.0a20
+Summary: Jentic OpenAPI Data Models
+Author: Jentic
+Author-email: Jentic <hello@jentic.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: ruamel-yaml~=0.18.15
+Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/jentic/jentic-openapi-tools
+Description-Content-Type: text/markdown
+
+# jentic-openapi-datamodels
+
+Low-level data models for OpenAPI specifications.
+
+This package provides data model classes for representing OpenAPI specification objects in Python.
+
+## Features
+
+**Low-Level Architecture**
+- **Preserve Everything**: All data from source documents preserved exactly as-is, including invalid values
+- **Zero Validation**: No validation or coercion during parsing - deferred to higher layers
+- **Separation of Concerns**: Low-level model focuses on faithful representation; validation belongs elsewhere
+
+**Source Tracking**
+- **Complete Source Fidelity**: Every field tracks its exact YAML node location
+- **Precise Error Reporting**: Line and column numbers via `start_mark` and `end_mark`
+- **Metadata Preservation**: Full position tracking for accurate diagnostics
+
+**Python Integration**
+- **Python-Idiomatic Naming**: snake_case field names (e.g., `bearer_format`, `property_name`)
+- **Spec-Aligned Mapping**: Automatic YAML name mapping (e.g., `bearerFormat` ↔ `bearer_format`)
+- **Type Safety**: Full type hints with Generic types (`FieldSource[T]`, `KeySource[T]`, `ValueSource[T]`)
+
+**Extensibility**
+- **Extension Support**: Automatic extraction of OpenAPI `x-*` specification extensions
+- **Unknown Field Tracking**: Capture typos and invalid fields for validation tools
+- **Generic Builder Pattern**: Core `build_model()` function with object-specific builders for complex cases
+
+**Performance**
+- **Memory Efficient**: Immutable frozen dataclasses with `__slots__` for optimal memory usage
+- **Shared Context**: All instances share a single YAML constructor for efficiency
+
+**Version Support**
+- **OpenAPI 2.0**: Planned for future release
+- **OpenAPI 3.0.x**: Fully implemented
+- **OpenAPI 3.1.x**: Fully implemented with JSON Schema 2020-12 support
+- **OpenAPI 3.2.x**: Planned for future release
+
+## Installation
+
+```bash
+pip install jentic-openapi-datamodels
+```
+
+**Prerequisites:**
+- Python 3.11+
+
+## Quick Start
+
+### Parsing OpenAPI 3.0 Documents
+
+The main use case is parsing complete OpenAPI Documents:
+
+```python
+from jentic.apitools.openapi.parser.core import OpenAPIParser
+from jentic.apitools.openapi.parser.backends.ruamel_ast import MappingNode
+from jentic.apitools.openapi.datamodels.low.v30 import build
+
+# Parse OpenAPI document
+parser = OpenAPIParser("ruamel-ast")
+root = parser.parse("""
+openapi: 3.0.4
+info:
+  title: Pet Store API
+  version: 1.0.0
+paths:
+  /pets:
+    get:
+      summary: List all pets
+      responses:
+        '200':
+          description: A list of pets
+""", return_type=MappingNode)
+
+# Build OpenAPI document model
+openapi_doc = build(root)
+
+# Access document fields via Python naming (snake_case)
+print(openapi_doc.openapi.value)  # "3.0.4"
+print(openapi_doc.info.value.title.value)  # "Pet Store API"
+print(openapi_doc.info.value.version.value)  # "1.0.0"
+
+# Access nested fields with full type safety
+for path_key, path_item in openapi_doc.paths.value.path_items.items():
+    print(f"Path: {path_key.value}")  # "/pets"
+    if path_item.value.get:
+        operation = path_item.value.get.value
+        print(f"  Summary: {operation.summary.value}")  # "List all pets"
+```
+
+### Parsing OpenAPI 3.1 Documents with JSON Schema 2020-12
+
+OpenAPI 3.1 fully supports JSON Schema 2020-12, including advanced features like boolean schemas, conditional validation and vocabulary declarations:
+
+```python
+from jentic.apitools.openapi.parser.core import OpenAPIParser
+from jentic.apitools.openapi.parser.backends.ruamel_ast import MappingNode
+from jentic.apitools.openapi.datamodels.low.v31 import build
+
+# Parse OpenAPI 3.1 document with JSON Schema 2020-12 features
+parser = OpenAPIParser("ruamel-ast")
+root = parser.parse("""
+openapi: 3.1.2
+info:
+  title: Pet Store API
+  version: 1.0.0
+paths:
+  /pets:
+    get:
+      responses:
+        '200':
+          description: Pet list
+          content:
+            application/json:
+              schema:
+                type: array
+                prefixItems:
+                  - type: string
+                  - type: integer
+                items: false
+                contains:
+                  type: object
+                  required: [id]
+""", return_type=MappingNode)
+
+openapi_doc = build(root)
+
+# Access JSON Schema 2020-12 features
+schema = openapi_doc.paths.value.path_items["/pets"].value.get.value.responses.value["200"].value.content.value["application/json"].value.schema
+print(schema.prefix_items.value[0].type.value)  # "string"
+print(schema.items.value)  # False (boolean schema)
+print(schema.contains.value.required.value[0].value)  # "id"
+```
+
+### Parsing Individual Spec Objects
+
+You can also parse individual OpenAPI specification objects:
+
+```python
+from jentic.apitools.openapi.parser.core import OpenAPIParser
+from jentic.apitools.openapi.parser.backends.ruamel_ast import MappingNode
+from jentic.apitools.openapi.datamodels.low.v30.security_scheme import build as build_security_scheme
+
+# Parse a Security Scheme object
+parser = OpenAPIParser("ruamel-ast")
+root = parser.parse("""
+type: http
+scheme: bearer
+bearerFormat: JWT
+""", return_type=MappingNode)
+
+security_scheme = build_security_scheme(root)
+
+# Access via Python field names (snake_case)
+print(security_scheme.bearer_format.value)  # "JWT"
+
+# Access source location information
+print(security_scheme.bearer_format.key_node.value)  # "bearerFormat"
+print(security_scheme.bearer_format.key_node.start_mark.line)  # Line number
+```
+
+You can also parse OpenAPI 3.1 Schema objects with JSON Schema 2020-12 features:
+
+```python
+from jentic.apitools.openapi.parser.core import OpenAPIParser
+from jentic.apitools.openapi.parser.backends.ruamel_ast import MappingNode
+from jentic.apitools.openapi.datamodels.low.v31.schema import build as build_schema
+
+# Parse a Schema object with JSON Schema 2020-12 features
+parser = OpenAPIParser("ruamel-ast")
+root = parser.parse("""
+type: object
+properties:
+  id:
+    type: integer
+  tags:
+    type: array
+    prefixItems:
+      - type: string
+      - type: string
+    items: false
+patternProperties:
+  "^x-":
+    type: string
+unevaluatedProperties: false
+if:
+  properties:
+    premium:
+      const: true
+then:
+  required: [support_tier]
+""", return_type=MappingNode)
+
+schema = build_schema(root)
+
+# Access JSON Schema 2020-12 fields via Python naming (snake_case)
+print(schema.properties.value["id"].type.value)  # "integer"
+print(schema.pattern_properties.value["^x-"].type.value)  # "string"
+print(schema.unevaluated_properties.value)  # False
+print(schema.prefix_items.value[0].type.value)  # "string"
+
+# Access conditional schema fields
+print(schema.if_.value.properties.value["premium"].const.value)  # True
+print(schema.then_.value.required.value[0].value)  # "support_tier"
+
+# Access source location information
+print(schema.type.key_node.start_mark.line)  # Line number for "type" key
+```
+
+### Field Name Mapping
+
+YAML `camelCase` fields automatically map to Python `snake_case`:
+- `bearerFormat` → `bearer_format`
+- `authorizationUrl` → `authorization_url`
+- `openIdConnectUrl` → `openid_connect_url`
+
+Special cases for Python reserved keywords and `$` fields:
+
+- `in` → `in_`
+- `if` → `if_`
+- `then` → `then_`
+- `else` → `else_`
+- `not` → `not_`
+- `$ref` → `ref_`
+- `$id` → `id_`
+- `$schema` → `schema_`
+
+### Source Tracking
+
+The package provides three immutable wrapper types for preserving source information:
+
+**FieldSource[T]** - For OpenAPI fields with key-value pairs
+- Used for: Fixed fields (`name`, `bearer_format`) and patterned fields (status codes, path items, schema properties)
+- Tracks: Both key and value nodes
+- Example: `SecurityScheme.bearer_format` is `FieldSource[str]`, response status codes are `FieldSource[Response]`
+
+**KeySource[T]** - For dictionary keys
+- Used for: keys in OpenAPI fields, `x-*` extensions and mapping dictionaries
+- Tracks: Only key node
+- Example: Keys in `Discriminator.mapping` are `KeySource[str]`
+
+**ValueSource[T]** - For dictionary values and array items
+- Used for: values in OpenAPI fields, in `x-*` extensions, mapping dictionaries and array items
+- Tracks: Only value node
+- Example: Values in `Discriminator.mapping` are `ValueSource[str]`
+
+```python
+from jentic.apitools.openapi.parser.core import OpenAPIParser
+from jentic.apitools.openapi.parser.backends.ruamel_ast import MappingNode
+from jentic.apitools.openapi.datamodels.low.v30 import build
+
+# FieldSource: Fixed specification fields in OpenAPI document
+parser = OpenAPIParser("ruamel-ast")
+root = parser.parse("""
+openapi: 3.0.4
+info:
+  title: Pet Store API
+  version: 1.0.0
+paths: {}
+""", return_type=MappingNode)
+openapi_doc = build(root)
+
+field = openapi_doc.info.value.title  # FieldSource[str]
+print(field.value)  # "Pet Store API" - The actual value
+print(field.key_node)  # YAML node for "title"
+print(field.value_node)  # YAML node for "Pet Store API"
+
+# KeySource/ValueSource: Dictionary fields (extensions, mapping)
+# Extensions in OpenAPI objects use KeySource/ValueSource
+root = parser.parse("""
+openapi: 3.0.4
+info:
+  title: API
+  version: 1.0.0
+  x-custom: value
+  x-another: data
+paths: {}
+""", return_type=MappingNode)
+openapi_doc = build(root)
+
+for key, value in openapi_doc.info.value.extensions.items():
+    print(key.value)  # KeySource[str]: "x-custom" or "x-another"
+    print(key.key_node)  # YAML node for the extension key
+    print(value.value)  # ValueSource: "value" or "data"
+    print(value.value_node)  # YAML node for the extension value
+```
+
+### Location Ranges
+
+Access precise location ranges within the source document using start_mark and end_mark:
+
+```python
+from jentic.apitools.openapi.parser.core import OpenAPIParser
+from jentic.apitools.openapi.parser.backends.ruamel_ast import MappingNode
+from jentic.apitools.openapi.datamodels.low.v30 import build
+
+yaml_content = """
+openapi: 3.0.4
+info:
+  title: Pet Store API
+  version: 1.0.0
+  description: A sample Pet Store API
+paths: {}
+"""
+
+parser = OpenAPIParser("ruamel-ast")
+root = parser.parse(yaml_content, return_type=MappingNode)
+openapi_doc = build(root)
+
+# Access location information for any field
+field = openapi_doc.info.value.title
+
+# Key location (e.g., "title")
+print(f"Key start: line {field.key_node.start_mark.line}, col {field.key_node.start_mark.column}")
+print(f"Key end: line {field.key_node.end_mark.line}, col {field.key_node.end_mark.column}")
+
+# Value location (e.g., "Pet Store API")
+print(f"Value start: line {field.value_node.start_mark.line}, col {field.value_node.start_mark.column}")
+print(f"Value end: line {field.value_node.end_mark.line}, col {field.value_node.end_mark.column}")
+
+# Full field range (from key start to value end)
+start = field.key_node.start_mark
+end = field.value_node.end_mark
+print(f"Field range: ({start.line}:{start.column}) to ({end.line}:{end.column})")
+```
+
+### Invalid Data Handling
+
+Low-level models preserve invalid data without validation:
+
+```python
+from jentic.apitools.openapi.parser.core import OpenAPIParser
+from jentic.apitools.openapi.parser.backends.ruamel_ast import MappingNode
+from jentic.apitools.openapi.datamodels.low.v30 import build
+
+parser = OpenAPIParser("ruamel-ast")
+root = parser.parse("""
+openapi: 3.0.4
+info:
+  title: 123  # Intentionally wrong type for demonstration (should be string)
+  version: 1.0.0
+paths: {}
+""", return_type=MappingNode)
+
+openapi_doc = build(root)
+print(openapi_doc.info.value.title.value)  # 123 (preserved as-is)
+print(type(openapi_doc.info.value.title.value))  # <class 'int'>
+
+# Invalid data is preserved with full source tracking for validation tools
+print(openapi_doc.info.value.title.value_node.start_mark.line)  # Line number
+```
+
+### Error Reporting
+
+This architecture—where the low-level model preserves data without validation and validation tools consume 
+that data—allows the low-level model to remain simple while enabling sophisticated validation tools to provide
+user-friendly error messages with exact source locations.
+
+## Testing
+
+Run the test suite:
+
+```bash
+uv run --package jentic-openapi-datamodels pytest packages/jentic-openapi-datamodels -v
+```

jentic_openapi_datamodels-1.0.0a20.dist-info/RECORD

@@ -0,0 +1,75 @@
+jentic/apitools/openapi/datamodels/low/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jentic/apitools/openapi/datamodels/low/context.py,sha256=pAuPf8GmdttXMEeuO4clAvTTxH7LMtEHdxoo1RpyK2c,555
+jentic/apitools/openapi/datamodels/low/extractors.py,sha256=ZdTndH_9OcN9O7l560D13n4d0IJPCKLR0ayqrkrey9Y,4840
+jentic/apitools/openapi/datamodels/low/fields.py,sha256=g1Sta-eN4JDg_AnuJxe1MeWS3Ut81A5dw_ZIdyGrgbk,1448
+jentic/apitools/openapi/datamodels/low/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jentic/apitools/openapi/datamodels/low/sources.py,sha256=H4I6LSn-Ry6cJageIyhCvE0H85O7Lh94gdCIm60wj0E,2924
+jentic/apitools/openapi/datamodels/low/v30/__init__.py,sha256=3i8EWv_2cxoSPkpIOedhswAPSk8cTitUGWbt4iZ9U34,1934
+jentic/apitools/openapi/datamodels/low/v30/builders/__init__.py,sha256=mIpggEOAZa6M4EgJc-THjdhsZB_vsaVTHb8WkKD7eXQ,15717
+jentic/apitools/openapi/datamodels/low/v30/callback.py,sha256=eNPzblFpsm3zP9GiqaDguWFLFgoWMSxNIveUYhvFKPI,4802
+jentic/apitools/openapi/datamodels/low/v30/components.py,sha256=gzpp9EJhO4N_0hqPi55KhLqT4uZfIjo6v1uifyIDg2A,11426
+jentic/apitools/openapi/datamodels/low/v30/contact.py,sha256=1RJCZ165aXOZ0Rjz_LftKy4rB99_hqCVaT0iLV56H3o,2194
+jentic/apitools/openapi/datamodels/low/v30/discriminator.py,sha256=vPQgQ6KQY3z6dkIWbvC4qv36DBev8WHRyvavfbHh0aw,2362
+jentic/apitools/openapi/datamodels/low/v30/encoding.py,sha256=DE6M79J_6BUrBevqaVTCGGLjII83lqJD40NviRFDzm8,3438
+jentic/apitools/openapi/datamodels/low/v30/example.py,sha256=QCtF8-T0uQQ_aGXIEPW754U62ygmly_1VpIUdekEyKY,3488
+jentic/apitools/openapi/datamodels/low/v30/external_documentation.py,sha256=BNOcD6W1LI43g_463wlGfTOYXL8gV41Ib28flsULETk,2269
+jentic/apitools/openapi/datamodels/low/v30/header.py,sha256=oGv-smivn_z0RbS9S5vbvHX2KZaz90tXBnJWi6hxRzU,5275
+jentic/apitools/openapi/datamodels/low/v30/info.py,sha256=-EHY7uRMlFUPYo_OETsQPvSvhtzbs4dNkxY2CzgSvQk,4575
+jentic/apitools/openapi/datamodels/low/v30/license.py,sha256=ghKqCOJPASMNIybe7RLiEA437Lb2PChMfrKnGLhxcUo,2005
+jentic/apitools/openapi/datamodels/low/v30/link.py,sha256=hY8ioLU66ozZ6Gidydd6lycx8DrM4Wr4uaYpSqd2hM0,5881
+jentic/apitools/openapi/datamodels/low/v30/media_type.py,sha256=hnuELzZbl3GL6YtgtwB51erZZxtLXZ-mAO5A_vs0IRc,4698
+jentic/apitools/openapi/datamodels/low/v30/oauth_flow.py,sha256=aAQUy_xX3vEhGHwiSgWiJuBnqidaf3uy6o8JX4fYpns,2727
+jentic/apitools/openapi/datamodels/low/v30/oauth_flows.py,sha256=a2aezPtBhanFvIAYSJGNtSIUcMCh-KGjmSYKizulGjk,4331
+jentic/apitools/openapi/datamodels/low/v30/openapi.py,sha256=tySlKTuFyHgEpS13-vJSRpuy7eWQEM1QrY2F7QDdFPc,5833
+jentic/apitools/openapi/datamodels/low/v30/operation.py,sha256=tU2qngEeJSqRW103-PVo5cBGzLtkdDws8kGRusSLKC0,5446
+jentic/apitools/openapi/datamodels/low/v30/parameter.py,sha256=YopOV5rnA-XiumEVSVOi2AESyRPWT6yqqENuqX04QTM,5186
+jentic/apitools/openapi/datamodels/low/v30/path_item.py,sha256=4MQUIwHEr7qcpHZQHmQzrZstMyKwwTFyvlnfcIiUn_M,4878
+jentic/apitools/openapi/datamodels/low/v30/paths.py,sha256=DTfH6-3eI1muIAgCzL9TbbQjN-9_et_wxlL66LRSFOQ,3896
+jentic/apitools/openapi/datamodels/low/v30/reference.py,sha256=QXuI-caWgMlU1Zl1V5wiOQurIUAn_3t_XoOLyG0hSQ8,1966
+jentic/apitools/openapi/datamodels/low/v30/request_body.py,sha256=8Ca3iWXn13wmMusy75QyZSFR6KmGcwbhGjxTeTHjiFo,3900
+jentic/apitools/openapi/datamodels/low/v30/response.py,sha256=FFLoHRVAw91vKWlkDzD08Xlie0hHnCSKXzjMKDKmH1U,3976
+jentic/apitools/openapi/datamodels/low/v30/responses.py,sha256=JiHotGO1mCoO8rhOgj6ETaDtcEcnm554v-L4bHiJXkY,4245
+jentic/apitools/openapi/datamodels/low/v30/schema.py,sha256=fkGRJz_Ta-Giq06KPoLjAZanDGgTILmX5Ikj5PlSCow,15717
+jentic/apitools/openapi/datamodels/low/v30/security_requirement.py,sha256=LZbUUXmnGtvEzgwXlGVNIUwZTx9gK6uXPbrtmKaXqsw,4277
+jentic/apitools/openapi/datamodels/low/v30/security_scheme.py,sha256=LClieys-mEiM84EEOGK4dsaWwNny1lKztzVBicddQd4,5455
+jentic/apitools/openapi/datamodels/low/v30/server.py,sha256=G9mcOMq9owtd6qECaQIxpvN9VrU7zjxnwaBVAfJw0Cs,4687
+jentic/apitools/openapi/datamodels/low/v30/server_variable.py,sha256=CmWdchAOTO3RtlSIodPOwGQds3-WZnWjaHMh66H7WpA,2762
+jentic/apitools/openapi/datamodels/low/v30/tag.py,sha256=wH9uWAqNLryvatahDWAjQOcSLlpRw0cUrTvIIhfuUbo,2359
+jentic/apitools/openapi/datamodels/low/v30/xml.py,sha256=4KgtMgjp4v8lMTUuLG-7RBOgXGvPSsIrtHU-u6TUbGg,1930
+jentic/apitools/openapi/datamodels/low/v31/__init__.py,sha256=MXwVorDh1quZU5A0mndI4__dVB247A5HQFzDJrocQsM,1978
+jentic/apitools/openapi/datamodels/low/v31/builders/__init__.py,sha256=9-ohxirframb6EmcFlDQ83cnGZ_mbnt_2aoFeCQE51o,17925
+jentic/apitools/openapi/datamodels/low/v31/callback.py,sha256=RBW8Xdhrd97elpiVBXGQqdXfDaWHEBaysM7RhZyqcrA,4802
+jentic/apitools/openapi/datamodels/low/v31/components.py,sha256=pZet9wXywTNz0h_o5CU9HsIpOsY7bc-LdY9cAhRfdeY,11665
+jentic/apitools/openapi/datamodels/low/v31/contact.py,sha256=SnvuCz-YitRwK8l5CwuWSP4LjuB10KWTNmad_fMOENM,2194
+jentic/apitools/openapi/datamodels/low/v31/discriminator.py,sha256=5f4FRqLid4ZLPIha87bxjik-P6BskKixE7hZ8i9DUQY,2460
+jentic/apitools/openapi/datamodels/low/v31/encoding.py,sha256=ZThHWbcUW8JXWQ8iNswOtJ4lPJ5UnNng2W6N7BNhhuY,3438
+jentic/apitools/openapi/datamodels/low/v31/example.py,sha256=EpUEZwGSIgTd71zkRhnIphMHJLV96W5rPiQuepP39AA,3488
+jentic/apitools/openapi/datamodels/low/v31/external_documentation.py,sha256=zQ2Hw2DDiGeR0zUjzRppxtt78SuIkkU-7behTw9ZjPA,2269
+jentic/apitools/openapi/datamodels/low/v31/header.py,sha256=2zCP9wRTYvdv4XWiSSsH1YX537lqUdmnV5gRx0ABnnk,5302
+jentic/apitools/openapi/datamodels/low/v31/info.py,sha256=xK0PJf8mVyAlWe6NqA8lkTuKoEVPFjjhM5EHRJu1OCc,4694
+jentic/apitools/openapi/datamodels/low/v31/license.py,sha256=YlujRqmYc3mYQ3-uMc5vcdxxsFLedTXSzmhGBa264MA,2227
+jentic/apitools/openapi/datamodels/low/v31/link.py,sha256=owYcMIFhSABY4bFlMmwy7XRqjmvK0Cpc3TqzbiZd2ug,5881
+jentic/apitools/openapi/datamodels/low/v31/media_type.py,sha256=kVntYlOZe5uNeOftDZrbnNFDnfbkIulqu9D7yJ1Sdac,4725
+jentic/apitools/openapi/datamodels/low/v31/oauth_flow.py,sha256=iCD-51C0wzO8ZIzRRxEtIAnHxd4oVTLwsHlzH9cMZmI,2727
+jentic/apitools/openapi/datamodels/low/v31/oauth_flows.py,sha256=DLivDlTiQyTR_RtjjxbTjQcD7GbZPfotlg-GGBlGbxs,4331
+jentic/apitools/openapi/datamodels/low/v31/openapi.py,sha256=5cBP0SdMewLtEDB88HvZMz-Yjo7ezamIX_SPnd_rAwE,6940
+jentic/apitools/openapi/datamodels/low/v31/operation.py,sha256=cLQRVF6Vff4k1XkNwam8fL79Oa20I0xMtc4jdo3CwG4,5445
+jentic/apitools/openapi/datamodels/low/v31/parameter.py,sha256=NilV-XRaV1FUon5ZyJG8KN1qdZcK923mBQtNlH59J_w,5213
+jentic/apitools/openapi/datamodels/low/v31/path_item.py,sha256=mQTtGnIg1SYa2kEWHWFVQ2W7GlZ2fgwqcAg8NTQMcjk,4878
+jentic/apitools/openapi/datamodels/low/v31/paths.py,sha256=Yf_DRrqKWjUVJQN57Lxb_4KBuwGVZa170BxGobioRhA,3896
+jentic/apitools/openapi/datamodels/low/v31/reference.py,sha256=9sv24nmuS-l8Fp9T53UuQ_KINLHy86tb5HaUAhXwR8I,2595
+jentic/apitools/openapi/datamodels/low/v31/request_body.py,sha256=tQ2QaNSAZSQAQgpSU1VxB0GhK0-Miq5D1cH0FojQzA8,3900
+jentic/apitools/openapi/datamodels/low/v31/response.py,sha256=N46VyXBuJ1agYhDuD4-gDRlSW3k1kQK_TaOVwZoqHFQ,3976
+jentic/apitools/openapi/datamodels/low/v31/responses.py,sha256=9qozdOF9miFd_RygGHIUZVtLQ_-3ma1OxORvEA_uzNc,4245
+jentic/apitools/openapi/datamodels/low/v31/schema.py,sha256=jRVRKxSUNClWbmdHs1chDmTJKJBVT_DZWj9Nu2kQu7E,24818
+jentic/apitools/openapi/datamodels/low/v31/security_requirement.py,sha256=BbnbK-rkJVFJcIc0mLReNOd9mhvNynNZHhFYOWSM2m0,4277
+jentic/apitools/openapi/datamodels/low/v31/security_scheme.py,sha256=qNlKF9PkTC0tfV_PvbKUZnQMSr6PVeH5fyw3I83JPnw,5455
+jentic/apitools/openapi/datamodels/low/v31/server.py,sha256=IA-dDnhqdD6WCZ_bjdGw_nQmp0cd0HiHeqGU_jIGocw,4687
+jentic/apitools/openapi/datamodels/low/v31/server_variable.py,sha256=UfGDky_NVUF_WQc5ZIU947MjmpxaO__VIv6sq8HMsk0,2762
+jentic/apitools/openapi/datamodels/low/v31/tag.py,sha256=8-QfVk4dUp3r-LbseMSvlCcAWeZkzlhZP3giVKNgaPI,2359
+jentic/apitools/openapi/datamodels/low/v31/xml.py,sha256=SFLNLrhiZRWVH_CBV8SqtO4C4qjDjGtqz_lYpp84BnE,1930
+jentic_openapi_datamodels-1.0.0a20.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+jentic_openapi_datamodels-1.0.0a20.dist-info/licenses/NOTICE,sha256=pAOGW-rGw9KNc2cuuLWZkfx0GSTV4TicbgBKZSLPMIs,168
+jentic_openapi_datamodels-1.0.0a20.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+jentic_openapi_datamodels-1.0.0a20.dist-info/METADATA,sha256=7Q28pNaN1yY8_95wbff-bV1izBBWiitL5HZNLAMq3ME,12466
+jentic_openapi_datamodels-1.0.0a20.dist-info/RECORD,,

jentic/apitools/openapi/datamodels/low/model_builder.py

@@ -1,129 +0,0 @@
-from dataclasses import fields
-from typing import Any, TypeVar, cast, get_args
-
-from ruamel import yaml
-
-from jentic.apitools.openapi.datamodels.low.context import Context
-from jentic.apitools.openapi.datamodels.low.extractors import extract_extension_fields
-from jentic.apitools.openapi.datamodels.low.fields import fixed_fields
-from jentic.apitools.openapi.datamodels.low.sources import (
-    FieldSource,
-    KeySource,
-    ValueSource,
-    YAMLInvalidValue,
-)
-
-
-__all__ = ["build_model"]
-
-
-T = TypeVar("T")
-
-
-def build_model(
-    root: yaml.Node, dataclass_type: type[T], *, context: Context | None = None
-) -> T | ValueSource[YAMLInvalidValue]:
-    """
-    Generic builder for OpenAPI low model.
-
-    Builds any dataclass that follows the pattern:
-    - Has a required `root_node: yaml.Node` field
-    - Has an optional `extensions: dict[...]` field
-    - Has spec fields marked with `fixed_field()`
-
-    Args:
-        root: The YAML node to parse (should be a MappingNode)
-        dataclass_type: The dataclass type to build
-        context: Optional parsing context. If None, a default context will be created.
-
-    Returns:
-        An instance of dataclass_type 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:
-        xml = build_model(root_node, XML, context=context)
-    """
-    # 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)
-
-    # Get fixed specification fields for this dataclass type
-    _fixed_fields = fixed_fields(dataclass_type)
-
-    # Build YAML name to Python field name mapping
-    yaml_to_field = {
-        field.metadata.get("yaml_name", fname): fname for fname, field in _fixed_fields.items()
-    }
-
-    # Extract field values in a single pass (non-recursive, single layer only)
-    field_values: dict[str, FieldSource[Any]] = {}
-    for key_node, value_node in root.value:
-        key = context.yaml_constructor.construct_yaml_str(key_node)
-
-        # Map YAML key to Python field name
-        field_name = yaml_to_field.get(key)
-        if field_name:
-            field = _fixed_fields[field_name]
-            field_type_args = set(get_args(field.type))
-
-            if field_type_args & {FieldSource[str], FieldSource[bool], FieldSource[int]}:
-                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
-                )
-            elif field_type_args & {FieldSource[dict[KeySource[str], ValueSource[str]]]}:
-                # Handle dict with KeySource/ValueSource wrapping
-                if isinstance(value_node, yaml.MappingNode):
-                    mapping_dict: dict[KeySource[str], ValueSource[str]] = {}
-                    for map_key_node, map_value_node in value_node.value:
-                        map_key = context.yaml_constructor.construct_yaml_str(map_key_node)
-                        map_value = context.yaml_constructor.construct_object(
-                            map_value_node, deep=True
-                        )
-                        mapping_dict[KeySource(value=map_key, key_node=map_key_node)] = ValueSource(
-                            value=map_value, value_node=map_value_node
-                        )
-                    field_values[field_name] = FieldSource(
-                        value=mapping_dict, key_node=key_node, value_node=value_node
-                    )
-                else:
-                    # Not a mapping - 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
-                    )
-            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
-    # Cast to Any to work around generic type constraints
-    has_extensions = any(f.name == "extensions" for f in fields(cast(Any, dataclass_type)))
-    return cast(
-        T,
-        dataclass_type(
-            root_node=root,  # type: ignore[call-arg]
-            **field_values,
-            **({"extensions": extract_extension_fields(root, context)} if has_extensions else {}),
-        ),
-    )