vortex-nwp 2.0.0b1__py3-none-any.whl → 2.0.0b2__py3-none-any.whl

vortex/data/geometries.py

@@ -62,7 +62,6 @@ import bronx.patterns.getbytag
 import footprints
 
 from vortex.syntax.stddeco import namebuilding_insert, generic_pathname_insert
-from vortex.util.config import GenericConfigParser
 
 #: No automatic export
 __all__ = []
@@ -72,6 +71,7 @@ logger = loggers.getLogger(__name__)
 
 # Module Interface
 
+
 def get(**kw):
     """Return actual geometry object matching description.
 
@@ -111,6 +111,7 @@ def grep(**kw):
 
 # Abstract geometry classes
 
+
 class Geometry(bronx.patterns.getbytag.GetByTag):
     """Abstract geometry."""
 
@@ -124,18 +125,21 @@ class Geometry(bronx.patterns.getbytag.GetByTag):
 
         .. note:: This is an abstract class, do not instantiate.
         """
-        self.info = 'anonymous'
+        self.info = "anonymous"
         self.inifile = None
         self.__dict__.update(kw)
-        self.kind = 'abstract'
+        self.kind = "abstract"
         self._init_attributes = {k: v for k, v in kw.items() if v is not None}
-        logger.debug('Abstract Geometry init kw=%s', str(kw))
+        logger.debug("Abstract Geometry init kw=%s", str(kw))
 
     @classmethod
     def _tag_implicit_new_error(cls, tag):
         """Called whenever a tag does not exists and _tag_implicit_new = False."""
-        raise RuntimeError('The "{:s}" {:s} object does not exist yet...'.
-                           format(tag, cls.__name__))
+        raise RuntimeError(
+            'The "{:s}" {:s} object does not exist yet...'.format(
+                tag, cls.__name__
+            )
+        )
 
     @classmethod
     def tag_clean(self, tag):
@@ -144,7 +148,7 @@ class Geometry(bronx.patterns.getbytag.GetByTag):
 
     def __repr__(self):
         """Nicer represenation for geometries."""
