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

vortex/algo/serversynctools.py

@@ -23,30 +23,25 @@ class ServerSyncTool(footprints.FootprintBase):
     """
 
     _abstract = True
-    _collector = ('serversynctool',)
+    _collector = ("serversynctool",)
     _footprint = dict(
-        info='Abstract Server Synchronisation Tool',
+        info="Abstract Server Synchronisation Tool",
         attr=dict(
-            method=dict(
-            ),
+            method=dict(),
             medium=dict(
                 optional=True,
             ),
-            raiseonexit=dict(
-                type=bool,
-                optional=True,
-                default=True
-            ),
+            raiseonexit=dict(type=bool, optional=True, default=True),
             checkinterval=dict(
                 type=int,
                 optional=True,
                 default=10,
             ),
-        )
+        ),
     )
 
     def __init__(self, *args, **kw):
-        logger.debug('Server Synchronisation Tool init %s', self.__class__)
+        logger.debug("Server Synchronisation Tool init %s", self.__class__)
         self._check_callback = lambda: True
         super().__init__(*args, **kw)
 
@@ -80,19 +75,19 @@ class ServerSyncSimpleSocket(ServerSyncTool):
     """
 
     _footprint = dict(
-        info='Server Synchronisation Tool that uses a Socket',
+        info="Server Synchronisation Tool that uses a Socket",
         attr=dict(
             method=dict(
-                values=['simple_socket'],
+                values=["simple_socket"],
             ),
             medium=dict(
                 optional=False,
             ),
             tplname=dict(
                 optional=True,
-                default='@servsync-simplesocket.tpl',
+                default="@servsync-simplesocket.tpl",
             ),
-        )
+        ),
     )
 
     def __init__(self, *args, **kw):
@@ -102,7 +97,7 @@ class ServerSyncSimpleSocket(ServerSyncTool):
         try:
             self._socket.bind((socket.getfqdn(), 0))
         except OSError:
-            self._socket.bind(('localhost', 0))
+            self._socket.bind(("localhost", 0))
         self._socket.settimeout(self.checkinterval)
         self._socket.listen(1)
         # Current connection
@@ -110,11 +105,13 @@ class ServerSyncSimpleSocket(ServerSyncTool):
         # Create the script that will be called by the server
         t = sessions.current()
         tpl = config.load_template(t, self.tplname)
-        with open(self.medium, 'w') as fd:
-            fd.write(tpl.substitute(
-                python=sys.executable,
-                address=self._socket.getsockname(),
-            ))
+        with open(self.medium, "w") as fd:
+            fd.write(
+                tpl.substitute(
+                    python=sys.executable,
+                    address=self._socket.getsockname(),
+                )
+            )
         t.sh.chmod(self.medium, 0o555)
 
     def __del__(self):
@@ -130,13 +127,13 @@ class ServerSyncSimpleSocket(ServerSyncTool):
         if self._socket_conn is not None:
             logger.info('Sending "%s" to the server.', mess)
             # NB: For send/recv, the settimeout also applies...
-            self._socket_conn.send(mess.encode(encoding='utf-8'))
-            repl = self._socket_conn.recv(255).decode(encoding='utf-8')
+            self._socket_conn.send(mess.encode(encoding="utf-8"))
+            repl = self._socket_conn.recv(255).decode(encoding="utf-8")
             logger.info('Server replied "%s" to %s.', repl, mess)
             self._socket_conn.close()
             self._socket_conn = None
-            if repl != 'OK':
-                raise ValueError(mess + ' failed')
+            if repl != "OK":
+                raise ValueError(mess + " failed")
             return True
         else:
             # This should not happen ! If we are sitting here, it's most likely
@@ -144,27 +141,31 @@ class ServerSyncSimpleSocket(ServerSyncTool):
             return False
 
     def trigger_wait(self):
-        logger.info('Waiting for the server to complete')
+        logger.info("Waiting for the server to complete")
         while self._socket_conn is None and self._check_callback():
             try:
-                self._socket_conn, addr = self._socket.accept()  # @UnusedVariable
+                self._socket_conn, addr = (
+                    self._socket.accept()
+                )  # @UnusedVariable
             except socket.timeout:
