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

vortex/nwp/syntax/stdattrs.py

@@ -4,25 +4,32 @@ of attributes description that could be used in the footprint definition of any
 class which follow the :class:`footprints.Footprint` syntax.
 """
 
-from bronx.stdtypes.date import Time
+import re
+from functools import total_ordering
+
 import footprints
+from bronx.stdtypes.date import Time
+
+from vortex.syntax.stddeco import namebuilding_append
 
-#: Export a set of attributes :data:`a_run`, etc..
-__all__ = []
+#: Export some new class for attributes in footprint objects, eg : GenvKey
+__all__ = ["GenvKey", "GenvDomain"]
 
 #: Usual Footprint for a single member (in an algo Component)
 a_algo_member = dict(
-    info=("The current member's number " +
-          "(may be omitted in deterministic configurations)."),
+    info=(
+        "The current member's number "
+        + "(may be omitted in deterministic configurations)."
+    ),
     optional=True,
-    type=int
+    type=int,
 )
 
 #: Usual Footprint of the ``outputid`` attribute.
 algo_member = footprints.Footprint(attr=dict(member=a_algo_member))
 
 #: Known OOPS testcomponent ``run``
-known_oops_testcomponent_runs = ['ootestcomponent', 'testcomponent', 'testvar']
+known_oops_testcomponent_runs = ["ootestcomponent", "testcomponent", "testvar"]
 
 #: Usual definition of the ``run`` attribute for OOPS binaries.
 a_oops_run = dict(
@@ -30,41 +37,51 @@ a_oops_run = dict(
     optional=False,
 )
 #: Usual Footprint of the ``run`` attribute for OOPS binaries.
-oops_run = footprints.Footprint(info='OOPS kind of run', attr=dict(run=a_oops_run))
+oops_run = footprints.Footprint(
+    info="OOPS kind of run", attr=dict(run=a_oops_run)
+)
 
 #: Usual definition of the ``test_type`` attribute.
 a_oops_test_type = dict(
-    info='Sub-test or family of sub-tests to be ran.',
+    info="Sub-test or family of sub-tests to be ran.",
     optional=False,
 )
 #: Usual Footprint of the ``test_type`` attribute.
-oops_test_type = footprints.Footprint(info='OOPS type of test', attr=dict(test_type=a_oops_test_type))
+oops_test_type = footprints.Footprint(
+    info="OOPS type of test", attr=dict(test_type=a_oops_test_type)
+)
 
 #: Usual definition of the ``expected_target`` attribute.
 an_oops_expected_target = dict(
-    info=('Expected target for the test success'),
+    info=("Expected target for the test success"),
     type=footprints.FPDict,
     optional=True,
-    default=None
+    default=None,
 )
 #: Usual Footprint of the ``expected_target`` attribute.
-oops_expected_target = footprints.Footprint(attr=dict(expected_target=an_oops_expected_target))
+oops_expected_target = footprints.Footprint(
+    attr=dict(expected_target=an_oops_expected_target)
+)
 
 #: Usual Footprint of a combined lists of members and terms
 oops_members_terms_lists = footprints.Footprint(
     info="Abstract footprint for a members/terms list.",
     attr=dict(
         members=dict(
-            info='A list of members.',
+            info="A list of members.",
             type=footprints.FPList,
         ),
         terms=dict(
-            info='A list of effective terms.',
+            info="A list of effective terms.",
             type=footprints.FPList,
             optional=True,
-            default=footprints.FPList([Time(0), ])
+            default=footprints.FPList(
+                [
+                    Time(0),
+                ]
+            ),
         ),
-    )
+    ),
 )
 
 #: Usual definition of the ``outputid`` attribute
@@ -79,15 +96,20 @@ outputid = footprints.Footprint(attr=dict(outputid=a_outputid))
 
 def _apply_outputid(cls):
     """Decorator that tweak the class in order to add OUTPUTID on the namelist"""
-    orig_pnd = getattr(cls, 'prepare_namelist_delta', None)
+    orig_pnd = getattr(cls, "prepare_namelist_delta", None)
     if orig_pnd is None:
-        raise ImportError('_apply_outputid can not be applied on {!s}'.format(cls))
+        raise ImportError(
+            "_apply_outputid can not be applied on {!s}".format(cls)
+        )
 
     def prepare_namelist_delta(self, rh, namcontents, namlocal):
         namw = orig_pnd(self, rh, namcontents, namlocal)
-        if self.outputid is not None and any(['OUTPUTID' in nam_b.macros()
-                                              for nam_b in namcontents.values()]):
-            self._set_nam_macro(namcontents, namlocal, 'OUTPUTID', self.outputid)
+        if self.outputid is not None and any(
+            ["OUTPUTID" in nam_b.macros() for nam_b in namcontents.values()]
+        ):
+            self._set_nam_macro(
+                namcontents, namlocal, "OUTPUTID", self.outputid
+            )
             namw = True
         return namw
 
@@ -96,34 +118,31 @@ def _apply_outputid(cls):
 
 
 #: Decorated footprint for the ``outputid`` attribute
-outputid_deco = footprints.DecorativeFootprint(outputid,
-                                               decorator=[_apply_outputid, ])
+outputid_deco = footprints.DecorativeFootprint(
+    outputid,
+    decorator=[
+        _apply_outputid,
+    ],
+)
 
 
 def show():
     """Returns available items and their type."""
     dmod = globals()
-    for stda in sorted(filter(lambda x: x.startswith('a_') or isinstance(dmod[x], footprints.Footprint),
-                              dmod.keys())):
-        print('{} ( {} ) :\n  {}\n'.format(stda, type(dmod[stda]).__name__, dmod[stda]))
+    for stda in sorted(
+        filter(
+            lambda x: x.startswith("a_")
+            or isinstance(dmod[x], footprints.Footprint),
+            dmod.keys(),
+        )
+    ):
+        print(
+            "{} ( {} ) :\n  {}\n".format(
+                stda, type(dmod[stda]).__name__, dmod[stda]
+            )
+        )
 
 
-"""
-This module provides some pre-defined attributes descriptions or combined sets
-of attributes description that could be used in the footprint definition of any
-class which follow the :class:`footprints.Footprint` syntax.
-"""
-
-import re
-from functools import total_ordering
-
-import footprints
-
-from vortex.syntax.stddeco import namebuilding_append
-
-#: Export some new class for attributes in footprint objects, eg : GenvKey
-__all__ = ['GenvKey', 'GenvDomain']
-
 domain_remap = dict()
 
 
@@ -141,18 +160,18 @@ class GenvKey(str):
 
     def __new__(cls, value):
         """Proxy to ``str.__new___`` with attributes inside brackets translated to lower case."""
-        return str.__new__(cls, re.sub(r'\[\w+\]', _lowerattr, value.upper()))
+        return str.__new__(cls, re.sub(r"\[\w+\]", _lowerattr, value.upper()))
 
 
-a_gvar = dict(info='The key that identifies the resource in the Genv database.',
-              type=GenvKey,
-              optional=True,
-              doc_visibility=footprints.doc.visibility.ADVANCED,
-              )
+a_gvar = dict(
+    info="The key that identifies the resource in the Genv database.",
+    type=GenvKey,
+    optional=True,
+    doc_visibility=footprints.doc.visibility.ADVANCED,
+)
 
 #: Usual definition of the ``genv`` attribute.
-gvar = footprints.Footprint(info='A GENV access key',
-                            attr=dict(gvar=a_gvar))
+gvar = footprints.Footprint(info="A GENV access key", attr=dict(gvar=a_gvar))
 
 
 class GenvDomain(str):
@@ -166,15 +185,18 @@ class GenvDomain(str):
         return str.__new__(cls, domain_remap.get(value, value))
 
 
-a_gdomain = dict(info="The resource's geographical domain name in the Genv database.",
-                 type=GenvDomain,
-                 optional=True,
-                 default='[geometry::area]',
-                 doc_visibility=footprints.doc.visibility.ADVANCED,)
+a_gdomain = dict(
+    info="The resource's geographical domain name in the Genv database.",
+    type=GenvDomain,
+    optional=True,
+    default="[geometry::area]",
+    doc_visibility=footprints.doc.visibility.ADVANCED,
+)
 
 #: Usual definition of the ``gdomain`` attribute.
-gdomain = footprints.Footprint(info='A domain name in GCO convention',
-                               attr=dict(gdomain=a_gdomain))
+gdomain = footprints.Footprint(
+    info="A domain name in GCO convention", attr=dict(gdomain=a_gdomain)
+)
 
 
 @total_ordering
@@ -187,22 +209,33 @@ class ArpIfsSimplifiedCycle:
 
     It can be used in a footprint specification.
     """
