vortex-nwp 2.0.0b1__py3-none-any.whl

vortex/gloves.py

@@ -0,0 +1,282 @@
+"""
+GLObal Versatile Environment classes are responsible for session-wide
+configuration (username, emil adress, ...)
+"""
+
+from bronx.fancies import loggers
+import footprints
+
+from vortex.tools.env import Environment
+
+#: No automatic export
+__all__ = []
+
+logger = loggers.getLogger(__name__)
+
+
+class Glove(footprints.FootprintBase):
+    """Base class for GLObal Versatile Environment."""
+
+    _abstract = True
+    _collector = ('glove',)
+    _footprint = dict(
+        info = 'Abstract glove',
+        attr = dict(
+            email = dict(
+                alias    = ['address'],
+                optional = True,
+                default  = Environment(active=False)['email'],
+                access   = 'rwx',
+            ),
+            vapp = dict(
+                optional = True,
+                default  = 'play',
+                access   = 'rwx',
+            ),
+            vconf = dict(
+                optional = True,
+                default  = 'sandbox',
+                access   = 'rwx',
+            ),
+            tag = dict(
+                optional = True,
+                default  = 'default',
+            ),
+            user = dict(
+                alias    = ('logname', 'username'),
+                optional = True,
+                default  = Environment(active=False)['logname']
+            ),
+            profile = dict(
+                alias    = ('kind', 'membership'),
+                values   = ['oper', 'dble', 'test', 'research', 'tourist'],
+                remap    = dict(tourist = 'research')
+            )
+        )
+    )
+
+    def __init__(self, *args, **kw):
+        logger.debug('Glove abstract %s init', self.__class__)
+        super().__init__(*args, **kw)
+        self._rmdepthmin = 3
+        self._siteroot = None
+        self._siteconf = None
+        self._sitedoc = None
+        self._sitesrc = None
+        self._ftdhost = None
+        self._ftduser = None
+        self._ftusers = dict()
+
+    @property
+    def realkind(self):
+        """Returns the litteral string identity of the current glove."""
+        return 'glove'
+
+    @property
+    def configrc(self):
+        """Returns the path of the default directory where ``.ini`` files are stored."""
+        return Environment(active=False).HOME + '/.vortexrc'
+
+    @property
+    def siteroot(self):
+        """Returns the path of the vortex install directory."""
+        if not self._siteroot:
+            self._siteroot = '/'.join(__file__.split('/')[0:-3])
+        return self._siteroot
+
+    @property
+    def siteconf(self):
+        """Returns the path of the default directory where ``.ini`` files are stored."""
+        if not self._siteconf:
+            self._siteconf = '/'.join((self.siteroot, 'conf'))
+        return self._siteconf
+
+    @property
+    def sitedoc(self):
+        """Returns the path of the default directory where ``.ini`` files are stored."""
+        if not self._sitedoc:
+            self._sitedoc = '/'.join((self.siteroot, 'sphinx'))
+        return self._sitedoc
+
+    @property
+    def sitesrc(self):
+        """Returns the path of the default directory where ``.ini`` files are stored."""
+        if not self._sitesrc:
+            self._sitesrc = (
+                '/'.join((self.siteroot, 'site')),
+                '/'.join((self.siteroot, 'src'))
+            )
+        return self._sitesrc
+
+    def setenv(self, app=None, conf=None):
+        """Change ``vapp`` or/and ``vconf`` in one call."""
+        if app is not None:
+            self.vapp = app
+        if conf is not None:
+            self.vconf = conf
+        return (self.vapp, self.vconf)
+
+    def setmail(self, domain=None):
+        """Refresh actual email with current username and provided ``domain``."""
+        if domain is None:
+            from vortex import sessions
+            domain = sessions.system().getfqdn()
+        return '@'.join((self.user, domain))
+
+    @property
+    def xmail(self):
+        if self.email is None:
+            return self.setmail()
+        else:
+            return self.email
+
+    def safedirs(self):
+        """Protected paths as a list a tuples (path, depth)."""
+        e = Environment(active=False)
+        return [(e.HOME, 2), (e.TMPDIR, 1)]
+
+    def setftuser(self, user, hostname=None):
+        """Register a default username for *hostname*.
+
+        If *hostname* is omitted the default username is set.
+        """
+        if hostname is None:
+            self._ftduser = user
+        else:
+            if not user:
+                del self._ftusers[hostname]
+            else:
+                self._ftusers[hostname] = user
+
+    def getftuser(self, hostname, defaults_to_user=True):
+        """Get the default username for a given *hostname*."""
+        if self._ftusers.get(hostname, None):
+            return self._ftusers[hostname]
+        else:
+            if self._ftduser:
+                return self._ftduser
+            else:
+                return Environment.current().get('VORTEX_ARCHIVE_USER',
+                                                 self.user if defaults_to_user else None)
+
+    def _get_default_fthost(self):
+        if self._ftdhost:
+            return self._ftdhost
+        else:
+            return Environment.current().get('VORTEX_ARCHIVE_HOST', None)
+
+    def _set_default_fthost(self, value):
+        self._ftdhost = value
+
+    def _del_default_fthost(self):
+        self._ftdhost = None
+
+    default_fthost = property(_get_default_fthost, _set_default_fthost, _del_default_fthost)
+
+    def describeftsettings(self, indent='+ '):
+        """Returns a printable description of default file transfert usernames."""
+        card = "\n".join(
+            ['{0}{3:48s} = {4:s}', ] +
+            ['{0}{1:48s} = {2:s}', ] +
+            (['{0}Host specific FT users:', ] if self._ftusers else []) +
+            ['{0}' + '  {:46s} = {:s}'.format(k, v) for k, v in self._ftusers.items() if v]
+        ).format(indent,
+                 'Default FT User', str(self._ftduser),
+                 'Default FT Host', str(self._ftdhost))
+        return card
+
+    def idcard(self, indent='+ '):
+        """Returns a printable description of the current glove."""
+        card = "\n".join((
+            '{0}User     = {1:s}',
+            '{0}Profile  = {2!s}',
+            '{0}Vapp     = {3:s}',
+            '{0}Vconf    = {4:s}',
+            '{0}Configrc = {5:s}'
+        )).format(
+            indent,
+            self.user, self.profile, self.vapp, self.vconf, self.configrc
+        )
+        return card
+
+
+class ResearchGlove(Glove):
+    """
+    The default glove as long as you do not need operational privileges.
+    Optional arguments are:
+
+    * mail
+    * profile (default is research)
+    """
+
+    _explicit = False
+    _footprint = dict(
+        info = 'Research glove',
+        attr = dict(
+            profile = dict(
+                optional = True,
+                values   = ['research', 'tourist'],
+                default  = 'research',
+            )
+        )
+    )
+
+    @property
+    def realkind(self):
+        return 'research'
+
+
+class OperGlove(Glove):
+    """
+    The default glove if you need operational privileges.
+    Mandatory arguments are:
+
+    * user
+    * profile
+    """
+
+    _footprint = dict(
+        info = 'Operational glove',
+        attr = dict(
+            user = dict(
+                values   = ['mxpt001']
+            ),
+            profile = dict(
+                optional = False,
+                values   = ['oper', 'dble', 'test', 'miroir'],
+            )
+        )
+    )
+
+    @property
+    def realkind(self):
+        return 'opuser'
+
+
+class UnitTestGlove(ResearchGlove):
+    """A very special glove for unit-tests."""
+
+    _footprint = dict(
+        info = 'Unit-Test Glove',
+        attr = dict(
+            profile = dict(
+                optional = False,
+                values   = ['utest'],
+            ),
+            test_configrc = dict(
+                optional = False,
+            ),
+            test_siteroot = dict(
+                optional = False,
+            ),
+        )
+    )
+
+    def __init__(self, *args, **kw):
+        super().__init__(*args, **kw)
+        self._siteroot = self.test_siteroot
+
+    @property
+    def configrc(self):
+        """Returns the path of the default directory where ``.ini`` files are stored."""
+        return self.test_configrc