-                logger.debug('Socket accept timed-out: checking for the server...')
+                logger.debug(
+                    "Socket accept timed-out: checking for the server..."
+                )
                 self._socket_conn = None
         if self._socket_conn is None:
             if self.raiseonexit:
-                raise OSError('Apparently the server died.')
+                raise OSError("Apparently the server died.")
             else:
-                logger.info('The server stopped.')
+                logger.info("The server stopped.")
         else:
             self._socket_conn.settimeout(self.checkinterval)
-            logger.info('The server is now waiting')
+            logger.info("The server is now waiting")
 
     def trigger_run(self):
         # Tell the server that everything is ready
-        self._command('STEP')
+        self._command("STEP")
         # Wait for the server to complete its work
         self.trigger_wait()
 
     def trigger_stop(self):
-        return self._command('STOP')
+        return self._command("STOP")

vortex/config.py

@@ -2,6 +2,7 @@
 the value of configuration options, respectively.
 
 """
+
 import tomli
 
 from bronx.fancies import loggers
@@ -19,6 +20,10 @@ VORTEX_CONFIG = {}
 logger = loggers.getLogger(__name__)
 
 
+class ConfigurationError(Exception):
+    """Something is wrong with the provided configuration"""
+
+
 def load_config(configpath="vortex.toml"):
     """Load configuration from a TOML configuration file
 
@@ -38,21 +43,15 @@ def load_config(configpath="vortex.toml"):
     global VORTEX_CONFIG
     try:
         with open(configpath, "rb") as f:
-             VORTEX_CONFIG = tomli.load(f)
+            VORTEX_CONFIG = tomli.load(f)
         print(f"Successfully read configuration file {configpath}")
     except FileNotFoundError:
-        print(
-            f"Could not read configuration file {configpath}"
-            " (not found)."
-        )
-        print(
-            "Use load_config(/path/to/config) to update the configuration"
-        )
+        print(f"Could not read configuration file {configpath} (not found).")
+        print("Use load_config(/path/to/config) to update the configuration")
 
 
 def print_config():
-    """Print configuration (key, value) pairs
-    """
+    """Print configuration (key, value) pairs"""
     if VORTEX_CONFIG:
         for k, v in VORTEX_CONFIG:
             print(k.upper(), v)
@@ -66,18 +65,19 @@ def from_config(section, key=None):
     """
     try:
         subconfig = VORTEX_CONFIG[section]
-    except KeyError as e:
-        print(f"Could not find section {section} in configuration")
-        raise(e)
-
+    except KeyError:
+        raise ConfigurationError(
+            f"Missing configuration section {section}",
+        )
     if not key:
         return subconfig
 
     try:
         value = subconfig[key]
-    except KeyError as e :
-        print(f"Could not find key {key} in section {section} of configuration")
-        raise(e)
+    except KeyError:
+        raise ConfigurationError(
+            f"Missing configuration key {key} in section {section}",
+        )
     return value
 
 
@@ -87,9 +87,7 @@ def set_config(section, key, value):
     if section not in VORTEX_CONFIG.keys():
         VORTEX_CONFIG[section] = {}
     if key in VORTEX_CONFIG[section]:
-        logger.warning(
-            f"Updating existing configuration {section}:{key}"
-        )
+        logger.warning(f"Updating existing configuration {section}:{key}")
     VORTEX_CONFIG[section][key] = value
 
 
@@ -108,8 +106,7 @@ def is_defined(section, key=None):
 
 
 def get_from_config_w_default(section, key, default):
-    logger.info(f"Reading config value {section}.{key}")
     try:
         return from_config(section, key)
-    except KeyError:
+    except ConfigurationError:
         return default

vortex/data/__init__.py

@@ -4,10 +4,16 @@ Abstract classes involved in data management within VORTEX.
 Actual resources and custom providers should be defined in dedicated packages.
 """
 
-from . import handlers, resources, containers, contents, providers, \
-    executables, stores, geometries
+from . import handlers as handlers
+from . import resources as resources
+from . import containers as containers
+from . import contents as contents
+from . import providers as providers
+from . import executables as executables
+from . import stores as stores
+from . import geometries as geometries
 
 #: No automatic export
 __all__ = []
 
-__tocinfoline__ = 'Abstract classes involved in data management within VORTEX'
+__tocinfoline__ = "Abstract classes involved in data management within VORTEX"