-    _cy_re = re.compile(r'(?:u(?:env|get):)?(?:cy|al)(\d+)(?:t(\d{1,3}))?(?=_|@|\.|$)(?:.*?(?:[_-]op(\d{1,3})))?')
+
+    _cy_re = re.compile(
+        r"(?:u(?:env|get):)?(?:cy|al)(\d+)(?:t(\d{1,3}))?(?=_|@|\.|$)(?:.*?(?:[_-]op(\d{1,3})))?"
+    )
     _hash_shift = 10000
 
     def __init__(self, cyclestr):
         cy_match = self._cy_re.match(cyclestr)
         if cy_match:
             self._number = int(cy_match.group(1))
-            self._toulouse = (int(cy_match.group(2)) + 1
-                              if cy_match.group(2) is not None else 0)
-            self._op = (int(cy_match.group(3)) + 1
-                        if cy_match.group(3) is not None else 0)
+            self._toulouse = (
+                int(cy_match.group(2)) + 1
+                if cy_match.group(2) is not None
+                else 0
+            )
+            self._op = (
+                int(cy_match.group(3)) + 1
+                if cy_match.group(3) is not None
+                else 0
+            )
         else:
-            raise ValueError('Malformed cycle: {}'.format(cyclestr))
+            raise ValueError("Malformed cycle: {}".format(cyclestr))
 
     def __hash__(self):