vortex/layout/__init__.py

@@ -0,0 +1,27 @@
+"""
+Package dealing with various aspects of the VORTEX session organisation/layout.
+
+It provides modules to keep track of all the input/output data handled during
+a VORTEX session:
+
+    * the :mod:`dataflow` module defines the :class:`~dataflow.Section` class
+      and all the necessary class to gather and manipulate :class:`~dataflow.Section`
+      objects ;
+    * the :mod:`contexts` module is dedicated to the :class:`~contexts.Context`
+      class that provide a logical separation within VORTEX sessions. It mantains
+      the list of sections and environment variables ;
+    * the :mod:`monitor` module defines utility classes to monitor the state of an
+      ensemble of :class:`~dataflow.Section` objects.
+
+It also provides modules that allows to create "standard" VORTEX's jobs:
+
+    * the :mod:`nodes` modules defines a bunch of classes that helps to organise
+      VORTEX jobs (creating tasks, families of tasks, ...);
+    * the :mod:`jobs` module focuses on the actual job generation and initialisation.
+
+"""
+
+#: No automatic export
+__all__ = []
+
+__tocinfoline__ = 'Package that helps organising a VORTEX session.'

vortex/layout/appconf.py

@@ -0,0 +1,109 @@
+"""
+This modules defines objects that any kind of configuration data
+for jobs and nodes.
+"""
+
+import collections.abc
+import re
+
+from bronx.syntax.decorators import secure_getattr
+
+from vortex.util.config import AppConfigStringDecoder
+
+
+class ConfigSet(collections.abc.MutableMapping):
+    """Simple struct-like object that acts as a lower case dictionary.
+
+    Two syntax are available to add a new entry in a :class:`ConfigSet` object:
+
+    * ``ConfigSetObject.key = value``
+    * ``ConfigSetObject[key] = value``
+
+    Prior to being retrieved, entries are passed to a
+    :class:`vortex.util.config.AppConfigStringDecoder` object. It allows to
+    describe complex data types (see the :class:`vortex.util.config.AppConfigStringDecoder`
+    class documentation).
+
+    Some extra features are added on top of the
+    :class:`vortex.util.config.AppConfigStringDecoder` capabilities:
+
+    * If ``key`` ends with *_map*, ``value`` will be seen as a dictionary
+    * If ``key`` contains the words *geometry* or *geometries*, ``value``
+      will be converted to a :class:`vortex.data.geometries.Geometry` object
+    * If ``key`` ends with *_range*, ``value`` will be passed to the
+      :func:`footprints.util.rangex` function
+
+    """
+
+    def __init__(self, *kargs, **kwargs):
+        super().__init__(*kargs, **kwargs)
+        self.__dict__['_internal'] = dict()
+        self.__dict__['_confdecoder'] = AppConfigStringDecoder(substitution_cb=self._internal.get)
+
+    @staticmethod
+    def _remap_key(key):
+        return key.lower()
+
+    def __iter__(self):
+        for k in self._internal.keys():
+            yield self._remap_key(k)
+
+    def __getitem__(self, key):
+        return self._confdecoder(self._internal[self._remap_key(key)])
+
+    def __setitem__(self, key, value):
+        if value is not None and isinstance(value, str):
+            # Support for old style dictionaries (compatibility)
+            if (key.endswith('_map') and not re.match(r'^dict\(.*\)$', value) and
+                    not re.match(r'^\w+\(dict\(.*\)\)$', value)):
+                key = key[:-4]
+                if re.match(r'^\w+\(.*\)$', value):
+                    value = re.sub(r'^(\w+)\((.*)\)$', r'\1(dict(\2))', value)
+                else:
+                    value = 'dict(' + value + ')'
+            # Support for geometries (compatibility)
+            if (('geometry' in key or 'geometries' in key) and
+                    (not re.match(r'^geometry\(.*\)$', value, flags=re.IGNORECASE))):
+                value = 'geometry(' + value + ')'
+            # Support for oldstyle range (compatibility)
+            if (key.endswith('_range') and not re.match(r'^rangex\(.*\)$', value) and
+                    not re.match(r'^\w+\(rangex\(.*\)\)$', value)):
+                key = key[:-6]
+                if re.match(r'^\w+\(.*\)$', value):
+                    value = re.sub(r'^(\w+)\((.*)\)$', r'\1(rangex(\2))', value)
+                else:
+                    value = 'rangex(' + value + ')'
+        self._internal[self._remap_key(key)] = value
+
+    def __delitem__(self, key):
+        del self._internal[self._remap_key(key)]
+
+    def __len__(self):
+        return len(self._internal)
+
+    def clear(self):
+        self._internal.clear()
+
+    def __contains__(self, key):
+        return self._remap_key(key) in self._internal
+
+    @secure_getattr
+    def __getattr__(self, key):
+        if key in self:
+            return self[key]
+        else:
+            raise AttributeError('No such parameter <' + key + '>')
+
+    def __setattr__(self, attr, value):
+        self[attr] = value
+
+    def __delattr__(self, key):
+        if key in self:
+            del self[key]
+        else:
+            raise AttributeError('No such parameter <' + key + '>')
+
+    def copy(self):
+        newobj = self.__class__()
+        newobj.update(**self._internal)
+        return newobj