-        return '<{:s}.{:s} (tag=\'{:s}\') object at {:#x}>'.format(
+        return "<{:s}.{:s} (tag='{:s}') object at {:#x}>".format(
             self.__module__, self.__class__.__name__, self.tag, id(self)
         )
 
@@ -153,14 +157,14 @@ class Geometry(bronx.patterns.getbytag.GetByTag):
 
     def doc_export(self):
         """Relevant informations to print in the documentation."""
-        return 'kind={:s}'.format(self.kind)
+        return "kind={:s}".format(self.kind)
 
     def to_inifile(self):
         """Format geometry to put in the inifile."""
         self._init_attributes.update(kind=self.kind)
-        s = '[{}]\n'.format(self.tag)
+        s = "[{}]\n".format(self.tag)
         for k in sorted(self._init_attributes.keys()):
-            s += '{:10s} = {}\n'.format(k, self._init_attributes[k])
+            s += "{:10s} = {}\n".format(k, self._init_attributes[k])
         return s
 
 
@@ -178,8 +182,10 @@ class VerticalGeometry(Geometry):
         .. note:: This is an abstract class, do not instantiate.
         """
         super().__init__(**kw)
-        self.kind = 'vertical'
-        logger.debug('Abstract Vertical Geometry init %s %s', str(self), str(kw))
+        self.kind = "vertical"
+        logger.debug(
+            "Abstract Vertical Geometry init %s %s", str(self), str(kw)
+        )
 
 
 class HorizontalGeometry(Geometry):
@@ -197,7 +203,7 @@ class HorizontalGeometry(Geometry):
         .. note:: This is an abstract class, do not instantiate.
         """
         desc = dict(
-            info='anonymous',
+            info="anonymous",
             gridtype=None,
             area=None,
             nlon=None,
@@ -205,8 +211,8 @@ class HorizontalGeometry(Geometry):
             nlat=None,
             ni=None,
             nj=None,
-            resolution=0.,
-            expected_resolution=0.,
+            resolution=0.0,
+            expected_resolution=0.0,
             runit=None,
             truncation=None,
             truncationtype=None,
@@ -220,22 +226,30 @@ class HorizontalGeometry(Geometry):
         desc.update(kw)
         super().__init__(**desc)
         for k, v in self.__dict__.items():
-            if isinstance(v, str) and re.match('none', v, re.IGNORECASE):
+            if isinstance(v, str) and re.match("none", v, re.IGNORECASE):
                 self.__dict__[k] = None
-            if isinstance(v, str) and re.match('true', v, re.IGNORECASE):
+            if isinstance(v, str) and re.match("true", v, re.IGNORECASE):
                 self.__dict__[k] = True
-            if isinstance(v, str) and re.match('false', v, re.IGNORECASE):
+            if isinstance(v, str) and re.match("false", v, re.IGNORECASE):
                 self.__dict__[k] = False
-        for item in ('nlon', 'nlat', 'ni', 'nj', 'nmassif', 'nposts', 'truncation'):
+        for item in (
+            "nlon",
+            "nlat",
+            "ni",
+            "nj",
+            "nmassif",
+            "nposts",
+            "truncation",
+        ):
             cv = getattr(self, item)
             if cv is not None:
                 setattr(self, item, int(cv))
-        for item in ('stretching', 'resolution', 'lonmin', 'latmin'):
+        for item in ("stretching", "resolution", "lonmin", "latmin"):
             cv = getattr(self, item)
             if cv is not None:
                 setattr(self, item, float(cv))
         self._check_attributes()
-        logger.debug('Abstract Horizontal Geometry init %s', str(self))
+        logger.debug("Abstract Horizontal Geometry init %s", str(self))
 
     def _check_attributes(self):
         if self.lam and (self.area is None):
@@ -250,15 +264,15 @@ class HorizontalGeometry(Geometry):
     def rnice(self):
         """Returns a string with a nice representation of the resolution (if sensible)."""
         if self.runit is not None:
-            if self.runit == 'km':
-                res = '{:05.2f}'.format(self.resolution)
-            elif self.runit in ('s', 'min'):
-                res = '{:04.1f}'.format(self.resolution)
+            if self.runit == "km":
+                res = "{:05.2f}".format(self.resolution)
+            elif self.runit in ("s", "min"):
+                res = "{:04.1f}".format(self.resolution)
             else:
-                res = '{:06.3f}'.format(self.resolution)
-            return re.sub(r'\.', self.runit, res, 1)
+                res = "{:06.3f}".format(self.resolution)
+            return re.sub(r"\.", self.runit, res, 1)
         else:
-            return 'Unknown Resolution'
+            return "Unknown Resolution"
 
     @property
     def rnice_u(self):
@@ -266,16 +280,20 @@ class HorizontalGeometry(Geometry):
 
     @property
     def gco_grid_def(self):
-        return ('{0.area}' + ('_{0.rnice}' if self.runit is not None else '')).format(self)
+        return (
+            "{0.area}" + ("_{0.rnice}" if self.runit is not None else "")
+        ).format(self)
 
     def anonymous_info(self, *args):  # @UnusedVariable
         """Try to build a meaningful information from an anonymous geometry."""
-        return '{!s}, {:s}'.format(self.area, self.rnice)
+        return "{!s}, {:s}".format(self.area, self.rnice)
 
     def __str__(self):
         """Very short presentation."""
-        if self.info == 'anonymous':
-            return '{:s}({:s})'.format(self.__class__.__name__, self.anonymous_info())
+        if self.info == "anonymous":
+            return "{:s}({:s})".format(
+                self.__class__.__name__, self.anonymous_info()
+            )
         else:
             return self.info
 
@@ -284,41 +302,61 @@ class HorizontalGeometry(Geometry):
         Returns a multilines documentation string with a summary
         of the valuable information contained by this geometry.
         """
-        indent = ' ' * indent
+        indent = " " * indent
         # Basics...
-        card = "\n".join((
-            '{0}Geometry {1!r}',
-            '{0}{0}Info       : {2:s}',
-            '{0}{0}LAM        : {3!s}',
-        )).format(indent, self, self.info, self.lam)
+        card = "\n".join(
+            (
+                "{0}Geometry {1!r}",
+                "{0}{0}Info       : {2:s}",
+                "{0}{0}LAM        : {3!s}",
+            )
+        ).format(indent, self, self.info, self.lam)
         # Optional infos
-        for attr in [k for k in ('area', 'resolution', 'truncation',
-                                 'stretching', 'nlon', 'nlat', 'ni', 'nj',
-                                 'nmassif', 'nposts')
-                     if getattr(self, k, False)]:
-            card += "\n{0}{0}{1:10s} : {2!s}".format(indent, attr.title(),
-                                                     getattr(self, attr))
+        for attr in [
+            k
+            for k in (
+                "area",
+                "resolution",
+                "truncation",
+                "stretching",
+                "nlon",
+                "nlat",
+                "ni",
+                "nj",
+                "nmassif",
+                "nposts",
+            )
+            if getattr(self, k, False)
+        ]:
+            card += "\n{0}{0}{1:10s} : {2!s}".format(
+                indent, attr.title(), getattr(self, attr)
+            )
         return card
 
     def strheader(self):
         """Return the beginning of the formatted print representation."""
-        header = '{:s}.{:s} | tag=\'{}\' id=\'{:s}\''.format(
+        header = "{:s}.{:s} | tag='{}' id='{:s}'".format(
             self.__module__,
             self.__class__.__name__,
             self.tag,
             self.info,
         )
         if self.lam:
-            header += ' area=\'{:s}\''.format(self.area)
+            header += " area='{:s}'".format(self.area)
         return header
 
     @property
     def coordinates(self):
-        if any([getattr(self, x) is None for x in ('lonmin', 'latmin', 'nlat', 'nlon', 'resolution')]):
+        if any(
+            [
+                getattr(self, x) is None
+                for x in ("lonmin", "latmin", "nlat", "nlon", "resolution")
+            ]
+        ):
             return dict()
         coordinates = dict(lonmin=self.lonmin, latmin=self.latmin)
-        coordinates['latmax'] = self.latmin + self.resolution * (self.nlat - 1)
-        coordinates['lonmax'] = self.lonmin + self.resolution * (self.nlon - 1)
+        coordinates["latmax"] = self.latmin + self.resolution * (self.nlat - 1)
+        coordinates["lonmax"] = self.lonmin + self.resolution * (self.nlon - 1)
         return coordinates
 
 
@@ -330,10 +368,13 @@ class SpectralAwareHorizontalGeometry(HorizontalGeometry):
     def _check_attributes(self):
         super()._check_attributes()
         if self.truncationtype is None:
-            self.truncationtype = 'linear'
-        if self.truncationtype not in ('linear', 'quadratic', 'cubic'):
-            raise ValueError("Improper value {:s} for *truncationtype*"
-                             .format(self.truncationtype))
+            self.truncationtype = "linear"
+        if self.truncationtype not in ("linear", "quadratic", "cubic"):
+            raise ValueError(
+                "Improper value {:s} for *truncationtype*".format(
+                    self.truncationtype
+                )
+            )
 
     @property
     def short_truncationtype(self):
@@ -341,11 +382,14 @@ class SpectralAwareHorizontalGeometry(HorizontalGeometry):
 
     @property
     def xtruncationtype(self):
-        return dict(quadratic='quad').get(self.truncationtype, self.truncationtype)
+        return dict(quadratic="quad").get(
+            self.truncationtype, self.truncationtype
+        )
 
 
 # Combined geometry (not used at the present time)
 
+
 class CombinedGeometry(Geometry):
     """Combine horizontal and vertical geometry (not used at the present time)."""
 
@@ -362,12 +406,13 @@ class CombinedGeometry(Geometry):
         self.hgeo = None
         self.vgeo = None
         super().__init__(**kw)
-        self.kind = 'combined'
-        logger.debug('Combined Geometry init %s %s', str(self), str(kw))
+        self.kind = "combined"
+        logger.debug("Combined Geometry init %s %s", str(self), str(kw))
 
 
 # Concrete geometry classes
 
+
 class GaussGeometry(SpectralAwareHorizontalGeometry):
     """
     Gaussian grid (stretched or not, rotated or not) associated with a spectral
@@ -392,8 +437,8 @@ class GaussGeometry(SpectralAwareHorizontalGeometry):
         .. note:: Gaussian grids are always global grids.
         """
         super().__init__(**kw)
-        self.kind = 'gauss'
-        logger.debug('Gauss Geometry init %s', str(self))
+        self.kind = "gauss"
+        logger.debug("Gauss Geometry init %s", str(self))
 
     def _check_attributes(self):
         self.lam = False  # Always false for gaussian grid
@@ -401,39 +446,48 @@ class GaussGeometry(SpectralAwareHorizontalGeometry):
         if self.truncation is None or self.stretching is None:
             raise AttributeError("Some mandatory arguments are missing")
         if self.gridtype is None:
-            self.gridtype = 'rgrid'
-        if self.gridtype not in ('rgrid', 'octahedral'):
-            raise ValueError("Improper value {:s} for *gridtype*"
-                             .format(self.gridtype))
+            self.gridtype = "rgrid"
+        if self.gridtype not in ("rgrid", "octahedral"):
+            raise ValueError(
+                "Improper value {:s} for *gridtype*".format(self.gridtype)
+            )
 
     @property
     def short_gridtype(self):
-        return self.gridtype[0] if self.gridtype != 'rgrid' else ''
+        return self.gridtype[0] if self.gridtype != "rgrid" else ""
 
     @property
     def gco_grid_def(self):
-        geotag_f = 't'
-        if self.truncationtype != 'linear' or self.gridtype != 'rgrid':
-            geotag_f += '{0.short_truncationtype}'
-        geotag_f += '{0.short_gridtype}{0.truncation:d}'
+        geotag_f = "t"
+        if self.truncationtype != "linear" or self.gridtype != "rgrid":
+            geotag_f += "{0.short_truncationtype}"
+        geotag_f += "{0.short_gridtype}{0.truncation:d}"
         return geotag_f.format(self)
 
     def __str__(self):
         """Standard formatted print representation."""
-        return '<{:s} t{:s}{:s}={:d} c={:g}>'.format(self.strheader(),
-                                                     self.short_truncationtype,
-                                                     self.short_gridtype,
-                                                     self.truncation,
-                                                     self.stretching)
+        return "<{:s} t{:s}{:s}={:d} c={:g}>".format(
+            self.strheader(),
+            self.short_truncationtype,
+            self.short_gridtype,
+            self.truncation,
+            self.stretching,
+        )
 
     def doc_export(self):
         """Relevant informations to print in the documentation."""
         if self.stretching > 1:
-            fmts = 'kind={0:s}, t{1:s}{2:s}={3:d}, c={4:g} (pole of interest over {5!s})'
+            fmts = "kind={0:s}, t{1:s}{2:s}={3:d}, c={4:g} (pole of interest over {5!s})"
         else:
-            fmts = 'kind={0:s}, t{1:s}{2:s}={3:d}, c={4:g}'
-        return fmts.format(self.kind, self.short_truncationtype, self.short_gridtype,
-                           self.truncation, self.stretching, self.area)
+            fmts = "kind={0:s}, t{1:s}{2:s}={3:d}, c={4:g}"
+        return fmts.format(
+            self.kind,
+            self.short_truncationtype,
+            self.short_gridtype,
+            self.truncation,
+            self.stretching,
+            self.area,
+        )
 
 
 class ProjectedGeometry(SpectralAwareHorizontalGeometry):
@@ -451,10 +505,10 @@ class ProjectedGeometry(SpectralAwareHorizontalGeometry):
         :param str runit: The unit of the resolution (km, ...) (km by default)
         :param str area: The grid location (needed if **lam** is *True*)
         """
-        kw.setdefault('runit', 'km')
+        kw.setdefault("runit", "km")
         super().__init__(**kw)
-        self.kind = 'projected'
-        logger.debug('Projected Geometry init %s', str(self))
+        self.kind = "projected"
+        logger.debug("Projected Geometry init %s", str(self))
 
     def _check_attributes(self):
         super()._check_attributes()
@@ -463,23 +517,30 @@ class ProjectedGeometry(SpectralAwareHorizontalGeometry):
 
     @property
     def gco_grid_def(self):
-        geotag_f = ('{0.area}_{0.rnice}' if self.truncationtype == 'linear' else
-                    '{0.area}_{0.xtruncationtype}_{0.rnice}')
+        geotag_f = (
+            "{0.area}_{0.rnice}"
+            if self.truncationtype == "linear"
+            else "{0.area}_{0.xtruncationtype}_{0.rnice}"
+        )
         return geotag_f.format(self)
 
     def __str__(self):
         """Standard formatted print representation."""
-        return '<{:s} r=\'{:s}\' {:s}>'.format(self.strheader(),
-                                               self.rnice,
-                                               self.truncationtype)
+        return "<{:s} r='{:s}' {:s}>".format(
+            self.strheader(), self.rnice, self.truncationtype
+        )
 
     def doc_export(self):
         """Relevant informations to print in the documentation."""
         if self.lam:
-            fmts = 'kind={0:s}, r={1:s}, truncationtype={2:s}, limited-area={3:s}'
+            fmts = (
+                "kind={0:s}, r={1:s}, truncationtype={2:s}, limited-area={3:s}"
+            )
         else:
-            fmts = 'kind={0:s}, r={1:s}, truncationtype={2:s}, global'
-        return fmts.format(self.kind, self.rnice, self.truncationtype, self.area)
+            fmts = "kind={0:s}, r={1:s}, truncationtype={2:s}, global"
+        return fmts.format(
+            self.kind, self.rnice, self.truncationtype, self.area
+        )
 
 
 class LonlatGeometry(HorizontalGeometry):
@@ -499,23 +560,25 @@ class LonlatGeometry(HorizontalGeometry):
         :param int nlat: The number of latitude points in the grid
         :param str area: The grid location (needed if **lam** is *True*)
         """
-        kw.setdefault('runit', 'dg')
+        kw.setdefault("runit", "dg")
         super().__init__(**kw)
-        self.kind = 'lonlat'
+        self.kind = "lonlat"
         # TODO: coherence entre les coordonnees et nlon/nlat/resolution
-        logger.debug('Lon/Lat Geometry init %s', str(self))
+        logger.debug("Lon/Lat Geometry init %s", str(self))
 
     def __str__(self):
         """Standard formatted print representation."""
-        return '<{:s} r=\'{:s}\'>'.format(self.strheader(), self.rnice)
+        return "<{:s} r='{:s}'>".format(self.strheader(), self.rnice)
 
     def doc_export(self):
         """Relevant informations to print in the documentation."""
         if self.lam:
-            fmts = 'kind={0:s}, r={1:s}, limited-area={2:s}, nlon={3!s}, nlat={4!s}'
+            fmts = "kind={0:s}, r={1:s}, limited-area={2:s}, nlon={3!s}, nlat={4!s}"
         else:
-            fmts = 'kind={0:s}, r={1:s}, global, nlon={3!s}, nlat={4!s}'
-        return fmts.format(self.kind, self.rnice, self.area, self.nlon, self.nlat)
+            fmts = "kind={0:s}, r={1:s}, global, nlon={3!s}, nlat={4!s}"
+        return fmts.format(
+            self.kind, self.rnice, self.area, self.nlon, self.nlat
+        )
 
 
 class UnstructuredGeometry(HorizontalGeometry):
@@ -533,19 +596,19 @@ class UnstructuredGeometry(HorizontalGeometry):
         .. note:: This is an abstract class, do not instantiate.
         """
         super().__init__(**kw)
-        self.kind = 'unstructured'
-        logger.debug('Unstructured Geometry init %s', str(self))
+        self.kind = "unstructured"
+        logger.debug("Unstructured Geometry init %s", str(self))
 
     def __str__(self):
         """Standard formatted print representation."""
-        return '<{:s}>'.format(self.strheader())
+        return "<{:s}>".format(self.strheader())
 
     def doc_export(self):
         """Relevant informations to print in the documentation."""
         if self.area:
-            fmts = 'kind={0:s}, area={1:s}'
+            fmts = "kind={0:s}, area={1:s}"
         else:
-            fmts = 'kind={0:s}'
+            fmts = "kind={0:s}"
         return fmts.format(self.kind, self.area)
 
 
@@ -565,7 +628,7 @@ class CurvlinearGeometry(UnstructuredGeometry):
         :param str area: The grid location (needed if **lam** is *True*)
         """
         super().__init__(**kw)
-        self.kind = 'curvlinear'
+        self.kind = "curvlinear"
 
     def _check_attributes(self):
         super()._check_attributes()
@@ -575,10 +638,14 @@ class CurvlinearGeometry(UnstructuredGeometry):
     def doc_export(self):
         """Relevant informations to print in the documentation."""
         if self.lam:
-            fmts = 'kind={0:s}, r={1:s}, limited-area={2:s}, ni={3!s}, nj={4!s}'
+            fmts = (
+                "kind={0:s}, r={1:s}, limited-area={2:s}, ni={3!s}, nj={4!s}"
+            )
         else:
-            fmts = 'kind={0:s}, r={1:s}, global, ni={3!s}, nj={4!s}'
-        return fmts.format(self.kind, self.rnice, self.area, self.nlon, self.nlat)
+            fmts = "kind={0:s}, r={1:s}, global, ni={3!s}, nj={4!s}"
+        return fmts.format(
+            self.kind, self.rnice, self.area, self.nlon, self.nlat
+        )
 
 
 class RedgridGeometry(HorizontalGeometry):
@@ -598,28 +665,34 @@ class RedgridGeometry(HorizontalGeometry):
                                         ``longitudes = expected_resolution * cos(lat)``
         :param str area: The grid location (needed if **lam** is *True*)
         """
-        kw.setdefault('runit', 'dg')
-        kw.setdefault('lam', False)
+        kw.setdefault("runit", "dg")
+        kw.setdefault("lam", False)
         super().__init__(**kw)
-        self.kind = 'redgrid'
+        self.kind = "redgrid"
 
     def _check_attributes(self):
-        if self.nlonmax is None or self.nlat is None or self.resolution is None:
+        if (
+            self.nlonmax is None
+            or self.nlat is None
+            or self.resolution is None
+        ):
             raise AttributeError("Some mandatory arguments are missing")
         super()._check_attributes()
         if self.lam is False:
-            self.area = 'global'
+            self.area = "global"
 
     def __str__(self):
         """Standard formatted print representation."""
-        return '<{:s} area=\'{:s}\' r=\'{:s}\'>'.format(self.strheader(),
-                                                        self.area,
-                                                        self.rnice)
+        return "<{:s} area='{:s}' r='{:s}'>".format(
+            self.strheader(), self.area, self.rnice
+        )
 
     def doc_export(self):
         """Relevant informations to print in the documentation."""
-        fmts = 'kind={0:s}, r={1:s}, area={2:s}, nlonmax={3!s}, nlat={4!s}'
-        return fmts.format(self.kind, self.rnice, self.area, self.nlonmax, self.nlat)
+        fmts = "kind={0:s}, r={1:s}, area={2:s}, nlonmax={3!s}, nlat={4!s}"
+        return fmts.format(
+            self.kind, self.rnice, self.area, self.nlonmax, self.nlat
+        )
 
 
 # Pre-defined footprint attribute for any HorizontalGeometry
@@ -637,60 +710,83 @@ def _add_geo2basename_info(cls):
     def _geo2basename_info(self, add_stretching=True):
         """Return an array describing the geometry for the Vortex's name builder."""
         if isinstance(self.geometry, GaussGeometry):
-            lgeo = [{'truncation': (self.geometry.truncation,
-                                    self.geometry.short_truncationtype,
-                                    self.geometry.short_gridtype)}, ]
+            lgeo = [
+                {
+                    "truncation": (
+                        self.geometry.truncation,
+                        self.geometry.short_truncationtype,
+                        self.geometry.short_gridtype,
+                    )
+                },
+            ]
             if add_stretching:
-                lgeo.append({'stretching': self.geometry.stretching})
+                lgeo.append({"stretching": self.geometry.stretching})
         elif isinstance(self.geometry, (ProjectedGeometry, RedgridGeometry)):
             lgeo = [self.geometry.area, self.geometry.rnice]
-            if (self.geometry.truncationtype is not None and
-                    self.geometry.truncationtype != 'linear'):
+            if (
+                self.geometry.truncationtype is not None
+                and self.geometry.truncationtype != "linear"
+            ):
                 lgeo.append(self.geometry.xtruncationtype)
         else:
             lgeo = self.geometry.area  # Default: always defined
         return lgeo
 
-    if not hasattr(cls, '_geo2basename_info'):
+    if not hasattr(cls, "_geo2basename_info"):
         cls._geo2basename_info = _geo2basename_info
     return cls
 
 
 #: Abstract footprint definition of the ``geometry`` attribute.
-hgeometry = footprints.Footprint(info='Abstract Horizontal Geometry',
-                                 attr=dict(geometry=a_hgeometry))
+hgeometry = footprints.Footprint(
+    info="Abstract Horizontal Geometry", attr=dict(geometry=a_hgeometry)
+)
 
 #: Abstract footprint definition of the ``geometry`` attribute with decorators
 #: that alter the ``namebuilding_info`` method
 hgeometry_deco = footprints.DecorativeFootprint(
     hgeometry,
-    decorator=[_add_geo2basename_info,
-               namebuilding_insert('geo', lambda self: self._geo2basename_info()),
-               generic_pathname_insert('geometry', lambda self: self.geometry, setdefault=True)])
+    decorator=[
+        _add_geo2basename_info,
+        namebuilding_insert("geo", lambda self: self._geo2basename_info()),
+        generic_pathname_insert(
+            "geometry", lambda self: self.geometry, setdefault=True
+        ),
+    ],
+)
 
 
 # Load default geometries when the module is first imported
 
-def load(inifile='@geometries.ini', refresh=False, verbose=True):
+
+def load(inifile="@geometries.ini", refresh=False, verbose=True):
     """Load a set of pre-defined geometries from a configuration file.
 
     The class that will be instantiated depends on the "kind" keyword..
     """
     iniconf = configparser.ConfigParser()
     with importlib.resources.open_text(
-            "vortex.data", "geometries.ini",
+        "vortex.data",
+        "geometries.ini",
     ) as fh:
         iniconf.read_file(fh)
     for item in iniconf.sections():
         gdesc = dict(iniconf.items(item))
-        gkind = gdesc.get('kind')
+        gkind = gdesc.get("kind")
         try:
-            thisclass = [x for x in Geometry.tag_classes()
-                         if x.__name__.lower().startswith(gkind.lower())].pop()
+            thisclass = [
+                x
+                for x in Geometry.tag_classes()
+                if x.__name__.lower().startswith(gkind.lower())
+            ].pop()
         except IndexError:
-            raise AttributeError('Kind={:s} is unknown (for geometry [{:s}])'.format(gkind, item))
+            raise AttributeError(
+                "Kind={:s} is unknown (for geometry [{:s}])".format(
+                    gkind, item
+                )
+            )
         if verbose:
-            print('+ Load', item.ljust(16), 'as', thisclass)
+            print("+ Load", item.ljust(16), "as", thisclass)
         if refresh:
             # Always recreate the Geometry...
             thisclass(tag=item, new=True, **gdesc)