vortex-nwp 2.0.0b1__py3-none-any.whl → 2.0.0b2__py3-none-any.whl

vortex/layout/contexts.py

@@ -18,10 +18,10 @@ __all__ = []
 
 logger = loggers.getLogger(__name__)
 
-_RHANDLERS_OBSBOARD = 'Resources-Handlers'
-_STORES_OBSBOARD = 'Stores-Activity'
+_RHANDLERS_OBSBOARD = "Resources-Handlers"
+_STORES_OBSBOARD = "Stores-Activity"
 
-_PRESTAGE_REQ_ACTION = 'prestage_req'
+_PRESTAGE_REQ_ACTION = "prestage_req"
 
 
 # Module Interface
@@ -105,14 +105,14 @@ class ContextObserverRecorder(observer.Observer):
 
     def updobsitem(self, item, info):
         if (self._binded_context is not None) and self._binded_context.active:
-            logger.debug('Recording upd item %s', item)
-            if info['observerboard'] == _RHANDLERS_OBSBOARD:
+            logger.debug("Recording upd item %s", item)
+            if info["observerboard"] == _RHANDLERS_OBSBOARD:
                 processed_item = item.as_dict()
                 self._stages_recorder.append((processed_item, info))
                 self._tracker_recorder.update_rh(item, info)
-            elif info['observerboard'] == _STORES_OBSBOARD:
+            elif info["observerboard"] == _STORES_OBSBOARD:
                 self._tracker_recorder.update_store(item, info)
-                if info['action'] == _PRESTAGE_REQ_ACTION:
+                if info["action"] == _PRESTAGE_REQ_ACTION:
                     self._prestaging_recorder.append(info)
 
     def replay_in(self, context):
