relax a few too strict instances of "label" property. Adjust tests to account for this. Add a SchemaFetchWarning to alert users when this fails so it doesn't get missed.

Author: tipatterson-dev

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "oshconnect"
-version = "0.5.1a7"
+version = "0.5.1a9"
 description = "Library for interfacing with OSH, helping guide visualization efforts, and providing a place to store configurations. Implements OGC CS API Part 3 (Pub/Sub) MQTT topic conventions including :data topics and resource event topics."
 readme = "README.md"
 authors = [

src/oshconnect/streamableresource.py

@@ -75,6 +75,21 @@
 from .timemanagement import TimeInstant, TimePeriod, TimeUtils
 
 
+class SchemaFetchWarning(UserWarning):
+    """A datastream/control-stream schema fetch or parse failed during
+    `Node.discover_systems` / `System.discover_datastreams` /
+    `System.discover_controlstreams`.
+
+    Discovery deliberately does not raise on per-resource schema failures —
+    one broken schema would otherwise poison the entire listing. The
+    matching wrapper is still appended (with `record_schema` / `command_schema`
+    left as ``None``), but the original exception is surfaced both here
+    (via ``warnings.warn``) and in the root logger at ERROR level (with a
+    full traceback via ``exc_info=True``). Filter or capture this category
+    if you want to react programmatically.
+    """
+
+
 @dataclass(kw_only=True)
 class Endpoints:
     """Default URL path segments for an OSH server's REST APIs."""
@@ -976,11 +991,12 @@ def discover_datastreams(self) -> list[Datastream]:
                     SWEDatastreamRecordSchema.from_swejson_dict(schema_resp.json())
                 )
             except Exception as e:
-                warnings.warn(
+                msg = (
                     f"Failed to fetch SWE+JSON schema for datastream "
-                    f"{datastream_objs.ds_id}: {e}",
-                    stacklevel=2,
+                    f"{datastream_objs.ds_id}: {type(e).__name__}: {e}"
                 )
+                logging.error(msg, exc_info=True)
+                warnings.warn(msg, SchemaFetchWarning, stacklevel=2)
             datastreams.append(new_ds)
 
             if not [ds.get_underlying_resource() != datastream_objs for ds in self.datastreams]:
@@ -1027,11 +1043,12 @@ def discover_controlstreams(self) -> list[ControlStream]:
                     JSONCommandSchema.from_json_dict(schema_resp.json())
                 )
             except Exception as e:
