atmos-validation 2.1.2__tar.gz → 2.2.0__tar.gz

{atmos_validation-2.1.2 → atmos_validation-2.2.0}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [2.2.0](https://github.com/equinor/atmos-validation/compare/v2.1.2...v2.2.0) (2026-11-13)
+
+
+### Features
+
+* Add contractor validation and ascii -> netcdf conversion ([#128](https://github.com/equinor/atmos-validation/issues/128)) ([43769dd](https://github.com/equinor/atmos-validation/commit/43769dd40c3e5c6aa07cfe28f92341fd63c48089))
+* **validate-ascii:** standardize location notation and datum ([#126](https://github.com/equinor/atmos-validation/issues/126)) ([fb2e5e5](https://github.com/equinor/atmos-validation/commit/fb2e5e551fc230ed453e87c58cd984313dc376f2))
+* **validate-netcdf:** validate averaging_period units ([#120](https://github.com/equinor/atmos-validation/issues/120)) ([11d2431](https://github.com/equinor/atmos-validation/commit/11d2431e6c8105a82975def1ed4c80aa6b7dfc9c))
+* **validate-netcdf:** validate instrument_types/instrument_specifications count match ([#119](https://github.com/equinor/atmos-validation/issues/119)) ([47a95b1](https://github.com/equinor/atmos-validation/commit/47a95b1a8e56836bcd2d770db66def5e6864f7e7))
+* **validate-netcdf:** validate location notation and datum ([#125](https://github.com/equinor/atmos-validation/issues/125)) ([6ab4c15](https://github.com/equinor/atmos-validation/commit/6ab4c15a72463fc134dd3714ab1de53880e1bf5f))
+* **validate-netcdf:** validate total_water_depth unit ([#121](https://github.com/equinor/atmos-validation/issues/121)) ([a8a3a98](https://github.com/equinor/atmos-validation/commit/a8a3a984a6f7afc04f1a4aa1b2226cc51316b92d))
+
+
+### Bug Fixes
+
+* Update contractor and division handling  ([#129](https://github.com/equinor/atmos-validation/issues/129)) ([a8ce84f](https://github.com/equinor/atmos-validation/commit/a8ce84f3f408b0e6dd39da52fd05c44ad7de343f))
+* **validate-netcdf:** allow "NA" for averaging_period ([#127](https://github.com/equinor/atmos-validation/issues/127)) ([bc64afb](https://github.com/equinor/atmos-validation/commit/bc64afb97f837a19e3afacba9c9a2b68fa546369))
+
 ## [2.1.2](https://github.com/equinor/atmos-validation/compare/v2.1.1...v2.1.2) (2026-11-09)
 
 

{atmos_validation-2.1.2 → atmos_validation-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: atmos_validation
-Version: 2.1.2
+Version: 2.2.0
 Summary: A python library containing automated data validation tools for the Atmos Data Service
 Project-URL: Repository, https://github.com/equinor/atmos-validation
 Project-URL: Documentation, https://github.com/equinor/atmos-validation/tree/main/docs

{atmos_validation-2.1.2 → atmos_validation-2.2.0}/atmos_validation/convert_ascii/attrs_to_meta.py

@@ -21,9 +21,7 @@ def parse_measurement_attrs(file_name: str, attrs_map_path: str):
             if line.startswith("%"):
                 attrs.update(
                     {
-                        metadata: (
-                            *map(lambda s: s.strip(), filter(None, line.split(":"))),
-                        )[-1]
+                        metadata: line.partition(":")[2].strip()
                         for metadata, attr in attrs_map.items()
                         if line.replace("%", "")
                         .strip()
@@ -39,6 +37,16 @@ def parse_measurement_attrs(file_name: str, attrs_map_path: str):
         attrs["source_file"] = (
             file_name.replace("ø", "oe").replace("æ", "ae").replace("å", "aa")
         )  # NetCDF attrs can not have Norwegian letters
+        contractor = attrs.pop("contractor", "NA")
+        attrs["contractor"] = (
+            [c.strip() for c in contractor.split(",")] if contractor.strip() else []
+        )
+        contractor_division = attrs.pop("contractor_division", "")
+        attrs["contractor_division"] = (
+            []
+            if not contractor_division.strip()
+            else [c.strip() for c in contractor_division.split(",")]
+        )
         if "asset" not in attrs:
             attrs["asset"] = "NA"
         if "country" not in attrs:

{atmos_validation-2.1.2 → atmos_validation-2.2.0}/atmos_validation/convert_ascii/measurement_metadata_to_schema.json

@@ -2,6 +2,7 @@
   "asset": "Asset",
   "comments": "Comments",
   "contractor": "Contractor/Data Responsible",
+  "contractor_division": "Contractor Division",
   "country": "Country",
   "data_history": "Data history",
   "final_reports": "Final Reports",

{atmos_validation-2.1.2 → atmos_validation-2.2.0}/atmos_validation/convert_ascii/parsers.py

@@ -13,22 +13,18 @@ MISSING_HEIGHT = -99999
 def parse_location_text(line_content: str) -> Tuple[float, float]:
     """Parses Location text into a float tuple (lat, lon)
 
+    Expects the new "<lat>N <lon>E" decimal notation (sign carries the
+    hemisphere), e.g. "60.3589N 70.8764E" or "-60.3589N -70.8764E".
+
     Args:
         line_content: the raw location text line
 
     Returns:
         float numbers tuple (lat, lon)
     """
-    location_text = line_content.split(":", 1)[1].split(",")[0]
-    location_text = location_text.replace("Â", "")
-    match = re.findall(r"[-+]?(?:\d*\.*\d+)", location_text)
-    is_east = 1
-    is_north = 1
-    if "S" in location_text:
-        is_north = -1
-    if "W" in location_text:
-        is_east = -1
-    return (float(match[0]) * is_north, float(match[1]) * is_east)
+    location_text = line_content.split(":", 1)[1].split(",")[0].strip()
+    match = re.findall(r"-?[0-9]+\.[0-9]+", location_text)
+    return (float(match[0]), float(match[1]))
 
 
 def data_frame_parser(header_line: str, data_lines: List[List[str]]) -> pd.DataFrame:

atmos_validation-2.2.0/atmos_validation/convert_ascii/tests/test_attrs_to_meta.py

@@ -0,0 +1,101 @@
+import numpy as np
+import pytest
+import xarray as xr
+
+from atmos_validation.convert_ascii import attrs_to_meta
+from atmos_validation.convert_ascii.df_to_nc import assign_metadata_to_ds
+from atmos_validation.convert_ascii.utils import store_netcdf
+
+
+@pytest.mark.parametrize(
+    ("contractor", "division", "expected_contractors", "expected_divisions"),
+    [
+        ("Oceanweather Inc.", "Marine", ["Oceanweather Inc."], ["Marine"]),
+        ("NA", "NA", ["NA"], ["NA"]),
+        ("Fugro, RPS", "Fugro GB Ltd., NA", ["Fugro", "RPS"], ["Fugro GB Ltd.", "NA"]),
+        (
+            "Fugro, RPS",
+            "NA, RPS Group Inc.",
+            ["Fugro", "RPS"],
+            ["NA", "RPS Group Inc."],
+        ),
+        ("Fugro, RPS", "NA, NA", ["Fugro", "RPS"], ["NA", "NA"]),
+        ("Fugro, RPS", "", ["Fugro", "RPS"], []),
+        ("Fugro, RPS", None, ["Fugro", "RPS"], []),
+    ],
+)
+def test_ascii_contractors_are_converted_to_lists(
+    tmp_path,
+    monkeypatch,
+    contractor,
+    division,
+    expected_contractors,
+    expected_divisions,
+):
+    attrs_map = {
+        "comments": "Comments",
+        "contractor": "Contractor/Data Responsible",
+        "contractor_division": "Contractor Division",
+        "data_history": "History",
+        "final_reports": "Final reports",
+        "project_name": "Project",
+        "qc_provider": "QC provider",
+        "averaging_period": "Averaging period",
+        "data_usability": "Data usability",
+        "instrument_types": "Instrument types",
+        "instrument_specifications": "Instrument specifications",
+        "installation_type": "Installation type",
+        "country": "Country",
+        "location": "Location",
+        "mooring_name": "Mooring name",
+        "total_water_depth": "Total water depth",
+    }
+    monkeypatch.setattr(attrs_to_meta, "get_encoding", lambda _: "utf-8")
+    monkeypatch.setattr(attrs_to_meta, "load_attrs_map", lambda _: attrs_map)
+    source = tmp_path / "measurement.txt"
+    source.write_text(
+        "\n".join(
+            [
+                "% Comments: processed",
+                f"% Contractor/Data Responsible: {contractor}",
+                *(
+                    [f"% Contractor Division: {division}"]
+                    if division is not None
+                    else []
+                ),
+                "% History: Original data",
+                "% Final reports: NA",
+                "% Project: Example",
+                "% QC provider: Example QC",
+                "% Averaging period: 10 min",
+                "% Data usability: usable",
+                "% Instrument types: sensor",
+                "% Instrument specifications: specification",
+                "% Installation type: fixed",
+                "% Country: NO",
+                "% Location: North Sea",
+                "% Mooring name: Example",
+                "% Total water depth: 100 m",
+            ]
+        ),
+        encoding="utf-8",
+    )
+
+    metadata = attrs_to_meta.parse_measurement_attrs(str(source), "unused")
+
+    assert metadata.contractor == expected_contractors
+    assert metadata.contractor_division == expected_divisions
+
+    ds = xr.Dataset(coords={"Time": [np.datetime64("2026-01-01", "ns")]})
+    assign_metadata_to_ds(str(source), ds)
+    assert ds.attrs["contractor"] == expected_contractors
+    assert ds.attrs["contractor_division"] == expected_divisions
+
+    path = store_netcdf(str(source), ds)
+    with xr.open_dataset(path, engine="h5netcdf") as reopened:
+        for key, expected in (
+            ("contractor", expected_contractors),
+            ("contractor_division", expected_divisions),
+        ):
+            actual = reopened.attrs[key]
+            assert ([actual] if isinstance(actual, str) else list(actual)) == expected

atmos_validation-2.2.0/atmos_validation/convert_ascii/tests/test_parsers.py

@@ -0,0 +1,15 @@
+from ..parsers import parse_location_text
+
+
+def test_parse_location_text_north_east():
+    """Tests parsing a north-east location line into signed (lat, lon) floats"""
+    lat, lon = parse_location_text("% Location: 60.3589N 70.8764E, WGS84")
+    assert lat == 60.3589
+    assert lon == 70.8764
+
+
+def test_parse_location_text_south_west():
+    """Tests parsing a south-west location line (negative sign) into signed (lat, lon) floats"""
+    lat, lon = parse_location_text("% Location: -60.3589N -70.8764E, WGS84")
+    assert lat == -60.3589
+    assert lon == -70.8764

{atmos_validation-2.1.2 → atmos_validation-2.2.0}/atmos_validation/schemas/__init__.py

@@ -1,3 +1,4 @@
+from .contractor import *
 from .data_usability_level import *
 from .data_usability_levels import *
 from .dim_constants import *

atmos_validation-2.2.0/atmos_validation/schemas/contractor.py

@@ -0,0 +1,73 @@
+from typing import Annotated
+
+from pydantic import BaseModel, Field, StringConstraints, field_validator
+
+ContractorName = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1)]
+
+
+class Contractor(BaseModel, extra="forbid"):
+    contractor: ContractorName
+    divisions: list[ContractorName] | None = Field(
+        default=None,
+        description="Allowed divisions. Null or an empty list means no divisions are configured.",
+    )
+
+    @field_validator("divisions")
+    @classmethod
+    def validate_unique_divisions(cls, divisions: list[str] | None) -> list[str] | None:
+        if divisions is not None and len(divisions) != len(set(divisions)):
+            raise ValueError("Division names must be unique within a contractor")
+        return divisions
+
+
+class Contractors(BaseModel):
+    configs: list[Contractor]
+
+    @field_validator("configs")
+    @classmethod
+    def validate_unique_contractors(cls, configs: list[Contractor]) -> list[Contractor]:
+        names = [entry.contractor for entry in configs]
+        if len(names) != len(set(names)):
+            raise ValueError("Contractor names must be unique")
+        return configs
+
+
+def validate_contractor_metadata(
+    contractor_names: list[str],
+    contractor_divisions: list[str],
+    configs: list[Contractor],
+) -> list[str]:
+    """Validate contractor names and their positionally corresponding divisions."""
+    configs_by_name = {config.contractor: config for config in configs}
+    errors = [
+        f'Contractor "{name}" is not in the allowed list.'
+        for name in contractor_names
+        if name.upper() != "NA" and name not in configs_by_name
+    ]
+
+    if not contractor_names:
+        return [
+            f'Division "{division}" is not allowed without a contractor.'
+            for division in contractor_divisions
+            if division.upper() != "NA"
+        ]
+    if not contractor_divisions:
+        return errors
+    if len(contractor_names) != len(contractor_divisions):
+        errors.append(
+            "Contractor and contractor_division lists must have the same length "
+            "when divisions are provided. Use NA for unspecified divisions."
+        )
+        return errors
+
+    for name, division in zip(contractor_names, contractor_divisions):
+        if division.upper() == "NA":
+            continue
+        config = configs_by_name.get(name)
+        allowed_divisions = (config.divisions or []) if config is not None else []
+        if division not in allowed_divisions:
+            errors.append(
+                f'Division "{division}" is not allowed for contractor "{name}". '
+                f"Allowed values: {sorted(allowed_divisions)}"
+            )
+    return errors

{atmos_validation-2.1.2 → atmos_validation-2.2.0}/atmos_validation/schemas/metadata.py

@@ -23,7 +23,8 @@ class CommonMetadata(BaseModel):
     model_config = ConfigDict(use_enum_values=True)
 
     comments: Union[List[str], str]
-    contractor: str
+    contractor: Union[List[str], str] = Field(default_factory=list)
+    contractor_division: Union[List[str], str] = Field(default_factory=list)
     classification_level: ClassificationLevel = Field(
         default=ClassificationLevel.INTERNAL
     )
@@ -66,4 +67,4 @@ class MeasurementMetadata(CommonMetadata):
     location: Union[str, List[str]]
     mooring_name: str
     source_file: str
-    total_water_depth: Union[str, float]
+    total_water_depth: str

{atmos_validation-2.1.2 → atmos_validation-2.2.0}/atmos_validation/validate_ascii/header_metadata.py

@@ -12,6 +12,7 @@ from .header_position import HeaderPosition
 class HeaderMetaData:
     number_of_header_lines: int
     contractor: str
+    contractor_division: str
     final_report: str
     qc: str
     duration: HeaderDate

{atmos_validation-2.1.2 → atmos_validation-2.2.0}/atmos_validation/validate_ascii/header_names.py

@@ -3,6 +3,7 @@ from enum import Enum
 
 class Headers(str, Enum):
     CONTRACTOR = "Contractor/Data Responsible"
+    CONTRACTOR_DIVISION = "Contractor Division"
     FINAL_REPORT = "Final Reports"
     QC = "QC Provider"
     DURATION = "Duration of Data"

{atmos_validation-2.1.2 → atmos_validation-2.2.0}/atmos_validation/validate_ascii/header_parser.py

@@ -18,6 +18,7 @@ class HeaderParser:
         errors: List[str],
         accepted_values: Optional[Set[str]] = None,
         split_by: Optional[str] = None,
+        optional: bool = False,
     ) -> str:
         real_valued = [
             Headers.LOCATION,
@@ -50,6 +51,8 @@ class HeaderParser:
                     # No colon to separate key from value in metadata line
                     errors.append(f'Missing Colon in line: "{line}"')
         # Could not find the key
+        if optional:
+            return ""
         if key in real_valued:
             errors.append(f"Metadata must include a real value for {key}")
         else:
@@ -90,6 +93,11 @@ class HeaderParser:
             errors,
             accepted_values[Headers.INSTALLATION_TYPE],
         )
+        contractor_division = self.get_simple_value(
+            Headers.CONTRACTOR_DIVISION,
+            errors,
+            optional=True,
+        )
 
         parameters = HeaderParameterInfoList(
             self.get_lines_from(
@@ -106,6 +114,7 @@ class HeaderParser:
         data = HeaderMetaData(
             number_of_header_lines=len(self.lines),
             contractor=self.get_simple_value(Headers.CONTRACTOR, errors),
+            contractor_division=contractor_division,
             final_report=self.get_simple_value(Headers.FINAL_REPORT, errors),
             qc=self.get_simple_value(Headers.QC, errors),
             duration=HeaderDate(self.get_simple_value(Headers.DURATION, errors)),

{atmos_validation-2.1.2 → atmos_validation-2.2.0}/atmos_validation/validate_ascii/header_position.py

@@ -1,59 +1,59 @@
 import re
 from typing import List
 
-from .utils import trim_value
+ALLOWED_DATUMS = [
+    "datum uncertain",
+    "WGS84",
+    "ED50",
+    "ED87",
+    "ETRS89",
+    "Tokyo",
+    "NAD27",
+]
+
+# Matches "<lat>N <lon>E, <datum>", e.g. "60.3589N 70.8764E, WGS84" or
+# "-60.3589N -70.8764E, WGS84". The sign carries the hemisphere; the N/E
+# letters are fixed and do not flip to S/W.
+LOCATION_PATTERN = re.compile(r"^-?[0-9]+\.[0-9]+N -?[0-9]+\.[0-9]+E,.+$")
 
 
 class HeaderPosition:
     def __init__(self, position_text: str):
-        self.parse_location(self.replace_special_character(position_text))
+        self.parse_location(position_text)
 
     def parse_location(self, location_text: str):
-        match = None
         regex_example = (
-            "location should match e.g 11.574483°N 108.36825°E, WGS84 or "
-            "11.574483°S 108.36825°W, some123 ranD0m characters"
-        )
-        pattern = re.compile(
-            r"^[0-9]*\.[0-9]+°[NS] [0-9]*\.[0-9]+°[EW],.+$", re.IGNORECASE
+            "location should match e.g 60.3589N 70.8764E, WGS84 (north-east) or "
+            "-60.3589N -70.8764E, WGS84 (south-west)"
         )
-        match = pattern.match(location_text)
+        match = LOCATION_PATTERN.match(location_text)
         if match is None:
             raise ValueError(
-                f"the location string {location_text} should match the regex {pattern.pattern}. "
-                f"valid examples: {regex_example}"
+                f"the location string {location_text} should match the regex "
+                f"{LOCATION_PATTERN.pattern}. valid examples: {regex_example}"
             )
         try:
-            items = location_text.split(",")
+            items = location_text.split(",", 1)
             location_items = items[0].split(" ")
             self.location_text = location_text
-            self.latitude = trim_value(location_items[0])
-            self.longitude = trim_value(location_items[1])
-            self.datum = trim_value(items[1])
+            self.latitude = location_items[0][:-1]  # strip trailing "N"
+            self.longitude = location_items[1][:-1]  # strip trailing "E"
+            self.datum = items[1].strip()
         except Exception as e:
             print(e)
 
     def get_latitude(self) -> str:
-        return self.get_position_value(self.latitude, "S")
+        return self.latitude
 
     def get_longitude(self) -> str:
-        return self.get_position_value(self.longitude, "W")
-
-    def get_position_value(self, text_in: str, direction: str) -> str:
-        index = text_in.find("°")
-        value = text_in[0:index]
-        if text_in[index + 1 : len(text_in)] == direction:
-            return "-" + self.replace_special_character(value)
-        return self.replace_special_character(value)
-
-    def replace_special_character(self, text_in: str) -> str:
-        return text_in.replace("�", "°").replace("Â", "°")
+        return self.longitude
 
     def validate(self) -> List[str]:
         messages = []
         try:
             messages = messages + self.validate_latitude()
             messages = messages + self.validate_longitude()
+            messages = messages + self.validate_datum()
         except Exception:
             messages.append("Location could not be parsed")
         return messages
@@ -64,6 +64,14 @@ class HeaderPosition:
     def validate_longitude(self) -> List[str]:
         return self.validate_item(self.get_longitude(), "Longitude", -180, 180)
 
+    def validate_datum(self) -> List[str]:
+        if self.datum not in ALLOWED_DATUMS:
+            return [
+                f'Datum "{self.datum}" is not in the allowed list. '
+                f"Allowed values: {ALLOWED_DATUMS}"
+            ]
+        return []
+
     def validate_item(
         self, value: str, position: str, lower: int, upper: int
     ) -> List[str]:
@@ -72,5 +80,5 @@ class HeaderPosition:
             messages.append(position + " could not be parsed")
         value_f = float(value)
         if value_f < lower or value_f > upper:
-            messages.append(position + " should be between +-90")
+            messages.append(f"{position} should be between {lower} and {upper}")
         return messages

{atmos_validation-2.1.2 → atmos_validation-2.2.0}/atmos_validation/validate_ascii/main.py

@@ -1,9 +1,10 @@
 import sys
 from typing import List, Optional, Tuple
 
+from ..schemas import validate_contractor_metadata
 from .header_parser import HeaderMetaData, HeaderParser
 from .row_parser import RowParser
-from .utils import load_parameter_configs
+from .utils import load_contractor_configs, load_parameter_configs
 from .validate_result import ValidateMeasurementResult, ValidateResult
 
 DOCSTRING = """
@@ -51,6 +52,9 @@ def main():
 
     messages = header_info.validate()
     messages += validate_with_parameter_configs(header_info)
+    messages += validate_contractor_header(
+        header_info.contractor, header_info.contractor_division
+    )
     if messages:
         print(ValidateMeasurementResult(ValidateResult.ERROR, messages))
         sys.exit(1)
@@ -110,3 +114,18 @@ def validate_with_parameter_configs(header_info: HeaderMetaData) -> List[str]:
                 f"The unit {unit} is incorrect for base parameter {key}. The unit should be {cfg.units}"
             )
     return messages
+
+
+def validate_contractor_header(contractor: str, contractor_division: str) -> List[str]:
+    contractor_names = [name.strip() for name in contractor.split(",")]
+    raw_divisions = contractor_division.strip()
+    divisions = (
+        []
+        if not raw_divisions
+        else [division.strip() for division in raw_divisions.split(",")]
+    )
+    return validate_contractor_metadata(
+        contractor_names,
+        divisions,
+        load_contractor_configs(),
+    )

atmos_validation-2.2.0/atmos_validation/validate_ascii/tests/test_contractor_validation.py

@@ -0,0 +1,137 @@
+from importlib import import_module
+
+import pytest
+
+from atmos_validation.schemas import Contractor
+from atmos_validation.validate_ascii import validate_contractor_header
+from atmos_validation.validate_ascii.header_parser import HeaderParser
+
+ascii_main = import_module("atmos_validation.validate_ascii.main")
+
+
+def test_ascii_contractor_and_multiple_divisions_are_rejected(monkeypatch):
+    monkeypatch.setattr(
+        ascii_main,
+        "load_contractor_configs",
+        lambda: [
+            Contractor(
+                contractor="Oceanweather Inc.",
+                divisions=["Marine", "Offshore", "Wind", "Wave", "Current"],
+            )
+        ],
+    )
+
+    errors = validate_contractor_header(
+        "Oceanweather Inc.", "Marine, Offshore, Wind, Wave, Current"
+    )
+
+    assert len(errors) == 1
+    assert "same length" in errors[0]
+
+
+def test_ascii_unknown_contractor_is_rejected(monkeypatch):
+    monkeypatch.setattr(
+        ascii_main,
+        "load_contractor_configs",
+        lambda: [Contractor(contractor="Oceanweather Inc.", divisions=["Marine"])],
+    )
+
+    errors = validate_contractor_header("Unknown Contractor", "")
+
+    assert len(errors) == 1
+    assert "Unknown Contractor" in errors[0]
+
+
+@pytest.mark.parametrize("division", ["NA", "Marine"])
+def test_ascii_na_contractor_means_no_contractor(monkeypatch, division):
+    monkeypatch.setattr(
+        ascii_main,
+        "load_contractor_configs",
+        lambda: [Contractor(contractor="Oceanweather Inc.", divisions=["Marine"])],
+    )
+
+    errors = validate_contractor_header("NA", division)
+
+    if division == "Marine":
+        assert len(errors) == 1
+        assert 'Division "Marine"' in errors[0]
+    else:
+        assert errors == []
+
+
+@pytest.mark.parametrize("configured_divisions", [None, [], ["Marine"]])
+def test_ascii_na_division_is_not_validated_as_a_division(
+    monkeypatch, configured_divisions
+):
+    monkeypatch.setattr(
+        ascii_main,
+        "load_contractor_configs",
+        lambda: [
+            Contractor(contractor="Oceanweather Inc.", divisions=configured_divisions)
+        ],
+    )
+
+    assert validate_contractor_header("Oceanweather Inc.", "NA") == []
+
+
+def test_ascii_division_not_allowed_by_selected_contractor_is_rejected(monkeypatch):
+    monkeypatch.setattr(
+        ascii_main,
+        "load_contractor_configs",
+        lambda: [
+            Contractor(contractor="Oceanweather Inc.", divisions=["Marine"]),
+            Contractor(contractor="Example Contractor", divisions=None),
+        ],
+    )
+
+    errors = validate_contractor_header("Example Contractor", "Marine")
+
+    assert len(errors) == 1
+    assert "Marine" in errors[0]
+
+
+@pytest.mark.parametrize(
+    ("divisions", "error_count"),
+    [
+        ("Marine, Offshore", 0),
+        ("Marine, NA", 0),
+        ("NA, Offshore", 0),
+        ("NA, NA", 0),
+        ("", 0),
+        ("Offshore, Marine", 2),
+        ("Marine", 1),
+        ("NA", 1),
+        ("Marine, Offshore, Marine", 1),
+    ],
+)
+def test_ascii_divisions_match_contractors_by_position(
+    monkeypatch, divisions, error_count
+):
+    monkeypatch.setattr(
+        ascii_main,
+        "load_contractor_configs",
+        lambda: [
+            Contractor(contractor="Oceanweather Inc.", divisions=["Marine"]),
+            Contractor(contractor="Example Contractor", divisions=["Offshore"]),
+        ],
+    )
+
+    errors = validate_contractor_header(
+        "Oceanweather Inc., Example Contractor", divisions
+    )
+
+    assert len(errors) == error_count
+    if divisions == "Offshore, Marine":
+        assert 'contractor "Oceanweather Inc."' in errors[0]
+        assert 'contractor "Example Contractor"' in errors[1]
+
+
+def test_contractor_division_header_is_optional():
+    errors = []
+
+    value = HeaderParser([]).get_simple_value(
+        "Contractor Division", errors, optional=True
+    )
+
+    assert value == ""
+    assert errors == []