Converting MFP CSV to YAML schedule

environment.yml

@@ -12,6 +12,7 @@ dependencies:
   - pip
   - pyyaml
   - copernicusmarine >= 2
+  - openpyxl >= 3.1.5
 
   # linting
   - pre-commit

src/virtualship/cli/commands.py

@@ -16,16 +16,26 @@
     hash_to_filename,
 )
 from virtualship.expedition.do_expedition import _get_schedule, do_expedition
-from virtualship.utils import SCHEDULE, SHIP_CONFIG
+from virtualship.utils import SCHEDULE, SHIP_CONFIG, mfp_to_yaml
 
 
 @click.command()
 @click.argument(
     "path",
     type=click.Path(exists=False, file_okay=False, dir_okay=True),
 )
-def init(path):
-    """Initialize a directory for a new expedition, with an example schedule and ship config files."""
+@click.option(
+    "--mfp-file",
+    type=str,
+    default=None,
+    help='Partially initialise a project from an exported xlsx or csv file from NIOZ\' Marine Facilities Planning tool (specifically the "Export Coordinates > DD" option). User edits are required after initialisation.',
+)
+def init(path, mfp_file):
+    """
+    Initialize a directory for a new expedition, with an example schedule and ship config files.
+
+    If --mfp-file is provided, it will generate the schedule from the MPF file instead.
+    """
     path = Path(path)
     path.mkdir(exist_ok=True)
 
@@ -43,7 +53,20 @@ def init(path):
         )
 
     config.write_text(utils.get_example_config())
-    schedule.write_text(utils.get_example_schedule())
+
+    if mfp_file:
+        # Generate schedule.yaml from the MPF file
+        click.echo(f"Generating schedule from {mfp_file}...")
+        schedule_body = mfp_to_yaml(mfp_file, schedule)
+        click.echo(
+            "\n⚠️  The generated schedule does not contain time values. "
+            "\nPlease edit 'schedule.yaml' and manually add the necessary time values."
+            "\n🕒  Expected time format: 'YYYY-MM-DD HH:MM:SS' (e.g., '2023-10-20 01:00:00').\n"
+        )
+    else:
+        # Create a default example schedule
+        # schedule_body = utils.get_example_schedule()
+        schedule.write_text(utils.get_example_schedule())
 
     click.echo(f"Created '{config.name}' and '{schedule.name}' at {path}.")
 

src/virtualship/expedition/instrument_type.py

@@ -9,3 +9,5 @@ class InstrumentType(Enum):
     CTD = "CTD"
     DRIFTER = "DRIFTER"
     ARGO_FLOAT = "ARGO_FLOAT"
+    XBT = "XBT"
+

src/virtualship/expedition/space_time_region.py

@@ -38,20 +38,19 @@ def _check_lon_lat_domain(self) -> Self:
             raise ValueError("minimum_depth must be less than maximum_depth")
         return self
 
-
 class TimeRange(BaseModel):
     """Defines the temporal boundaries for a space-time region."""
 
-    start_time: datetime
-    end_time: datetime
+    start_time: datetime | None = None
+    end_time: datetime | None = None
 
     @model_validator(mode="after")
     def _check_time_range(self) -> Self:
-        if not self.start_time < self.end_time:
-            raise ValueError("start_time must be before end_time")
+        if self.start_time and self.end_time:
+            if not self.start_time < self.end_time:
+                raise ValueError("start_time must be before end_time")
         return self
 
-
 class SpaceTimeRegion(BaseModel):
     """An space-time region with spatial and temporal boundaries."""
 

src/virtualship/utils.py

@@ -2,6 +2,8 @@
 from importlib.resources import files
 from typing import TextIO
 
+import numpy as np
+import pandas as pd
 import yaml
 from pydantic import BaseModel
 
@@ -37,3 +39,107 @@ def _dump_yaml(model: BaseModel, stream: TextIO) -> str | None:
 def _generic_load_yaml(data: str, model: BaseModel) -> BaseModel:
     """Load a yaml string into a pydantic model."""
     return model.model_validate(yaml.safe_load(data))
