vortex-nwp 2.0.0b1__py3-none-any.whl

vortex/data/executables.py

@@ -0,0 +1,284 @@
+"""
+Abstract for any "Resource" class that deal with some kind of :class:`Script` or
+:class:`Binary` executable.
+
+Mode specialised version are also provided for various physical models:
+
+    * :class:`NWPModel`;
+    * :class:`OceanographicModel`;
+    * :class:`SurfaceModel`;
+    * :class:`ChemistryModel`.
+
+"""
+
+from bronx.syntax import mktuple
+import footprints
+
+from .resources import Resource
+from vortex.syntax.stdattrs import model_deco
+from vortex.util.config import JacketConfigParser
+
+#: No automatic export
+__all__ = []
+
+
+class Jacket:
+    """The class definition of in and out resources from a given executable."""
+    def __init__(self, afile=None):
+        if afile:
+            self.config = JacketConfigParser(afile)
+            self.virtual = False
+        else:
+            self.virtual = True
+        self._initfile = afile
+
+    def as_dump(self):
+        return "file={!r}".format(self._initfile)
+
+    def export_dict(self):
+        return self._initfile
+
+
+class Executable(Resource):
+    """Abstract class for resources that could be executed."""
+
+    _abstract = True
+    _footprint = dict(
+        info = 'Miscellaneaous executable resource',
+        attr = dict(
+            cycle = dict(
+                info     = "Any kind of cycle name",
+                optional = True,
+                default  = None,
+                access   = 'rwx',
+            ),
+            kind = dict(
+                info        = "The resource's kind.",
+                doc_zorder  = 90,
+            ),
+            nativefmt = dict(
+                doc_visibility = footprints.doc.visibility.GURU,
+            ),
+            clscontents = dict(
+                doc_visibility = footprints.doc.visibility.GURU,
+            )
+        )
+    )
+
+    def stdin_text(self, **opts):
+        """Abstract method."""
+        return None
+
+
+class Script(Executable):
+    """Basic interpreted executable associated to a specific language."""
+
+    _footprint = dict(
+        attr = dict(
+            rawopts = dict(
+                info     = "Options that will be passed directly to the script",
+                optional = True,
+                default  = '',
+            ),
+            language = dict(
+                info     = "The programming language",
+                values   = ['perl', 'python', 'ksh', 'bash', 'sh', 'awk'],
+            ),
+            kind = dict(
+                optional = True,
+                default  = 'script',
+                values   = ['script'],
+            )
+        ),
+        fastkeys = {'language'},
+    )
+
+    @property
+    def realkind(self):
+        return 'script'
+
+    def command_line(self, **opts):
+        """Returns optional attribute :attr:`rawopts`."""
+        if self.rawopts is None:
+            return ''
+        else:
+            return self.rawopts
+
+
+class GnuScript(Executable):
+    """Basic interpreted executable with standard command line arguments."""
+
+    _footprint = dict(
+        attr = dict(
+            language = dict(
+                info     = "The programming language",
+                values   = ['perl', 'python', 'ksh', 'bash', 'sh', 'awk'],
+            ),
+            kind = dict(
+                default  = 'gnuscript',
+                values   = ['gnuscript', 'argscript'],
+            )
+        ),
+        fastkeys = {'kind', 'language'},
+    )
+
+    @property
+    def realkind(self):
+        return 'script'
+
+    def command_line(self, **opts):
+        """Returns a blank separated list of options."""
+        return ' '.join(['--' + k + ' ' + ' '.join([str(x)
+                                                    for x in mktuple(v)])
+                         for k, v in opts.items()])
+
+
+class Binary(Executable):
+    """Basic compiled executable."""
+
+    _abstract = True
+    _footprint = dict(
+        attr = dict(
+            static = dict(
+                info     = "Statically linked binary.",
+                type     = bool,
+                optional = True,
+                doc_visibility  = footprints.doc.visibility.ADVANCED,
+            ),
+            jacket = dict(
+                type            = Jacket,
+                optional        = True,
+                default         = Jacket(),
+                doc_visibility  = footprints.doc.visibility.ADVANCED,
+            )
+        )
+    )
+
+    @property
+    def realkind(self):
+        return 'binary'
+
+    def guess_binary_sources(self, provider):  # @UnusedVariable
+        """A list of path that contains source files (for debugging purposes)."""
+        return []
+
+
+class BlackBox(Binary):
+    """Binary resource with explicit command line options."""
+
+    _footprint = dict(
+        attr = dict(
+            binopts = dict(
+                info     = "Options that will be passed directly to the binary",
+                optional = True,
+                default  = '',
+            ),
+            kind = dict(
+                values   = ['binbox', 'blackbox'],
+                remap    = dict(binbox = 'blackbox'),
+            ),
+        )
+    )
+
+    def command_line(self, **opts):
+        """Returns current attribute :attr:`binopts`."""
+        return self.binopts
+
+
+class NWPModel(Binary):
+    """Base class for any Numerical Weather Prediction Model."""
+
+    _abstract = True
+    _footprint = [
+        model_deco,
+        dict(
+            info = 'NWP Model',
+            attr = dict(
+                kind = dict(
+                    values = ['nwpmodel']
+                )
+            )
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return 'nwpmodel'
+
+    def command_line(self, **opts):
+        """Abstract method."""
+        return ''
+
+
+class OceanographicModel(Binary):
+    """Base class for any Oceanographic Model."""
+
+    _abstract = True
+    _footprint = [
+        model_deco,
+        dict(
+            info = 'Oceanographic Model',
+            attr = dict(
+                kind = dict(
+                    values = ['oceanmodel']
+                )
+            )
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return 'oceanmodel'
+
+    def command_line(self, **opts):
+        """Abstract method."""
+        return ''
+
+
+class SurfaceModel(Binary):
+
+    _abstract = True
+    _footprint = [
+        model_deco,
+        dict(
+            info = 'Model used for the Safran-Surfex-Mepra chain.',
+            attr = dict(
+                kind  = dict(
+                    values = ['surfacemodel', 'snowmodel'],
+                    remap = dict(autoremap = 'first'),
+                ),
+            ),
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return 'surfacemodel'
+
+    def command_line(self, **opts):
+        """Abstract method."""
+        return ''
+
+
+class ChemistryModel(Binary):
+
+    _abstract = True
+    _footprint = [
+        model_deco,
+        dict(
+            info = 'Base class for Chemistry models.',
+            attr = dict(
+                kind  = dict(
+                    values = ['chemistrymodel'],
+                ),
+            ),
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return 'chemistrymodel'
+
+    def command_line(self, **opts):
+        """Abstract method."""
+        return ''

vortex/data/flow.py

@@ -0,0 +1,113 @@
+"""
+Abstract class for any flow-dependant "Resource".
+
+By "flow-dependant", we mean a "Resource" that has to be described by ``model``,
+``date`` and ``cutoff`` attributes. See :class:`FlowResource`
+
+The :class:`GeoFlowResource` abstract class is to be used for flow-dependant
+resources associated with an horizontal geometry.
+"""
+
+from .resources import Resource
+from .geometries import hgeometry_deco
+from .contents import FormatAdapter
+
+from vortex.syntax.stdattrs import model_deco, date_deco, dateperiod_deco, cutoff_deco, term_deco
+from vortex.syntax.stddeco import namebuilding_insert
+
+#: No automatic export
+__all__ = []
+
+
+class FlowResource(Resource):
+    """Abstract resource bound to a model, a date and a cutoff."""
+
+    _abstract = True
+    _footprint = [model_deco, date_deco, cutoff_deco]
+
+
+@namebuilding_insert('radical', lambda s: s.nickname)
+class UnknownFlow(FlowResource):
+
+    _footprint = [
+        term_deco,
+        dict(
+            info = 'Unknown assumed NWP Flow-Resource (development only !)',
+            attr = dict(
+                unknownflow = dict(
+                    info = "Activate the unknown flow resource",
+                    type = bool
+                ),
+                term = dict(
+                    optional = True,
+                ),
+                nickname = dict(
+                    info = "The string that serves the purpose of Vortex's basename radical",
+                    optional = True,
+                    default = 'unknown'
+                ),
+                clscontents = dict(
+                    default = FormatAdapter
+                ),
+            ),
+            fastkeys = {'unknownflow'},
+        )
+    ]
+
+    _extension_remap = {k: None for k in ('auto', 'autoconfig', 'foo', 'unknown')}
+
+    def olive_basename(self):
+        target = self.nickname
+        if self.term is not None:
+            target += '+' + self.term.fmth
+        return target
+
+
+class GeoFlowResource(FlowResource):
+    """Class which is a :class:`FlowResource` bound to a geometry."""
+
+    _abstract = True
+    _footprint = [
+        hgeometry_deco,
+        dict(
+            attr = dict(
+                clscontents = dict(
+                    default = FormatAdapter,
+                ),
+            )
+        )
+    ]
+
+
+class PeriodFlowResource(Resource):
+    """Abstract resource bound to a model, a begindate, enddate and a cutoff."""
+
+    _abstract = True
+    _footprint = [model_deco, dateperiod_deco, cutoff_deco]
+
+    _footprint = [
+        model_deco, dateperiod_deco, cutoff_deco,
+        dict(
+            attr = dict(
+                cutoff = dict(
+                    optional = True,
+                ),
+            )
+        )
+    ]
+
+
+class GeoPeriodFlowResource(PeriodFlowResource):
+    """Class which is a :class:`PeriodFlowResource` bound to a geometry."""
+
+    _abstract = True
+    _footprint = [
+        hgeometry_deco,
+        dict(
+            attr = dict(
+                clscontents = dict(
+                    default = FormatAdapter,
+                ),
+            )
+        )
+    ]