-                warnings.warn(
+                msg = (
                     f"Failed to fetch command schema for control stream "
-                    f"{controlstream_objs.cs_id}: {e}",
-                    stacklevel=2,
+                    f"{controlstream_objs.cs_id}: {type(e).__name__}: {e}"
                 )
+                logging.error(msg, exc_info=True)
+                warnings.warn(msg, SchemaFetchWarning, stacklevel=2)
             controlstreams.append(new_cs)
 
             if not [cs.get_underlying_resource() != controlstream_objs for cs in self.control_channels]:

src/oshconnect/swe_components.py

@@ -78,7 +78,6 @@ def _fields_require_name(self):
 
 
 class VectorSchema(AnyComponentSchema):
-    label: str = Field(...)
     type: Literal["Vector"] = "Vector"
     definition: str = Field(...)
     reference_frame: str = Field(..., alias='referenceFrame')
@@ -142,7 +141,6 @@ def _items_require_name(self):
 
 
 class GeometrySchema(AnyComponentSchema):
-    label: str = Field(...)
     type: Literal["Geometry"] = "Geometry"
     updatable: bool = Field(False)
     optional: bool = Field(False)
@@ -163,7 +161,6 @@ class GeometrySchema(AnyComponentSchema):
 
 
 class AnySimpleComponentSchema(AnyComponentSchema):
-    label: str = Field(...)
     description: str = Field(None)
     type: str = Field(...)
     updatable: bool = Field(False)

tests/test_discovery.py

@@ -23,6 +23,7 @@
 from oshconnect import Node, System
 from oshconnect.resource_datamodels import DatastreamResource
 from oshconnect.schema_datamodels import SWEDatastreamRecordSchema
+from oshconnect.streamableresource import SchemaFetchWarning
 from oshconnect.timemanagement import TimePeriod
 
 FIXTURES_DIR = Path(__file__).parent / "fixtures"
@@ -191,7 +192,8 @@ def schema_handler(ds_id):
     sys = System(name="s", label="S", urn="urn:test:s",
                  parent_node=node, resource_id="sys-1")
 
-    with pytest.warns(UserWarning, match="Failed to fetch SWE\\+JSON schema"):
+    with pytest.warns(SchemaFetchWarning,
+                      match=r"Failed to fetch SWE\+JSON schema"):
         discovered = sys.discover_datastreams()
 
     assert len(discovered) == 2
@@ -200,4 +202,42 @@ def schema_handler(ds_id):
     assert isinstance(
         by_id["ds-ok"]._underlying_resource.record_schema,
         SWEDatastreamRecordSchema,
+    )
+
+
+def test_discover_datastreams_logs_traceback_on_schema_failure(node, monkeypatch, caplog):
+    """A schema-fetch failure must surface in the root logger with the
+    full traceback (`exc_info=True`), so users who configure logging
+    (the common case) actually see *what* broke — not just that
+    something did."""
+    swe_schema = json.loads(
+        (FIXTURES_DIR / "fake_weather_schema_swejson.json").read_text()
+    )
+
+    def schema_handler(ds_id):
+        if ds_id == "ds-broken":
+            return _MockResponse({"error": "boom"}, status=500)
+        return _MockResponse(swe_schema)
+
+    _install_dispatching_get(
+        monkeypatch,
+        listing_payload=_listing_payload("ds-broken", "ds-ok"),
+        schema_handler=schema_handler,
+    )
+
+    sys = System(name="s", label="S", urn="urn:test:s",
+                 parent_node=node, resource_id="sys-1")
+
+    import logging as _logging
+    with caplog.at_level(_logging.ERROR):
+        with pytest.warns(SchemaFetchWarning):
+            sys.discover_datastreams()
+
+    error_records = [r for r in caplog.records if r.levelno == _logging.ERROR]
+    assert any("ds-broken" in r.getMessage() for r in error_records), (
+        "expected an ERROR log mentioning the failing datastream id"
+    )
+    # exc_info plumbed through: the record carries the original exception
+    assert any(r.exc_info is not None for r in error_records), (
+        "expected at least one ERROR record to carry exc_info (traceback)"
     )

tests/test_swe_components.py

@@ -312,49 +312,55 @@ def test_swe_datastream_root_invalid_name_pattern_raises():
 #   Quantity:  [type, definition, label, uom]
 #   Boolean:   [type, definition, label]
 #   Text:      [type, definition, label]
-#   Vector:    [type, definition, referenceFrame, label, coordinates]
+#   Vector:    [type, definition, referenceFrame, coordinates]
 #   DataRecord:[type, fields]
-#   Geometry:  [type, srs, definition, label]
+#   Geometry:  [type, srs, definition]
+#
+# `label` is optional everywhere — SWE Common 3 inherits it from
+# AbstractDataComponent as optional. OSH emits labelless components
+# in the wild (e.g. the SensorLocation Vector); a required `label`
+# here would break record-schema parsing during discovery.
 
 
 def test_quantity_requires_uom():
     with pytest.raises(ValidationError, match="uom"):
         QuantitySchema(label="X", definition="http://example.org/x")
 
 
-def test_quantity_requires_label():
-    with pytest.raises(ValidationError, match="label"):
-        QuantitySchema(definition="http://example.org/x", uom={"code": "m"})
+def test_quantity_label_is_optional():
+    q = QuantitySchema(definition="http://example.org/x", uom={"code": "m"})
+    assert q.label is None
 
 
 def test_quantity_requires_definition():
     with pytest.raises(ValidationError, match="definition"):
         QuantitySchema(label="X", uom={"code": "m"})
 
 
-def test_boolean_requires_label_and_definition():
-    with pytest.raises(ValidationError, match="label"):
-        BooleanSchema(definition="http://example.org/b")
+def test_boolean_label_optional_definition_required():
+    BooleanSchema(definition="http://example.org/b")  # no label — OK
     with pytest.raises(ValidationError, match="definition"):
         BooleanSchema(label="X")
 
 
-def test_text_requires_label_and_definition():
-    with pytest.raises(ValidationError, match="label"):
-        TextSchema(definition="http://example.org/t")
+def test_text_label_optional_definition_required():
+    TextSchema(definition="http://example.org/t")  # no label — OK
     with pytest.raises(ValidationError, match="definition"):
         TextSchema(label="X")
 
 
-def test_vector_requires_label_definition_referenceframe_coordinates():
+def test_vector_requires_definition_referenceframe_coordinates():
+    # `label` is intentionally NOT in the required set: SWE Common 3 inherits
+    # it from AbstractDataComponent as optional, and OSH emits labelless
+    # Vectors (e.g. SensorLocation). See test_vector_label_is_optional…
     base = dict(
         label="V", definition="http://example.org/v",
         referenceFrame="http://example.org/frames/ENU",
         coordinates=[QuantitySchema(name="x", label="X",
                                     definition="http://example.org/x",
                                     uom={"code": "m"})],
     )
-    for missing in ("label", "definition", "referenceFrame", "coordinates"):
+    for missing in ("definition", "referenceFrame", "coordinates"):
         kwargs = {k: v for k, v in base.items() if k != missing}
         with pytest.raises(ValidationError):
             VectorSchema(**kwargs)
@@ -365,15 +371,23 @@ def test_datarecord_requires_fields():
         DataRecordSchema(name="r")
 
 
-def test_geometry_requires_srs_definition_label():
+def test_geometry_requires_srs_and_definition():
+    # `label` deliberately omitted from required set — SWE Common 3
+    # inherits it from AbstractDataComponent as optional.
     base = dict(label="G", definition="http://example.org/g",
                 srs="http://www.opengis.net/def/crs/EPSG/0/4326")
-    for missing in ("label", "definition", "srs"):
+    for missing in ("definition", "srs"):
         kwargs = {k: v for k, v in base.items() if k != missing}
         with pytest.raises(ValidationError):
             GeometrySchema(**kwargs)
 
 
+def test_geometry_label_is_optional():
+    g = GeometrySchema(definition="http://example.org/g",
+                       srs="http://www.opengis.net/def/crs/EPSG/0/4326")
+    assert g.label is None
+
+
 # --- B.2 discriminator routing ---------------------------------------------
 
 DISCRIMINATOR_CASES = [
@@ -566,6 +580,69 @@ def test_vector_accepts_quantity_in_coordinates():
     })
 
 
