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

vortex/nwp/data/logs.py

@@ -24,77 +24,84 @@ class FlowLogsStack(Resource):
         date_deco,
         cutoff_deco,
         dict(
-            info = 'Stack of miscellaneous log files.',
-            attr = dict(
-                kind = dict(
-                    values   = ['flow_logs']
-                ),
-                nativefmt = dict(
-                    values   = ['filespack', ],
-                    default  = 'filespack',
+            info="Stack of miscellaneous log files.",
+            attr=dict(
+                kind=dict(values=["flow_logs"]),
+                nativefmt=dict(
+                    values=[
+                        "filespack",
+                    ],
+                    default="filespack",
                 ),
             ),
-        )
+        ),
     ]
 
     @property
     def realkind(self):
-        return 'flow_logs'
+        return "flow_logs"
 
 
 def use_flow_logs_stack(cls):
     """Setup the decorated class to work with the FlowLogsStack resource."""
     fpattrs = set(cls.footprint_retrieve().attr.keys())
-    fpcheck = all([k in fpattrs for k in ('date', 'cutoff')])
+    fpcheck = all([k in fpattrs for k in ("date", "cutoff")])
     if not fpcheck:
-        raise ImportError('The "{!s}" class is not compatible with the FlowLogsStack class.'
-                          .format(cls))
+        raise ImportError(
+            'The "{!s}" class is not compatible with the FlowLogsStack class.'.format(
+                cls
+            )
+        )
 
     def stackedstorage_resource(self):
         """Use the FlowLogsStack resource for stacked storage."""
-        return FlowLogsStack(kind='flow_logs', date=self.date, cutoff=self.cutoff), False
+        return FlowLogsStack(
+            kind="flow_logs", date=self.date, cutoff=self.cutoff
+        ), False
 
     cls.stackedstorage_resource = stackedstorage_resource
     return cls
 
 
 @use_flow_logs_stack
-@namebuilding_insert('src', lambda s: [s.binary, '-'.join(s.task.split('/')[s.task_start:s.task_stop])])
-@namebuilding_insert('compute', lambda s: s.part)
-@namebuilding_delete('fmt')
+@namebuilding_insert(
+    "src",
+    lambda s: [
+        s.binary,
+        "-".join(s.task.split("/")[s.task_start : s.task_stop]),
+    ],
+)
+@namebuilding_insert("compute", lambda s: s.part)
+@namebuilding_delete("fmt")
 class Listing(FlowResource):
     """Miscellaneous application output from a task processing."""
