oapi-profile-builder 3.7.5__tar.gz → 3.9.0__tar.gz

{oapi_profile_builder-3.7.5/src/oapi_profile_builder.egg-info → oapi_profile_builder-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oapi-profile-builder
-Version: 3.7.5
+Version: 3.9.0
 Summary: Authoritative tooling for creating OGC API Service Profiles (EDR, Features)
 Author-email: Shane Mill <shane.mill@noaa.gov>
 License: Apache License
@@ -520,6 +520,25 @@ extent_requirements:
 
 At least one of `extent_crs` or `supported_crs` is required. The same applies to TRS and VRS — all are optional individually but at least one CRS constraint must be present.
 
+#### CRS as WKT2 strings — quote with single quotes
+
+CRS/TRS values can be URIs (as above) **or** full WKT2 strings. A WKT2 string embeds double quotes, square brackets and commas — for example `GEOGCRS["WGS 84",...,ID["EPSG",4326]]`. YAML cannot parse this as a bare scalar or a **double-quoted** scalar (the inner `"` end the string early), so it must be wrapped in **single quotes**, or written as a block scalar:
+
+```yaml
+# Single-quoted (recommended) — the whole WKT2 value in one line:
+crs:
+  - 'GEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",...,ID["EPSG",4326]]'
+
+# or a block scalar (`|-` keeps it on multiple lines with no trailing newline):
+extent_requirements:
+  extent_crs:
+    allowed:
+      - |-
+        GEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",...,ID["EPSG",4326]]
+```
+
+Double-quoting (`"GEOGCRS["WGS 84"...]"`) will fail to parse. If a config fails with a YAML parse error near a CRS line, this is almost always the cause — the CLI prints a hint pointing here. Publish the `wkt` conformance class (`.../conf/wkt`) in `required_conformance_classes` when your CRS values are WKT2.
+
 #### Vertical direction (`positive`)
 
 OGC API - EDR's vertical extent has no field for which way values increase. This is ambiguous for VRS like pressure levels, which different providers order top-to-bottom or bottom-to-top inconsistently (pressure increases as altitude *decreases*). Set `extent.vertical.positive` to `up` or `down` on a collection (following the CF Conventions `positive` attribute) to make the ordering explicit:

{oapi_profile_builder-3.7.5 → oapi_profile_builder-3.9.0}/README.md

@@ -473,6 +473,25 @@ extent_requirements:
 
 At least one of `extent_crs` or `supported_crs` is required. The same applies to TRS and VRS — all are optional individually but at least one CRS constraint must be present.
 
+#### CRS as WKT2 strings — quote with single quotes
+
+CRS/TRS values can be URIs (as above) **or** full WKT2 strings. A WKT2 string embeds double quotes, square brackets and commas — for example `GEOGCRS["WGS 84",...,ID["EPSG",4326]]`. YAML cannot parse this as a bare scalar or a **double-quoted** scalar (the inner `"` end the string early), so it must be wrapped in **single quotes**, or written as a block scalar:
+
+```yaml
+# Single-quoted (recommended) — the whole WKT2 value in one line:
+crs:
+  - 'GEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",...,ID["EPSG",4326]]'
+
+# or a block scalar (`|-` keeps it on multiple lines with no trailing newline):
+extent_requirements:
+  extent_crs:
+    allowed:
+      - |-
+        GEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",...,ID["EPSG",4326]]
+```
+
+Double-quoting (`"GEOGCRS["WGS 84"...]"`) will fail to parse. If a config fails with a YAML parse error near a CRS line, this is almost always the cause — the CLI prints a hint pointing here. Publish the `wkt` conformance class (`.../conf/wkt`) in `required_conformance_classes` when your CRS values are WKT2.
+
 #### Vertical direction (`positive`)
 
 OGC API - EDR's vertical extent has no field for which way values increase. This is ambiguous for VRS like pressure levels, which different providers order top-to-bottom or bottom-to-top inconsistently (pressure increases as altitude *decreases*). Set `extent.vertical.positive` to `up` or `down` on a collection (following the CF Conventions `positive` attribute) to make the ordering explicit:

{oapi_profile_builder-3.7.5 → oapi_profile_builder-3.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "oapi-profile-builder"
-version = "3.7.5"
+version = "3.9.0"
 description = "Authoritative tooling for creating OGC API Service Profiles (EDR, Features)"
 readme = "README.md"
 license = { file = "LICENSE" }

{oapi_profile_builder-3.7.5 → oapi_profile_builder-3.9.0}/src/oapi_profile_builder/cli.py

@@ -71,10 +71,42 @@ def _parse_datetimes(obj, _in_examples: bool = False):
 def load_config(path: Path) -> dict:
     text = path.read_text(encoding="utf-8")
     if path.suffix in {".yaml", ".yml"}:
-        return _parse_datetimes(yaml.safe_load(text))
+        try:
+            data = yaml.safe_load(text)
+        except yaml.YAMLError as exc:
+            raise SystemExit(_yaml_error_hint(exc)) from exc
+        return _parse_datetimes(data)
     return _parse_datetimes(json.loads(text))
 
 
+def _yaml_error_hint(exc: "yaml.YAMLError") -> str:
+    """Turn a raw PyYAML parse error into an actionable message.
+
+    The most common failure is an unquoted or double-quoted WKT2 CRS string.
+    WKT2 embeds double quotes, square brackets and commas
+    (e.g. GEOGCRS["WGS 84",...,ID["EPSG",4326]]), which YAML cannot parse as a
+    bare or double-quoted scalar. The value must be wrapped in SINGLE quotes
+    (or written as a block scalar with `|-`).
+    """
+    base = f"Failed to parse YAML config:\n{exc}"
+    text = str(exc)
+    looks_like_wkt = any(tok in text for tok in ("GEOGCRS", "PROJCRS", "BOUNDCRS", "COMPOUNDCRS", '"'))
+    if looks_like_wkt or "expected" in text:
+        base += (
+            "\n\nHint: if a CRS/TRS value is a WKT2 string (e.g. "
+            'GEOGCRS[\"WGS 84\",...,ID[\"EPSG\",4326]]), it contains double quotes, '
+            "square brackets and commas that YAML cannot parse unquoted or "
+            "double-quoted. Wrap the whole value in SINGLE quotes:\n"
+            "    crs:\n"
+            "      - 'GEOGCRS[\"WGS 84\",...,ID[\"EPSG\",4326]]'\n"
+            "or use a block scalar:\n"
+            "    crs:\n"
+            "      - |-\n"
+            '        GEOGCRS["WGS 84",...,ID["EPSG",4326]]'
+        )
+    return base
+
+
 def main() -> None:
     import argparse
 

{oapi_profile_builder-3.7.5 → oapi_profile_builder-3.9.0}/src/oapi_profile_builder/generate.py

@@ -44,7 +44,21 @@ from oapi_profile_builder.models import ServiceProfile
 def _const(val, version: str) -> dict:
     if version == "3.1.0":
         return {"const": val}
-    return {"enum": [val]}
+    return {"enum": [val], "default": val}
+
+def _fixed(val, version: str) -> dict:
+    """Render a reference/example value WITHOUT constraining the schema.
+
+    Descriptive metadata (description, keywords, title, provider details,
+    extent values, the profile URI, ...) are reference values a conforming
+    service echoes, not the *only* allowed value. Emitting them via ``_const``
+    turned every such field into a single-value ``enum`` + ``default`` (OpenAPI
+    3.0) or ``const`` (3.1), which the Swagger Editor flags as a warning and
+    which wrongly implies the value is the sole permitted one. ``_fixed`` uses
+    ``example`` instead: the value is surfaced for documentation/Swagger's
+    "Example Value" pane, but the field stays an unconstrained typed schema.
+    """
+    return {"example": val}
 
 def _contains(schema: dict, version: str) -> dict:
     if version == "3.1.0":
@@ -164,62 +178,82 @@ def _landing_page_schema(profile: "ServiceProfile") -> dict:
             if getattr(l, "hreflang", None): link_obj["hreflang"] = l.hreflang
             links_to_show.append(link_obj)
     else:
+        # Default EDR Part 1 landing-page link set: self, service-desc,
+        # service-doc, conformance, the collections resource (rel 'data'), and
+        # the profile document (rel 'profile' → the spec_uri_base/req/<name> URI).
         links_to_show = [
             {"href": "/", "rel": "self", "type": "application/json", "title": "this document"},
             {"href": "/api", "rel": "service-desc", "type": "application/vnd.oai.openapi+json;version=3.0.0", "title": "the API definition"},
+            {"href": "/api.html", "rel": "service-doc", "type": "text/html", "title": "the API documentation"},
             {"href": "/conformance", "rel": "conformance", "type": "application/json", "title": "OGC API conformance classes implemented by this server"},
             {"href": "/collections", "rel": "data", "type": "application/json", "title": "Information about the collections"},
-            {"href": profile_uri, "rel": "profile", "type": "text/html", "title": "The Service Profile for this API"}
+            {"href": profile_uri, "rel": "profile", "type": "application/yaml", "title": f"OpenAPI Specification Profile for {profile.name}"},
         ]
 
+    # Ensure a rel='profile' link is always present, even when the profile
+    # supplies its own links (Point 4/9: the profile URI belongs in a link
+    # object, not a bespoke x-ogc-profile property).
+    if not any(lk.get("rel") == "profile" for lk in links_to_show):
+        links_to_show.append(
+            {"href": profile_uri, "rel": "profile", "type": "application/yaml",
+             "title": f"OpenAPI Specification Profile for {profile.name}"}
+        )
+
+    # Links are surfaced as concrete data via `example` (not enum) so Swagger's
+    # "Example Value" pane shows the actual hrefs/rels rather than the schema
+    # stub ("href": "string", ...). The schema itself stays unconstrained.
     schema_props: dict = {
         "links": {
             "type": "array",
             "items": link_items,
-            "enum": [links_to_show]
+            "example": links_to_show,
         },
-        "title": {"type": "string", **_const(profile.title, version)},
-        "version": {"type": "string", **_const(profile.version, version)},
-        "x-ogc-profile": {"type": "string", **_const(profile_uri, version)}
+        "title": {"type": "string", **_fixed(profile.title, version)},
+        "version": {"type": "string", **_fixed(profile.version, version)},
     }
-    
+
     if profile.description:
-        schema_props["description"] = {"type": "string", **_const(profile.description, version)}
+        schema_props["description"] = {"type": "string", **_fixed(profile.description, version)}
     if profile.keywords:
         schema_props["keywords"] = {
             "type": "array",
             "items": {"type": "string"},
-            "enum": [profile.keywords]
+            **_fixed(profile.keywords, version)
         }
-    
+
     if profile.provider:
         p = profile.provider
-        provider_props = {"name": {"type": "string", **_const(p.name, version)}}
-        if p.url: provider_props["url"] = {"type": "string", **_const(p.url, version)}
+        provider_props = {"name": {"type": "string", **_fixed(p.name, version)}}
+        if p.url: provider_props["url"] = {"type": "string", **_fixed(p.url, version)}
         if p.contact:
             c = p.contact
             contact_props = {}
-            if c.email: contact_props["email"] = {"type": "string", **_const(c.email, version)}
+            if c.email: contact_props["email"] = {"type": "string", **_fixed(c.email, version)}
+            # Response bodies are free-form JSON (not OpenAPI's restricted
+            # `info` object), so contact fields keep their input names — no
+            # x- prefix (Point 4).
             for key in ("phone", "hours", "instructions", "address", "postalcode", "city", "country"):
                 val = getattr(c, key, None)
-                if val: contact_props[f"x-{key}"] = {"type": "string", **_const(val, version)}
+                if val: contact_props[key] = {"type": "string", **_fixed(val, version)}
             if contact_props: provider_props["contact"] = {"type": "object", "properties": contact_props}
         schema_props["provider"] = {"type": "object", "properties": provider_props}
 
     if profile.classification:
         cl = profile.classification
-        schema_props["x-classification"] = {
+        schema_props["classification"] = {
             "type": "object",
             "properties": {
-                "level": {"type": "string", **_const(cl.level, version)},
-                "system": {"type": "string", **_const(cl.system, version)} if cl.system else {"type": "string"}
+                "classification_level": {"type": "string", **_fixed(cl.classification_level, version)},
+                "classification_system": {"type": "string", **_fixed(cl.classification_system, version)} if cl.classification_system else {"type": "string"}
             }
         }
 
+    if profile.attribution:
+        schema_props["attribution"] = {"type": "string", **_fixed(profile.attribution, version)}
     if profile.metadata_date:
-        schema_props["x-metadata-date"] = {"type": "string", **_const(profile.metadata_date, version)}
+        schema_props["metadata-date"] = {"type": "string", **_fixed(profile.metadata_date, version)}
     if profile.resource_service_publish_date:
-        schema_props["x-resource-publish-date"] = {"type": "string", **_const(profile.resource_service_publish_date, version)}
+        schema_props["resource-publish-date"] = {"type": "string", **_fixed(profile.resource_service_publish_date, version)}
 
     return {
         "description": "Landing page",
@@ -454,6 +488,26 @@ _POST_BODY_SCHEMAS: dict[str, dict] = {
             "f": {"type": "string", "description": "Response format"},
         },
     },
+    # `items` POST mirrors the GET items query parameters (bbox filter,
+    # datetime, parameter-name, crs, z, f). Without this entry the POST body
+    # fell back to an empty {"type": "object"} (Point 10).
+    "items": {
+        "type": "object",
+        "properties": {
+            "bbox": {
+                "type": "array",
+                "description": "Bounding box filter [minLon, minLat, maxLon, maxLat]",
+                "items": {"type": "number"},
+                "minItems": 4,
+                "maxItems": 6,
+            },
+            "datetime": {"type": "string", "description": "RFC 3339 datetime or interval"},
+            "parameter-name": {"type": "string", "description": "Comma-separated list of parameter names to return"},
+            "crs": {"type": "string", "description": "Identifier for the coordinate reference system"},
+            "z": {"type": "string", "description": "Vertical level(s)"},
+            "f": {"type": "string", "description": "Response format"},
+        },
+    },
 }
 
 def _post_operation(get_op: dict, query_type: str, coll: object, responses: dict) -> dict:
@@ -685,10 +739,20 @@ def _collection_response_schema(coll: Collection,
 
     output_formats_schema: dict = {"type": "array", "items": {"type": "string"}}
     if coll.output_formats:
-        output_formats_schema["items"] = {"type": "string", "enum": list(coll.output_formats)}
+        output_formats_schema = {
+            "type": "array",
+            "items": {"type": "string"},
+            **_fixed(list(coll.output_formats), version)
+        }
 
-    if coll.crs: crs_array_schema: dict = {"type": "array", "items": {"type": "string", "enum": list(coll.crs)}}
-    else: crs_array_schema = {"type": "array", "items": supported_crs_schema}
+    if coll.crs:
+        crs_array_schema: dict = {
+            "type": "array",
+            "items": {"type": "string"},
+            **_fixed(list(coll.crs), version)
+        }
+    else:
+        crs_array_schema = {"type": "array", "items": supported_crs_schema}
 
     extent_props: dict = {}
     if coll.extent and coll.extent.spatial:
@@ -696,42 +760,42 @@ def _collection_response_schema(coll: Collection,
         extent_props["spatial"] = {
             "type": "object", "required": ["bbox", "crs"],
             "properties": {
-                "bbox": {"type": "array", "items": {"type": "array", "items": {"type": "number"}}, **_const(s.bbox, version)},
-                "crs": {"type": "string", **_const(s.crs, version)}
+                "bbox": {"type": "array", "items": {"type": "array", "items": {"type": "number"}}, **_fixed(s.bbox, version)},
+                "crs": {"type": "string", **_fixed(s.crs, version)}
             }
         }
     if coll.extent and coll.extent.temporal:
         t = coll.extent.temporal
-        temporal_props = {"trs": {"type": "string", **_const(t.trs, version)}}
+        temporal_props = {"trs": {"type": "string", **_fixed(t.trs, version)}}
         if t.interval:
             temporal_props["interval"] = {
                 "type": "array",
                 "items": {"type": "array", "items": {"type": "string", "nullable": True}},
-                **_const(t.interval, version)
+                **_fixed(t.interval, version)
             }
         if t.values:
             temporal_props["values"] = {
                 "type": "array",
                 "items": {"type": "string"},
-                **_const(t.values, version)
+                **_fixed(t.values, version)
             }
         extent_props["temporal"] = {"type": "object", "required": ["trs"], "properties": temporal_props}
     if coll.extent and coll.extent.vertical:
         v = coll.extent.vertical
-        vertical_props = {"vrs": {"type": "string", **_const(v.vrs, version)}}
+        vertical_props = {"vrs": {"type": "string", **_fixed(v.vrs, version)}}
         if v.interval:
             vertical_props["interval"] = {
                 "type": "array",
                 "items": {"type": "array", "items": {"type": "number"}},
-                **_const(v.interval, version)
+                **_fixed(v.interval, version)
             }
         if v.values:
             vertical_props["values"] = {
                 "type": "array",
                 "items": {"type": "string"},
-                **_const(v.values, version)
+                **_fixed(v.values, version)
             }
-        if getattr(v, "positive", None): vertical_props["positive"] = {"type": "string", **_const(v.positive, version)}
+        if getattr(v, "positive", None): vertical_props["positive"] = {"type": "string", **_fixed(v.positive, version)}
         extent_props["vertical"] = {"type": "object", "required": ["vrs"], "properties": vertical_props}
     if coll.extent and coll.extent.custom:
         custom_items = []
@@ -740,9 +804,9 @@ def _collection_response_schema(coll: Collection,
                 "type": "object",
                 "required": ["id", "interval", "reference"],
                 "properties": {
-                    "id": {"type": "string", **_const(c.id, version)},
-                    "interval": {"type": "array", "items": {"type": "string"}, **_const(c.interval, version)},
-                    "reference": {"type": "string", **_const(c.reference, version)},
+                    "id": {"type": "string", **_fixed(c.id, version)},
+                    "interval": {"type": "array", "items": {"type": "string"}, **_fixed(c.interval, version)},
+                    "reference": {"type": "string", **_fixed(c.reference, version)},
                 }
             })
         extent_props["custom"] = {"type": "array", "items": {"oneOf": custom_items}}
@@ -756,15 +820,15 @@ def _collection_response_schema(coll: Collection,
             if vars_obj:
                 for f in ("query_type", "default_output_format"):
                     v = getattr(vars_obj, f, None); 
-                    if v: vars_props[f] = {"type": "string", **_const(v, version)}
+                    if v: vars_props[f] = {"type": "string", **_fixed(v, version)}
                 if getattr(vars_obj, "output_formats", None):
-                    vars_props["output_formats"] = {"type": "array", "items": {"type": "string", "enum": list(vars_obj.output_formats)}}
+                    vars_props["output_formats"] = {"type": "array", "items": {"type": "string"}, **_fixed(list(vars_obj.output_formats), version)}
                 extra = getattr(vars_obj, "model_extra", {}) or {}
-                if "crs" in extra: vars_props["crs"] = {"type": "array", "items": {"type": "string"}, **_const(extra["crs"], version)}
-                if "crs_details" in extra: vars_props["crs_details"] = {"type": "array", **_const(extra["crs_details"], version)}
+                if "crs" in extra: vars_props["crs"] = {"type": "array", "items": {"type": "string"}, **_fixed(extra["crs"], version)}
+                if "crs_details" in extra: vars_props["crs_details"] = {"type": "array", **_fixed(extra["crs_details"], version)}
             dq_props[dq_name] = {"type": "object", "properties": {"link": {"type": "object", "properties": {
-                "href": {"type": "string", **_const(dq_val.link.href, version)},
-                "rel": {"type": "string", **_const(dq_val.link.rel, version)},
+                "href": {"type": "string", **_fixed(dq_val.link.href, version)},
+                "rel": {"type": "string", **_fixed(dq_val.link.rel, version)},
                 "variables": {"type": "object", "properties": vars_props}
             }}}}
 
@@ -777,18 +841,61 @@ def _collection_response_schema(coll: Collection,
             if getattr(l, "hreflang", None): link_obj["hreflang"] = l.hreflang
             links_to_show.append(link_obj)
 
+    coll_props: dict = {
+        "id": {"type": "string", **_fixed(coll.id, version)},
+        "title": {"type": "string", **_fixed(coll.title, version)} if coll.title else {"type": "string"},
+        "description": {"type": "string", **_fixed(coll.description, version)} if coll.description else {"type": "string"},
+        "keywords": {
+            "type": "array",
+            "items": {"type": "string"},
+            **(_fixed(coll.keywords, version) if coll.keywords else {})
+        },
+        "links": {
+            "type": "array",
+            "items": _LINK_SCHEMA,
+            **(_fixed(links_to_show, version) if links_to_show else {})
+        },
+        "crs": crs_array_schema,
+        "output_formats": output_formats_schema,
+        "parameter_names": {**param_names_schema, "additionalProperties": False},
+        "extent": {"type": "object", "required": ["spatial"], "properties": extent_props},
+        "data_queries": {"type": "object", "properties": dq_props, "additionalProperties": False}
+    }
+
+    # Per-collection metadata (provider, attribution, classification, dates,
+    # locale). Emitted with their plain input names in the response body
+    # (Point 4/13). Collection-level values override the profile-level ones.
+    prov = coll.provider or (profile.provider if profile else None)
+    if prov:
+        provider_props = {"name": {"type": "string", **_fixed(prov.name, version)}}
+        if prov.url: provider_props["url"] = {"type": "string", **_fixed(prov.url, version)}
+        if prov.contact:
+            c = prov.contact
+            contact_props = {}
+            if c.email: contact_props["email"] = {"type": "string", **_fixed(c.email, version)}
+            for key in ("phone", "hours", "instructions", "address", "postalcode", "city", "country"):
+                val = getattr(c, key, None)
+                if val: contact_props[key] = {"type": "string", **_fixed(val, version)}
+            if contact_props: provider_props["contact"] = {"type": "object", "properties": contact_props}
+        coll_props["provider"] = {"type": "object", "properties": provider_props}
+
+    attribution = coll.attribution or (profile.attribution if profile else None)
+    if attribution:
+        coll_props["attribution"] = {"type": "string", **_fixed(attribution, version)}
+
+    cl = coll.classification or (profile.classification if profile else None)
+    if cl:
+        coll_props["classification"] = {
+            "type": "object",
+            "properties": {
+                "classification_level": {"type": "string", **_fixed(cl.classification_level, version)},
+                "classification_system": {"type": "string", **_fixed(cl.classification_system, version)} if cl.classification_system else {"type": "string"}
+            }
+        }
+
     schema: dict = {
         "type": "object", "required": ["id", "links", "extent"],
-        "properties": {
-            "id": {"type": "string", **_const(coll.id, version)},
-            "title": {"type": "string", **_const(coll.title, version)} if coll.title else {"type": "string"},
-            "description": {"type": "string", **_const(coll.description, version)} if coll.description else {"type": "string"},
-            "keywords": {"type": "array", "items": {"type": "string"}, "enum": [coll.keywords] if coll.keywords else [[]]},
-            "links": {"type": "array", "items": _LINK_SCHEMA, "enum": [links_to_show]}, "crs": crs_array_schema, "output_formats": output_formats_schema,
-            "parameter_names": {**param_names_schema, "additionalProperties": False},
-            "extent": {"type": "object", "required": ["spatial"], "properties": extent_props},
-            "data_queries": {"type": "object", "properties": dq_props, "additionalProperties": False}
-        }
+        "properties": coll_props,
     }
     return {"description": "Collection metadata", "content": {"application/json": {"schema": schema}}}
 def _f_enum(profile: "ServiceProfile | None") -> list[str]:
@@ -1112,6 +1219,95 @@ def _collection_paths(coll: Collection, examples: dict | None = None,
     return paths
 
 
+def _collections_response_schema(profile: "ServiceProfile") -> dict:
+    """Build the /collections 200 response per OGC API - EDR Part 1 (§E.4).
+
+    The response is an object with:
+      - ``links``: a rel 'self' (application/json) and rel 'alternate'
+        (text/html) link, surfaced as example data (Point 5/7);
+      - ``collections``: an array whose items reuse each collection's own
+        response schema (id, title, description, extent, parameter_names,
+        data_queries, provider, ...), so the enumerated collection definitions
+        (e.g. the ``earth_observations_lightning`` collection with its
+        ``frequency_of_lightning_flashes_per_unit_area`` parameter) appear here
+        rather than only a bare links stub (Point 7).
+    """
+    version = profile.openapi_version
+
+    links_example = [
+        {"href": "/collections", "rel": "self", "type": "application/json", "title": "this document"},
+        {"href": "/collections?f=html", "rel": "alternate", "type": "text/html", "title": "this document as HTML"},
+    ]
+
+    # Each collection's item schema is the `schema` node of its own
+    # collection-metadata response, so /collections and /collections/{id}
+    # stay consistent.
+    collection_item_schemas = [
+        _collection_response_schema(coll, profile)["content"]["application/json"]["schema"]
+        for coll in profile.collections
+    ]
+    if len(collection_item_schemas) == 1:
+        collection_items_schema = collection_item_schemas[0]
+    else:
+        collection_items_schema = {"oneOf": collection_item_schemas}
+
+    schema = {
+        "type": "object",
+        "required": ["links", "collections"],
+        "properties": {
+            "links": {
+                "type": "array",
+                "items": _LINK_SCHEMA,
+                "example": links_example,
+            },
+            "collections": {
+                "type": "array",
+                "items": collection_items_schema,
+            },
+        },
+    }
+    return {"description": "Collections", "content": {"application/json": {"schema": schema}}}
+
+
+def _api_response_schema(profile: "ServiceProfile") -> dict:
+    """Build the /api 200 response.
+
+    The OpenAPI definition document is served here, and (Point 9) it advertises
+    the rel 'profile' link pointing at spec_uri_base/req/<name>, mirroring the
+    profile link in the landing page. The link is surfaced as example data.
+    """
+    profile_link = {
+        "href": profile.req_uri,
+        "rel": "profile",
+        "type": "application/yaml",
+        "title": f"OpenAPI Specification Profile for {profile.name}",
+    }
+    self_link = {
+        "href": "/api",
+        "rel": "self",
+        "type": "application/vnd.oai.openapi+json;version=3.0.0",
+        "title": "this document",
+    }
+    schema = {
+        "type": "object",
+        "description": "OpenAPI definition document",
+        "properties": {
+            "links": {
+                "type": "array",
+                "items": _LINK_SCHEMA,
+                "example": [self_link, profile_link],
+            },
+        },
+    }
+    return {
+        "description": "OpenAPI document",
+        "content": {
+            "application/vnd.oai.openapi+json;version=3.0.0": {"schema": schema},
+            "text/html": {"schema": {"type": "string"}},
+        },
+    }
+
+
 def _core_paths(profile: ServiceProfile) -> dict:
     version = profile.openapi_version
     landing_response = _landing_page_schema(profile)
@@ -1123,11 +1319,10 @@ def _core_paths(profile: ServiceProfile) -> dict:
         if version == "3.1.0":
             schema["properties"]["conformsTo"]["contains"] = {"enum": profile.required_conformance_classes}
         else:
-            # Force listing all expected classes in Swagger UI by using enum at the array level
             schema["properties"]["conformsTo"] = {
                 "type": "array",
                 "items": {"type": "string"},
-                "enum": [profile.required_conformance_classes]
+                **_const(profile.required_conformance_classes, version)
             }
     
     return {
@@ -1153,7 +1348,7 @@ def _core_paths(profile: ServiceProfile) -> dict:
             "operationId": "getCollections",
             "tags": ["server"],
             "parameters": [_F, _LANG],
-            "responses": {"200": {"description": "Collections list", "content": {"application/json": {"schema": {"type": "object", "properties": {"links": _LINKS_ARRAY}}}}}, "400": _ERR_400, "500": _ERR_500},
+            "responses": {"200": _collections_response_schema(profile), "400": _ERR_400, "500": _ERR_500},
         }},
         "/api": {"get": {
             "summary": "OpenAPI definition",
@@ -1161,7 +1356,7 @@ def _core_paths(profile: ServiceProfile) -> dict:
             "operationId": "getOpenAPI",
             "tags": ["server"],
             "parameters": [_F],
-            "responses": {"200": {"description": "OpenAPI document"}, "default": _ERR_DEFAULT},
+            "responses": {"200": _api_response_schema(profile), "default": _ERR_DEFAULT},
         }},
     }
 
@@ -1333,10 +1528,12 @@ def build_openapi(profile: ServiceProfile) -> dict:
     if profile.classification:
         info["x-classification"] = {
             k: v for k, v in (
-                ("level", profile.classification.level),
-                ("system", profile.classification.system),
+                ("classification_level", profile.classification.classification_level),
+                ("classification_system", profile.classification.classification_system),
             ) if v
         }
+    if profile.attribution:
+        info["x-attribution"] = profile.attribution
     if profile.metadata_date:
         info["x-metadata-date"] = profile.metadata_date
     if profile.resource_service_publish_date:
@@ -1373,7 +1570,7 @@ def build_openapi(profile: ServiceProfile) -> dict:
                 "lang": {
                     "name": "lang", "in": "query", "required": False,
                     "description": "The optional lang parameter instructs the server return a response in a certain language, if supported.",
-                    "schema": {"type": "string", "default": "en-US", "enum": ["en-US"]},
+                    "schema": {"type": "string", "default": profile.effective_language, "enum": profile.effective_languages},
                 },
             },
             "responses": {
@@ -2341,7 +2538,7 @@ def _build_sections(profile: ServiceProfile) -> dict[str, str]:
     classification_banner = ""
     if profile.classification:
         cl = profile.classification
-        label = cl.level + (f" ({cl.system})" if cl.system else "")
+        label = cl.classification_level + (f" ({cl.classification_system})" if cl.classification_system else "")
         classification_banner = f"*SECURITY CLASSIFICATION: {label}*\n\n"
 
     # --- Point of contact paragraph (from provider) ---

{oapi_profile_builder-3.7.5 → oapi_profile_builder-3.9.0}/src/oapi_profile_builder/models.py

@@ -47,7 +47,15 @@ from annotated_types import Len
 from edr_pydantic.link import Link
 from edr_pydantic.collections import Collection as EDRCollection
 from edr_pydantic.extent import Custom, Extent as EDRExtent, Spatial, Vertical
-from pydantic import AwareDatetime, BaseModel, Field, field_validator, model_validator
+from pydantic import (
+    AliasChoices,
+    AwareDatetime,
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_validator,
+    model_validator,
+)
 
 
 # ---------------------------------------------------------------------------
@@ -110,9 +118,27 @@ class ExtentWithNullBounds(EDRExtent):
 
 
 class Classification(BaseModel):
-    """Security classification metadata (e.g. for DGIWG / military profiles)."""
-    level: str = Field(description="Classification level, e.g. 'NATO RESTRICTED (NR)'")
-    system: str | None = Field(default=None, description="Classification system, e.g. 'NATO'")
+    """Security classification metadata (e.g. for DGIWG / military profiles).
+
+    The canonical field names are ``classification_level`` and
+    ``classification_system`` (a DGIWG requirement). The legacy names
+    ``level`` and ``system`` are accepted as input aliases so existing
+    profiles keep validating, but the generated output uses the DGIWG names.
+    """
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    classification_level: str = Field(
+        validation_alias=AliasChoices("classification_level", "level"),
+        serialization_alias="classification_level",
+        description="Classification level, e.g. 'NATO RESTRICTED (NR)'",
+    )
+    classification_system: str | None = Field(
+        default=None,
+        validation_alias=AliasChoices("classification_system", "system"),
+        serialization_alias="classification_system",
+        description="Classification system, e.g. 'NATO'",
+    )
 
 
 class ProviderContact(BaseModel):
@@ -175,6 +201,14 @@ class Collection(EDRCollection):
     # value for this collection. Round-tripped into profile_config.json.
     classification: Optional[Classification] = None
     provider: Optional[Provider] = None
+    attribution: Optional[str] = Field(
+        default=None,
+        description=(
+            "Attribution / acknowledgement for this collection (OGC API collection "
+            "metadata). Overrides the profile-level attribution for this collection. "
+            "Surfaces as a plain 'attribution' property in the collection object."
+        ),
+    )
     metadata_date: Optional[str] = None
     resource_service_publish_date: Optional[str] = None
     resource_default_locale: Optional[str] = None
@@ -218,6 +252,15 @@ class Collection(EDRCollection):
             )
         return v
 
+    @field_validator("description", "attribution")
+    @classmethod
+    def _strip_freetext(cls, v: str | None) -> str | None:
+        # YAML folded scalars ('>') append a trailing newline; strip it so it
+        # doesn't leak into the generated collection metadata.
+        if v is None:
+            return v
+        return v.strip()
+
 
 # ---------------------------------------------------------------------------
 # Enumerations (profile-specific; EDR data model enums live in edr-pydantic)
@@ -861,6 +904,17 @@ class ServiceProfile(BaseModel):
             "OpenAPI info block and the landing page response."
         ),
     )
+    attribution: str | None = Field(
+        default=None,
+        description=(
+            "Attribution / acknowledgement for the service or its data, per the "
+            "OGC API landing-page metadata (title/description/attribution). Surfaces "
+            "as a plain 'attribution' property in the landing page response and in "
+            "each collection object (collection-level overrides this profile-level "
+            "value). Aligns with EDR Part 3 ATS A.5, which inherits it from OGC API - "
+            "Common."
+        ),
+    )
     keywords: list[str] = Field(
         default_factory=list,
         description=(
@@ -900,6 +954,23 @@ class ServiceProfile(BaseModel):
         default=None,
         description="Default locale of the resource (e.g. 'eng'). Surfaces as info.x-default-locale.",
     )
+    default_language: str | None = Field(
+        default=None,
+        description=(
+            "Default value for the `lang` query parameter (e.g. 'en-US', 'en-GB', "
+            "'fr'). When unset, falls back to 'en-US'. Drives the `lang` parameter's "
+            "`default` in the generated OpenAPI."
+        ),
+    )
+    supported_languages: list[str] = Field(
+        default_factory=list,
+        description=(
+            "Languages the service supports for the `lang` query parameter. When set, "
+            "drives the `lang` parameter's `enum` in the generated OpenAPI (allowing "
+            "more than one language). When empty, the enum contains just the effective "
+            "default language."
+        ),
+    )
     collections: list[Collection] = Field(min_length=1)
     collection_examples: dict[str, dict] = Field(default_factory=dict)
     requirements: list[Requirement] = Field(default_factory=list)
@@ -1032,6 +1103,30 @@ class ServiceProfile(BaseModel):
         ),
     )
 
