Enforced the SWE Common 3 SoftNamedProperty rule: components carry an optional name, but every binding context (DataRecord.fields, DataChoice.items, Vector.coordinates, DataArray/Matrix.elementType, and the root recordSchema/resultSchema/parametersSchema of datastream and control‑stream wrappers)

  now validates that each bound child has a non‑empty name matching the NameToken pattern ^[A-Za-z][A-Za-z0-9_\-]*$.

Author: tipatterson-dev

pyproject.toml

@@ -28,3 +28,6 @@ tinydb = ["tinydb>=4.8.0,<5.0.0"]
 
 [tool.setuptools]
 packages = {find = { where = ["src/"]}}
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]

src/oshconnect/schema_datamodels.py

@@ -9,13 +9,13 @@
 from datetime import datetime
 from typing import Union, List
 
-from pydantic import BaseModel, Field, SerializeAsAny, field_validator, HttpUrl, ConfigDict
+from pydantic import BaseModel, Field, SerializeAsAny, field_validator, model_validator, HttpUrl, ConfigDict
 
 from .api_utils import Link, URI
 from .csapi4py.constants import ObservationFormat
 from .encoding import Encoding
 from .geometry import Geometry
-from .swe_components import AnyComponent
+from .swe_components import AnyComponent, check_named
 
 """
 In many of the top level resource models there is a "schema" field of some description. These models are meant to ease
@@ -53,6 +53,11 @@ class SWEJSONCommandSchema(CommandSchema):
     encoding: SerializeAsAny[Encoding] = Field(...)
     record_schema: AnyComponent = Field(..., alias='recordSchema')
 
+    @model_validator(mode="after")
+    def _root_record_schema_requires_name(self):
+        check_named(self.record_schema, "SWEJSONCommandSchema.recordSchema")
+        return self
+
 
 class JSONCommandSchema(CommandSchema):
     """
@@ -65,6 +70,15 @@ class JSONCommandSchema(CommandSchema):
     result_schema: AnyComponent = Field(None, alias='resultSchema')
     feasibility_schema: AnyComponent = Field(None, alias='feasibilityResultSchema')
 
+    @model_validator(mode="after")
+    def _root_schemas_require_name(self):
+        check_named(self.params_schema, "JSONCommandSchema.parametersSchema")
+        if self.result_schema is not None:
+            check_named(self.result_schema, "JSONCommandSchema.resultSchema")
+        if self.feasibility_schema is not None:
+            check_named(self.feasibility_schema, "JSONCommandSchema.feasibilityResultSchema")
+        return self
+
 
 class DatastreamRecordSchema(BaseModel):
     """
@@ -92,6 +106,11 @@ def check_check_obs_format(cls, v):
             raise ValueError('obsFormat must be on of the SWE formats')
         return v
 
+    @model_validator(mode="after")
+    def _root_record_schema_requires_name(self):
+        check_named(self.record_schema, "SWEDatastreamRecordSchema.recordSchema")
+        return self
+
 
 class JSONDatastreamRecordSchema(DatastreamRecordSchema):
     """Datastream observation schema for the JSON media types
@@ -117,6 +136,14 @@ def _check_obs_format(cls, v):
             )
         return v
 
+    @model_validator(mode="after")
+    def _root_schemas_require_name(self):
+        if self.result_schema is not None:
+            check_named(self.result_schema, "JSONDatastreamRecordSchema.resultSchema")
+        if self.parameters_schema is not None:
+            check_named(self.parameters_schema, "JSONDatastreamRecordSchema.parametersSchema")
+        return self
+
 
 class ObservationOMJSONInline(BaseModel):
     """

src/oshconnect/streamableresource.py

@@ -789,7 +789,9 @@ def get_system_resource(self) -> SystemResource:
     def add_insert_datastream(self, datarecord_schema: DataRecordSchema):
         """
         Adds a datastream to the system while also inserting it into the system's parent node via HTTP POST.
-        :param datarecord_schema: DataRecordSchema to be used to define the datastream
+        :param datarecord_schema: DataRecordSchema to be used to define the datastream. Must carry a `name`
+            matching NameToken (^[A-Za-z][A-Za-z0-9_\\-]*$); SWE Common 3 wraps DataStream.elementType in
+            SoftNamedProperty, so the root component requires a name.
         :return:
         """
         print(f'Adding datastream: {datarecord_schema.model_dump_json(exclude_none=True, by_alias=True)}')
@@ -831,7 +833,9 @@ def add_and_insert_control_stream(self, control_stream_record_schema: DataRecord
         """
         Accepts a DataRecordSchema and creates a JSON encoded schema structure ControlStreamResource, which is inserted
         into the parent system via the host node.