+
     _footprint = [
         dict(
-            info = 'Listing',
-            attr = dict(
-                task = dict(
-                    optional = True,
-                    default  = 'anonymous'
-                ),
-                task_start = dict(
-                    optional = True,
-                    type     = int,
-                    default  = -1,
-                ),
-                task_stop = dict(
-                    optional = True,
-                    type     = int,
-                    default  = None,
-                ),
-                kind = dict(
-                    values   = ['listing']
-                ),
-                part = dict(
-                    optional = True,
-                    default  = 'all',
-                ),
-                binary = dict(
-                    optional = True,
-                    default  = '[model]',
-                ),
-                clscontents = dict(
-                    default = FormatAdapter,
+            info="Listing",
+            attr=dict(
+                task=dict(optional=True, default="anonymous"),
+                task_start=dict(
+                    optional=True,
+                    type=int,
+                    default=-1,
+                ),
+                task_stop=dict(
+                    optional=True,
+                    type=int,
+                    default=None,
+                ),
+                kind=dict(values=["listing"]),
+                part=dict(
+                    optional=True,
+                    default="all",
+                ),
+                binary=dict(
+                    optional=True,
+                    default="[model]",
+                ),
+                clscontents=dict(
+                    default=FormatAdapter,
                 ),
             ),
         )
@@ -102,11 +109,11 @@ class Listing(FlowResource):
 
     @property
     def realkind(self):
-        return 'listing'
+        return "listing"
 
     def olive_basename(self):
         """Fake basename for getting olive listings"""
-        if hasattr(self, '_listingpath'):
+        if hasattr(self, "_listingpath"):
             return self._listingpath
         else:
             return "NOT_IMPLEMENTED"
@@ -117,39 +124,40 @@ class Listing(FlowResource):
 
 class ParallelListing(Listing):
     """Multi output for parallel MPI and/or OpenMP processing."""
+
     _footprint = [
         dict(
-            attr = dict(
-                kind = dict(
-                    values = ['listing', 'plisting', 'mlisting'],
-                    remap  = dict(
-                        listing  = 'plisting',
-                        mlisting = 'plisting',
-                    )
-                ),
-                mpi = dict(
-                    optional = True,
-                    default  = None,
-                    type     = FmtInt,
-                    args     = dict(fmt = '03'),
-                ),
-                openmp = dict(
-                    optional = True,
-                    default  = None,
-                    type     = FmtInt,
-                    args     = dict(fmt = '02'),
-                ),
-                seta = dict(
-                    optional = True,
-                    default  = None,
-                    type     = FmtInt,
-                    args     = dict(fmt = '03'),
-                ),
-                setb = dict(
-                    optional = True,
-                    default  = None,
-                    type     = FmtInt,
-                    args     = dict(fmt = '02'),
+            attr=dict(
+                kind=dict(
+                    values=["listing", "plisting", "mlisting"],
+                    remap=dict(
+                        listing="plisting",
+                        mlisting="plisting",
+                    ),
+                ),
+                mpi=dict(
+                    optional=True,
+                    default=None,
+                    type=FmtInt,
+                    args=dict(fmt="03"),
+                ),
+                openmp=dict(
+                    optional=True,
+                    default=None,
+                    type=FmtInt,
+                    args=dict(fmt="02"),
+                ),
+                seta=dict(
+                    optional=True,
+                    default=None,
+                    type=FmtInt,
+                    args=dict(fmt="03"),
+                ),
+                setb=dict(
+                    optional=True,
+                    default=None,
+                    type=FmtInt,
+                    args=dict(fmt="02"),
                 ),
             )
         )
@@ -159,38 +167,34 @@ class ParallelListing(Listing):
         """From base information of ``listing`` add mpi and openmp values."""
         info = super().namebuilding_info()
         if self.mpi and self.openmp:
-            info['compute'] = [{'mpi': self.mpi}, {'openmp': self.openmp}]
+            info["compute"] = [{"mpi": self.mpi}, {"openmp": self.openmp}]
         if self.seta and self.setb:
-            info['compute'] = [{'seta': self.seta}, {'setb': self.setb}]
+            info["compute"] = [{"seta": self.seta}, {"setb": self.setb}]
         return info
 
 
-@namebuilding_insert('src', lambda s: [s.binary, s.task.split('/').pop()])
-@namebuilding_insert('compute', lambda s: s.part)
-@namebuilding_delete('fmt')
+@namebuilding_insert("src", lambda s: [s.binary, s.task.split("/").pop()])
+@namebuilding_insert("compute", lambda s: s.part)
+@namebuilding_delete("fmt")
 class StaticListing(Resource):
     """Miscelanous application output from a task processing, out-of-flow."""
+
     _footprint = [
         dict(
-            info = 'Listing',
-            attr = dict(
-                task = dict(
-                    optional = True,
-                    default  = 'anonymous'
-                ),
-                kind = dict(
-                    values   = ['staticlisting']
-                ),
-                part = dict(
-                    optional = True,
-                    default  = 'all',
+            info="Listing",
+            attr=dict(
+                task=dict(optional=True, default="anonymous"),
+                kind=dict(values=["staticlisting"]),
+                part=dict(
+                    optional=True,
+                    default="all",
                 ),
-                binary = dict(
-                    optional = True,
-                    default  = '[model]',
+                binary=dict(
+                    optional=True,
+                    default="[model]",
                 ),
-                clscontents = dict(
-                    default = FormatAdapter,
+                clscontents=dict(
+                    default=FormatAdapter,
                 ),
             ),
         )
@@ -198,23 +202,33 @@ class StaticListing(Resource):
 
     @property
     def realkind(self):
-        return 'staticlisting'
-
-
-@namebuilding_insert('compute', lambda s: None if s.mpi is None else [{'mpi': s.mpi}, ],
-                     none_discard=True)
+        return "staticlisting"
+
+
+@namebuilding_insert(
+    "compute",
+    lambda s: None
+    if s.mpi is None
+    else [
+        {"mpi": s.mpi},
+    ],
+    none_discard=True,
+)
 class DrHookListing(Listing):
     """Output produced by DrHook"""
+
     _footprint = [
         dict(
-            attr = dict(
-                kind = dict(
-                    values = ['drhook', ],
+            attr=dict(
+                kind=dict(
+                    values=[
+                        "drhook",
+                    ],
                 ),
-                mpi = dict(
-                    optional = True,
-                    type     = FmtInt,
-                    args     = dict(fmt = '03'),
+                mpi=dict(
+                    optional=True,
+                    type=FmtInt,
+                    args=dict(fmt="03"),
                 ),
             )
         )
@@ -222,116 +236,107 @@ class DrHookListing(Listing):
 
     @property
     def realkind(self):
-        return 'drhookprof'
+        return "drhookprof"
 
 
 @use_flow_logs_stack
 class Beacon(FlowResource):
     """Output indicating the end of a model run."""
+
     _footprint = [
         dict(
-            info = 'Beacon',
-            attr = dict(
-                kind = dict(
-                    values   = ['beacon']
-                ),
-                clscontents = dict(
-                    default = JsonDictContent,
+            info="Beacon",
+            attr=dict(
+                kind=dict(values=["beacon"]),
+                clscontents=dict(
+                    default=JsonDictContent,
                 ),
-                nativefmt = dict(
-                    default = 'json',
+                nativefmt=dict(
+                    default="json",
                 ),
-            )
+            ),
         )
     ]
 
     @property
     def realkind(self):
-        return 'beacon'
+        return "beacon"
 
 
 @use_flow_logs_stack
-@namebuilding_insert('src', lambda s: s.task.split('/').pop())
-@namebuilding_insert('compute', lambda s: s.scope)
+@namebuilding_insert("src", lambda s: s.task.split("/").pop())
+@namebuilding_insert("compute", lambda s: s.scope)
 class TaskInfo(FlowResource):
     """Task informations."""
+
     _footprint = [
         dict(
-            info = 'Task informations',
-            attr = dict(
-                task = dict(
-                    optional = True,
-                    default  = 'anonymous'
+            info="Task informations",
+            attr=dict(
+                task=dict(optional=True, default="anonymous"),
+                kind=dict(values=["taskinfo"]),
+                scope=dict(
+                    optional=True,
+                    default="void",
                 ),
-                kind = dict(
-                    values   = ['taskinfo']
+                clscontents=dict(
+                    default=JsonDictContent,
                 ),
-                scope = dict(
-                    optional = True,
-                    default  = 'void',
+                nativefmt=dict(
+                    default="json",
                 ),
-                clscontents = dict(
-                    default = JsonDictContent,
-                ),
-                nativefmt = dict(
-                    default = 'json',
-                ),
-            )
+            ),
         )
     ]
 
     @property
     def realkind(self):
-        return 'taskinfo'
+        return "taskinfo"
 
 
-@namebuilding_insert('src', lambda s: s.task.split('/').pop())
-@namebuilding_insert('compute', lambda s: s.scope)
-@namebuilding_delete('fmt')
+@namebuilding_insert("src", lambda s: s.task.split("/").pop())
+@namebuilding_insert("compute", lambda s: s.scope)
+@namebuilding_delete("fmt")
 class StaticTaskInfo(Resource):
     """Task informations."""
+
     _footprint = [
         dict(
-            info = 'Task informations',
-            attr = dict(
-                task = dict(
-                    optional = True,
-                    default  = 'anonymous'
+            info="Task informations",
+            attr=dict(
+                task=dict(optional=True, default="anonymous"),
+                kind=dict(values=["statictaskinfo"]),
+                scope=dict(
+                    optional=True,
+                    default="void",
                 ),
-                kind = dict(
-                    values   = ['statictaskinfo']
+                clscontents=dict(
+                    default=JsonDictContent,
                 ),
-                scope = dict(
-                    optional = True,
-                    default  = 'void',
+                nativefmt=dict(
+                    default="json",
                 ),
-                clscontents = dict(
-                    default = JsonDictContent,
-                ),
-                nativefmt = dict(
-                    default = 'json',
-                ),
-            )
+            ),
         )
     ]
 
     @property
     def realkind(self):
-        return 'statictaskinfo'
+        return "statictaskinfo"
 
 
 class SectionsSlice(collections.abc.Sequence):
     """Hold a list of dictionaries representing Sections."""
 
-    _INDEX_PREFIX = 'sslice'
-    _INDEX_ATTR = 'sliceindex'
+    _INDEX_PREFIX = "sslice"
+    _INDEX_ATTR = "sliceindex"
 
     def __init__(self, sequence):
         self._data = sequence
 
     def __getitem__(self, i):
         if isinstance(i, str) and i.startswith(self._INDEX_PREFIX):
-            i = int(i[len(self._INDEX_PREFIX):])
+            i = int(i[len(self._INDEX_PREFIX) :])
         return self._data[i]
 
     def __eq__(self, other):
@@ -361,23 +366,26 @@ class SectionsSlice(collections.abc.Sequence):
         'resource', 'provider' and 'container' parts of the 'rh'sub-dictionary
         are also looked for.
         """
-        if k == 'role':
-            return item[k] or item['alternate']
-        elif k == 'kind' and k in item.get('rh', dict()).get('resource', dict()):
-            return item['rh']['resource'][k]
-        elif k == 'section_kind' and 'kind' in item:
-            return item['kind']
+        if k == "role":
+            return item[k] or item["alternate"]
+        elif k == "kind" and k in item.get("rh", dict()).get(
+            "resource", dict()
+        ):
+            return item["rh"]["resource"][k]
+        elif k == "section_kind" and "kind" in item:
+            return item["kind"]
         elif k in item:
             return item[k]
-        elif k in item.get('rh', dict()).get('resource', dict()):
-            return item['rh']['resource'][k]
-        elif k in item.get('rh', dict()).get('provider', dict()):
-            return item['rh']['provider'][k]
-        elif k in item.get('rh', dict()).get('container', dict()):
-            return item['rh']['container'][k]
+        elif k in item.get("rh", dict()).get("resource", dict()):
+            return item["rh"]["resource"][k]
+        elif k in item.get("rh", dict()).get("provider", dict()):
+            return item["rh"]["provider"][k]
+        elif k in item.get("rh", dict()).get("container", dict()):
+            return item["rh"]["container"][k]
         else:
-            raise KeyError("'{:s}' wasn't found in the designated dictionary"
-                           .format(k))
+            raise KeyError(
+                "'{:s}' wasn't found in the designated dictionary".format(k)
+            )
 
     @staticmethod
     def _sloppy_compare(json_v, v):
@@ -398,20 +406,22 @@ class SectionsSlice(collections.abc.Sequence):
 
     def _sloppy_ckeck(self, item, k, v, extras):
         """Perform a _sloppy_lookup and check the result against *v*."""
-        if k in ('role', 'alternate'):
+        if k in ("role", "alternate"):
             v = setrole(v)
         try:
-            if k == 'baseterm':
-                found = self._sloppy_lookup(item, 'term')
-                foundbis = self._sloppy_lookup(item, 'date')
+            if k == "baseterm":
+                found = self._sloppy_lookup(item, "term")
+                foundbis = self._sloppy_lookup(item, "date")
             else:
                 found = self._sloppy_lookup(item, k)
         except KeyError:
             return False
         if not isinstance(v, (list, tuple, set)):
-            v = [v, ]
-        if k == 'baseterm' and extras.get('basedate', None):
-            delta = (Date(extras['basedate']) - Date(foundbis))
+            v = [
+                v,
+            ]
+        if k == "baseterm" and extras.get("basedate", None):
+            delta = Date(extras["basedate"]) - Date(foundbis)
             found = Time(found) - delta
         return any([self._sloppy_compare(found, a_v) for a_v in v])
 
@@ -423,10 +433,17 @@ class SectionsSlice(collections.abc.Sequence):
             >>> self.filter(role='Guess', member=1)
         """
         extras = dict()
-        extras['basedate'] = kwargs.pop('basedate', None)
-        newslice = [s for s in self
-                    if all([self._sloppy_ckeck(s, k, v, extras)
-                            for k, v in kwargs.items()])]
+        extras["basedate"] = kwargs.pop("basedate", None)
+        newslice = [
+            s
+            for s in self
+            if all(
+                [
+                    self._sloppy_ckeck(s, k, v, extras)
+                    for k, v in kwargs.items()
+                ]
+            )
+        ]
         return self.__class__(newslice)
 
     def uniquefilter(self, **kwargs):
@@ -442,7 +459,9 @@ class SectionsSlice(collections.abc.Sequence):
     @property
     def indexes(self):
         """Returns an index list of all the element contained if the present object."""
-        return [self._INDEX_PREFIX + '{:d}'.format(i) for i in range(len(self))]
+        return [
+            self._INDEX_PREFIX + "{:d}".format(i) for i in range(len(self))
+        ]
 
     def __deepcopy__(self, memo):
         newslice = self.__class__(self._data)
@@ -465,27 +484,40 @@ class SectionsSlice(collections.abc.Sequence):
         be generated using the :meth:`indexes` property), the corresponding element
         will be searched using :meth:`_sloppy_lookup`.
         """.format(idx_attr=self._INDEX_ATTR)
-        if attr.startswith('__'):
+        if attr.startswith("__"):
             raise AttributeError(attr)
         if len(self) == 1:
             try:
                 return self._sloppy_lookup(self[0], attr)
             except KeyError:
-                raise AttributeError("'{:s}' wasn't found in the unique dictionary"
-                                     .format(attr))
+                raise AttributeError(
+                    "'{:s}' wasn't found in the unique dictionary".format(attr)
+                )
         elif len(self) == 0:
-            raise AttributeError("The current SectionsSlice is empty. No attribute lookup allowed !")
+            raise AttributeError(
+                "The current SectionsSlice is empty. No attribute lookup allowed !"
+            )
         else:
+
             def _attr_lookup(g, x):
-                if len(self) > 1 and (self._INDEX_ATTR in g or self._INDEX_ATTR in x):
+                if len(self) > 1 and (
+                    self._INDEX_ATTR in g or self._INDEX_ATTR in x
+                ):
                     idx = g.get(self._INDEX_ATTR, x.get(self._INDEX_ATTR))
                     try:
                         return self._sloppy_lookup(self[idx], attr)
                     except KeyError:
-                        raise AttributeError("'{:s}' wasn't found in the {!s}-th dictionary"
-                                             .format(attr, idx))
+                        raise AttributeError(
+                            "'{:s}' wasn't found in the {!s}-th dictionary".format(
+                                attr, idx
+                            )
+                        )
                 else:
-                    raise AttributeError("A '{:s}' attribute must be there !".format(self._INDEX_ATTR))
+                    raise AttributeError(
+                        "A '{:s}' attribute must be there !".format(
+                            self._INDEX_ATTR
+                        )
+                    )
 
             return _attr_lookup
 
@@ -518,7 +550,7 @@ class SectionsJsonListContent(DataContent):
 
 
 @use_flow_logs_stack
-@namebuilding_insert('src', lambda s: s.task.split('/').pop())
+@namebuilding_insert("src", lambda s: s.task.split("/").pop())
 class SectionsList(FlowResource):
     """Class to handle a resource that contains a list of Sections in JSON format.
 
@@ -527,23 +559,24 @@ class SectionsList(FlowResource):
     """
 
     _footprint = dict(
-        info = 'A Sections List',
-        attr = dict(
+        info="A Sections List",
+        attr=dict(
             kind=dict(
-                values=['sectionslist', ],
+                values=[
+                    "sectionslist",
+                ],
             ),
-            task = dict(
-                optional = True,
-                default  = 'anonymous'
+            task=dict(optional=True, default="anonymous"),
+            clscontents=dict(
+                default=SectionsJsonListContent,
             ),
-            clscontents = dict(
-                default = SectionsJsonListContent,
+            nativefmt=dict(
+                values=[
+                    "json",
+                ],
+                default="json",
             ),
-            nativefmt   = dict(
-                values  = ['json', ],
-                default = 'json',
-            )
-        )
+        ),
     )
 
     @property