-        return (self._number * self._hash_shift + self._toulouse) * self._hash_shift + self._op
+        return (
+            self._number * self._hash_shift + self._toulouse
+        ) * self._hash_shift + self._op
 
     def __eq__(self, other):
         if not isinstance(other, ArpIfsSimplifiedCycle):
@@ -218,39 +251,51 @@ class ArpIfsSimplifiedCycle:
         return hash(self) > hash(other)
 
     def __str__(self):
-        return ('cy{:d}'.format(self._number) +
-                ('t{:d}'.format(self._toulouse - 1) if self._toulouse else '') +
-                ('_op{:d}'.format(self._op - 1) if self._op else ''))
+        return (
+            "cy{:d}".format(self._number)
+            + ("t{:d}".format(self._toulouse - 1) if self._toulouse else "")
+            + ("_op{:d}".format(self._op - 1) if self._op else "")
+        )
 
     def __repr__(self):
-        return '<{} | {!s}>'.format(object.__repr__(self).lstrip('<').rstrip('>'), self)
+        return "<{} | {!s}>".format(
+            object.__repr__(self).lstrip("<").rstrip(">"), self
+        )
 
     def export_dict(self):
         """The pure dict/json output is the raw integer"""
         return str(self)
 
 
-a_arpifs_cycle = dict(info="An Arpege/IFS cycle name",
-                      type=ArpIfsSimplifiedCycle,
-                      optional=True,
-                      default='cy40',  # For "old" Olive configurations to keep working
-                      )
+a_arpifs_cycle = dict(
+    info="An Arpege/IFS cycle name",
+    type=ArpIfsSimplifiedCycle,
+    optional=True,
+    default="cy40",  # For "old" Olive configurations to keep working
+)
 
 #: Usual definition of the ``cycle`` attribute.
-arpifs_cycle = footprints.Footprint(info='An abstract arpifs_cycle in GCO convention',
-                                    attr=dict(cycle=a_arpifs_cycle))
+arpifs_cycle = footprints.Footprint(
+    info="An abstract arpifs_cycle in GCO convention",
+    attr=dict(cycle=a_arpifs_cycle),
+)
 
-uget_sloppy_id_regex = re.compile(r'(?P<shortuget>(?P<id>\S+)@(?P<location>[-\w]+))')
-uget_id_regex = r'(?P<fulluget>u(?:get|env):' + uget_sloppy_id_regex.pattern + ')'
-uget_id_regex_only = re.compile('^' + uget_id_regex + '$')
-uget_id_regex = re.compile(r'\b' + uget_id_regex + r'\b')
+uget_sloppy_id_regex = re.compile(
+    r"(?P<shortuget>(?P<id>\S+)@(?P<location>[-\w]+))"
+)
+uget_id_regex = (
+    r"(?P<fulluget>u(?:get|env):" + uget_sloppy_id_regex.pattern + ")"
+)
+uget_id_regex_only = re.compile("^" + uget_id_regex + "$")
+uget_id_regex = re.compile(r"\b" + uget_id_regex + r"\b")
 
 
 class GgetId(str):
     """Basestring wrapper for Gget Ids."""