@@ -122,24 +122,33 @@ class ContextObserverRecorder(observer.Observer):
         """
         # First the stages of the sequence
         if self._stages_recorder:
-            logger.info('The recorder is replaying stages for context <%s>', context.tag)
-            for (pr_item, info) in self._stages_recorder:
+            logger.info(
+                "The recorder is replaying stages for context <%s>",
+                context.tag,
+            )
+            for pr_item, info in self._stages_recorder:
                 rh_stack = set()
                 for section in context.sequence.fastsearch(pr_item):
                     if section.rh.as_dict() == pr_item:
                         context.sequence.section_updstage(section, info)
                         rh_stack.add(section.rh)
                 for rh in rh_stack:
-                    rh.external_stage_update(info.get('stage'))
+                    rh.external_stage_update(info.get("stage"))
         # Then the localtracker
         if self._tracker_recorder is not None:
-            logger.info('The recorder is updating the LocalTracker for context <%s>', context.tag)
+            logger.info(
+                "The recorder is updating the LocalTracker for context <%s>",
+                context.tag,
+            )
             context.localtracker.append(self._tracker_recorder)
         # Finally the prestaging requests
         if self._prestaging_recorder:
-            logger.info('The recorder is replaying prestaging requests for context <%s>', context.tag)
+            logger.info(
+                "The recorder is replaying prestaging requests for context <%s>",
+                context.tag,
+            )
             for info in self._prestaging_recorder:
-                context.prestaging_hub(** info)
+                context.prestaging_hub(**info)
 
 
 class DiffHistory(PrivateHistory):
@@ -147,11 +156,17 @@ class DiffHistory(PrivateHistory):
 
     def append_record(self, rc, localcontainer, remotehandler):
         """Adds a new diff record in the current DiffHistory."""
-        rcmap = {True: 'PASS', False: 'FAIL'}
-        containerstr = (str(localcontainer) if localcontainer.is_virtual()
-                        else localcontainer.localpath())
-        self.append('{:s}: {:s} (Ref: {!s})'.format(rcmap[bool(rc)], containerstr,
-                                                    remotehandler.provider))
+        rcmap = {True: "PASS", False: "FAIL"}
+        containerstr = (
+            str(localcontainer)
+            if localcontainer.is_virtual()
+            else localcontainer.localpath()
+        )
+        self.append(
+            "{:s}: {:s} (Ref: {!s})".format(
+                rcmap[bool(rc)], containerstr, remotehandler.provider
+            )
+        )
 
     def datastore_inplace_overwrite(self, other):
         """Used by a DataStore object to refill a DiffHistory."""
@@ -163,23 +178,26 @@ class DiffHistory(PrivateHistory):
 class Context(getbytag.GetByTag, observer.Observer):
     """Physical layout of a session or task, etc."""
 
-    _tag_default = 'ctx'
+    _tag_default = "ctx"
 
-    def __init__(self, path=None, topenv=None, sequence=None, localtracker=None):
+    def __init__(
+        self, path=None, topenv=None, sequence=None, localtracker=None
+    ):
         """Initiate a new execution context."""
-        logger.debug('Context initialisation %s', self)
+        logger.debug("Context initialisation %s", self)
         if path is None:
-            logger.critical('Try to define a new context without virtual path')
-            raise ValueError('No virtual path given to new context.')
+            logger.critical("Try to define a new context without virtual path")
+            raise ValueError("No virtual path given to new context.")
         if topenv is None:
-            logger.critical('Try to define a new context without a topenv.')
-            raise ValueError('No top environment given to new context.')
-        self._env = Environment(env=topenv, verbose=topenv.verbose(),
-                                contextlock=self)
-        self._path = path + '/' + self.tag
+            logger.critical("Try to define a new context without a topenv.")
+            raise ValueError("No top environment given to new context.")
+        self._env = Environment(
+            env=topenv, verbose=topenv.verbose(), contextlock=self
+        )
+        self._path = path + "/" + self.tag
         self._session = None
         self._rundir = None
-        self._stamp = '-'.join(('vortex', 'stamp', self.tag, str(id(self))))
+        self._stamp = "-".join(("vortex", "stamp", self.tag, str(id(self))))
         self._fstore = dict()
         self._fstamps = set()
         self._wkdir = None
@@ -196,22 +214,30 @@ class Context(getbytag.GetByTag, observer.Observer):
             self._localtracker = localtracker
         else:
             # Create the localtracker within the Session's datastore
-            if self.session.datastore.check('context_localtracker', dict(path=self.path)):
-                self._localtracker = self.session.datastore.get('context_localtracker',
-                                                                dict(path=self.path))
+            if self.session.datastore.check(
+                "context_localtracker", dict(path=self.path)
+            ):
+                self._localtracker = self.session.datastore.get(
+                    "context_localtracker", dict(path=self.path)
+                )
             else:
-                self._localtracker = self.session.datastore.insert('context_localtracker',
-                                                                   dict(path=self.path),
-                                                                   dataflow.LocalTracker())
+                self._localtracker = self.session.datastore.insert(
+                    "context_localtracker",
+                    dict(path=self.path),
+                    dataflow.LocalTracker(),
+                )
 
         # Create the localtracker within the Session's datastore
-        if self.session.datastore.check('context_diffhistory', dict(path=self.path)):
-            self._dhistory = self.session.datastore.get('context_diffhistory',
-                                                        dict(path=self.path))
+        if self.session.datastore.check(
+            "context_diffhistory", dict(path=self.path)
+        ):
+            self._dhistory = self.session.datastore.get(
+                "context_diffhistory", dict(path=self.path)
+            )
         else:
-            self._dhistory = self.session.datastore.insert('context_diffhistory',
-                                                           dict(path=self.path),
-                                                           DiffHistory())
+            self._dhistory = self.session.datastore.insert(
+                "context_diffhistory", dict(path=self.path), DiffHistory()
+            )
 
         observer.get(tag=_RHANDLERS_OBSBOARD).register(self)
         observer.get(tag=_STORES_OBSBOARD).register(self)
@@ -223,7 +249,9 @@ class Context(getbytag.GetByTag, observer.Observer):
 
     def _enforce_active(self):
         if not self.active:
-            raise RuntimeError("It's not allowed to call this method on an inactive Context.")
+            raise RuntimeError(
+                "It's not allowed to call this method on an inactive Context."
+            )
 
     def newobsitem(self, item, info):
         """
