pdmv-http-client 2.1.0__tar.gz → 2.2.0__tar.gz

{pdmv_http_client-2.1.0 → pdmv_http_client-2.2.0}/.gitlab-ci.yml

@@ -43,14 +43,14 @@ lint:
 smoke-test:
   extends: .test-setup
   script:
-    - uv run pytest -k 'TestSessionFactory or test_rest' -vv
+    - uv run pytest -m 'not (slow or admin)' -vv
   needs:
    - lint
 
 integration-test:
   extends: .test-setup
   script:
-    - uv run pytest -vv
+    - uv run pytest -m 'not admin' -vv
   needs:
     - smoke-test
   rules:

{pdmv_http_client-2.1.0/src/pdmv_http_client.egg-info → pdmv_http_client-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pdmv-http-client
-Version: 2.1.0
+Version: 2.2.0
 Summary: A HTTP client wrapper to handle authenticated requests to CERN internal applications
 Maintainer-email: PdmV Service <pdmv.service@cern.ch>, PPD Technical Support <cms-PPD-technical-support@cern.ch>
 License-Expression: MIT

{pdmv_http_client-2.1.0 → pdmv_http_client-2.2.0}/pyproject.toml

@@ -51,6 +51,11 @@ log_cli_level = "INFO"
 pythonpath = [
     "tests"
 ]
+addopts = "--strict-markers"
+markers = [
+    "slow: tests which require too much time to run and could have collateral actions",
+    "admin: tests which require administrator permissions in the application to success"
+]
 
 [[tool.uv.index]]
 name = "testpypi"

{pdmv_http_client-2.1.0 → pdmv_http_client-2.2.0/src/pdmv_http_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pdmv-http-client
-Version: 2.1.0
+Version: 2.2.0
 Summary: A HTTP client wrapper to handle authenticated requests to CERN internal applications
 Maintainer-email: PdmV Service <pdmv.service@cern.ch>, PPD Technical Support <cms-PPD-technical-support@cern.ch>
 License-Expression: MIT

{pdmv_http_client-2.1.0 → pdmv_http_client-2.2.0}/src/pdmv_http_client.egg-info/SOURCES.txt

@@ -24,6 +24,10 @@ src/rest/applications/mcm/__init__.py
 src/rest/applications/mcm/core.py
 src/rest/applications/mcm/invalidate_request.py
 src/rest/applications/mcm/resubmission.py
+src/rest/applications/relmon/__init__.py
+src/rest/applications/relmon/core.py
+src/rest/applications/relval/__init__.py
+src/rest/applications/relval/core.py
 src/rest/applications/rereco/core.py
 src/rest/applications/stats/core.py
 src/rest/client/__init__.py
@@ -41,6 +45,8 @@ tests/__init__.py
 tests/applications/mcm/test_invalidate_request.py
 tests/applications/mcm/test_rest.py
 tests/applications/mcm/test_resubmission.py
+tests/applications/relmon/test_relmon.py
+tests/applications/relval/test_relval.py
 tests/applications/stats/test_stats.py
 tests/client/README.md
 tests/client/test_session.py
@@ -50,4 +56,6 @@ tests/fixtures/__init__.py
 tests/fixtures/files.py
 tests/fixtures/mcm.py
 tests/fixtures/oauth.py
+tests/fixtures/relmon.py
+tests/fixtures/relval.py
 tests/utils/test_shell.py

{pdmv_http_client-2.1.0 → pdmv_http_client-2.2.0}/src/rest/__init__.py

@@ -6,5 +6,7 @@ Just to keep backward compatibility.
 
 from rest.applications.base import BaseClient
 from rest.applications.mcm.core import McM
+from rest.applications.relmon.core import RelMonService
+from rest.applications.relval.core import RelVal
 from rest.applications.rereco.core import ReReco
 from rest.applications.stats.core import Stats2

{pdmv_http_client-2.1.0 → pdmv_http_client-2.2.0}/src/rest/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.1.0'
-__version_tuple__ = version_tuple = (2, 1, 0)
+__version__ = version = '2.2.0'
+__version_tuple__ = version_tuple = (2, 2, 0)
 
-__commit_id__ = commit_id = 'ge8e5501a4'
+__commit_id__ = commit_id = 'gd7c2f07c4'

pdmv_http_client-2.2.0/src/rest/applications/relmon/core.py

@@ -0,0 +1,95 @@
+"""
+REST client for the RelMonService application.
+"""
+
+from typing import Any, Dict, Optional, Union
+from urllib.parse import urlencode
+
+from rest.applications.base import BaseClient
+
+
+class RelMonService(BaseClient):
+    """
+    Initializes an HTTP client for querying RelMonService.
+    """
+
+    def __init__(
+        self,
+        id: str = BaseClient.SSO,
+        debug: bool = False,
+        cookie: Union[str, None] = None,
+        dev: bool = True,
+        client_id: str = "",
+        client_secret: str = "",
+    ):
+        super().__init__(
+            app="relmonservice",
+            id=id,
+            debug=debug,
+            cookie=cookie,
+            dev=dev,
+            client_id=client_id,
+            client_secret=client_secret,
+        )
+
+    # -----------------
+    # RelMonService APIs
+    # -----------------
+
+    def get_relmons(
+        self,
+        page: int = 0,
+        limit: Optional[int] = None,
+        query: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Fetch RelMons from database.
+        """
+        params = {"page": page}
+        if limit is not None:
+            params["limit"] = limit
+        if query:
+            params["q"] = query
+
+        qs = f"?{urlencode(params)}" if params else ""
+        return self._get(url=f"api/get_relmons{qs}")
+
+    def create(self, relmon: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Create a new RelMon.
+        """
+        return self._post(url="api/create", data=relmon)
+
+    def reset(self, relmon_id: str) -> Dict[str, Any]:
+        """
+        Reset a RelMon by ID.
+        """
+        return self._post(url="api/reset", data={"id": relmon_id})
+
+    def delete(self, relmon_id: str) -> Dict[str, Any]:
+        """
+        Delete a RelMon by ID.
+        """
+        request_body = {"id": relmon_id}
+        request_endpoint = f"{self.server}api/delete"
+        response = self.session.delete(url=request_endpoint, json=request_body)
+        response.raise_for_status()
+        return response.json()
+
+    def edit(self, relmon: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Edit an existing RelMon.
+        """
+        return self._post(url="api/edit", data=relmon)
+
+    def tick(self) -> Dict[str, Any]:
+        """
+        Trigger a controller tick.
+        """
+        return self._get(url="api/tick")
+
+    def user(self) -> Dict[str, Any]:
+        """
+        Get user info.
+        """
+        return self._get(url="api/user")

pdmv_http_client-2.2.0/src/rest/applications/relval/core.py

@@ -0,0 +1,129 @@
+"""
+REST client for the RelVal application.
+"""
+
+from typing import Union
+
+from rest.applications.base import BaseClient
+
+
+class RelVal(BaseClient):
+    """
+    Initializes an HTTP client for querying RelVal.
+    """
+
+    def __init__(
+        self,
+        id: str = BaseClient.SSO,
+        debug: bool = False,
+        cookie: Union[str, None] = None,
+        dev: bool = True,
+        client_id: str = "",
+        client_secret: str = "",
+    ):
+        # Set the HTTP session
+        super().__init__(
+            app="relval",
+            id=id,
+            debug=debug,
+            cookie=cookie,
+            dev=dev,
+            client_id=client_id,
+            client_secret=client_secret,
+        )
+
+    # RelVal methods
+
+    def create(self, data):
+        """
+        Create a new RelVal.
+        Requires manager role.
+        """
+        return self._put(url="api/relvals/create", data=data)
+
+    def delete(self, data):
+        """
+        Delete one or multiple RelVals.
+        Requires manager role.
+        """
+        response = self.session.delete(
+            url=f"{self.server}api/relvals/delete", json=data
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def update(self, data):
+        """
+        Update one or multiple RelVals.
+        Requires manager role.
+        """
+        return self._post(url="api/relvals/update", data=data)
+
+    def get_relval(self, prepid: str):
+        """
+        Retrieve a single RelVal by its prepid.
+        """
+        return self._get(url=f"api/relvals/get/{prepid}")
+
+    def get_editable(self, prepid: str = None):
+        """
+        Get information on which RelVal fields are editable.
+        If prepid is given, return for a specific RelVal.
+        """
+        url = "api/relvals/get_editable"
+        if prepid:
+            url += f"/{prepid}"
+        return self._get(url=url)
+
+    def get_cmsdriver(self, prepid: str):
+        """
+        Get a bash script with cmsDriver.py commands of RelVal.
+        """
+        response = self.session.get(
+            url=f"{self.server}api/relvals/get_cmsdriver/{prepid}"
+        )
+        response.raise_for_status()
+        return response.text
+
+    def get_config_upload(self, prepid: str):
+        """
+        Get a bash script to upload configs to ReqMgr config cache.
+        """
+        response = self.session.get(
+            url=f"{self.server}api/relvals/get_config_upload/{prepid}"
+        )
+        response.raise_for_status()
+        return response.text
+
+    def get_dict(self, prepid: str):
+        """
+        Get a dictionary with job information for ReqMgr2.
+        """
+        return self._get(url=f"api/relvals/get_dict/{prepid}")
+
+    def get_default_step(self):
+        """
+        Get a default (empty) step that could be used as a template.
+        """
+        return self._get(url="api/relvals/get_default_step")
+
+    def next_status(self, data):
+        """
+        Move one or multiple RelVals to next status.
+        Requires manager role.
+        """
+        return self._post(url="api/relvals/next_status", data=data)
+
+    def previous_status(self, data):
+        """
+        Move one or multiple RelVals to previous status.
+        Requires manager role.
+        """
+        return self._post(url="api/relvals/previous_status", data=data)
+
+    def update_workflows(self, data):
+        """
+        Trigger one or multiple RelVal updates from Stats2 (ReqMgr2 + DBS).
+        Requires manager role.
+        """
+        return self._post(url="api/relvals/update_workflows", data=data)

{pdmv_http_client-2.1.0 → pdmv_http_client-2.2.0}/tests/applications/mcm/test_invalidate_request.py

@@ -15,6 +15,7 @@ from fixtures.mcm import (
 from fixtures.oauth import stdin_enabled
 
 
+@pytest.mark.slow
 @pytest.mark.usefixtures("stdin_enabled", "production_manager_or_higher")
 class TestInvalidateDeleteRequest:
     """

{pdmv_http_client-2.1.0 → pdmv_http_client-2.2.0}/tests/applications/mcm/test_resubmission.py

@@ -19,6 +19,7 @@ from rest.applications.mcm.core import McM
 from rest.applications.mcm.resubmission import ChainRequestResubmitter
 
 
+@pytest.mark.slow
 @pytest.mark.usefixtures("stdin_enabled", "production_manager_or_higher")
 class TestChainRequestResubmitter:
     """

pdmv_http_client-2.2.0/tests/applications/relmon/test_relmon.py

@@ -0,0 +1,95 @@
+"""Include some tests to check the RelMon module to interact with the API."""
+
+import time
+from copy import deepcopy
+from typing import Any, Dict, Optional, Union
+
+import pytest
+from fixtures.oauth import session_cookie_issues
+from fixtures.relmon import relmon, relmon_development
+
+from rest.applications.relmon.core import RelMonService
+
+
+def test_get_relmons(relmon_development: RelMonService):
+    default_response = relmon_development.get_relmons()
+
+    assert (
+        isinstance(default_response, dict) and default_response
+    ), "Unable to retrieve RelMons from web service!"
+    assert default_response.get("total_rows", -1) > 0, "Unexpected number of rows"
+    assert (
+        len(default_response.get("data", [])) > 0
+    ), "No data available from the application"
+
+    with_limit = relmon_development.get_relmons(limit=1)
+    assert (
+        len(with_limit.get("data", [])) == 1
+    ), "Unexpected number of element while using limit"
+
+    with_query_for_name = relmon_development.get_relmons(query="^CMSSW_13_*$")
+    assert (
+        len(with_query_for_name.get("data", [])) > 0
+    ), "Unexpected number of element while using query"
+    for record in with_query_for_name.get("data", []):
+        assert record.get("name", "").startswith(
+            "CMSSW_13"
+        ), "Unexpected element in subset!"
+
+    with_query_for_none = relmon_development.get_relmons(query="^NotExist_Pattern$")
+    assert (
+        len(with_query_for_none.get("data", [])) == 0
+    ), "There should be no element here!"
+
+
+def test_get_relmons(relmon_development: RelMonService):
+    user_info = relmon_development.user()
+    assert isinstance(user_info, dict) and user_info, "No user information available"
+    assert user_info.get("login"), "Login information is not available"
+
+
+@pytest.mark.admin
+def test_tick(relmon_development: RelMonService):
+    perform_tick = relmon_development.tick()
+    assert isinstance(perform_tick, dict) and perform_tick
+    assert perform_tick.get("message") == "OK"
+
+
+@pytest.mark.slow
+def test_crud(relmon_development: RelMonService, relmon: Dict[str, Any]):
+    # Create a new RelMon
+    create_instance = deepcopy(relmon)
+    create_instance["name"] = f"TestFromHTTPClient_{int(time.time())}"
+    create_response = relmon_development.create(relmon=create_instance)
+    assert create_response.get("message") == "OK"
+
+    instance = relmon_development.get_relmons(query=create_instance["name"]).get(
+        "data", []
+    )
+    assert instance
+    assert instance[-1].get("name") == create_instance["name"]
+    instance = instance[-1]
+
+    # Reset the RelMon
+    reset_response = relmon_development.reset(relmon_id=instance["_id"])
+    assert reset_response.get("message") == "OK"
+
+    # Edit the RelMon
+    edit_new_name = f"TestFromHTTPClient_{int(time.time())}"
+    instance["name"] = edit_new_name
+    edit_response = relmon_development.edit(relmon=instance)
+    assert edit_response.get("message") == "OK"
+
+    instance = relmon_development.get_relmons(query=edit_new_name).get("data", [])
+    assert instance
+    assert instance[-1].get("name") == edit_new_name
+    instance = instance[-1]
+
+    # Wait some time before deleting
+    # Otherwise, the backend stores the operation
+    # but executes it in a lazy mode.
+    time.sleep(2)
+
+    # Delete the RelMon
+    delete_response = relmon_development.delete(relmon_id=instance["_id"])
+    assert delete_response.get("message") == "OK"

pdmv_http_client-2.2.0/tests/applications/relval/test_relval.py

@@ -0,0 +1,116 @@
+"""Check the RelVal module and its correctness."""
+
+from copy import deepcopy
+
+import pytest
+from fixtures.oauth import session_cookie_issues
+from fixtures.relval import relval, relval_development, sample_relval_id
+
+from rest.applications.relval.core import RelVal
+
+
+def test_get_relval(relval_development: RelVal, sample_relval_id: str):
+    relval = relval_development.get_relval(prepid=sample_relval_id)
+    assert (
+        isinstance(relval, dict) and relval
+    ), "Unable to retrieve RelMons from web service!"
+
+    assert relval.get("response", {}), "Unable to find the RelVal content!"
+    assert relval.get("response", {}).get("prepid") == sample_relval_id
+
+
+def test_get_editable(relval_development: RelVal, sample_relval_id: str):
+    editable_for_relval = relval_development.get_editable(prepid=sample_relval_id)
+    assert (
+        isinstance(editable_for_relval, dict) and editable_for_relval
+    ), "Unable to retrieve RelMons from web service!"
+    assert editable_for_relval.get("response", {})
+    assert editable_for_relval.get("response", {}).get("editing_info")
+
+
+def test_get_cmsdriver(relval_development: RelVal, sample_relval_id: str):
+    driver_response = relval_development.get_cmsdriver(prepid=sample_relval_id)
+    assert isinstance(driver_response, str) and driver_response
+    assert "/cvmfs/cms.cern.ch/cmsset_default.sh" in driver_response
+
+
+def test_get_config_upload(relval_development: RelVal, sample_relval_id: str):
+    config_response = relval_development.get_config_upload(prepid=sample_relval_id)
+    assert isinstance(config_response, str) and config_response
+    assert "$PYTHON_INT config_uploader.py --file" in config_response
+
+
+def test_get_dict(relval_development: RelVal, sample_relval_id: str):
+    reqmgr2_for_relval = relval_development.get_dict(prepid=sample_relval_id)
+    assert isinstance(reqmgr2_for_relval, dict) and reqmgr2_for_relval
+    assert "CMSSWVersion" in reqmgr2_for_relval
+    assert "AcquisitionEra" in reqmgr2_for_relval
+
+
+def test_get_default_step(relval_development: RelVal):
+    default_step_response = relval_development.get_default_step()
+    assert isinstance(default_step_response, dict) and default_step_response
+
+    driver_content = default_step_response.get("response", {}).get("driver")
+    assert isinstance(driver_content, dict) and driver_content
+
+
+@pytest.mark.slow
+def test_crud(relval_development: RelVal, relval: dict):
+    # Create a new RelVal in the application.
+    create_relval_response = relval_development.create(data=relval)
+    assert isinstance(create_relval_response, dict) and create_relval_response
+    assert isinstance(
+        create_relval_response.get("success"), bool
+    ) and create_relval_response.get("success")
+
+    relval_instance = create_relval_response.get("response", {})
+    assert isinstance(relval_instance, dict) and relval_instance
+
+    # Update the created RelVal
+    new_notes = "RelVal instance for testing the PdmV HTTP client"
+    relval_instance["notes"] = new_notes
+    update_relval_response = relval_development.update(data=relval_instance)
+    assert isinstance(update_relval_response, dict) and update_relval_response
+    assert isinstance(
+        update_relval_response.get("success"), bool
+    ) and update_relval_response.get("success")
+
+    relval_instance = update_relval_response.get("response", {})
+    assert isinstance(relval_instance, dict) and relval_instance
+    assert relval_instance["notes"] == new_notes
+
+    # Send to the next status
+    initial_status = relval_instance["status"]
+    next_status_response = relval_development.next_status(data=relval_instance)
+    assert isinstance(next_status_response, dict) and next_status_response
+    assert isinstance(
+        next_status_response.get("success"), bool
+    ) and next_status_response.get("success")
+
+    relval_instance = next_status_response.get("response", {})
+    assert isinstance(relval_instance, dict) and relval_instance
+    assert relval_instance["status"] != initial_status
+
+    # Send to the previous status
+    previous_status_response = relval_development.previous_status(data=relval_instance)
+    assert isinstance(previous_status_response, dict) and previous_status_response
+    assert isinstance(
+        previous_status_response.get("success"), bool
+    ) and previous_status_response.get("success")
+
+    relval_instance = previous_status_response.get("response", {})
+    assert isinstance(relval_instance, dict) and relval_instance
+    assert relval_instance["status"] == initial_status
+
+    # Delete the instance
+    delete_response = relval_development.delete(data=relval_instance)
+    assert isinstance(delete_response, dict) and delete_response
+    assert isinstance(delete_response.get("success"), bool) and delete_response.get(
+        "success"
+    )
+
+    still_exists_response = relval_development.get_relval(
+        prepid=relval_instance["prepid"]
+    )
+    assert still_exists_response["success"] == False

pdmv_http_client-2.2.0/tests/fixtures/relmon.py

@@ -0,0 +1,73 @@
+"""Fixture for the RelMon tests."""
+
+from typing import Any, Dict, Optional, Union
+
+import pytest
+
+from rest.applications.relmon.core import RelMonService
+
+
+@pytest.fixture
+def relmon_development() -> RelMonService:
+    return RelMonService(id=RelMonService.SSO, dev=True)
+
+
+@pytest.fixture
+def relmon() -> Dict[str, Any]:
+    return {
+        "name": "",
+        "categories": [
+            {
+                "name": "Data",
+                "hlt": "both",
+                "automatic_pairing": True,
+                "reference": [],
+                "target": [],
+                "rerun": False,
+            },
+            {
+                "name": "FullSim",
+                "hlt": "both",
+                "automatic_pairing": True,
+                "reference": [],
+                "target": [],
+                "rerun": False,
+            },
+            {
+                "name": "FastSim",
+                "hlt": "both",
+                "automatic_pairing": True,
+                "reference": [],
+                "target": [],
+                "rerun": False,
+            },
+            {
+                "name": "Generator",
+                "hlt": "no",
+                "automatic_pairing": True,
+                "reference": [],
+                "target": [],
+                "rerun": False,
+            },
+            {
+                "name": "FullSim_PU",
+                "hlt": "both",
+                "automatic_pairing": True,
+                "reference": [
+                    "pdmvserv_RVCMSSW_12_3_0_pre6ZMM_14__2026D88PU200_rsb_220417_125145_9614"
+                ],
+                "target": [
+                    "pdmvserv_RVCMSSW_12_3_0_pre6ZMM_14__2026D88PU200_rsb_220417_125145_9614"
+                ],
+                "rerun": False,
+            },
+            {
+                "name": "FastSim_PU",
+                "hlt": "both",
+                "automatic_pairing": True,
+                "reference": [],
+                "target": [],
+                "rerun": False,
+            },
+        ],
+    }

pdmv_http_client-2.2.0/tests/fixtures/relval.py

@@ -0,0 +1,101 @@
+"""Fixture for the RelVal tests."""
+
+import time
+
+import pytest
+
+from rest.applications.relval.core import RelVal
+
+
+@pytest.fixture
+def relval_development() -> RelVal:
+    return RelVal(id=RelVal.SSO, dev=True)
+
+
+@pytest.fixture
+def sample_relval_id() -> str:
+    return "CMSSW_13_0_13__RV270_MiniToMini_2023DataReference-EGamma0_Run2023D-22Sep2023_v2-00001"
+
+
+@pytest.fixture
+def relval() -> dict:
+    return {
+        "_id": f"CMSSW_15_1_0_pre5__Phase2_{int(time.time())}-00001",
+        "batch_name": "Phase2_Run4D110_PU",
+        "campaign_timestamp": 0,
+        "cmssw_release": "CMSSW_15_1_0_pre5",
+        "cpu_cores": 4,
+        "execute_steps": False,
+        "fragment": "",
+        "history": [],
+        "job_dict_overwrite": {},
+        "label": "STD_Run4D110_PU",
+        "matrix": "upgrade",
+        "memory": 16000,
+        "notes": "",
+        "output_datasets": [],
+        "prepid": "",
+        "sample_tag": "Phase2_D110",
+        "scram_arch": "",
+        "size_per_event": 1,
+        "status": "new",
+        "steps": [
+            {
+                "cmssw_release": "",
+                "config_id": "",
+                "driver": {
+                    "beamspot": "DBrealisticHLLHC",
+                    "conditions": "auto:phase2_realistic_T33_13TeV",
+                    "customise": "SLHCUpgradeSimulations/Configuration/aging.customise_aging_1000",
+                    "customise_commands": "",
+                    "data": False,
+                    "datatier": ["GEN-SIM"],
+                    "era": "Phase2C20I13M9",
+                    "eventcontent": ["FEVTDEBUG"],
+                    "extra": "",
+                    "fast": False,
+                    "filetype": "",
+                    "fragment_name": "SingleMuFlatPt2To100_cfi",
+                    "geometry": "ExtendedRun4D115",
+                    "hltProcess": "",
+                    "mc": False,
+                    "nStreams": "1",
+                    "number": "10",
+                    "pileup": "",
+                    "pileup_input": "",
+                    "process": "",
+                    "relval": "9000,100",
+                    "runUnscheduled": False,
+                    "scenario": "",
+                    "step": ["GEN", "SIM"],
+                },
+                "events_per_lumi": "",
+                "gpu": {
+                    "cuda_capabilities": [],
+                    "cuda_driver_version": "",
+                    "cuda_runtime": "",
+                    "cuda_runtime_version": "",
+                    "gpu_memory": "",
+                    "gpu_name": "",
+                    "requires": "forbidden",
+                },
+                "input": {
+                    "dataset": "",
+                    "events": 0,
+                    "label": "",
+                    "lumisection": {},
+                    "run": [],
+                },
+                "keep_output": True,
+                "lumis_per_job": "10",
+                "name": "SingleMuFlatPt2To100_Run4D115_GenSimHLBeamSpot",
+                "resolved_globaltag": "",
+                "scram_arch": "",
+                "step_type": "driver",
+            }
+        ],
+        "time_per_event": 1,
+        "workflow_id": 32104,
+        "workflow_name": "SingleMuFlatPt2To100",
+        "workflows": [],
+    }