+
     def __new__(cls, value):
         if uget_id_regex_only.match(value):
-            raise ValueError('A GgetId cannot look like a UgetId !')
+            raise ValueError("A GgetId cannot look like a UgetId !")
         return str.__new__(cls, value)
 
 
@@ -265,12 +310,20 @@ class AbstractUgetId(str):
         if not vmatch:
             raise ValueError('Invalid UgetId (got "{:s}")'.format(value))
         me = str.__new__(cls, value)
-        me._id = vmatch.group('id')
-        me._location = vmatch.group('location')
+        me._id = vmatch.group("id")
+        me._location = vmatch.group("location")
         if me._location in set(cls._OUTCAST_LOCATIONS):
-            raise ValueError('Invalid UgetId (got "{:s}"). Outcast Location.'.format(value))
-        if cls._ALLOWED_LOCATIONS and me._location not in set(cls._ALLOWED_LOCATIONS):
-            raise ValueError('Invalid UgetId (got "{:s}"). Disallowed location'.format(value))
+            raise ValueError(
+                'Invalid UgetId (got "{:s}"). Outcast Location.'.format(value)
+            )
+        if cls._ALLOWED_LOCATIONS and me._location not in set(
+            cls._ALLOWED_LOCATIONS
+        ):
+            raise ValueError(
+                'Invalid UgetId (got "{:s}"). Disallowed location'.format(
+                    value
+                )
+            )
         return me
 
     @property
@@ -283,31 +336,30 @@ class AbstractUgetId(str):
 
     @property
     def short(self):
-        return self._id + '@' + self._location
+        return self._id + "@" + self._location
 
     def monthlyshort(self, month):
-        return self._id + '.m{:02d}'.format(month) + '@' + self._location
+        return self._id + ".m{:02d}".format(month) + "@" + self._location
 
 
 class UgetId(AbstractUgetId):
-
-    _OUTCAST_LOCATIONS = ('demo', )
+    _OUTCAST_LOCATIONS = ("demo",)
 
 
 def genv_ifs_compiler_convention(cls):
     """Add the necessary method to handle compiler version/option in Genv."""
-    original_gget_basename = getattr(cls, 'gget_basename', None)
+    original_gget_basename = getattr(cls, "gget_basename", None)
     if original_gget_basename is not None:
 
         def gget_basename(self):
             """GGET specific naming convention."""
             b_dict = original_gget_basename(self)
-            if getattr(self, 'compiler_version', None):
-                b_dict['compiler_version'] = self.compiler_version
-            if getattr(self, 'compiler_option', None):
-                b_dict['compiler_option'] = self.compiler_option
-            if getattr(self, 'cycle', None):
-                b_dict['cycle'] = self.cycle
+            if getattr(self, "compiler_version", None):
+                b_dict["compiler_version"] = self.compiler_version
+            if getattr(self, "compiler_option", None):
+                b_dict["compiler_option"] = self.compiler_option
+            if getattr(self, "cycle", None):
+                b_dict["cycle"] = self.cycle
             return b_dict
 
         cls.gget_basename = gget_basename
@@ -316,15 +368,13 @@ def genv_ifs_compiler_convention(cls):
 
 #: Usual definition of the ``compiler_version`` and ``compiler_option`` attributes.
 gmkpack_compiler_identification = footprints.Footprint(
-    info='Add the compiler version/option in the footprint',
+    info="Add the compiler version/option in the footprint",
     attr=dict(
         compiler_version=dict(
-            info="The compiler version in gmkpack convention.",
-            optional=True
+            info="The compiler version in gmkpack convention.", optional=True
         ),
         compiler_option=dict(
-            info="The compiler option in gmkpack convention.",
-            optional=True
+            info="The compiler option in gmkpack convention.", optional=True
         ),
     ),
 )
