diracx-db 0.0.1a44__tar.gz → 0.0.1a45__tar.gz

diracx_db-0.0.1a45/.gitignore

@@ -0,0 +1,98 @@
+# Python
+*.py[cod]
+
+# Conda
+.conda
+
+# C extensions
+*.so
+var
+sdist
+lib
+lib64
+
+# Packages
+*.egg
+*.egg-info
+dist
+build
+eggs
+parts
+bin
+develop-eggs
+.installed.cfg
+*.whl
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+
+# Installer logs
+pip-log.txt
+
+# Unit test / coverage reports
+.coverage
+.tox
+.ruff_cache
+.mypy_cache
+
+# Eclipse
+.project
+.pydevproject
+.pyproject
+.settings
+.metadata
+
+#VSCode
+.vscode
+.env
+
+# Vim
+.*.sw[a-z]
+*.un~
+Session.vim
+*~
+
+# Intellij
+.idea/
+LHCbDIRAC.iml
+
+# MaxOSX files
+.DS_Store
+
+# test stuff
+.pytest_cache
+.cache
+__pycache__
+pytests.xml
+nosetests.xml
+coverage.xml
+Local_*
+.hypothesis
+*.gz
+htmlcov/
+*.xml.temp
+
+#remove in case we want a specific LHCb one
+.pylintrc
+
+# docs
+# this is auto generated
+docs/source/CodeDocumentation/
+docs/source/AdministratorGuide/Configuration/ExampleConfig.rst
+docs/source/AdministratorGuide/CommandReference
+docs/source/UserGuide/CommandReference
+docs/_build
+docs/source/_build
+
+
+# CMT junk
+/*/*/x86_64-*-*-*/
+*/*/cmt/Makefile
+
+# pixi environments
+.pixi
+pixi.lock
+*.egg-info

{diracx_db-0.0.1a44 → diracx_db-0.0.1a45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diracx-db
-Version: 0.0.1a44
+Version: 0.0.1a45
 Summary: TODO
 License: GPL-3.0-only
 Classifier: Intended Audience :: Science/Research
@@ -9,11 +9,11 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: System :: Distributed Computing
 Requires-Python: >=3.11
-Description-Content-Type: text/markdown
 Requires-Dist: diracx-core
 Requires-Dist: opensearch-py[async]
 Requires-Dist: pydantic>=2.10
 Requires-Dist: sqlalchemy[aiomysql,aiosqlite]>=2
 Requires-Dist: uuid-utils
 Provides-Extra: testing
-Requires-Dist: diracx-testing; extra == "testing"
+Requires-Dist: diracx-testing; extra == 'testing'
+Requires-Dist: freezegun; extra == 'testing'

{diracx_db-0.0.1a44 → diracx_db-0.0.1a45}/pyproject.toml

@@ -22,9 +22,7 @@ dependencies = [
 dynamic = ["version"]
 
 [project.optional-dependencies]
-testing = [
-    "diracx-testing",
-]
+testing = ["diracx-testing", "freezegun"]
 
 [project.entry-points."diracx.dbs.sql"]
 AuthDB = "diracx.db.sql:AuthDB"
@@ -37,16 +35,18 @@ TaskQueueDB = "diracx.db.sql:TaskQueueDB"
 [project.entry-points."diracx.dbs.os"]
 JobParametersDB = "diracx.db.os:JobParametersDB"
 
-[tool.setuptools.packages.find]
-where = ["src"]
-
 [build-system]
-requires = ["setuptools>=61", "wheel", "setuptools_scm>=8"]
-build-backend = "setuptools.build_meta"
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
 
-[tool.setuptools_scm]
+[tool.hatch.version.raw-options]
 root = ".."
 
+[tool.hatch.build.targets.wheel]
+packages = ["src/diracx"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{diracx_db-0.0.1a44 → diracx_db-0.0.1a45}/src/diracx/db/os/job_parameters.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from DIRAC.Core.Utilities import TimeUtilities
+from datetime import UTC, datetime
 
 from diracx.db.os.utils import BaseOSDB
 
@@ -31,7 +31,7 @@ class JobParametersDB(BaseOSDB):
     def upsert(self, vo, doc_id, document):
         document = {
             "JobID": doc_id,
-            "timestamp": TimeUtilities.toEpochMilliSeconds(),
+            "timestamp": int(datetime.now(tz=UTC).timestamp() * 1000),
             **document,
         }
         return super().upsert(vo, doc_id, document)

{diracx_db-0.0.1a44 → diracx_db-0.0.1a45}/src/diracx/db/sql/job/db.py

@@ -50,7 +50,7 @@ class JobDB(BaseSQLDB):
     }
 
     # TODO: this is copied from the DIRAC JobDB
-    # but is overwriten in LHCbDIRAC, so we need
+    # but is overwritten in LHCbDIRAC, so we need
     # to find a way to make it dynamic
     jdl_2_db_parameters = ["JobName", "JobType", "JobGroup"]
 

{diracx_db-0.0.1a44 → diracx_db-0.0.1a45}/src/diracx/db/sql/job_logging/schema.py

@@ -44,7 +44,7 @@ class MagicEpochDateTime(TypeDecorator):
         """
         if value is None:
             return None
-        # Carefully convert from Decimal to datetime to avoid loosing precision
+        # Carefully convert from Decimal to datetime to avoid losing precision
         value += self.MAGIC_EPOC_NUMBER
         value_int = int(value)
         result = datetime.fromtimestamp(value_int, tz=UTC)

{diracx_db-0.0.1a44 → diracx_db-0.0.1a45}/src/diracx/db/sql/sandbox_metadata/db.py

@@ -1,8 +1,24 @@
 from __future__ import annotations
 
-from typing import Any
+import logging
+from contextlib import asynccontextmanager
+from functools import partial
+from typing import Any, AsyncGenerator
 
-from sqlalchemy import Executable, delete, insert, literal, select, update
+from sqlalchemy import (
+    BigInteger,
+    Column,
+    Executable,
+    MetaData,
+    Table,
+    and_,
+    delete,
+    insert,
+    literal,
+    or_,
+    select,
+    update,
+)
 from sqlalchemy.exc import IntegrityError, NoResultFound
 
 from diracx.core.exceptions import (
@@ -12,15 +28,25 @@ from diracx.core.exceptions import (
 )
 from diracx.core.models import SandboxInfo, SandboxType, UserInfo
 from diracx.db.sql.utils.base import BaseSQLDB
-from diracx.db.sql.utils.functions import utcnow
+from diracx.db.sql.utils.functions import days_since, utcnow
 
 from .schema import Base as SandboxMetadataDBBase
 from .schema import SandBoxes, SBEntityMapping, SBOwners
 
+logger = logging.getLogger(__name__)
+
 
 class SandboxMetadataDB(BaseSQLDB):
     metadata = SandboxMetadataDBBase.metadata
 
+    # Temporary table to store the sandboxes to delete, see `select_and_delete_expired`
+    _temp_table = Table(
+        "sb_to_delete",
+        MetaData(),
+        Column("SBId", BigInteger, primary_key=True),
+        prefixes=["TEMPORARY"],
+    )
+
     async def get_owner_id(self, user: UserInfo) -> int | None:
         """Get the id of the owner from the database."""
         stmt = select(SBOwners.OwnerID).where(
@@ -85,7 +111,13 @@ class SandboxMetadataDB(BaseSQLDB):
             .values(LastAccessTime=utcnow())
         )
         result = await self.conn.execute(stmt)
-        assert result.rowcount == 1
+        if result.rowcount == 0:
+            # If the update didn't affect any row, the sandbox doesn't exist
+            raise SandboxNotFoundError(pfn, se_name)
+        elif result.rowcount != 1:
+            raise NotImplementedError(
+                "More than one sandbox was updated. This should not happen."
+            )
 
     async def sandbox_is_assigned(self, pfn: str, se_name: str) -> bool | None:
         """Checks if a sandbox exists and has been assigned."""
@@ -128,7 +160,7 @@ class SandboxMetadataDB(BaseSQLDB):
         sb_type: SandboxType,
         se_name: str,
     ) -> None:
-        """Mapp sandbox and jobs."""
+        """Map sandbox and jobs."""
         for job_id in jobs_ids:
             # Define the entity id as 'Entity:entity_id' due to the DB definition:
             entity_id = self.jobid_to_entity_id(job_id)
@@ -187,3 +219,56 @@ class SandboxMetadataDB(BaseSQLDB):
                     .values(Assigned=False)
                 )
                 await self.conn.execute(unassign_stmt)
+
+    @asynccontextmanager
+    async def delete_unused_sandboxes(
+        self, *, limit: int | None = None
+    ) -> AsyncGenerator[AsyncGenerator[str, None], None]:
+        """Get the sandbox PFNs to delete.
+
+        The result of this function can be used as an async context manager
+        to yield the PFNs of the sandboxes to delete. The context manager
+        will automatically remove the sandboxes from the database upon exit.
+
+        Args:
+            limit: If not None, the maximum number of sandboxes to delete.
+
+        """
+        conditions = [
+            # If it has assigned to a job but is no longer mapped it can be removed
+            # and_(SandBoxes.Assigned, ~exists(SandBoxes.SBId == SBEntityMapping.SBId)),
+            # If the sandbox is still unassigned after 15 days, remove it
+            and_(~SandBoxes.Assigned, days_since(SandBoxes.LastAccessTime) >= 15),
+        ]
+        # Sandboxes which are not on S3 will be handled by legacy DIRAC
+        condition = and_(SandBoxes.SEPFN.like("/S3/%"), or_(*conditions))
+
+        # Copy the in-flight rows to a temporary table
+        await self.conn.run_sync(partial(self._temp_table.create, checkfirst=True))
+        select_stmt = select(SandBoxes.SBId).where(condition)
+        if limit:
+            select_stmt = select_stmt.limit(limit)
+        insert_stmt = insert(self._temp_table).from_select(["SBId"], select_stmt)
+        await self.conn.execute(insert_stmt)
+
+        try:
+            # Select the sandbox PFNs from the temporary table and yield them
+            select_stmt = select(SandBoxes.SEPFN).join(
+                self._temp_table, self._temp_table.c.SBId == SandBoxes.SBId
+            )
+
+            async def yield_pfns() -> AsyncGenerator[str, None]:
+                async for row in await self.conn.stream(select_stmt):
+                    yield row.SEPFN
+
+            yield yield_pfns()
+
+            # Delete the sandboxes from the main table
+            delete_stmt = delete(SandBoxes).where(
+                SandBoxes.SBId.in_(select(self._temp_table.c.SBId))
+            )
+            result = await self.conn.execute(delete_stmt)
+            logger.info("Deleted %d expired/unassigned sandboxes", result.rowcount)
+
+        finally:
+            await self.conn.run_sync(partial(self._temp_table.drop, checkfirst=True))

{diracx_db-0.0.1a44 → diracx_db-0.0.1a45}/src/diracx/db/sql/task_queue/db.py

@@ -56,7 +56,7 @@ class TaskQueueDB(BaseSQLDB):
         )
         rows = await self.conn.execute(stmt)
         # Get owners in this group and the amount of times they appear
-        # TODO: I guess the rows are already a list of tupes
+        # TODO: I guess the rows are already a list of tuples
         # maybe refactor
         return {r[0]: r[1] for r in rows if r}
 
@@ -108,7 +108,7 @@ class TaskQueueDB(BaseSQLDB):
         tq_ids: list[int],
         priority: float,
     ):
-        """Set the priority for a user/userGroup combo given a splitted share."""
+        """Set the priority for a user/userGroup combo given a split share."""
         update_stmt = (
             update(TaskQueues)
             .where(TaskQueues.TQId.in_(tq_ids))

{diracx_db-0.0.1a44 → diracx_db-0.0.1a45}/src/diracx/db/sql/utils/base.py

@@ -51,7 +51,7 @@ class BaseSQLDB(metaclass=ABCMeta):
     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
+    it's `__init__` function with a URL previously obtained from
     `BaseSQLDB.available_urls`.
 
     To control the lifetime of the SQLAlchemy engine used for connecting to the

{diracx_db-0.0.1a44 → diracx_db-0.0.1a45}/src/diracx/db/sql/utils/functions.py

@@ -103,6 +103,37 @@ def sqlite_date_trunc(element, compiler, **kw):
     )
 
 
+class days_since(expression.FunctionElement):  # noqa: N801
+    """Sqlalchemy function to get the number of days since a given date.
+
+    Primarily used to be able to query for a specific resolution of a date e.g.
+
+        select * from table where days_since(date_column) = 0
+        select * from table where days_since(date_column) = 1
+    """
+
+    type = DateTime()
+    inherit_cache = False
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+
+@compiles(days_since, "postgresql")
+def pg_days_since(element, compiler, **kw):
+    return f"EXTRACT(DAY FROM (now() - {compiler.process(element.clauses)}))"
+
+
+@compiles(days_since, "mysql")
+def mysql_days_since(element, compiler, **kw):
+    return f"DATEDIFF(NOW(), {compiler.process(element.clauses)})"
+
+
+@compiles(days_since, "sqlite")
+def sqlite_days_since(element, compiler, **kw):
+    return f"julianday('now') - julianday({compiler.process(element.clauses)})"
+
+
 def substract_date(**kwargs: float) -> datetime:
     return datetime.now(tz=timezone.utc) - timedelta(**kwargs)
 

diracx_db-0.0.1a45/tests/test_freeze_time.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import re
+from datetime import UTC, datetime, timedelta, timezone
+
+import freezegun
+import pytest
+import sqlalchemy
+from sqlalchemy.ext.asyncio import create_async_engine
+
+from diracx.testing.time import julian_date, mock_sqlite_time
+
+RE_SQLITE_TIME = re.compile(r"(\d{4})-(\d{2})-(\d{2})(?: (\d{2}):(\d{2}):(\d{2}))?")
+
+
+@pytest.mark.parametrize(
+    "dt, expected",
+    [
+        (datetime(2000, 1, 1, 18, 0, 0, tzinfo=UTC), 2451545.25),
+        (datetime(2000, 1, 1, 6, 0, 0, tzinfo=UTC), 2451544.75),
+    ],
+)
+def test_julian_date(dt, expected):
+    """Test the julian_date function with known values."""
+    assert julian_date(dt) == expected
+
+
+def test_julian_date_non_utc():
+    """Test the julian_date function with a non-UTC timezone."""
+    non_utc = timezone(timedelta(hours=-5))
+    dt = datetime(2000, 1, 1, 18, 0, 0, tzinfo=non_utc)
+    jd = julian_date(dt)
+    # dt in UTC is 2000-01-01 23:00:00, so fractional day is (23-12)/24 = 11/24
+    expected = 2451545 + 11 / 24
+    assert abs(jd - expected) < 1e-6
+
+
+@pytest.mark.parametrize("with_mock", [True, False])
+async def test_freeze_sqlite_datetime(with_mock):
+    """Test the SQLite DATETIME() function with freezegun."""
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:", future=True, echo=True)
+    if with_mock:
+        sqlalchemy.event.listen(engine.sync_engine, "connect", mock_sqlite_time)
+
+    async with engine.begin() as conn:
+        # DATETIME()
+        result = await conn.execute(sqlalchemy.text("SELECT DATETIME()"))
+        value = datetime.strptime(result.scalar_one(), "%Y-%m-%d %H:%M:%S").replace(
+            tzinfo=UTC
+        )
+        actual = datetime.now(UTC)
+        assert abs(value - actual) < timedelta(seconds=1)
+
+        if with_mock:
+            with freezegun.freeze_time("2000-10-01 12:00:00"):
+                result = await conn.execute(sqlalchemy.text("SELECT DATETIME()"))
+                value = datetime.strptime(
+                    result.scalar_one(), "%Y-%m-%d %H:%M:%S"
+                ).replace(tzinfo=UTC)
+                actual = datetime(2000, 10, 1, 12, 0, 0, tzinfo=UTC)
+                assert abs(value - actual) < timedelta(seconds=1)
+
+        # DATETIME('now')
+        result = await conn.execute(sqlalchemy.text("SELECT DATETIME('now')"))
+        value = datetime.strptime(result.scalar_one(), "%Y-%m-%d %H:%M:%S").replace(
+            tzinfo=UTC
+        )
+        actual = datetime.now(UTC)
+        assert abs(value - actual) < timedelta(seconds=1)
+
+        if with_mock:
+            with freezegun.freeze_time("2000-10-01 12:00:00"):
+                result = await conn.execute(sqlalchemy.text("SELECT DATETIME('now')"))
+                value = datetime.strptime(
+                    result.scalar_one(), "%Y-%m-%d %H:%M:%S"
+                ).replace(tzinfo=UTC)
+                actual = datetime(2000, 10, 1, 12, 0, 0, tzinfo=UTC)
+                assert abs(value - actual) < timedelta(seconds=1)
+
+
+@pytest.mark.parametrize("with_mock", [True, False])
+async def test_freeze_sqlite_julianday(with_mock):
+    """Test the SQLite JULIANDAY() function with freezegun."""
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:", future=True, echo=True)
+    if with_mock:
+        sqlalchemy.event.listen(engine.sync_engine, "connect", mock_sqlite_time)
+
+    async with engine.begin() as conn:
+        # JULIANDAY()
+        result = await conn.execute(sqlalchemy.text("SELECT JULIANDAY()"))
+        actual = julian_date(datetime.now(UTC))
+        assert abs(result.scalar_one() - actual) < 1e-3
+
+        if with_mock:
+            with freezegun.freeze_time("2000-10-01 12:00:00"):
+                result = await conn.execute(sqlalchemy.text("SELECT JULIANDAY()"))
+                actual = julian_date(datetime(2000, 10, 1, 12, 0, 0, tzinfo=UTC))
+                assert abs(result.scalar_one() - actual) < 1e-3
+
+        # JULIANDAY('now')
+        result = await conn.execute(sqlalchemy.text("SELECT JULIANDAY('now')"))
+        actual = julian_date(datetime.now(UTC))
+        assert abs(result.scalar_one() - actual) < 1e-3
+
+        if with_mock:
+            with freezegun.freeze_time("2000-10-01 12:00:00"):
+                result = await conn.execute(sqlalchemy.text("SELECT JULIANDAY('now')"))
+                actual = julian_date(datetime(2000, 10, 1, 12, 0, 0, tzinfo=UTC))
+                assert abs(result.scalar_one() - actual) < 1e-3
+
+        # JULIANDAY('YYYY-MM-DD')
+        result = await conn.execute(sqlalchemy.text("SELECT JULIANDAY('1996-05-30')"))
+        assert result.scalar_one() == 2450233.5
+
+        if with_mock:
+            with freezegun.freeze_time("2020-12-13 12:34:56"):
+                result = await conn.execute(
+                    sqlalchemy.text("SELECT JULIANDAY('1996-05-30')")
+                )
+                assert result.scalar_one() == 2450233.5
+
+        # JULIANDAY('YYYY-MM-DD HH:MM:SS')
+        result = await conn.execute(
+            sqlalchemy.text("SELECT JULIANDAY('2000-10-01 12:00:00')")
+        )
+        assert result.scalar_one() == 2451819.0
+
+        if with_mock:
+            with freezegun.freeze_time("2020-12-13 12:34:56"):
+                result = await conn.execute(
+                    sqlalchemy.text("SELECT JULIANDAY('2000-10-01 12:00:00')")
+                )
+                assert result.scalar_one() == 2451819.0
+
+        # JULIANDAY('1356')
+        result = await conn.execute(sqlalchemy.text("SELECT JULIANDAY('1356')"))
+        assert result.scalar_one() == 1356.0
+
+        if with_mock:
+            with freezegun.freeze_time("2020-12-13 12:34:56"):
+                result = await conn.execute(sqlalchemy.text("SELECT JULIANDAY('1356')"))
+                assert result.scalar_one() == 1356.0
+
+        # JULIANDAY('1356.12')
+        result = await conn.execute(sqlalchemy.text("SELECT JULIANDAY('1356.12')"))
+        assert result.scalar_one() == 1356.12
+
+        if with_mock:
+            with freezegun.freeze_time("2020-12-13 12:34:56"):
+                result = await conn.execute(
+                    sqlalchemy.text("SELECT JULIANDAY('1356.12')")
+                )
+                assert result.scalar_one() == 1356.12

diracx_db-0.0.1a44/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-

diracx_db-0.0.1a44/src/diracx_db.egg-info/PKG-INFO

@@ -1,19 +0,0 @@
-Metadata-Version: 2.4
-Name: diracx-db
-Version: 0.0.1a44
-Summary: TODO
-License: GPL-3.0-only
-Classifier: Intended Audience :: Science/Research
-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.11
-Description-Content-Type: text/markdown
-Requires-Dist: diracx-core
-Requires-Dist: opensearch-py[async]
-Requires-Dist: pydantic>=2.10
-Requires-Dist: sqlalchemy[aiomysql,aiosqlite]>=2
-Requires-Dist: uuid-utils
-Provides-Extra: testing
-Requires-Dist: diracx-testing; extra == "testing"

diracx_db-0.0.1a44/src/diracx_db.egg-info/SOURCES.txt

@@ -1,53 +0,0 @@
-README.md
-pyproject.toml
-src/diracx/db/__init__.py
-src/diracx/db/__main__.py
-src/diracx/db/exceptions.py
-src/diracx/db/py.typed
-src/diracx/db/os/__init__.py
-src/diracx/db/os/job_parameters.py
-src/diracx/db/os/utils.py
-src/diracx/db/sql/__init__.py
-src/diracx/db/sql/auth/__init__.py
-src/diracx/db/sql/auth/db.py
-src/diracx/db/sql/auth/schema.py
-src/diracx/db/sql/dummy/__init__.py
-src/diracx/db/sql/dummy/db.py
-src/diracx/db/sql/dummy/schema.py
-src/diracx/db/sql/job/__init__.py
-src/diracx/db/sql/job/db.py
-src/diracx/db/sql/job/schema.py
-src/diracx/db/sql/job_logging/__init__.py
-src/diracx/db/sql/job_logging/db.py
-src/diracx/db/sql/job_logging/schema.py
-src/diracx/db/sql/pilot_agents/__init__.py
-src/diracx/db/sql/pilot_agents/db.py
-src/diracx/db/sql/pilot_agents/schema.py
-src/diracx/db/sql/sandbox_metadata/__init__.py
-src/diracx/db/sql/sandbox_metadata/db.py
-src/diracx/db/sql/sandbox_metadata/schema.py
-src/diracx/db/sql/task_queue/__init__.py
-src/diracx/db/sql/task_queue/db.py
-src/diracx/db/sql/task_queue/schema.py
-src/diracx/db/sql/utils/__init__.py
-src/diracx/db/sql/utils/base.py
-src/diracx/db/sql/utils/functions.py
-src/diracx/db/sql/utils/types.py
-src/diracx_db.egg-info/PKG-INFO
-src/diracx_db.egg-info/SOURCES.txt
-src/diracx_db.egg-info/dependency_links.txt
-src/diracx_db.egg-info/entry_points.txt
-src/diracx_db.egg-info/requires.txt
-src/diracx_db.egg-info/top_level.txt
-tests/test_dummy_db.py
-tests/auth/test_authorization_flow.py
-tests/auth/test_device_flow.py
-tests/auth/test_refresh_token.py
-tests/jobs/test_job_db.py
-tests/jobs/test_job_logging_db.py
-tests/jobs/test_sandbox_metadata.py
-tests/opensearch/test_connection.py
-tests/opensearch/test_index_template.py
-tests/opensearch/test_search.py
-tests/pilot_agents/__init__.py
-tests/pilot_agents/test_pilot_agents_db.py

diracx_db-0.0.1a44/src/diracx_db.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

diracx_db-0.0.1a44/src/diracx_db.egg-info/entry_points.txt

@@ -1,10 +0,0 @@
-[diracx.dbs.os]
-JobParametersDB = diracx.db.os:JobParametersDB
-
-[diracx.dbs.sql]
-AuthDB = diracx.db.sql:AuthDB
-JobDB = diracx.db.sql:JobDB
-JobLoggingDB = diracx.db.sql:JobLoggingDB
-PilotAgentsDB = diracx.db.sql:PilotAgentsDB
-SandboxMetadataDB = diracx.db.sql:SandboxMetadataDB
-TaskQueueDB = diracx.db.sql:TaskQueueDB

diracx_db-0.0.1a44/src/diracx_db.egg-info/requires.txt

@@ -1,8 +0,0 @@
-diracx-core
-opensearch-py[async]
-pydantic>=2.10
-sqlalchemy[aiomysql,aiosqlite]>=2
-uuid-utils
-
-[testing]
-diracx-testing

diracx_db-0.0.1a44/src/diracx_db.egg-info/top_level.txt

@@ -1 +0,0 @@
-diracx