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

vortex/__init__.py

@@ -20,45 +20,75 @@ of the very high level interface defined in the :mod:`vortex.toolbox` module is
 strongly advised.
 """
 
-__version__ = '2.0.0b1'
-__prompt__ = 'Vortex v-' + __version__ + ':'
+import atexit
+import sys
+import os
+
+# importlib.metadata included in stdlib from 3.8 onwards.
+# For older versions, import third-party importlib_metadata
+if sys.version_info < (3, 8):
+    import importlib_metadata
+    import importlib
+
+    importlib.metadata = importlib_metadata
+else:
+    import importlib.metadata
 
-__nextversion__ = '2.0.0b2'
-__tocinfoline__ = 'VORTEX core package'
+from bronx.fancies import loggers as bloggers
+import bronx.stdtypes.date
+
+import footprints
+
+# Populate a fake proxy module with footprints shortcuts
+from . import proxy, tools, sessions, config
+
+# vortex user API
+from .toolbox import input as input
+from .toolbox import output as output
+from .toolbox import executable as executable
+from .toolbox import promise as promise
+from .toolbox import diff as diff
+from .toolbox import defaults as defaults
+from .toolbox import algo as task
+
+from . import nwp as nwp  # footprints import
+
+__version__ = "2.1.0"
+__prompt__ = "Vortex v-" + __version__ + ":"
+
+__nextversion__ = "2.1.1"
+__tocinfoline__ = "VORTEX core package"
 
 __all__ = [
-    "input", "output", "executable", "task", "promise", "diff",
+    "input",
+    "output",
+    "executable",
+    "task",
+    "promise",
+    "diff",
 ]
 
 # Set vortex specific priorities for footprints usage
 
-from bronx.fancies import loggers as bloggers
 
-import footprints
-footprints.priorities.set_before('debug', 'olive', 'oper')
+footprints.priorities.set_before("debug", "olive", "oper")
 
 # Set a root logging mechanism for vortex
 
 #: Shortcut to Vortex's root logger
-logger = bloggers.getLogger('vortex')
-
-# Populate a fake proxy module with footprints shortcuts
+logger = bloggers.getLogger("vortex")
 
-from . import proxy
 setup = footprints.config.get()
 setup.add_proxy(proxy)
 proxy.cat = footprints.proxy.cat
 proxy.objects = footprints.proxy.objects
 
 # Set a background environment and a root session
-
-from . import tools
-from . import sessions
-from . import config
-
 rootenv = tools.env.Environment(active=True)
 
-rs = sessions.get(active=True, topenv=rootenv, glove=sessions.getglove(), prompt=__prompt__)
+rs = sessions.get(
+    active=True, topenv=rootenv, glove=sessions.getglove(), prompt=__prompt__
+)
 if rs.system().systems_reload():
     rs.system(refill=True)
 del rs
@@ -70,8 +100,7 @@ def vortexfpdefaults():
     """Return actual glove, according to current environment."""
     cur_session = sessions.current()
     return dict(
-        glove=cur_session.glove,
-        systemtarget=cur_session.sh.default_target
+        glove=cur_session.glove, systemtarget=cur_session.sh.default_target
     )
 
 
@@ -82,54 +111,53 @@ footprints.setup.callback = vortexfpdefaults
 ticket = sessions.get
 sh = sessions.system
 
-# Specific toolbox exceptions
-
-
-class VortexForceComplete(Exception):
-    """Exception for handling fast exit mecanisms."""
-    pass
-
-# If a config file can be found in current dir, load it
-config.load_config()
+# If a config file can be found in current dir, load it else load .vortex.d/vortex.toml
+if os.path.isfile("vortex.toml"):
+    config.load_config("vortex.toml")
+else:
+    config.load_config(os.environ["HOME"] + "/.vortex.d/vortex.toml")
 
 # Load some superstars sub-packages
-from .toolbox import (
-    input,
-    output,
-    executable,
-    promise,
-    diff,
-    defaults,
-)
-from .toolbox import algo as task
-from . import nwp
+
 
 # Now load plugins that have been installed with the
 # 'vtx' entry point.  Order matters: since plugins
 # will typically depend on objects defined in 'vortex'
 # and 'vortex.nwp', these must be imported /before/
 # loading plugins.
-from importlib.metadata import entry_points
-for plugin in entry_points(group='vtx'):
+for plugin in importlib.metadata.entry_points(group="vtx"):
     plugin.load()
     print(f"Loaded plugin {plugin.name}")
 
-# Register proper vortex exit before the end of interpreter session
 
-import bronx.stdtypes.date
+# Register proper vortex exit before the end of interpreter session
 def complete():
     sessions.exit()
     import multiprocessing
+
     for kid in multiprocessing.active_children():
-        logger.warning('Terminate active kid %s', str(kid))
+        logger.warning("Terminate active kid %s", str(kid))
         kid.terminate()
-    print('Vortex', __version__, 'completed', '(', bronx.stdtypes.date.at_second().reallynice(), ')')
+    print(
+        "Vortex",
+        __version__,
+        "completed",
+        "(",
+        bronx.stdtypes.date.at_second().reallynice(),
+        ")",
+    )
 
 
-import atexit
 atexit.register(complete)
 del atexit, complete
 
-print('Vortex', __version__, 'loaded', '(', bronx.stdtypes.date.at_second().reallynice(), ')')
+print(
+    "Vortex",
+    __version__,
+    "loaded",
+    "(",
+    bronx.stdtypes.date.at_second().reallynice(),
+    ")",
+)
 
 del footprints

vortex/algo/__init__.py

@@ -4,9 +4,10 @@ Generic AlgoComponent classes (and related utility classes).
 Application specific AlgoComponent classes should be defined in dedicated packages.
 """
 
-from . import components, serversynctools
+from . import components as components
+from . import serversynctools as serversynctools
 
 #: No automatic export
 __all__ = []
 
-__tocinfoline__ = 'Generic AlgoComponent classes (and their utility classes)'
+__tocinfoline__ = "Generic AlgoComponent classes (and their utility classes)"