+    @field_validator("description", "attribution")
+    @classmethod
+    def _strip_freetext(cls, v: str | None) -> str | None:
+        # YAML folded scalars ('>') append a trailing newline; strip surrounding
+        # whitespace so it doesn't leak into the OpenAPI/landing-page output.
+        if v is None:
+            return v
+        return v.strip()
+
+    @property
+    def effective_language(self) -> str:
+        """Default `lang` value: explicit default_language, else 'en-US'."""
+        return self.default_language or "en-US"
+
+    @property
+    def effective_languages(self) -> list[str]:
+        """Enum of `lang` values: supported_languages, else just the default."""
+        if self.supported_languages:
+            langs = list(dict.fromkeys(self.supported_languages))
+            if self.effective_language not in langs:
+                langs.insert(0, self.effective_language)
+            return langs
+        return [self.effective_language]
+
     # OGC identifiers derived from name and spec_uri_base — not user-supplied directly
     @property
     def req_uri(self) -> str:
@@ -1127,7 +1222,7 @@ class ServiceProfile(BaseModel):
         def _check(label: str, value: str, constraint: "CrsConstraint | None") -> None:
             if constraint is None:
                 return
-            if constraint.allowed is not None and value not in constraint.allowed:
+            if constraint.allowed is not None and not _crs_in_allowed(value, constraint.allowed):
                 raise ValueError(
                     f"{label} '{value}' is not in allowed list {constraint.allowed}"
                 )
