pyTMD 3.0.2__tar.gz → 3.0.4__tar.gz

{pytmd-3.0.2/pyTMD.egg-info → pytmd-3.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyTMD
-Version: 3.0.2
+Version: 3.0.4
 Summary: Python-based tidal prediction software for estimating ocean, load, solid Earth and pole tides
 Author: Tyler Sutterley
 Author-email: tsutterl@uw.edu
@@ -55,10 +55,10 @@ Requires-Dist: pint
 Requires-Dist: platformdirs
 Requires-Dist: pyproj>=2.5.0
 Requires-Dist: scipy>=1.10.1
-Requires-Dist: timescale>=0.0.8
+Requires-Dist: timescale>=0.1.1
 Requires-Dist: xarray
 Provides-Extra: doc
-Requires-Dist: docutils; extra == "doc"
+Requires-Dist: docutils>=0.17; extra == "doc"
 Requires-Dist: graphviz; extra == "doc"
 Requires-Dist: ipympl; extra == "doc"
 Requires-Dist: myst-nb; extra == "doc"

{pytmd-3.0.2 → pytmd-3.0.4}/pyTMD/compute.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 """
 compute.py
-Written by Tyler Sutterley (12/2025)
+Written by Tyler Sutterley (02/2026)
 Calculates tidal elevations for correcting elevation or imagery data
 Calculates tidal currents at locations and times
 
@@ -64,6 +64,7 @@ PROGRAM DEPENDENCIES:
     interpolate.py: interpolation routines for spatial data
 
 UPDATE HISTORY:
+    Updated 02/2026: added attributes for constituents to output DataArrays
     Updated 12/2025: use coords functions to convert x and y to DataArrays
         no longer subclassing pathlib.Path for working directories
     Updated 11/2025: use xarray DataArrays for input coordinates
@@ -321,8 +322,8 @@ def tide_elevations(
 
     Returns
     -------
-    tide: xarray.DataArray
-        tidal elevation (meters)
+    tpred: xarray.DataArray
+        predicted tide elevation (meters)
     """
     # default keyword arguments
     kwargs.setdefault("chunks", None)
@@ -404,20 +405,28 @@ def tide_elevations(
         X, Y, method=method, extrapolate=extrapolate, cutoff=cutoff
     )
     # calculate tide values for input data type
-    tide = local.tmd.predict(
+    tpred = local.tmd.predict(
         ts.tide, deltat=deltat, corrections=nodal_corrections
     )
     # calculate values for minor constituents by inference
     if kwargs["infer_minor"]:
-        # add major and minor components
-        tide += local.tmd.infer(
+        # infer minor constituents
+        tinfer = local.tmd.infer(
             ts.tide,
             deltat=deltat,
             corrections=nodal_corrections,
             minor=minor_constituents,
         )
+        # add major and minor components
+        tpred += tinfer
+        # add attributes for inferred constituents
+        tpred.attrs["inferred"] = []
+        if hasattr(tinfer, "constituents"):
+            tpred.attrs["inferred"].extend(tinfer.constituents)
+    # add attributes
+    tpred.attrs["nodal_corrections"] = nodal_corrections
     # return the ocean or load tide correction
-    return tide
+    return tpred
 
 
 # PURPOSE: compute tides at points and times using tide model algorithms
@@ -508,8 +517,8 @@ def tide_currents(
 
     Returns
     -------
-    tide: xr.DataTree
-        tidal currents in cm/s
+    tpred: xr.DataTree
+        predicted tidal currents in cm/s
 
         u: xr.Dataset
             zonal velocities
@@ -584,7 +593,7 @@ def tide_currents(
         deltat = ts.tt_ut1
 
     # python dictionary with tide model data
-    tide = xr.DataTree()
+    tpred = xr.DataTree()
     # iterate over u and v currents
     for key, ds in dtree.items():
         # convert component to dataset
@@ -594,20 +603,28 @@ def tide_currents(
             X, Y, method=method, extrapolate=extrapolate, cutoff=cutoff
         )
         # calculate tide values for input data type
-        tide[key] = local.tmd.predict(
+        tpred[key] = local.tmd.predict(
             ts.tide, deltat=deltat, corrections=nodal_corrections
         )
         # calculate values for minor constituents by inference
         if kwargs["infer_minor"]:
-            # add major and minor components
-            tide[key] += local.tmd.infer(
+            # infer minor constituents
+            tinfer = local.tmd.infer(
                 ts.tide,
                 deltat=deltat,
                 corrections=nodal_corrections,
                 minor=minor_constituents,
             )
+            # add major and minor components
+            tpred[key] += tinfer
+            # add attributes for inferred constituents
+            tpred[key].attrs["inferred"] = []
+            if hasattr(tinfer, "constituents"):
+                tpred[key].attrs["inferred"].extend(tinfer.constituents)
+        # add attributes
+        tpred[key].attrs["nodal_corrections"] = nodal_corrections
     # return the tidal currents
-    return tide
+    return tpred
 
 
 # PURPOSE: check if points are within a tide model domain
@@ -1389,8 +1406,10 @@ def _catalog_SET(
     longitude, latitude = pyTMD.io.dataset._coords(
         x, y, type=type, source_crs=crs, target_crs=4326
     )
+    # geocentric latitude (degrees)
+    latitude_geocentric = pyTMD.spatial.geocentric_latitude(latitude)
     # create dataset
-    ds = xr.Dataset(coords={"x": longitude, "y": latitude})
+    ds = xr.Dataset(coords={"x": longitude, "y": latitude_geocentric})
 
     # verify that delta time is an array
     delta_time = np.atleast_1d(delta_time)

{pytmd-3.0.2 → pytmd-3.0.4}/pyTMD/datasets/reduce_otis.py

@@ -114,10 +114,10 @@ def reduce_otis(
             m["u"].model_file
         )
         # combine local solutions with global solution
-        dsg = dsg.compact.combine_local(dtg)
-        dsz = dsz.compact.combine_local(dtz)
-        dsu = dsu.compact.combine_local(dtu)
-        dsv = dsv.compact.combine_local(dtv)
+        dsg = dsg.tmd.compact.combine_local(dtg)
+        dsz = dsz.tmd.compact.combine_local(dtz)
+        dsu = dsu.tmd.compact.combine_local(dtu)
+        dsv = dsv.tmd.compact.combine_local(dtv)
     else:
         # if reading a pure global solution
         dsg = pyTMD.io.OTIS.open_otis_grid(m["z"].grid_file)
@@ -140,9 +140,9 @@ def reduce_otis(
     new_elevation_file = _unique_filename(m["z"].model_file)
     new_transport_file = _unique_filename(m["u"].model_file)
     # output reduced datasets to file
-    dtree.otis.to_grid(new_grid_file)
-    dtree.otis.to_elevation(new_elevation_file)
-    dtree.otis.to_transport(new_transport_file)
+    dtree.tmd.otis.to_grid(new_grid_file)
+    dtree.tmd.otis.to_elevation(new_elevation_file)
+    dtree.tmd.otis.to_transport(new_transport_file)
     # change the permissions level to mode
     new_grid_file.chmod(mode=mode)
     new_elevation_file.chmod(mode=mode)

{pytmd-3.0.2 → pytmd-3.0.4}/pyTMD/io/ATLAS.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 """
 ATLAS.py
-Written by Tyler Sutterley (12/2025)
+Written by Tyler Sutterley (02/2026)
 
 Reads netCDF4 ATLAS tidal solutions provided by Oregon State University
 
@@ -10,6 +10,8 @@ PYTHON DEPENDENCIES:
         https://docs.xarray.dev/en/stable/
 
 UPDATE HISTORY:
+    Updated 02/2026: make dataset and datatree accessors for ATLAS
+        be subaccessors from dataset module
     Updated 12/2025: no longer subclassing pathlib.Path for working directories
         added option to change the output datatype when writing netCDF files
     Updated 11/2025: near-complete rewrite of program to use xarray
@@ -63,6 +65,10 @@ import datetime
 import xarray as xr
 import pyTMD.version
 import pyTMD.utilities
+from .dataset import (
+    register_dataset_subaccessor,
+    register_datatree_subaccessor,
+)
 
 # attempt imports
 dask = pyTMD.utilities.import_dependency("dask")
@@ -295,11 +301,10 @@ def open_atlas_dataset(
 
 
 # PURPOSE: ATLAS-netcdf utilities for xarray Datasets
-@xr.register_dataset_accessor("atlas")
+@register_dataset_subaccessor("atlas")
 class ATLASDataset:
     """
-    Accessor for extending an ``xarray.Dataset`` for ATLAS-netcdf
-    tidal models
+    ``xarray.Dataset`` utilities for ATLAS-netcdf tidal models
     """
 
     def __init__(self, ds):
@@ -462,11 +467,10 @@ class ATLASDataset:
 
 
 # PURPOSE: ATLAS-netcdf utilities for xarray DataTrees
-@xr.register_datatree_accessor("atlas")
+@register_datatree_subaccessor("atlas")
 class ATLASDataTree:
     """
-    Accessor for extending an ``xarray.DataTree`` for ATLAS-netcdf
-    tidal models
+    ``xarray.DataTree`` utilities for ATLAS-netcdf tidal models
     """
 
     def __init__(self, dtree):
@@ -500,6 +504,8 @@ class ATLASDataTree:
             ds = self._dtree[group].to_dataset()
             # write in append mode to add group to same grid and directory
             # output grid file
-            ds.atlasnc.to_grid(grid_file, group=group, mode="a", **kwargs)
+            ATLASDataset(ds).to_grid(grid_file, group=group, mode="a", **kwargs)
             # output constituent files
-            ds.atlasnc.to_netcdf(directory, group=group, mode="a", **kwargs)
+            ATLASDataset(ds).to_netcdf(
+                directory, group=group, mode="a", **kwargs
+            )

{pytmd-3.0.2 → pytmd-3.0.4}/pyTMD/io/FES.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 """
 FES.py
-Written by Tyler Sutterley (12/2025)
+Written by Tyler Sutterley (02/2026)
 
 Reads ascii and netCDF4 files for FES tidal solutions provided by AVISO
     https://www.aviso.altimetry.fr/data/products/auxiliary-products/
@@ -15,6 +15,7 @@ PYTHON DEPENDENCIES:
         https://docs.xarray.dev/en/stable/
 
 UPDATE HISTORY:
+    Updated 02/2026: make dataset accessor for FES be a subaccessor from dataset
     Updated 12/2025: no longer subclassing pathlib.Path for working directories
     Updated 11/2025: near-complete rewrite of program to use xarray
     Updated 10/2025: simplify ascii read function to use masked_equal
@@ -71,6 +72,7 @@ import numpy as np
 import xarray as xr
 import pyTMD.constituents
 import pyTMD.utilities
+from .dataset import register_dataset_subaccessor
 
 # attempt imports
 dask = pyTMD.utilities.import_dependency("dask")
@@ -311,14 +313,14 @@ def open_fes_netcdf(
     if "Ha" in tmp.variables:
         # FES2012 variable names
         mapping_coords = dict(lon="x", lat="y")
-        mapping_amp = dict(z="Ha", u="Ua", v="Va")
-        mapping_ph = dict(z="Hg", u="Ug", v="Vg")
-    elif "amplitude" in tmp.variables:
+        mapping_amp = dict(z="Ha")
+        mapping_ph = dict(z="Hg")
+    elif any([v in tmp.variables for v in ["amplitude", "Ua", "Va"]]):
         # FES2014/2022 variable names
         mapping_coords = dict(lon="x", lat="y")
         mapping_amp = dict(z="amplitude", u="Ua", v="Va")
         mapping_ph = dict(z="phase", u="Ug", v="Vg")
-    elif "AMPL" in tmp.variables:
+    elif any([v in tmp.variables for v in ["AMPL", "UAMP", "VAMP"]]):
         # HAMTIDE11 variable names
         mapping_coords = dict(LON="x", LAT="y")
         mapping_amp = dict(z="AMPL", u="UAMP", v="VAMP")
@@ -344,9 +346,9 @@ def open_fes_netcdf(
 
 
 # PURPOSE: FES utilities for xarray Datasets
-@xr.register_dataset_accessor("fes")
+@register_dataset_subaccessor("fes")
 class FESDataset:
-    """Accessor for extending an ``xarray.Dataset`` for FES tidal models"""
+    """``xarray.Dataset`` utilities for FES tidal models"""
 
     def __init__(self, ds):
         self._ds = ds

{pytmd-3.0.2 → pytmd-3.0.4}/pyTMD/io/GOT.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 """
 GOT.py
-Written by Tyler Sutterley (12/2025)
+Written by Tyler Sutterley (02/2026)
 
 Reads ascii and netCDF4 files from Richard Ray's Goddard Ocean Tide (GOT) model
     https://earth.gsfc.nasa.gov/geo/data/ocean-tide-models
@@ -14,6 +14,8 @@ PYTHON DEPENDENCIES:
         https://docs.xarray.dev/en/stable/
 
 UPDATE HISTORY:
+    Updated 02/2026: make dataset accessor for GOT be a subaccessor from dataset
+        some models have units in the second line of the header text
     Updated 12/2025: no longer subclassing pathlib.Path for working directories
         added function to write to output GOT-formatted ascii files
         fixed writing of output constituents to match GOT attribute format
@@ -74,6 +76,7 @@ import xarray as xr
 import pyTMD.version
 import pyTMD.constituents
 import pyTMD.utilities
+from .dataset import register_dataset_subaccessor
 
 # attempt imports
 dask = pyTMD.utilities.import_dependency("dask")
@@ -208,8 +211,16 @@ def open_got_ascii(
     # parse header text
     # constituent identifier
     cons = pyTMD.constituents._parse_name(file_contents[0])
-    # get units
-    units = re.findall(r"\((\w+m)\)", file_contents[0], re.IGNORECASE)
+    # get units from header if available
+    rx = re.compile(r"\((\w+m)\)", re.IGNORECASE)
+    # GOT headers from Richard Ray have units on the first line
+    # some other models have units on the second line
+    if rx.search(file_contents[0]):
+        units = rx.findall(file_contents[0], re.IGNORECASE)
+    elif rx.search(file_contents[1]):
+        units = rx.findall(file_contents[1], re.IGNORECASE)
+    else:
+        units = None
     # grid dimensions
     nlat, nlon = np.array(file_contents[2].split(), dtype=int)
     # longitude range
@@ -331,9 +342,9 @@ def open_got_netcdf(
 
 
 # PURPOSE: GOT utilities for xarray Datasets
-@xr.register_dataset_accessor("got")
+@register_dataset_subaccessor("got")
 class GOTDataset:
-    """Accessor for extending an ``xarray.Dataset`` for GOT tidal models"""
+    """``xarray.Dataset`` utilities for GOT tidal models"""
 
     def __init__(self, ds):
         self._ds = ds

{pytmd-3.0.2 → pytmd-3.0.4}/pyTMD/io/OTIS.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 """
 OTIS.py
-Written by Tyler Sutterley (01/2026)
+Written by Tyler Sutterley (02/2026)
 
 Reads OTIS format tidal solutions provided by Oregon State University and ESR
     http://volkov.oce.orst.edu/tides/region.html
@@ -19,6 +19,8 @@ PYTHON DEPENDENCIES:
         https://docs.xarray.dev/en/stable/
 
 UPDATE HISTORY:
+    Updated 02/2026: make dataset and datatree accessors for OTIS
+        be subaccessors from dataset module
     Updated 01/2026: check if flexure variable exists in TMD3 files
     Updated 12/2025: no longer subclassing pathlib.Path for working directories
     Updated 11/2025: near-complete rewrite of program to use xarray
@@ -102,6 +104,10 @@ import warnings
 import numpy as np
 import xarray as xr
 import pyTMD.utilities
+from .dataset import (
+    register_dataset_subaccessor,
+    register_datatree_subaccessor,
+)
 
 # attempt imports
 dask = pyTMD.utilities.import_dependency("dask")
@@ -126,7 +132,7 @@ __all__ = [
     "write_raw_binary",
     "OTISDataset",
     "OTISDataTree",
-    "ATLASDataset",
+    "CompactDataset",
 ]
 
 # variable attributes
@@ -373,7 +379,7 @@ def open_otis_dataset(
         # transports are returned as (u,v)
         ds2 = open_otis_transport(model_file, **kwargs)[1]
     # merge datasets
-    ds = ds1.otis.merge(ds2, group=group)
+    ds = OTISDataset(ds1).merge(ds2, group=group)
     # add attributes
     ds.attrs["group"] = group.upper() if group in ("u", "v") else group
     # return xarray dataset
@@ -421,22 +427,22 @@ def open_atlas_dataset(
     crs = kwargs.get("crs", 4326)
     # open grid file
     dsg, dtg = open_atlas_grid(grid_file, use_mmap=use_mmap)
-    ds1 = dsg.compact.combine_local(dtg, chunks=chunks)
+    ds1 = CompactDataset(dsg).combine_local(dtg, chunks=chunks)
     # add attributes
     ds1.attrs["crs"] = pyproj.CRS.from_user_input(crs).to_dict()
     # open model file(s)
     if group == "z":
         # elevations are returned as (z, localz)
         dsh, dth = open_atlas_elevation(model_file, use_mmap=use_mmap)
-        ds2 = dsh.compact.combine_local(dth, chunks=chunks)
+        ds2 = CompactDataset(dsh).combine_local(dth, chunks=chunks)
     elif group in ("u", "U"):
         # transports are returned as (u, v, localu, localv)
         dsu, dtu, dsv, dtv = open_atlas_transport(model_file, use_mmap=use_mmap)
-        ds2 = dsu.compact.combine_local(dtu, chunks=chunks)
+        ds2 = CompactDataset(dsu).combine_local(dtu, chunks=chunks)
     elif group in ("v", "V"):
         # transports are returned as (u, v, localu, localv)
         dsu, dtu, dsv, dtv = open_atlas_transport(model_file, use_mmap=use_mmap)
-        ds2 = dsv.compact.combine_local(dtv, chunks=chunks)
+        ds2 = CompactDataset(dsv).combine_local(dtv, chunks=chunks)
     # merge datasets
     ds = xr.merge([ds1, ds2], compat="override")
     # add attributes
@@ -1836,9 +1842,9 @@ def write_raw_binary(
 
 
 # PURPOSE: OTIS utilities for xarray Datasets
-@xr.register_dataset_accessor("otis")
+@register_dataset_subaccessor("otis")
 class OTISDataset:
-    """Accessor for extending an ``xarray.Dataset`` for OTIS tidal models"""
+    """``xarray.Dataset`` utilities for OTIS tidal models"""
 
     def __init__(self, ds):
         # initialize dataset
@@ -1913,9 +1919,9 @@ class OTISDataset:
 
 
 # PURPOSE: OTIS utilities for xarray datatrees
-@xr.register_datatree_accessor("otis")
+@register_datatree_subaccessor("otis")
 class OTISDataTree:
-    """Accessor for extending an ``xarray.DataTree`` for OTIS tidal models"""
+    """``xarray.DataTree`` utilities for OTIS tidal models"""
 
     def __init__(self, dtree):
         # initialize datatree
@@ -2144,11 +2150,10 @@ class OTISDataTree:
 
 
 # PURPOSE: ATLAS-compact utilities for xarray Datasets
-@xr.register_dataset_accessor("compact")
-class ATLASDataset:
+@register_datatree_subaccessor("compact")
+class CompactDataset:
     """
-    Accessor for extending an ``xarray.Dataset`` for ATLAS-compact
-    tidal models
+    ``xarray.Dataset`` utilities for ATLAS-compact tidal models
     """
 
     def __init__(self, ds, spacing: float | list[float] = 1.0 / 30.0):

{pytmd-3.0.2 → pytmd-3.0.4}/pyTMD/io/dataset.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 """
 dataset.py
-Written by Tyler Sutterley (01/2026)
+Written by Tyler Sutterley (02/2026)
 An xarray.Dataset extension for tidal model data
 
 PYTHON DEPENDENCIES:
@@ -17,6 +17,8 @@ PYTHON DEPENDENCIES:
         https://docs.xarray.dev/en/stable/
 
 UPDATE HISTORY:
+    Updated 02/2026: create subaccessor registration functions
+        add functions to test if units are compatible with known groups
     Updated 01/2026: handle scalar inputs for coordinate transformations
     Updated 12/2025: add coords functions to transform coordinates
         set units attribute for amplitude and phase data arrays
@@ -40,7 +42,16 @@ import xarray as xr
 # suppress warnings
 warnings.filterwarnings("ignore", category=UserWarning)
 
-__all__ = ["DataTree", "Dataset", "DataArray", "_transform", "_coords"]
+__all__ = [
+    "DataTree",
+    "Dataset",
+    "DataArray",
+    "register_datatree_subaccessor",
+    "register_dataset_subaccessor",
+    "register_dataarray_subaccessor",
+    "_transform",
+    "_coords",
+]
 
 # pint unit registry
 __ureg__ = pint.UnitRegistry()
@@ -896,7 +907,12 @@ class DataArray:
     @property
     def units(self):
         """Units of the ``DataArray``"""
-        return __ureg__.parse_units(self._da.attrs.get("units", ""))
+        try:
+            return __ureg__.parse_units(self._units)
+        except TypeError as exc:
+            raise ValueError(f"Unknown units: {self._units}") from exc
+        except AttributeError as exc:
+            raise AttributeError("DataArray has no attribute 'units'") from exc
 
     @property
     def quantity(self):
@@ -912,8 +928,58 @@ class DataArray:
             return "current"
         elif self.units.is_compatible_with("m^2/s"):
             return "transport"
+        elif self.units.is_compatible_with("degrees"):
+            return "angle"
         else:
-            raise ValueError(f"Unknown unit group: {self.units}")
+            raise ValueError(f"Unknown unit group: {self._units}")
+
+    @property
+    def _units(self):
+        """Units attribute of the ``DataArray`` as a string"""
+        return self._da.attrs.get("units")
+
+    @property
+    def _has_compatible_units(self):
+        """Tests that units are compatible with known groups"""
+        try:
+            unit_group = self.group
+        except (TypeError, ValueError, AttributeError) as exc:
+            return False
+        else:
+            return True
+
+
+def register_datatree_subaccessor(name):
+    """Register a subaccessor on ``DataTree`` objects
+
+    Parameters
+    ----------
+    name: str
+        subaccessor name
+    """
+    return xr.core.extensions._register_accessor(name, DataTree)
+
+
+def register_dataset_subaccessor(name):
+    """Register a subaccessor on ``Dataset`` objects
+
+    Parameters
+    ----------
+    name: str
+        subaccessor name
+    """
+    return xr.core.extensions._register_accessor(name, Dataset)
+
+
+def register_dataarray_subaccessor(name):
+    """Register a subaccessor on ``DataArray`` objects
+
+    Parameters
+    ----------
+    name: str
+        subaccessor name
+    """
+    return xr.core.extensions._register_accessor(name, DataArray)
 
 
 def _transform(

{pytmd-3.0.2 → pytmd-3.0.4}/pyTMD/io/model.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 """
 model.py
-Written by Tyler Sutterley (11/2025)
+Written by Tyler Sutterley (02/2026)
 Retrieves tide model parameters for named tide models and
     from model definition files
 
@@ -13,6 +13,9 @@ PYTHON DEPENDENCIES:
         https://docs.xarray.dev/en/stable/
 
 UPDATE HISTORY:
+    Updated 02/2026: add HTML representation for model objects using xarray
+        set tidal constituent units (if unset) in a loop
+        check if units are compatible with known types before setting units
     Updated 11/2025: use default cache directory if directory is None
         added crs property for model coordinate reference system
         refactor to use new simpler (flattened) database format
@@ -121,14 +124,14 @@ class DataBase:
         """Returns the items of the model database"""
         return self.__dict__.items()
 
-    def __repr__(self):
-        """Representation of the ``DataBase`` object"""
-        return str(self.__dict__)
-
     def __str__(self):
         """String representation of the ``DataBase`` object"""
         return str(self.__dict__)
 
+    def __repr__(self):
+        """Representation of the ``DataBase`` object"""
+        return self.__str__()
+
     def get(self, key, default=None):
         if not hasattr(self, key) or getattr(self, key) is None:
             return default
@@ -218,6 +221,7 @@ class model:
         self.format = None
         self.name = None
         self.verify = copy.copy(kwargs["verify"])
+        self.__parameters__ = {}
 
     def from_database(self, m: str, group: tuple = ("z", "u", "v")):
         """
@@ -833,11 +837,11 @@ class model:
         ds.attrs["source"] = self.name
         # add coordinate reference system to Dataset
         ds.attrs["crs"] = self.crs.to_dict()
-        # list of constituents
-        c = ds.tmd.constituents
-        # set units attribute if not already set
-        # (uses value defined in the model database)
-        ds[c].attrs["units"] = ds[c].attrs.get("units", self[group].units)
+        # check if units attribute can be parsed and is a known type
+        # if units cannot be parsed: use value defined in the model database
+        for c in ds.tmd.constituents:
+            if not ds[c].tmd._has_compatible_units:
+                ds[c].attrs["units"] = self[group].units
         # convert to default units
         if kwargs["use_default_units"]:
             ds = ds.tmd.to_default_units()
@@ -873,6 +877,34 @@ class model:
         properties.append(f"    name: {self.name}")
         return "\n".join(properties)
 
+    def __repr__(self):
+        """Representation of the ``io.model`` object"""
+        return self.__str__()
+
+    def _repr_html_(self):
+        """HTML representation of the ``io.model`` object"""
+        header = "pyTMD.io.model"
+        header_components = [f"<div class='xr-obj-type'>{header}</div>"]
+        sections = []
+        data_vars = [k for k in ("z", "u", "v") if k in self.__parameters__]
+        parameters = {
+            k: v for k, v in self.__parameters__.items() if k not in data_vars
+        }
+        sections.append(xr.core.formatting_html.attr_section(parameters))
+        for v in data_vars:
+            sections.append(
+                xr.core.formatting_html._mapping_section(
+                    mapping=self.__parameters__[v],
+                    name=f"{v}-Attributes",
+                    details_func=xr.core.formatting_html.summarize_attrs,
+                    max_items_collapse=0,
+                    expand_option_name="display_expand_attrs",
+                )
+            )
+        return xr.core.formatting_html._obj_repr(
+            self, header_components, sections
+        )
+
     def get(self, key, default=None):
         return getattr(self, key, default) or default