esgvoc 2.0.2__py3-none-any.whl

esgvoc/apps/ga/example_usage.py

@@ -0,0 +1,315 @@
+"""
+Example usage of the GA (Global Attributes) validator.
+
+This script demonstrates how to use the GA validator to validate NetCDF global attributes
+against CMIP project specifications using the esgvoc API.
+"""
+
+import os
+from pathlib import Path
+
+from esgvoc.apps.ga.validator import GAValidator, validate_netcdf_attributes, create_validation_summary
+from esgvoc.apps.ga.models import NetCDFHeaderParser
+
+
+def example_validate_ncdump():
+    """
+    Example: Validate NetCDF global attributes from ncdump output.
+    """
+    # Sample ncdump output from the provided example
+    ncdump_output = """netcdf tas_Amon_CanESM5_historical_r11i1p1f1_gn_185001-201412 {
+dimensions:
+    time = UNLIMITED ; // (1980 currently)
+    bnds = 2 ;
+    lat = 64 ;
+    lon = 128 ;
+variables:
+    double time(time) ;
+        time:bounds = "time_bnds" ;
+        time:units = "days since 1850-01-01 0:0:0.0" ;
+        time:calendar = "365_day" ;
+        time:axis = "T" ;
+        time:long_name = "time" ;
+        time:standard_name = "time" ;
+    double time_bnds(time, bnds) ;
+    double lat(lat) ;
+        lat:bounds = "lat_bnds" ;
+        lat:units = "degrees_north" ;
+        lat:axis = "Y" ;
+        lat:long_name = "Latitude" ;
+        lat:standard_name = "latitude" ;
+    double lat_bnds(lat, bnds) ;
+    double lon(lon) ;
+        lon:bounds = "lon_bnds" ;
+        lon:units = "degrees_east" ;
+        lon:axis = "X" ;
+        lon:long_name = "Longitude" ;
+        lon:standard_name = "longitude" ;
+    double lon_bnds(lon, bnds) ;
+    double height ;
+        height:units = "m" ;
+        height:axis = "Z" ;
+        height:positive = "up" ;
+        height:long_name = "height" ;
+        height:standard_name = "height" ;
+    float tas(time, lat, lon) ;
+        tas:standard_name = "air_temperature" ;
+        tas:long_name = "Near-Surface Air Temperature" ;
+        tas:comment = "ST+273.16, CMIP_table_comment: near-surface (usually, 2 meter) air temperature" ;
+        tas:units = "K" ;
+        tas:original_name = "ST" ;
+        tas:history = "degctok 2019-04-30T17:44:13Z altered by CMOR: Treated scalar dimension: 'height'. 2019-04-30T17:44:13Z altered by CMOR: Reordered dimensions, original order: lat lon time. 2019-04-30T17:44:13Z altered by CMOR: replaced missing value flag (1e+38) with standard missing value (1e+20)." ;
+        tas:cell_methods = "area: time: mean" ;
+        tas:cell_measures = "area: areacella" ;
+        tas:coordinates = "height" ;
+        tas:missing_value = 1.e+20f ;
+        tas:_FillValue = 1.e+20f ;
+
+// global attributes:
+        :CCCma_model_hash = "7e8e715f3f2ce47e1bab830db971c362ca329419" ;
+        :CCCma_parent_runid = "rc3.1-pictrl" ;
+        :CCCma_pycmor_hash = "33c30511acc319a98240633965a04ca99c26427e" ;
+        :CCCma_runid = "rc3.1-his11" ;
+        :Conventions = "CF-1.7 CMIP-6.2" ;
+        :YMDH_branch_time_in_child = "1850:01:01:00" ;
+        :YMDH_branch_time_in_parent = "5701:01:01:00" ;
+        :activity_id = "CMIP" ;
+        :branch_method = "Spin-up documentation" ;
+        :branch_time_in_child = 0. ;
+        :branch_time_in_parent = 1405615. ;
+        :contact = "ec.cccma.info-info.ccmac.ec@canada.ca" ;
+        :creation_date = "2019-04-30T17:44:13Z" ;
+        :data_specs_version = "01.00.29" ;
+        :experiment = "all-forcing simulation of the recent past" ;
+        :experiment_id = "historical" ;
+        :external_variables = "areacella" ;
+        :forcing_index = 1 ;
+        :frequency = "mon" ;
+        :further_info_url = "https://furtherinfo.es-doc.org/CMIP6.CCCma.CanESM5.historical.none.r11i1p1f1" ;
+        :grid = "T63L49 native atmosphere, T63 Linear Gaussian Grid; 128 x 64 longitude/latitude; 49 levels; top level 1 hPa" ;
+        :grid_label = "gn" ;
+        :history = "2019-04-30T17:44:13Z ;rewrote data to be consistent with CMIP for variable tas found in table Amon.;\n",
+            "Output from $runid" ;
+        :initialization_index = 1 ;
+        :institution = "Canadian Centre for Climate Modelling and Analysis, Environment and Climate Change Canada, Victoria, BC V8P 5C2, Canada" ;
+        :institution_id = "CCCma" ;
+        :mip_era = "CMIP6" ;
+        :nominal_resolution = "500 km" ;
+        :parent_activity_id = "CMIP" ;
+        :parent_experiment_id = "piControl" ;
+        :parent_mip_era = "CMIP6" ;
+        :parent_source_id = "CanESM5" ;
+        :parent_time_units = "days since 1850-01-01 0:0:0.0" ;
+        :parent_variant_label = "r1i1p1f1" ;
+        :physics_index = 1 ;
+        :product = "model-output" ;
+        :realization_index = 11 ;
+        :realm = "atmos" ;
+        :references = "Geophysical Model Development Special issue on CanESM5 (https://www.geosci-model-dev.net/special_issues.html)" ;
+        :source = "CanESM5 (2019): \\n",
+            "aerosol: interactive\\n",
+            "atmos: CanAM5 (T63L49 native atmosphere, T63 Linear Gaussian Grid; 128 x 64 longitude/latitude; 49 levels; top level 1 hPa)\\n",
+            "atmosChem: specified oxidants for aerosols\\n",
+            "land: CLASS3.6/CTEM1.2\\n",
+            "landIce: specified ice sheets\\n",
+            "ocean: NEMO3.4.1 (ORCA1 tripolar grid, 1 deg with refinement to 1/3 deg within 20 degrees of the equator; 361 x 290 longitude/latitude; 45 vertical levels; top grid cell 0-6.19 m)\\n",
+            "ocnBgchem: Canadian Model of Ocean Carbon (CMOC); NPZD ecosystem with OMIP prescribed carbonate chemistry\\n",
+            "seaIce: LIM2" ;
+        :source_id = "CanESM5" ;
+        :source_type = "AOGCM" ;
+        :sub_experiment = "none" ;
+        :sub_experiment_id = "none" ;
+        :table_id = "Amon" ;
+        :table_info = "Creation Date:(20 February 2019) MD5:374fbe5a2bcca535c40f7f23da271e49" ;
+        :title = "CanESM5 output prepared for CMIP6" ;
+        :tracking_id = "hdl:21.14100/3a32f67e-ae59-40d8-ae4a-2e03e922fe8e" ;
+        :variable_id = "tas" ;
+        :variant_label = "r11i1p1f1" ;
+        :version = "v20190429" ;
+        :license = "CMIP6 model data produced by The Government of Canada (Canadian Centre for Climate Modelling and Analysis, Environment and Climate Change Canada) is licensed under a Creative Commons Attribution ShareAlike 4.0 International License (https://creativecommons.org/licenses). Consult https://pcmdi.llnl.gov/CMIP6/TermsOfUse for terms of use governing CMIP6 output, including citation requirements and proper acknowledgment. Further information about this data, including some limitations, can be found via the further_info_url (recorded as a global attribute in this file) and at https:///pcmdi.llnl.gov/. The data producers and data providers make no warranty, either express or implied, including, but not limited to, warranties of merchantability and fitness for a particular purpose. All liabilities arising from the supply of the information (including any liability arising in negligence) are excluded to the fullest extent permitted by law." ;
+        :cmor_version = "3.4.0" ;
+}"""
+
+    print("=== Example: Validating NetCDF Global Attributes ===")
+    print()
+
+    # Method 1: Using the convenience function
+    print("Method 1: Using convenience function")
+    report = validate_netcdf_attributes(
+        ncdump_output=ncdump_output,
+        project_id="cmip6",
+        filename="tas_Amon_CanESM5_historical_r11i1p1f1_gn_185001-201412.nc",
+    )
+
+    print(create_validation_summary(report))
+    print()
+
+    # Method 2: Using the GAValidator class directly
+    print("Method 2: Using GAValidator class")
+    validator = GAValidator(project_id="cmip6")
+
+    # List required attributes
+    print("Required attributes for CMIP6:")
+    for attr in validator.get_required_attributes():
+        print(f"  • {attr}")
+    print()
+
+    # Get info about specific attributes
+    print("Information about 'activity_id' attribute:")
+    activity_info = validator.get_attribute_info("activity_id")
+    if activity_info:
+        for key, value in activity_info.items():
+            print(f"  {key}: {value}")
+    print()
+
+    # Validate with detailed reporting
+    report2 = validator.validate_from_ncdump(ncdump_output, "example_file.nc")
+    print(f"Validation result: {report2.summary()}")
+
+    return report, report2
+
+
+def example_validate_attributes_dict():
+    """
+    Example: Validate global attributes from a dictionary.
+    """
+    print("=== Example: Validating from Attributes Dictionary ===")
+    print()
+
+    # Sample attributes dictionary
+    attributes = {
+        "Conventions": "CF-1.7 CMIP-6.2",
+        "activity_id": "CMIP",
+        "creation_date": "2019-04-30T17:44:13Z",
+        "data_specs_version": "01.00.29",
+        "experiment_id": "historical",
+        "forcing_index": 1,
+        "frequency": "mon",
+        "grid_label": "gn",
+        "initialization_index": 1,
+        "institution_id": "CCCma",
+        "mip_era": "CMIP6",
+        "nominal_resolution": "500 km",
+        "physics_index": 1,
+        "realization_index": 11,
+        "source_id": "CanESM5",
+        "table_id": "Amon",
+        "tracking_id": "hdl:21.14100/3a32f67e-ae59-40d8-ae4a-2e03e922fe8e",
+        "variable_id": "tas",
+        "variant_label": "r11i1p1f1",
+        # Missing some required attributes to test validation
+        # "license": "...", # Optional attribute
+    }
+
+    validator = GAValidator(project_id="cmip6")
+    report = validator.validate_from_attributes_dict(attributes, "test_attributes.nc")
+
+    print(create_validation_summary(report))
+
+    return report
+
+
+def example_parse_netcdf_header():
+    """
+    Example: Parse NetCDF header information.
+    """
+    print("=== Example: Parsing NetCDF Header ===")
+    print()
+
+    # Simple ncdump output for parsing
+    simple_ncdump = """netcdf test_file {
+dimensions:
+    time = UNLIMITED ; // (12 currently)
+    lat = 180 ;
+    lon = 360 ;
+variables:
+    double time(time) ;
+        time:units = "days since 1850-01-01" ;
+        time:calendar = "gregorian" ;
+    float temperature(time, lat, lon) ;
+        temperature:units = "K" ;
+        temperature:long_name = "Temperature" ;
+
+// global attributes:
+        :Conventions = "CF-1.7" ;
+        :title = "Test NetCDF file" ;
+        :institution = "Test Institution" ;
+        :source = "Test Model" ;
+        :history = "Created for testing" ;
+        :comment = "This is a test file" ;
+}"""
+
+    # Parse the header
+    header = NetCDFHeaderParser.parse_from_ncdump(simple_ncdump)
+
+    print(f"Filename: {header.filename}")
+    print(f"Dimensions: {len(header.dimensions)}")
+    for dim_name, dim in header.dimensions.items():
+        print(f"  • {dim_name}: {dim.size} {'(unlimited)' if dim.is_unlimited else ''}")
+
+    print(f"Variables: {len(header.variables)}")
+    for var_name, var in header.variables.items():
+        print(f"  • {var_name} ({var.data_type}): dims={var.dimensions}, attrs={len(var.attributes)}")
+
+    print(f"Global attributes: {len(header.global_attributes.attributes)}")
+    for attr_name, attr_value in header.global_attributes.attributes.items():
+        print(f"  • {attr_name}: {attr_value}")
+
+    return header
+
+
+def example_custom_config():
+    """
+    Example: Using custom YAML configuration.
+    """
+    print("=== Example: Custom Configuration ===")
+    print()
+
+    # Get the default config path
+    current_dir = Path(__file__).parent
+    config_path = current_dir / "attributes_specs.yaml"
+
+    print(f"Using configuration file: {config_path}")
+
+    if config_path.exists():
+        validator = GAValidator(config_path=str(config_path), project_id="cmip6")
+
+        print(f"Loaded {len(validator.list_attributes())} attribute specifications")
+        print("Attribute names:")
+        for attr in sorted(validator.list_attributes()):
+            info = validator.get_attribute_info(attr)
+            required = "required" if info and info.get("required") else "optional"
+            print(f"  • {attr} ({required})")
+
+        return validator
+    else:
+        print(f"Configuration file not found: {config_path}")
+        return None
+
+
+def main():
+    """
+    Run all examples.
+    """
+    try:
+        print("NetCDF Global Attributes Validator - Examples")
+        print("=" * 50)
+        print()
+
+        # Example 1: Validate from ncdump output
+        report1, report2 = example_validate_ncdump()
+
+        print()
+        print("=" * 50)
+        print("Examples completed successfully!")
+
+    except Exception as e:
+        print(f"Error running examples: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()
+

esgvoc/apps/ga/models/__init__.py

@@ -0,0 +1,47 @@
+"""
+GA (Global Attributes) models package.
+
+This package provides Pydantic models for validating NetCDF global attributes
+against project specifications using the esgvoc API.
+"""
+
+# Import from project_specs for attribute models
+from esgvoc.api.project_specs import AttributeProperty, AttributeSpecification
+
+from .netcdf_header import (
+    NetCDFDimension,
+    NetCDFVariable,
+    NetCDFGlobalAttributes as NetCDFGlobalAttributesNew,
+    NetCDFHeader,
+    NetCDFHeaderParser,
+)
+
+from .validator import (
+    ValidationSeverity,
+    ValidationIssue,
+    ValidationReport,
+    ESGVocAttributeValidator,
+    GlobalAttributeValidator as GlobalAttributeValidatorNew,
+    ValidatorFactory,
+)
+
+
+# Build __all__ dynamically based on available modules
+__all__ = [
+    # Attribute specification models from project_specs
+    "AttributeProperty",
+    "AttributeSpecification",
+    # NetCDF header models
+    "NetCDFDimension",
+    "NetCDFVariable",
+    "NetCDFGlobalAttributesNew",
+    "NetCDFHeader",
+    "NetCDFHeaderParser",
+    # Validation models
+    "ValidationSeverity",
+    "ValidationIssue",
+    "ValidationReport",
+    "ESGVocAttributeValidator",
+    "GlobalAttributeValidatorNew",
+    "ValidatorFactory",
+]

esgvoc/apps/ga/models/netcdf_header.py

@@ -0,0 +1,306 @@
+"""
+Models for parsing and validating NetCDF headers.
+
+This module provides Pydantic models to parse NetCDF header information
+and validate global attributes against project specifications.
+"""
+
+import re
+from typing import Any, Union, Optional, Dict, List
+from pydantic import BaseModel, Field, field_validator, ValidationError
+
+from esgvoc.api.data_descriptors.data_descriptor import ConfiguredBaseModel
+
+
+class NetCDFDimension(ConfiguredBaseModel):
+    """
+    Represents a NetCDF dimension.
+    """
+
+    name: str = Field(..., description="Dimension name")
+    size: Union[int, str] = Field(..., description="Dimension size (int or 'UNLIMITED')")
+    is_unlimited: bool = Field(default=False, description="Whether this is an unlimited dimension")
+
+    @field_validator("is_unlimited", mode="before")
+    @classmethod
+    def check_unlimited(cls, v, info):
+        """Check if dimension is unlimited based on size."""
+        if info.data.get("size") == "UNLIMITED":
+            return True
+        return v
+
+
+class NetCDFVariable(ConfiguredBaseModel):
+    """
+    Represents a NetCDF variable with its attributes.
+    """
+
+    name: str = Field(..., description="Variable name")
+    dimensions: List[str] = Field(default_factory=list, description="Variable dimensions")
+    data_type: str = Field(..., description="Variable data type (e.g., float, double)")
+    attributes: Dict[str, Any] = Field(default_factory=dict, description="Variable attributes")
+
+
+class NetCDFGlobalAttributes(ConfiguredBaseModel):
+    """
+    Container for NetCDF global attributes.
+    """
+
+    attributes: Dict[str, Union[str, int, float, List[Any]]] = Field(
+        default_factory=dict, description="Dictionary of global attributes"
+    )
+
+    def get_attribute(self, name: str) -> Optional[Any]:
+        """
+        Get a global attribute by name.
+
+        :param name: Attribute name
+        :return: Attribute value or None if not found
+        """
+        return self.attributes.get(name)
+
+    def get_string_attribute(self, name: str) -> Optional[str]:
+        """
+        Get a global attribute as string.
+
+        :param name: Attribute name
+        :return: Attribute value as string or None if not found
+        """
+        value = self.get_attribute(name)
+        return str(value) if value is not None else None
+
+    def has_attribute(self, name: str) -> bool:
+        """
+        Check if global attribute exists.
+
+        :param name: Attribute name
+        :return: True if attribute exists
+        """
+        return name in self.attributes
+
+    def list_attributes(self) -> List[str]:
+        """
+        List all global attribute names.
+
+        :return: List of attribute names
+        """
+        return list(self.attributes.keys())
+
+
+class NetCDFHeader(ConfiguredBaseModel):
+    """
+    Complete NetCDF header information including dimensions, variables, and global attributes.
+    """
+
+    filename: Optional[str] = Field(default=None, description="NetCDF filename")
+    dimensions: Dict[str, NetCDFDimension] = Field(default_factory=dict, description="File dimensions")
+    variables: Dict[str, NetCDFVariable] = Field(default_factory=dict, description="File variables")
+    global_attributes: NetCDFGlobalAttributes = Field(
+        default_factory=NetCDFGlobalAttributes, description="Global attributes"
+    )
+
+    @classmethod
+    def from_ncdump_output(cls, ncdump_output: str) -> "NetCDFHeader":
+        """
+        Parse NetCDF header from ncdump command output.
+
+        :param ncdump_output: Output from ncdump -h command
+        :return: NetCDFHeader instance
+        """
+        lines = ncdump_output.strip().split("\n")
+
+        # Extract filename from first line (e.g., "netcdf tas_Amon_CanESM5_historical_r11i1p1f1_gn_185001-201412 {")
+        filename_match = re.match(r"netcdf\s+(.+?)\s*\{", lines[0])
+        filename = filename_match.group(1) if filename_match else None
+
+        dimensions = {}
+        variables = {}
+        global_attributes = {}
+
+        current_section = None
+        current_variable = None
+        current_variable_info = {}
+
+        for line in lines[1:]:
+            line = line.strip()
+
+            if not line or line == "}":
+                continue
+
+            # Section headers
+            if line.startswith("dimensions:"):
+                current_section = "dimensions"
+                continue
+            elif line.startswith("variables:"):
+                current_section = "variables"
+                continue
+            elif line.startswith("// global attributes:"):
+                current_section = "global_attributes"
+                continue
+            elif line.startswith("data:"):
+                break  # We don't need data section
+
+            # Parse based on current section
+            if current_section == "dimensions":
+                cls._parse_dimension_line(line, dimensions)
+            elif current_section == "variables":
+                result = cls._parse_variable_line(line, variables, current_variable, current_variable_info)
+                if result:
+                    current_variable, current_variable_info = result
+            elif current_section == "global_attributes":
+                cls._parse_global_attribute_line(line, global_attributes)
+
+        return cls(
+            filename=filename,
+            dimensions=dimensions,
+            variables=variables,
+            global_attributes=NetCDFGlobalAttributes(attributes=global_attributes),
+        )
+
+    @staticmethod
+    def _parse_dimension_line(line: str, dimensions: Dict[str, NetCDFDimension]):
+        """Parse a dimension line from ncdump output."""
+        # e.g., "time = UNLIMITED ; // (1980 currently)"
+        # e.g., "lat = 64 ;"
+        match = re.match(r"\s*(\w+)\s*=\s*(.+?)\s*;", line)
+        if match:
+            dim_name = match.group(1)
+            dim_size_str = match.group(2).split("//")[0].strip()
+
+            if dim_size_str == "UNLIMITED":
+                dimensions[dim_name] = NetCDFDimension(name=dim_name, size="UNLIMITED", is_unlimited=True)
+            else:
+                try:
+                    size = int(dim_size_str)
+                    dimensions[dim_name] = NetCDFDimension(name=dim_name, size=size)
+                except ValueError:
+                    pass  # Skip malformed dimension lines
+
+    @staticmethod
+    def _parse_variable_line(
+        line: str, variables: Dict[str, NetCDFVariable], current_variable: Optional[str], current_variable_info: Dict
+    ) -> Optional[tuple]:
+        """Parse a variable line from ncdump output."""
+        # Variable declaration: "double time(time) ;"
+        var_decl_match = re.match(r"\s*(\w+)\s+(\w+)\s*\(([^)]*)\)\s*;", line)
+        if var_decl_match:
+            data_type = var_decl_match.group(1)
+            var_name = var_decl_match.group(2)
+            dimensions_str = var_decl_match.group(3)
+
+            dimensions_list = [d.strip() for d in dimensions_str.split(",") if d.strip()]
+
+            variables[var_name] = NetCDFVariable(
+                name=var_name, data_type=data_type, dimensions=dimensions_list, attributes={}
+            )
+
+            return var_name, {}
+
+        # Variable attribute: "time:units = "days since 1850-01-01 0:0:0.0" ;"
+        attr_match = re.match(r"\s*(\w+):(\w+)\s*=\s*(.+?)\s*;", line)
+        if attr_match and current_variable:
+            var_name = attr_match.group(1)
+            attr_name = attr_match.group(2)
+            attr_value = attr_match.group(3).strip()
+
+            # Remove quotes if present
+            if attr_value.startswith('"') and attr_value.endswith('"'):
+                attr_value = attr_value[1:-1]
+
+            # Try to convert to appropriate type
+            try:
+                if "." in attr_value or "e" in attr_value.lower():
+                    attr_value = float(attr_value)
+                elif attr_value.isdigit() or (attr_value.startswith("-") and attr_value[1:].isdigit()):
+                    attr_value = int(attr_value)
+            except ValueError:
+                pass  # Keep as string
+
+            if var_name in variables:
+                variables[var_name].attributes[attr_name] = attr_value
+
+        return current_variable, current_variable_info
+
+    @staticmethod
+    def _parse_global_attribute_line(line: str, global_attributes: Dict[str, Any]):
+        """Parse a global attribute line from ncdump output."""
+        # e.g., ':Conventions = "CF-1.7 CMIP-6.2" ;'
+        # e.g., ':forcing_index = 1 ;'
+        match = re.match(r"\s*:(\w+)\s*=\s*(.+?)\s*;", line)
+        if match:
+            attr_name = match.group(1)
+            attr_value = match.group(2).strip()
+
+            # Handle multiline strings
+            if attr_value.startswith('"') and not attr_value.endswith('"'):
+                # This is a multiline string, we'd need to handle continuation
+                attr_value = attr_value[1:]  # Remove starting quote
+            elif attr_value.startswith('"') and attr_value.endswith('"'):
+                attr_value = attr_value[1:-1]  # Remove both quotes
+
+            # Try to convert to appropriate type
+            try:
+                if (
+                    attr_value.replace(".", "")
+                    .replace("-", "")
+                    .replace("e", "")
+                    .replace("E", "")
+                    .replace("+", "")
+                    .isdigit()
+                ):
+                    if "." in attr_value or "e" in attr_value.lower() or "E" in attr_value:
+                        attr_value = float(attr_value)
+                    else:
+                        attr_value = int(attr_value)
+            except (ValueError, AttributeError):
+                pass  # Keep as string
+
+            global_attributes[attr_name] = attr_value
+
+
+class NetCDFHeaderParser:
+    """
+    Utility class for parsing NetCDF headers from various sources.
+    """
+
+    @staticmethod
+    def parse_from_ncdump(ncdump_output: str) -> NetCDFHeader:
+        """
+        Parse NetCDF header from ncdump command output.
+
+        :param ncdump_output: Output from ncdump -h command
+        :return: NetCDFHeader instance
+        """
+        return NetCDFHeader.from_ncdump_output(ncdump_output)
+
+    @staticmethod
+    def parse_from_file(filepath: str) -> NetCDFHeader:
+        """
+        Parse NetCDF header directly from file using netCDF4 library.
+
+        Note: This is a placeholder for future implementation.
+        """
+        raise NotImplementedError("Direct NetCDF file parsing not yet implemented")
+
+    @staticmethod
+    def validate_ncdump_format(ncdump_output: str) -> bool:
+        """
+        Validate that the input looks like valid ncdump output.
+
+        :param ncdump_output: String to validate
+        :return: True if format looks valid
+        """
+        lines = ncdump_output.strip().split("\n")
+        if not lines:
+            return False
+
+        # Check for netcdf header
+        if not lines[0].strip().startswith("netcdf "):
+            return False
+
+        # Check for required sections
+        has_dimensions = any("dimensions:" in line for line in lines)
+        has_global_attrs = any("// global attributes:" in line for line in lines)
+
+        return has_dimensions or has_global_attrs
+