@@ -1421,3 +1516,42 @@ def _compile_optional_pattern(label: str, pattern: str | None) -> re.Pattern | N
         return re.compile(pattern)
     except re.error as exc:
         raise ValueError(f"Invalid {label} regex '{pattern}': {exc}") from exc
+
+
+def _normalize_crs(value: str) -> str:
+    """Normalize a CRS value for tolerant comparison.
+
+    URI CRS values are compared verbatim (after stripping). WKT2 CRS strings
+    (e.g. GEOGCRS["WGS 84",...,ID["EPSG",4326]]) carry insignificant whitespace
+    between tokens — after commas, around brackets — that differs by hand-
+    editing but does not change meaning. Comparing such strings byte-for-byte
+    makes an `allowed` list extremely fragile: a single space (e.g.
+    '...ensemble", MEMBER[' vs '...ensemble",MEMBER[') fails the match.
+
+    For WKT-looking values (containing '[' and ']'), this collapses whitespace
+    that sits OUTSIDE double-quoted substrings, so token spacing no longer
+    matters while quoted names (e.g. "WGS 84") are preserved exactly.
+    """
+    v = value.strip()
+    if "[" not in v or "]" not in v:
+        return v
+    out: list[str] = []
+    in_quotes = False
+    for ch in v:
+        if ch == '"':
+            in_quotes = not in_quotes
+            out.append(ch)
+        elif ch.isspace() and not in_quotes:
+            # drop insignificant whitespace between WKT tokens
+            continue
+        else:
+            out.append(ch)
+    return "".join(out)
+
+
+def _crs_in_allowed(value: str, allowed: list[str]) -> bool:
+    """True if *value* matches any entry in *allowed*, WKT-whitespace tolerant."""
+    if value in allowed:
+        return True
+    nv = _normalize_crs(value)
+    return any(nv == _normalize_crs(a) for a in allowed)