+
+
+def mfp_to_yaml(excel_file_path: str, yaml_output_path: str):
+    """
+    Generates a YAML file with spatial and temporal information based on instrument data from MFP excel file.
+
+    Parameters
+    ----------
+    - excel_file_path (str): Path to the Excel file containing coordinate and instrument data.
+
+    The function:
+    1. Reads instrument and location data from the Excel file.
+    2. Determines the maximum depth and buffer based on the instruments present.
+    3. Ensures longitude and latitude values remain valid after applying buffer adjustments.
+    4. returns the yaml information.
+
+    """
+
+    # Importing Schedule and related models from expedition module
+    from virtualship.expedition.schedule import Schedule
+    from virtualship.expedition.space_time_region import SpaceTimeRegion, SpatialRange, TimeRange
+    from virtualship.expedition.waypoint import Waypoint, Location
+    from virtualship.expedition.instrument_type import InstrumentType
+
+    # Read data from Excel
+    coordinates_data = pd.read_excel(
+        excel_file_path,
+        usecols=["Station Type", "Name", "Latitude", "Longitude", "Instrument"],
+    )
+    coordinates_data = coordinates_data.dropna()
+
+    # Define maximum depth (in meters) and buffer (in degrees) for each instrument
+    instrument_properties = {
+        "XBT": {"maximum_depth": 2000, "buffer": 1},
+        "CTD": {"maximum_depth": 5000, "buffer": 1},
+        "DRIFTER": {"maximum_depth": 1, "buffer": 5},
+        "ARGO_FLOAT": {"maximum_depth": 2000, "buffer": 5},
+    }
+
+    # Extract unique instruments from dataset using a set
+    unique_instruments = set()
+
+    for instrument_list in coordinates_data["Instrument"]:
+        instruments = instrument_list.split(", ")  # Split by ", " to get individual instruments
+        unique_instruments |= set(instruments)  # Union update with set of instruments
+
+    # Determine the maximum depth based on the unique instruments
+    maximum_depth = max(
+        instrument_properties.get(inst, {"maximum_depth": 0})["maximum_depth"]
+        for inst in unique_instruments
+    )
+    minimum_depth = 0
+
+    # Determine the buffer based on the maximum buffer of the instruments present
+    buffer = max(
+        instrument_properties.get(inst, {"buffer": 0})["buffer"]
+        for inst in unique_instruments
+    )
+
+    # Adjusted spatial range
+    min_longitude = coordinates_data["Longitude"].min() - buffer
+    max_longitude = coordinates_data["Longitude"].max() + buffer
+    min_latitude = coordinates_data["Latitude"].min() - buffer
+    max_latitude = coordinates_data["Latitude"].max() + buffer
+
+
+    spatial_range = SpatialRange(
+        minimum_longitude=coordinates_data["Longitude"].min() - buffer,
+        maximum_longitude=coordinates_data["Longitude"].max() + buffer,
+        minimum_latitude=coordinates_data["Latitude"].min() - buffer,
+        maximum_latitude=coordinates_data["Latitude"].max() + buffer,
+        minimum_depth=0,
+        maximum_depth=maximum_depth,
+    )
+
+
+    # Create space-time region object
+    space_time_region = SpaceTimeRegion(
+        spatial_range=spatial_range,
+        time_range=TimeRange(),
+    )
+
+    # Generate waypoints
+    waypoints = []
+    for _, row in coordinates_data.iterrows():
+        instruments = [InstrumentType(instrument) for instrument in row["Instrument"].split(", ")]
+        waypoints.append(
+            Waypoint(
+                instrument=instruments,
+                location=Location(latitude=row["Latitude"], longitude=row["Longitude"]),
+            )
+        )
+
+    # Create Schedule object
+    schedule = Schedule(
+        waypoints=waypoints,
+        space_time_region=space_time_region,
+    )
+
+    # Save to YAML file
+    schedule.to_yaml(yaml_output_path)
+
+
+