+def test_vector_label_is_optional_per_swe_common3():
+    # SWE Common 3 Vector inherits AbstractDataComponent.label as optional;
+    # OSH's SensorLocation datastream emits a labelless Vector. A required
+    # `label` here would break SWE+JSON schema discovery for any datastream
+    # carrying a Vector — see the discover_datastreams cascade.
+    v = VectorSchema.model_validate({
+        "type": "Vector",
+        "name": "location",
+        "definition": "http://www.opengis.net/def/property/OGC/0/SensorLocation",
+        "referenceFrame": "http://www.opengis.net/def/crs/EPSG/0/4979",
+        "coordinates": [_quantity_field("x")],
+    })
+    assert v.label is None
+
+
+def test_swe_datastream_schema_parses_osh_sensor_location_shape():
+    # End-to-end shape mirroring `GET /datastreams/{id}/schema` for OSH's
+    # built-in `sensorLocation` output (CS API SWE+JSON form).
+    payload = {
+        "obsFormat": "application/swe+json",
+        "recordSchema": {
+            "type": "DataRecord",
+            "name": "sensorLocation",
+            "id": "SENSOR_LOCATION",
+            "label": "Sensor Location",
+            "fields": [
+                {
+                    "type": "Time",
+                    "name": "time",
+                    "definition": "http://www.opengis.net/def/property/OGC/0/SamplingTime",
+                    "label": "Sampling Time",
+                    "referenceFrame": "http://www.opengis.net/def/trs/BIPM/0/UTC",
+                    "uom": {"href": "http://www.opengis.net/def/uom/ISO-8601/0/Gregorian"},
+                },
+                {
+                    "type": "Vector",
+                    "name": "location",
+                    "definition": "http://www.opengis.net/def/property/OGC/0/SensorLocation",
+                    "referenceFrame": "http://www.opengis.net/def/crs/EPSG/0/4979",
+                    "localFrame": "#REF_FRAME_LOCAL",
+                    "coordinates": [
+                        {"type": "Quantity", "name": "lat", "label": "Geodetic Latitude",
+                         "definition": "http://sensorml.com/ont/swe/property/GeodeticLatitude",
+                         "axisID": "Lat", "uom": {"code": "deg"}},
+                        {"type": "Quantity", "name": "lon", "label": "Longitude",
+                         "definition": "http://sensorml.com/ont/swe/property/Longitude",
+                         "axisID": "Lon", "uom": {"code": "deg"}},
+                        {"type": "Quantity", "name": "alt", "label": "Ellipsoidal Height",
+                         "definition": "http://sensorml.com/ont/swe/property/HeightAboveEllipsoid",
+                         "axisID": "h", "uom": {"code": "m"}},
+                    ],
+                },
+            ],
+        },
+    }
+    sw = SWEDatastreamRecordSchema.from_swejson_dict(payload)
+    vec = sw.record_schema.fields[1]
+    assert vec.type == "Vector"
+    assert vec.label is None
+    assert vec.reference_frame == "http://www.opengis.net/def/crs/EPSG/0/4979"
+    assert [c.name for c in vec.coordinates] == ["lat", "lon", "alt"]
+
+
 # --- B.6 DataRecord.fields minItems: 1 -------------------------------------
 
 def test_datarecord_empty_fields_rejected():