DIRAC 9.0.0a42__py3-none-any.whl → 9.0.7__py3-none-any.whl

{DIRAC-9.0.0a42.dist-info → dirac-9.0.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{DIRAC-9.0.0a42.dist-info → dirac-9.0.7.dist-info}/entry_points.txt

@@ -145,13 +145,10 @@ dirac-status-component = DIRAC.FrameworkSystem.scripts.dirac_status_component:ma
 dirac-stop-component = DIRAC.FrameworkSystem.scripts.dirac_stop_component:main [server]
 dirac-sys-sendmail = DIRAC.FrameworkSystem.scripts.dirac_sys_sendmail:main [admin]
 dirac-transformation-add-files = DIRAC.TransformationSystem.scripts.dirac_transformation_add_files:main [admin]
-dirac-transformation-archive = DIRAC.TransformationSystem.scripts.dirac_transformation_archive:main [admin]
-dirac-transformation-clean = DIRAC.TransformationSystem.scripts.dirac_transformation_clean:main [admin]
 dirac-transformation-cli = DIRAC.TransformationSystem.scripts.dirac_transformation_cli:main [admin]
 dirac-transformation-get-files = DIRAC.TransformationSystem.scripts.dirac_transformation_get_files:main [admin]
 dirac-transformation-information = DIRAC.TransformationSystem.scripts.dirac_transformation_information:main [admin]
 dirac-transformation-recover-data = DIRAC.TransformationSystem.scripts.dirac_transformation_recover_data:main [admin]
-dirac-transformation-remove-output = DIRAC.TransformationSystem.scripts.dirac_transformation_remove_output:main [admin]
 dirac-transformation-replication = DIRAC.TransformationSystem.scripts.dirac_transformation_replication:main [admin]
 dirac-transformation-update-derived = DIRAC.TransformationSystem.scripts.dirac_transformation_update_derived:main [admin]
 dirac-transformation-verify-outputdata = DIRAC.TransformationSystem.scripts.dirac_transformation_verify_outputdata:main [admin]

DIRAC/Core/Utilities/test/Test_List.py

@@ -1,150 +0,0 @@
-########################################################################
-# Author: Krzysztof.Ciba@NOSPAMgmail.com
-# Date: 2011/01/17 08:17:58
-########################################################################
-
-""".. module:: ListTestCase
-
-Test cases for DIRAC.Core.Utilities.List module.
-
-"""
-import unittest
-
-# sut
-from DIRAC.Core.Utilities import List
-
-
-########################################################################
-class ListTestCase(unittest.TestCase):
-    """py:class ListTestCase
-    Test case for DIRAC.Core.Utilities.List module.
-    """
-
-    def testUniqueElements(self):
-        """uniqueElements tests"""
-        # empty list
-        aList = []
-        self.assertEqual(List.uniqueElements(aList), [])
-        # redundant elements
-        aList = [1, 1, 2, 3]
-        self.assertEqual(List.uniqueElements(aList), [1, 2, 3])
-
-    def testAppendUnique(self):
-        """appendUnique tests"""
-        # empty
-        aList = []
-        List.appendUnique(aList, None)
-        self.assertEqual(aList, [None])
-        # redundant element
-        aList = [1, 2, 3]
-        List.appendUnique(aList, 1)
-        self.assertEqual(aList, [1, 2, 3])
-        # all unique
-        aList = [1, 2]
-        List.appendUnique(aList, 3)
-        self.assertEqual(aList, [1, 2, 3])
-
-    def testRandomize(self):
-        """randomize tests"""
-        # empty list
-        aList = []
-        randList = List.randomize(aList)
-        self.assertEqual(randList, [])
-        # non empty
-        aList = ["1", "2", "3"]
-        randList = List.randomize(aList)
-        self.assertEqual(len(aList), len(randList))
-        for x in aList:
-            self.assertEqual(x in randList, True)
-        for x in randList:
-            self.assertEqual(x in aList, True)
-
-    def testPop(self):
-        """pop tests"""
-        # empty list
-        aList = []
-        x = List.pop(aList, 1)
-        self.assertEqual(aList, [])
-        self.assertEqual(x, None)
-        # pop
-        aList = [1, 2, 3]
-        x = List.pop(aList, 2)
-        self.assertEqual(x, 2)
-        self.assertEqual(aList, [1, 3])
-
-    def testStringListToString(self):
-        """stringListToString tests"""
-        # empty list
-        aList = []
-        aStr = List.stringListToString(aList)
-        self.assertEqual(aStr, "")
-        # not string elements (should it raise an exception???)
-        aList = ["a", 1]
-        aStr = List.stringListToString(aList)
-        self.assertEqual(aStr, "'a','1'")
-        # normal list
-        aList = ["a", "b", "c"]
-        aStr = List.stringListToString(aList)
-        self.assertEqual(aStr, "'a','b','c'")
-
-    def testIntListToString(self):
-        """intListToString"""
-        # empty list
-        aList = []
-        aStr = List.intListToString(aList)
-        self.assertEqual(aStr, "")
-        # int list
-        aList = [1, 2, 3]
-        aStr = List.intListToString(aList)
-        self.assertEqual(aStr, "1,2,3")
-        # mixture elements (should it raise an exception???)
-        aList = ["1", 2, 3]
-        aStr = List.intListToString(aList)
-        self.assertEqual(aStr, "1,2,3")
-
-    def testFromChar(self):
-        """fromChar tests"""
-        # empty string
-        aStr = ""
-        self.assertEqual(List.fromChar(aStr, "-"), [])
-        # wrong sep (should it raise an exception???)
-        aStr = "a:b:c"
-        self.assertEqual(List.fromChar(aStr, "-"), ["a:b:c"])
-        # norman behavior
-        aStr = "a:b:c"
-        self.assertEqual(List.fromChar(aStr, ":"), ["a", "b", "c"])
-        # only sep
-        aStr = ","
-        self.assertEqual(List.fromChar(aStr, ","), [])
-        # too many separators
-        aStr = "a,,b,,c,,,"
-        self.assertEqual(List.fromChar(aStr, ","), ["a", "b", "c"])
-
-    def testBreakListIntoChunks(self):
-        """breakListIntoChunks tests"""
-        # empty list
-        aList = []
-        self.assertEqual(List.breakListIntoChunks(aList, 5), [])
-        # negative number of chunks
-        try:
-            List.breakListIntoChunks([], -2)
-        except Exception as val:
-            self.assertEqual(isinstance(val, RuntimeError), True)
-            self.assertEqual(str(val), "chunkSize cannot be less than 1")
-
-        # normal behavior
-        aList = list(range(10))
-        self.assertEqual(List.breakListIntoChunks(aList, 5), [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])
-        # and once again this time with a rest
-        aList = list(range(10))
-        self.assertEqual(List.breakListIntoChunks(aList, 4), [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9]])
-        # almost empty list, too many chunks
-        aList = [1]
-        self.assertEqual(List.breakListIntoChunks(aList, 2), [[1]])
-
-
-# test suite execution
-if __name__ == "__main__":
-    TESTLOADER = unittest.TestLoader()
-    SUITE = TESTLOADER.loadTestsFromTestCase(ListTestCase)
-    unittest.TextTestRunner(verbosity=3).run(SUITE)

DIRAC/Core/Utilities/test/Test_Time.py

@@ -1,88 +0,0 @@
-""" Test class for plugins
-"""
-# imports
-import unittest
-
-# sut
-from DIRAC.Core.Utilities.TimeUtilities import timeThis
-
-
-class logClass:
-    def __init__(self):
-        self._systemName = "aSystemName"
-        self._subName = "sSubName"
-
-
-@timeThis
-def myMethod():
-    print("boh")
-
-
-class myClass:
-    def __init__(self):
-        self.log = logClass()
-
-    @timeThis
-    def myMethodInAClass(self):
-        print("boh")
-
-
-class myBetterClass:
-    def __init__(self):
-        self.log = logClass()
-        self.log._subName = "anotherSubName"
-
-    @timeThis
-    def myMethodInAClass(self):
-        print("boh")
-
-
-class myEvenBetterClass:
-    def __init__(self):
-        self.log = logClass()
-        self.transString = "this is a transString"
-
-    @timeThis
-    def myMethodInAClass(self, a, b=None):
-        print("boh")
-
-
-class TimeTestCase(unittest.TestCase):
-    """Base class for the Agents test cases"""
-
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
-
-
-class TimeSuccess(TimeTestCase):
-    def test_timeThis(self):
-        self.assertIsNone(myMethod())
-        self.assertIsNone(myClass().myMethodInAClass())
-        self.assertIsNone(myBetterClass().myMethodInAClass())
-        a1 = ["aa", "bb"]
-        a2 = "bb"
-        self.assertIsNone(myEvenBetterClass().myMethodInAClass(a1, b=a2))
-        a1 = "aa"
-        a2 = {"a": "aa", "b": "bb"}
-        self.assertIsNone(myEvenBetterClass().myMethodInAClass(a1, b=a2))
-        a1 = "aa"
-        a2 = {"a": "aa", "b": "bb"}
-        self.assertIsNone(myEvenBetterClass().myMethodInAClass(a=a1, b=a2))
-        a1 = "aa"
-        a2 = {"a": "aa", "b": "bb", "c": "cc"}
-        self.assertIsNone(myEvenBetterClass().myMethodInAClass(a=a2, b=a2))
-
-
-#############################################################################
-# Test Suite run
-#############################################################################
-
-if __name__ == "__main__":
-    suite = unittest.defaultTestLoader.loadTestsFromTestCase(TimeTestCase)
-    suite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(TimeSuccess))
-    testResult = unittest.TextTestRunner(verbosity=2).run(suite)
-
-# EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#

DIRAC/Resources/Computing/PilotBundle.py

@@ -1,70 +0,0 @@
-"""
-  Collection of Utilities to handle pilot jobs
-
-"""
-import os
-import base64
-import bz2
-import tempfile
-
-
-def bundleProxy(executableFile, proxy):
-    """Create a self extracting archive bundling together an executable script and a proxy"""
-
-    compressedAndEncodedProxy = base64.b64encode(bz2.compress(proxy.dumpAllToString()["Value"])).decode()
-    with open(executableFile, "rb") as fp:
-        compressedAndEncodedExecutable = base64.b64encode(bz2.compress(fp.read(), 9)).decode()
-
-    bundle = """#!/usr/bin/env python
-# Wrapper script for executable and proxy
-import os
-import tempfile
-import sys
-import stat
-import base64
-import bz2
-import shutil
-
-try:
-  workingDirectory = tempfile.mkdtemp(suffix='_wrapper', prefix='TORQUE_')
-  os.chdir(workingDirectory)
-
-  # Decode and decompress the proxy
-  with open('proxy', "wb") as proxy_file:
-    proxy_file.write(bz2.decompress(base64.b64decode("{compressedAndEncodedProxy}")))
-
-  # Decode and decompress the executable
-  with open('{executable}', "wb") as executable_file:
-    executable_file.write(bz2.decompress(base64.b64decode("{compressedAndEncodedExecutable}")))
-
-  os.chmod('proxy', stat.S_IRUSR | stat.S_IWUSR)
-  os.chmod('{executable}', stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
-  os.environ["X509_USER_PROXY"] = os.path.join(workingDirectory, 'proxy')
-except Exception as x:
-  print("Error:", x, file=sys.stderr)
-  sys.exit(-1)
-
-cmd = "./{executable}"
-print('Executing:', cmd)
-sys.stdout.flush()
-os.system(cmd)
-
-shutil.rmtree(workingDirectory)
-""".format(
-        compressedAndEncodedProxy=compressedAndEncodedProxy,
-        compressedAndEncodedExecutable=compressedAndEncodedExecutable,
-        executable=os.path.basename(executableFile),
-    )
-
-    return bundle
-
-
-def writeScript(script, writeDir=None):
-    """
-    Write script into a temporary unique file under provided writeDir
-    """
-    fd, name = tempfile.mkstemp(suffix="_pilotWrapper.py", prefix="DIRAC_", dir=writeDir)
-    pilotWrapper = os.fdopen(fd, "w")
-    pilotWrapper.write(script)
-    pilotWrapper.close()
-    return name

DIRAC/TransformationSystem/scripts/dirac_transformation_archive.py

@@ -1,30 +0,0 @@
-#!/usr/bin/env python
-"""
-Archive a transformation
-"""
-from DIRAC.Core.Base.Script import Script
-
-
-@Script()
-def main():
-    # Registering arguments will automatically add their description to the help menu
-    Script.registerArgument(["transID: transformation ID"])
-    _, args = Script.parseCommandLine()
-
-    transIDs = [int(arg) for arg in args]
-
-    from DIRAC.TransformationSystem.Agent.TransformationCleaningAgent import TransformationCleaningAgent
-
-    agent = TransformationCleaningAgent(
-        "Transformation/TransformationCleaningAgent",
-        "Transformation/TransformationCleaningAgent",
-        "dirac-transformation-archive",
-    )
-    agent.initialize()
-
-    for transID in transIDs:
-        agent.archiveTransformation(transID)
-
-
-if __name__ == "__main__":
-    main()

DIRAC/TransformationSystem/scripts/dirac_transformation_clean.py

@@ -1,30 +0,0 @@
-#!/usr/bin/env python
-"""
-Clean a tranformation
-"""
-from DIRAC.Core.Base.Script import Script
-
-
-@Script()
-def main():
-    # Registering arguments will automatically add their description to the help menu
-    Script.registerArgument(["transID: transformation ID"])
-    _, args = Script.parseCommandLine()
-
-    from DIRAC.TransformationSystem.Agent.TransformationCleaningAgent import TransformationCleaningAgent
-
-    transIDs = [int(arg) for arg in args]
-
-    agent = TransformationCleaningAgent(
-        "Transformation/TransformationCleaningAgent",
-        "Transformation/TransformationCleaningAgent",
-        "dirac-transformation-clean",
-    )
-    agent.initialize()
-
-    for transID in transIDs:
-        agent.cleanTransformation(transID)
-
-
-if __name__ == "__main__":
-    main()

DIRAC/TransformationSystem/scripts/dirac_transformation_remove_output.py

@@ -1,30 +0,0 @@
-#!/usr/bin/env python
-"""
-Remove the outputs produced by a transformation
-"""
-from DIRAC.Core.Base.Script import Script
-
-
-@Script()
-def main():
-    # Registering arguments will automatically add their description to the help menu
-    Script.registerArgument(["transID: transformation ID"])
-    _, args = Script.parseCommandLine()
-
-    transIDs = [int(arg) for arg in args]
-
-    from DIRAC.TransformationSystem.Agent.TransformationCleaningAgent import TransformationCleaningAgent
-
-    agent = TransformationCleaningAgent(
-        "Transformation/TransformationCleaningAgent",
-        "Transformation/TransformationCleaningAgent",
-        "dirac-transformation-remove-output",
-    )
-    agent.initialize()
-
-    for transID in transIDs:
-        agent.removeTransformationOutput(transID)
-
-
-if __name__ == "__main__":
-    main()

DIRAC/WorkloadManagementSystem/Utilities/test/Test_JobManager.py

@@ -1,58 +0,0 @@
-""" unit test (pytest) of JobManager service
-"""
-
-from unittest.mock import MagicMock
-import pytest
-
-from DIRAC import gLogger
-
-gLogger.setLevel("DEBUG")
-
-from DIRAC.WorkloadManagementSystem.Service.JobPolicy import (
-    RIGHT_DELETE,
-    RIGHT_KILL,
-)
-
-# sut
-from DIRAC.WorkloadManagementSystem.Service.JobManagerHandler import JobManagerHandlerMixin
-
-# mocks
-jobPolicy_mock = MagicMock()
-jobDB_mock = MagicMock()
-jobDB_mock.getJobsAttributes.return_value = {"OK": True, "Value": {}}
-
-
-@pytest.mark.parametrize(
-    "jobIDs_list, right, lists, filteredJobsList, expected_res, expected_value",
-    [
-        ([], RIGHT_KILL, ([], [], [], []), [], True, []),
-        ([], RIGHT_DELETE, ([], [], [], []), [], True, []),
-        (1, RIGHT_KILL, ([], [], [], []), [], True, []),
-        (1, RIGHT_KILL, ([1], [], [], []), [], True, []),
-        ([1, 2], RIGHT_KILL, ([], [], [], []), [], True, []),
-        ([1, 2], RIGHT_KILL, ([1], [], [], []), [], True, []),
-        (1, RIGHT_KILL, ([1], [], [], []), [1], True, [1]),
-        ([1, 2], RIGHT_KILL, ([1], [], [], []), [1], True, [1]),
-        ([1, 2], RIGHT_KILL, ([1], [2], [], []), [1], True, [1]),
-        ([1, 2], RIGHT_KILL, ([1], [2], [], []), [], True, []),
-        ([1, 2], RIGHT_KILL, ([1, 2], [], [], []), [1, 2], True, [1, 2]),
-    ],
-)
-def test___kill_delete_jobs(mocker, jobIDs_list, right, lists, filteredJobsList, expected_res, expected_value):
-    mocker.patch(
-        "DIRAC.WorkloadManagementSystem.Service.JobManagerHandler.filterJobStateTransition",
-        return_value={"OK": True, "Value": filteredJobsList},
-    )
-
-    JobManagerHandlerMixin.log = gLogger
-    JobManagerHandlerMixin.jobPolicy = jobPolicy_mock
-    JobManagerHandlerMixin.jobDB = jobDB_mock
-    JobManagerHandlerMixin.taskQueueDB = MagicMock()
-
-    jobPolicy_mock.evaluateJobRights.return_value = lists
-
-    jm = JobManagerHandlerMixin()
-
-    res = jm._kill_delete_jobs(jobIDs_list, right)
-    assert res["OK"] == expected_res
-    assert res["Value"] == expected_value