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

vortex/nwp/data/eps.py

@@ -22,7 +22,10 @@ __all__ = []
 logger = loggers.getLogger(__name__)
 
 
-@namebuilding_insert('radical', lambda s: {'unit': 'u', 'normed': 'n'}.get(s.processing, '') + s.realkind)
+@namebuilding_insert(
+    "radical",
+    lambda s: {"unit": "u", "normed": "n"}.get(s.processing, "") + s.realkind,
+)
 class PerturbedState(Historic):
     """
     Class for numbered historic resources, for example perturbations or perturbed states of the EPS.
@@ -31,77 +34,95 @@ class PerturbedState(Historic):
     _footprint = [
         number_deco,
         dict(
-            info = 'Perturbation or perturbed state',
-            attr = dict(
-                kind = dict(
-                    values  = ['perturbation', 'perturbed_historic', 'perturbed_state', 'pert'],
-                    remap = dict(autoremap = 'first')
+            info="Perturbation or perturbed state",
+            attr=dict(
+                kind=dict(
+                    values=[
+                        "perturbation",
+                        "perturbed_historic",
+                        "perturbed_state",
+                        "pert",
+                    ],
+                    remap=dict(autoremap="first"),
                 ),
-                term = dict(
-                    optional = True,
-                    default = Time(0)
+                term=dict(optional=True, default=Time(0)),
+                processing=dict(
+                    values=["unit", "normed"],
+                    optional=True,
                 ),
-                processing = dict(
-                    values = ['unit', 'normed'],
-                    optional = True,
-                ),
-            )
-        )
+            ),
+        ),
     ]
 
     @property
     def realkind(self):
-        return 'pert'
+        return "pert"
 
     def olive_basename(self):
         """OLIVE specific naming convention."""
-        raise NotImplementedError("Perturbations were previously tar files, not supported yet.")
+        raise NotImplementedError(
+            "Perturbations were previously tar files, not supported yet."
+        )
 
     def archive_basename(self):
         """OP ARCHIVE specific naming convention."""
-        raise NotImplementedError("Perturbations were previously tar files, not supported yet.")
+        raise NotImplementedError(
+            "Perturbations were previously tar files, not supported yet."
+        )
 
 
-@namebuilding_insert('radical', lambda s: s.realkind + '-' + s.zone)
+@namebuilding_insert("radical", lambda s: s.realkind + "-" + s.zone)
 class SingularVector(Historic):
     """
     Generic class for resources internal to singular vectors.
     """
+
     _footprint = [
         number_deco,
         dict(
-            info = 'Singular vector',
-            attr = dict(
-                kind = dict(
-                    values  = ['svector'],
+            info="Singular vector",
+            attr=dict(
+                kind=dict(
+                    values=["svector"],
                 ),
-                zone = dict(
-                    values  = ['ateur', 'hnc', 'hs', 'pno', 'oise', 'an', 'pne',
-                               'oiso', 'ps', 'oin', 'trop1', 'trop2', 'trop3', 'trop4'],
+                zone=dict(
+                    values=[
+                        "ateur",
+                        "hnc",
+                        "hs",
+                        "pno",
+                        "oise",
+                        "an",
+                        "pne",
+                        "oiso",
+                        "ps",
+                        "oin",
+                        "trop1",
+                        "trop2",
+                        "trop3",
+                        "trop4",
+                    ],
                 ),
-                term = dict(
-                    optional = True,
-                    default = Time(0)
+                term=dict(optional=True, default=Time(0)),
+                optime=dict(
+                    type=Time,
+                    optional=True,
                 ),
-                optime = dict(
-                    type = Time,
-                    optional = True,
-                )
-            )
-        )
+            ),
+        ),
     ]
 
     @property
     def realkind(self):
-        return 'svector'
+        return "svector"
 
     def olive_basename(self):
         """OLIVE specific naming convention."""
-        return 'SVARPE' + '{:03d}'.format(self.number) + '+0000'
+        return "SVARPE" + "{:03d}".format(self.number) + "+0000"
 
     def archive_basename(self):
         """OP ARCHIVE specific naming convention."""
-        return 'SVARPE' + '{:03d}'.format(self.number) + '+0000'
+        return "SVARPE" + "{:03d}".format(self.number) + "+0000"
 
 
 @use_flow_logs_stack
@@ -111,30 +132,30 @@ class NormCoeff(FlowResource):
     """
 
     _footprint = dict(
-        info = 'Perturbations coefficient',
-        attr = dict(
-            kind = dict(
-                values   = ['coeffnorm', 'coeffpert'],
-                remap = dict(autoremap = 'first'),
+        info="Perturbations coefficient",
+        attr=dict(
+            kind=dict(
+                values=["coeffnorm", "coeffpert"],
+                remap=dict(autoremap="first"),
             ),
-            clscontents = dict(
-                default = JsonDictContent,
+            clscontents=dict(
+                default=JsonDictContent,
             ),
-            nativefmt   = dict(
-                values  = ['json'],
-                default = 'json',
+            nativefmt=dict(
+                values=["json"],
+                default="json",
             ),
-            pertkind     = dict(
-                values   = ['sv', 'bd'],
-                optional = True,
-                default  = 'sv',
+            pertkind=dict(
+                values=["sv", "bd"],
+                optional=True,
+                default="sv",
             ),
-        )
+        ),
     )
 
     @property
     def realkind(self):
-        return 'coeff' + self.pertkind
+        return "coeff" + self.pertkind
 
 
 class SampleContent(JsonDictContent):
@@ -142,8 +163,16 @@ class SampleContent(JsonDictContent):
 
     def drawing(self, g, x):
         """Return the number of a sampled element according to the local number."""
-        n = g.get('number', x.get('number', None))
-        virgin = g.get('untouched', x.get('untouched', [0, ]))
+        n = g.get("number", x.get("number", None))
+        virgin = g.get(
+            "untouched",
+            x.get(
+                "untouched",
+                [
+                    0,
+                ],
+            ),
+        )
         if n is None:
             return None
         else:
@@ -159,17 +188,21 @@ class SampleContent(JsonDictContent):
                 return n
             else:
                 try:
-                    return self.data['drawing'][n - 1]
+                    return self.data["drawing"][n - 1]
                 except KeyError:
                     return None
 
     @secure_getattr
     def __getattr__(self, attr):
         # Return an access function that corresponds to the key in "drawing"
-        drawing_keys = {item
-                        for d in self.data.get('drawing', []) if isinstance(d, dict)
-                        for item in d.keys()}
+        drawing_keys = {
+            item
+            for d in self.data.get("drawing", [])
+            if isinstance(d, dict)
+            for item in d.keys()
+        }
         if attr in drawing_keys:
+
             def _attr_access(g, x):
                 elt = self.drawing(g, x)
                 # drawing may returns
@@ -177,52 +210,68 @@ class SampleContent(JsonDictContent):
                 # * An integer if 'number' is in the 'untouched' list
                 # * A dictionary
                 if elt is None:
-                    choices = {d[attr] for d in self.data['drawing']}
+                    choices = {d[attr] for d in self.data["drawing"]}
                     return None if len(choices) > 1 else choices.pop()
                 else:
                     return elt[attr] if isinstance(elt, dict) else None
+
             return _attr_access
         # Return an access function that corresponds to the key in "population"
-        population_keys = {item
-                           for d in self.data.get('population', []) if isinstance(d, dict)
-                           for item in d.keys()}
+        population_keys = {
+            item
+            for d in self.data.get("population", [])
+            if isinstance(d, dict)
+            for item in d.keys()
+        }
         if attr in population_keys:
+
             def _attr_access(g, x):
-                n = g.get('number', x.get('number', None))
+                n = g.get("number", x.get("number", None))
                 if n is None:
                     return None
                 else:
-                    return self.data['population'][n - 1][attr]
+                    return self.data["population"][n - 1][attr]
+
             return _attr_access
         # Returns the list of drawn keys
-        listing_keys = {item + 's'
-                        for d in self.data.get('drawing', []) if isinstance(d, dict)
-                        for item in d.keys()}
+        listing_keys = {
+            item + "s"
+            for d in self.data.get("drawing", [])
+            if isinstance(d, dict)
+            for item in d.keys()
+        }
         if attr in listing_keys:
-            return [d[attr[:-1]] for d in self.data['drawing']]
+            return [d[attr[:-1]] for d in self.data["drawing"]]
         # Return the list of available keys
-        listing_keys = {item + 's'
-                        for d in self.data['population'] if isinstance(d, dict)
-                        for item in d.keys()}
+        listing_keys = {
+            item + "s"
+            for d in self.data["population"]
+            if isinstance(d, dict)
+            for item in d.keys()
+        }
         if attr in listing_keys:
-            return [d[attr[:-1]] for d in self.data['population']]
+            return [d[attr[:-1]] for d in self.data["population"]]
         raise AttributeError()
 
     def targetdate(self, g, x):
-        targetdate = g.get('targetdate', x.get('targetdate', None))
+        targetdate = g.get("targetdate", x.get("targetdate", None))
         if targetdate is None:
-            raise ValueError("A targetdate attribute must be present if targetdate is used")
+            raise ValueError(
+                "A targetdate attribute must be present if targetdate is used"
+            )
         return Date(targetdate)
 
     def targetterm(self, g, x):
-        targetterm = g.get('targetterm', x.get('targetterm', None))
+        targetterm = g.get("targetterm", x.get("targetterm", None))
         if targetterm is None:
-            raise ValueError("A targetterm attribute must be present if targetterm is used")
+            raise ValueError(
+                "A targetterm attribute must be present if targetterm is used"
+            )
         return Time(targetterm)
 
     def timedelta(self, g, x):
         """Find the time difference between the resource's date and the targetdate."""
-        targetterm = Time(g.get('targetterm', x.get('targetterm', 0)))
+        targetterm = Time(g.get("targetterm", x.get("targetterm", 0)))
         thedate = Date(self.date(g, x))
         period = (self.targetdate(g, x) + targetterm) - thedate
         return period.time()
@@ -230,13 +279,15 @@ class SampleContent(JsonDictContent):
     def _actual_diff(self, ref):
         me = copy.copy(self.data)
         other = copy.copy(ref.data)
-        me.pop('experiment', None)  # Do not compare the experiment ID (if present)
-        other.pop('experiment', None)
+        me.pop(
+            "experiment", None
+        )  # Do not compare the experiment ID (if present)
+        other.pop("experiment", None)
         return me == other
 
 
 @use_flow_logs_stack
-@namebuilding_delete('src')
+@namebuilding_delete("src")
 class PopulationList(FlowResource):
     """
     Description of available data
@@ -244,60 +295,58 @@ class PopulationList(FlowResource):
 
     _abstract = True
     _footprint = dict(
-        info = 'A Population List',
-        attr = dict(
-            clscontents = dict(
-                default = SampleContent,
+        info="A Population List",
+        attr=dict(
+            clscontents=dict(
+                default=SampleContent,
             ),
-            nativefmt   = dict(
-                values  = ['json'],
-                default = 'json',
+            nativefmt=dict(
+                values=["json"],
+                default="json",
             ),
-            nbsample = dict(
-                optional = True,
-                type = int,
+            nbsample=dict(
+                optional=True,
+                type=int,
             ),
-            checkrole = dict(
-                optional = True
-            )
-        )
+            checkrole=dict(optional=True),
+        ),
     )
 
 
 class MembersPopulation(PopulationList):
-
     _footprint = dict(
-        info = 'Members population',
-        attr = dict(
-            kind = dict(
-                values   = ['mbpopulation', ],
+        info="Members population",
+        attr=dict(
+            kind=dict(
+                values=[
+                    "mbpopulation",
+                ],
             ),
-        )
+        ),
     )
 
     @property
     def realkind(self):
-        return 'mbpopulation'
+        return "mbpopulation"
 
 
-@namebuilding_insert('radical', lambda s: '{:s}of{:d}'.format(s.realkind, s.nbsample))
+@namebuilding_insert(
+    "radical", lambda s: "{:s}of{:d}".format(s.realkind, s.nbsample)
+)
 class Sample(PopulationList):
     """
     Lot drawn out of a set.
     """
 
-    _abstract = True,
+    _abstract = (True,)
     _footprint = dict(
-        info = 'Sample',
-        attr = dict(
-            nbsample = dict(
-                optional = False,
+        info="Sample",
+        attr=dict(
+            nbsample=dict(
+                optional=False,
             ),
-            population = dict(
-                type = footprints.stdtypes.FPList,
-                optional = True
-            ),
-        )
+            population=dict(type=footprints.stdtypes.FPList, optional=True),
+        ),
     )
 
 
@@ -307,18 +356,18 @@ class MembersSample(Sample):
     """
 
     _footprint = dict(
-        info = 'Members sample',
-        attr = dict(
-            kind = dict(
-                values   = ['mbsample', 'mbselect', 'mbdrawing', 'members_select'],
-                remap = dict(autoremap = 'first'),
+        info="Members sample",
+        attr=dict(
+            kind=dict(
+                values=["mbsample", "mbselect", "mbdrawing", "members_select"],
+                remap=dict(autoremap="first"),
             ),
-        )
+        ),
     )
 
     @property
     def realkind(self):
-        return 'mbsample'
+        return "mbsample"
 
 
 class MultiphysicsSample(Sample):
@@ -327,18 +376,18 @@ class MultiphysicsSample(Sample):
     """
 
     _footprint = dict(
-        info = 'Physical packages sample',
-        attr = dict(
-            kind = dict(
-                values   = ['physample', 'physelect', 'phydrawing'],
-                remap = dict(autoremap = 'first'),
+        info="Physical packages sample",
+        attr=dict(
+            kind=dict(
+                values=["physample", "physelect", "phydrawing"],
+                remap=dict(autoremap="first"),
             ),
-        )
+        ),
     )
 
     @property
     def realkind(self):
-        return 'physample'
+        return "physample"
 
 
 class ClustContent(TextContent):
@@ -349,35 +398,35 @@ class ClustContent(TextContent):
 
 
 @use_flow_logs_stack
-@namebuilding_delete('src')
+@namebuilding_delete("src")
 class GeneralCluster(FlowResource):
     """
     Files produced by the clustering step of the LAM PE.
     """
 
     _footprint = dict(
-        info = 'Clustering stuff',
-        attr = dict(
-            kind = dict(
-                values   = ['clustering', 'clust', 'members_select'],
-                remap = dict(autoremap = 'first'),
+        info="Clustering stuff",
+        attr=dict(
+            kind=dict(
+                values=["clustering", "clust", "members_select"],
+                remap=dict(autoremap="first"),
             ),
-            clscontents = dict(
-                default = ClustContent,
+            clscontents=dict(
+                default=ClustContent,
             ),
-            nativefmt = dict(
-                values   = ['ascii', 'txt'],
-                default  = 'txt',
-                remap    = dict(ascii = 'txt'),
+            nativefmt=dict(
+                values=["ascii", "txt"],
+                default="txt",
+                remap=dict(ascii="txt"),
             ),
-            filling = dict(
-                values   = ['population', 'pop', 'members', 'full'],
-                remap    = dict(population = 'pop'),
-                default  = '',
+            filling=dict(
+                values=["population", "pop", "members", "full"],
+                remap=dict(population="pop"),
+                default="",
             ),
-        )
+        ),
     )
 
     @property
     def realkind(self):
-        return 'clustering' + '_' + self.filling
+        return "clustering" + "_" + self.filling