@@ -231,9 +259,14 @@ class Context(getbytag.GetByTag, observer.Observer):
         Register a new section in void active context with the resource handler ``item``.
         """
         if self.active:
-            logger.debug('Notified %s new item of class %s and id %s', self, item.__class__, id(item))
-            if self._record and info['observerboard'] == _RHANDLERS_OBSBOARD:
-                self._sequence.section(rh=item, stage='load')
+            logger.debug(
+                "Notified %s new item of class %s and id %s",
+                self,
+                item.__class__,
+                id(item),
+            )
+            if self._record and info["observerboard"] == _RHANDLERS_OBSBOARD:
+                self._sequence.section(rh=item, stage="load")
 
     def updobsitem(self, item, info):
         """
@@ -241,21 +274,21 @@ class Context(getbytag.GetByTag, observer.Observer):
         Track the new stage of the section containing the resource handler ``item``.
         """
         if self.active:
-            logger.debug('Notified %s upd item %s', self, item)
-            if info['observerboard'] == _RHANDLERS_OBSBOARD:
-                if 'stage' in info:
+            logger.debug("Notified %s upd item %s", self, item)
+            if info["observerboard"] == _RHANDLERS_OBSBOARD:
+                if "stage" in info:
                     # Update the sequence
                     for section in self._sequence.fastsearch(item):
                         if section.rh is item:
                             self._sequence.section_updstage(section, info)
-                if ('stage' in info) or ('clear' in info):
+                if ("stage" in info) or ("clear" in info):
                     # Update the local tracker
                     self._localtracker.update_rh(item, info)
-            elif info['observerboard'] == _STORES_OBSBOARD:
+            elif info["observerboard"] == _STORES_OBSBOARD:
                 # Update the local tracker
                 self._localtracker.update_store(item, info)
-                if info['action'] == _PRESTAGE_REQ_ACTION:
-                    self.prestaging_hub.record(** info)
+                if info["action"] == _PRESTAGE_REQ_ACTION:
+                    self.prestaging_hub.record(**info)
 
     def get_recorder(self):
         """Return a :obj:`ContextObserverRecorder` object recording the changes in this Context."""
@@ -275,7 +308,9 @@ class Context(getbytag.GetByTag, observer.Observer):
         # It's not possible to activate a Context that lies outside the current
         # session
         if not self.session.active:
-            raise RuntimeError("It's not allowed to switch to a Context that belongs to an inactive session")
+            raise RuntimeError(
+                "It's not allowed to switch to a Context that belongs to an inactive session"
+            )
 
     def focus_gain_hook(self):
         super().focus_gain_hook()
@@ -297,7 +332,7 @@ class Context(getbytag.GetByTag, observer.Observer):
             obj.catch_focus()
             return obj
         else:
-            logger.error('Try to switch to an undefined context: %s', tag)
+            logger.error("Try to switch to an undefined context: %s", tag)
             return None
 
     def activate(self):
@@ -314,7 +349,10 @@ class Context(getbytag.GetByTag, observer.Observer):
         """Return the session bound to the current virtual context path."""
         if self._session is None:
             from vortex import sessions
-            self._session = sessions.get(tag=[x for x in self.path.split('/') if x][0])
+
+            self._session = sessions.get(
+                tag=[x for x in self.path.split("/") if x][0]
+            )
         return self._session
 
     def _get_rundir(self):
@@ -324,12 +362,20 @@ class Context(getbytag.GetByTag, observer.Observer):
     def _set_rundir(self, path):
         """Set a new rundir."""
         if self._rundir:
-            logger.warning('Context <%s> is changing its working directory <%s>', self.tag, self._rundir)
+            logger.warning(
+                "Context <%s> is changing its working directory <%s>",
+                self.tag,
+                self._rundir,
+            )
         if self.system.path.isdir(path):
             self._rundir = path
-            logger.info('Context <%s> set rundir <%s>', self.tag, self._rundir)
+            logger.info("Context <%s> set rundir <%s>", self.tag, self._rundir)
         else:
-            logger.error('Try to change context <%s> to invalid path <%s>', self.tag, path)
+            logger.error(
+                "Try to change context <%s> to invalid path <%s>",
+                self.tag,
+                path,
+            )
 
     rundir = property(_get_rundir, _set_rundir)
 
@@ -337,7 +383,7 @@ class Context(getbytag.GetByTag, observer.Observer):
         """Change directory to the one associated to that context."""
         self._enforce_active()
         if self.rundir is None:
-            subpath = self.path.replace(self.session.path, '', 1)
+            subpath = self.path.replace(self.session.path, "", 1)
             self._rundir = self.session.rundir + subpath
         self.system.cd(self.rundir, create=True)
         self._wkdir = self.rundir
@@ -357,9 +403,11 @@ class Context(getbytag.GetByTag, observer.Observer):
         see :class:`vortex.tools.prestaging` for more details.
         """
         if self._prestaging_hub is None:
-            self._prestaging_hub = vortex.tools.prestaging.get_hub(tag='contextbound_{:s}'.format(self.tag),
-                                                                   sh=self.system,
-                                                                   email=self.session.glove.email)
+            self._prestaging_hub = vortex.tools.prestaging.get_hub(
+                tag="contextbound_{:s}".format(self.tag),
+                sh=self.system,
+                email=self.session.glove.email,
+            )
         return self._prestaging_hub
 
     @property
@@ -369,8 +417,9 @@ class Context(getbytag.GetByTag, observer.Observer):
         see :class:`vortex.tools.delayedactions` for more details.
         """
         if self._delayedactions_hub is None:
-            self._delayedactions_hub = PrivateDelayedActionsHub(sh=self.system,
-                                                                contextrundir=self.rundir)
+            self._delayedactions_hub = PrivateDelayedActionsHub(
+                sh=self.system, contextrundir=self.rundir
+            )
         return self._delayedactions_hub
 
     @property
@@ -395,8 +444,12 @@ class Context(getbytag.GetByTag, observer.Observer):
     @property
     def subcontexts(self):
         """The current contexts virtually included in the current one."""
-        rootpath = self.path + '/'
-        return [x for x in self.__class__.tag_values() if x.path.startswith(rootpath)]
+        rootpath = self.path + "/"
+        return [
+            x
+            for x in self.__class__.tag_values()
+            if x.path.startswith(rootpath)
+        ]
 
     def newcontext(self, name, focus=False):
         """
@@ -405,17 +458,19 @@ class Context(getbytag.GetByTag, observer.Observer):
         as well as the default ``focus``.
         """
         if name in self.__class__.tag_keys():
-            raise RuntimeError("A context with tag={!s} already exists.".format(name))
+            raise RuntimeError(
+                "A context with tag={!s} already exists.".format(name)
+            )
         newctx = self.__class__(tag=name, topenv=self.env, path=self.path)
         if focus:
             self.__class__.set_focus(newctx)
         return newctx
 
-    def stamp(self, tag='default'):
+    def stamp(self, tag="default"):
         """Return a stamp name that could be used for any generic purpose."""
-        return self._stamp + '.' + str(tag)
+        return self._stamp + "." + str(tag)
 
-    def fstrack_stamp(self, tag='default'):
+    def fstrack_stamp(self, tag="default"):
         """Set a stamp to track changes on the filesystem."""
         self._enforce_active()
         stamp = self.stamp(tag)
@@ -423,7 +478,7 @@ class Context(getbytag.GetByTag, observer.Observer):
         self.system.touch(stamp)
         self._fstore[stamp] = set(self.system.ffind())
 
-    def fstrack_check(self, tag='default'):
+    def fstrack_check(self, tag="default"):
         """
         Return a anonymous dictionary with for the each key, the list of entries
         in the file system that are concerned since the last associated ``tag`` stamp.
