panda-server-source 1.0.4__tar.gz → 1.1.0__tar.gz

panda_server_source-1.1.0/.pre-commit-config.yaml

@@ -0,0 +1,73 @@
+repos:
+
+# What is checked, and at which version, is defined here rather than in the CI workflow,
+# so that `pre-commit run --all-files` gives a contributor the same answer CI will.
+# Do not add a check to CI without adding it here.
+
+# ruff stands in for black, isort and flynt as well as being the linter: one pin instead
+# of three, and one tool to reason about. Its formatter targets black's style but is not
+# byte-identical to it, which is why the switch came with a one-time reformat of the tree.
+#
+# The rules and the line length live in [tool.ruff] in pyproject.toml, so --isolated is
+# deliberately absent here and a developer running ruff by hand gets the same answer.
+-   repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.16.9
+    hooks:
+    # The whole tree, not just the staged files: the scan takes hundredths of a second,
+    # and a name can be broken by an edit somewhere else -- a renamed import, a deleted
+    # helper, a moved class.
+    -   id: ruff-check
+        args: [--fix, .]
+        pass_filenames: false
+    -   id: ruff-format
+
+-   repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v2.3.1
+    hooks:
+    # The tree is clean under the flags in [tool.mypy], so the gate is mypy itself: any
+    # finding fails the hook. Do not swap it for a count -- annotating a function turns on
+    # checking of its whole body, so improving annotations can raise the number before it
+    # lowers it. With zero as the bar that goes away.
+    #
+    # args is emptied because this mirror otherwise passes --ignore-missing-imports and
+    # --scripts-are-modules, which would override pyproject.toml. pass_filenames is off
+    # for the same reason: handing mypy the staged files would both miss files that an
+    # edit elsewhere breaks and change which flags apply.
+    #
+    # mypy and the stubs are pinned together: the stubs are part of what the run sees, so
+    # an unpinned upgrade would produce findings without a code change. When upgrading
+    # either, fix what the new version reports in the same PR.
+    #
+    # panda-common is deliberately absent. It ships py.typed, so installing it changes
+    # what mypy resolves, and this hook is the gate.
+    -   id: mypy
+        args: []
+        additional_dependencies:
+        -   types-requests==2.33.0.20260906
+        -   types-PyYAML==6.0.12.20260906
+        pass_filenames: false
+
+-   repo: local
+    hooks:
+    # None of the hooks above executes a class body, so a class that cannot be created
+    # passes all of them and fails at import time instead -- in a daemon, an outage rather
+    # than a failed check. The case this tree can actually reach is a class attribute that
+    # carries a value while its name is in __slots__, which raises ValueError when the
+    # class is built. Annotating the spec classes is exactly the work that invites it,
+    # since the obvious way to write one is `status: str = ""`.
+    #
+    # These four are the spec classes that assign __slots__ and import without a config
+    # file. The fifth, daemons/utils.py's DaemonWorker, is left out on purpose: it pulls in
+    # pandaserver.config.panda_config, which reads panda_server.cfg at import time and does
+    # not swallow the failure, so covering it would mean shipping a config.
+    #
+    # panda-common carries no version here: the hook only needs it to be importable, and
+    # the bound belongs in pyproject.toml alone. This hook gets its own environment, so
+    # installing panda-common here does not reach the mypy hook above.
+    -   id: slots-import
+        name: import the classes that build __slots__
+        language: python
+        entry: python -c "import pandaserver.taskbuffer.JobSpec, pandaserver.taskbuffer.FileSpec, pandaserver.taskbuffer.WorkerSpec, pandaserver.taskbuffer.HarvesterMetricsSpec"
+        additional_dependencies: ['panda-common']
+        pass_filenames: false
+        always_run: true

{panda_server_source-1.0.4 → panda_server_source-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: panda-server-source
-Version: 1.0.4
+Version: 1.1.0
 Summary: Unified PanDA Server and JEDI Package - Source Only
 Project-URL: Homepage, https://panda-wms.readthedocs.io/en/latest/
 Author-email: PanDA Team <panda-support@cern.ch>

panda_server_source-1.1.0/PandaPkgInfo.py

@@ -0,0 +1 @@
+release_version = "1.1.0"

{panda_server_source-1.0.4 → panda_server_source-1.1.0}/package/hatch_build.py

@@ -105,8 +105,8 @@ def mm_notification():
     }
     headers = {"Content-Type": "application/json"}
     try:
-        response = requests.post(mm_webhook_url, data=json.dumps(mm_message), headers=headers)
-    except requests.exceptions.RequestException as e:
+        requests.post(mm_webhook_url, data=json.dumps(mm_message), headers=headers)
+    except requests.exceptions.RequestException:
         pass
 
 

{panda_server_source-1.0.4 → panda_server_source-1.1.0}/pandajedi/jedibrokerage/AtlasAnalJobBroker.py

@@ -3,18 +3,21 @@ import datetime
 import math
 import random
 import re
-import sys
 import traceback
+from typing import Any
 
 from pandacommon.pandalogger.PandaLogger import PandaLogger
 from pandacommon.pandautils.PandaUtils import naive_utcnow
 
 from pandajedi.jedicore import Interaction
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
 from pandajedi.jedicore.MsgWrapper import MsgWrapper
 from pandajedi.jedicore.SiteCandidate import SiteCandidate
 from pandaserver.dataservice.DataServiceUtils import select_scope
 from pandaserver.srvcore import CoreUtils
 from pandaserver.taskbuffer import JobUtils
+from pandaserver.taskbuffer.InputChunk import InputChunk
+from pandaserver.taskbuffer.JediTaskSpec import JediTaskSpec
 
 from . import AtlasBrokerUtils
 from .JobBrokerBase import JobBrokerBase
@@ -30,9 +33,9 @@ VO = "atlas"
 # brokerage for ATLAS analysis
 class AtlasAnalJobBroker(JobBrokerBase):
     # constructor
-    def __init__(self, ddmIF, taskBufferIF):
+    def __init__(self, ddmIF: Interaction.CommandSendInterface, taskBufferIF: JediTaskBufferInterface) -> None:
         JobBrokerBase.__init__(self, ddmIF, taskBufferIF)
-        self.dataSiteMap = {}
+        self.dataSiteMap: dict[str, Any] = {}
 
         # load the SW availability map
         try:
@@ -56,7 +59,9 @@ class AtlasAnalJobBroker(JobBrokerBase):
             self.wn_gpu_map = {}
 
     # main
-    def doBrokerage(self, taskSpec, cloudName, inputChunk, taskParamMap):
+    def doBrokerage(
+        self, taskSpec: JediTaskSpec, cloudName: str | None, inputChunk: InputChunk, taskParamMap: dict[str, Any] | None
+    ) -> tuple[Interaction.StatusCode, InputChunk]:
         # make logger
         if inputChunk.masterDataset:
             msg_tag = f"<jediTaskID={taskSpec.jediTaskID} datasetID={inputChunk.masterDataset.datasetID}>"
@@ -70,6 +75,20 @@ class AtlasAnalJobBroker(JobBrokerBase):
         # return when the task is only waiting for something it cannot control, so that
         # it is not penalized with the pending timeout while it waits
         retWaiting = self.SC_WAITING, inputChunk
+        # doBrokerage returns either one of the error tuples above or None. Declared
+        # without a value, which binds nothing at runtime, so that the first assignment
+        # further down does not fix retVal to the tuple type alone.
+        retVal: tuple[Interaction.StatusCode, Any] | None
+        # the brokerage arithmetic below cannot run on a NULL column; a task read from the DB
+        # always carries these, so one that does not is reported rather than crashing mid-scan
+        if taskSpec.currentPriority is None or taskSpec.cpuEfficiency is None or taskSpec.prodSourceLabel is None or taskSpec.taskPriority is None:
+            tmpLog.error(
+                f"cannot broker with currentPriority={taskSpec.currentPriority} cpuEfficiency={taskSpec.cpuEfficiency} "
+                f"prodSourceLabel={taskSpec.prodSourceLabel} taskPriority={taskSpec.taskPriority}"
+            )
+            return retTmpError
+        # a NULL baseWalltime is no offset, as everywhere else it is read
+        baseWalltime = taskSpec.baseWalltime if taskSpec.baseWalltime is not None else 0
         # new maxwdir
         newMaxwdir = {}
         # get primary site candidates
@@ -79,7 +98,7 @@ class AtlasAnalJobBroker(JobBrokerBase):
         includeList = None
         scanSiteList = []
         # problematic sites
-        problematic_sites_dict = {}
+        problematic_sites_dict: dict[str, Any] = {}
         # not to use VP replicas for merging, scouts, and forceStaged
         if inputChunk.isMerging or taskSpec.avoid_vp() or taskSpec.useScout() or taskSpec.useLocalIO():
             useVP = False
@@ -92,8 +111,10 @@ class AtlasAnalJobBroker(JobBrokerBase):
         # get workQueue
         workQueue = self.taskBufferIF.getWorkQueueMap().getQueueWithIDGshare(taskSpec.workQueue_ID, taskSpec.gshare)
 
-        # site limitation
-        if taskSpec.useLimitedSites():
+        # site limitation. JobGenerator fills taskParamMap in exactly when the task uses
+        # limited sites and leaves it None otherwise, so this branch is the only place
+        # here that may read it
+        if taskSpec.useLimitedSites() and taskParamMap is not None:
             if "excludedSite" in taskParamMap:
                 excludeList = taskParamMap["excludedSite"]
                 # str to list for task retry
@@ -106,13 +127,16 @@ class AtlasAnalJobBroker(JobBrokerBase):
                 includeList = taskParamMap["includedSite"]
                 # str to list for task retry
                 if includeList == "":
+                    # nothing was pre-assigned. The split below cannot run on None, and
+                    # the AttributeError it raised into the handler was doing this check
                     includeList = None
-                try:
-                    if not isinstance(includeList, list):
-                        includeList = includeList.split(",")
-                    siteListPreAssigned = True
-                except Exception:
-                    pass
+                else:
+                    try:
+                        if not isinstance(includeList, list):
+                            includeList = includeList.split(",")
+                        siteListPreAssigned = True
+                    except Exception:
+                        pass
         # loop over all sites
         for siteName, tmpSiteSpec in self.siteMapper.siteSpecList.items():
             if tmpSiteSpec.type == "analysis" or tmpSiteSpec.is_grandly_unified():
@@ -356,7 +380,7 @@ class AtlasAnalJobBroker(JobBrokerBase):
 
         # cannot get local quota
         if not local_quota_ok:
-            tmpLog.error(f"failed to check local quota")
+            tmpLog.error("failed to check local quota")
             taskSpec.setErrDiag(tmpLog.uploadLog(taskSpec.jediTaskID))
             return retTmpError
 
@@ -375,7 +399,7 @@ class AtlasAnalJobBroker(JobBrokerBase):
         loc_check_timeout_val = self.taskBufferIF.getConfigValue(ANALYSIS_COMPONENT, loc_check_timeout_key, "jedi", taskSpec.vo)
 
         # check input datasets
-        element_map = dict()
+        element_map: dict[str, Any] = dict()
         ddsList = set()
         complete_disk_ok = {}
         complete_tape_ok = {}
@@ -417,6 +441,11 @@ class AtlasAnalJobBroker(JobBrokerBase):
                         tmpLog.error(f"fatal error when getting the list of sites where data is available, since {tmpRet}")
                         taskSpec.setErrDiag(tmpLog.uploadLog(taskSpec.jediTaskID))
                         return retFatal
+                    if not isinstance(tmpRet, dict):
+                        # only the error paths handled above return a message in its place
+                        tmpLog.error(f"failed to get the list of sites where data is available, since {tmpRet}")
+                        taskSpec.setErrDiag(tmpLog.uploadLog(taskSpec.jediTaskID))
+                        return retTmpError
                     # append
                     self.dataSiteMap[datasetName] = tmpRet
                     complete_disk_ok[datasetName] = tmp_complete_disk_ok
@@ -520,10 +549,10 @@ class AtlasAnalJobBroker(JobBrokerBase):
 
         retVal = None
         checkDataLocality = False
-        scanSiteWoVP = []
-        summaryList = []
-        site_list_with_data = None
-        overall_site_list = set()
+        scanSiteWoVP: list[Any] = []
+        # the sites that had the data in the first loop pass, kept for the ranking below
+        site_list_with_data: set[str] = set()
+        overall_site_list: set[str] = set()
         for i_loop, (scanSiteList, checkDataLocality) in enumerate(scan_site_list_loops):
             useUnionLocality = False
             self.init_summary_list("Job brokerage summary", f"data locality check: {checkDataLocality}", self.get_unified_sites(scanSiteList))
@@ -534,8 +563,8 @@ class AtlasAnalJobBroker(JobBrokerBase):
             ######################################
             # selection for data availability
             hasDDS = False
-            dataWeight = {}
-            remoteSourceList = {}
+            dataWeight: dict[str, Any] = {}
+            remoteSourceList: dict[str, Any] = {}
             sites_in_nucleus = []
             for datasetSpec in inputChunk.getDatasets():
                 datasetSpec.reset_distributed()
@@ -552,12 +581,15 @@ class AtlasAnalJobBroker(JobBrokerBase):
                     if datasetName in ddsList:
                         datasetSpec.setDistributed()
 
-                # get the list of sites where data is available
-                scanSiteList = None
-                scanSiteListOnDisk = None
-                scanSiteListUnion = None
-                scanSiteListOnDiskUnion = None
-                scanSiteWoVpUnion = None
+                # get the list of sites where data is available. The first dataset seeds
+                # the lists and the rest intersect with them, which is what the flag marks;
+                # with no dataset at all they stay empty and the checks below find nothing
+                scanSiteList = []
+                scanSiteListOnDisk: set[str] = set()
+                scanSiteListUnion: set[str] = set()
+                scanSiteListOnDiskUnion: set[str] = set()
+                scanSiteWoVpUnion: set[str] = set()
+                is_first_dataset = True
 
                 for datasetName, tmpDataSite in self.dataSiteMap.items():
                     # check if incomplete replica is allowed
@@ -582,7 +614,8 @@ class AtlasAnalJobBroker(JobBrokerBase):
                             dataWeight[tmpSiteName] += 0.001
 
                     # first list
-                    if scanSiteList is None:
+                    if is_first_dataset:
+                        is_first_dataset = False
                         scanSiteList = []
                         for tmpSiteName in tmpSiteList:
                             if tmpSiteName not in oldScanUnifiedSiteList:
@@ -736,7 +769,7 @@ class AtlasAnalJobBroker(JobBrokerBase):
                     diskio_limit_tmp = max_diskio_per_core_default
 
                 # normalize task diskIO by site corecount
-                diskio_task_tmp = taskSpec.diskIO
+                diskio_task_tmp: float | None = taskSpec.diskIO
                 if taskSpec.diskIO is not None and taskSpec.coreCount not in [None, 0, 1] and tmp_site_spec.coreCount not in [None, 0]:
                     diskio_task_tmp = taskSpec.diskIO / tmp_site_spec.coreCount
 
@@ -771,20 +804,28 @@ class AtlasAnalJobBroker(JobBrokerBase):
 
             ######################################
             # selection with IO intensity
-            if taskSpec.ioIntensity and not inputChunk.isMerging:
+            if not inputChunk.isMerging:
                 newScanSiteList = []
                 oldScanSiteList = copy.copy(scanSiteList)
                 msg_map = {}
                 for tmpSiteName in scanSiteList:
                     tmpSiteSpec = self.siteMapper.getSite(tmpSiteName)
                     max_io_intensity = tmpSiteSpec.get_max_io_intensity()
-                    if max_io_intensity is None or taskSpec.ioIntensity <= max_io_intensity:
-                        newScanSiteList.append(tmpSiteName)
+                    if taskSpec.ioIntensity is None:
+                        if max_io_intensity is None:
+                            newScanSiteList.append(tmpSiteName)
+                        else:
+                            msg_map[tmpSiteSpec.get_unified_name()] = (
+                                f"  skip site={tmpSiteSpec.get_unified_name()} since task ioIntensity is None and site max_io_intensity={max_io_intensity} criteria=-max_io_intensity"
+                            )
                     else:
-                        msg_map[tmpSiteSpec.get_unified_name()] = (
-                            f"  skip site={tmpSiteSpec.get_unified_name()} since ioIntensity={taskSpec.ioIntensity} "
-                            f"is larger than site max_io_intensity={max_io_intensity} criteria=-max_io_intensity"
-                        )
+                        if max_io_intensity is None or taskSpec.ioIntensity <= max_io_intensity:
+                            newScanSiteList.append(tmpSiteName)
+                        else:
+                            msg_map[tmpSiteSpec.get_unified_name()] = (
+                                f"  skip site={tmpSiteSpec.get_unified_name()} since ioIntensity={taskSpec.ioIntensity} "
+                                f"is larger than site max_io_intensity={max_io_intensity} criteria=-max_io_intensity"
+                            )
                 scanSiteList = newScanSiteList
                 self.add_summary_message(oldScanSiteList, scanSiteList, "max IO intensity check", tmpLog, msg_map)
                 if not scanSiteList:
@@ -874,26 +915,6 @@ class AtlasAnalJobBroker(JobBrokerBase):
                 retVal = retTmpError
                 continue
             ######################################
-            # selection for closed
-            if not sitePreAssigned and not inputChunk.isMerging:
-                oldScanSiteList = copy.copy(scanSiteList)
-                newScanSiteList = []
-                msg_map = {}
-                for tmpSiteName in self.get_unified_sites(scanSiteList):
-                    if tmpSiteName in failureCounts and "closed" in failureCounts[tmpSiteName]:
-                        nClosed = failureCounts[tmpSiteName]["closed"]
-                        if nClosed > 0:
-                            msg_map[tmpSiteName] = f"  skip site={tmpSiteName} due to n_closed={nClosed} criteria=-closed"
-                            continue
-                    newScanSiteList.append(tmpSiteName)
-                scanSiteList = self.get_pseudo_sites(newScanSiteList, scanSiteList)
-                self.add_summary_message(oldScanSiteList, scanSiteList, "too many closed check", tmpLog, msg_map)
-                if not scanSiteList:
-                    self.dump_summary(tmpLog)
-                    tmpLog.error("no candidates")
-                    retVal = retTmpError
-                    continue
-            ######################################
             # selection for release
             cmt_config = taskSpec.get_sw_platform()
             is_regexp_cmt_config = False
@@ -1072,21 +1093,22 @@ class AtlasAnalJobBroker(JobBrokerBase):
                     if taskSpec.ramPerCore() and not inputChunk.isMerging:
                         if tmpSiteSpec.coreCount not in [None, 0]:
                             minRamCount = origMinRamCount * tmpSiteSpec.coreCount
-                    minRamCount = JobUtils.compensate_ram_count(minRamCount)
+                    compensated_min_ram_count = JobUtils.compensate_ram_count(minRamCount)
+                    minRamCount = compensated_min_ram_count if compensated_min_ram_count is not None else 0
                     # site max memory requirement
-                    site_maxmemory = 0
+                    site_maxmemory: float = 0
                     if tmpSiteSpec.maxrss not in [0, None]:
                         site_maxmemory = tmpSiteSpec.maxrss
-                    if site_maxmemory not in [0, None] and minRamCount != 0 and minRamCount > site_maxmemory:
+                    if site_maxmemory not in [0, None] and minRamCount and minRamCount > site_maxmemory:
                         msg_map[tmpSiteSpec.get_unified_name()] = (
                             f"  skip site={tmpSiteSpec.get_unified_name()} due to insufficient RAM less than job's core-scaled requirement {minRamCount} MB criteria=-lowmemory"
                         )
                         continue
                     # site min memory requirement
-                    site_minmemory = 0
+                    site_minmemory: float = 0
                     if tmpSiteSpec.minrss not in [0, None]:
                         site_minmemory = tmpSiteSpec.minrss
-                    if site_minmemory not in [0, None] and minRamCount != 0 and minRamCount < site_minmemory:
+                    if site_minmemory not in [0, None] and minRamCount and minRamCount < site_minmemory:
                         msg_map[tmpSiteSpec.get_unified_name()] = (
                             f"  skip site={tmpSiteSpec.get_unified_name()} due to RAM lower limit greater than job's core-scaled requirement {minRamCount} MB criteria=-highmemory"
                         )
@@ -1117,7 +1139,7 @@ class AtlasAnalJobBroker(JobBrokerBase):
                 else:
                     maxSizePerJob //= 1024 * 1024
                 # size for direct IO sites
-                minDiskCountR = tmpOutDiskSize * tmpEffAtomSize + tmpWorkDiskSize
+                minDiskCountR: Any = tmpOutDiskSize * tmpEffAtomSize + tmpWorkDiskSize
                 minDiskCountR = minDiskCountR // 1024 // 1024
                 tmpLog.info(f"maxAtomSize={tmpMaxAtomSize} effectiveAtomSize={tmpEffAtomSize} outDiskCount={tmpOutDiskSize} workDiskSize={tmpWorkDiskSize}")
             else:
@@ -1140,9 +1162,9 @@ class AtlasAnalJobBroker(JobBrokerBase):
                 # check disk space
                 if tmpSiteSpec.maxwdir:
                     if CoreUtils.use_direct_io_for_job(taskSpec, tmpSiteSpec, inputChunk):
-                        minDiskCount = minDiskCountR
+                        minDiskCount: Any = minDiskCountR
                         if maxSizePerJob is not None and not taskSpec.useLocalIO():
-                            tmpMinDiskCountR = tmpOutDiskSize * maxSizePerJob + tmpWorkDiskSize
+                            tmpMinDiskCountR: float = tmpOutDiskSize * maxSizePerJob + tmpWorkDiskSize
                             tmpMinDiskCountR /= 1024 * 1024
                             if tmpMinDiskCountR > minDiskCount:
                                 minDiskCount = tmpMinDiskCountR
@@ -1221,8 +1243,10 @@ class AtlasAnalJobBroker(JobBrokerBase):
                                 )
                                 continue
                 # check if blacklisted
-                tmp_msg = AtlasBrokerUtils.check_endpoints_with_blacklist(tmpSiteSpec, scope_input, scope_output, sites_in_nucleus, remote_source_available)
-                if tmp_msg is not None:
+                blacklist_msg = AtlasBrokerUtils.check_endpoints_with_blacklist(
+                    tmpSiteSpec, scope_input, scope_output, sites_in_nucleus, remote_source_available
+                )
+                if blacklist_msg is not None:
                     msg_map[tmpSiteName] = f"  skip site={tmpSiteName} since {tmpSiteSpec.ddm_output[scope_output]} is blacklisted in DDM criteria=-blacklist"
                     continue
                 # local quota
@@ -1248,8 +1272,9 @@ class AtlasAnalJobBroker(JobBrokerBase):
                 strMinWalltime = f"walltime*inputSize={taskSpec.walltime}*{tmpMaxAtomSize}"
             else:
                 tmpMaxAtomSize = inputChunk.getMaxAtomSize(getNumEvents=True)
-                if taskSpec.getCpuTime() is not None:
-                    minWalltime = taskSpec.getCpuTime() * tmpMaxAtomSize
+                cpu_time = taskSpec.getCpuTime()
+                if cpu_time is not None:
+                    minWalltime = cpu_time * tmpMaxAtomSize
                 else:
                     minWalltime = None
                 strMinWalltime = f"cpuTime*nEventsPerJob={taskSpec.getCpuTime()}*{tmpMaxAtomSize}"
@@ -1259,14 +1284,15 @@ class AtlasAnalJobBroker(JobBrokerBase):
                 msg_map = {}
                 for tmpSiteName in scanSiteList:
                     tmpSiteSpec = self.siteMapper.getSite(tmpSiteName)
-                    siteMaxTime = tmpSiteSpec.maxtime
+                    # a site with no maxtime imposes no ceiling, the same as 0 below and as in JobSplitter
+                    siteMaxTime: float = tmpSiteSpec.maxtime if tmpSiteSpec.maxtime is not None else 0
                     origSiteMaxTime = siteMaxTime
                     # check max walltime at the site
                     tmpSiteStr = f"{siteMaxTime}"
                     if taskSpec.useHS06():
                         oldSiteMaxTime = siteMaxTime
-                        siteMaxTime -= taskSpec.baseWalltime
-                        tmpSiteStr = f"({oldSiteMaxTime}-{taskSpec.baseWalltime})"
+                        siteMaxTime -= baseWalltime
+                        tmpSiteStr = f"({oldSiteMaxTime}-{baseWalltime})"
                     if siteMaxTime not in [None, 0] and tmpSiteSpec.coreCount not in [None, 0]:
                         siteMaxTime *= tmpSiteSpec.coreCount
                         tmpSiteStr += f"*{tmpSiteSpec.coreCount}"
@@ -1283,13 +1309,13 @@ class AtlasAnalJobBroker(JobBrokerBase):
                         msg_map[tmpSiteSpec.get_unified_name()] = tmpMsg
                         continue
                     # check min walltime at the site
-                    siteMinTime = tmpSiteSpec.mintime
+                    siteMinTime: float = tmpSiteSpec.mintime
                     origSiteMinTime = siteMinTime
                     tmpSiteStr = f"{siteMinTime}"
                     if taskSpec.useHS06():
                         oldSiteMinTime = siteMinTime
-                        siteMinTime -= taskSpec.baseWalltime
-                        tmpSiteStr = f"({oldSiteMinTime}-{taskSpec.baseWalltime})"
+                        siteMinTime -= baseWalltime
+                        tmpSiteStr = f"({oldSiteMinTime}-{baseWalltime})"
                     if siteMinTime not in [None, 0] and tmpSiteSpec.coreCount not in [None, 0]:
                         siteMinTime *= tmpSiteSpec.coreCount
                         tmpSiteStr += f"*{tmpSiteSpec.coreCount}"
@@ -1332,12 +1358,13 @@ class AtlasAnalJobBroker(JobBrokerBase):
                 msg_map = {}
                 for tmpSiteName in scanSiteList:
                     tmpSiteSpec = self.siteMapper.getSite(tmpSiteName)
-                    siteMaxTime = tmpSiteSpec.maxtime
+                    # a site with no maxtime imposes no ceiling, the same as 0 below and as in JobSplitter
+                    siteMaxTime = tmpSiteSpec.maxtime if tmpSiteSpec.maxtime is not None else 0
                     tmpSiteStr = f"{siteMaxTime}"
                     if taskSpec.useHS06():
                         oldSiteMaxTime = siteMaxTime
-                        siteMaxTime -= taskSpec.baseWalltime
-                        tmpSiteStr = f"({oldSiteMaxTime}-{taskSpec.baseWalltime})"
+                        siteMaxTime -= baseWalltime
+                        tmpSiteStr = f"({oldSiteMaxTime}-{baseWalltime})"
                     if siteMaxTime not in [None, 0] and tmpSiteSpec.coreCount not in [None, 0]:
                         siteMaxTime *= tmpSiteSpec.coreCount
                         tmpSiteStr += f"*{tmpSiteSpec.coreCount}"
@@ -1567,7 +1594,9 @@ class AtlasAnalJobBroker(JobBrokerBase):
                     for jobStatus in ["defined", "assigned", "activated", "starting"]:
                         nQueue += AtlasBrokerUtils.getNumJobs(jobStatPrioMap, tmpSiteName, jobStatus, workQueue_tag=taskSpec.gshare)
                     # skip if overloaded
-                    if nQueue > minQueue and (nRunning == 0 or float(nQueue) / float(nRunning) > grandRatio * ratioOffset):
+                    # grandRatio is None only when nothing is running in the share at all, in
+                    # which case every site takes the nRunning == 0 branch before the ratio is used
+                    if nQueue > minQueue and (nRunning == 0 or (grandRatio is not None and float(nQueue) / float(nRunning) > grandRatio * ratioOffset)):
                         tmpMsg = f"  skip site={tmpSiteName} "
                         tmpMsg += f"nQueue>minQueue({minQueue}) and "
                         if nRunning == 0:
@@ -1746,7 +1775,7 @@ class AtlasAnalJobBroker(JobBrokerBase):
                     for tmpPseudoSiteName, error_diag in candidates_with_problems:
                         tmpSiteSpec = self.siteMapper.getSite(tmpPseudoSiteName)
                         msg_map[tmpSiteSpec.get_unified_name()] = (
-                            f"  skip site={tmpSiteSpec.get_unified_name()} due to a temporary user-specific problem: {error_diag} " "criteria=-tmp_user_problem"
+                            f"  skip site={tmpSiteSpec.get_unified_name()} due to a temporary user-specific problem: {error_diag} criteria=-tmp_user_problem"
                         )
                     self.add_summary_message(scanSiteList, [], "temp user problem check", tmpLog, msg_map)
                     self.dump_summary(tmpLog)
@@ -1757,7 +1786,7 @@ class AtlasAnalJobBroker(JobBrokerBase):
             ############
             # loop end
             overall_site_list.update(scanSiteList)
-            if site_list_with_data is None:
+            if not site_list_with_data:
                 # preserve site list with data
                 site_list_with_data = set(scanSiteList)
             if len(overall_site_list) >= taskSpec.getNumSitesPerJob():
@@ -1810,16 +1839,15 @@ class AtlasAnalJobBroker(JobBrokerBase):
                 if tmpAvFileMap is None:
                     raise Interaction.JEDITemporaryError("ddmIF.getAvailableFiles failed")
                 availableFileMap[datasetSpec.datasetName] = tmpAvFileMap