{oapi_profile_builder-3.7.5 → oapi_profile_builder-3.9.0/src/oapi_profile_builder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oapi-profile-builder
-Version: 3.7.5
+Version: 3.9.0
 Summary: Authoritative tooling for creating OGC API Service Profiles (EDR, Features)
 Author-email: Shane Mill <shane.mill@noaa.gov>
 License: Apache License
@@ -520,6 +520,25 @@ extent_requirements:
 
 At least one of `extent_crs` or `supported_crs` is required. The same applies to TRS and VRS — all are optional individually but at least one CRS constraint must be present.
 
+#### CRS as WKT2 strings — quote with single quotes
+
+CRS/TRS values can be URIs (as above) **or** full WKT2 strings. A WKT2 string embeds double quotes, square brackets and commas — for example `GEOGCRS["WGS 84",...,ID["EPSG",4326]]`. YAML cannot parse this as a bare scalar or a **double-quoted** scalar (the inner `"` end the string early), so it must be wrapped in **single quotes**, or written as a block scalar:
+
+```yaml
+# Single-quoted (recommended) — the whole WKT2 value in one line:
+crs:
+  - 'GEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",...,ID["EPSG",4326]]'
+
+# or a block scalar (`|-` keeps it on multiple lines with no trailing newline):
+extent_requirements:
+  extent_crs:
+    allowed:
+      - |-
+        GEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",...,ID["EPSG",4326]]
+```
+
+Double-quoting (`"GEOGCRS["WGS 84"...]"`) will fail to parse. If a config fails with a YAML parse error near a CRS line, this is almost always the cause — the CLI prints a hint pointing here. Publish the `wkt` conformance class (`.../conf/wkt`) in `required_conformance_classes` when your CRS values are WKT2.
+
 #### Vertical direction (`positive`)
 
 OGC API - EDR's vertical extent has no field for which way values increase. This is ambiguous for VRS like pressure levels, which different providers order top-to-bottom or bottom-to-top inconsistently (pressure increases as altitude *decreases*). Set `extent.vertical.positive` to `up` or `down` on a collection (following the CF Conventions `positive` attribute) to make the ordering explicit: