DIRAC 9.0.0a63__py3-none-any.whl → 9.0.0a66__py3-none-any.whl

DIRAC/ConfigurationSystem/Client/LocalConfiguration.py

@@ -1,5 +1,5 @@
-""" This is the guy that parses and interprets the local configuration options.
-"""
+"""This is the guy that parses and interprets the local configuration options."""
+
 import re
 import os
 import sys
@@ -286,16 +286,18 @@ class LocalConfiguration:
             gLogger.exception()
             return S_ERROR(str(e))
 
-    def initialize(self, *, returnErrors=False):
+    def initialize(self, *, returnErrors=False, requireSuccessfulSync=False):
         """Entrypoint used by :py:class:`DIRAC.initialize`
 
+        :param requireSuccessfulSync: fails if syncing with the remote did not work
+
         TODO: This is currently a hack that returns a list of errors for so it
         can be used by ``__addUserDataToConfiguration``. This entire module
         should be refactored and simplified with ``Script.parseCommandLine``.
         """
         errorsList = self.__loadCFGFiles()
         if gConfigurationData.getServers():
-            retVal = self.syncRemoteConfiguration()
+            retVal = self.syncRemoteConfiguration(strict=requireSuccessfulSync)
             if not retVal["OK"]:
                 return retVal
         else:
@@ -321,7 +323,7 @@ class LocalConfiguration:
             gLogger.showHeaders(True)
             gLogger.enableLogsFromExternalLibs()
 
-    def loadUserData(self):
+    def loadUserData(self, requireSuccessfulSync=False):
         """
         This is the magic method that reads the command line and processes it
         It is used by the Script Base class and the dirac-service and dirac-agent scripts
@@ -329,6 +331,7 @@ class LocalConfiguration:
         - any additional switches to be processed
         - mandatory and default configuration configuration options must be defined.
 
+        :param requireSuccessfulSync: if True, will fail if the sync with remote server failed
         """
         if self.initialized:
             return S_OK()
@@ -336,7 +339,7 @@ class LocalConfiguration:
         try:
             if not self.isParsed:
                 self.__parseCommandLine()  # Parse command line
-            retVal = self.__addUserDataToConfiguration()
+            retVal = self.__addUserDataToConfiguration(requireSuccessfulSync=requireSuccessfulSync)
 
             for optionTuple in self.optionalEntryList:
                 optionPath = self.__getAbsolutePath(optionTuple[0])
@@ -496,8 +499,8 @@ class LocalConfiguration:
 
         return errorsList
 
-    def __addUserDataToConfiguration(self):
-        retVal = self.initialize(returnErrors=True)
+    def __addUserDataToConfiguration(self, requireSuccessfulSync=False):
+        retVal = self.initialize(returnErrors=True, requireSuccessfulSync=requireSuccessfulSync)
         if not retVal["OK"]:
             return retVal
         errorsList = retVal["Value"]

DIRAC/Core/Utilities/DErrno.py

@@ -37,320 +37,16 @@
                              DErrno.ERRX : ['An error message for ERRX that is specific to LHCb']}
 
 """
-import os
 import importlib
 import sys
 
-from DIRAC.Core.Utilities.Extensions import extensionsByPriority
-
-# To avoid conflict, the error numbers should be greater than 1000
-# We decided to group the by range of 100 per system
-
-# 1000: Generic
-# 1100: Core
-# 1200: Framework
-# 1300: Interfaces
-# 1400: Config
-# 1500: WMS + Workflow
-# 1600: DMS + StorageManagement
-# 1700: RMS
-# 1800: Accounting + Monitoring
-# 1900: TS + Production
-# 2000: Resources + RSS
-
-# ## Generic (10XX)
-# Python related: 0X
-ETYPE = 1000
-EIMPERR = 1001
-ENOMETH = 1002
-ECONF = 1003
-EVALUE = 1004
-EEEXCEPTION = 1005
-# Files manipulation: 1X
-ECTMPF = 1010
-EOF = 1011
-ERF = 1012
-EWF = 1013
-ESPF = 1014
-
-# ## Core (11XX)
-# Certificates and Proxy: 0X
-EX509 = 1100
-EPROXYFIND = 1101
-EPROXYREAD = 1102
-ECERTFIND = 1103
-ECERTREAD = 1104
-ENOCERT = 1105
-ENOCHAIN = 1106
-ENOPKEY = 1107
-ENOGROUP = 1108
-# DISET: 1X
-EDISET = 1110
-ENOAUTH = 1111
-# 3rd party security: 2X
-E3RDPARTY = 1120
-EVOMS = 1121
-# Databases : 3X
-EDB = 1130
-EMYSQL = 1131
-ESQLA = 1132
-# Message Queues: 4X
-EMQUKN = 1140
-EMQNOM = 1141
-EMQCONN = 1142
-# OpenSearch
-EELNOFOUND = 1146
-# Tokens
-EATOKENFIND = 1150
-EATOKENREAD = 1151
-ETOKENTYPE = 1152
-
-# config
-ESECTION = 1400
-
-# processes
-EEZOMBIE = 1147
-EENOPID = 1148
-
-# ## WMS/Workflow
-EWMSUKN = 1500
-EWMSJDL = 1501
-EWMSRESC = 1502
-EWMSSUBM = 1503
-EWMSJMAN = 1504
-EWMSSTATUS = 1505
-EWMSNOMATCH = 1510
-EWMSPLTVER = 1511
-EWMSNOPILOT = 1550
-
-# ## DMS/StorageManagement (16XX)
-EFILESIZE = 1601
-EGFAL = 1602
-EBADCKS = 1603
-EFCERR = 1604
-
-# ## RMS (17XX)
-ERMSUKN = 1700
-
-# ## TS (19XX)
-ETSUKN = 1900
-ETSDATA = 1901
-
-# ## Resources and RSS (20XX)
-ERESGEN = 2000
-ERESUNA = 2001
-ERESUNK = 2002
-
-# This translates the integer number into the name of the variable
-dErrorCode = {
-    # ## Generic (10XX)
-    # 100X: Python related
-    1000: "ETYPE",
-    1001: "EIMPERR",
-    1002: "ENOMETH",
-    1003: "ECONF",
-    1004: "EVALUE",
-    1005: "EEEXCEPTION",
-    # 101X: Files manipulation
-    1010: "ECTMPF",
-    1011: "EOF",
-    1012: "ERF",
-    1013: "EWF",
-    1014: "ESPF",
-    # ## Core
-    # 110X: Certificates and Proxy
-    1100: "EX509",
-    1101: "EPROXYFIND",
-    1102: "EPROXYREAD",
-    1103: "ECERTFIND",
-    1104: "ECERTREAD",
-    1105: "ENOCERT",
-    1106: "ENOCHAIN",
-    1107: "ENOPKEY",
-    1108: "ENOGROUP",
-    # 111X: DISET
-    1110: "EDISET",
-    1111: "ENOAUTH",
-    # 112X: 3rd party security
-    1120: "E3RDPARTY",
-    1121: "EVOMS",
-    # 113X: Databases
-    1130: "EDB",
-    1131: "EMYSQL",
-    1132: "ESQLA",
-    # 114X: Message Queues
-    1140: "EMQUKN",
-    1141: "EMQNOM",
-    1142: "EMQCONN",
-    # OpenSearch
-    1146: "EELNOFOUND",
-    # 115X: Tokens
-    1150: "EATOKENFIND",
-    1151: "EATOKENREAD",
-    1152: "ETOKENTYPE",
-    # Config
-    1400: "ESECTION",
-    # Processes
-    1147: "EEZOMBIE",
-    1148: "EENOPID",
-    # WMS/Workflow
-    1500: "EWMSUKN",
-    1501: "EWMSJDL",
-    1502: "EWMSRESC",
-    1503: "EWMSSUBM",
-    1504: "EWMSJMAN",
-    1505: "EWMSSTATUS",
-    1510: "EWMSNOMATCH",
-    1511: "EWMSPLTVER",
-    1550: "EWMSNOPILOT",
-    # DMS/StorageManagement
-    1601: "EFILESIZE",
-    1602: "EGFAL",
-    1603: "EBADCKS",
-    1604: "EFCERR",
-    # RMS
-    1700: "ERMSUKN",
-    # Resources and RSS
-    2000: "ERESGEN",
-    2001: "ERESUNA",
-    2002: "ERESUNK",
-    # TS
-    1900: "ETSUKN",
-    1901: "ETSDATA",
-}
-
-
-dStrError = {  # Generic (10XX)
-    # 100X: Python related
-    ETYPE: "Object Type Error",
-    EIMPERR: "Failed to import library",
-    ENOMETH: "No such method or function",
-    ECONF: "Configuration error",
-    EVALUE: "Wrong value passed",
-    EEEXCEPTION: "runtime general exception",
-    # 101X: Files manipulation
-    ECTMPF: "Failed to create temporary file",
-    EOF: "Cannot open file",
-    ERF: "Cannot read from file",
-    EWF: "Cannot write to file",
-    ESPF: "Cannot set permissions to file",
-    # ## Core
-    # 110X: Certificates and Proxy
-    EX509: "Generic Error with X509",
-    EPROXYFIND: "Can't find proxy",
-    EPROXYREAD: "Can't read proxy",
-    ECERTFIND: "Can't find certificate",
-    ECERTREAD: "Can't read certificate",
-    ENOCERT: "No certificate loaded",
-    ENOCHAIN: "No chain loaded",
-    ENOPKEY: "No private key loaded",
-    ENOGROUP: "No DIRAC group",
-    # 111X: DISET
-    EDISET: "DISET Error",
-    ENOAUTH: "Unauthorized query",
-    # 112X: 3rd party security
-    E3RDPARTY: "3rd party security service error",
-    EVOMS: "VOMS Error",
-    # 113X: Databases
-    EDB: "Database Error",
-    EMYSQL: "MySQL Error",
-    ESQLA: "SQLAlchemy Error",
-    # 114X: Message Queues
-    EMQUKN: "Unknown MQ Error",
-    EMQNOM: "No messages",
-    EMQCONN: "MQ connection failure",
-    # 114X OpenSearch
-    EELNOFOUND: "Index not found",
-    # 115X: Tokens
-    EATOKENFIND: "Can't find a bearer access token.",
-    EATOKENREAD: "Can't read a bearer access token.",
-    ETOKENTYPE: "Unsupported access token type.",
-    # Config
-    ESECTION: "Section is not found",
-    # processes
-    EEZOMBIE: "Zombie process",
-    EENOPID: "No PID of process",
-    # WMS/Workflow
-    EWMSUKN: "Unknown WMS error",
-    EWMSJDL: "Invalid job description",
-    EWMSRESC: "Job to reschedule",
-    EWMSSUBM: "Job submission error",
-    EWMSJMAN: "Job management error",
-    EWMSSTATUS: "Job status error",
-    EWMSNOPILOT: "No pilots found",
-    EWMSPLTVER: "Pilot version does not match",
-    EWMSNOMATCH: "No match found",
-    # DMS/StorageManagement
-    EFILESIZE: "Bad file size",
-    EGFAL: "Error with the gfal call",
-    EBADCKS: "Bad checksum",
-    EFCERR: "FileCatalog error",
-    # RMS
-    ERMSUKN: "Unknown RMS error",
-    # Resources and RSS
-    ERESGEN: "Unknown Resource Failure",
-    ERESUNA: "Resource not available",
-    ERESUNK: "Unknown Resource",
-    # TS
-    ETSUKN: "Unknown Transformation System Error",
-    ETSDATA: "Invalid Input Data definition",
-}
+# Import all the stateless parts from DIRACCommon
+from DIRACCommon.Utils.DErrno import *  # noqa: F401, F403
 
+from DIRAC.Core.Utilities.Extensions import extensionsByPriority
 
-def strerror(code: int) -> str:
-    """This method wraps up os.strerror, and behave the same way.
-    It completes it with the DIRAC specific errors.
-    """
-
-    if code == 0:
-        return "Undefined error"
-
-    errMsg = f"Unknown error {code}"
-
-    try:
-        errMsg = dStrError[code]
-    except KeyError:
-        # It is not a DIRAC specific error, try the os one
-        try:
-            errMsg = os.strerror(code)
-            # On some system, os.strerror raises an exception with unknown code,
-            # on others, it returns a message...
-        except ValueError:
-            pass
-
-    return errMsg
-
-
-def cmpError(inErr, candidate):
-    """This function compares an error (in its old form (a string or dictionary) or in its int form
-    with a candidate error code.
-
-    :param inErr: a string, an integer, a S_ERROR dictionary
-    :type inErr: str or int or S_ERROR
-    :param int candidate: error code to compare with
-
-    :return: True or False
-
-    If an S_ERROR instance is passed, we compare the code with S_ERROR['Errno']
-    If it is a Integer, we do a direct comparison
-    If it is a String, we use strerror to check the error string
-    """
-
-    if isinstance(inErr, str):  # old style
-        # Compare error message strings
-        errMsg = strerror(candidate)
-        return errMsg in inErr
-    elif isinstance(inErr, dict):  # if the S_ERROR structure is given
-        # Check if Errno defined in the dict
-        errorNumber = inErr.get("Errno")
-        if errorNumber:
-            return errorNumber == candidate
-        errMsg = strerror(candidate)
-        return errMsg in inErr.get("Message", "")
-    elif isinstance(inErr, int):
-        return inErr == candidate
-    else:
-        raise TypeError(f"Unknown input error type {type(inErr)}")
+# compatErrorString is used by the extension mechanism but not in DIRACCommon
+compatErrorString = {}
 
 
 def includeExtensionErrors():

DIRAC/Core/Utilities/ReturnValues.py

@@ -1,255 +1,10 @@
-"""
-   DIRAC return dictionary
+"""Backward compatibility wrapper - moved to DIRACCommon
 
-   Message values are converted to string
+This module has been moved to DIRACCommon.Utils.ReturnValues to avoid
+circular dependencies and allow DiracX to use these utilities without
+triggering DIRAC's global state initialization.
 
-   keys are converted to string
+All exports are maintained for backward compatibility.
 """
-from __future__ import annotations
-
-import functools
-import sys
-import traceback
-from types import TracebackType
-from typing import Any, Callable, cast, Generic, Literal, overload, Type, TypeVar, Union
-from typing_extensions import TypedDict, ParamSpec, NotRequired
-
-from DIRAC.Core.Utilities.DErrno import strerror
-
-
-T = TypeVar("T")
-P = ParamSpec("P")
-
-
-class DOKReturnType(TypedDict, Generic[T]):
-    """used for typing the DIRAC return structure"""
-
-    OK: Literal[True]
-    Value: T
-
-
-class DErrorReturnType(TypedDict):
-    """used for typing the DIRAC return structure"""
-
-    OK: Literal[False]
-    Message: str
-    Errno: int
-    ExecInfo: NotRequired[tuple[type[BaseException], BaseException, TracebackType]]
-    CallStack: NotRequired[list[str]]
-
-
-DReturnType = Union[DOKReturnType[T], DErrorReturnType]
-
-
-def S_ERROR(*args: Any, **kwargs: Any) -> DErrorReturnType:
-    """return value on error condition
-
-    Arguments are either Errno and ErrorMessage or just ErrorMessage fro backward compatibility
-
-    :param int errno: Error number
-    :param string message: Error message
-    :param list callStack: Manually override the CallStack attribute better performance
-    """
-    callStack = kwargs.pop("callStack", None)
-
-    result: DErrorReturnType = {"OK": False, "Errno": 0, "Message": ""}
-
-    message = ""
-    if args:
-        if isinstance(args[0], int):
-            result["Errno"] = args[0]
-            if len(args) > 1:
-                message = args[1]
-        else:
-            message = args[0]
-
-    if result["Errno"]:
-        message = f"{strerror(result['Errno'])} ( {result['Errno']} : {message})"
-    result["Message"] = message
-
-    if callStack is None:
-        try:
-            callStack = traceback.format_stack()
-            callStack.pop()
-        except Exception:
-            callStack = []
-
-    result["CallStack"] = callStack
-
-    return result
-
-
-# mypy doesn't understand default parameter values with generics so use overloads (python/mypy#3737)
-@overload
-def S_OK() -> DOKReturnType[None]:
-    ...
-
-
-@overload
-def S_OK(value: T) -> DOKReturnType[T]:
-    ...
-
-
-def S_OK(value=None):  # type: ignore
-    """return value on success
-
-    :param value: value of the 'Value'
-    :return: dictionary { 'OK' : True, 'Value' : value }
-    """
-    return {"OK": True, "Value": value}
-
-
-def isReturnStructure(unk: Any) -> bool:
-    """Check if value is an `S_OK`/`S_ERROR` object"""
-    if not isinstance(unk, dict):
-        return False
-    if "OK" not in unk:
-        return False
-    if unk["OK"]:
-        return "Value" in unk
-    else:
-        return "Message" in unk
-
-
-def isSError(value: Any) -> bool:
-    """Check if value is an `S_ERROR` object"""
-    if not isinstance(value, dict):
-        return False
-    if "OK" not in value:
-        return False
-    return "Message" in value
-
-
-def reprReturnErrorStructure(struct: DErrorReturnType, full: bool = False) -> str:
-    errorNumber = struct.get("Errno", 0)
-    message = struct.get("Message", "")
-    if errorNumber:
-        reprStr = f"{strerror(errorNumber)} ( {errorNumber} : {message})"
-    else:
-        reprStr = message
-
-    if full:
-        callStack = struct.get("CallStack")
-        if callStack:
-            reprStr += "\n" + "".join(callStack)
-
-    return reprStr
-
-
-def returnSingleResult(dictRes: DReturnType[Any]) -> DReturnType[Any]:
-    """Transform the S_OK{Successful/Failed} dictionary convention into
-    an S_OK/S_ERROR return. To be used when a single returned entity
-    is expected from a generally bulk call.
-
-    :param dictRes: S_ERROR or S_OK( "Failed" : {}, "Successful" : {})
-    :returns: S_ERROR or S_OK(value)
-
-    The following rules are applied:
-
-    - if dictRes is an S_ERROR: returns it as is
-    - we start by looking at the Failed directory
-    - if there are several items in a dictionary, we return the first one
-    - if both dictionaries are empty, we return S_ERROR
-    - For an item in Failed, we return S_ERROR
-    - Far an item in Successful we return S_OK
-
-    Behavior examples (would be perfect unit test :-) )::
-
-      {'Message': 'Kaput', 'OK': False} -> {'Message': 'Kaput', 'OK': False}
-      {'OK': True, 'Value': {'Successful': {}, 'Failed': {'a': 1}}} -> {'Message': '1', 'OK': False}
-      {'OK': True, 'Value': {'Successful': {'b': 2}, 'Failed': {}}} -> {'OK': True, 'Value': 2}
-      {'OK': True, 'Value': {'Successful': {'b': 2}, 'Failed': {'a': 1}}} -> {'Message': '1', 'OK': False}
-      {'OK': True, 'Value': {'Successful': {'b': 2}, 'Failed': {'a': 1, 'c': 3}}} -> {'Message': '1', 'OK': False}
-      {'OK': True, 'Value': {'Successful': {'b': 2, 'd': 4}, 'Failed': {}}} -> {'OK': True, 'Value': 2}
-      {'OK': True, 'Value': {'Successful': {}, 'Failed': {}}} ->
-          {'Message': 'returnSingleResult: Failed and Successful dictionaries are empty', 'OK': False}
-    """
-    # if S_ERROR was returned, we return it as well
-    if not dictRes["OK"]:
-        return dictRes
-    # if there is a Failed, we return the first one in an S_ERROR
-    if "Failed" in dictRes["Value"] and len(dictRes["Value"]["Failed"]):
-        errorMessage = list(dictRes["Value"]["Failed"].values())[0]
-        if isinstance(errorMessage, dict):
-            if isReturnStructure(errorMessage):
-                return cast(DErrorReturnType, errorMessage)
-            else:
-                return S_ERROR(str(errorMessage))
-        return S_ERROR(errorMessage)
-    # if there is a Successful, we return the first one in an S_OK
-    elif "Successful" in dictRes["Value"] and len(dictRes["Value"]["Successful"]):
-        return S_OK(list(dictRes["Value"]["Successful"].values())[0])
-    else:
-        return S_ERROR("returnSingleResult: Failed and Successful dictionaries are empty")
-
-
-class SErrorException(Exception):
-    """Exception class for use with `convertToReturnValue`"""
-
-    def __init__(self, result: DErrorReturnType | str, errCode: int = 0):
-        """Create a new exception return value
-
-        If `result` is a `S_ERROR` return it directly else convert it to an
-        appropriate value using `S_ERROR(errCode, result)`.
-
-        :param result: The error to propagate
-        :param errCode: the error code to propagate
-        """
-        if not isSError(result):
-            result = S_ERROR(errCode, result)
-        self.result = cast(DErrorReturnType, result)
-
-
-def returnValueOrRaise(result: DReturnType[T], *, errorCode: int = 0) -> T:
-    """Unwrap an S_OK/S_ERROR response into a value or Exception
-
-    This method assists with using exceptions in DIRAC code by raising
-    :exc:`SErrorException` if `result` is an error. This can then by propagated
-    automatically as an `S_ERROR` by wrapping public facing functions with
-    `@convertToReturnValue`.
-
-    :param result: Result of a DIRAC function which returns `S_OK`/`S_ERROR`
-    :returns: The value associated with the `S_OK` object
-    :raises: If `result["OK"]` is falsey the original exception is re-raised.
-             If no exception is known an :exc:`SErrorException` is raised.
-    """
-    if not result["OK"]:
-        if "ExecInfo" in result:
-            raise result["ExecInfo"][0]
-        else:
-            raise SErrorException(result, errorCode)
-    return result["Value"]
-
-
-def convertToReturnValue(func: Callable[P, T]) -> Callable[P, DReturnType[T]]:
-    """Decorate a function to convert return values to `S_OK`/`S_ERROR`
-
-    If `func` returns, wrap the return value in `S_OK`.
-    If `func` raises :exc:`SErrorException`, return the associated `S_ERROR`
-    If `func` raises any other exception type, convert it to an `S_ERROR` object
-
-    :param result: The bare result of a function call
-    :returns: `S_OK`/`S_ERROR`
-    """
-
-    @functools.wraps(func)
-    def wrapped(*args: P.args, **kwargs: P.kwargs) -> DReturnType[T]:
-        try:
-            value = func(*args, **kwargs)
-        except SErrorException as e:
-            return e.result
-        except Exception as e:
-            retval = S_ERROR(f"{repr(e)}: {e}")
-            # Replace CallStack with the one from the exception
-            # Use cast as mypy doesn't understand that sys.exc_info can't return None in an exception block
-            retval["ExecInfo"] = cast(tuple[type[BaseException], BaseException, TracebackType], sys.exc_info())
-            exc_type, exc_value, exc_tb = retval["ExecInfo"]
-            retval["CallStack"] = traceback.format_tb(exc_tb)
-            return retval
-        else:
-            return S_OK(value)
-
-    # functools will copy the annotations. Since we change the return type
-    # we have to update it
-    wrapped.__annotations__["return"] = DReturnType
-    return wrapped
+# Re-export everything from DIRACCommon for backward compatibility
+from DIRACCommon.Utils.ReturnValues import *  # noqa: F401, F403

DIRAC/Core/scripts/dirac_agent.py

@@ -25,7 +25,7 @@ def main():
     localCfg.setConfigurationForAgent(agentName)
     localCfg.addDefaultEntry("/DIRAC/Security/UseServerCertificate", "yes")
     localCfg.addDefaultEntry("LogColor", True)
-    resultDict = localCfg.loadUserData()
+    resultDict = localCfg.loadUserData(requireSuccessfulSync=True)
     if not resultDict["OK"]:
         gLogger.error("There were errors when loading configuration", resultDict["Message"])
         sys.exit(1)

DIRAC/Interfaces/API/Dirac.py

@@ -422,6 +422,14 @@ class Dirac(API):
                 sandbox = [isFile.strip() for isFile in sandbox.split(",")]
             for isFile in sandbox:
                 self.log.debug(f"Resolving Input Sandbox {isFile}")
+                # If the sandbox is already in the sandbox store, download it
+                if isFile.startswith("SB:"):
+                    result = SandboxStoreClient(useCertificates=self.useCertificates).downloadSandbox(
+                        isFile, destinationDir=os.getcwd()
+                    )
+                    if not result["OK"]:
+                        return S_ERROR(f"Cannot download Input sandbox {isFile}: {result['Message']}")
+                    continue
                 if isFile.lower().startswith("lfn:"):  # isFile is an LFN
                     isFile = isFile[4:]
                 # Attempt to copy into job working directory, unless it is already there

DIRAC/Interfaces/API/Job.py

@@ -1105,6 +1105,7 @@ class Job(API):
                 uniqueInputSandbox = uniqueElements(finalInputSandbox.split(";"))
                 paramsDict["InputSandbox"]["value"] = ";".join(uniqueInputSandbox)
                 self.log.verbose(f"Final unique Input Sandbox {';'.join(uniqueInputSandbox)}")
+                paramsDict["InputSandbox"]["type"] = "JDL"
             else:
                 paramsDict["InputSandbox"] = {}
                 paramsDict["InputSandbox"]["value"] = extraFiles

DIRAC/TransformationSystem/Agent/TransformationCleaningAgent.py

@@ -37,7 +37,7 @@ from DIRAC.WorkloadManagementSystem.Service.JobPolicy import (
     RIGHT_DELETE,
     RIGHT_KILL,
 )
-from DIRAC.WorkloadManagementSystem.Utilities.jobAdministration import kill_delete_jobs
+from DIRAC.WorkloadManagementSystem.DB.StatusUtils import kill_delete_jobs
 
 # # agent's name
 AGENT_NAME = "Transformation/TransformationCleaningAgent"