-            except Exception:
-                errtype, errvalue = sys.exc_info()[:2]
-                tmpLog.error(f"failed to get available files with {errtype.__name__} {errvalue}")
+            except Exception as e:
+                tmpLog.error(f"failed to get available files with {type(e).__name__} {e}")
                 taskSpec.setErrDiag(tmpLog.uploadLog(taskSpec.jediTaskID))
                 return retTmpError
         # make data weight
         totalSize = 0
         totalNumFiles = 0
-        totalDiskSizeMap = dict()
-        totalTapeSizeMap = dict()
+        totalDiskSizeMap: dict[str, Any] = dict()
+        totalTapeSizeMap: dict[str, Any] = dict()
         for datasetSpec in inputChunk.getDatasets():
             totalNumFiles += len(datasetSpec.Files)
             for fileSpec in datasetSpec.Files:
@@ -1841,11 +1869,11 @@ class AtlasAnalJobBroker(JobBrokerBase):
         ######################################
         # final procedure
         tmpLog.info(f"{len(scanSiteList)} candidates for final check")
-        weightMap = {}
+        weightMap: dict[str, Any] = {}
         weightStr = {}
         candidateSpecList = []
         preSiteCandidateSpec = None
-        basic_weight_compar_map = {}
+        basic_weight_compar_map: dict[str, Any] = {}
         workerStat = self.taskBufferIF.ups_load_worker_stats()
         for tmpPseudoSiteName in scanSiteList:
             tmpSiteSpec = self.siteMapper.getSite(tmpPseudoSiteName)
@@ -1899,12 +1927,10 @@ class AtlasAnalJobBroker(JobBrokerBase):
                 if isinstance(site_to_running_rate, dict):
                     site_to_running_rate = sum(site_to_running_rate.values())
             except KeyError:
-                to_running_rate_str = "0(unknown)"
                 to_running_rate = 0
             else:
                 site_n_running = AtlasBrokerUtils.getNumJobs(jobStatPrioMap, tmpSiteName, "running")
                 to_running_rate = nRunning * site_to_running_rate / site_n_running if site_n_running > 0 else 0
-                to_running_rate_str = f"{to_running_rate:.3f}"
             # site class value; by default mid-class (= 0) if unclassified
             site_class_value = analy_sites_class_dict.get(tmpSiteName, 0)
             site_class_value = 0 if site_class_value is None else site_class_value
@@ -2049,7 +2075,7 @@ class AtlasAnalJobBroker(JobBrokerBase):
                 # main weight, for User Analysis, determined by number of jobs to submit to each site class
                 main_weight_site_class_dict = {1: weight_epsilon_init, 0: weight_epsilon_init, -1: weight_epsilon_init}
                 if taskSpec.gshare in ["User Analysis", "Express Analysis"]:
-                    n_jobs_to_submit_rem = min(n_jobs_to_submit, total_rem_q_len)
+                    n_jobs_to_submit_rem: float = min(n_jobs_to_submit, total_rem_q_len)
                     if task_class_value == -1:
                         # C-task
                         main_weight_site_class_dict[-1] = n_jobs_to_submit_rem
@@ -2076,11 +2102,11 @@ class AtlasAnalJobBroker(JobBrokerBase):
                 for site in weight_comparison_avail_sites:
                     bw_map = basic_weight_compar_map[site]
                     # main weight by site & task class for User Analysis, and constant for group shares
-                    nbw_main = n_jobs_to_submit
+                    nbw_main: float = n_jobs_to_submit
                     if taskSpec.gshare in ["User Analysis", "Express Analysis"]:
                         nbw_main = main_weight_site_class_dict[bw_map["class"]]
                     # secondary weight proportional to remaining queue length
-                    nbw_sec = 1
+                    nbw_sec: float = 1
                     if taskSpec.gshare in ["User Analysis", "Express Analysis"]:
                         _nbw_numer = max(bw_map["rem_q_len"] - nbw_main / site_class_n_site_dict[bw_map["class"]], nbw_main * 0.001)
                         reduced_site_class_rem_q_len = site_class_rem_q_len_dict[bw_map["class"]] - nbw_main
@@ -2180,7 +2206,7 @@ class AtlasAnalJobBroker(JobBrokerBase):
                         taskSpec.gshare, (" merging," if inputChunk.isMerging else ""), task_class_value, n_jobs_to_submit, "\n".join(prt_str_list)
                     )
                 )
-        except Exception as e:
+        except Exception:
             tmpLog.error(f"{traceback.format_exc()}")
         # choose basic weight
         _basic_weight_version = "new"