diracx-db 0.0.1a26__py3-none-any.whl → 0.0.1a28__py3-none-any.whl

diracx/db/sql/sandbox_metadata/db.py

@@ -5,9 +5,14 @@ from typing import Any
 from sqlalchemy import Executable, delete, insert, literal, select, update
 from sqlalchemy.exc import IntegrityError, NoResultFound
 
-from diracx.core.exceptions import SandboxNotFoundError
+from diracx.core.exceptions import (
+    SandboxAlreadyAssignedError,
+    SandboxAlreadyInsertedError,
+    SandboxNotFoundError,
+)
 from diracx.core.models import SandboxInfo, SandboxType, UserInfo
-from diracx.db.sql.utils import BaseSQLDB, utcnow
+from diracx.db.sql.utils.base import BaseSQLDB
+from diracx.db.sql.utils.functions import utcnow
 
 from .schema import Base as SandboxMetadataDBBase
 from .schema import SandBoxes, SBEntityMapping, SBOwners
@@ -16,18 +21,16 @@ from .schema import SandBoxes, SBEntityMapping, SBOwners
 class SandboxMetadataDB(BaseSQLDB):
     metadata = SandboxMetadataDBBase.metadata
 
-    async def upsert_owner(self, user: UserInfo) -> int:
+    async def get_owner_id(self, user: UserInfo) -> int | None:
         """Get the id of the owner from the database."""
-        # TODO: Follow https://github.com/DIRACGrid/diracx/issues/49
         stmt = select(SBOwners.OwnerID).where(
             SBOwners.Owner == user.preferred_username,
             SBOwners.OwnerGroup == user.dirac_group,
             SBOwners.VO == user.vo,
         )
-        result = await self.conn.execute(stmt)
-        if owner_id := result.scalar_one_or_none():
-            return owner_id
+        return (await self.conn.execute(stmt)).scalar_one_or_none()
 
+    async def insert_owner(self, user: UserInfo) -> int:
         stmt = insert(SBOwners).values(
             Owner=user.preferred_username,
             OwnerGroup=user.dirac_group,
@@ -50,11 +53,9 @@ class SandboxMetadataDB(BaseSQLDB):
         return "/" + "/".join(parts)
 
     async def insert_sandbox(
-        self, se_name: str, user: UserInfo, pfn: str, size: int
+        self, owner_id: int, se_name: str, pfn: str, size: int
     ) -> None:
         """Add a new sandbox in SandboxMetadataDB."""
-        # TODO: Follow https://github.com/DIRACGrid/diracx/issues/49
-        owner_id = await self.upsert_owner(user)
         stmt = insert(SandBoxes).values(
             OwnerId=owner_id,
             SEName=se_name,
@@ -64,11 +65,9 @@ class SandboxMetadataDB(BaseSQLDB):
             LastAccessTime=utcnow(),
         )
         try:
-            result = await self.conn.execute(stmt)
-        except IntegrityError:
-            await self.update_sandbox_last_access_time(se_name, pfn)
-        else:
-            assert result.rowcount == 1
+            await self.conn.execute(stmt)
+        except IntegrityError as e:
+            raise SandboxAlreadyInsertedError(pfn, se_name) from e
 
     async def update_sandbox_last_access_time(self, se_name: str, pfn: str) -> None:
         stmt = (
@@ -135,10 +134,18 @@ class SandboxMetadataDB(BaseSQLDB):
             stmt = insert(SBEntityMapping).from_select(
                 ["SBId", "EntityId", "Type"], select_sb_id
             )
-            await self.conn.execute(stmt)
+            try:
+                await self.conn.execute(stmt)
+            except IntegrityError as e:
+                raise SandboxAlreadyAssignedError(pfn, se_name) from e
 
             stmt = update(SandBoxes).where(SandBoxes.SEPFN == pfn).values(Assigned=True)
             result = await self.conn.execute(stmt)
+            if result.rowcount == 0:
+                # If the update didn't affect any row, the sandbox doesn't exist
+                # It means the previous insert didn't have any effect
+                raise SandboxNotFoundError(pfn, se_name)
+
             assert result.rowcount == 1
 
     async def unassign_sandboxes_to_jobs(self, jobs_ids: list[int]) -> None:

diracx/db/sql/task_queue/db.py

@@ -7,8 +7,6 @@ from sqlalchemy import delete, func, select, update
 if TYPE_CHECKING:
     pass
 
-from diracx.core.properties import JOB_SHARING, SecurityProperty
-
 from ..utils import BaseSQLDB
 from .schema import (
     BannedSitesQueue,
@@ -49,126 +47,23 @@ class TaskQueueDB(BaseSQLDB):
         )
         return dict((await self.conn.execute(stmt)).one()._mapping)
 
-    async def remove_job(self, job_id: int):
-        """Remove a job from the task queues."""
-        stmt = delete(JobsQueue).where(JobsQueue.JobId == job_id)
-        await self.conn.execute(stmt)
-
-    async def remove_jobs(self, job_ids: list[int]):
-        """Remove jobs from the task queues."""
-        stmt = delete(JobsQueue).where(JobsQueue.JobId.in_(job_ids))
-        await self.conn.execute(stmt)
-
-    async def delete_task_queue_if_empty(
-        self,
-        tq_id: int,
-        tq_owner: str,
-        tq_group: str,
-        job_share: int,
-        group_properties: set[SecurityProperty],
-        enable_shares_correction: bool,
-        allow_background_tqs: bool,
-    ):
-        """Try to delete a task queue if it's empty."""
-        # Check if the task queue is empty
-        stmt = (
-            select(TaskQueues.TQId)
-            .where(TaskQueues.Enabled >= 1)
-            .where(TaskQueues.TQId == tq_id)
-            .where(~TaskQueues.TQId.in_(select(JobsQueue.TQId)))
-        )
-        rows = await self.conn.execute(stmt)
-        if not rows.rowcount:
-            return
-
-        # Deleting the task queue (the other tables will be deleted in cascade)
-        stmt = delete(TaskQueues).where(TaskQueues.TQId == tq_id)
-        await self.conn.execute(stmt)
-
-        await self.recalculate_tq_shares_for_entity(
-            tq_owner,
-            tq_group,
-            job_share,
-            group_properties,
-            enable_shares_correction,
-            allow_background_tqs,
-        )
-
-    async def recalculate_tq_shares_for_entity(
-        self,
-        owner: str,
-        group: str,
-        job_share: int,
-        group_properties: set[SecurityProperty],
-        enable_shares_correction: bool,
-        allow_background_tqs: bool,
-    ):
-        """Recalculate the shares for a user/userGroup combo."""
-        if JOB_SHARING in group_properties:
-            # If group has JobSharing just set prio for that entry, user is irrelevant
-            return await self.__set_priorities_for_entity(
-                owner, group, job_share, group_properties, allow_background_tqs
-            )
-
+    async def get_task_queue_owners_by_group(self, group: str) -> dict[str, int]:
+        """Get the owners for a task queue and group."""
         stmt = (
             select(TaskQueues.Owner, func.count(TaskQueues.Owner))
             .where(TaskQueues.OwnerGroup == group)
             .group_by(TaskQueues.Owner)
         )
         rows = await self.conn.execute(stmt)
-        # make the rows a list of tuples
         # Get owners in this group and the amount of times they appear
         # TODO: I guess the rows are already a list of tupes
         # maybe refactor
-        data = [(r[0], r[1]) for r in rows if r]
-        num_owners = len(data)
-        # If there are no owners do now
-        if num_owners == 0:
-            return
-        # Split the share amongst the number of owners
-        entities_shares = {row[0]: job_share / num_owners for row in data}
-
-        # TODO: implement the following
-        # If corrector is enabled let it work it's magic
-        # if enable_shares_correction:
-        #     entities_shares = await self.__shares_corrector.correct_shares(
-        #         entitiesShares, group=group
-        #     )
-
-        # Keep updating
-        owners = dict(data)
-        # IF the user is already known and has more than 1 tq, the rest of the users don't need to be modified
-        # (The number of owners didn't change)
-        if owner in owners and owners[owner] > 1:
-            await self.__set_priorities_for_entity(
-                owner,
-                group,
-                entities_shares[owner],
-                group_properties,
-                allow_background_tqs,
-            )
-            return
-        # Oops the number of owners may have changed so we recalculate the prio for all owners in the group
-        for owner in owners:
-            await self.__set_priorities_for_entity(
-                owner,
-                group,
-                entities_shares[owner],
-                group_properties,
-                allow_background_tqs,
-            )
-
-    async def __set_priorities_for_entity(
-        self,
-        owner: str,
-        group: str,
-        share,
-        properties: set[SecurityProperty],
-        allow_background_tqs: bool,
-    ):
-        """Set the priority for a user/userGroup combo given a splitted share."""
-        from DIRAC.WorkloadManagementSystem.DB.TaskQueueDB import calculate_priority
+        return {r[0]: r[1] for r in rows if r}
 
+    async def get_task_queue_priorities(
+        self, group: str, owner: str | None = None
+    ) -> dict[int, float]:
+        """Get the priorities for a list of task queues."""
         stmt = (
             select(
                 TaskQueues.TQId,
@@ -178,24 +73,48 @@ class TaskQueueDB(BaseSQLDB):
             .where(TaskQueues.OwnerGroup == group)
             .group_by(TaskQueues.TQId)
         )
-        if JOB_SHARING not in properties:
+        if owner:
             stmt = stmt.where(TaskQueues.Owner == owner)
         rows = await self.conn.execute(stmt)
-        tq_dict: dict[int, float] = {tq_id: priority for tq_id, priority in rows}
+        return {tq_id: priority for tq_id, priority in rows}
 
-        if not tq_dict:
-            return
+    async def remove_jobs(self, job_ids: list[int]):
+        """Remove jobs from the task queues."""
+        stmt = delete(JobsQueue).where(JobsQueue.JobId.in_(job_ids))
+        await self.conn.execute(stmt)
 
-        rows = await self.retrieve_task_queues(list(tq_dict))
+    async def is_task_queue_empty(self, tq_id: int) -> bool:
+        """Check if a task queue is empty."""
+        stmt = (
+            select(TaskQueues.TQId)
+            .where(TaskQueues.Enabled >= 1)
+            .where(TaskQueues.TQId == tq_id)
+            .where(~TaskQueues.TQId.in_(select(JobsQueue.TQId)))
+        )
+        rows = await self.conn.execute(stmt)
+        return not rows.rowcount
 
-        prio_dict = calculate_priority(tq_dict, rows, share, allow_background_tqs)
+    async def delete_task_queue(
+        self,
+        tq_id: int,
+    ):
+        """Delete a task queue."""
+        # Deleting the task queue (the other tables will be deleted in cascade)
+        stmt = delete(TaskQueues).where(TaskQueues.TQId == tq_id)
+        await self.conn.execute(stmt)
 
-        # Execute updates
-        for prio, tqs in prio_dict.items():
-            update_stmt = (
-                update(TaskQueues).where(TaskQueues.TQId.in_(tqs)).values(Priority=prio)
-            )
-            await self.conn.execute(update_stmt)
+    async def set_priorities_for_entity(
+        self,
+        tq_ids: list[int],
+        priority: float,
+    ):
+        """Set the priority for a user/userGroup combo given a splitted share."""
+        update_stmt = (
+            update(TaskQueues)
+            .where(TaskQueues.TQId.in_(tq_ids))
+            .values(Priority=priority)
+        )
+        await self.conn.execute(update_stmt)
 
     async def retrieve_task_queues(self, tq_id_list=None):
         """Get all the task queues."""

diracx/db/sql/utils/__init__.py

@@ -6,7 +6,7 @@ from .base import (
     apply_search_filters,
     apply_sort_constraints,
 )
-from .functions import substract_date, utcnow
+from .functions import hash, substract_date, utcnow
 from .types import Column, DateNowColumn, EnumBackedBool, EnumColumn, NullColumn
 
 __all__ = (
@@ -20,5 +20,6 @@ __all__ = (
     "apply_search_filters",
     "apply_sort_constraints",
     "substract_date",
+    "hash",
     "SQLDBUnavailableError",
 )

diracx/db/sql/utils/base.py

@@ -104,7 +104,7 @@ class BaseSQLDB(metaclass=ABCMeta):
         db_classes: list[type[BaseSQLDB]] = [
             entry_point.load()
             for entry_point in select_from_extension(
-                group="diracx.db.sql", name=db_name
+                group="diracx.dbs.sql", name=db_name
             )
         ]
         if not db_classes:
@@ -119,7 +119,7 @@ class BaseSQLDB(metaclass=ABCMeta):
         prefixed with ``DIRACX_DB_URL_{DB_NAME}``.
         """
         db_urls: dict[str, str] = {}
-        for entry_point in select_from_extension(group="diracx.db.sql"):
+        for entry_point in select_from_extension(group="diracx.dbs.sql"):
             db_name = entry_point.name
             var_name = f"DIRACX_DB_URL_{entry_point.name.upper()}"
             if var_name in os.environ:
@@ -232,7 +232,7 @@ def find_time_resolution(value):
     if isinstance(value, datetime):
         return None, value
     if match := re.fullmatch(
-        r"\d{4}(-\d{2}(-\d{2}(([ T])\d{2}(:\d{2}(:\d{2}(\.\d{6}Z?)?)?)?)?)?)?", value
+        r"\d{4}(-\d{2}(-\d{2}(([ T])\d{2}(:\d{2}(:\d{2}(\.\d{1,6}Z?)?)?)?)?)?)?", value
     ):
         if match.group(6):
             precision, pattern = "SECOND", r"\1-\2-\3 \4:\5:\6"
@@ -249,7 +249,7 @@ def find_time_resolution(value):
         return (
             precision,
             re.sub(
-                r"^(\d{4})-?(\d{2})?-?(\d{2})?[ T]?(\d{2})?:?(\d{2})?:?(\d{2})?\.?(\d{6})?Z?$",
+                r"^(\d{4})-?(\d{2})?-?(\d{2})?[ T]?(\d{2})?:?(\d{2})?:?(\d{2})?\.?(\d{1,6})?Z?$",
                 pattern,
                 value,
             ),

diracx/db/sql/utils/functions.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import hashlib
 from datetime import datetime, timedelta, timezone
 from typing import TYPE_CHECKING
 
@@ -47,7 +48,8 @@ class date_trunc(expression.FunctionElement):  # noqa: N801
     """
 
     type = DateTime()
-    inherit_cache = True
+    # Cache does not work as intended with time resolution values, so we disable it
+    inherit_cache = False
 
     def __init__(self, *args, time_resolution, **kwargs) -> None:
         super().__init__(*args, **kwargs)
@@ -103,3 +105,7 @@ def sqlite_date_trunc(element, compiler, **kw):
 
 def substract_date(**kwargs: float) -> datetime:
     return datetime.now(tz=timezone.utc) - timedelta(**kwargs)
+
+
+def hash(code: str):
+    return hashlib.sha256(code.encode()).hexdigest()

{diracx_db-0.0.1a26.dist-info → diracx_db-0.0.1a28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: diracx-db
-Version: 0.0.1a26
+Version: 0.0.1a28
 Summary: TODO
 License: GPL-3.0-only
 Classifier: Intended Audience :: Science/Research
@@ -10,9 +10,7 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: System :: Distributed Computing
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: dirac
 Requires-Dist: diracx-core
-Requires-Dist: fastapi
 Requires-Dist: opensearch-py[async]
 Requires-Dist: pydantic>=2.10
 Requires-Dist: sqlalchemy[aiomysql,aiosqlite]>=2

{diracx_db-0.0.1a26.dist-info → diracx_db-0.0.1a28.dist-info}/RECORD

@@ -4,36 +4,35 @@ diracx/db/exceptions.py,sha256=1nn-SZLG-nQwkxbvHjZqXhE5ouzWj1f3qhSda2B4ZEg,83
 diracx/db/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 diracx/db/os/__init__.py,sha256=IZr6z6SefrRvuC8sTC4RmB3_wwOyEt1GzpDuwSMH8O4,112
 diracx/db/os/job_parameters.py,sha256=Knca19uT2G-5FI7MOFlaOAXeHn4ecPVLIH30TiwhaTw,858
-diracx/db/os/utils.py,sha256=k4EBCDLzx_P35aTOoFFrYjO7bnyIF_-PRZGlpMk3IAI,11366
+diracx/db/os/utils.py,sha256=xQLhOgC9YidfeEIbmdigXg3_YZLKHwMcZzhHf4mRwyQ,11399
 diracx/db/sql/__init__.py,sha256=JYu0b0IVhoXy3lX2m2r2dmAjsRS7IbECBUMEDvX0Te4,391
 diracx/db/sql/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-diracx/db/sql/auth/db.py,sha256=Ma3P6m49wUNM9wcQZWoQu1CsyJF8vvGeirBFuQUaAIY,10202
+diracx/db/sql/auth/db.py,sha256=O9sp-AKobQ4X4IF2WaJKig-8LU8Ra9Syn5jW8JNLRU4,9030
 diracx/db/sql/auth/schema.py,sha256=-yXVfNz45W3VvvrNf-ZrSzIgb9qMaI9x1fWDshSkpPU,3141
 diracx/db/sql/dummy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 diracx/db/sql/dummy/db.py,sha256=whcF02IjFQTwe1l4iTHtCkg2XukEaLHpLeHYNGMuGGw,1645
 diracx/db/sql/dummy/schema.py,sha256=9zI53pKlzc6qBezsyjkatOQrNZdGCjwgjQ8Iz_pyAXs,789
 diracx/db/sql/job/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-diracx/db/sql/job/db.py,sha256=21J5vvIT6z_kdVxmoQjiZ61pjCvAXJ5tKN25eJyNR6Q,11712
+diracx/db/sql/job/db.py,sha256=qoK1toWekRP1BO5XbT9CaRuGKR9_oixMVfRZ9myZsjg,8644
 diracx/db/sql/job/schema.py,sha256=Rmt5ldVN6Pf4MJHMhiT_Zn-k9LVPBTVivmGlyPKFRZE,4647
 diracx/db/sql/job_logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-diracx/db/sql/job_logging/db.py,sha256=-i_azE67MI95LnXER31USCKioq0l4Q3VJb1oQPdy2Ds,7827
+diracx/db/sql/job_logging/db.py,sha256=0WuRn3pKEeuV9IZ_3VDhlvqI9eM1W4C0dZwIVZKW9N8,5811
 diracx/db/sql/job_logging/schema.py,sha256=DyFr_4goxfC453xPJX4OkxTGHtlP_5q8PXpr8bhNQS0,960
 diracx/db/sql/pilot_agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 diracx/db/sql/pilot_agents/db.py,sha256=7-cuCbh_KhM0jlybsHMWV-W66bHsPHIVBpbuqwjncj0,1232
 diracx/db/sql/pilot_agents/schema.py,sha256=KeWnFSpYOTrT3-_rOCFjbjNnPNXKnUZiJVsu4vv5U2U,2149
 diracx/db/sql/sandbox_metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-diracx/db/sql/sandbox_metadata/db.py,sha256=wpGPUA1KLrt9B9qJaQGZExnyeREp44jdbW3XkRX_kP0,6410
+diracx/db/sql/sandbox_metadata/db.py,sha256=IyQtTIxRzRv0cdhR3Of1uVzliggePY67bz_9HeKIOjE,6666
 diracx/db/sql/sandbox_metadata/schema.py,sha256=mI-YpH6NneOQ6QiqwIwyJ4afwfoamybSlQpvaISFfPY,1431
 diracx/db/sql/task_queue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-diracx/db/sql/task_queue/db.py,sha256=xY8yPpCIwTC5epcyFGxAP8K9sOVybYsgoH2_QH3NHb8,9105
+diracx/db/sql/task_queue/db.py,sha256=Ymd9cBasiSAPmgu5846B8KmguRiJ_GoJhuOev9YwW2o,6248
 diracx/db/sql/task_queue/schema.py,sha256=5efAgvNYRkLlaJ2NzRInRfmVa3tyIzQu2l0oRPy4Kzw,3258
-diracx/db/sql/utils/__init__.py,sha256=b4lLIYRFVX8PW15ekklzs5OeulA6lNEOfBOJqgIOtYY,529
-diracx/db/sql/utils/base.py,sha256=hAFeUKWQIOJq9w_WholaLDdDxBd-E8UVLKq99uX7aYw,12361
-diracx/db/sql/utils/functions.py,sha256=PFA570qkCZQdABxsz2_LBEfYUv8dln3suNHx17PHGS0,2879
-diracx/db/sql/utils/job.py,sha256=U_y8DZdMGU5NbQF3udA4Yg43HaKhF8YhYa-PhzYmIyI,19592
+diracx/db/sql/utils/__init__.py,sha256=QkvpqBuIAgkAOywAssYzdxSzUQVZlSUumK7mPxotXfM,547
+diracx/db/sql/utils/base.py,sha256=7UxHBNLOSjdrIdslMKW4C_c5H9-6Y1BEimxscri2poE,12367
+diracx/db/sql/utils/functions.py,sha256=iLqlUIQ6SrDUtDEnZ5szaFbdcINJW15KNbCdGXss6kc,3055
 diracx/db/sql/utils/types.py,sha256=yU-tXsu6hFGPsr9ba1n3ZjGPnHQI_06lbpkTeDCWJtg,1287
-diracx_db-0.0.1a26.dist-info/METADATA,sha256=2s_xYS6cfK8T9C4lhl9ad7mK8_tWRzXUV4oXOviqOcA,688
-diracx_db-0.0.1a26.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-diracx_db-0.0.1a26.dist-info/entry_points.txt,sha256=YLI4f6640bri8Ud6Jt9WNq79pSTVQAkfUasb9f75fR8,315
-diracx_db-0.0.1a26.dist-info/top_level.txt,sha256=vJx10tdRlBX3rF2Psgk5jlwVGZNcL3m_7iQWwgPXt-U,7
-diracx_db-0.0.1a26.dist-info/RECORD,,
+diracx_db-0.0.1a28.dist-info/METADATA,sha256=7tBHb4St4d0QeFQEBqfMYGTxhXaIOP2K2evK0GvJHCo,644
+diracx_db-0.0.1a28.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+diracx_db-0.0.1a28.dist-info/entry_points.txt,sha256=UPqhLvb9gui0kOyWeI_edtefcrHToZmQt1p76vIwujo,317
+diracx_db-0.0.1a28.dist-info/top_level.txt,sha256=vJx10tdRlBX3rF2Psgk5jlwVGZNcL3m_7iQWwgPXt-U,7
+diracx_db-0.0.1a28.dist-info/RECORD,,

{diracx_db-0.0.1a26.dist-info → diracx_db-0.0.1a28.dist-info}/WHEEL

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

{diracx_db-0.0.1a26.dist-info → diracx_db-0.0.1a28.dist-info}/entry_points.txt

@@ -1,7 +1,7 @@
-[diracx.db.os]
+[diracx.dbs.os]
 JobParametersDB = diracx.db.os:JobParametersDB
 
-[diracx.db.sql]
+[diracx.dbs.sql]
 AuthDB = diracx.db.sql:AuthDB
 JobDB = diracx.db.sql:JobDB
 JobLoggingDB = diracx.db.sql:JobLoggingDB