@@ -432,14 +487,18 @@ class Context(getbytag.GetByTag, observer.Observer):
         self._enforce_active()
         stamp = self.stamp(tag)
         if not self.system.path.exists(stamp):
-            logger.warning('Missing stamp %s', stamp)
+            logger.warning("Missing stamp %s", stamp)
             return None
         ffinded = set(self.system.ffind())
         bkuptrace = self.system.trace
         self.system.trace = False
         fscheck = Tracker(self._fstore[stamp], ffinded)
         stroot = self.system.stat(stamp)
-        fscheck.updated = [f for f in fscheck.unchanged if self.system.stat(f).st_mtime > stroot.st_mtime]
+        fscheck.updated = [
+            f
+            for f in fscheck.unchanged
+            if self.system.stat(f).st_mtime > stroot.st_mtime
+        ]
         self.system.trace = bkuptrace
         return fscheck
 
@@ -456,35 +515,42 @@ class Context(getbytag.GetByTag, observer.Observer):
         """Activate automatic recording of section while loading resource handlers."""
         self._record = True
 
-    def clear_promises(self, netloc='promise.cache.fr', scheme='vortex', storeoptions=None):
+    def clear_promises(
+        self, netloc="promise.cache.fr", scheme="vortex", storeoptions=None
+    ):
         """Remove all promises that have been made in this context.
 
         :param netloc: Netloc of the promise's cache store to clean up
         :param scheme: Scheme of the promise's cache store to clean up
         :param storeoptions: Option dictionary passed to the store (may be None)
         """
-        self.system.header('Clear promises for {}://{} in context {}'.format(scheme, netloc, self.path))
+        self.system.header(
+            "Clear promises for {}://{} in context {}".format(
+                scheme, netloc, self.path
+            )
+        )
         skeleton = dict(scheme=scheme, netloc=netloc)
-        promises = self.localtracker.grep_uri('put', skeleton)
+        promises = self.localtracker.grep_uri("put", skeleton)
         if promises:
-            logger.info('Some promises are left pending...')
+            logger.info("Some promises are left pending...")
             if storeoptions is None:
                 storeoptions = dict()
-            store = footprints.proxy.store(scheme=scheme, netloc=netloc,
-                                           **storeoptions)
+            store = footprints.proxy.store(
+                scheme=scheme, netloc=netloc, **storeoptions
+            )
             for promise in [pr.copy() for pr in promises]:
-                del promise['scheme']
-                del promise['netloc']
+                del promise["scheme"]
+                del promise["netloc"]
                 store.delete(promise)
         else:
-            logger.info('No promises were left pending.')
+            logger.info("No promises were left pending.")
 
     def clear_stamps(self):
         """Remove local context stamps."""
         if self._fstore:
             fstamps = list(self._fstamps)
             self.system.rmall(*fstamps)
-            logger.info('Removing context stamps %s', fstamps)
+            logger.info("Removing context stamps %s", fstamps)
             self._fstore = dict()
             self._fstamps = set()
 
@@ -503,7 +569,7 @@ class Context(getbytag.GetByTag, observer.Observer):
         try:
             self.clear()
         except TypeError:
-            logger.error('Could not clear local context <%s>', self.tag)
+            logger.error("Could not clear local context <%s>", self.tag)
         # Nullify some variable to help during garbage collection
         self._prestaging_hub = None
         if self._delayedactions_hub: