argus-alm 0.12.2__py3-none-any.whl → 0.12.3__py3-none-any.whl

argus/backend/cli.py

@@ -22,7 +22,7 @@ def sync_models_command():
         LOGGER.info("Synchronizing plugin type %s...", user_type.__name__)
         sync_type(ks_name=cluster.config["SCYLLA_KEYSPACE_NAME"], type_model=user_type)
     LOGGER.info("Synchronizing plugin models...")
-    for model in all_plugin_models():
+    for model in all_plugin_models(True):
         LOGGER.info("Synchronizing plugin model %s...", model.__name__)
         sync_table(model=model, keyspaces=[cluster.config["SCYLLA_KEYSPACE_NAME"]])
 

argus/backend/controller/testrun_api.py

@@ -6,6 +6,7 @@ from flask import (
 )
 
 from argus.backend.error_handlers import handle_api_exception
+from argus.backend.models.web import ArgusTest
 from argus.backend.service.jenkins_service import JenkinsService
 from argus.backend.service.testrun import TestRunService
 from argus.backend.service.user import api_login_required
@@ -336,4 +337,118 @@ def get_queue_info():
         "response": {
             "queueItem": result
         }
-    }
+    }
+
+
+@bp.route("/jenkins/clone/targets")
+@api_login_required
+def get_clone_targets():
+    test_id = request.args.get("testId")
+    if not test_id:
+        raise Exception("No testId provided")
+    service = JenkinsService()
+    result = service.get_releases_for_clone(test_id)
+
+    return {
+        "status": "ok",
+        "response": {
+            "targets": result
+        }
+    }
+
+
+@bp.route("/jenkins/clone/groups")
+@api_login_required
+def get_groups_for_target():
+    target_id = request.args.get("targetId")
+    if not target_id:
+        raise Exception("No targetId provided")
+    service = JenkinsService()
+    result = service.get_groups_for_release(target_id)
+
+    return {
+        "status": "ok",
+        "response": {
+            "groups": result
+        }
+    }
+
+
+@bp.route("/jenkins/clone/create", methods=["POST"])
+@api_login_required
+def clone_jenkins_job():
+
+    payload = get_payload(request)
+    service = JenkinsService()
+
+    result = service.clone_job(
+        current_test_id=payload["currentTestId"],
+        new_name=payload["newName"],
+        target=payload["target"],
+        group=payload["group"],
+        advanced_settings=payload["advancedSettings"],
+    )
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/jenkins/clone/build", methods=["POST"])
+@api_login_required
+def clone_build_jenkins_job():
+
+    payload = get_payload(request)
+    service = JenkinsService()
+
+    result = service.clone_build_job(build_id=payload["buildId"], params=payload["parameters"])
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/jenkins/clone/settings")
+@api_login_required
+def get_clone_job_advanced_settings():
+    build_id = request.args.get("buildId")
+    if not build_id:
+        raise Exception("No testId provided")
+    service = JenkinsService()
+    result = service.get_advanced_settings(build_id)
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/jenkins/clone/settings/change", methods=["POST"])
+@api_login_required
+def set_job_settings():
+    payload = get_payload(request)
+    service = JenkinsService()
+    test = ArgusTest.get(build_system_id=payload["buildId"])
+    result = service.adjust_job_settings(build_id=test.build_system_id, plugin_name=test.plugin_name, settings=payload["settings"])
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/jenkins/clone/settings/validate", methods=["POST"])
+@api_login_required
+def clone_validate_new_settings():
+
+    payload = get_payload(request)
+    service = JenkinsService()
+
+    result = service.verify_job_settings(build_id=payload["buildId"], new_settings=payload["newSettings"])
+
+    return {
+        "status": "ok",
+        "response": result
+    }

argus/backend/plugins/core.py

@@ -132,12 +132,20 @@ class PluginModelBase(Model):
         return bound_query
 
     @classmethod
-    def get_stats_for_release(cls, release: ArgusRelease):
+    def get_stats_for_release(cls, release: ArgusRelease, build_ids=list[str]):
         cluster = ScyllaCluster.get()
         query = cluster.prepare(cls._stats_query())
-        rows = cluster.session.execute(query=query, parameters=(release.id,))
-
-        return list(rows)
+        futures = []
+        step = 0
+        step_size = 90
+        total_tests = len(build_ids)
+        while total_tests > 0:
+            id_slice = build_ids[step:step+step_size]
+            futures.append(cluster.session.execute_async(query=query, parameters=(id_slice,)))
+            step += step_size
+            total_tests = max(0, total_tests - step_size)
+
+        return futures
 
     @classmethod
     def get_run_meta_by_build_id(cls, build_id: str, limit: int = 10):

argus/backend/plugins/driver_matrix_tests/model.py

@@ -44,7 +44,7 @@ class DriverTestRun(PluginModelBase):
     @classmethod
     def _stats_query(cls) -> str:
         return ("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
-                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE release_id = ?")
+                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE build_id IN ? PER PARTITION LIMIT 15")
 
     @classmethod
     def get_distinct_product_versions(cls, release: ArgusRelease) -> list[str]:

argus/backend/plugins/generic/model.py

@@ -24,7 +24,7 @@ class GenericRun(PluginModelBase):
     @classmethod
     def _stats_query(cls) -> str:
         return ("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
-                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE release_id = ?")
+                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE build_id IN ? PER PARTITION LIMIT 15")
 
     @classmethod
     def get_distinct_product_versions(cls, release: ArgusRelease, cluster: ScyllaCluster = None) -> list[str]:

argus/backend/plugins/loader.py

@@ -32,8 +32,8 @@ def plugin_loader() -> dict[str, PluginInfoBase]:
 AVAILABLE_PLUGINS = plugin_loader()
 
 
-def all_plugin_models() -> list[PluginModelBase]:
-    return [model for plugin in AVAILABLE_PLUGINS.values() for model in plugin.all_models]
+def all_plugin_models(include_all=False) -> list[PluginModelBase]:
+    return [model for plugin in AVAILABLE_PLUGINS.values() for model in plugin.all_models if issubclass(model, PluginModelBase) or include_all]
 
 
 def all_plugin_types():

argus/backend/plugins/sct/controller.py

@@ -81,6 +81,17 @@ def sct_resource_update_shards(run_id: str, resource_name: str):
     }
 
 
+@bp.route("/<string:run_id>/resource/<string:resource_name>/update", methods=["POST"])
+@api_login_required
+def sct_resource_update(run_id: str, resource_name: str):
+    payload = get_payload(request)
+    result = SCTService.update_resource(run_id=run_id, resource_name=resource_name, update_data=payload["update_data"])
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
 @bp.route("/<string:run_id>/nemesis/submit", methods=["POST"])
 @api_login_required
 def sct_nemesis_submit(run_id: str):
@@ -152,3 +163,23 @@ def sct_get_kernel_report(release_name: str):
         "status": "ok",
         "response": result
     }
+
+
+@bp.route("/<string:run_id>/junit/submit", methods=["POST"])
+@api_login_required
+def sct_submit_junit_report(run_id: str):
+    payload = get_payload(request)
+    result = SCTService.junit_submit(run_id, payload["file_name"], payload["content"])
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+@bp.route("/<string:run_id>/junit/get_all", methods=["GET"])
+@api_login_required
+def sct_get_junit_reports(run_id: str):
+    result = SCTService.junit_get_all(run_id)
+    return {
+        "status": "ok",
+        "response": result
+    }

argus/backend/plugins/sct/plugin.py

@@ -1,6 +1,6 @@
 from flask import Blueprint
 
-from argus.backend.plugins.sct.testrun import SCTTestRun
+from argus.backend.plugins.sct.testrun import SCTJunitReports, SCTTestRun
 from argus.backend.plugins.sct.controller import bp as sct_bp
 from argus.backend.plugins.core import PluginInfoBase, PluginModelBase
 from argus.backend.plugins.sct.udt import (
@@ -23,6 +23,7 @@ class PluginInfo(PluginInfoBase):
     controller: Blueprint = sct_bp
     all_models = [
         SCTTestRun,
+        SCTJunitReports,
     ]
     all_types = [
         NemesisRunInfo,

argus/backend/plugins/sct/service.py

@@ -1,12 +1,15 @@
+import base64
 from dataclasses import dataclass
 from functools import reduce
 import logging
 import math
+import re
 from time import time
+from xml.etree import ElementTree
 from flask import g
 from argus.backend.models.web import ArgusEventTypes
-from argus.backend.plugins.sct.testrun import SCTTestRun, SubtestType
-from argus.backend.plugins.sct.types import GeminiResultsRequest, PerformanceResultsRequest
+from argus.backend.plugins.sct.testrun import SCTJunitReports, SCTTestRun, SubtestType
+from argus.backend.plugins.sct.types import GeminiResultsRequest, PerformanceResultsRequest, ResourceUpdateRequest
 from argus.backend.plugins.sct.udt import (
     CloudInstanceDetails,
     CloudResource,
@@ -60,7 +63,8 @@ class SCTService:
             run: SCTTestRun = SCTTestRun.get(id=run_id)
             for package_dict in packages:
                 package = PackageVersion(**package_dict)
-                run.packages.append(package)
+                if package not in run.packages:
+                    run.packages.append(package)
             run.save()
         except SCTTestRun.DoesNotExist as exception:
             LOGGER.error("Run %s not found for SCTTestRun", run_id)
@@ -277,6 +281,33 @@ class SCTService:
 
         return "updated"
 
+    @staticmethod
+    def update_resource(run_id: str, resource_name: str, update_data: ResourceUpdateRequest) -> str:
+        try:
+            fields_updated = {}
+            run: SCTTestRun = SCTTestRun.get(id=run_id)
+            resource = next(res for res in run.get_resources() if res.name == resource_name)
+            instance_info = update_data.pop("instance_info", None)
+            resource.state = ResourceState(update_data.get("state", resource.state)).value
+            if instance_info:
+                resource_instance_info = resource.get_instance_info()
+                for k, v in instance_info.items():
+                    if k in resource_instance_info.keys():
+                        resource_instance_info[k] = v
+                        fields_updated[k] = v
+            run.save()
+        except StopIteration as exception:
+            LOGGER.error("Resource %s not found in run %s", resource_name, run_id)
+            raise SCTServiceException("Resource not found", resource_name) from exception
+        except SCTTestRun.DoesNotExist as exception:
+            LOGGER.error("Run %s not found for SCTTestRun", run_id)
+            raise SCTServiceException("Run not found", run_id) from exception
+
+        return {
+            "state": "updated",
+            "fields": fields_updated
+        }
+
     @staticmethod
     def terminate_resource(run_id: str, resource_name: str, reason: str) -> str:
         try:
@@ -348,6 +379,8 @@ class SCTService:
                 wrapper = EventsBySeverity(severity=event.severity,
                                            event_amount=event.total_events, last_events=event.messages)
                 run.get_events().append(wrapper)
+            coredumps = SCTService.locate_coredumps(run, run.get_events())
+            run.submit_logs(coredumps)
             run.save()
         except SCTTestRun.DoesNotExist as exception:
             LOGGER.error("Run %s not found for SCTTestRun", run_id)
@@ -355,6 +388,28 @@ class SCTService:
 
         return "added"
 
+    @staticmethod
+    def locate_coredumps(run: SCTTestRun, events: list[EventsBySeverity]) -> list[dict]:
+        flat_messages: list[str] = []
+        links = []
+        for es in events:
+            flat_messages.extend(es.last_events)
+        coredump_events = filter(lambda v: "coredumpevent" in v.lower(), flat_messages)
+        for idx, event in enumerate(coredump_events):
+            core_pattern = r"corefile_url=(?P<url>.+)$"
+            node_name_pattern = r"node=(?P<name>.+)$"
+            core_url_match = re.search(core_pattern, event, re.MULTILINE)
+            node_name_match = re.search(node_name_pattern, event, re.MULTILINE)
+            if core_url_match:
+                node_name = node_name_match.group("name") if node_name_match else f"unknown-node-{idx}"
+                url = core_url_match.group("url")
+                log_link = {
+                    "log_name": f"COREDUMP-{node_name}",
+                    "log_link": url
+                }
+                links.append(log_link)
+        return links
+
     @staticmethod
     def get_scylla_version_kernels_report(release_name: str):
         all_release_runs = SCTTestRun.get_version_data_for_release(release_name=release_name)
@@ -391,3 +446,34 @@ class SCTService:
             "versions": kernels_by_version,
             "metadata": kernel_metadata
         }
+    
+    @staticmethod
+    def junit_submit(run_id: str, file_name: str, content: str) -> bool:
+        try:
+            report = SCTJunitReports.get(test_id=run_id, file_name=file_name)
+            if report:
+                raise SCTServiceException(f"Report {file_name} already exists.", file_name)
+        except SCTJunitReports.DoesNotExist:
+            pass
+        report = SCTJunitReports()
+        report.test_id = run_id
+        report.file_name = file_name
+        
+        xml_content = str(base64.decodebytes(bytes(content, encoding="utf-8")), encoding="utf-8")
+        try:
+            _ = ElementTree.fromstring(xml_content)
+        except Exception:
+            raise SCTServiceException(f"Malformed JUnit report submitted")
+
+        report.report = xml_content
+        report.save()
+
+        return True
+
+    @staticmethod
+    def junit_get_all(run_id: str) -> list[SCTJunitReports]:
+        return list(SCTJunitReports.filter(test_id=run_id).all())
+    
+    @staticmethod
+    def junit_get_single(run_id: str, file_name: str) -> SCTJunitReports:
+        return SCTJunitReports.get(test_id=run_id, file_name=file_name)

argus/backend/plugins/sct/testrun.py

@@ -6,7 +6,7 @@ from typing import Optional
 from uuid import UUID
 
 from cassandra.cqlengine import columns
-from cassandra.cqlengine.models import _DoesNotExist
+from cassandra.cqlengine.models import _DoesNotExist, Model
 from argus.backend.db import ScyllaCluster
 from argus.backend.models.web import ArgusRelease
 from argus.backend.plugins.core import PluginModelBase
@@ -113,7 +113,7 @@ class SCTTestRun(PluginModelBase):
     @classmethod
     def _stats_query(cls) -> str:
         return ("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
-                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE release_id = ?")
+                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE build_id IN ? PER PARTITION LIMIT 15")
 
     @classmethod
     def load_test_run(cls, run_id: UUID) -> 'SCTTestRun':
@@ -248,3 +248,9 @@ class SCTTestRun(PluginModelBase):
             self._add_new_event_type(event)
 
         self._collect_event_message(event, event_message)
+
+
+class SCTJunitReports(Model):
+    test_id = columns.UUID(primary_key=True, partition_key=True, required=True)
+    file_name = columns.Text(primary_key=True, required=True)
+    report = columns.Text(required=True)

argus/backend/plugins/sct/types.py

@@ -36,3 +36,21 @@ class PerformanceResultsRequest(TypedDict):
     perf_total_errors: str
 
     histograms: list[dict[str, RawHDRHistogram]] | None
+
+
+class InstanceInfoUpdateRequest(TypedDict):
+    provider: str
+    region: str
+    public_ip: str
+    private_ip: str
+    dc_name: str
+    rack_name: str
+    creation_time: int
+    termination_time: int
+    termination_reason: str
+    shards_amount: int
+
+
+class ResourceUpdateRequest(TypedDict):
+    state: str
+    instance_info: InstanceInfoUpdateRequest

argus/backend/plugins/sct/udt.py

@@ -14,6 +14,12 @@ class PackageVersion(UserType):
     build_id = columns.Text()
 
 
+    def __eq__(self, other):
+        if isinstance(other, PackageVersion):
+            return all(getattr(self, a) == getattr(other, a) for a in ["name", "version", "date", "revision_id", "build_id"])
+        return super().__eq__(other)
+
+
 class CloudInstanceDetails(UserType):
     __type_name__ = "CloudInstanceDetails_v3"
     provider = columns.Text()

argus/backend/plugins/sirenada/model.py

@@ -47,7 +47,7 @@ class SirenadaRun(PluginModelBase):
     @classmethod
     def _stats_query(cls) -> str:
         return ("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
-                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE release_id = ?")
+                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE build_id IN ? PER PARTITION LIMIT 15")
 
     @classmethod
     def get_distinct_product_versions(cls, release: ArgusRelease, cluster: ScyllaCluster = None) -> list[str]:

argus/backend/service/argus_service.py

@@ -487,8 +487,17 @@ class ArgusService:
         groups = ArgusGroup.filter(release_id=release_id).all()
         group_ids = [group.id for group in groups if group.enabled]
 
-        scheduled_groups = ArgusScheduleGroup.filter(release_id=release.id, group_id__in=group_ids).all()
-        schedule_ids = {schedule.schedule_id for schedule in scheduled_groups}
+        total_ids = len(group_ids)
+        schedule_ids = set()
+        step = 0
+        step_size = 60
+        while total_ids > 0:
+            group_slice = group_ids[step:step+step_size]
+            scheduled_groups = ArgusScheduleGroup.filter(release_id=release.id, group_id__in=group_slice).all()
+            batch_ids = {schedule.schedule_id for schedule in scheduled_groups}
+            schedule_ids.union(batch_ids)
+            total_ids = max(0, total_ids - step_size)
+            step += step_size
 
         schedules = ArgusSchedule.filter(release_id=release.id, id__in=tuple(schedule_ids)).all()
 

argus/backend/service/jenkins_service.py

@@ -1,12 +1,17 @@
+import re
+import requests
 from typing import Any, TypedDict
+from uuid import UUID
 import xml.etree.ElementTree as ET
 import jenkins
 import logging
 
 from flask import current_app, g
 
-LOGGER = logging.getLogger(__name__)
+from argus.backend.models.web import ArgusGroup, ArgusRelease, ArgusTest, UserOauthToken
 
+LOGGER = logging.getLogger(__name__)
+GITHUB_REPO_RE = r"(?P<http>^https?:\/\/(www\.)?github\.com\/(?P<user>[\w\d\-]+)\/(?P<repo>[\w\d\-]+)(\.git)?$)|(?P<ssh>git@github\.com:(?P<ssh_user>[\w\d\-]+)\/(?P<ssh_repo>[\w\d\-]+)(\.git)?)"
 
 class Parameter(TypedDict):
     _class: str
@@ -15,9 +20,31 @@ class Parameter(TypedDict):
     value: Any
 
 
+class JenkinsServiceError(Exception):
+    pass
+
+
 class JenkinsService:
     RESERVED_PARAMETER_NAME = "requested_by_user"
 
+    SETTINGS_CONFIG_MAP = {
+        "scylla-cluster-tests": {
+            "gitRepo": "*//scm/userRemoteConfigs/hudson.plugins.git.UserRemoteConfig/url",
+            "gitBranch": "*//scm/branches/hudson.plugins.git.BranchSpec/name",
+            "pipelineFile": "*//scriptPath",
+        },
+        "driver-matrix-tests": {
+            "gitRepo": "*//scm/userRemoteConfigs/hudson.plugins.git.UserRemoteConfig/url",
+            "gitBranch": "*//scm/branches/hudson.plugins.git.BranchSpec/name",
+            "pipelineFile": "*//scriptPath",
+        },
+        "sirenada": {
+            "gitRepo": "*//scm/userRemoteConfigs/hudson.plugins.git.UserRemoteConfig/url",
+            "gitBranch": "*//scm/branches/hudson.plugins.git.BranchSpec/name",
+            "pipelineFile": "*//scriptPath",
+        }
+    }
+
     def __init__(self) -> None:
         self._jenkins = jenkins.Jenkins(url=current_app.config["JENKINS_URL"],
                                         username=current_app.config["JENKINS_USER"],
@@ -42,6 +69,153 @@ class JenkinsService:
 
         return params
 
+    def get_releases_for_clone(self, test_id: str):
+        test_id = UUID(test_id)
+        # TODO: Filtering based on origin location / user preferences
+        _: ArgusTest = ArgusTest.get(id=test_id)
+
+        releases = list(ArgusRelease.all())
+
+        return sorted(releases, key=lambda r: r.pretty_name if r.pretty_name else r.name)
+
+    def get_groups_for_release(self, release_id: str):
+        groups = list(ArgusGroup.filter(release_id=release_id).all())
+
+        return sorted(groups, key=lambda g: g.pretty_name if g.pretty_name else g.name)
+
+    def _verify_sct_settings(self, new_settings: dict[str, str]) -> tuple[bool, str]:
+        if not (match := re.match(GITHUB_REPO_RE, new_settings["gitRepo"])):
+            return (False, "Repository doesn't conform to GitHub schema")
+
+        git_info = match.groupdict()
+        if git_info.get("ssh"):
+            repo = git_info["ssh_repo"]
+            user = git_info["ssh_user"]
+        else:
+            repo = git_info["repo"]
+            user = git_info["user"]
+
+        user_tokens = UserOauthToken.filter(user_id=g.user.id).all()
+        token = None
+        for tok in user_tokens:
+            if tok.kind == "github":
+                token = tok.token
+                break
+        if not token:
+            raise JenkinsServiceError("Github token not found")
+
+        response = requests.get(
+            url=f"https://api.github.com/repos/{user}/{repo}/contents/{new_settings['pipelineFile']}?ref={new_settings['gitBranch']}",
+            headers={
+                "Accept": "application/vnd.github+json",
+                "Authorization": f"Bearer {token}",
+            }
+            )
+        
+        if response.status_code == 404:
+            return (False, f"Pipeline file not found in the <a href=\"https://github.com/{user}/{repo}/tree/{new_settings['gitBranch']}\"> target repository</a>, please check the repository before continuing")
+
+        if response.status_code == 403:
+            return (True, "No access to this repository using your token. The pipeline file cannot be verified.")
+
+        if response.status_code == 200:
+            return (True, "")
+
+        return (False, "Generic Error")
+
+    def verify_job_settings(self, build_id: str, new_settings: dict[str, str]) -> tuple[bool, str]:
+        PLUGIN_MAP = {
+            "scylla-cluster-tests": self._verify_sct_settings,
+            # for now they match
+            "sirenada": self._verify_sct_settings,
+            "driver-matrix-tests": self._verify_sct_settings,
+        }
+        test: ArgusTest = ArgusTest.get(build_system_id=build_id)
+        plugin_name = test.plugin_name
+
+        validated, message = PLUGIN_MAP.get(plugin_name, lambda _: (True, ""))(new_settings)
+
+        return {
+            "validated": validated,
+            "message": message,
+        }
+
+    def get_advanced_settings(self, build_id: str):
+        test: ArgusTest = ArgusTest.get(build_system_id=build_id)
+        plugin_name = test.plugin_name
+
+        if not (plugin_settings := self.SETTINGS_CONFIG_MAP.get(plugin_name)):
+            return {}
+
+        settings = {}
+        raw_config = self._jenkins.get_job_config(name=build_id)
+        config = ET.fromstring(raw_config)
+
+        for setting, xpath in plugin_settings.items():
+            value = config.find(xpath)
+            settings[setting] = value.text
+
+        return settings
+
+    def adjust_job_settings(self, build_id: str, plugin_name: str, settings: dict[str, str]):
+        xpath_map = self.SETTINGS_CONFIG_MAP.get(plugin_name)
+        if not xpath_map:
+            return
+        
+        config = self._jenkins.get_job_config(name=build_id)
+        xml = ET.fromstring(config)
+        for setting, value in settings.items():
+            element = xml.find(xpath_map[setting])
+            element.text = value
+
+        adjusted_config = ET.tostring(xml, encoding="unicode")
+        self._jenkins.reconfig_job(name=build_id, config_xml=adjusted_config)
+
+    def clone_job(self, current_test_id: str, new_name: str, target: str, group: str, advanced_settings: bool | dict[str, str]):
+        cloned_test: ArgusTest = ArgusTest.get(id=current_test_id)
+        target_release: ArgusRelease = ArgusRelease.get(id=target)
+        target_group: ArgusGroup = ArgusGroup.get(id=group)
+
+        if target_group.id == cloned_test.id and new_name == cloned_test.name:
+            raise JenkinsServiceError("Unable to clone: source and destination are the same")
+
+        if not target_group.build_system_id:
+            raise JenkinsServiceError("Unable to clone: target group is missing jenkins folder path")
+
+        jenkins_new_build_id = f"{target_group.build_system_id}/{new_name}"
+
+        new_test = ArgusTest()
+        new_test.name = new_name
+        new_test.build_system_id = jenkins_new_build_id
+        new_test.group_id = target_group.id
+        new_test.release_id = target_release.id
+        new_test.plugin_name = cloned_test.plugin_name
+
+        old_config = self._jenkins.get_job_config(name=cloned_test.build_system_id)
+        LOGGER.info(old_config)
+        xml = ET.fromstring(old_config)
+        display_name = xml.find("displayName")
+        display_name.text = new_name
+        new_config = ET.tostring(xml, encoding="unicode")
+        self._jenkins.create_job(name=jenkins_new_build_id, config_xml=new_config)
+        new_job_info = self._jenkins.get_job_info(name=jenkins_new_build_id)
+        new_test.build_system_url = new_job_info["url"]
+        new_test.save()
+
+        if advanced_settings:
+            self.adjust_job_settings(build_id=jenkins_new_build_id, plugin_name=new_test.plugin_name, settings=advanced_settings)
+
+        return {
+            "new_job": new_job_info,
+            "new_entity": new_test,
+        }
+
+    def clone_build_job(self, build_id: str, params: dict[str, str]):
+        queue_item = self.build_job(build_id=build_id, params=params)
+        return {
+            "queueItem": queue_item,
+        }
+
     def build_job(self, build_id: str, params: dict, user_override: str = None):
         queue_number = self._jenkins.build_job(build_id, {
             **params,

argus/backend/service/stats.py

@@ -1,3 +1,5 @@
+from collections import defaultdict
+from functools import reduce
 import logging
 
 from datetime import datetime
@@ -182,7 +184,7 @@ class ReleaseStats:
             **aggregated_investigation_status
         }
 
-    def collect(self, rows: list[TestRunStatRow], limited=False, force=False) -> None:
+    def collect(self, rows: list[TestRunStatRow], limited=False, force=False, dict: dict | None = None, tests=None) -> None:
         self.forced_collection = force
         if not self.release.enabled and not force:
             return
@@ -193,10 +195,19 @@ class ReleaseStats:
             ).all())
 
         self.rows = rows
+        self.dict = dict
         if not limited or force:
-            self.issues = ArgusGithubIssue.filter(release_id=self.release.id).all()
-            self.comments = ArgusTestRunComment.filter(release_id=self.release.id).all()
-        self.all_tests = ArgusTest.filter(release_id=self.release.id).all()
+            self.issues = reduce(
+                lambda acc, row: acc[row["run_id"]].append(row) or acc,
+                ArgusGithubIssue.filter(release_id=self.release.id).all(),
+                defaultdict(list)
+            )
+            self.comments = reduce(
+                lambda acc, row: acc[row["test_run_id"]].append(row) or acc,
+                ArgusTestRunComment.filter(release_id=self.release.id).all(),
+                defaultdict(list)
+            )
+        self.all_tests = ArgusTest.filter(release_id=self.release.id).all() if not tests else tests
         groups: list[ArgusGroup] = ArgusGroup.filter(release_id=self.release.id).all()
         for group in groups:
             if group.enabled:
@@ -292,13 +303,17 @@ class TestStats:
             "hasBugReport": self.has_bug_report,
             "hasComments": self.has_comments,
             "buildNumber": self.tracked_run_number,
+            "buildId": self.test.build_system_id,
         }
 
     def collect(self, limited=False):
 
         # TODO: Parametrize run limit
         # FIXME: This is only a mitigation, build_number overflows on the build system side.
-        last_runs = [r for r in self.parent_group.parent_release.rows if r["build_id"] == self.test.build_system_id][:15]
+        if not self.parent_group.parent_release.dict:
+            last_runs = [r for r in self.parent_group.parent_release.rows if r["build_id"] == self.test.build_system_id]
+        else:
+            last_runs = self.parent_group.parent_release.dict.get(self.test.build_system_id, [])
         last_runs: list[TestRunStatRow] = sorted(
             last_runs, reverse=True, key=lambda r: get_build_number(r["build_job_url"]))
         try:
@@ -326,8 +341,8 @@ class TestStats:
                 "build_job_name": run["build_id"],
                 "start_time": run["start_time"],
                 "assignee": run["assignee"],
-                "issues": [dict(i.items()) for i in self.parent_group.parent_release.issues if i.run_id == run["id"]],
-                "comments": [dict(i.items()) for i in self.parent_group.parent_release.comments if i.test_run_id == run["id"]],
+                "issues": [dict(issue.items()) for issue in self.parent_group.parent_release.issues[run["id"]]],
+                "comments": [dict(comment.items()) for comment in self.parent_group.parent_release.comments[run["id"]]],
             }
             for run in last_runs
         ]
@@ -335,8 +350,8 @@ class TestStats:
             target_run = next(run for run in self.last_runs if run["id"] == worst_case[1]["id"])
         except StopIteration:
             target_run = worst_case[1]
-            target_run["issues"] = [dict(i.items()) for i in self.parent_group.parent_release.issues if i.run_id == target_run["id"]]
-            target_run["comments"] = [dict(i.items()) for i in self.parent_group.parent_release.comments if i.test_run_id == target_run["id"]]
+            target_run["issues"] = [dict(issue.items()) for issue in self.parent_group.parent_release.issues[target_run["id"]]]
+            target_run["comments"] = [dict(comment.items()) for comment in self.parent_group.parent_release.comments[target_run["id"]]]
         self.has_bug_report = len(target_run["issues"]) > 0
         self.parent_group.parent_release.has_bug_report = self.has_bug_report or self.parent_group.parent_release.has_bug_report
         self.has_comments = len(target_run["comments"]) > 0
@@ -356,13 +371,15 @@ class ReleaseStatsCollector:
 
     def collect(self, limited=False, force=False, include_no_version=False) -> dict:
         self.release: ArgusRelease = ArgusRelease.get(name=self.release_name)
-        self.release_rows = [row for plugin in all_plugin_models()
-                             for row in plugin.get_stats_for_release(release=self.release)]
+        all_tests = ArgusTest.filter(release_id=self.release.id).all()
+        build_ids = [t.build_system_id for t in all_tests]
+        self.release_rows = [futures for plugin in all_plugin_models()
+                             for futures in plugin.get_stats_for_release(release=self.release, build_ids=build_ids)]
+        self.release_rows = [row for future in self.release_rows for row in future.result()]
         if self.release.dormant and not force:
             return {
                 "dormant": True
             }
-
         if self.release_version:
             if include_no_version:
                 expr = lambda row: row["scylla_version"] == self.release_version or not row["scylla_version"] 
@@ -376,7 +393,12 @@ class ReleaseStatsCollector:
             else:
                 expr = lambda row: row["scylla_version"]
         self.release_rows = list(filter(expr, self.release_rows))
+        self.release_dict = {}
+        for row in self.release_rows:
+            runs = self.release_dict.get(row["build_id"], [])
+            runs.append(row)
+            self.release_dict[row["build_id"]] = runs
 
         self.release_stats = ReleaseStats(release=self.release)
-        self.release_stats.collect(rows=self.release_rows, limited=limited, force=force)
+        self.release_stats.collect(rows=self.release_rows, limited=limited, force=force, dict=self.release_dict, tests=all_tests)
         return self.release_stats.to_dict()

argus/client/sct/client.py

@@ -1,3 +1,5 @@
+import base64
+from typing import Any
 from uuid import UUID
 from dataclasses import asdict
 from argus.backend.plugins.sct.types import GeminiResultsRequest, PerformanceResultsRequest
@@ -15,6 +17,7 @@ class ArgusSCTClient(ArgusClient):
         SUBMIT_SCREENSHOTS = "/sct/$id/screenshots/submit"
         CREATE_RESOURCE = "/sct/$id/resource/create"
         TERMINATE_RESOURCE = "/sct/$id/resource/$name/terminate"
+        UPDATE_RESOURCE = "/sct/$id/resource/$name/update"
         SET_SCT_RUNNER  = "/sct/$id/sct_runner/set"
         UPDATE_SHARDS_FOR_RESOURCE = "/sct/$id/resource/$name/shards"
         SUBMIT_NEMESIS = "/sct/$id/nemesis/submit"
@@ -22,6 +25,7 @@ class ArgusSCTClient(ArgusClient):
         SUBMIT_PERFORMANCE_RESULTS = "/sct/$id/performance/submit"
         FINALIZE_NEMESIS = "/sct/$id/nemesis/finalize"
         SUBMIT_EVENTS = "/sct/$id/events/submit"
+        SUBMIT_JUNIT_REPORT = "/sct/$id/junit/submit"
 
     def __init__(self, run_id: UUID, auth_token: str, base_url: str, api_version="v1") -> None:
         super().__init__(auth_token, base_url, api_version)
@@ -204,6 +208,22 @@ class ArgusSCTClient(ArgusClient):
         )
         self.check_response(response)
 
+
+    def update_resource(self, name: str, update_data: dict[str, Any]) -> None:
+        """
+            Update fields of the resource.
+        """
+        response = self.post(
+            endpoint=self.Routes.UPDATE_RESOURCE,
+            location_params={"id": str(self.run_id), "name": name},
+            body={
+                **self.generic_body,
+                "update_data": update_data,
+            }
+        )
+        self.check_response(response)
+
+
     def submit_nemesis(self, name: str, class_name: str, start_time: int,
                        target_name: str, target_ip: str, target_shards: int) -> None:
         """
@@ -265,3 +285,17 @@ class ArgusSCTClient(ArgusClient):
             Updates a heartbeat field for an already existing test.
         """
         super().heartbeat(run_type=self.test_type, run_id=self.run_id)
+
+    def sct_submit_junit_report(self, file_name: str, raw_content: str) -> None:
+        """
+            Submits a JUnit-formatted XML report to argus
+        """
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_JUNIT_REPORT,
+            location_params={"id": str(self.run_id)},
+            body={
+                **self.generic_body,
+                "file_name": file_name,
+                "content": str(base64.encodebytes(bytes(raw_content, encoding="utf-8")), encoding="utf-8")
+            }
+        )

{argus_alm-0.12.2.dist-info → argus_alm-0.12.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: argus-alm
-Version: 0.12.2
+Version: 0.12.3
 Summary: Argus
 Home-page: https://github.com/scylladb/argus
 License: Apache-2.0
@@ -11,6 +11,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: click (>=8.1.3,<9.0.0)
 Requires-Dist: requests (>=2.26.0,<3.0.0)
 Project-URL: Repository, https://github.com/scylladb/argus

{argus_alm-0.12.2.dist-info → argus_alm-0.12.3.dist-info}/RECORD

@@ -1,7 +1,7 @@
 argus/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-argus/backend/cli.py,sha256=EZFI70CIaHNt93ARvEkNanbC0_nB7loIPq9giEQ3P2s,1342
+argus/backend/cli.py,sha256=fWSS1m0mhQeCwfH58Qfs4Cicxc95IKi9vwmQn3SUYs0,1346
 argus/backend/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/controller/admin.py,sha256=2z29RX7ZQO_VTklSKH9RrEj-Ag2SsvyOaIzWDKr0ahQ,575
 argus/backend/controller/admin_api.py,sha256=9CkewYmnqKJpSKoXyKDMxuMziyAWQ1lRD3dMSh5R3PI,6249
@@ -13,43 +13,43 @@ argus/backend/controller/notification_api.py,sha256=wz7V4nE6Mxclpq78P8gNnCyeQ7xA
 argus/backend/controller/notifications.py,sha256=zMSJln72BGU6Q_nQvJesMnuvJ57Ucbov4M2ZI-37Bxo,290
 argus/backend/controller/team.py,sha256=G6LdIBaYgfG0Qr4RhNQ53MZVdh4wcuotsIIpFwhTJ3w,3101
 argus/backend/controller/team_ui.py,sha256=B7N1_Kzl6Rac8BV3FbKj55pGAS_dht47rYhAi94PC8A,589
-argus/backend/controller/testrun_api.py,sha256=JhSzstTWkcYPiMKQikeWaYjTPSlvNyHHRany11TQUGo,9070
+argus/backend/controller/testrun_api.py,sha256=5VWJnYlPuh3GQyDsKqE0b1zw7rFGlGTg16BHCsiYnB4,11883
 argus/backend/db.py,sha256=bBiraYD05Qex28yZHjSP1bRlcMsc6oTYGt792zXmaHo,4101
 argus/backend/error_handlers.py,sha256=IEjz7Vzfldv1PTOeHrpRWmRsgBrHtAW0PXHUJZDovAE,480
 argus/backend/events/event_processors.py,sha256=bsmBayiXvlGn3aqiT2z9WgwnVBRtn2cRqkgn4pLodck,1291
 argus/backend/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/models/web.py,sha256=dUWQQaw5TivSCOuGQqAxIH9yVraGXX7sayNBloIS3n8,12206
 argus/backend/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-argus/backend/plugins/core.py,sha256=Tit-JlybrFCSsqoKjp_BFmtaxRk_AiocGOKqMfBovj4,7604
+argus/backend/plugins/core.py,sha256=fZG24qysFyOfjBPAdEIHb0UXIQYI3szJZvldqBTBIC0,7910
 argus/backend/plugins/driver_matrix_tests/controller.py,sha256=9Q6QCripzM528SGsQnYupM6k7HW7hUzkNyjJFiXXfEw,739
-argus/backend/plugins/driver_matrix_tests/model.py,sha256=Ay_Q6EAF4CwAW0fejdia4zyKcZOc943eZWT5nWIefYM,6822
+argus/backend/plugins/driver_matrix_tests/model.py,sha256=Qto0_TQec-ZDJzAsn28P3fEWfHloMtsNSRUS3bJ4ZJ0,6844
 argus/backend/plugins/driver_matrix_tests/plugin.py,sha256=72ESU7s8C6ovVMfJTlYwtaokdvRp_HJF1_czm1UMhKg,745
 argus/backend/plugins/driver_matrix_tests/raw_types.py,sha256=A108HCnv5q0RHfNRhUJrTpRy3fG7sPxr9Sk4gfsbooU,600
 argus/backend/plugins/driver_matrix_tests/service.py,sha256=dxb8VGTJLIyVqVrZ4RtzCXgnmS2qg2RAGhcp_SARt9I,1737
 argus/backend/plugins/driver_matrix_tests/udt.py,sha256=6lydzF3AQHm3GR5bKEDu1xLPYsLaBL3o-wu9NpabbqA,1134
-argus/backend/plugins/generic/model.py,sha256=y5-eJRxMm8L2zDRVXcG-ZK7mrslZ5rGPTv-ihXFt9Yc,3096
+argus/backend/plugins/generic/model.py,sha256=mX-IgBCxvWj_S_v_b2L4uitHGPR1apCz993uL4bnRD4,3118
 argus/backend/plugins/generic/plugin.py,sha256=5URbQVUCizrk-KZqb6I0P_8nLUekjYh-Js7ZLKVoBAA,407
 argus/backend/plugins/generic/types.py,sha256=jlZUcQ7r153ziyl3ZJmix7AzL2G1aX9N_z-4Kw9trWc,267
-argus/backend/plugins/loader.py,sha256=0MmGNBVle51tIyH7lA7Lz2L8PcGKGub9vyFuwnLm840,1320
-argus/backend/plugins/sct/controller.py,sha256=ek4gNiraDzd81QMpHKCzpugUSkwbXCHKAPsjD9ol6CE,4791
-argus/backend/plugins/sct/plugin.py,sha256=3TlX5NAd7bv4aMI9FJNJLkf8o2bcahZhZobAV4xAbzU,965
+argus/backend/plugins/loader.py,sha256=6PUrMjXKoCSDazMRkUHt8qxpniRhuqhY8Tof8lzeunk,1390
+argus/backend/plugins/sct/controller.py,sha256=NF11JLoUJ13whghlxRrVex9rLMgFtlkczUAAKAM9vYg,5738
+argus/backend/plugins/sct/plugin.py,sha256=_sOMcXLoFfeG9jwj_t48C4IFvY87juK8ApR6tfSw6q4,1007
 argus/backend/plugins/sct/resource_setup.py,sha256=hwfAOu-oKOH42tjtzJhiqwq_MtUE9_HevoFyql8JKqY,10120
-argus/backend/plugins/sct/service.py,sha256=fiwnIE4guVOnw5c8g8xwOSr5BoTI_AoyVzJkWYhnQ5A,17632
-argus/backend/plugins/sct/testrun.py,sha256=qU-81IRs7UYTs5ozcDlATLZWGUp6I8X3XOIVJoz9RFc,9416
-argus/backend/plugins/sct/types.py,sha256=avLL3fzug_n6GbtlW8bcPewcDGi1DxHFD0vp-JZ7hdQ,969
-argus/backend/plugins/sct/udt.py,sha256=oP2xzUGy2o4fVICcZyGyvLWapR2Rox-Myp_FTXHmxlQ,2879
-argus/backend/plugins/sirenada/model.py,sha256=ku9jITNf9wU0YZJ9JwkopJYCC2MKek1M1Q7aPKZzt5M,4683
+argus/backend/plugins/sct/service.py,sha256=e7zuvSMvUSl8pos8VG17TK_1BrRM4Ld2QHzJwOdBTQY,21379
+argus/backend/plugins/sct/testrun.py,sha256=NopC3Gnzf2m65S_E4DedAlgnbFvyaMQH5aLJip6ZPrE,9660
+argus/backend/plugins/sct/types.py,sha256=Gw1y4iqYguqNqTh_GopLDFho8vuGaOGuK7fjaHYhAOQ,1326
+argus/backend/plugins/sct/udt.py,sha256=V_x8_yw8rV7Q_QRBYayqtTNsPdZvjzOxWpRhXP1XAzs,3119
+argus/backend/plugins/sirenada/model.py,sha256=KVnI75BacuBryc5lR_Aai-mEOs7CB9xxhb7J-YRU3bc,4705
 argus/backend/plugins/sirenada/plugin.py,sha256=AlQAakwy3u-OqAqqK3RonUR5oDm-JoiwBUDUF3YEVP4,447
 argus/backend/plugins/sirenada/types.py,sha256=Gm3XMK9YJoozVaeM9XE7n8iRxA6PKBrS23Mo2vJfdLs,697
 argus/backend/service/admin.py,sha256=_VnWl3CkZBOAie_pPbd9sbXZUpBf2SApyNoFZLfB_QI,637
-argus/backend/service/argus_service.py,sha256=o415BalaQ-FP5CDSjeypiXJ4ejaVVXqive25syPhRdM,24192
+argus/backend/service/argus_service.py,sha256=t6pkjFOnIWoos_5TnrntwpzgNg6vQYVa_NgWHFIGcM8,24515
 argus/backend/service/build_system_monitor.py,sha256=_Bxugk4CCh2z-I-i74QMPe7M8j0dmBMDri2dd3WGVew,7328
 argus/backend/service/client_service.py,sha256=CS5esppd9s-SgUYE-HVLkfz-MrN8zxPouf9e4VlPV_M,2326
 argus/backend/service/event_service.py,sha256=iYeqxN2QCYTjYB1WPPv4BEFLXG0Oz3TvskkaK4v9pVY,654
-argus/backend/service/jenkins_service.py,sha256=BnUvVi1iUvvD99lnscs-kxPGA9LExxNUsgwfO-46tq8,2518
+argus/backend/service/jenkins_service.py,sha256=gAEPGHm-HaazHHyVXK5d7uG24oe5t9XlnDjPre-qzWg,9656
 argus/backend/service/notification_manager.py,sha256=h00Ej_-hH9H7pq0wah_1TH8dnpPyPNsgVJNO1rwJi7o,7011
 argus/backend/service/release_manager.py,sha256=DymV5OI53ClRdc4p7jlCGT6xPqrjIxHjs8EDiyWffqQ,7362
-argus/backend/service/stats.py,sha256=4WEtd5gdzT-dzOjD1NUHdBfVurxnwXcawjseu-kqxHw,15167
+argus/backend/service/stats.py,sha256=Vdm24PtMxFQFTaP1dDJZ9nsrcSLYrTIFi8Ju_-zuSrY,16308
 argus/backend/service/team_manager_service.py,sha256=zY5dvy3ffvQbJuXBvlWKE5dS5LQ3ss6tkFE-cwFZsdw,3010
 argus/backend/service/testrun.py,sha256=ggjTcWjyvsPXSSv_v80rrp3bHaqCOjcxYEewXrW9AXg,19706
 argus/backend/service/user.py,sha256=N3t43rgKMnSsPXU5R9bigEEGbPjYrc6MsJtof3z7kDE,9027
@@ -66,7 +66,7 @@ argus/client/base.py,sha256=-R-BINTolY06lUQLOLGlsWzza4fBdtLBW-4V3NT64vg,6755
 argus/client/driver_matrix_tests/client.py,sha256=ekuTkEZbcVqhg6DAC6PvGuC9bXuu4DSOjk96vcLzmuQ,7817
 argus/client/generic/cli.py,sha256=IJkgEZ5VOAeqp5SlLM13Y5m8e34Cqnyz8WkfeKoN7so,2208
 argus/client/generic/client.py,sha256=l4PDjDy65Mm2OI9ZLSnyd8_2i4Ei1Pp9yRt3bRX8s2Y,1114
-argus/client/sct/client.py,sha256=0xRIeYtjTFGfDS03klSTFie3uxrQqB51xkeOW223MiQ,10204
+argus/client/sct/client.py,sha256=DtRA0Ra3ycUcedDYfZZW1jER0nc8vdYHaY6DT0te4x0,11341
 argus/client/sct/types.py,sha256=VLgVe7qPmJtCLqtPnuX8N8kMKZq-iY3SKz68nvU6nJ4,371
 argus/client/sirenada/client.py,sha256=ilcyLXJb-0gKbmb9WSPr-Yvldh73joGBhRDoilQoSJ4,6220
 argus/db/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -77,8 +77,8 @@ argus/db/db_types.py,sha256=iLbmrUaDzrBw0kDCnvW0FSZ9-kNc3uQY-fsbIPymV4E,3612
 argus/db/interface.py,sha256=HroyA1Yijz5cXLdYbxorHCEu0GH9VeMMqB36IHTlcew,17146
 argus/db/testrun.py,sha256=0YG7FIH5FLQeNlYULxC6rhhyru2rziSMe3qKtYzTBnc,26014
 argus/db/utils.py,sha256=YAWsuLjUScSgKgdaL5aF4Sgr13gqH29Mb5cLctX4V_w,337
-argus_alm-0.12.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-argus_alm-0.12.2.dist-info/METADATA,sha256=RCkJF9S0qfgVoZYNzby251ebAl13rN_5Mzk64Ng_XaQ,6862
-argus_alm-0.12.2.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-argus_alm-0.12.2.dist-info/entry_points.txt,sha256=zEqrAK95P8AAhKbwO4lgrQzKBWqCzHH9zlUPCaCVHoQ,69
-argus_alm-0.12.2.dist-info/RECORD,,
+argus_alm-0.12.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+argus_alm-0.12.3.dist-info/METADATA,sha256=Y7opbIMG2m_jRxQyZkmPePpz5BxDIokPbgSxf2AOH7M,6913
+argus_alm-0.12.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+argus_alm-0.12.3.dist-info/entry_points.txt,sha256=zEqrAK95P8AAhKbwO4lgrQzKBWqCzHH9zlUPCaCVHoQ,69
+argus_alm-0.12.3.dist-info/RECORD,,

{argus_alm-0.12.2.dist-info → argus_alm-0.12.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.6.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any