vortex-nwp 2.0.0b1__py3-none-any.whl

vortex/nwp/tools/conftools.py

@@ -0,0 +1,1311 @@
+"""
+Conftools are small objects that can be instantiated from an application's
+configuration file.
+
+They might be used when some complex calculations are needed to establish the
+tasks configuration.
+"""
+
+import collections
+import collections.abc
+import functools
+import math
+import re
+
+from bronx.fancies import loggers
+from bronx.stdtypes.date import Date, Time, Period, Month, timeintrangex
+from bronx.syntax.decorators import secure_getattr
+from footprints.stdtypes import FPDict, FPList
+from footprints.util import rangex
+import footprints
+
+from ..tools.odb import TimeSlots
+
+#: No automatic export
+__all__ = []
+
+logger = loggers.getLogger(__name__)
+
+
+class ConfTool(footprints.FootprintBase):
+    """Abstract class for conftools objects."""
+
+    _abstract = True
+    _collector = ('conftool',)
+    _footprint = dict(
+        info = 'Abstract Conf/Weird Tool',
+        attr = dict(
+            kind = dict(),
+        )
+    )
+
+
+class AbstractObjectProxyConfTool(ConfTool):
+    """Allow transparent access to any Vortex object."""
+
+    _abstract = True
+    _footprint = dict(
+        info = 'Conf tool that find the appropriate begin/end date for an input resource.',
+        attr = dict(
+            kind = dict(
+                values      = ['objproxy', ],
+            ),
+        )
+    )
+
+    def __init__(self, *kargs, **kwargs):
+        super().__init__(*kargs, **kwargs)
+        self._proxied_obj = self._create_proxied_obj()
+
+    def _create_proxied_obj(self):
+        """Initialise the object that will be proxied."""
+        raise NotImplementedError()
+
+    @secure_getattr
+    def __getattr__(self, item):
+        """Pass all requests to the proxied object."""
+        target = getattr(self._proxied_obj, item, None)
+        if target is None:
+            raise AttributeError('Attribute "{:s}" was not found'.format(item))
+        else:
+            return target
+
+
+#: Holds coupling's data for a particular cutoff/hour
+CouplingInfos = collections.namedtuple('CouplingInfos',
+                                       ('base', 'dayoff', 'cutoff', 'vapp', 'vconf', 'xpid', 'model', 'steps')
+                                       )
+
+
+class CouplingOffsetConfError(Exception):
+    """Abstract exception raise by :class:`CouplingOffsetConfTool` objects."""
+    pass
+
+
+class CouplingOffsetConfPrepareError(CouplingOffsetConfError):
+    """Exception raised when an error occurs during coupling data calculations."""
+
+    def __init__(self, fmtk):
+        msg = 'It is useless to compute coupling for: {}.'.format(fmtk)
+        super().__init__(msg)
+
+
+class CouplingOffsetConfRefillError(CouplingOffsetConfError):
+    """Exception raised when an orror occurs during refill."""
+
+    def __init__(self, fmtk, hh=None):
+        msg = 'It is useless to compute a refill for: {}'.format(fmtk)
+        if hh is None:
+            msg += '.'
+        else:
+            msg += ' at HH={!s}.'.format(hh)
+        super().__init__(msg)
+
+
+class CouplingOffsetConfTool(ConfTool):
+    """Conf tool that do all sorts of computations for coupling."""
+
+    _footprint = dict(
+        info = 'Conf tool that do all sorts of computations for coupling',
+        attr = dict(
+            kind = dict(
+                values= ['couplingoffset', ],
+            ),
+            cplhhlist = dict(
+                info = ('The list of cutoff and hours for this application. '
+                        'If omitted, all entries of the **cplhhbase** attribute are used. ' +
+                        "(e.g ``{'assim':[0, 6, 12, 18], 'production':[0, ]}``)"),
+                type = FPDict,
+                optional = True,
+            ),
+            cplhhbase = dict(
+                info = ('For a given cutoff and hour, gives the base hour to couple to. ' +
+                        "(e.g ``{'assim':{0:0, 6:6, 12:12, 18:18}, 'production':{0:18}}``)."),
+                type = FPDict,
+            ),
+            cpldayoff = dict(
+                info = ('For a given cutoff and hour, gives an offset in days. 0 by default. ' +
+                        "(e.g ``{'assim':{'default':0}, 'production':{'default':1}}``)."),
+                type = FPDict,
+                optional = True,
+            ),
+            cplcutoff = dict(
+                info = 'For a given cutoff and hour, gives the base cutoff to couple to.',
+                type = FPDict,
+            ),
+            cplvapp = dict(
+                info = 'For a given cutoff and hour, gives the base vapp to couple to.',
+                type = FPDict,
+            ),
+            cplvconf = dict(
+                info = 'For a given cutoff and hour, gives the base vconf to couple to.',
+                type = FPDict,
+            ),
+            cplxpid = dict(
+                info = 'For a given cutoff and hour, gives the experiment ID to couple to.',
+                type = FPDict,
+                optional = True,
+            ),
+            cplmodel = dict(
+                info = 'For a given cutoff and hour, gives the base model to couple to.',
+                type = FPDict,
+                optional = True,
+            ),
+            cplsteps = dict(
+                info = 'For a given cutoff and hour, gives then list of requested terms.',
+                type = FPDict,
+            ),
+            finalterm = dict(
+                info = 'For a given cutoff and hour, the final term (for "finalterm" token substitution)',
+                type = FPDict,
+                optional = True
+            ),
+            refill_cutoff = dict(
+                values = ['assim', 'production', 'all'],
+                info = 'By default, what is the cutoff name of the refill task.',
+                optional = True,
+                default = 'assim',
+            ),
+            compute_on_refill = dict(
+                info = 'Is it necessary to compute coupling files for the refilling cutoff ?',
+                optional = True,
+                default = True,
+                type = bool,
+            ),
+            isolated_refill = dict(
+                info = 'Are the refill tasks exclusive with prepare tasks ?',
+                optional = True,
+                default = True,
+                type = bool,
+            ),
+            verbose = dict(
+                info = 'When the object is created, print a summary.',
+                type = bool,
+                optional = True,
+                default = True,
+            ),
+        )
+    )
+
+    _DFLT_KEY = 'default'
+
+    def __init__(self, *kargs, **kwargs):
+        super().__init__(*kargs, **kwargs)
+
+        # A dictionary summarising the base HH supported by this configuration tool
+        # ex: dict(assim=set([0, 1 , 2, ...]), production=set([0, 6,...])
+        self._target_hhs = collections.defaultdict(set)
+        if self.cplhhlist is None:
+            t_hhbase = collections.defaultdict(dict)
+            for c, cv in self.cplhhbase.items():
+                for h, v in [(Time(lh), Time(lv)) for lh, lv in cv.items()]:
+                    t_hhbase[c][h] = v
+                    self._target_hhs[c].add(h)
+        else:
+            for c, clist in self.cplhhlist.items():
+                if not isinstance(clist, (tuple, list)):
+                    clist = [clist, ]
+                self._target_hhs[c].update([Time(h) for h in clist])
+            t_hhbase = self._reshape_inputs(self.cplhhbase, value_reclass=Time)
+
+        # Consistency checks and array reshaping
+        t_dayoff = self._reshape_inputs(self.cpldayoff, class_default=0)
+        t_cutoff = self._reshape_inputs(self.cplcutoff)
+        t_vapp = self._reshape_inputs(self.cplvapp)
+        t_vconf = self._reshape_inputs(self.cplvconf)
+        t_steps = self._reshape_inputs(self.cplsteps)
+        if self.cplmodel is None:
+            t_model = t_vapp
+        else:
+            t_model = self._reshape_inputs(self.cplmodel)
+        t_xpid = self._reshape_inputs(self.cplxpid, class_default='')
+
+        # If relevent, do "finalterm" token substitution
+        if self.finalterm is not None:
+            t_finalterm = self._reshape_inputs(self.finalterm, value_reclass=str)
+            for c, cv in t_hhbase.items():
+                for hh in cv.keys():
+                    if isinstance(t_steps[c][hh], str):
+                        t_steps[c][hh] = t_steps[c][hh].replace('finalterm',
+                                                                t_finalterm[c][hh])
+
+        # Build the dictionary of CouplingInfos objects
+        self._cpl_data = collections.defaultdict(dict)
+        for c, cv in t_hhbase.items():
+            self._cpl_data[c] = {hh: CouplingInfos(cv[hh], int(t_dayoff[c][hh]),
+                                                   t_cutoff[c][hh], t_vapp[c][hh],
+                                                   t_vconf[c][hh], t_xpid[c][hh],
+                                                   t_model[c][hh],
+                                                   rangex(t_steps[c][hh]))
+                                 for hh in cv.keys()}
+
+        # Pre-compute the prepare terms
+        self._prepare_terms_map = self._compute_prepare_terms()
+        if self.verbose:
+            print()
+            print('#### Coupling configuration tool initialised ####')
+            print('**** Coupling tasks terms map:')
+            print('{:s}  :  {:s}'.format(self._cpl_fmtkey(('HH', 'VAPP', 'VCONF', 'XPID', 'MODEL', 'CUTOFF')),
+                                         'Computed Terms'))
+            for k in sorted(self._prepare_terms_map.keys()):
+                print('{:s}  :  {:s}'.format(self._cpl_fmtkey(k),
+                                             ' '.join([str(t.hour)
+                                                       for t in self._prepare_terms_map[k]
+                                                       ])
+                                             )
+                      )
+
+        # Pre-compute the default refill_map
+        self._refill_terms_map = dict()
+        self._refill_terms_map[self.refill_cutoff] = self._compute_refill_terms(self.refill_cutoff,
+                                                                                self.compute_on_refill,
+                                                                                self.isolated_refill)
+        if self.verbose:
+            print('**** Refill tasks activation map (default refill_cutoff is: {:s}):'.format(self.refill_cutoff))
+            print('{:s}  :  {:s}'.format(self._rtask_fmtkey(('VAPP', 'VCONF', 'XPID', 'MODEL', 'CUTOFF')),
+                                         'Active hours'))
+            for k in sorted(self._refill_terms_map[self.refill_cutoff].keys()):
+                vdict = self._refill_terms_map[self.refill_cutoff][k]
+                print('{:s}  :  {:s}'.format(self._rtask_fmtkey(k),
+                                             ' '.join([str(t.hour) for t in sorted(vdict.keys())])))
+            print()
+
+    @property
+    def target_hhs(self):
+        return self._target_hhs
+
+    def _reshape_inputs(self, input_dict, class_default=None, value_reclass=lambda x: x):
+        """Deal with default values, check dictionaries and convert keys to Time objects."""
+        # Convert keys to time objects
+        r_dict = dict()
+        if input_dict is not None:
+            for c, cv in input_dict.items():
+                if isinstance(cv, dict):
+                    r_dict[c] = dict()
+                    for h, v in cv.items():
+                        if h != self._DFLT_KEY:
+                            r_dict[c][Time(h)] = value_reclass(v)
+                        else:
+                            r_dict[c][h] = value_reclass(v)
+                else:
+                    r_dict[c] = cv
+
+        # Is there a generic default ?
+        defined_topdefault = self._DFLT_KEY in r_dict
+        top_default = r_dict.pop(self._DFLT_KEY, class_default)
+
+        # Check consistency and replace missing values with defaults
+        for c in self.target_hhs:
+            myv = r_dict.setdefault(c, dict())
+            # Is there a cutoff specific default ?
+            defined_cutdefault = defined_topdefault or self._DFLT_KEY in myv
+            last_default = myv.pop(self._DFLT_KEY, top_default)
+            my_c_hhs = set(myv.keys())
+            if defined_cutdefault or (class_default is not None):
+                missinghh = self.target_hhs[c] - my_c_hhs
+                for h in missinghh:
+                    myv[h] = last_default
+            else:
+                if not my_c_hhs >= self.target_hhs[c]:
+                    logger.error("Inconsistent input arrays while processing: \n%s",
+                                 str(input_dict))
+                    logger.error("Cutoff %s, expecting the following HH: \n%s",
+                                 c, str(self.target_hhs[c]))
+                    raise ValueError("Inconsistent input array.")
+
+        # Filter values according to _target_hhs
+        for c in list(r_dict.keys()):
+            if c not in self.target_hhs:
+                del r_dict[c]
+        for c in self.target_hhs:
+            my_c_hhs = set(r_dict[c].keys())
+            extra = my_c_hhs - self.target_hhs[c]
+            for hh in extra:
+                del r_dict[c][hh]
+
+        return r_dict
+
+    @staticmethod
+    def _cpl_key(hh, cutoff, vapp, vconf, xpid, model):
+        return (str(hh), vapp, vconf, xpid, model, cutoff)
+
+    @staticmethod
+    def _cpl_fmtkey(k):
+        cutoff_map = dict(production='prod')
+        return '{:5s} {:6s}  {:24s} {:s} ({:s})'.format(
+            k[0],
+            cutoff_map.get(k[5], k[5]),
+            k[1] + '/' + k[2],
+            k[3],
+            k[4]
+        )
+
+    @staticmethod
+    def _rtask_key(cutoff, vapp, vconf, xpid, model):
+        return (vapp, vconf, xpid, model, cutoff)
+
+    @staticmethod
+    def _rtask_fmtkey(k):
+        cutoff_map = dict(production='prod')
+        return '{:6s}  {:24s} {:s} ({:s})'.format(cutoff_map.get(k[4], k[4]), k[0] + '/' + k[1], k[2], k[3])
+
+    @staticmethod
+    def _process_date(date):
+        mydate = Date(date)
+        myhh = Time('{0.hour:d}:{0.minute:02d}'.format(mydate))
+        return mydate, myhh
+
+    @staticmethod
+    def _hh_offset(hh, hhbase, dayoff):
+        offset = hh - hhbase
+        if offset < 0:
+            offset += Time(24)
+        return offset + Period(days=dayoff)
+
+    def _compute_prepare_terms(self):
+        terms_map = collections.defaultdict(set)
+        for _, cv in self._cpl_data.items():
+            for h, infos in cv.items():
+                key = self._cpl_key(infos.base, infos.cutoff, infos.vapp, infos.vconf, infos.xpid, infos.model)
+                targetoffset = self._hh_offset(h, infos.base, infos.dayoff)
+                terms_map[key].update([s + targetoffset for s in infos.steps])
+        terms_map = {k: sorted(terms) for k, terms in terms_map.items()}
+        return terms_map
+
+    def _compute_refill_terms(self, refill_cutoff, compute_on_refill, isolated_refill):
+        finaldates = collections.defaultdict(functools.partial(collections.defaultdict,
+                                                               functools.partial(collections.defaultdict, set)))
+        if refill_cutoff == 'all':
+            possiblehours = sorted(functools.reduce(lambda x, y: x | y,
+                                                    [set(l) for l in self.target_hhs.values()]))
+        else:
+            possiblehours = self.target_hhs[refill_cutoff]
+
+        # Look 24hr ahead
+        for c, cv in self._cpl_data.items():
+            for h, infos in cv.items():
+                key = self._rtask_key(infos.cutoff, infos.vapp, infos.vconf, infos.xpid, infos.model)
+                offset = self._hh_offset(h, infos.base, infos.dayoff)
+                for possibleh in possiblehours:
+                    roffset = self._hh_offset(h, possibleh, 0)
+                    if ((roffset > 0 or
+                            (compute_on_refill and roffset == 0 and (refill_cutoff == 'all' or refill_cutoff == c))) and
+                            (roffset < offset or (isolated_refill and roffset == offset))):
+                        finaldates[key][possibleh][offset - roffset].update([s + offset for s in infos.steps])
+
+        for key, vdict in finaldates.items():
+            for possibleh in vdict.keys():
+                vdict[possibleh] = {off: sorted(terms) for off, terms in vdict[possibleh].items()}
+
+        return finaldates
+
+    def compatible_with(self, other):
+        if isinstance(other, self.__class__):
+            return (self.target_hhs == other.target_hhs and
+                    self.refill_cutoff == other.refill_cutoff)
+        else:
+            return False
+
+    def prepare_terms(self, date, cutoff, vapp, vconf, model=None, xpid=''):
+        """
+        For a task computing coupling files (at **date** and **cutoff**,
+        for a specific **vapp** and **vconf**), lists the terms that should be
+        computed.
+        """
+        _, myhh = self._process_date(date)
+        if model is None:
+            model = vapp
+        key = self._cpl_key(myhh, cutoff, vapp, vconf, xpid, model)
+        try:
+            return self._prepare_terms_map[key]
+        except KeyError:
+            raise CouplingOffsetConfPrepareError(self._cpl_fmtkey(key))
+
+    def coupling_offset(self, date, cutoff):
+        """
+        For a task needing coupling (at **date** and **cutoff**), return the
+        time delta with the coupling model/file base date.
+        """
+        _, myhh = self._process_date(date)
+        return self._hh_offset(myhh, self._cpl_data[cutoff][myhh].base,
+                               self._cpl_data[cutoff][myhh].dayoff)
+
+    def coupling_date(self, date, cutoff):
+        """
+        For a task needing coupling (at **date** and **cutoff**), return the
+        base date of the coupling model/file.
+        """
+        mydate, myhh = self._process_date(date)
+        return mydate - self._hh_offset(myhh, self._cpl_data[cutoff][myhh].base,
+                                        self._cpl_data[cutoff][myhh].dayoff)
+
+    def coupling_terms(self, date, cutoff):
+        """
+        For a task needing coupling (at **date** and **cutoff**), return the
+        list of terms that should be fetched from the coupling model/file.
+        """
+        _, myhh = self._process_date(date)
+        offset = self._hh_offset(myhh, self._cpl_data[cutoff][myhh].base,
+                                 self._cpl_data[cutoff][myhh].dayoff)
+        return [s + offset for s in self._cpl_data[cutoff][myhh].steps]
+
+    def _coupling_stuff(self, date, cutoff, stuff):
+        _, myhh = self._process_date(date)
+        return getattr(self._cpl_data[cutoff][myhh], stuff)
+
+    def coupling_steps(self, date, cutoff):
+        """
+        For a task needing coupling (at **date** and **cutoff**), return the
+        prescribed steps.
+        """
+        return self._coupling_stuff(date, cutoff, 'steps')
+
+    def coupling_cutoff(self, date, cutoff):
+        """
+        For a task needing coupling (at **date** and **cutoff**), return the
+        cutoff of the coupling model/file.
+        """
+        return self._coupling_stuff(date, cutoff, 'cutoff')
+
+    def coupling_vapp(self, date, cutoff):
+        """
+        For a task needing coupling (at **date** and **cutoff**), return the
+        vapp of the coupling model/file.
+        """
+        return self._coupling_stuff(date, cutoff, 'vapp')
+
+    def coupling_vconf(self, date, cutoff):
+        """
+        For a task needing coupling (at **date** and **cutoff**), return the
+        vconf of the coupling model/file.
+        """
+        return self._coupling_stuff(date, cutoff, 'vconf')
+
+    def coupling_xpid(self, date, cutoff):
+        """
+        For a task needing coupling (at **date** and **cutoff**), return the
+        experiment ID of the coupling model/file.
+        """
+        return self._coupling_stuff(date, cutoff, 'xpid')
+
+    def coupling_model(self, date, cutoff):
+        """
+        For a task needing coupling (at **date** and **cutoff**), return the
+        vconf of the coupling model/file.
+        """
+        return self._coupling_stuff(date, cutoff, 'model')
+
+    def refill_terms(self, date, cutoff, vapp, vconf, model=None, refill_cutoff=None, xpid=''):
+        """The terms that should be computed for a given refill task."""
+        refill_cutoff = self.refill_cutoff if refill_cutoff is None else refill_cutoff
+        if refill_cutoff not in self._refill_terms_map:
+            self._refill_terms_map[refill_cutoff] = self._compute_refill_terms(refill_cutoff,
+                                                                               self.compute_on_refill,
+                                                                               self.isolated_refill)
+        if model is None:
+            model = vapp
+        mydate, myhh = self._process_date(date)
+        key = self._rtask_key(cutoff, vapp, vconf, xpid, model)
+        finaldates = dict()
+        if (key not in self._refill_terms_map[refill_cutoff] or
+                myhh not in self._refill_terms_map[refill_cutoff][key]):
+            raise CouplingOffsetConfRefillError(self._rtask_fmtkey(key))
+        for off, terms in self._refill_terms_map[refill_cutoff][key][myhh].items():
+            finaldates[str(mydate - off)] = terms
+        return {'date': finaldates}
+
+    def refill_dates(self, date, cutoff, vapp, vconf, model=None, refill_cutoff=None, xpid=''):
+        """The dates that should be processed in a given refill task."""
+        return list(self.refill_terms(date, cutoff, vapp, vconf, model=model,
+                                      refill_cutoff=refill_cutoff, xpid=xpid)['date'].keys())
+
+    def refill_months(self, date, cutoff, vapp, vconf, model=None, refill_cutoff=None, xpid=''):
+        """The months that should be processed in a given refill task."""
+        mindate = min(self.refill_dates(date, cutoff, vapp, vconf, model=model,
+                                        refill_cutoff=refill_cutoff, xpid=xpid))
+        minmonth = Month(mindate)
+        return [minmonth, minmonth + 1]
+
+
+class AggregatedCouplingOffsetConfTool(ConfTool):
+
+    _footprint = dict(
+        info = 'Aggregate several CouplingOffsetConfTool objects into one',
+        attr = dict(
+            kind = dict(
+                values= ['aggcouplingoffset', ],
+            ),
+            nominal = dict(
+                info = "A list of couplingoffset objects used in nominal cases",
+                type = FPList,
+            ),
+            alternate = dict(
+                info = "A list of couplingoffset objects used in rescue modes",
+                type = FPList,
+                optional = True,
+            ),
+            use_alternates = dict(
+                info = 'Actually use rescue mode ?',
+                optional = True,
+                default = True,
+                type = bool,
+            ),
+            verbose = dict(
+                info = 'When the object is created, print a summary.',
+                type = bool,
+                optional = True,
+                default = True,
+            ),
+        )
+    )
+
+    def __init__(self, *kargs, **kwargs):
+        super().__init__(*kargs, **kwargs)
+        self._toolslist = list(self.nominal)
+        if self.alternate and self.use_alternates:
+            self._toolslist.extend(self.alternate)
+        # At least one object is needed:
+        if not len(self._toolslist):
+            raise CouplingOffsetConfError("At least one sub-object is needed")
+        # Check consistency
+        for num, toolobj in enumerate(self._toolslist[1:]):
+            if not self._toolslist[0].compatible_with(toolobj):
+                print('\n', '*' * 50)
+                print('self._toolslist[0] =', self._toolslist[0], '\n',
+                      ' target_hhs    =', self._toolslist[0].target_hhs,
+                      ' refill_cutoff =', self._toolslist[0].refill_cutoff)
+                print('is not consistent with object num', num, ':', toolobj, '\n',
+                      ' target_hhs    =', toolobj.target_hhs,
+                      ' refill_cutoff =', toolobj.refill_cutoff)
+                raise CouplingOffsetConfError("Inconsistent sub-objects")
+
+        if self.verbose:
+            print()
+            print('#### Aggregated Coupling configuration tool initialised ####')
+            print('It is made of {:d} nominal configuration tool(s)'.format(len(self.nominal)))
+            if self.alternate and self.use_alternates:
+                print('+ {:d} rescue-mode configuration tool(s)'.format(len(self.alternate)))
+            else:
+                print('No rescue-mode configuration tool is considered (deactivated)')
+            print()
+
+    def prepare_terms(self, date, cutoff, vapp, vconf, model=None, xpid=''):
+        """
+        For a task computing coupling files (at **date** and **cutoff**,
+        for a specific **vapp** and **vconf**), lists the terms that should be
+        computed.
+        """
+        terms = set()
+        for toolobj in self._toolslist:
+            try:
+                terms.update(toolobj.prepare_terms(date, cutoff, vapp, vconf, model=model, xpid=xpid))
+            except CouplingOffsetConfPrepareError as e:
+                lateste = e
+        if not terms:
+            raise lateste
+        else:
+            return sorted(terms)
+
+    def refill_terms(self, date, cutoff, vapp, vconf, model=None, refill_cutoff=None, xpid=''):
+        """The terms that should be computed for a given refill task."""
+        finaldates = collections.defaultdict(set)
+        for toolobj in self._toolslist:
+            try:
+                rt = toolobj.refill_terms(date, cutoff, vapp, vconf, model=model,
+                                          refill_cutoff=refill_cutoff, xpid=xpid)
+                for k, v in rt['date'].items():
+                    finaldates[k].update(v)
+            except CouplingOffsetConfRefillError as e:
+                lateste = e
+        if not finaldates:
+            raise lateste
+        else:
+            for k, v in finaldates.items():
+                finaldates[k] = sorted(v)
+            return {'date': finaldates}
+
+    def refill_dates(self, date, cutoff, vapp, vconf, model=None, refill_cutoff=None, xpid=''):
+        """The dates that should be processed in a given refill task."""
+        return list(self.refill_terms(date, cutoff, vapp, vconf, model=model,
+                                      refill_cutoff=refill_cutoff, xpid=xpid)['date'].keys())
+
+    def refill_months(self, date, cutoff, vapp, vconf, model=None, refill_cutoff=None, xpid=''):
+        """The months that should be processed in a given refill task."""
+        mindate = min(self.refill_dates(date, cutoff, vapp, vconf, model=model,
+                                        refill_cutoff=refill_cutoff, xpid=xpid))
+        minmonth = Month(mindate)
+        return [minmonth, minmonth + 1]
+
+
+class TimeSerieInputFinderError(Exception):
+    """Any exception raise by :class:`TimeSerieInputFinderConfTool` objects."""
+    pass
+
+
+class TimeSerieInputFinderConfTool(ConfTool):
+    """
+    A conf tool that find the appropriate begin/end date for an input resource
+    to be taken in a timeserie.
+
+    Let's consider a serie of 3 consecutive Surfex forcing files:
+
+      * The first file start on 2018/01/01 00UTC
+      * Each file covers a two days period
+
+    The conf tool will look like::
+
+      >>> ct = TimeSerieInputFinderConfTool(kind="timeserie",
+      ...                                   timeserie_begin="2018010100",
+      ...                                   timeserie_step="P2D")
+
+    To find the date/term of the forcing file encompassing a 6 hours forecast
+    starting on 2018/01/04 12UTC, use::
+
+      >>> ct.begindate('2018010412', 'PT6H')
+      Date(2018, 1, 3, 0, 0)
+      >>> ct.term('2018010312', '06:00')
+      Time(48, 0)
+
+    """
+
+    _footprint = dict(
+        info = 'Conf tool that find the appropriate begin/end date for an input resource.',
+        attr = dict(
+            kind = dict(
+                values      = ['timeserie', ],
+            ),
+            timeserie_begin = dict(
+                info        = "The date when the time serie starts",
+                type        = Date
+            ),
+            timeserie_step = dict(
+                info        = "The step between files of the time serie.",
+                type        = Period
+            ),
+            upperbound_included = dict(
+                type        = bool,
+                optional    = True,
+                default     = True
+            ),
+            singlefile = dict(
+                info        = "The period requested by a user should be contained in a single file.",
+                type        = bool,
+                optional    = True,
+                default     = False
+            )
+        )
+    )
+
+    def __init__(self, *kargs, **kwargs):
+        super().__init__(*kargs, **kwargs)
+        self._begincache = dict()
+        self._steplength = self.timeserie_step.length
+
+    def _begin_lookup(self, begindate):
+        """Find the appropriate tiem serie's file date just before **begindate**."""
+        if begindate not in self._begincache:
+            if begindate < self.timeserie_begin:
+                raise TimeSerieInputFinderError("Request begin date is too soon !")
+            dt = begindate - self.timeserie_begin
+            nsteps = int(math.floor(dt.length / self._steplength))
+            self._begincache[begindate] = self.timeserie_begin + nsteps * self.timeserie_step
+        return self._begincache[begindate]
+
+    def _begindates_expansion(self, tdate, tlength):
+        """Generate a begin date or a list of begin dates."""
+        xperiods = tlength / self._steplength
+        nfiles = int(math.ceil(xperiods))
+        if xperiods == int(xperiods) and not self.upperbound_included:
+            nfiles += 1
+        if nfiles > 1:
+            if self.singlefile:
+                raise TimeSerieInputFinderError("Multiple files requested but singlefile=.T.")
+            return [tdate + i * self.timeserie_step for i in range(0, nfiles)]
+        else:
+            return tdate
+
+    def _enddates_expansion(self, tdates):
+        """Generate an end date or a dict of enddates."""
+        if isinstance(tdates, list):
+            return dict(begindate={d: d + self.timeserie_step for d in tdates})
+        else:
+            return tdates + self.timeserie_step
+
+    @staticmethod
+    def _dates_normalise(begindate, enddate):
+        """Convert **begin/enddate** to a proper Date object."""
+        if not isinstance(begindate, Date):
+            begindate = Date(begindate)
+        if not isinstance(enddate, Date):
+            enddate = Date(enddate)
+        return begindate, enddate
+
+    @staticmethod
+    def _date_term_normalise(begindate, term):
+        """Convert **begindate** and **term** to a proper Date/Time object."""
+        if not isinstance(begindate, Date):
+            begindate = Date(begindate)
+        if not isinstance(term, Time):
+            term = Time(term)
+        return begindate, term
+
+    def begindate_i(self, begindate, enddate):
+        """Find the file dates encompassing [**begindate**, **enddate**]."""
+        begindate, enddate = self._dates_normalise(begindate, enddate)
+        tdate = self._begin_lookup(begindate)
+        tlength = (enddate - begindate).length
+        return self._begindates_expansion(tdate, tlength)
+
+    def enddate_i(self, begindate, enddate):
+        """Find the file enddates encompassing [**begindate**, **enddate**]."""
+        return self._enddates_expansion(self.begindate_i(begindate, enddate))
+
+    def term_i(self, begindate, enddate):  # @UnusedVariable
+        """Find the term of the time serie files."""
+        return Time(self.timeserie_step)
+
+    def begindate(self, begindate, term):
+        """Find the file dates encompassing [**begindate**, **begindate** + **term**]."""
+        begindate, term = self._date_term_normalise(begindate, term)
+        return self._begindates_expansion(self._begin_lookup(begindate), int(term) * 60)
+
+    def enddate(self, begindate, term):
+        """Find the file enddates encompassing [**begindate**, **begindate** + **term**]."""
+        return self._enddates_expansion(self.begindate(begindate, term))
+
+    def term(self, begindate, term):  # @UnusedVariable
+        """Find the term of the time serie files."""
+        return Time(self.timeserie_step)
+
+
+class ArpIfsForecastTermConfTool(ConfTool):
+    """Deal with any Arpege/IFS model final term and outputs.
+
+
+    The conf tool will look like::
+
+      >>> ct = ArpIfsForecastTermConfTool(kind="arpifs_fcterms",
+      ...                                 fcterm_def=dict(production={0:102, 12:24},
+      ...                                                 assim={"default": 6}),
+      ...                                 hist_terms_def=dict(production={"default":"0-47-6,48-finalterm-12"},
+      ...                                                     assim={"default":"0,3,6"}),
+      ...                                 surf_terms_def=dict(production={"default":None, 0:"3,6"},
+      ...                                                     assim={"default":"3,6"}),
+      ...                                 diag_fp_terms_def=dict(default={"default":"0-47-3,48-finalterm-6"}),
+      ...                                 extra_fp_terms_def=dict(
+      ...                                     aero=dict(production={0:"0-48-3"}),
+      ...                                     foo=dict(default={"default":"2,3"})
+      ...                                 ),
+      ...                                 secondary_diag_terms_def=dict(
+      ...                                     labo=dict(production={0: "0-12-1"})
+      ...                                 ),
+      ...      )
+
+    The forecast term can be retrieved:
+
+      >>> print(ct.fcterm('assim', 6))
+      6
+      >>> print(ct.fcterm('production', 0))
+      102
+      >>> print(ct.fcterm('production', 12))
+      24
+
+    If nothing is defined it crashes:
+
+      >>> print(ct.fcterm('production', 6))
+      Traceback (most recent call last):
+      ...
+      ValueError: Nothing is defined for cutoff="production"/hh="06:00" in "fcterm"
+
+    The list of requested historical terms can be retrieved. It is automaticaly
+    constrained by the forecast term:
+
+      >>> print(','.join([str(t) for t in ct.hist_terms('assim', 6)]))
+      0,3,6
+      >>> print(','.join([str(t) for t in ct.hist_terms('production', 0)]))
+      0,6,12,18,24,30,36,42,48,60,72,84,96
+      >>> print(','.join([str(t) for t in ct.hist_terms('production', 12)]))
+      0,6,12,18,24
+
+    The list of requested Surfex files can be retrieved:
+
+      >>> print(','.join([str(t) for t in ct.surf_terms('assim', 6)]))
+      3,6
+
+    The list of terms produced by the inline fullpos is:
+
+      >>> print(','.join([str(t) for t in ct.inline_terms('assim', 6)]))
+      0,3,6
+      >>> print(','.join([str(t) for t in ct.inline_terms('production', 0)]))
+      0,1,2,3,4,5,6,7,8,9,10,11,12,15,18,21,24,27,30,33,36,39,42,45,48,54,60,66,72,78,84,90,96,102
+      >>> print(','.join([str(t) for t in ct.inline_terms('production', 12)]))
+      0,3,6,9,12,15,18,21,24
+
+    Note: It depends on the value of **use_inline_fp**. If ``False`` an empty
+    list will be returned.
+
+    The inline Fullpos can also be switched-off manually using the `no_inline`
+    property:
+
+      >>> print(','.join([str(t) for t in ct.no_inline.inline_terms('production', 0)]))
+      <BLANKLINE>
+      >>> print(','.join([str(t) for t in ct.no_inline.diag_terms('production', 0)]))
+      0,1,2,3,4,5,6,7,8,9,10,11,12,15,18,21,24,27,30,33,36,39,42,45,48,54,60,66,72,78,84,90,96,102
+
+    The list of terms when some offline fullpos job is needed (for any of the
+    domains):
+
+      >>> print(','.join([str(t) for t in ct.fpoff_terms('assim', 6)]))
+      2,3
+      >>> print(','.join([str(t) for t in ct.fpoff_terms('production', 0)]))
+      0,2,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48
+      >>> print(','.join([str(t) for t in ct.fpoff_terms('production', 12)]))
+      2,3
+
+    The list of terms, in addition to requested historical terms, needed to run
+    offline fullpos job:
+
+      >>> print(','.join([str(t) for t in ct.extra_hist_terms('production', 0)]))
+      2,3,9,15,21,27,33,39,45
+
+    The list of all historical terms (both requested terms and terms required
+    for offline Fullpos)
+
+      >>> print(','.join([str(t) for t in ct.all_hist_terms('production', 0)]))
+      0,2,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,60,72,84,96
+
+    The list of involved Fullpos objects for a given cutoff/hh:
+
+      >>> print(','.join([t for t in ct.fpoff_items('assim', 6)]))
+      foo
+      >>> print(','.join([t for t in ct.fpoff_items('production', 0)]))
+      aero,foo
+      >>> print(','.join([t for t in ct.fpoff_items('production', 0, discard=['aero'])]))
+      foo
+      >>> print(','.join([t for t in ct.fpoff_items('production', 0, only=['foo'])]))
+      foo
+      >>> print(','.join([t for t in ct.fpoff_items('production', 12)]))
+      foo
+
+    The list of terms associated to a given Fullpos object can be obtained:
+
+      >>> print(','.join([str(t) for t in ct.foo_terms('assim', 6)]))
+      2,3
+      >>> print(','.join([str(t) for t in ct.aero_terms('assim', 6)]))
+      <BLANKLINE>
+      >>> print(','.join([str(t) for t in ct.foo_terms('production', 0)]))
+      2,3
+      >>> print(','.join([str(t) for t in ct.aero_terms('production', 0)]))
+      0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48
+      >>> print(','.join([str(t) for t in ct.foo_terms('production', 12)]))
+      2,3
+      >>> print(','.join([str(t) for t in ct.aero_terms('production', 12)]))
+      <BLANKLINE>
+
+    It can also be obtained as a FPList objects (if empty, an empty list is returned
+    instead of an FPList object):
+
+      >>> ct.aero_terms_fplist('assim', 6)
+      []
+      >>> print(','.join([str(t) for t in ct.aero_terms_fplist('production', 0)]))
+      0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48
+      >>> print(type(ct.aero_terms_fplist('production', 0)).__name__)
+      FPList
+      >>> ct.aero_terms_fplist('production', 12)
+      []
+
+    A mapping dictionary can also be obtained:
+
+      >>> for k, v in sorted(ct.fpoff_terms_map('production', 0).items()):
+      ...     print('{:s}: {:s}'.format(k, ','.join([str(vv) for vv in v])))
+      aero: 0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48
+      foo: 2,3
+
+    The list of terms associated to secondary diagnostics can be obtained
+    ("secondary diagnostics" stands for diagnostics that are based on files
+    pre-calculated by the inline/offline fullpos):
+
+      >>> print(','.join([str(t) for t in ct.labo_terms('production', 0)]))
+      0,1,2,3,4,5,6,7,8,9,10,11,12
+      >>> print(','.join([str(t) for t in ct.labo_terms('production', 12)]))
+      <BLANKLINE>
+
+    """
+
+    _footprint = dict(
+        info = "Conf tool that helps setting up Arpege's forecast term and outputs",
+        attr = dict(
+            kind = dict(
+                values= ['arpifs_fcterms', ],
+            ),
+            fcterm_def = dict(
+                info = ("The forecast's term for each cutoff and base time " +
+                        "(e.g ``{'assim':{0:6, 12:6}, 'production':{0:102}}``)"),
+                type = dict,
+            ),
+            fcterm_unit=dict(
+                info="The forecast's term unit (hour or timestep)",
+                values=['hour', 'timestep'],
+                optional=True,
+                default='hour',
+            ),
+            hist_terms_def=dict(
+                info=("The forecast's terms when historical files are needed " +
+                      "(for permanant storage) " +
+                      "(e.g ``{'assim':{default: '0-finalterm-3'}, " +
+                      "'production':{0:'0-23-1,24-finalterm-6}}``)"),
+                type=dict,
+                optional=True,
+            ),
+            surf_terms_def=dict(
+                info=("The forecast's terms when surface files are needed " +
+                      "(for permanant storage) "),
+                type=dict,
+                optional=True,
+            ),
+            norm_terms_def=dict(
+                info="The forecast's terms when spectral norms are computed",
+                type=dict,
+                optional=True,
+            ),
+            diag_fp_terms_def=dict(
+                info="The forecast's terms when fullpos core diagnostics are computed",
+                type=dict,
+                optional=True,
+            ),
+            extra_fp_terms_def=dict(
+                info=("The forecast's terms when extra fullpos diagnostics are computed. " +
+                      "They are always computed by some offline tasks. " +
+                      "The dictionary has an additional level (describing the 'name' of the " +
+                      "extra fullpos processing"),
+                type=dict,
+                optional=True,
+            ),
+            secondary_diag_terms_def=dict(
+                info=("The forecast's terms when secondary diagnostics are computed. " +
+                      "Secondary dignostics are based on diagnostics previously created by " +
+                      "the inline/offline diag fullpos (see diag_fp_terms_def)." +
+                      "The dictionary has an additional level (describing the 'name' of the " +
+                      "secondary diags"),
+                type=dict,
+                optional=True,
+            ),
+            use_inline_fp = dict(
+                info = 'Use inline Fullpos to compute "core_fp_terms"',
+                type = bool,
+                optional = True,
+                default = True,
+            ),
+        )
+    )
+
+    _ACTUAL_T_RE = re.compile(r'(\w+)_terms$')
+    _ACTUAL_FPLIST_T_RE = re.compile(r'(\w+)_terms_fplist$')
+    _UNDEFINED = object()
+
+    def __init__(self, *kargs, **kwargs):
+        super().__init__(*kargs, **kwargs)
+        self._x_fcterm = self._check_data_keys_and_times(self.fcterm_def, 'fcterm_def',
+                                                         cast=self._cast_unique_value)
+        self._x_hist_terms = self._check_data_keys_and_times(self.hist_terms_def, 'hist_terms_def',
+                                                             cast=self._cast_timerangex)
+        self._x_surf_terms = self._check_data_keys_and_times(self.surf_terms_def, 'surf_terms_def',
+                                                             cast=self._cast_timerangex)
+        self._x_norm_terms = self._check_data_keys_and_times(self.norm_terms_def, 'norm_terms_def',
+                                                             cast=self._cast_timerangex)
+        self._x_diag_fp_terms = self._check_data_keys_and_times(self.diag_fp_terms_def, 'diag_fp_terms_def',
+                                                                cast=self._cast_timerangex)
+        self._x_extra_fp_terms = dict() if self.extra_fp_terms_def is None else self.extra_fp_terms_def
+        if not all([isinstance(v, dict) for v in self._x_extra_fp_terms.values()]):
+            raise ValueError("extra_fp_terms values need to be dictionaries")
+        self._x_extra_fp_terms = {k: self._check_data_keys_and_times(v,
+                                                                     'extra_fp_terms_def[{:s}]'.format(k),
+                                                                     cast=self._cast_timerangex)
+                                  for k, v in self._x_extra_fp_terms.items()}
+        self._x_secondary_diag_terms_def = (dict()
+                                            if self.secondary_diag_terms_def is None
+                                            else self.secondary_diag_terms_def)
+        if not all([isinstance(v, dict) for v in self._x_secondary_diag_terms_def.values()]):
+            raise ValueError("extra_fp_terms values need to be dictionaries")
+        self._x_secondary_diag_terms_def = {
+            k: self._check_data_keys_and_times(v,
+                                               'secondary_diag_terms_def[{:s}]'.format(k),
+                                               cast=self._cast_timerangex)
+            for k, v in self._x_secondary_diag_terms_def.items()
+        }
+        self._lookup_cache = dict()
+        self._lookup_rangex_cache = dict()
+        self._no_inline_cache = None
+
+    def _clone(self, **kwargs):
+        my_args = self.footprint_as_shallow_dict()
+        my_args.update(kwargs)
+        return self.__class__(** my_args)
+
+    @property
+    def no_inline(self):
+        """Return a clone of this object with inline fullpos de-activated."""
+        if self._no_inline_cache is None:
+            self._no_inline_cache = self._clone(use_inline_fp=False)
+        return self._no_inline_cache
+
+    @staticmethod
+    def _cast_void(value):
+        return value
+
+    def _cast_unique_value(self, value):
+        if self.fcterm_unit == 'hour':
+            return Time(value)
+        else:
+            return int(value)
+
+    @staticmethod
+    def _cast_timerangex(value):
+        if not (value is None or isinstance(value, str)):
+            if isinstance(value, collections.abc.Iterable):
+                value = ','.join([str(e) for e in value])
+            else:
+                value = str(value)
+        return value
+
+    @staticmethod
+    def _check_data_keys(data, dataname):
+        """Check the first level of any input dictionary."""
+        if data is None:
+            return dict(default=dict(default=None))
+        else:
+            if not set(data.keys()) <= {'assim', 'production', 'default'}:
+                raise ValueError('Impoper value ({!s}) for "{:s}".'.format(data, dataname))
+            return data
+
+    def _check_data_keys_and_times(self, data, dataname, cast=None):
+        """Check any input dictionary and convert values."""
+        data = self._check_data_keys(data, dataname)
+        cast = self._cast_void if cast is None else cast
+        new_data = dict()
+        for data_k, data_v in data.items():
+            if not isinstance(data_v, dict):
+                raise ValueError('The {:s} "{:s}" entry should be a dictionary (got "{!s}")'
+                                 .format(dataname, data_k, data_v))
+            try:
+                new_data[data_k] = {'default' if k == 'default' else Time(k): cast(v)
+                                    for k, v in data_v.items()}
+            except ValueError as e:
+                raise ValueError("Error while processing {:s}'s {:s}: ".format(dataname, data_k) +
+                                 "Could not convert to Time (original message '{!s}')".format(e))
+        return new_data
+
+    def _cutoff_hh_lookup(self, what_desc, cutoff, hh, rawdata=None):
+        """Look for a particular cutoff in self._x_what_desc."""
+        if not isinstance(hh, Time):
+            hh = Time(hh)
+        if (what_desc, cutoff, hh) not in self._lookup_cache:
+            if rawdata is None:
+                rawdata = getattr(self, '_x_{:s}'.format(what_desc))
+            cutoff_v = rawdata.get(cutoff, rawdata.get('default', self._UNDEFINED))
+            if cutoff_v is self._UNDEFINED:
+                raise ValueError('Nothing is defined for cutoff="{:s}" in "{:s}"'
+                                 .format(cutoff, what_desc))
+            hh_v = cutoff_v.get(hh, cutoff_v.get('default', self._UNDEFINED))
+            if hh_v is self._UNDEFINED:
+                raise ValueError('Nothing is defined for cutoff="{:s}"/hh="{!s}" in "{:s}"'
+                                 .format(cutoff, hh, what_desc))
+            self._lookup_cache[(what_desc, cutoff, hh)] = hh_v
+        return self._lookup_cache[(what_desc, cutoff, hh)]
+
+    def _cutoff_hh_rangex_lookup(self, what_desc, cutoff, hh, rawdata=None):
+        """Look for a particular cutoff in self._x_what_desc and resolve the rangex."""
+        if (what_desc, cutoff, hh) not in self._lookup_rangex_cache:
+            try:
+                what = self._cutoff_hh_lookup(what_desc, cutoff, hh, rawdata=rawdata)
+            except ValueError:
+                what = None
+            if what is None:
+                self._lookup_rangex_cache[(what_desc, cutoff, hh)] = list()
+            else:
+                finalterm = self._cutoff_hh_lookup('fcterm', cutoff, hh)
+                if 'finalterm' in what:
+                    what = what.replace('finalterm', str(finalterm))
+                try:
+                    tir = timeintrangex(what)
+                except (TypeError, ValueError):
+                    raise ValueError(
+                        'Could not process "{:s}" using timeintrangex (from "{:s}" with cutoff={:s}/hh={!s})'
+                        .format(what, what_desc, cutoff, hh)
+                    )
+                if self.fcterm_unit == 'timestep' and not all([isinstance(i, int) for i in tir]):
+                    raise ValueError('No hours/minutes allowed when fcterm_unit is "timestep" ' +
+                                     '(from "{:s}" with cutoff={:s}/hh={!s})'
+                                     .format(what_desc, cutoff, hh))
+                self._lookup_rangex_cache[(what_desc, cutoff, hh)] = sorted(
+                    [t for t in tir if t <= finalterm]
+                )
+        return self._lookup_rangex_cache[(what_desc, cutoff, hh)]
+
+    def fcterm(self, cutoff, hh):
+        """The forecast term for **cutoff** and **hh**."""
+        fcterm = self._cutoff_hh_lookup('fcterm', cutoff, hh)
+        if isinstance(fcterm, Time) and fcterm.minute == 0:
+            return fcterm.hour
+        else:
+            return fcterm
+
+    def hist_terms(self, cutoff, hh):
+        """The list of terms for requested/archived historical files."""
+        return self._cutoff_hh_rangex_lookup('hist_terms', cutoff, hh)
+
+    def surf_terms(self, cutoff, hh):
+        """The list of terms for historical surface files."""
+        return self._cutoff_hh_rangex_lookup('surf_terms', cutoff, hh)
+
+    def norm_terms(self, cutoff, hh):
+        """The list of terms for norm calculations."""
+        return self._cutoff_hh_rangex_lookup('norm_terms', cutoff, hh)
+
+    def inline_terms(self, cutoff, hh):
+        """The list of terms for inline diagnostics."""
+        if self.use_inline_fp:
+            return sorted(
+                set(self._cutoff_hh_rangex_lookup('diag_fp_terms', cutoff, hh)) |
+                self._secondary_diag_terms_set(cutoff, hh)
+            )
+        else:
+            return list()
+
+    def diag_terms(self, cutoff, hh):
+        """The list of terms for offline diagnostics."""
+        if self.use_inline_fp:
+            return list()
+        else:
+            return sorted(
+                set(self._cutoff_hh_rangex_lookup('diag_fp_terms', cutoff, hh)) |
+                self._secondary_diag_terms_set(cutoff, hh)
+            )
+
+    def diag_terms_fplist(self, cutoff, hh):
+        """The list of terms for offline diagnostics (as a FPlist)."""
+        flist = self.diag_terms(cutoff, hh)
+        return FPList(flist) if flist else []
+
+    def _extra_fp_terms_item_fplist(self, item, cutoff, hh):
+        flist = self._cutoff_hh_rangex_lookup('extra_fp_terms[{:s}]'.format(item),
+                                              cutoff, hh,
+                                              rawdata=self._x_extra_fp_terms[item])
+        return FPList(flist) if flist else []
+
+    def _secondary_diag_terms_item_fplist(self, item, cutoff, hh):
+        flist = self._cutoff_hh_rangex_lookup('secondary_diag_terms[{:s}]'.format(item),
+                                              cutoff, hh,
+                                              rawdata=self._x_secondary_diag_terms_def[item])
+        return FPList(flist) if flist else []
+
+    @secure_getattr
+    def __getattr__(self, item):
+        actual_m = self._ACTUAL_T_RE.match(item)
+        actual_fplist_m = self._ACTUAL_FPLIST_T_RE.match(item)
+        if actual_m and actual_m.group(1) in self._x_extra_fp_terms.keys():
+            return functools.partial(self._cutoff_hh_rangex_lookup,
+                                     'extra_fp_terms[{:s}]'.format(actual_m.group(1)),
+                                     rawdata=self._x_extra_fp_terms[actual_m.group(1)])
+        elif actual_fplist_m and actual_fplist_m.group(1) in self._x_extra_fp_terms.keys():
+            return functools.partial(self._extra_fp_terms_item_fplist,
+                                     actual_fplist_m.group(1))
+        elif actual_m and actual_m.group(1) in self._x_secondary_diag_terms_def.keys():
+            return functools.partial(self._cutoff_hh_rangex_lookup,
+                                     'secondary_diag_terms[{:s}]'.format(actual_m.group(1)),
+                                     rawdata=self._x_secondary_diag_terms_def[actual_m.group(1)])
+        elif actual_fplist_m and actual_fplist_m.group(1) in self._x_secondary_diag_terms_def.keys():
+            return functools.partial(self._secondary_diag_terms_item_fplist,
+                                     actual_fplist_m.group(1))
+        else:
+            raise AttributeError('Attribute "{:s}" was not found'.format(item))
+
+    def _fpoff_terms_set(self, cutoff, hh):
+        fpoff_terms = set()
+        for k, v in self._x_extra_fp_terms.items():
+            fpoff_terms.update(self._cutoff_hh_rangex_lookup('extra_fp_terms[{:s}]'.format(k),
+                                                             cutoff, hh, rawdata=v))
+        if not self.use_inline_fp:
+            fpoff_terms.update(self._cutoff_hh_rangex_lookup('diag_fp_terms', cutoff, hh))
+            fpoff_terms.update(self._secondary_diag_terms_set(cutoff, hh))
+        return fpoff_terms
+
+    def _secondary_diag_terms_set(self, cutoff, hh):
+        sec_terms = set()
+        for k, v in self._x_secondary_diag_terms_def.items():
+            sec_terms.update(self._cutoff_hh_rangex_lookup('secondary_diag_terms[{:s}]'.format(k),
+                                                           cutoff, hh, rawdata=v))
+        return sec_terms
+
+    def extra_hist_terms(self, cutoff, hh):
+        """The list of terms for historical file terms solely produced for fullpos use."""
+        fpoff_terms = self._fpoff_terms_set(cutoff, hh)
+        fpoff_terms -= set(self.hist_terms(cutoff, hh))
+        return sorted(fpoff_terms)
+
+    def all_hist_terms(self, cutoff, hh):
+        """The list of terms for all historical file."""
+        all_terms = self._fpoff_terms_set(cutoff, hh)
+        all_terms |= set(self.hist_terms(cutoff, hh))
+        return sorted(all_terms)
+
+    def fpoff_terms(self, cutoff, hh):
+        """The list of terms for offline fullpos."""
+        fpoff_terms = self._fpoff_terms_set(cutoff, hh)
+        return sorted(fpoff_terms)
+
+    def fpoff_items(self, cutoff, hh, discard=None, only=None):
+        """List of active offline post-processing domains."""
+        items = {k
+                 for k, v in self._x_extra_fp_terms.items()
+                 if self._cutoff_hh_rangex_lookup('extra_fp_terms[{:s}]'.format(k),
+                                                  cutoff,
+                                                  hh,
+                                                  rawdata=v)}
+        if not self.use_inline_fp and self._cutoff_hh_rangex_lookup('diag_fp_terms', cutoff, hh):
+            items.add('diag')
+        if discard:
+            items -= set(discard)
+        if only:
+            items &= set(only)
+        return sorted(items)
+
+    def fpoff_terms_map(self, cutoff, hh):
+        """The mapping dictionary between offline post-processing terms and domains."""
+        return {k: getattr(self, '{:s}_terms'.format(k))(cutoff, hh)
+                for k in self.fpoff_items(cutoff, hh)}
+
+    def fpoff_terms_fpmap(self, cutoff, hh):
+        """The mapping dictionary between offline post-processing terms and domains (as a FPlist)."""
+        return {k: getattr(self, '{:s}_terms_fplist'.format(k))(cutoff, hh)
+                for k in self.fpoff_items(cutoff, hh)}
+
+
+class TimeSlotsConfTool(AbstractObjectProxyConfTool):
+    """Gives easy access to a Timeslots object.
+
+    The conf tool will look like::
+
+      >>> ct = TimeSlotsConfTool(kind="objproxy",
+      ...                        timeslots_def="7/-PT3H/PT6H")
+      >>> print(ct.start)
+      -PT10800S
+
+    """
+
+    _footprint = dict(
+        info = 'Gives easy access to a Timeslots object.',
+        attr = dict(
+            timeslots_def = dict(
+                info        = "The timeslots specification",
+            ),
+        )
+    )
+
+    def _create_proxied_obj(self):
+        return TimeSlots(self.timeslots_def)
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()