-        :param control_stream_record_schema: DataRecordSchema to be used for the control stream
+        :param control_stream_record_schema: DataRecordSchema to be used for the control stream. Must carry a `name`
+            matching NameToken (^[A-Za-z][A-Za-z0-9_\\-]*$); JSONCommandSchema.parametersSchema is wrapped in
+            SoftNamedProperty so the root component requires a name.
         :param input_name: Name of the input, if None the label of the schema is converted to lower and stripped of whitespace
         :return: ControlStream object added to the system
         """

src/oshconnect/swe_components.py

@@ -7,15 +7,34 @@
 
 from __future__ import annotations
 
+import re
 from numbers import Real
 from typing import Union, Any, Literal, Annotated
 
-from pydantic import BaseModel, ConfigDict, Field, field_validator, SerializeAsAny
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator, SerializeAsAny
 
 from .csapi4py.constants import GeometryTypes
 from .api_utils import UCUMCode, URI
 from .geometry import Geometry
 
+# SWE Common 3 NameToken: basicTypes.json#/$defs/NameToken
+_NAME_TOKEN_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_\-]*$")
+
+
+def check_named(component, location: str) -> None:
+    """Validate that a component bound via SoftNamedProperty carries a NameToken `name`."""
+    name = getattr(component, "name", None)
+    if not name:
+        raise ValueError(
+            f"{location}: a component bound here must carry `name` (SWE Common 3 SoftNamedProperty)."
+        )
+    if not _NAME_TOKEN_RE.match(name):
+        raise ValueError(
+            f"{location}: `name` {name!r} does not match NameToken pattern "
+            f"^[A-Za-z][A-Za-z0-9_\\-]*$."
+        )
+
+
 """
  NOTE: The following classes are used to represent the Record Schemas that are required for use with Datastreams
 The names are likely to change to include a "Schema" suffix to differentiate them from the actual data structures.
@@ -34,6 +53,11 @@ class AnyComponentSchema(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
     type: str = Field(...)
     id: str = Field(None)
+    # Wire-format flat carrier for SoftNamedProperty.name. Optional on the component
+    # itself (per AbstractDataComponent.json); enforced as required by parent
+    # binding-context validators (DataRecord/DataChoice/Vector/DataArray/Matrix and
+    # the datastream/controlstream schema wrappers in schema_datamodels.py).
+    name: str = Field(None)
     label: str = Field(None)
     description: str = Field(None)
     updatable: bool = Field(False)
@@ -43,44 +67,61 @@ class AnyComponentSchema(BaseModel):
 
 class DataRecordSchema(AnyComponentSchema):
     type: Literal["DataRecord"] = "DataRecord"
-    # `name` is not part of AbstractDataComponent in SWE Common 3 — it belongs to
-    # the SoftNamedProperty wrapper that binds a component as a record field. We
-    # accept it here only because the OSH server emits `name` at the root-level
-    # DataRecord of a datastream's recordSchema/resultSchema. See
-    # docs/osh_spec_deviations.md (root-component-name).
-    name: str = Field(None)
     fields: list["AnyComponent"] = Field(...)
 
+    @model_validator(mode="after")
+    def _fields_require_name(self):
+        for i, f in enumerate(self.fields):
+            check_named(f, f"DataRecord.fields[{i}]")
+        return self
+
 
 class VectorSchema(AnyComponentSchema):
     label: str = Field(...)
-    name: str = Field(...)
     type: Literal["Vector"] = "Vector"
     definition: str = Field(...)
     reference_frame: str = Field(..., alias='referenceFrame')
     local_frame: str = Field(None, alias='localFrame')
     # TODO: VERIFY might need to be moved further down when these are defined
     coordinates: SerializeAsAny[Union[list[CountSchema], list[QuantitySchema], list[TimeSchema]]] = Field(...)
 
+    @model_validator(mode="after")
+    def _coordinates_require_name(self):
+        for i, c in enumerate(self.coordinates):
+            check_named(c, f"Vector.coordinates[{i}]")
+        return self
+
 
 class DataArraySchema(AnyComponentSchema):
     type: Literal["DataArray"] = "DataArray"
-    name: str = Field(...)
     element_count: dict | str | CountSchema = Field(..., alias='elementCount')  # Should type of Count
     element_type: "AnyComponent" = Field(..., alias='elementType')
     encoding: str = Field(...)  # TODO: implement an encodings class
     values: list = Field(None)
 
+    @model_validator(mode="after")
+    def _element_type_requires_name(self):
+        check_named(self.element_type, "DataArray.elementType")
+        return self
+
 
 class MatrixSchema(AnyComponentSchema):
     type: Literal["Matrix"] = "Matrix"
     element_count: dict | str | CountSchema = Field(..., alias='elementCount')  # Should be type of Count
+    # TODO: spec defines Matrix.elementType as a single component (allOf SoftNamedProperty + AnyComponent),
+    # not a list. Cardinality fix is out of scope for the name-validator change.
     element_type: list["AnyComponent"] = Field(..., alias='elementType')
     encoding: str = Field(...)  # TODO: implement an encodings class
     values: list = Field(None)
     reference_frame: str = Field(None)
     local_frame: str = Field(None)
 
+    @model_validator(mode="after")
+    def _element_type_requires_name(self):
+        for i, et in enumerate(self.element_type):
+            check_named(et, f"Matrix.elementType[{i}]")
+        return self
+
 
 class DataChoiceSchema(AnyComponentSchema):
     type: Literal["DataChoice"] = "DataChoice"
@@ -89,6 +130,12 @@ class DataChoiceSchema(AnyComponentSchema):
     choice_value: CategorySchema = Field(..., alias='choiceValue')  # TODO: Might be called "choiceValues"
     items: list["AnyComponent"] = Field(...)
 
+    @model_validator(mode="after")
+    def _items_require_name(self):
+        for i, item in enumerate(self.items):
+            check_named(item, f"DataChoice.items[{i}]")
+        return self
+
 
 class GeometrySchema(AnyComponentSchema):
     label: str = Field(...)
@@ -127,7 +174,6 @@ class AnySimpleComponentSchema(AnyComponentSchema):
     nil_values: list = Field(None, alias='nilValues')
     constraint: Any = Field(None)
     value: Any = Field(None)
-    name: str = Field(...)
 
 
 class AnyScalarComponentSchema(AnySimpleComponentSchema):