@@ -333,21 +383,27 @@ gmkpack_compiler_identification = footprints.Footprint(
 #: Usual definition of the ``compiler_version`` and ``compiler_option`` attributes + genv integration.
 gmkpack_compiler_identification_deco = footprints.DecorativeFootprint(
     gmkpack_compiler_identification,
-    decorator=[genv_ifs_compiler_convention, ]
+    decorator=[
+        genv_ifs_compiler_convention,
+    ],
 )
 
 
 def genv_executable_flavour(cls):
     """Add the necessary method to the "flavour" in Genv."""
-    original_genv_basename = getattr(cls, 'genv_basename', None)
+    original_genv_basename = getattr(cls, "genv_basename", None)
     if original_genv_basename is not None:
 
         def genv_basename(self):
             """Just retrieve a potential gvar attribute."""
             gvar = original_genv_basename(self)
-            if getattr(self, 'flavour', None):
-                gvar += '_' + {'singleprecision': 'SP'
-                               }.get(self.flavour, self.flavour).upper()
+            if getattr(self, "flavour", None):
+                gvar += (
+                    "_"
+                    + {"singleprecision": "SP"}.get(
+                        self.flavour, self.flavour
+                    ).upper()
+                )
             return gvar
 
         cls.genv_basename = genv_basename
@@ -356,11 +412,13 @@ def genv_executable_flavour(cls):
 
 #: Usual definition of the ``flavour`` attribute.
 executable_flavour = footprints.Footprint(
-    info='Add the executable flavour attribute to the resource',
+    info="Add the executable flavour attribute to the resource",
     attr=dict(
         flavour=dict(
             info="The executable flavour (This may influence the Genv's key choice).",
-            values=['singleprecision', ],
+            values=[
+                "singleprecision",
+            ],
             optional=True,
         ),
     ),
@@ -370,6 +428,10 @@ executable_flavour = footprints.Footprint(
 #: Usual definition of the ``flavour``.
 executable_flavour_deco = footprints.DecorativeFootprint(
     executable_flavour,
-    decorator=[genv_executable_flavour,
-               namebuilding_append('src', lambda self: [self.flavour], none_discard=True)]
+    decorator=[
+        genv_executable_flavour,
+        namebuilding_append(
+            "src", lambda self: [self.flavour], none_discard=True
+        ),
+    ],
 )

vortex/nwp/tools/__init__.py

@@ -3,8 +3,8 @@ Standalone tools for NWP
 """
 
 # Recursive inclusion of packages with potential FootprintBase classes
-from . import conftools
-from . import ifstools
+from . import conftools as conftools
+from . import ifstools as ifstools
 
 #: Automatic export of data subpackage
 __all__ = []

vortex/nwp/tools/addons.py

@@ -4,12 +4,12 @@ Various System needed for NWP applications.
 
 from vortex.tools.addons import AddonGroup
 
-# Load the proper Addon modules...
-import vortex.tools.folder  # @UnusedImport
-import vortex.tools.lfi  # @UnusedImport
-import vortex.tools.grib  # @UnusedImport
-import vortex.tools.listings  # @UnusedImport
-import vortex.tools.surfex  # @UnusedImport
+# Import the proper Addon modules for footprints
+from vortex.tools import folder as folder
+from vortex.tools import lfi as lfi
+from vortex.tools import grib as grib
+from vortex.tools import listings as listings
+from vortex.tools import surfex as surfex
 
 #: No automatic export
 __all__ = []
@@ -19,17 +19,22 @@ class NWPAddonsGroup(AddonGroup):
     """A set of usual NWP Addons."""
 
     _footprint = dict(
-        info = 'Default NWP Addons',
-        attr = dict(
-            kind = dict(
-                values = ['nwp', ],
+        info="Default NWP Addons",
+        attr=dict(
+            kind=dict(
+                values=[
+                    "nwp",
+                ],
             ),
-        )
+        ),
     )
 
-    _addonslist = ('allfolders',  # Folder like...
-                   'lfi', 'iopoll',  # Wonderful FA/LFI world...
-                   'grib', 'gribapi',  # GRIB stuff...
-                   'arpifs_listings',  # Obscure IFS/Arpege listings...
-                   'sfx',  # Surfex...
-                   )
+    _addonslist = (
+        "allfolders",  # Folder like...
+        "lfi",
+        "iopoll",  # Wonderful FA/LFI world...
+        "grib",
+        "gribapi",  # GRIB stuff...
+        "arpifs_listings",  # Obscure IFS/Arpege listings...
+        "sfx",  # Surfex...
+    )

vortex/nwp/tools/agt.py

@@ -7,6 +7,7 @@ import collections
 
 class AgtConfigurationError(Exception):
     """Specific Transfer Agent configuration error."""
+
     pass
 
 
@@ -15,10 +16,10 @@ def agt_volatile_path(sh):
     and hard-linking to it instead of expecting it to be present "later".
     """
     config = sh.default_target.config
-    if not config.has_section('agt'):
+    if not config.has_section("agt"):
         fmt = 'Missing section "agt" in configuration file\n"{}"'
         raise AgtConfigurationError(fmt.format(config.file))
-    return config.get('agt', 'agt_volatile')
+    return config.get("agt", "agt_volatile")
 
 
 def agt_actual_command(sh, binary_name, args, extraenv=None):
@@ -35,21 +36,32 @@ def agt_actual_command(sh, binary_name, args, extraenv=None):
     :param extraenv: Additional environment variables to export (dictionary)
     """
     config = sh.default_target.config
-    if not config.has_section('agt'):
+    if not config.has_section("agt"):
         fmt = 'Missing section "agt" in configuration file\n"{}"'
         raise AgtConfigurationError(fmt.format(config.file))
 
-    agt_path = sh.default_target.get('agt_path', default=None)
+    agt_path = sh.default_target.get("agt_path", default=None)
     agt_bin = sh.default_target.get(binary_name, default=None)
     if not all([agt_path, agt_bin]):
         fmt = 'Missing key "agt_path" or "{}" in configuration file\n"{}"'
         raise AgtConfigurationError(fmt.format(binary_name, config.file))
-    cfgkeys = ['HOME_SOPRA', 'LD_LIBRARY_PATH',
-               'base_transfert_agent', 'DIAP_AGENT_NUMPROG_AGENT']
-    context = ' ; '.join(["export {}={}".format(key, config.get('agt', key))
-                          for key in cfgkeys])
+    cfgkeys = [
+        "HOME_SOPRA",
+        "LD_LIBRARY_PATH",
+        "base_transfert_agent",
+        "DIAP_AGENT_NUMPROG_AGENT",
+    ]
+    context = " ; ".join(
+        ["export {}={}".format(key, config.get("agt", key)) for key in cfgkeys]
+    )
     if extraenv is not None and isinstance(extraenv, collections.abc.Mapping):
-        context = ' ; '.join([context, ] +
-                             ["export {}={}".format(key.upper(), value)
-                              for (key, value) in extraenv.items()])
-    return '{} ; {} {}'.format(context, sh.path.join(agt_path, agt_bin), args)
+        context = " ; ".join(
+            [
+                context,
+            ]
+            + [
+                "export {}={}".format(key.upper(), value)
+                for (key, value) in extraenv.items()
+            ]
+        )
+    return "{} ; {} {}".format(context, sh.path.join(agt_path, agt_bin), args)

vortex/nwp/tools/bdap.py

@@ -8,16 +8,19 @@ __all__ = []
 
 class BDAPError(Exception):
     """General BDAP error."""
+
     pass
 
 
 class BDAPRequestConfigurationError(BDAPError):
     """Specific Transfer Agent configuration error."""
+
     pass
 
 
 class BDAPGetError(BDAPError):
     """Generic BDAP get error."""
+
     pass
 
 
@@ -38,11 +41,19 @@ def BDAPrequest_actual_command(command, date, term, query, int_extraenv=False):
     """
 
     # Environment variable to specify the date of the file
-    context = ' ; '.join(["export {}={}".format('dmt_date_pivot'.upper(), date.ymdhms)])
+    context = " ; ".join(
+        ["export {}={}".format("dmt_date_pivot".upper(), date.ymdhms)]
+    )
     # Extra environment variables (integration BDAP)
     if int_extraenv:
-        context = ' ; '.join([context] +
-                             ["export {}={}".format('db_file_bdap'.upper(),
-                                                    '/usr/local/sopra/neons_db_bdap.intgr')])
+        context = " ; ".join(
+            [context]
+            + [
+                "export {}={}".format(
+                    "db_file_bdap".upper(),
+                    "/usr/local/sopra/neons_db_bdap.intgr",
+                )
+            ]
+        )
     # Return the command to be launched
-    return '{} ; {} {:d} {}'.format(context, command, term.hour, query)
+    return "{} ; {} {:d} {}".format(context, command, term.hour, query)