vortex-nwp 2.0.0b1__py3-none-any.whl → 2.1.0__py3-none-any.whl

vortex/tools/names.py

@@ -17,6 +17,7 @@ logger = loggers.getLogger(__name__)
 
 class VortexNameBuilderError(ValueError):
     """Raised whenever the name building process fails."""
+
     pass
 
 
@@ -24,26 +25,39 @@ class AbstractVortexNameBuilder(footprints.FootprintBase):
     """Abstract class for any name building class."""
 
     _abstract = True
-    _collector = ('vortexnamebuilder',)
+    _collector = ("vortexnamebuilder",)
     _footprint = dict(
-        info = 'Abstract Vortex NameBuilder',
-        attr = dict(
-            name = dict(
-                info        = "The NameBuilder's name.",
+        info="Abstract Vortex NameBuilder",
+        attr=dict(
+            name=dict(
+                info="The NameBuilder's name.",
             ),
         ),
-        fastkeys = {'name'}
+        fastkeys={"name"},
     )
 
     def __init__(self, *args, **kw):
-        logger.debug('Init VortexNameBuilder %s', self.__class__)
+        logger.debug("Init VortexNameBuilder %s", self.__class__)
         super().__init__(*args, **kw)
         self._default = dict(
-            radical='vortexdata',
+            radical="vortexdata",
         )
         # List of known defaults
-        for k in ['flow', 'src', 'term', 'period', 'cen_period', 'geo', 'suffix',
-                  'stage', 'fmt', 'part', 'compute', 'number', 'filtername']:
+        for k in [
+            "flow",
+            "src",
+            "term",
+            "period",
+            "cen_period",
+            "geo",
+            "suffix",
+            "stage",
+            "fmt",
+            "part",
+            "compute",
+            "number",
+            "filtername",
+        ]:
             self._default[k] = None
         self.setdefault(**kw)
 
@@ -66,16 +80,16 @@ class AbstractVortexNameBuilder(footprints.FootprintBase):
 
     def pack_basename(self, d):
         """Returns a basename given the **d** info dictionary."""
-        raise NotImplementedError('This is an abstract method !')
+        raise NotImplementedError("This is an abstract method !")
 
     def pack_pathname(self, d):
         """Returns a pathname given the **d** info dictionary."""
-        raise NotImplementedError('This is an abstract method !')
+        raise NotImplementedError("This is an abstract method !")
 
 
 # Activate the footprint's fasttrack on the resources collector
-vbcollect = footprints.collectors.get(tag='vortexnamebuilder')
-vbcollect.fasttrack = ('name', )
+vbcollect = footprints.collectors.get(tag="vortexnamebuilder")
+vbcollect.fasttrack = ("name",)
 del vbcollect
 
 
@@ -113,7 +127,7 @@ class AbstractVortexNameBuilderProxy(AbstractVortexNameBuilder):
 
     def _pick_actual_builder(self, d):
         """Given the input dictionary, returns the appropriate builder object."""
-        raise NotImplementedError('This is an abstract method !')
+        raise NotImplementedError("This is an abstract method !")
 
     def pack_basename(self, d):
         """Returns a basename given the **d** info dictionary."""
@@ -135,7 +149,7 @@ class AbstractActualVortexNameBuilder(AbstractVortexNameBuilder):
 
     _abstract = True
 
-    def _pack_generic(self, d, what, default='std'):
+    def _pack_generic(self, d, what, default="std"):
         """
         Build the resource vortex basename/pathname or whatever according to
         ``style`` value.
@@ -144,60 +158,68 @@ class AbstractActualVortexNameBuilder(AbstractVortexNameBuilder):
         components.update(self._default)
         components.update(d)
 
-        packstyle = getattr(self, '_pack_{!s}_{!s}'.format(what,
-                                                           components.get('style', default)))
+        packstyle = getattr(
+            self,
+            "_pack_{!s}_{!s}".format(what, components.get("style", default)),
+        )
         return packstyle(components)
 
     def pack_basename(self, d):
         """Build the resource vortex basename according to ``style`` value."""
-        return self._pack_generic(d, 'basename')
+        return self._pack_generic(d, "basename")
 
     def pack_pathname(self, d):
         """Build the resource vortex pathname according to ``style`` value."""
-        return '/'.join(self._pack_generic(d, 'pathname'))
+        return "/".join(self._pack_generic(d, "pathname"))
 
     # A Vortex pathname may include the following bits
 
     def _pack_pathname_init(self, d):
         """Mandatory things to be packed into the pathname."""
         pathbits = []
-        for k in ['vapp', 'vconf', 'experiment']:
+        for k in ["vapp", "vconf", "experiment"]:
             if k not in d:
-                raise VortexNameBuilderError('The {!r} info key is mandatory'.format(k))
+                raise VortexNameBuilderError(
+                    "The {!r} info key is mandatory".format(k)
+                )
             pathbits.append(str(d[k]))
         return pathbits
 
     def _pack_pathname_append_flowdate(self, pathbits, d):
         """Pack the date/cutoff that characterise the resource's flow."""
-        if 'flow' in d and d['flow'] is not None:
-            pathbits.append(self._pack_std_items_datestuff(d['flow'], fatal=True))
+        if "flow" in d and d["flow"] is not None:
+            pathbits.append(
+                self._pack_std_items_datestuff(d["flow"], fatal=True)
+            )
         else:
-            raise VortexNameBuilderError('The flow info key is mandatory')
+            raise VortexNameBuilderError("The flow info key is mandatory")
 
     def _pack_pathname_append_flowperiod(self, pathbits, d):
         """Pack the period/cutoff that characterise the resource's flow."""
-        if 'flow' in d and d['flow'] is not None:
-            pathbits.append(self._pack_std_items_periodstuff(d['flow'], fatal=True))
+        if "flow" in d and d["flow"] is not None:
+            pathbits.append(
+                self._pack_std_items_periodstuff(d["flow"], fatal=True)
+            )
         else:
-            raise VortexNameBuilderError('The flow info key is mandatory')
+            raise VortexNameBuilderError("The flow info key is mandatory")
 
     def _pack_pathname_append_member(self, pathbits, d):
         """Pack the provider's member number (optional)."""
-        if 'member' in d and d['member'] is not None:
-            pathbits.append(self._pack_std_item_member(d['member']))
+        if "member" in d and d["member"] is not None:
+            pathbits.append(self._pack_std_item_member(d["member"]))
 
     def _pack_pathname_append_scenario(self, pathbits, d):
         """Pack the provider's scenario identifier (optional)."""
-        if 'scenario' in d and d['scenario'] is not None:
-            pathbits.append(self._pack_std_item_scenario(d['scenario']))
+        if "scenario" in d and d["scenario"] is not None:
+            pathbits.append(self._pack_std_item_scenario(d["scenario"]))
 
     def _pack_pathname_append_block(self, pathbits, d):
         """Pack the provider's block name."""
-        if 'block' in d:
-            if d['block']:
-                pathbits.append('_'.join(self._pack_std_items(d['block'])))
+        if "block" in d:
+            if d["block"]:
+                pathbits.append("_".join(self._pack_std_items(d["block"])))
         else:
-            raise VortexNameBuilderError('The block info key is mandatory')
+            raise VortexNameBuilderError("The block info key is mandatory")
 
     # A bunch of utility methods that prepares values
 
@@ -207,67 +229,67 @@ class AbstractActualVortexNameBuilder(AbstractVortexNameBuilder):
 
     def _pack_std_item_seta(self, value):
         """Packing of a MPI-task number in first direction."""
-        return 'a{:04d}'.format(int(value))
+        return "a{:04d}".format(int(value))
 
     def _pack_std_item_setb(self, value):
         """Packing of a MPI-task number in second direction."""
-        return 'b{:04d}'.format(int(value))
+        return "b{:04d}".format(int(value))
 
     def _pack_std_item_mpi(self, value):
         """Packing of a MPI-task number."""
-        return 'n{:04d}'.format(int(value))
+        return "n{:04d}".format(int(value))
 
     def _pack_std_item_openmp(self, value):
         """Packing of an OpenMP id number."""
-        return 'omp{:02d}'.format(int(value))
+        return "omp{:02d}".format(int(value))
 
     def _pack_std_item_month(self, value):
         """Packing of a month-number value."""
-        return 'm{!s}'.format(value)
+        return "m{!s}".format(value)
 
     def _pack_std_item_stretching(self, value):
         """Packing of the stretching factor in spectral geometry."""
-        return 'c{!s}'.format(int(value * 10))
+        return "c{!s}".format(int(value * 10))
 
     def _pack_std_item_truncation(self, value):
         """Packing of the geometry's truncation value."""
         if isinstance(value, tuple):
-            return 't{1:s}{2:s}{0!s}'.format(* value)
+            return "t{1:s}{2:s}{0!s}".format(*value)
         else:
-            return 'tl{!s}'.format(value)
+            return "tl{!s}".format(value)
 
     def _pack_std_item_filtering(self, value):
         """Packing of the geometry's filtering value."""
-        return 'f{!s}'.format(value)
+        return "f{!s}".format(value)
 
     def _pack_std_item_time(self, value):
         """Packing of a Time object."""
-        return value.fmthm if hasattr(value, 'fmthm') else str(value)
+        return value.fmthm if hasattr(value, "fmthm") else str(value)
 
     _pack_std_item_begintime = _pack_std_item_time
     _pack_std_item_endtime = _pack_std_item_time
 
     def _pack_std_item_date(self, value):
         """Packing of a Time object."""
-        return value.stdvortex if hasattr(value, 'stdvortex') else str(value)
+        return value.stdvortex if hasattr(value, "stdvortex") else str(value)
 
     _pack_std_item_begindate = _pack_std_item_date
     _pack_std_item_enddate = _pack_std_item_date
 
     def _pack_std_item_cutoff(self, value):
         """Abbreviate the cutoff name."""
-        cutoff_map = dict(production='prod')
+        cutoff_map = dict(production="prod")
         return cutoff_map.get(value, value)
 
-    def _pack_std_item_shortcutoff(self, value, default='X'):
+    def _pack_std_item_shortcutoff(self, value, default="X"):
         """Abbreviate the cutoff name."""
         return value[0].upper() if value is not None else default
 
     def _pack_std_item_member(self, value):
-        return 'mb{:03d}'.format(value)
+        return "mb{:03d}".format(value)
 
     def _pack_std_item_scenario(self, value):
-        return 's{:s}'.format(value)
+        return "s{:s}".format(value)
 
     def _pack_std_items(self, items):
         """
@@ -280,15 +302,19 @@ class AbstractActualVortexNameBuilder(AbstractVortexNameBuilder):
         for i in items:
             if isinstance(i, dict):
                 for k, v in i.items():
-                    packmtd = getattr(self, '_pack_std_item_' + k, self._pack_void_item)
+                    packmtd = getattr(
+                        self, "_pack_std_item_" + k, self._pack_void_item
+                    )
                     packed.append(packmtd(v))
             else:
                 packed.append(self._pack_void_item(i))
         return packed
 
     def _pack_std_items_negativetimes(self, items):
-        return [(t[1:] + 'ago' if t[0] == '-' else t)
-                for t in self._pack_std_items(items)]
+        return [
+            (t[1:] + "ago" if t[0] == "-" else t)
+            for t in self._pack_std_items(items)
+        ]
 
     def _pack_std_items_datestuff(self, d, fatal=False):
         """Specialised version of _pack_std_items that deals with date/cutoff pairs."""
@@ -296,16 +322,18 @@ class AbstractActualVortexNameBuilder(AbstractVortexNameBuilder):
         flowcut = None
         if isinstance(d, (tuple, list)):
             for flowitem in [x for x in d if isinstance(x, dict)]:
-                if 'date' in flowitem:
-                    flowdate = flowitem['date']
-                if 'shortcutoff' in flowitem:
-                    flowcut = flowitem['shortcutoff']
+                if "date" in flowitem:
+                    flowdate = flowitem["date"]
+                if "shortcutoff" in flowitem:
+                    flowcut = flowitem["shortcutoff"]
         if flowdate is None:
             if fatal:
-                raise VortexNameBuilderError('A date is mandatory here...')
+                raise VortexNameBuilderError("A date is mandatory here...")
             else:
-                return ''
-        return self._pack_std_item_date(flowdate) + self._pack_std_item_shortcutoff(flowcut)
+                return ""
+        return self._pack_std_item_date(
+            flowdate
+        ) + self._pack_std_item_shortcutoff(flowcut)
 
     def _pack_std_items_periodstuff(self, d, fatal=False):
         """Specialised version of _pack_std_items that deals with begindate/enddate/cutoff pairs."""
@@ -314,67 +342,88 @@ class AbstractActualVortexNameBuilder(AbstractVortexNameBuilder):
         flowcut = None
         if isinstance(d, (tuple, list)):
             for flowitem in [x for x in d if isinstance(x, dict)]:
-                if 'begindate' in flowitem:
-                    flowbegin = flowitem['begindate']
-                if 'enddate' in flowitem:
-                    flowend = flowitem['enddate']
-                if 'shortcutoff' in flowitem:
-                    flowcut = flowitem['shortcutoff']
+                if "begindate" in flowitem:
+                    flowbegin = flowitem["begindate"]
+                if "enddate" in flowitem:
+                    flowend = flowitem["enddate"]
+                if "shortcutoff" in flowitem:
+                    flowcut = flowitem["shortcutoff"]
         if flowbegin is None or flowend is None:
             if fatal:
-                raise VortexNameBuilderError('A begindate/enddate pair is mandatory here...')
+                raise VortexNameBuilderError(
+                    "A begindate/enddate pair is mandatory here..."
+                )
             else:
-                return ''
-        return '-'.join([self._pack_std_item_date(flowbegin) +
-                         self._pack_std_item_shortcutoff(flowcut, default=''),
-                         self._pack_std_item_date(flowend)])
+                return ""
+        return "-".join(
+            [
+                self._pack_std_item_date(flowbegin)
+                + self._pack_std_item_shortcutoff(flowcut, default=""),
+                self._pack_std_item_date(flowend),
+            ]
+        )
 
     # A Vortex basename may include the following bits
 
     def _pack_std_basename_prefixstuff(self, d):  # @UnusedVariable
         """Adds any info about date, cutoff ..."""
-        name0 = d['radical']
-        name0 += self._join_basename_bit(d, 'src', prefix='.', sep='-')
-        name0 += self._join_basename_bit(d, 'filtername', prefix='.', sep='-')
-        name0 += self._join_basename_bit(d, 'geo', prefix='.', sep='-')
-        name0 += self._join_basename_bit(d, 'compute', prefix='.', sep='-')
+        name0 = d["radical"]
+        name0 += self._join_basename_bit(d, "src", prefix=".", sep="-")
+        name0 += self._join_basename_bit(d, "filtername", prefix=".", sep="-")
+        name0 += self._join_basename_bit(d, "geo", prefix=".", sep="-")
+        name0 += self._join_basename_bit(d, "compute", prefix=".", sep="-")
         return name0
 
     def _pack_std_basename_flowstuff(self, d):  # @UnusedVariable
         """Adds any info about date, cutoff ..."""
-        return ''
+        return ""
 
     def _pack_std_basename_timestuff(self, d):  # @UnusedVariable
         """Adds any info about term, period, ..."""
-        name = ''
-        if d['term'] is not None:
-            name += self._join_basename_bit(d, 'term', prefix='+', sep='.',
-                                            packcb=self._pack_std_items_negativetimes)
+        name = ""
+        if d["term"] is not None:
+            name += self._join_basename_bit(
+                d,
+                "term",
+                prefix="+",
+                sep=".",
+                packcb=self._pack_std_items_negativetimes,
+            )
         else:
-            if d['period'] is not None:
-                name += self._join_basename_bit(d, 'period', prefix='+', sep='-',
-                                                packcb=self._pack_std_items_negativetimes)
-            elif d['cen_period'] is not None:
-                name += self._join_basename_bit(d, 'cen_period', prefix='_', sep='_',
-                                                packcb=self._pack_std_items_negativetimes)
+            if d["period"] is not None:
+                name += self._join_basename_bit(
+                    d,
+                    "period",
+                    prefix="+",
+                    sep="-",
+                    packcb=self._pack_std_items_negativetimes,
+                )
+            elif d["cen_period"] is not None:
+                name += self._join_basename_bit(
+                    d,
+                    "cen_period",
+                    prefix="_",
+                    sep="_",
+                    packcb=self._pack_std_items_negativetimes,
+                )
         return name
 
     def _pack_std_basename_suffixstuff(self, d):  # @UnusedVariable
         """Adds any info about date, cutoff ..."""
-        name1 = ''
-        name1 += self._join_basename_bit(d, 'number', prefix='.', sep='-')
-        name1 += self._join_basename_bit(d, 'fmt', prefix='.', sep='.')
-        name1 += self._join_basename_bit(d, 'suffix', prefix='.', sep='.')
+        name1 = ""
+        name1 += self._join_basename_bit(d, "number", prefix=".", sep="-")
+        name1 += self._join_basename_bit(d, "fmt", prefix=".", sep=".")
+        name1 += self._join_basename_bit(d, "suffix", prefix=".", sep=".")
         return name1
 
-    def _join_basename_bit(self, d, entry, prefix='.', sep='-', packcb=None):
+    def _join_basename_bit(self, d, entry, prefix=".", sep="-", packcb=None):
         if d[entry] is not None:
             if packcb is None:
                 return prefix + sep.join(self._pack_std_items(d[entry]))
             else:
                 return prefix + sep.join(packcb(d[entry]))
         else:
-            return ''
+            return ""
 
     # Methods that generates basenames
 
@@ -383,10 +432,12 @@ class AbstractActualVortexNameBuilder(AbstractVortexNameBuilder):
         Main entry point to convert a description into a file name
         according to the so-called standard style.
         """
-        return (self._pack_std_basename_prefixstuff(d).lower() +
-                self._pack_std_basename_flowstuff(d) +
-                self._pack_std_basename_timestuff(d) +
-                self._pack_std_basename_suffixstuff(d).lower())
+        return (
+            self._pack_std_basename_prefixstuff(d).lower()
+            + self._pack_std_basename_flowstuff(d)
+            + self._pack_std_basename_timestuff(d)
+            + self._pack_std_basename_suffixstuff(d).lower()
+        )
 
     # Methods that generates pathnames
 
@@ -395,30 +446,32 @@ class AbstractActualVortexNameBuilder(AbstractVortexNameBuilder):
         Main entry point to convert a description into a path name
         according to the so-called standard style.
         """
-        raise NotImplementedError('This is an abstract method !')
+        raise NotImplementedError("This is an abstract method !")
 
 
 class VortexDateNameBuilder(AbstractActualVortexNameBuilder):
     """A Standard Vortex NameBuilder (with date and cutoff)."""
 
     _footprint = dict(
-        info = 'A Standard Vortex NameBuilder (with date and cutoff)',
-        attr = dict(
-            name = dict(
-                values = ['date@std', ],
+        info="A Standard Vortex NameBuilder (with date and cutoff)",
+        attr=dict(
+            name=dict(
+                values=[
+                    "date@std",
+                ],
             ),
-        )
+        ),
     )
 
     # A Vortex basename may include the following bits
 
     def _pack_std_basename_flowstuff(self, d):
         """Adds any info about term and period, ..."""
-        name = ''
-        if d['flow'] is not None:
-            pstuff = self._pack_std_items_periodstuff(d['flow'])
+        name = ""
+        if d["flow"] is not None:
+            pstuff = self._pack_std_items_periodstuff(d["flow"])
             if pstuff:
-                name += '.' + pstuff
+                name += "." + pstuff
         return name
 
     # Methods that generates basenames
@@ -428,16 +481,18 @@ class VortexDateNameBuilder(AbstractActualVortexNameBuilder):
         Main entry point to convert a description into a file name
         according to the so-called observation style.
         """
-        obsfmt = d.get('nativefmt', d.get('fmt', None))
+        obsfmt = d.get("nativefmt", d.get("fmt", None))
         if obsfmt is None:
             raise VortexNameBuilderError()
-        name = '.'.join([
-            obsfmt + '-' + d.get('layout', 'std'),
-            'void' if d['stage'] is None else d['stage'],
-            'all' if d['part'] is None else d['part'],
-        ])
-        if d['suffix'] is not None:
-            name = name + '.' + d['suffix']
+        name = ".".join(
+            [
+                obsfmt + "-" + d.get("layout", "std"),
+                "void" if d["stage"] is None else d["stage"],
+                "all" if d["part"] is None else d["part"],
+            ]
+        )
+        if d["suffix"] is not None:
+            name = name + "." + d["suffix"]
 
         return name.lower()
 
@@ -446,11 +501,13 @@ class VortexDateNameBuilder(AbstractActualVortexNameBuilder):
         Main entry point to convert a description into a file name
         according to the so-called observation-map style.
         """
-        name = '.'.join((
-            d['radical'],
-            '-'.join(self._pack_std_items(d['stage'])),
-            'txt' if d['fmt'] is None else d['fmt'],
-        ))
+        name = ".".join(
+            (
+                d["radical"],
+                "-".join(self._pack_std_items(d["stage"])),
+                "txt" if d["fmt"] is None else d["fmt"],
+            )
+        )
         return name.lower()
 
     # Methods that generates pathnames
@@ -475,22 +532,24 @@ class VortexPeriodNameBuilder(AbstractActualVortexNameBuilder):
     """A Standard Vortex NameBuilder (with period and cutoff)."""
 
     _footprint = dict(
-        info = 'A Standard Vortex NameBuilder (with period and cutoff)',
-        attr = dict(
-            name = dict(
-                values = ['period@std', ],
+        info="A Standard Vortex NameBuilder (with period and cutoff)",
+        attr=dict(
+            name=dict(
+                values=[
+                    "period@std",
+                ],
             ),
-        )
+        ),
     )
 
     # A Vortex basename may include the following bits
 
     def _pack_std_basename_flowstuff(self, d):
-        name = ''
-        if d['flow'] is not None:
-            dstuff = self._pack_std_items_datestuff(d['flow'])
+        name = ""
+        if d["flow"] is not None:
+            dstuff = self._pack_std_items_datestuff(d["flow"])
             if dstuff:
-                name += '.' + dstuff
+                name += "." + dstuff
         return name
 
     # Methods that generates pathnames
@@ -512,25 +571,27 @@ class VortexFlatNameBuilder(AbstractActualVortexNameBuilder):
     """'A Standard Vortex NameBuilder (without date or period)."""
 
     _footprint = dict(
-        info = 'A Standard Vortex NameBuilder (without date or period)',
-        attr = dict(
-            name = dict(
-                values = ['flat@std', ],
+        info="A Standard Vortex NameBuilder (without date or period)",
+        attr=dict(
+            name=dict(
+                values=[
+                    "flat@std",
+                ],
             ),
-        )
+        ),
     )
 
     # A Vortex basename may include the following bits
 
     def _pack_std_basename_flowstuff(self, d):
-        name = ''
-        if d['flow'] is not None:
-            dstuff = self._pack_std_items_datestuff(d['flow'])
+        name = ""
+        if d["flow"] is not None:
+            dstuff = self._pack_std_items_datestuff(d["flow"])
             if dstuff:
-                name += '.' + dstuff
-            pstuff = self._pack_std_items_periodstuff(d['flow'])
+                name += "." + dstuff
+            pstuff = self._pack_std_items_periodstuff(d["flow"])
             if pstuff:
-                name += '.' + pstuff
+                name += "." + pstuff
         return name
 
     # Methods that generates pathnames
@@ -548,28 +609,29 @@ class VortexFlatNameBuilder(AbstractActualVortexNameBuilder):
 
 
 class VortexNameBuilder(AbstractVortexNameBuilderProxy):
-
     _explicit = False
     _footprint = dict(
-        info = 'Standard Vortex NameBuilder Proxy',
-        attr = dict(
-            name = dict(
-                values = ['std', ],
-                optional = True,
-                default = 'std',
+        info="Standard Vortex NameBuilder Proxy",
+        attr=dict(
+            name=dict(
+                values=[
+                    "std",
+                ],
+                optional=True,
+                default="std",
             ),
-        )
+        ),
     )
 
     def _pick_actual_builder(self, d):
         """Given the input dictionary, returns the appropriate builder object."""
-        actual_builder_name = 'flat@std'
-        if 'flow' in d and isinstance(d['flow'], (tuple, list)):
+        actual_builder_name = "flat@std"
+        if "flow" in d and isinstance(d["flow"], (tuple, list)):
             flowkeys = set()
-            for item in [item for item in d['flow'] if isinstance(item, dict)]:
+            for item in [item for item in d["flow"] if isinstance(item, dict)]:
                 flowkeys.update(item.keys())
-            if 'date' in flowkeys:
-                actual_builder_name = 'date@std'
-            elif 'begindate' in flowkeys and 'enddate' in flowkeys:
-                actual_builder_name = 'period@std'
+            if "date" in flowkeys:
+                actual_builder_name = "date@std"
+            elif "begindate" in flowkeys and "enddate" in flowkeys:
+                actual_builder_name = "period@std"
         return self._get_builder(actual_builder_name)