diracx-testing 0.0.1a43__py3-none-any.whl → 0.0.1a45__py3-none-any.whl

diracx/testing/__init__.py

@@ -11,9 +11,8 @@ from .utils import (
     demo_urls,
     do_device_flow_with_dex,
     fernet_key,
-    private_key_pem,
+    private_key,
     pytest_addoption,
-    pytest_collection_modifyitems,
     session_client_factory,
     test_auth_settings,
     test_dev_settings,
@@ -29,8 +28,7 @@ __all__ = (
     "do_device_flow_with_dex",
     "test_login",
     "pytest_addoption",
-    "pytest_collection_modifyitems",
-    "private_key_pem",
+    "private_key",
     "fernet_key",
     "test_dev_settings",
     "test_auth_settings",

diracx/testing/__main__.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import argparse
+import shlex
+import subprocess
+from importlib.resources import as_file, files
+from pathlib import Path
+from typing import NoReturn
+
+SCRIPTS_BASE = files("diracx.testing").joinpath("scripts")
+
+
+def parse_args() -> None:
+    """Access to various utility scripts for testing DiracX and extensions."""
+    parser = argparse.ArgumentParser(description="Utility for testing DiracX.")
+    sp = parser.add_subparsers(dest="command", required=True)
+
+    # Create the 'coverage' argument group.
+    coverage_p = sp.add_parser("coverage", help="Coverage related commands")
+    coverage_sp = coverage_p.add_subparsers(dest="subcommand", required=True)
+
+    # Add the 'collect-demo' command under 'coverage'.
+    collect_demo_p = coverage_sp.add_parser(
+        "collect-demo", help="Collect demo coverage"
+    )
+    collect_demo_p.add_argument(
+        "--demo-dir",
+        required=True,
+        type=Path,
+        help="Path to the .demo dir of the diracx-charts repo.",
+    )
+    collect_demo_p.set_defaults(func=lambda a: coverage_collect_demo(a.demo_dir))
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+def coverage_collect_demo(demo_dir: Path) -> NoReturn:
+    """Collect coverage data from a running instance of the demo.
+
+    This script is primarily intended for use in CI/CD pipelines.
+    """
+    from diracx.core.extensions import extensions_by_priority
+
+    client_extension_name = min(extensions_by_priority(), key=lambda x: x == "diracx")
+
+    with as_file(SCRIPTS_BASE / "collect_demo_coverage.sh") as script_file:
+        cmd = ["bash", str(script_file), "--demo-dir", str(demo_dir)]
+        if client_extension_name in {"diracx", "gubbins"}:
+            cmd += ["--diracx-repo", str(Path.cwd())]
+            if client_extension_name == "gubbins":
+                cmd += ["--extension-name", "gubbins"]
+                cmd += ["--extension-repo", str(Path.cwd() / "extensions" / "gubbins")]
+        else:
+            cmd += ["--extension-name", client_extension_name]
+            cmd += ["--extension-repo", str(Path.cwd())]
+        print("Running:", shlex.join(cmd))
+        proc = subprocess.run(cmd, check=False)
+    if proc.returncode == 0:
+        print("Process completed successfully.")
+    else:
+        print("Process failed with return code", proc.returncode)
+    raise SystemExit(proc.returncode)
+
+
+if __name__ == "__main__":
+    parse_args()

diracx/testing/client_generation.py

@@ -2,17 +2,27 @@ from __future__ import annotations
 
 __all__ = [
     "regenerate_client",
-    "AUTOREST_VERSION",
 ]
 
+import argparse
 import ast
 import importlib.util
+import json
+import shlex
 import subprocess
+import sys
+from importlib.metadata import Distribution
 from pathlib import Path
+from urllib.parse import urlparse
 
 import git
 
-AUTOREST_VERSION = "6.13.7"
+AUTOREST_VERSION = "3.7.1"
+AUTOREST_CORE_VERSION = "3.10.4"
+AUTOREST_PUGINS = {
+    "@autorest/python": "6.34.2",
+    "@autorest/modelerfour": "4.23.7",
+}
 
 
 def extract_static_all(path):
@@ -70,6 +80,26 @@ def fixup_models_init(generated_dir, extension_name):
         )
 
 
+def _module_path(module_name: str) -> Path:
+    """Get the path to a module.
+
+    Args:
+        module_name: The name of the module.
+
+    Returns:
+        The path to the module.
+
+    """
+    spec = importlib.util.find_spec(module_name)
+    if spec is None:
+        raise ImportError("Cannot locate client_module package")
+    if spec.origin is None:
+        raise ImportError(
+            "Cannot locate client_module package, did you forget the __init__.py?"
+        )
+    return Path(spec.origin).parent
+
+
 def regenerate_client(openapi_spec: Path, client_module: str):
     """Regenerate the AutoREST client and run pre-commit checks on it.
 
@@ -82,14 +112,29 @@ def regenerate_client(openapi_spec: Path, client_module: str):
 
     WARNING: This test will modify the source code of the client!
     """
-    spec = importlib.util.find_spec(client_module)
-    if spec is None:
-        raise ImportError("Cannot locate client_module package")
-    if spec.origin is None:
-        raise ImportError(
-            "Cannot locate client_module package, did you forget the __init__.py?"
+    client_root = _module_path(client_module)
+
+    # If the client is not an editable install, we need to find the source code
+    direct_url = Distribution.from_name(client_module).read_text("direct_url.json")
+    pkg_url_info = json.loads(direct_url)
+    if not pkg_url_info.get("dir_info", {}).get("editable", False):
+        src_url = pkg_url_info.get("url")
+        if src_url is None:
+            raise ValueError("No URL found in direct_url.json")
+        url_info = urlparse(src_url)
+        if url_info.scheme != "file":
+            raise ValueError("URL is not a file URL")
+        pkg_root = Path(url_info.path) / "src" / client_module.replace(".", "/")
+        if not pkg_root.is_dir():
+            raise NotImplementedError(
+                "Failed to resolve client sources", client_module, pkg_root
+            )
+        client_root = pkg_root
+
+    if not pkg_url_info.get("dir_info", {}).get("editable", False):
+        raise NotImplementedError(
+            "Client generation from non-editable install is not yet supported",
         )
-    client_root = Path(spec.origin).parent
 
     assert client_root.is_dir()
     assert client_root.name == "client"
@@ -97,7 +142,7 @@ def regenerate_client(openapi_spec: Path, client_module: str):
     extension_name = client_root.parent.name
 
     repo_root = client_root.parents[3]
-    if extension_name == "gubbins":
+    if extension_name == "gubbins" and not (repo_root / ".git").is_dir():
         # Gubbins is special because it has a different structure due to being
         # in a subdirectory of diracx
         repo_root = repo_root.parents[1]
@@ -109,8 +154,10 @@ def regenerate_client(openapi_spec: Path, client_module: str):
             "Client is currently in a modified state, skipping regeneration"
         )
 
-    cmd = [
-        "autorest",
+    cmd = ["autorest", f"--version={AUTOREST_CORE_VERSION}"]
+    for plugin, version in AUTOREST_PUGINS.items():
+        cmd.append(f"--use={plugin}@{version}")
+    cmd += [
         "--python",
         f"--input-file={openapi_spec}",
         "--models-mode=msrest",
@@ -118,11 +165,6 @@ def regenerate_client(openapi_spec: Path, client_module: str):
         f"--output-folder={client_root}",
     ]
 
-    # This is required to be able to work offline
-    # TODO: if offline, find the version already installed
-    # and use it
-    # cmd += [f"--use=@autorest/python@{AUTOREST_VERSION}"]
-
     # ruff: disable=S603
     subprocess.run(cmd, check=True)
 
@@ -154,3 +196,36 @@ def regenerate_client(openapi_spec: Path, client_module: str):
     if proc.returncode != 0:
         raise AssertionError("Pre-commit failed")
     raise AssertionError("Client was regenerated with changes")
+
+
+def main():
+    from diracx.core.extensions import extensions_by_priority
+
+    parser = argparse.ArgumentParser(
+        description="Regenerate the AutoREST client and run pre-commit checks on it."
+    )
+    parser.parse_args()
+
+    client_extension_name = min(extensions_by_priority(), key=lambda x: x == "diracx")
+
+    cmd = ["npm", "install", "-g", f"autorest@{AUTOREST_VERSION}"]
+    print("Ensuring autorest is installed by running", shlex.join(cmd))
+    subprocess.run(cmd, check=True)
+
+    cmd = [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-pdiracx.testing",
+        "--import-mode=importlib",
+        "--no-cov",
+        f"--regenerate-client={client_extension_name}",
+        str(Path(__file__).parent / "client_generation_pytest.py"),
+    ]
+    print("Generating client for", client_extension_name)
+    print("Running:", shlex.join(cmd))
+    subprocess.run(cmd, check=True)
+
+
+if __name__ == "__main__":
+    main()

diracx/testing/client_generation_pytest.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import pytest
+
+from diracx.testing.client_generation import regenerate_client
+
+pytestmark = pytest.mark.enabled_dependencies([])
+
+
+@pytest.fixture
+def test_client(client_factory):
+    with client_factory.unauthenticated() as client:
+        yield client
+
+
+def test_regenerate_client(test_client, tmp_path, request):
+    """Regenerate the AutoREST client and run pre-commit checks on it.
+
+    This test is skipped by default, and can be enabled by passing
+    --regenerate-client to pytest. It is intended to be run manually
+    when the API changes.
+
+    The reason this is a test is that it is the only way to get access to the
+    test_client fixture, which is required to get the OpenAPI spec.
+
+    WARNING: This test will modify the source code of the client!
+    """
+    client_name = request.config.getoption("--regenerate-client")
+    if client_name is None:
+        pytest.skip("--regenerate-client not specified")
+
+    r = test_client.get("/api/openapi.json")
+    r.raise_for_status()
+    openapi_spec = tmp_path / "openapi.json"
+    openapi_spec.write_text(r.text)
+
+    regenerate_client(openapi_spec, f"{client_name}.client")

diracx/testing/scripts/collect_demo_coverage.sh

@@ -0,0 +1,147 @@
+#!/usr/bin/env bash
+# Enable the unofficial bash strict mode
+# See: http://redsymbol.net/articles/unofficial-bash-strict-mode/
+set -euo pipefail
+IFS=$'\n\t'
+
+usage() {
+    echo "Usage: $(basename "$0") [OPTIONS]"
+    echo "Collect coverage data from a demo run."
+    echo
+    echo "Options:"
+    echo "  --demo-dir <path>         Path to the demo directory."
+    echo "  --diracx-repo <path>     Path to the DiracX repository."
+    echo "  --extension-name <name>  Name of the extension to collect coverage for."
+    echo "  --extension-repo <path>  Path to the extension repository."
+    echo "  -h, --help              Show this help message and exit."
+    echo
+    exit 1
+}
+
+# Parse command line arguments
+demo_dir=""
+diracx_repo=""
+extension_name=""
+extension_repo=""
+
+while [[ "$#" -gt 0 ]]; do
+    case "$1" in
+        --demo-dir)
+            if [[ -n "${2:-}" ]]; then
+                demo_dir="$2"
+                shift 2
+            else
+                echo "Error: --demo-dir requires a value."
+                usage
+            fi
+            ;;
+        --diracx-repo)
+            if [[ -n "${2:-}" ]]; then
+                diracx_repo=$(realpath "$2")
+                shift 2
+            else
+                echo "Error: --diracx-repo requires a value."
+                usage
+            fi
+            ;;
+        --extension-name)
+            if [[ -n "${2:-}" ]]; then
+                extension_name="$2"
+                shift 2
+            else
+                echo "Error: --extension-name requires a value."
+                usage
+            fi
+            ;;
+        --extension-repo)
+            if [[ -n "${2:-}" ]]; then
+                extension_repo=$(realpath "$2")
+                shift 2
+            else
+                echo "Error: --extension-repo requires a value."
+                usage
+            fi
+            ;;
+        *)
+            echo "Unknown parameter passed: $1"
+            usage
+            ;;
+    esac
+done
+
+# Argument validation
+if [[ -z "$demo_dir" ]]; then
+    echo "Error: --demo-dir is required."
+    usage
+fi
+if [[ -z "${diracx_repo:-}" && -z "${extension_repo:-}" ]]; then
+    echo "Error: At least one of --diracx-repo or --extension-repo is required."
+    usage
+fi
+if [[ -n "${extension_name:-}" && -z "${extension_repo:-}" ]]; then
+    echo "Error: --extension-name is required when --extension-repo is provided."
+    usage
+fi
+if [[ ! -f ".coveragerc" ]]; then
+    echo "Error: Expected .coveragerc file not found in the current directory."
+    exit 1
+fi
+
+# Set up the environment
+export KUBECONFIG=${demo_dir}/kube.conf
+export PATH=${demo_dir}:$PATH
+
+if ! kubectl cluster-info > /dev/null 2>&1; then
+    echo "Error: The demo does not appear to be running."
+    exit 1
+fi
+
+# Shutdown the pods so we collect coverage data
+pods=$(kubectl get pods -o json | jq -r '.items[] | .metadata.name')
+for pod_name in $(echo "${pods}" | grep -vE '(dex|minio|mysql|rabbitmq|opensearch)'); do
+    kubectl delete pod/"${pod_name}"
+done
+
+# Combine the coverage data from the demo and make an XML report
+coverage_data=$(mktemp)
+echo "Changing ownership of coverage data to $(id -u)"
+sudo chown -R "$(id -u)" "${demo_dir}"/coverage-reports/
+coverage combine --keep --data-file "${coverage_data}" "${demo_dir}"/coverage-reports/*
+
+# coverage can't handle having multiple src directories, so we need to make a fake one with symlinks
+fake_module=$(mktemp -d)
+
+# Ensure we clean up the fake module and restore the original .coveragerc
+cleanup() {
+    rm -rf "${fake_module}"
+    if [[ -f ".coveragerc.bak" ]]; then
+        mv ".coveragerc.bak" .coveragerc
+    fi
+}
+trap cleanup EXIT
+
+# Symlink DiracX into the fake module (if provided)
+if [[ -n "${diracx_repo:-}" ]]; then
+    mkdir -p "${fake_module}/src/diracx"
+    for fn in "${diracx_repo}"/*/src/diracx/*; do
+        ln -sf "${fn}" "${fake_module}/src/diracx/$(basename "${fn}")"
+    done
+fi
+
+# Symlink the extension into the fake module (if provided)
+if [[ -n "${extension_repo:-}" ]]; then
+    mkdir -p "${fake_module}/src/${extension_name}/extensions"
+    for fn in "${extension_repo}"/*/src/"${extension_name}"/*; do
+        ln -sf "${fn}" "${fake_module}/src/${extension_name}/$(basename "${fn}")"
+    done
+fi
+
+# Edit the .coveragerc file to point to the fake module
+sed -i.bak "s@source =@source =\n    ${fake_module}/src@g" .coveragerc
+if diff -q .coveragerc .coveragerc.bak > /dev/null; then
+    echo "Error: .coveragerc was not modified."
+    exit 1
+fi
+
+# Make the actual coverage report
+coverage xml -o coverage-demo.xml --data-file "${coverage_data}"

diracx/testing/time.py

@@ -0,0 +1,135 @@
+"""Helper functions for mocking time functions.
+
+The main functionality in this module is to mock SQLite's date and time
+functions. This is useful for testing purposes, especially when using
+freezegun to freeze time.
+
+Example usage to mock SQLite time functions in SQLAlchemy for connections in
+a given engine:
+
+    import sqlalchemy
+
+    from diracx.testing.time import mock_sqlite_time
+
+    sqlalchemy.event.listen(engine.sync_engine, "connect", mock_sqlite_time)
+
+This functionality is tested in the `diracx-db` tests, specifically in the
+`test_freeze_time.py` file.
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "mock_sqlite_time",
+    "julian_date",
+]
+
+import re
+from datetime import UTC, datetime
+
+RE_SQLITE_TIME = re.compile(r"(\d{4})-(\d{2})-(\d{2})(?: (\d{2}):(\d{2}):(\d{2}))?")
+
+
+def mock_sqlite_time(dbapi_connection, connection_record):
+    """Override SQLite’s date and time functions.
+
+    See: https://sqlite.org/lang_datefunc.html#tmval
+    """
+
+    # 1. date(time-value, modifier, modifier, ...)
+    def date_mock(*args):
+        """Mock for DATE() function."""
+        raise NotImplementedError(args)
+
+    # 2. time(time-value, modifier, modifier, ...)
+    def time_mock(*args):
+        """Mock for TIME() function."""
+        raise NotImplementedError(args)
+
+    # 3. datetime(time-value, modifier, modifier, ...)
+    def datetime_mock(*args):
+        """Mock for DATETIME() function."""
+        if len(args) == 0:
+            args = ("now",)
+        if len(args) > 1:
+            raise NotImplementedError(args)
+
+        time_value = args[0]
+        if time_value == "now":
+            return datetime.now(UTC).strftime("%Y-%m-%d %H:%M:%S")
+
+        raise NotImplementedError(args)
+
+    # 7. julianday(time-value, modifier, modifier, ...)
+    def julianday_mock(*args):
+        """Mock for JULIANDAY() function."""
+        if len(args) == 0:
+            args = ("now",)
+        if len(args) > 1:
+            raise NotImplementedError(args)
+
+        if args[0] == "now":
+            return julian_date(datetime.now(UTC))
+        if match := RE_SQLITE_TIME.fullmatch(args[0]):
+            parts = [0 if x is None else int(x) for x in match.groups()]
+            return julian_date_from_parts(*parts)
+        if match := re.fullmatch(r"(\d{4})(?:\.(\d{2}))?", args[0]):
+            return float(args[0])
+
+        raise NotImplementedError(args[0])
+
+    # 5. unixepoch(time-value, modifier, modifier, ...)
+    def unixepoch_mock(*args):
+        """Mock for UNIXEPOCH() function."""
+        raise NotImplementedError(args)
+
+    # 6. strftime(format, time-value, modifier, modifier, ...)
+    def strftime_mock(*args):
+        """Mock for STRFTIME() function."""
+        raise NotImplementedError(args)
+
+    # 7. timediff(time-value, time-value)
+    def timediff_mock(*args):
+        """Mock for TIMEDIFF() function."""
+        raise NotImplementedError(args)
+
+    conn = dbapi_connection
+    conn.create_function("DATE", -1, date_mock)
+    conn.create_function("TIME", -1, time_mock)
+    conn.create_function("DATETIME", -1, datetime_mock)
+    conn.create_function("JULIANDAY", -1, julianday_mock)
+    conn.create_function("UNIXEPOCH", -1, unixepoch_mock)
+    conn.create_function("STRFTIME", -1, strftime_mock)
+    conn.create_function("TIMEDIFF", -1, timediff_mock)
+
+
+def julian_date(dt: datetime) -> float:
+    """Convert a datetime to Julian Date."""
+    if dt.tzinfo is None:
+        raise ValueError("Datetime must be timezone-aware")
+    if dt.tzinfo.utcoffset(dt) is None:
+        raise ValueError("Datetime must be timezone-aware")
+    dt = dt.astimezone(UTC)
+
+    return julian_date_from_parts(
+        dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second
+    )
+
+
+def julian_date_from_parts(
+    year: int, month: int, day: int, hour: int, minute: int, second: int
+) -> float:
+    """Convert year, month, day, hour, minute, second to Julian Date.
+
+    The time MUST be in UTC for the conversion to be correct.
+    """
+    # Step 1: break out the "month shift"
+    a = (14 - month) // 12
+    y = year + 4800 - a
+    m = month + 12 * a - 3
+
+    # Step 2: compute the (integer) Julian Day Number
+    jdn = day + (153 * m + 2) // 5 + 365 * y + y // 4 - y // 100 + y // 400 - 32045
+
+    # Step 3: add fractional day
+    return jdn + (hour - 12) / 24 + minute / 1440 + second / 86400

diracx/testing/utils.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 # are the enabled_dependencies markers
 import asyncio
 import contextlib
+import json
 import os
 import re
 import ssl
@@ -19,6 +20,7 @@ from urllib.parse import parse_qs, urljoin, urlparse
 
 import httpx
 import pytest
+from joserfc.jwk import KeySet, OKPKey
 from uuid_utils import uuid7
 
 from diracx.core.models import AccessTokenPayload, RefreshTokenPayload
@@ -43,8 +45,6 @@ ACCESS_TOKEN_EXPIRE_MINUTES = 30
 def pytest_addoption(parser):
     parser.addoption(
         "--regenerate-client",
-        action="store_true",
-        default=False,
         help="Regenerate the AutoREST client",
     )
     parser.addoption(
@@ -55,28 +55,15 @@ def pytest_addoption(parser):
     )
 
 
-def pytest_collection_modifyitems(config, items):
-    """Disable the test_regenerate_client if not explicitly asked for."""
-    if config.getoption("--regenerate-client"):
-        # --regenerate-client given in cli: allow client re-generation
-        return
-    skip_regen = pytest.mark.skip(reason="need --regenerate-client option to run")
-    for item in items:
-        if item.name == "test_regenerate_client":
-            item.add_marker(skip_regen)
-
-
 @pytest.fixture(scope="session")
-def private_key_pem() -> str:
-    from cryptography.hazmat.primitives import serialization
-    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
-
-    private_key = Ed25519PrivateKey.generate()
-    return private_key.private_bytes(
-        encoding=serialization.Encoding.PEM,
-        format=serialization.PrivateFormat.PKCS8,
-        encryption_algorithm=serialization.NoEncryption(),
-    ).decode()
+def private_key() -> OKPKey:
+    return OKPKey.generate_key(
+        parameters={
+            "key_ops": ["sign", "verify"],
+            "alg": "EdDSA",
+            "kid": uuid7().hex,
+        }
+    )
 
 
 @pytest.fixture(scope="session")
@@ -94,15 +81,12 @@ def test_dev_settings() -> Generator[DevelopmentSettings, None, None]:
 
 
 @pytest.fixture(scope="session")
-def test_auth_settings(
-    private_key_pem, fernet_key
-) -> Generator[AuthSettings, None, None]:
+def test_auth_settings(private_key, fernet_key) -> Generator[AuthSettings, None, None]:
     from diracx.core.settings import AuthSettings
 
     yield AuthSettings(
         token_issuer=ISSUER,
-        token_algorithm="EdDSA",
-        token_key=private_key_pem,
+        token_keystore=json.dumps(KeySet([private_key]).as_dict(private_keys=True)),
         state_key=fernet_key,
         allowed_redirects=[
             "http://diracx.test.invalid:8000/api/docs/oauth2-redirect",

{diracx_testing-0.0.1a43.dist-info → diracx_testing-0.0.1a45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diracx-testing
-Version: 0.0.1a43
+Version: 0.0.1a45
 Summary: TODO
 License: GPL-3.0-only
 Classifier: Intended Audience :: Science/Research
@@ -9,12 +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: httpx
+Requires-Dist: joserfc
 Requires-Dist: pytest
 Requires-Dist: pytest-asyncio
 Requires-Dist: pytest-cov
 Requires-Dist: pytest-xdist
-Requires-Dist: httpx
 Requires-Dist: uuid-utils
 Provides-Extra: testing
-Requires-Dist: diracx-testing; extra == "testing"

diracx_testing-0.0.1a45.dist-info/RECORD

@@ -0,0 +1,15 @@
+diracx/testing/__init__.py,sha256=ocW2U2SaWC9zvTjWMVhOQtFQ4rqSJbsCJXCMUpBj0rs,904
+diracx/testing/__main__.py,sha256=cd6HxeVKqVrxk32uAB_4O0PzzAo_rzwEK2GN7kND8XY,2419
+diracx/testing/client_generation.py,sha256=B1_b1ku2GEJkDqfDrro3ZpwMbzE5Pxo7fkZ3ew0VYe4,7949
+diracx/testing/client_generation_pytest.py,sha256=c4lvwi6U76yu_iNT6N3zgrdVsBhMPNZi50CXVXYNsi4,1173
+diracx/testing/dummy_osdb.py,sha256=ptLrrreOHJBKMV7S1pR_k83jl-aLKvw7bFZufB6570Y,916
+diracx/testing/entrypoints.py,sha256=ql7byyUOnUBdDoiN5xznlUTQSbD1YCNy4UF5t9MBhgc,2330
+diracx/testing/mock_osdb.py,sha256=2pl9yKV1-e5kzf6meBZnhoc1i0ySAJ8IdnP3r1bOwcI,6033
+diracx/testing/osdb.py,sha256=m6mUBLnGOoQLTCIBie9P2GhmLMybrgzIrlIYfhF1_Ss,3230
+diracx/testing/routers.py,sha256=UW-TnikMQgcNxF5sUZD5DWoucGiCpP6s8mYmuahDiSc,979
+diracx/testing/time.py,sha256=ec2b4yn-52ey8ea1oINdknxtQf-CpPRBIiI15Wa1W2Q,4320
+diracx/testing/utils.py,sha256=c8NA1RMPemAUfrec8YfphcsKsauWlIJ1vyOL3-uWjuM,23804
+diracx/testing/scripts/collect_demo_coverage.sh,sha256=EyIuP6rA-g542BHTPL2cD4qrBSm-FQ5y1e0c1qhVcEs,4555
+diracx_testing-0.0.1a45.dist-info/METADATA,sha256=FHxCST0jbSX2EM6oNwELxd3Fh1YnP3u3LINJC9jM6f4,593
+diracx_testing-0.0.1a45.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+diracx_testing-0.0.1a45.dist-info/RECORD,,

{diracx_testing-0.0.1a43.dist-info → diracx_testing-0.0.1a45.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

diracx_testing-0.0.1a43.dist-info/RECORD

@@ -1,12 +0,0 @@
-diracx/testing/__init__.py,sha256=nGbnGP8m53N9rqHR-hyqDa5vetcsmnQp806HadV6_dE,984
-diracx/testing/client_generation.py,sha256=vegOUVQPcB7NTUFDr0HbasH5eByKQvLh_xYqKBYajzk,5539
-diracx/testing/dummy_osdb.py,sha256=ptLrrreOHJBKMV7S1pR_k83jl-aLKvw7bFZufB6570Y,916
-diracx/testing/entrypoints.py,sha256=ql7byyUOnUBdDoiN5xznlUTQSbD1YCNy4UF5t9MBhgc,2330
-diracx/testing/mock_osdb.py,sha256=2pl9yKV1-e5kzf6meBZnhoc1i0ySAJ8IdnP3r1bOwcI,6033
-diracx/testing/osdb.py,sha256=m6mUBLnGOoQLTCIBie9P2GhmLMybrgzIrlIYfhF1_Ss,3230
-diracx/testing/routers.py,sha256=UW-TnikMQgcNxF5sUZD5DWoucGiCpP6s8mYmuahDiSc,979
-diracx/testing/utils.py,sha256=MnFUgRWfpU9GFOvP5d-LQS0uo1grHy_-iNOGLS7XlNk,24483
-diracx_testing-0.0.1a43.dist-info/METADATA,sha256=4UiegQpc2BUW4l9GLXFpshvsbTWVOpTNbs4njc6cJDA,660
-diracx_testing-0.0.1a43.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-diracx_testing-0.0.1a43.dist-info/top_level.txt,sha256=vJx10tdRlBX3rF2Psgk5jlwVGZNcL3m_7iQWwgPXt-U,7
-diracx_testing-0.0.1a43.dist-info/RECORD,,

diracx_testing-0.0.1a43.dist-info/top_level.txt

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