diracx-db 0.0.1a17__py3-none-any.whl → 0.0.1a19__py3-none-any.whl

diracx/db/sql/task_queue/schema.py

@@ -0,0 +1,109 @@
+from sqlalchemy import (
+    BigInteger,
+    Boolean,
+    Float,
+    ForeignKey,
+    Index,
+    Integer,
+    String,
+)
+from sqlalchemy.orm import declarative_base
+
+from ..utils import Column
+
+TaskQueueDBBase = declarative_base()
+
+
+class TaskQueues(TaskQueueDBBase):
+    __tablename__ = "tq_TaskQueues"
+    TQId = Column(Integer, primary_key=True)
+    Owner = Column(String(255), nullable=False)
+    OwnerGroup = Column(String(32), nullable=False)
+    VO = Column(String(32), nullable=False)
+    CPUTime = Column(BigInteger, nullable=False)
+    Priority = Column(Float, nullable=False)
+    Enabled = Column(Boolean, nullable=False, default=0)
+    __table_args__ = (Index("TQOwner", "Owner", "OwnerGroup", "CPUTime"),)
+
+
+class JobsQueue(TaskQueueDBBase):
+    __tablename__ = "tq_Jobs"
+    TQId = Column(
+        Integer, ForeignKey("tq_TaskQueues.TQId", ondelete="CASCADE"), primary_key=True
+    )
+    JobId = Column(Integer, primary_key=True)
+    Priority = Column(Integer, nullable=False)
+    RealPriority = Column(Float, nullable=False)
+    __table_args__ = (Index("TaskIndex", "TQId"),)
+
+
+class SitesQueue(TaskQueueDBBase):
+    __tablename__ = "tq_TQToSites"
+    TQId = Column(
+        Integer, ForeignKey("tq_TaskQueues.TQId", ondelete="CASCADE"), primary_key=True
+    )
+    Value = Column(String(64), primary_key=True)
+    __table_args__ = (
+        Index("SitesTaskIndex", "TQId"),
+        Index("SitesIndex", "Value"),
+    )
+
+
+class GridCEsQueue(TaskQueueDBBase):
+    __tablename__ = "tq_TQToGridCEs"
+    TQId = Column(
+        Integer, ForeignKey("tq_TaskQueues.TQId", ondelete="CASCADE"), primary_key=True
+    )
+    Value = Column(String(64), primary_key=True)
+    __table_args__ = (
+        Index("GridCEsTaskIndex", "TQId"),
+        Index("GridCEsValueIndex", "Value"),
+    )
+
+
+class BannedSitesQueue(TaskQueueDBBase):
+    __tablename__ = "tq_TQToBannedSites"
+    TQId = Column(
+        Integer, ForeignKey("tq_TaskQueues.TQId", ondelete="CASCADE"), primary_key=True
+    )
+    Value = Column(String(64), primary_key=True)
+    __table_args__ = (
+        Index("BannedSitesTaskIndex", "TQId"),
+        Index("BannedSitesValueIndex", "Value"),
+    )
+
+
+class PlatformsQueue(TaskQueueDBBase):
+    __tablename__ = "tq_TQToPlatforms"
+    TQId = Column(
+        Integer, ForeignKey("tq_TaskQueues.TQId", ondelete="CASCADE"), primary_key=True
+    )
+    Value = Column(String(64), primary_key=True)
+    __table_args__ = (
+        Index("PlatformsTaskIndex", "TQId"),
+        Index("PlatformsValueIndex", "Value"),
+    )
+
+
+class JobTypesQueue(TaskQueueDBBase):
+    __tablename__ = "tq_TQToJobTypes"
+    TQId = Column(
+        Integer, ForeignKey("tq_TaskQueues.TQId", ondelete="CASCADE"), primary_key=True
+    )
+    Value = Column(String(64), primary_key=True)
+    __table_args__ = (
+        Index("JobTypesTaskIndex", "TQId"),
+        Index("JobTypesValueIndex", "Value"),
+    )
+
+
+class TagsQueue(TaskQueueDBBase):
+    __tablename__ = "tq_TQToTags"
+    TQId = Column(
+        Integer, ForeignKey("tq_TaskQueues.TQId", ondelete="CASCADE"), primary_key=True
+    )
+    Value = Column(String(64), primary_key=True)
+    __table_args__ = (
+        Index("TagsTaskIndex", "TQId"),
+        Index("TagsValueIndex", "Value"),
+    )

diracx/db/sql/utils/__init__.py

@@ -0,0 +1,445 @@
+from __future__ import annotations
+
+__all__ = ("utcnow", "Column", "NullColumn", "DateNowColumn", "BaseSQLDB")
+
+import contextlib
+import logging
+import os
+import re
+from abc import ABCMeta
+from collections.abc import AsyncIterator
+from contextvars import ContextVar
+from datetime import datetime, timedelta, timezone
+from functools import partial
+from typing import TYPE_CHECKING, Self, cast
+
+import sqlalchemy.types as types
+from pydantic import TypeAdapter
+from sqlalchemy import Column as RawColumn
+from sqlalchemy import DateTime, Enum, MetaData, select
+from sqlalchemy.exc import OperationalError
+from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine, create_async_engine
+from sqlalchemy.ext.compiler import compiles
+from sqlalchemy.sql import expression
+
+from diracx.core.exceptions import InvalidQueryError
+from diracx.core.extensions import select_from_extension
+from diracx.core.models import SortDirection
+from diracx.core.settings import SqlalchemyDsn
+from diracx.db.exceptions import DBUnavailable
+
+if TYPE_CHECKING:
+    from sqlalchemy.types import TypeEngine
+
+logger = logging.getLogger(__name__)
+
+
+class utcnow(expression.FunctionElement):
+    type: TypeEngine = DateTime()
+    inherit_cache: bool = True
+
+
+@compiles(utcnow, "postgresql")
+def pg_utcnow(element, compiler, **kw) -> str:
+    return "TIMEZONE('utc', CURRENT_TIMESTAMP)"
+
+
+@compiles(utcnow, "mssql")
+def ms_utcnow(element, compiler, **kw) -> str:
+    return "GETUTCDATE()"
+
+
+@compiles(utcnow, "mysql")
+def mysql_utcnow(element, compiler, **kw) -> str:
+    return "(UTC_TIMESTAMP)"
+
+
+@compiles(utcnow, "sqlite")
+def sqlite_utcnow(element, compiler, **kw) -> str:
+    return "DATETIME('now')"
+
+
+class date_trunc(expression.FunctionElement):
+    """Sqlalchemy function to truncate a date to a given resolution.
+
+    Primarily used to be able to query for a specific resolution of a date e.g.
+
+        select * from table where date_trunc('day', date_column) = '2021-01-01'
+        select * from table where date_trunc('year', date_column) = '2021'
+        select * from table where date_trunc('minute', date_column) = '2021-01-01 12:00'
+    """
+
+    type = DateTime()
+    inherit_cache = True
+
+    def __init__(self, *args, time_resolution, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._time_resolution = time_resolution
+
+
+@compiles(date_trunc, "postgresql")
+def pg_date_trunc(element, compiler, **kw):
+    res = {
+        "SECOND": "second",
+        "MINUTE": "minute",
+        "HOUR": "hour",
+        "DAY": "day",
+        "MONTH": "month",
+        "YEAR": "year",
+    }[element._time_resolution]
+    return f"date_trunc('{res}', {compiler.process(element.clauses)})"
+
+
+@compiles(date_trunc, "mysql")
+def mysql_date_trunc(element, compiler, **kw):
+    pattern = {
+        "SECOND": "%Y-%m-%d %H:%i:%S",
+        "MINUTE": "%Y-%m-%d %H:%i",
+        "HOUR": "%Y-%m-%d %H",
+        "DAY": "%Y-%m-%d",
+        "MONTH": "%Y-%m",
+        "YEAR": "%Y",
+    }[element._time_resolution]
+    return f"DATE_FORMAT({compiler.process(element.clauses)}, '{pattern}')"
+
+
+@compiles(date_trunc, "sqlite")
+def sqlite_date_trunc(element, compiler, **kw):
+    pattern = {
+        "SECOND": "%Y-%m-%d %H:%M:%S",
+        "MINUTE": "%Y-%m-%d %H:%M",
+        "HOUR": "%Y-%m-%d %H",
+        "DAY": "%Y-%m-%d",
+        "MONTH": "%Y-%m",
+        "YEAR": "%Y",
+    }[element._time_resolution]
+    return f"strftime('{pattern}', {compiler.process(element.clauses)})"
+
+
+def substract_date(**kwargs: float) -> datetime:
+    return datetime.now(tz=timezone.utc) - timedelta(**kwargs)
+
+
+Column: partial[RawColumn] = partial(RawColumn, nullable=False)
+NullColumn: partial[RawColumn] = partial(RawColumn, nullable=True)
+DateNowColumn = partial(Column, type_=DateTime(timezone=True), server_default=utcnow())
+
+
+def EnumColumn(enum_type, **kwargs):
+    return Column(Enum(enum_type, native_enum=False, length=16), **kwargs)
+
+
+class EnumBackedBool(types.TypeDecorator):
+    """Maps a ``EnumBackedBool()`` column to True/False in Python."""
+
+    impl = types.Enum
+    cache_ok: bool = True
+
+    def __init__(self) -> None:
+        super().__init__("True", "False")
+
+    def process_bind_param(self, value, dialect) -> str:
+        if value is True:
+            return "True"
+        elif value is False:
+            return "False"
+        else:
+            raise NotImplementedError(value, dialect)
+
+    def process_result_value(self, value, dialect) -> bool:
+        if value == "True":
+            return True
+        elif value == "False":
+            return False
+        else:
+            raise NotImplementedError(f"Unknown {value=}")
+
+
+class SQLDBError(Exception):
+    pass
+
+
+class SQLDBUnavailable(DBUnavailable, SQLDBError):
+    """Used whenever we encounter a problem with the B connection."""
+
+
+class BaseSQLDB(metaclass=ABCMeta):
+    """This should be the base class of all the SQL DiracX DBs.
+
+    The details covered here should be handled automatically by the service and
+    task machinery of DiracX and this documentation exists for informational
+    purposes.
+
+    The available databases are discovered by calling `BaseSQLDB.available_urls`.
+    This method returns a mapping of database names to connection URLs. The
+    available databases are determined by the `diracx.dbs.sql` entrypoint in the
+    `pyproject.toml` file and the connection URLs are taken from the environment
+    variables of the form `DIRACX_DB_URL_<db-name>`.
+
+    If extensions to DiracX are being used, there can be multiple implementations
+    of the same database. To list the available implementations use
+    `BaseSQLDB.available_implementations(db_name)`. The first entry in this list
+    will be the preferred implementation and it can be initialized by calling
+    it's `__init__` function with a URL perviously obtained from
+    `BaseSQLDB.available_urls`.
+
+    To control the lifetime of the SQLAlchemy engine used for connecting to the
+    database, which includes the connection pool, the `BaseSQLDB.engine_context`
+    asynchronous context manager should be entered. When inside this context
+    manager, the engine can be accessed with `BaseSQLDB.engine`.
+
+    Upon entering, the DB class can then be used as an asynchronous context
+    manager to enter transactions. If an exception is raised the transaction is
+    rolled back automatically. If the inner context exits peacefully, the
+    transaction is committed automatically. When inside this context manager,
+    the DB connection can be accessed with `BaseSQLDB.conn`.
+
+    For example:
+
+    ```python
+    db_name = ...
+    url = BaseSQLDB.available_urls()[db_name]
+    MyDBClass = BaseSQLDB.available_implementations(db_name)[0]
+
+    db = MyDBClass(url)
+    async with db.engine_context:
+        async with db:
+            # Do something in the first transaction
+            # Commit will be called automatically
+
+        async with db:
+            # This transaction will be rolled back due to the exception
+            raise Exception(...)
+    ```
+    """
+
+    # engine: AsyncEngine
+    # TODO: Make metadata an abstract property
+    metadata: MetaData
+
+    def __init__(self, db_url: str) -> None:
+        # We use a ContextVar to make sure that self._conn
+        # is specific to each context, and avoid parallel
+        # route executions to overlap
+        self._conn: ContextVar[AsyncConnection | None] = ContextVar(
+            "_conn", default=None
+        )
+        self._db_url = db_url
+        self._engine: AsyncEngine | None = None
+
+    @classmethod
+    def available_implementations(cls, db_name: str) -> list[type[BaseSQLDB]]:
+        """Return the available implementations of the DB in reverse priority order."""
+        db_classes: list[type[BaseSQLDB]] = [
+            entry_point.load()
+            for entry_point in select_from_extension(
+                group="diracx.db.sql", name=db_name
+            )
+        ]
+        if not db_classes:
+            raise NotImplementedError(f"Could not find any matches for {db_name=}")
+        return db_classes
+
+    @classmethod
+    def available_urls(cls) -> dict[str, str]:
+        """Return a dict of available database urls.
+
+        The list of available URLs is determined by environment variables
+        prefixed with ``DIRACX_DB_URL_{DB_NAME}``.
+        """
+        db_urls: dict[str, str] = {}
+        for entry_point in select_from_extension(group="diracx.db.sql"):
+            db_name = entry_point.name
+            var_name = f"DIRACX_DB_URL_{entry_point.name.upper()}"
+            if var_name in os.environ:
+                try:
+                    db_url = os.environ[var_name]
+                    if db_url == "sqlite+aiosqlite:///:memory:":
+                        db_urls[db_name] = db_url
+                    else:
+                        db_urls[db_name] = str(
+                            TypeAdapter(SqlalchemyDsn).validate_python(db_url)
+                        )
+                except Exception:
+                    logger.error("Error loading URL for %s", db_name)
+                    raise
+        return db_urls
+
+    @classmethod
+    def transaction(cls) -> Self:
+        raise NotImplementedError("This should never be called")
+
+    @property
+    def engine(self) -> AsyncEngine:
+        """The engine to use for database operations.
+
+        It is normally not necessary to use the engine directly, unless you are
+        doing something special, like writing a test fixture that gives you a db.
+
+        Requires that the engine_context has been entered.
+        """
+        assert self._engine is not None, "engine_context must be entered"
+        return self._engine
+
+    @contextlib.asynccontextmanager
+    async def engine_context(self) -> AsyncIterator[None]:
+        """Context manage to manage the engine lifecycle.
+
+        This is called once at the application startup (see ``lifetime_functions``).
+        """
+        assert self._engine is None, "engine_context cannot be nested"
+
+        # Set the pool_recycle to 30mn
+        # That should prevent the problem of MySQL expiring connection
+        # after 60mn by default
+        engine = create_async_engine(self._db_url, pool_recycle=60 * 30)
+        self._engine = engine
+        try:
+            yield
+        finally:
+            self._engine = None
+            await engine.dispose()
+
+    @property
+    def conn(self) -> AsyncConnection:
+        if self._conn.get() is None:
+            raise RuntimeError(f"{self.__class__} was used before entering")
+        return cast(AsyncConnection, self._conn.get())
+
+    async def __aenter__(self) -> Self:
+        """Create a connection.
+
+        This is called by the Dependency mechanism (see ``db_transaction``),
+        It will create a new connection/transaction for each route call.
+        """
+        assert self._conn.get() is None, "BaseSQLDB context cannot be nested"
+        try:
+            self._conn.set(await self.engine.connect().__aenter__())
+        except Exception as e:
+            raise SQLDBUnavailable(
+                f"Cannot connect to {self.__class__.__name__}"
+            ) from e
+
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        """This is called when exiting a route.
+
+        If there was no exception, the changes in the DB are committed.
+        Otherwise, they are rolled back.
+        """
+        if exc_type is None:
+            await self._conn.get().commit()
+        await self._conn.get().__aexit__(exc_type, exc, tb)
+        self._conn.set(None)
+
+    async def ping(self):
+        """Check whether the connection to the DB is still working.
+
+        We could enable the ``pre_ping`` in the engine, but this would be ran at
+        every query.
+        """
+        try:
+            await self.conn.scalar(select(1))
+        except OperationalError as e:
+            raise SQLDBUnavailable("Cannot ping the DB") from e
+
+
+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
+    ):
+        if match.group(6):
+            precision, pattern = "SECOND", r"\1-\2-\3 \4:\5:\6"
+        elif match.group(5):
+            precision, pattern = "MINUTE", r"\1-\2-\3 \4:\5"
+        elif match.group(3):
+            precision, pattern = "HOUR", r"\1-\2-\3 \4"
+        elif match.group(2):
+            precision, pattern = "DAY", r"\1-\2-\3"
+        elif match.group(1):
+            precision, pattern = "MONTH", r"\1-\2"
+        else:
+            precision, pattern = "YEAR", r"\1"
+        return (
+            precision,
+            re.sub(
+                r"^(\d{4})-?(\d{2})?-?(\d{2})?[ T]?(\d{2})?:?(\d{2})?:?(\d{2})?\.?(\d{6})?Z?$",
+                pattern,
+                value,
+            ),
+        )
+
+    raise InvalidQueryError(f"Cannot parse {value=}")
+
+
+def apply_search_filters(column_mapping, stmt, search):
+    for query in search:
+        try:
+            column = column_mapping(query["parameter"])
+        except KeyError as e:
+            raise InvalidQueryError(f"Unknown column {query['parameter']}") from e
+
+        if isinstance(column.type, DateTime):
+            if "value" in query and isinstance(query["value"], str):
+                resolution, value = find_time_resolution(query["value"])
+                if resolution:
+                    column = date_trunc(column, time_resolution=resolution)
+                query["value"] = value
+
+            if query.get("values"):
+                resolutions, values = zip(
+                    *map(find_time_resolution, query.get("values"))
+                )
+                if len(set(resolutions)) != 1:
+                    raise InvalidQueryError(
+                        f"Cannot mix different time resolutions in {query=}"
+                    )
+                if resolution := resolutions[0]:
+                    column = date_trunc(column, time_resolution=resolution)
+                query["values"] = values
+
+        if query["operator"] == "eq":
+            expr = column == query["value"]
+        elif query["operator"] == "neq":
+            expr = column != query["value"]
+        elif query["operator"] == "gt":
+            expr = column > query["value"]
+        elif query["operator"] == "lt":
+            expr = column < query["value"]
+        elif query["operator"] == "in":
+            expr = column.in_(query["values"])
+        elif query["operator"] == "not in":
+            expr = column.notin_(query["values"])
+        elif query["operator"] in "like":
+            expr = column.like(query["value"])
+        elif query["operator"] in "ilike":
+            expr = column.ilike(query["value"])
+        else:
+            raise InvalidQueryError(f"Unknown filter {query=}")
+        stmt = stmt.where(expr)
+    return stmt
+
+
+def apply_sort_constraints(column_mapping, stmt, sorts):
+    sort_columns = []
+    for sort in sorts or []:
+        try:
+            column = column_mapping(sort["parameter"])
+        except KeyError as e:
+            raise InvalidQueryError(
+                f"Cannot sort by {sort['parameter']}: unknown column"
+            ) from e
+        sorted_column = None
+        if sort["direction"] == SortDirection.ASC:
+            sorted_column = column.asc()
+        elif sort["direction"] == SortDirection.DESC:
+            sorted_column = column.desc()
+        else:
+            raise InvalidQueryError(f"Unknown sort {sort['direction']=}")
+        sort_columns.append(sorted_column)
+    if sort_columns:
+        stmt = stmt.order_by(*sort_columns)
+    return stmt

diracx/db/sql/{jobs/status_utility.py → utils/job_status.py}

@@ -12,8 +12,8 @@ from diracx.core.models import (
     ScalarSearchOperator,
     SetJobStatusReturn,
 )
-from diracx.db.sql.jobs.db import JobDB, JobLoggingDB, TaskQueueDB
-from diracx.db.sql.sandbox_metadata.db import SandboxMetadataDB
+
+from .. import JobDB, JobLoggingDB, SandboxMetadataDB, TaskQueueDB
 
 
 async def set_job_status(
@@ -26,11 +26,10 @@ async def set_job_status(
     """Set various status fields for job specified by its jobId.
     Set only the last status in the JobDB, updating all the status
     logging information in the JobLoggingDB. The status dict has datetime
-    as a key and status information dictionary as values
+    as a key and status information dictionary as values.
 
     :raises: JobNotFound if the job is not found in one of the DBs
     """
-
     from DIRAC.Core.Utilities import TimeUtilities
     from DIRAC.Core.Utilities.ReturnValues import returnValueOrRaise
     from DIRAC.WorkloadManagementSystem.Utilities.JobStatusUtility import (
@@ -160,11 +159,10 @@ async def delete_jobs(
     task_queue_db: TaskQueueDB,
     background_task: BackgroundTasks,
 ):
-    """
-    "Delete" jobs by removing them from the task queues, set kill as a job command setting the job status to DELETED.
-    :raises: BaseExceptionGroup[JobNotFound] for every job that was not found
-    """
+    """Removing jobs from task queues, send a kill command and set status to DELETED.
 
+    :raises: BaseExceptionGroup[JobNotFound] for every job that was not found.
+    """
     await _remove_jobs_from_task_queue(job_ids, config, task_queue_db, background_task)
     # TODO: implement StorageManagerClient
     # returnValueOrRaise(StorageManagerClient().killTasksBySourceTaskID(job_ids))
@@ -198,9 +196,8 @@ async def kill_jobs(
     task_queue_db: TaskQueueDB,
     background_task: BackgroundTasks,
 ):
-    """
-    Kill jobs by removing them from the task queues, set kill as a job command and setting the job status to KILLED.
-    :raises: BaseExceptionGroup[JobNotFound] for every job that was not found
+    """Kill jobs by removing them from the task queues, set kill as a job command and setting the job status to KILLED.
+    :raises: BaseExceptionGroup[JobNotFound] for every job that was not found.
     """
     await _remove_jobs_from_task_queue(job_ids, config, task_queue_db, background_task)
     # TODO: implement StorageManagerClient
@@ -259,11 +256,9 @@ async def remove_jobs(
     task_queue_db: TaskQueueDB,
     background_task: BackgroundTasks,
 ):
+    """Fully remove a job from the WMS databases.
+    :raises: nothing.
     """
-    Fully remove a job from the WMS databases.
-    :raises: nothing
-    """
-
     # Remove the staging task from the StorageManager
     # TODO: this was not done in the JobManagerHandler, but it was done in the kill method
     # I think it should be done here too
@@ -290,9 +285,7 @@ async def _remove_jobs_from_task_queue(
     task_queue_db: TaskQueueDB,
     background_task: BackgroundTasks,
 ):
-    """
-    Remove the job from TaskQueueDB
-    """
+    """Remove the job from TaskQueueDB."""
     tq_infos = await task_queue_db.get_tq_infos_for_jobs(job_ids)
     await task_queue_db.remove_jobs(job_ids)
     for tq_id, owner, owner_group, vo in tq_infos:

{diracx_db-0.0.1a17.dist-info → diracx_db-0.0.1a19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diracx-db
-Version: 0.0.1a17
+Version: 0.0.1a19
 Summary: TODO
 License: GPL-3.0-only
 Classifier: Intended Audience :: Science/Research
@@ -8,14 +8,14 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: System :: Distributed Computing
-Requires-Python: >=3.10
+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.4
-Requires-Dist: sqlalchemy[aiomysql,aiosqlite] >=2
+Requires-Dist: pydantic>=2.4
+Requires-Dist: sqlalchemy[aiomysql,aiosqlite]>=2
 Provides-Extra: testing
-Requires-Dist: diracx-testing ; extra == 'testing'
+Requires-Dist: diracx-testing; extra == "testing"
 

diracx_db-0.0.1a19.dist-info/RECORD

@@ -0,0 +1,36 @@
+diracx/db/__init__.py,sha256=2oeUeVwZq53bo_ZOflEYZsBn7tcR5Tzb2AIu0TAWELM,109
+diracx/db/__main__.py,sha256=tU4tp3OAClYCiPMxlRj524sZGBx9oy4CoWHd8pMuEEs,1715
+diracx/db/exceptions.py,sha256=-LSkEwsvjwU7vXqx-xeLvLKInTRAhjwB7K_AKfQcIH8,41
+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=9UyhgMqaI8loh8chW2zHW-9JAOtH5YfktC-d-uY5Wnk,11346
+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=Wi4oeHCL4pPiaysZEx8R0KNk9BDxncAAtOD2qnD-NnY,10206
+diracx/db/sql/auth/schema.py,sha256=W5whp1ZK_SNt-wxWVRBegmrc9IgqCR1LFY1FWwUlEBs,2828
+diracx/db/sql/dummy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diracx/db/sql/dummy/db.py,sha256=4Xyo7gUh_5b6Q2a_ggJG6e7fCtc9HrP_BRXfKGfqZIs,1642
+diracx/db/sql/dummy/schema.py,sha256=uEkGDNVZbmJecytkHY1CO-M1MiKxe5w1_h0joJMPC9E,680
+diracx/db/sql/job/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diracx/db/sql/job/db.py,sha256=DaU1SGeXl7TqX1QxT1RldCeMIOYGnzNwkqBrwgGE90A,16248
+diracx/db/sql/job/schema.py,sha256=w9Ht9LyVK-fB5T9-hYGsqifzneeG2YP123j1-Mx8Xio,4283
+diracx/db/sql/job_logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diracx/db/sql/job_logging/db.py,sha256=OGVHYIDcWhGYVfHacsz9DEPSoJ7aRbKVoQOyCCj8XvU,5036
+diracx/db/sql/job_logging/schema.py,sha256=dD2arl-6bffeK8INT6tZ1HWEpJuYTx2iNiVzswVXXF8,812
+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=d4sVlhWpMVgHguS-VlDR3zqM0Yj5QVEjon3gBgrr-kk,2091
+diracx/db/sql/sandbox_metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diracx/db/sql/sandbox_metadata/db.py,sha256=ZoiKjs-Rdd4p-kOZOLoUkpP0xGIp0oGjou3D2oP_6GE,6452
+diracx/db/sql/sandbox_metadata/schema.py,sha256=rngYYkJxBhjETBHGLD1CTipDGe44mRYR0wdaFoAJwp0,1400
+diracx/db/sql/task_queue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diracx/db/sql/task_queue/db.py,sha256=e6yauZO0nWaUVqjqQycH8iPO4wXLXaC82eaIq1K_KI8,9102
+diracx/db/sql/task_queue/schema.py,sha256=fvzQyCw_xWAOWTLW6Qrp1m-WzEKb0tlYmafoLTbCy1I,3222
+diracx/db/sql/utils/__init__.py,sha256=8YcDra_P_FL3QIDzl53HvN1tHUE396F0tGKB-TPQxeM,15541
+diracx/db/sql/utils/job_status.py,sha256=GNQTKiyguhnB348mLIB7BT-PEOEKpKljR4JzvOd_h8M,10414
+diracx_db-0.0.1a19.dist-info/METADATA,sha256=_e0zgiSjl92T83BUpBXkEHzMeCcLcr4L_sE9h9v_iwQ,688
+diracx_db-0.0.1a19.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+diracx_db-0.0.1a19.dist-info/entry_points.txt,sha256=YLI4f6640bri8Ud6Jt9WNq79pSTVQAkfUasb9f75fR8,315
+diracx_db-0.0.1a19.dist-info/top_level.txt,sha256=vJx10tdRlBX3rF2Psgk5jlwVGZNcL3m_7iQWwgPXt-U,7
+diracx_db-0.0.1a19.dist-info/RECORD,,