argus-alm 0.11.4__py3-none-any.whl → 0.11.6__py3-none-any.whl

argus/backend/plugins/driver_matrix_tests/model.py

@@ -58,6 +58,10 @@ class DriverTestRun(PluginModelBase):
         run.build_id = req.job_name
         run.build_job_url = req.job_url
         run.assign_categories()
+        try:
+            run.assignee = run.get_scheduled_assignee()
+        except Exception:  # pylint: disable=broad-except
+            run.assignee = None
         for key, value in req.test_environment.items():
             env_info = EnvironmentInfo()
             env_info.key = key
@@ -102,7 +106,7 @@ class DriverTestRun(PluginModelBase):
                 collection.suites.append(suite)
             run.test_collection.append(collection)
 
-        run.status = run._determine_run_status()
+        run.status = run._determine_run_status().value
         run.save()
         return run
 

argus/backend/plugins/sct/controller.py

@@ -114,6 +114,36 @@ def sct_events_submit(run_id: str):
     }
 
 
+@bp.route("/<string:run_id>/gemini/submit", methods=["POST"])
+@api_login_required
+def sct_gemini_results_submit(run_id: str):
+    payload = get_payload(request)
+    result = SCTService.submit_gemini_results(run_id=run_id, gemini_data=payload["gemini_data"])
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+@bp.route("/<string:run_id>/performance/submit", methods=["POST"])
+@api_login_required
+def sct_performance_results_submit(run_id: str):
+    payload = get_payload(request)
+    result = SCTService.submit_performance_results(run_id=run_id, performance_results=payload["performance_results"])
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+@bp.route("/<string:run_id>/performance/history", methods=["GET"])
+@api_login_required
+def sct_get_performance_history(run_id: str):
+    result = SCTService.get_performance_history_for_test(run_id=run_id)
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
 @bp.route("/release/<string:release_name>/kernels", methods=["GET"])
 @api_login_required
 def sct_get_kernel_report(release_name: str):

argus/backend/plugins/sct/plugin.py

@@ -12,6 +12,7 @@ from argus.backend.plugins.sct.udt import (
     NemesisRunInfo,
     NodeDescription,
     PackageVersion,
+    PerformanceHDRHistogram,
 )
 
 
@@ -31,5 +32,6 @@ class PluginInfo(PluginInfoBase):
         CloudSetupDetails,
         CloudNodesInfo,
         CloudInstanceDetails,
-        PackageVersion
+        PackageVersion,
+        PerformanceHDRHistogram,
     ]

argus/backend/plugins/sct/service.py

@@ -1,7 +1,12 @@
 from dataclasses import dataclass
+from functools import reduce
 import logging
+import math
 from time import time
-from argus.backend.plugins.sct.testrun import SCTTestRun
+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.udt import (
     CloudInstanceDetails,
     CloudResource,
@@ -9,8 +14,11 @@ from argus.backend.plugins.sct.udt import (
     NemesisRunInfo,
     NodeDescription,
     PackageVersion,
+    PerformanceHDRHistogram,
 )
-from argus.backend.util.enums import NemesisStatus, ResourceState
+from argus.backend.service.event_service import EventService
+from argus.backend.util.common import get_build_number
+from argus.backend.util.enums import NemesisStatus, ResourceState, TestStatus
 
 LOGGER = logging.getLogger(__name__)
 
@@ -91,6 +99,154 @@ class SCTService:
 
         return "submitted"
 
+    @staticmethod
+    def submit_gemini_results(run_id: str, gemini_data: GeminiResultsRequest) -> str:
+        try:
+            run: SCTTestRun = SCTTestRun.get(id=run_id)
+            run.subtest_name = SubtestType.GEMINI.value
+            run.oracle_nodes_count = gemini_data.get("oracle_nodes_count")
+            run.oracle_node_ami_id = gemini_data.get("oracle_node_ami_id")
+            run.oracle_node_instance_type = gemini_data.get("oracle_node_instance_type")
+            run.oracle_node_scylla_version = gemini_data.get("oracle_node_scylla_version")
+            run.gemini_command = gemini_data.get("gemini_command")
+            run.gemini_version = gemini_data.get("gemini_version")
+            run.gemini_status = gemini_data.get("gemini_status")
+            run.gemini_seed = str(gemini_data.get("gemini_seed"))
+            run.gemini_write_ops = gemini_data.get("gemini_write_ops")
+            run.gemini_write_errors = gemini_data.get("gemini_write_errors")
+            run.gemini_read_ops = gemini_data.get("gemini_read_ops")
+            run.gemini_read_errors = gemini_data.get("gemini_read_errors")
+            run.save()
+
+            if run.gemini_status != "PASSED":
+                run.status = TestStatus.FAILED
+                EventService.create_run_event(kind=ArgusEventTypes.TestRunStatusChanged, body={
+                        "message": "[{username}] Setting run status to {status} due to Gemini reporting following status: {gemini_status}",
+                        "username": g.user.username,
+                        "status": TestStatus.FAILED.value,
+                        "gemini_status": run.gemini_status,
+                }, user_id=g.user.id, run_id=run_id, release_id=run.release_id, test_id=run.test_id)
+                run.save()
+        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 "submitted"
+
+    @staticmethod
+    def submit_performance_results(run_id: str, performance_results: PerformanceResultsRequest):
+        # pylint: disable=too-many-statements
+        try:
+            run: SCTTestRun = SCTTestRun.get(id=run_id)
+            run.subtest_name = SubtestType.PERFORMANCE.value
+            run.perf_op_rate_average = performance_results.get("perf_op_rate_average")
+            run.perf_op_rate_total = performance_results.get("perf_op_rate_total")
+            run.perf_avg_latency_99th = performance_results.get("perf_avg_latency_99th")
+            run.perf_avg_latency_mean = performance_results.get("perf_avg_latency_mean")
+            run.perf_total_errors = performance_results.get("perf_total_errors")
+            run.stress_cmd = performance_results.get("stress_cmd")
+            run.test_name = performance_results.get("test_name")
+            run.save()
+
+            is_latency_test = "latency" in run.test_name
+            threshold_negative = -10
+
+            def cmp(lhs, rhs):
+                delta = rhs - lhs
+                change = int(math.fabs(delta) * 100 / rhs)
+                return change if delta >= 0 else change * -1
+
+            previous_runs = SCTTestRun.get_perf_results_for_test_name(run.build_id, run.start_time, run.test_name)
+            metrics_to_check = ["perf_avg_latency_99th", "perf_avg_latency_mean"] if is_latency_test else ["perf_op_rate_total"]
+
+            older_runs_by_version = {}
+            for prev_run in previous_runs:
+                if not older_runs_by_version.get(prev_run["scylla_version"]):
+                    older_runs_by_version[prev_run["scylla_version"]] = []
+                older_runs_by_version[prev_run["scylla_version"]].append(prev_run)
+
+            regression_found = False
+            regression_info = {
+                "version": None,
+                "delta": None,
+                "id": None,
+                "metric": None,
+                "job_url": None,
+            }
+
+            if performance_results["histograms"]:
+                for histogram in performance_results["histograms"]:
+                    run.histograms = { k: PerformanceHDRHistogram(**v) for k, v in histogram.items() }
+
+            for version, runs in older_runs_by_version.items():
+                for metric in metrics_to_check:
+                    # pylint: disable=cell-var-from-loop
+                    best_run = sorted(runs, reverse=(not is_latency_test), key=lambda v: v[metric])[0]
+                    last_run = runs[0]
+
+                    metric_to_best = cmp(run[metric], best_run[metric])
+                    metric_to_last = cmp(run[metric], last_run[metric])
+                    if metric_to_last < threshold_negative:
+                        regression_found = True
+                        regression_info["metric"] = metric
+                        regression_info["version"] = version
+                        regression_info["job_url"] = last_run["build_job_url"]
+                        regression_info["id"] = str(last_run["id"])
+                        regression_info["delta"] = metric_to_last
+                        break
+
+                    if metric_to_best < threshold_negative:
+                        regression_found = True
+                        regression_info["metric"] = metric
+                        regression_info["version"] = version
+                        regression_info["job_url"] = best_run["build_job_url"]
+                        regression_info["id"] = str(best_run["id"])
+                        regression_info["delta"] = metric_to_best
+                        break
+
+                if regression_found:
+                    break
+
+            if regression_found:
+                run.status = TestStatus.FAILED.value
+                run.save()
+                EventService.create_run_event(kind=ArgusEventTypes.TestRunStatusChanged, body={
+                        "message": "[{username}] Setting run status to {status} due to performance metric '{metric}' falling "
+                                   "below allowed threshold ({threshold_negative}): {delta}% compared to "
+                                   "<a href='/test/{test_id}/runs?additionalRuns[]={base_run_id}&additionalRuns[]={previous_run_id}'>This {version} (#{build_number}) run</a>",
+                        "username": g.user.username,
+                        "status": TestStatus.FAILED.value,
+                        "metric": regression_info["metric"],
+                        "threshold_negative": threshold_negative,
+                        "delta": regression_info["delta"],
+                        "test_id": str(run.test_id),
+                        "base_run_id": str(run.id),
+                        "previous_run_id": regression_info["id"],
+                        "version": regression_info["version"],
+                        "build_number": get_build_number(regression_info["job_url"])
+                }, user_id=g.user.id, run_id=run_id, release_id=run.release_id, test_id=run.test_id)
+            else:
+                # NOTE: This will override status set by SCT Events.
+                run.status = TestStatus.PASSED.value
+                run.save()
+
+        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 "submitted"
+
+    @staticmethod
+    def get_performance_history_for_test(run_id: str):
+        try:
+            run: SCTTestRun = SCTTestRun.get(id=run_id)
+            rows = run.get_perf_results_for_test_name(build_id=run.build_id, start_time=run.start_time, test_name=run.test_name)
+            return rows
+        except SCTTestRun.DoesNotExist as exception:
+            LOGGER.error("Run %s not found for SCTTestRun", run_id)
+            raise SCTServiceException("Run not found", run_id) from exception
+
+
     @staticmethod
     def create_resource(run_id: str, resource_details: dict) -> str:
         instance_details = CloudInstanceDetails(**resource_details.pop("instance_details"))

argus/backend/plugins/sct/testrun.py

@@ -1,6 +1,8 @@
+from enum import Enum
 import logging
 from datetime import datetime
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from typing import Optional
 from uuid import UUID
 
 from cassandra.cqlengine import columns
@@ -16,6 +18,7 @@ from argus.backend.plugins.sct.udt import (
     EventsBySeverity,
     NemesisRunInfo,
     PackageVersion,
+    PerformanceHDRHistogram
 )
 
 LOGGER = logging.getLogger(__name__)
@@ -31,6 +34,11 @@ SCT_REGION_PROPERTY_MAP = {
 }
 
 
+class SubtestType(str, Enum):
+    GEMINI = "gemini"
+    PERFORMANCE = "performance"
+
+
 @dataclass(init=True, repr=True, frozen=True)
 class SCTTestRunSubmissionRequest():
     schema_version: str
@@ -39,9 +47,9 @@ class SCTTestRunSubmissionRequest():
     job_url: str
     started_by: str
     commit_id: str
-    runner_public_ip: str
-    runner_private_ip: str
-    sct_config: dict
+    sct_config: dict | None
+    runner_public_ip: Optional[str] = field(default=None)
+    runner_private_ip: Optional[str] = field(default=None)
 
 
 class SCTTestRun(PluginModelBase):
@@ -49,6 +57,7 @@ class SCTTestRun(PluginModelBase):
     _plugin_name = "scylla-cluster-tests"
 
     # Test Details
+    test_name = columns.Text()
     scm_revision_id = columns.Text()
     started_by = columns.Text()
     config_files = columns.List(value_type=columns.Text())
@@ -69,6 +78,33 @@ class SCTTestRun(PluginModelBase):
     nemesis_data = columns.List(value_type=columns.UserDefinedType(user_type=NemesisRunInfo))
     screenshots = columns.List(value_type=columns.Text())
 
+    # Subtest
+    subtest_name = columns.Text()
+
+    # Gemini-related fields
+    oracle_nodes_count = columns.Integer()
+    oracle_node_ami_id = columns.Text()
+    oracle_node_instance_type = columns.Text()
+    oracle_node_scylla_version = columns.Text()
+    gemini_command = columns.Text()
+    gemini_version = columns.Text()
+    gemini_status = columns.Text()
+    gemini_seed = columns.Text()
+    gemini_write_ops = columns.Integer()
+    gemini_write_errors = columns.Integer()
+    gemini_read_ops = columns.Integer()
+    gemini_read_errors = columns.Integer()
+
+    # Performance fields
+    perf_op_rate_average = columns.Double()
+    perf_op_rate_total = columns.Double()
+    perf_avg_latency_99th = columns.Double()
+    perf_avg_latency_mean = columns.Double()
+    perf_total_errors = columns.Double()
+    stress_cmd = columns.Text()
+
+    histograms = columns.List(value_type=columns.Map(key_type=columns.Text(), value_type=columns.UserDefinedType(user_type=PerformanceHDRHistogram)))
+
     @classmethod
     def _stats_query(cls) -> str:
         return ("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
@@ -102,7 +138,17 @@ class SCTTestRun(PluginModelBase):
         return list(rows)
 
     @classmethod
-    def from_sct_config(cls, req: SCTTestRunSubmissionRequest):
+    def get_perf_results_for_test_name(cls, build_id: str, start_time: float, test_name: str):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare(f"SELECT build_id, packages, scylla_version, test_name, perf_op_rate_average, perf_op_rate_total, "
+                                "perf_avg_latency_99th, perf_avg_latency_mean, perf_total_errors, id, start_time, build_job_url"
+                                f" FROM {cls.table_name()} WHERE build_id = ? AND start_time < ? AND test_name = ? ALLOW FILTERING")
+        rows = cluster.session.execute(query=query, parameters=(build_id, start_time, test_name))
+
+        return list(rows)
+
+    @classmethod
+    def init_sct_run(cls, req: SCTTestRunSubmissionRequest):
         run = cls()
         run.build_id = req.job_name
         run.assign_categories()
@@ -116,16 +162,35 @@ class SCTTestRun(PluginModelBase):
         run.started_by = req.started_by
         run.build_job_url = req.job_url
 
-        backend = req.sct_config.get("cluster_backend")
-        region_key = SCT_REGION_PROPERTY_MAP.get(backend, SCT_REGION_PROPERTY_MAP["default"])
-        raw_regions = req.sct_config.get(region_key) or "undefined_region"
-        regions = raw_regions.split() if isinstance(raw_regions, str) else raw_regions
+        return run
 
-        run.cloud_setup = ResourceSetup.get_resource_setup(backend=backend, sct_config=req.sct_config)
+    @classmethod
+    def from_sct_config(cls, req: SCTTestRunSubmissionRequest):
+        try:
+            run = cls.get(id=req.run_id)
+        except cls.DoesNotExist:
+            run = cls.init_sct_run(req)
+            run.save()
+
+        if req.sct_config:
+            backend = req.sct_config.get("cluster_backend")
+            region_key = SCT_REGION_PROPERTY_MAP.get(backend, SCT_REGION_PROPERTY_MAP["default"])
+            raw_regions = req.sct_config.get(region_key) or "undefined_region"
+            regions = raw_regions.split() if isinstance(raw_regions, str) else raw_regions
+            primary_region = regions[0]
+            if req.runner_public_ip:  # NOTE: Legacy support, not needed otherwise
+                run.sct_runner_host = CloudInstanceDetails(
+                    public_ip=req.runner_public_ip,
+                    private_ip=req.runner_private_ip,
+                    provider=backend,
+                    region=primary_region,
+                )
+            run.cloud_setup = ResourceSetup.get_resource_setup(backend=backend, sct_config=req.sct_config)
+
+            run.config_files = req.sct_config.get("config_files")
+            run.region_name = regions
+            run.save()
 
-        run.config_files = req.sct_config.get("config_files")
-        run.region_name = regions
-        run.save()
         return run
 
     def get_resources(self) -> list[CloudResource]:

argus/backend/plugins/sct/types.py

@@ -0,0 +1,38 @@
+from typing import TypedDict
+
+class RawHDRHistogram(TypedDict):
+    start_time: int
+    percentile_90: float
+    percentile_50: float
+    percentile_99_999: float
+    percentile_95: float
+    end_time: float
+    percentile_99_99: float
+    percentile_99: float
+    stddev: float
+    percentile_99_9: float
+
+class GeminiResultsRequest(TypedDict):
+    oracle_nodes_count: int
+    oracle_node_ami_id: str
+    oracle_node_instance_type: str
+    oracle_node_scylla_version: str
+    gemini_command: str
+    gemini_version: str
+    gemini_status: str
+    gemini_seed: str
+    gemini_write_ops: int
+    gemini_write_errors: int
+    gemini_read_ops: int
+    gemini_read_errors: int
+
+class PerformanceResultsRequest(TypedDict):
+    test_name: str
+    stress_cmd: str
+    perf_op_rate_average: float
+    perf_op_rate_total: float
+    perf_avg_latency_99th: float
+    perf_avg_latency_mean: float
+    perf_total_errors: str
+
+    histograms: list[dict[str, RawHDRHistogram]] | None

argus/backend/plugins/sct/udt.py

@@ -78,3 +78,16 @@ class NemesisRunInfo(UserType):
     start_time = columns.Integer()
     end_time = columns.Integer()
     stack_trace = columns.Text()
+
+
+class PerformanceHDRHistogram(UserType):
+    start_time = columns.Integer()
+    percentile_90 = columns.Float()
+    percentile_50 = columns.Float()
+    percentile_99_999 = columns.Float()
+    percentile_95 = columns.Float()
+    end_time = columns.Float()
+    percentile_99_99 = columns.Float()
+    percentile_99 = columns.Float()
+    stddev = columns.Float()
+    percentile_99_9 = columns.Float()

argus/backend/service/build_system_monitor.py

@@ -78,7 +78,7 @@ class JenkinsMonitor(ArgusTestsMonitor):
     def collect(self):
         click.echo("Collecting new tests from jenkins")
         all_jobs = self._jenkins.get_all_jobs()
-        all_monitored_folders = [job for job in all_jobs if job["name"] in self._monitored_releases]
+        all_monitored_folders = [job for job in all_jobs if job["fullname"] in self._monitored_releases]
         for release in all_monitored_folders:
             LOGGER.info("Processing release %s", release["name"])
             try:
@@ -89,8 +89,23 @@ class JenkinsMonitor(ArgusTestsMonitor):
                 saved_release = self.create_release(release["name"])
                 self._existing_releases.append(saved_release)
 
-            groups = self.collect_groups_for_release(release["jobs"])
+            try:
+                groups = self.collect_groups_for_release(release["jobs"])
+            except KeyError:
+                LOGGER.error("Empty release!\n %s", release)
+                continue
             folder_stack = [dict(parent_name="", parent_display_name="", group=g) for g in reversed(groups)]
+            root_folder = {
+                "parent_name": "",
+                "parent_display_name": "",
+                "group":  {
+                    "name": f"{release['fullname']}-root",
+                    "displayName": "-- root directory --",
+                    "fullname": release["fullname"],
+                    "jobs": self.collect_root_folder_jobs(release["jobs"]),
+                }
+            }
+            folder_stack.append(root_folder)
             while len(folder_stack) != 0:
                 group_dict = folder_stack.pop()
                 group = group_dict["group"]
@@ -104,7 +119,7 @@ class JenkinsMonitor(ArgusTestsMonitor):
                     LOGGER.warning(
                         "Group %s for release %s doesn't exist, creating...", group_name, saved_release.name)
                     try:
-                        display_name = self._jenkins.get_job_info(name=group["fullname"])["displayName"]
+                        display_name = group.get("displayName", self._jenkins.get_job_info(name=group["fullname"])["displayName"])
                         display_name = display_name if not group_dict[
                             "parent_display_name"] else f"{group_dict['parent_display_name']} - {display_name}"
                     except Exception:
@@ -138,3 +153,6 @@ class JenkinsMonitor(ArgusTestsMonitor):
         groups = [group for group in groups if self.check_filter(group["name"])]
 
         return groups
+
+    def collect_root_folder_jobs(self, jobs):
+        return [job for job in jobs if "WorkflowJob" in job["_class"]]

argus/backend/service/event_service.py

@@ -0,0 +1,18 @@
+from datetime import datetime
+import json
+from argus.backend.models.web import ArgusEvent, ArgusEventTypes
+
+
+class EventService:
+    @staticmethod
+    def create_run_event(kind: ArgusEventTypes, body: dict, user_id=None, run_id=None, release_id=None, group_id=None, test_id=None):
+        event = ArgusEvent()
+        event.release_id = release_id
+        event.group_id = group_id
+        event.test_id = test_id
+        event.user_id = user_id
+        event.run_id = run_id
+        event.body = json.dumps(body, ensure_ascii=True, separators=(',', ':'))
+        event.kind = kind.value
+        event.created_at = datetime.utcnow()
+        event.save()

argus/backend/service/stats.py

@@ -76,6 +76,70 @@ class ComparableTestStatus:
         return self._get_prio() <= __o._get_prio()
 
 
+class ComparableTestInvestigationStatus:
+    PRIORITY_MAP = {
+        TestInvestigationStatus.NOT_INVESTIGATED: 10,
+        TestInvestigationStatus.IN_PROGRESS: 9,
+        TestInvestigationStatus.INVESTIGATED: 8,
+        TestInvestigationStatus.IGNORED: 7,
+    }
+
+    def __init__(self, status: TestInvestigationStatus):
+        self._status = status
+
+    def _get_prio(self):
+        return self.PRIORITY_MAP.get(self._status, 0)
+
+    def __eq__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() == __o._get_prio()
+
+    def __ne__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return not self.__eq__(__o)
+
+    def __lt__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() < __o._get_prio()
+
+    def __gt__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() > __o._get_prio()
+
+    def __ge__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() >= __o._get_prio()
+
+    def __le__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() <= __o._get_prio()
+
+
+def generate_field_status_map(
+        last_runs: list[TestRunStatRow],
+        field_name = "status",
+        container_class = TestStatus,
+        cmp_class = ComparableTestStatus
+    ) -> dict[int, str]:
+
+    status_map = {}
+    for run in last_runs:
+        run_number = get_build_number(run["build_job_url"])
+        match status := status_map.get(run_number):
+            case str():
+                if cmp_class(container_class(status)) < cmp_class(container_class(run[field_name])):
+                    status_map[run_number] = run[field_name]
+            case _:
+                status_map[run_number] = run[field_name]
+    return status_map
+
+
 class ReleaseStats:
     def __init__(self, release: ArgusRelease) -> None:
         self.release = release
@@ -227,18 +291,6 @@ class TestStats:
             "hasComments": self.has_comments
         }
 
-    def _generate_status_map(self, last_runs: list[TestRunStatRow]) -> dict[int, str]:
-        status_map = {}
-        for run in last_runs:
-            run_number = get_build_number(run["build_job_url"])
-            match status := status_map.get(run_number):
-                case str():
-                    if ComparableTestStatus(TestStatus(status)) < ComparableTestStatus(TestStatus(run["status"])):
-                        status_map[run_number] = run["status"]
-                case _:
-                    status_map[run_number] = run["status"]
-        return status_map
-
     def collect(self, limited=False):
 
         # TODO: Parametrize run limit
@@ -252,10 +304,12 @@ class TestStats:
             self.status = TestStatus.NOT_RUN if self.is_scheduled else TestStatus.NOT_PLANNED
             self.parent_group.increment_status(status=self.status)
             return
-        status_map = self._generate_status_map(last_runs)
+        status_map = generate_field_status_map(last_runs)
+        investigation_status_map = generate_field_status_map(
+            last_runs, "investigation_status", TestInvestigationStatus, ComparableTestInvestigationStatus)
 
         self.status = status_map.get(get_build_number(last_run["build_job_url"]))
-        self.investigation_status = TestInvestigationStatus(last_run["investigation_status"])
+        self.investigation_status = investigation_status_map.get(get_build_number(last_run["build_job_url"]))
         self.start_time = last_run["start_time"]
 
         self.parent_group.increment_status(status=self.status)
@@ -300,7 +354,7 @@ class ReleaseStatsCollector:
 
         if self.release_version:
             self.release_rows = list(
-                filter(lambda row: row["scylla_version"] == self.release_version, self.release_rows))
+                filter(lambda row: row["scylla_version"] == self.release_version or not row["scylla_version"], self.release_rows))
 
         self.release_stats = ReleaseStats(release=self.release)
         self.release_stats.collect(rows=self.release_rows, limited=limited, force=force)

argus/backend/service/testrun.py

@@ -30,7 +30,9 @@ from argus.backend.plugins.core import PluginInfoBase, PluginModelBase
 
 from argus.backend.plugins.loader import AVAILABLE_PLUGINS
 from argus.backend.events.event_processors import EVENT_PROCESSORS
+from argus.backend.service.event_service import EventService
 from argus.backend.service.notification_manager import NotificationManagerService
+from argus.backend.service.stats import ComparableTestStatus
 from argus.backend.util.common import get_build_number, strip_html_tags
 from argus.backend.util.enums import TestInvestigationStatus, TestStatus
 
@@ -80,6 +82,8 @@ class TestRunService:
         for row in last_runs:
             row["build_number"] = get_build_number(build_job_url=row["build_job_url"])
 
+        last_runs = sorted(last_runs, reverse=True, key=lambda run: (run["build_number"], ComparableTestStatus(TestStatus(run["status"]))))
+
         return last_runs
 
     def get_runs_by_id(self, test_id: UUID, runs: list[UUID]):  # FIXME: Not needed, use get_run and individual polling
@@ -108,7 +112,7 @@ class TestRunService:
         run.status = new_status.value
         run.save()
 
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.TestRunStatusChanged,
             body={
                 "message": "Status was changed from {old_status} to {new_status} by {username}",
@@ -136,7 +140,7 @@ class TestRunService:
         run.investigation_status = new_status.value
         run.save()
 
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.TestRunStatusChanged,
             body={
                 "message": "Investigation status was changed from {old_status} to {new_status} by {username}",
@@ -175,7 +179,7 @@ class TestRunService:
                 LOGGER.warning("Non existent assignee was present on the run %s for test %s: %s",
                                run_id, test_id, old_assignee)
                 old_assignee = None
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.AssigneeChanged,
             body={
                 "message": "Assignee was changed from \"{old_user}\" to \"{new_user}\" by {username}",
@@ -244,7 +248,7 @@ class TestRunService:
                 content_params=params
             )
 
-        self.create_run_event(kind=ArgusEventTypes.TestRunCommentPosted, body={
+        EventService.create_run_event(kind=ArgusEventTypes.TestRunCommentPosted, body={
             "message": "A comment was posted by {username}",
             "username": g.user.username
         }, user_id=g.user.id, run_id=run_id, release_id=release.id, test_id=test.id)
@@ -257,7 +261,7 @@ class TestRunService:
             raise Exception("Unable to delete other user comments")
         comment.delete()
 
-        self.create_run_event(kind=ArgusEventTypes.TestRunCommentDeleted, body={
+        EventService.create_run_event(kind=ArgusEventTypes.TestRunCommentDeleted, body={
             "message": "A comment was deleted by {username}",
             "username": g.user.username
         }, user_id=g.user.id, run_id=run_id, release_id=comment.release_id, test_id=test_id)
@@ -273,25 +277,13 @@ class TestRunService:
         comment.mentions = mentions
         comment.save()
 
-        self.create_run_event(kind=ArgusEventTypes.TestRunCommentUpdated, body={
+        EventService.create_run_event(kind=ArgusEventTypes.TestRunCommentUpdated, body={
             "message": "A comment was edited by {username}",
             "username": g.user.username
         }, user_id=g.user.id, run_id=run_id, release_id=comment.release_id, test_id=test_id)
 
         return self.get_run_comments(run_id=run_id)
 
-    def create_run_event(self, kind: ArgusEventTypes, body: dict, user_id=None, run_id=None, release_id=None, group_id=None, test_id=None):
-        event = ArgusEvent()
-        event.release_id = release_id
-        event.group_id = group_id
-        event.test_id = test_id
-        event.user_id = user_id
-        event.run_id = run_id
-        event.body = json.dumps(body, ensure_ascii=True, separators=(',', ':'))
-        event.kind = kind.value
-        event.created_at = datetime.utcnow()
-        event.save()
-
     def get_run_events(self, run_id: UUID):
         response = {}
         all_events = ArgusEvent.filter(run_id=run_id).all()
@@ -358,7 +350,7 @@ class TestRunService:
         new_issue.last_status = issue_state.get("state")
         new_issue.save()
 
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.TestRunIssueAdded,
             body={
                 "message": "An issue titled \"{title}\" was added by {username}",
@@ -409,7 +401,7 @@ class TestRunService:
     def delete_github_issue(self, issue_id: UUID) -> dict:
         issue: ArgusGithubIssue = ArgusGithubIssue.get(id=issue_id)
 
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.TestRunIssueRemoved,
             body={
                 "message": "An issue titled \"{title}\" was removed by {username}",
@@ -448,7 +440,7 @@ class TestRunService:
             run.status = TestStatus.ABORTED.value
             run.save()
 
-            self.create_run_event(
+            EventService.create_run_event(
                 kind=ArgusEventTypes.TestRunStatusChanged,
                 body={
                     "message": "Run was automatically terminated due to not responding for more than 45 minutes "

argus/backend/util/encoders.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+import logging
 from json.encoder import JSONEncoder
 from uuid import UUID
 
@@ -6,6 +7,8 @@ import cassandra.cqlengine.usertype as ut
 import cassandra.cqlengine.models as m
 
 
+LOGGER = logging.getLogger(__name__)
+
 class ArgusJSONEncoder(JSONEncoder):
     def default(self, o):
         match o:

argus/client/driver_matrix_tests/client.py

@@ -16,6 +16,7 @@ from argus.backend.plugins.driver_matrix_tests.raw_types import RawMatrixTestRes
 
 LOGGER = logging.getLogger(__name__)
 
+TestTypeType = Literal['java', 'cpp', 'python', 'gocql']
 
 class AdaptedXUnitData(TypedDict):
     timestamp: str
@@ -52,6 +53,14 @@ def cpp_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
     }
 
 
+def gocql_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    testsuites = list(xml.getroot().iter("testsuite"))
+
+    return {
+        "timestamp": testsuites[0].attrib.get("timestamp"),
+    }
+
+
 def generic_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
     return {
         "timestamp": datetime.utcnow().isoformat()
@@ -66,6 +75,7 @@ class ArgusDriverMatrixClient(ArgusClient):
         "java": java_driver_matrix_adapter,
         "cpp": cpp_driver_matrix_adapter,
         "python": python_driver_matrix_adapter,
+        "gocql": gocql_driver_matrix_adapter,
     }
 
     def __init__(self, run_id: UUID, auth_token: str, base_url: str, api_version="v1") -> None:
@@ -107,8 +117,11 @@ class ArgusDriverMatrixClient(ArgusClient):
 
         return raw_cases
 
-    def get_driver_info(self, xml_name: str) -> dict[str, str]:
-        filename_re = r"(?P<name>[\w]*)\.(?P<driver_name>[\w]*)\.(?P<proto>v\d)\.(?P<version>[\d\.]*)\.xml"
+    def get_driver_info(self, xml_name: str, test_type: TestTypeType) -> dict[str, str]:
+        if test_type == "cpp":
+            filename_re = r"TEST-(?P<driver_name>[\w]*)-(?P<version>[\d\.]*)\.xml"
+        else:
+            filename_re = r"(?P<name>[\w]*)\.(?P<driver_name>[\w]*)\.(?P<proto>v\d)\.(?P<version>[\d\.]*)\.xml"
 
         match = re.match(filename_re, xml_name)
 
@@ -124,14 +137,14 @@ class ArgusDriverMatrixClient(ArgusClient):
 
         return total - errors - skipped - failures
 
-    def parse_result_xml(self, xml_path: Path, test_type:  Literal['java', 'cpp', 'python']) -> RawMatrixTestResult:
+    def parse_result_xml(self, xml_path: Path, test_type:  TestTypeType) -> RawMatrixTestResult:
         with xml_path.open(mode="rt", encoding="utf-8") as xml_file:
             xml = ElementTree.parse(source=xml_file)
             LOGGER.info("%s", pformat(xml))
         testsuites = xml.getroot()
         adapted_data = self.TEST_ADAPTERS.get(test_type, generic_adapter)(xml)
 
-        driver_info = self.get_driver_info(xml_path.name)
+        driver_info = self.get_driver_info(xml_path.name, test_type)
         test_collection = {
             "timestamp": adapted_data["timestamp"],
             "name": xml_path.stem,
@@ -171,7 +184,7 @@ class ArgusDriverMatrixClient(ArgusClient):
             "suites": all_suites
         }
 
-    def get_results(self, result_path: str, test_type: Literal['java', 'cpp', 'python']) -> list[RawMatrixTestResult]:
+    def get_results(self, result_path: str, test_type: TestTypeType) -> list[RawMatrixTestResult]:
         xmls = glob(f"{result_path}/**/*.xml", recursive=True)
         LOGGER.info("Will use following XMLs: %s", pformat(xmls))
         results = []
@@ -180,7 +193,7 @@ class ArgusDriverMatrixClient(ArgusClient):
             results.append(result)
         return results
 
-    def submit(self, build_id: str, build_url: str, env_path: str, result_path: str, test_type: Literal['java', 'cpp', 'python']):
+    def submit(self, build_id: str, build_url: str, env_path: str, result_path: str, test_type: TestTypeType):
         env = self.parse_build_environment(env_path)
         results = self.get_results(result_path, test_type)
 

argus/client/sct/client.py

@@ -1,5 +1,6 @@
 from uuid import UUID
 from dataclasses import asdict
+from argus.backend.plugins.sct.types import GeminiResultsRequest, PerformanceResultsRequest
 from argus.backend.util.enums import ResourceState, TestStatus
 from argus.client.base import ArgusClient
 from argus.client.sct.types import EventsInfo, LogLink, Package
@@ -17,6 +18,8 @@ class ArgusSCTClient(ArgusClient):
         SET_SCT_RUNNER  = "/sct/$id/sct_runner/set"
         UPDATE_SHARDS_FOR_RESOURCE = "/sct/$id/resource/$name/shards"
         SUBMIT_NEMESIS = "/sct/$id/nemesis/submit"
+        SUBMIT_GEMINI_RESULTS = "/sct/$id/gemini/submit"
+        SUBMIT_PERFORMANCE_RESULTS = "/sct/$id/performance/submit"
         FINALIZE_NEMESIS = "/sct/$id/nemesis/finalize"
         SUBMIT_EVENTS = "/sct/$id/events/submit"
 
@@ -113,6 +116,34 @@ class ArgusSCTClient(ArgusClient):
         )
         self.check_response(response)
 
+    def submit_gemini_results(self, gemini_data: GeminiResultsRequest) -> None:
+        """
+            Submits gemini results such as oracle node information and gemini command & its results
+        """
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_GEMINI_RESULTS,
+            location_params={"id": str(self.run_id)},
+            body={
+                **self.generic_body,
+                "gemini_data": gemini_data,
+            }
+        )
+        self.check_response(response)
+
+    def submit_performance_results(self, performance_results: PerformanceResultsRequest) -> None:
+        """
+            Submits results of a performance run. Things such as throughput stats, overall and per op
+        """
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_PERFORMANCE_RESULTS,
+            location_params={"id": str(self.run_id)},
+            body={
+                **self.generic_body,
+                "performance_results": performance_results,
+            }
+        )
+        self.check_response(response)
+
     def create_resource(self, name: str, resource_type: str, public_ip: str, private_ip: str,
                         region: str, provider: str, shards_amount: int, state=ResourceState.RUNNING) -> None:
         """

{argus_alm-0.11.4.dist-info → argus_alm-0.11.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: argus-alm
-Version: 0.11.4
+Version: 0.11.6
 Summary: Argus
 Home-page: https://github.com/scylladb/argus
 License: Apache-2.0

{argus_alm-0.11.4.dist-info → argus_alm-0.11.6.dist-info}/RECORD

@@ -22,42 +22,44 @@ argus/backend/models/web.py,sha256=E85BcV3ESTTweYmNrFSG9hDYDIuaTLlnbZul2J8sPQg,1
 argus/backend/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/plugins/core.py,sha256=CYwYz5BMQRZdqGXFKoiIi_AEKMunBSyE8zCXmYarjGI,7427
 argus/backend/plugins/driver_matrix_tests/controller.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-argus/backend/plugins/driver_matrix_tests/model.py,sha256=GbxQLkQHrKxZDip8Uw658Jt16_V6h9Mg-CWHkFbAZq8,5590
+argus/backend/plugins/driver_matrix_tests/model.py,sha256=VAX2JADA5l97IQu1p3ojqsxNoX6e--CgZtvd8Ynp3yE,5755
 argus/backend/plugins/driver_matrix_tests/plugin.py,sha256=NZN6lpHFpNuBkv2D_gGHh03402z0qlOeCWjgZXRs2c4,637
 argus/backend/plugins/driver_matrix_tests/raw_types.py,sha256=A108HCnv5q0RHfNRhUJrTpRy3fG7sPxr9Sk4gfsbooU,600
 argus/backend/plugins/driver_matrix_tests/udt.py,sha256=6lydzF3AQHm3GR5bKEDu1xLPYsLaBL3o-wu9NpabbqA,1134
 argus/backend/plugins/loader.py,sha256=0MmGNBVle51tIyH7lA7Lz2L8PcGKGub9vyFuwnLm840,1320
-argus/backend/plugins/sct/controller.py,sha256=voMvNl-JcfSJV-ghO-HyFXu4LxF1C3Mj1YGjcLhq_h8,3825
-argus/backend/plugins/sct/plugin.py,sha256=-ezQ7brAdgQ_YJpZiCaVBNuzP91FtBiKWf_IXy70xgg,902
+argus/backend/plugins/sct/controller.py,sha256=ek4gNiraDzd81QMpHKCzpugUSkwbXCHKAPsjD9ol6CE,4791
+argus/backend/plugins/sct/plugin.py,sha256=3TlX5NAd7bv4aMI9FJNJLkf8o2bcahZhZobAV4xAbzU,965
 argus/backend/plugins/sct/resource_setup.py,sha256=hwfAOu-oKOH42tjtzJhiqwq_MtUE9_HevoFyql8JKqY,10120
-argus/backend/plugins/sct/service.py,sha256=gttLbYRMNoR5_zj9gbcqVGAxXKh_ZGjBMXW2Ix23m6I,9368
-argus/backend/plugins/sct/testrun.py,sha256=2MAb6zlGE1cGMGlhyq7iHhaLIuhJjlibHtjqhO7Zr1Q,6302
-argus/backend/plugins/sct/udt.py,sha256=j1Q7sidzYXxP8ELkkaT-YeJqhe7qixNU9tbNuzLQ5_8,2420
+argus/backend/plugins/sct/service.py,sha256=VR9fEwc43Y9nFW9__Lvbm613VIb1lp5Y3P3dXm-LwRk,17618
+argus/backend/plugins/sct/testrun.py,sha256=-ulaIZ1Dn-umx3LAJOzZkF3C_3JNQLncbsLCCf7Y7ks,8931
+argus/backend/plugins/sct/types.py,sha256=avLL3fzug_n6GbtlW8bcPewcDGi1DxHFD0vp-JZ7hdQ,969
+argus/backend/plugins/sct/udt.py,sha256=KVVkzaiEeyKs2ntFjXQ6BpoBjX4kLuSK-csgIVyNK00,2819
 argus/backend/plugins/sirenada/model.py,sha256=npKs6GurFXgddOVEiD5hmPwCPi7RPAi9HFs-3s99C8w,4661
 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=3mASrrGXMoZ26zSNkUPpqR84HH9RCI3m9Ag3LV7idPc,24127
-argus/backend/service/build_system_monitor.py,sha256=ODxU2LxqJPOqU0r0sDSkxk73ZXjlaYngsJeXg4m-O5c,6586
+argus/backend/service/build_system_monitor.py,sha256=_Bxugk4CCh2z-I-i74QMPe7M8j0dmBMDri2dd3WGVew,7328
 argus/backend/service/client_service.py,sha256=_eH-sq8507oKXXtMFDAg2kUc445qQucr2fC6pKbmjZc,2290
+argus/backend/service/event_service.py,sha256=iYeqxN2QCYTjYB1WPPv4BEFLXG0Oz3TvskkaK4v9pVY,654
 argus/backend/service/notification_manager.py,sha256=h00Ej_-hH9H7pq0wah_1TH8dnpPyPNsgVJNO1rwJi7o,7011
 argus/backend/service/release_manager.py,sha256=v2yg45oWBpK_uwqkHtJHPTPbe21_cJu3skmzeaChVhw,6259
-argus/backend/service/stats.py,sha256=R8krmGi2RsOBSV3ZHDS9crkXSogiPqSnDE2LRYy3APs,12274
+argus/backend/service/stats.py,sha256=FjVmpHTNwRFOC79pzu8gz49yM8lUwcroTfjzCq0laiY,14102
 argus/backend/service/team_manager_service.py,sha256=zY5dvy3ffvQbJuXBvlWKE5dS5LQ3ss6tkFE-cwFZsdw,3010
-argus/backend/service/testrun.py,sha256=dNwR6REYtNd3cYVteqsB9qCSLwsMN2bVkZLN19I4llI,19878
+argus/backend/service/testrun.py,sha256=p0vRGkQYEsDxWzi0JLH-l8ijDyDcmMNeallMk5VrOds,19699
 argus/backend/service/user.py,sha256=N3t43rgKMnSsPXU5R9bigEEGbPjYrc6MsJtof3z7kDE,9027
 argus/backend/template_filters.py,sha256=hD8eDyBYp-X6JVoyQhM-TWYv3MuyorAv0Emz728iGcU,523
 argus/backend/util/common.py,sha256=fmE9cKnJ1CX_Cz4Mw1d_M-T-jwPh8DkKr_fLAx8LY9M,1458
 argus/backend/util/config.py,sha256=Sm0LCRkabYaSUkXNPglyjMr45GCDBNXqJLkmB_s51f0,860
-argus/backend/util/encoders.py,sha256=WWu9BWirOfTE7tsrm_8yx_4WeUXlZeMrO0FFMwkH2wQ,596
+argus/backend/util/encoders.py,sha256=xL4nwA6ByhIo4Zv8mFT0WP-KkVAQ5Cv3SSb-TISpfu8,649
 argus/backend/util/enums.py,sha256=ASL-mqhEtjBKAB-5YDSvGXe7amKjiVv0Q-Gf6eJNbUM,719
 argus/backend/util/logsetup.py,sha256=XWyFLC1_J5G8NcR7oC9l-Pf02ybAvEZR95y5LoY4W48,2438
 argus/backend/util/module_loaders.py,sha256=AcIlX-VRmUQ2THFKT8DLefLSE62Eub2hCxIosg3WgE0,698
 argus/backend/util/send_email.py,sha256=Bb2Hta7WlBCvDKga0_WPFWgxWJEfKpectOGypgf9xzo,3217
 argus/client/__init__.py,sha256=bO9_j5_jK5kvTHR46KEZ0Y-p0li7CBW8QSd-K5Ez4vA,42
 argus/client/base.py,sha256=WHYDUSFhhvAyzU3pKPohlsKifxwifx0vWA42VoAha9M,6676
-argus/client/driver_matrix_tests/client.py,sha256=hGChqp1Z8Z7aoG9IGsGdLtr4o-quBfkimXGJ20bdZVE,7369
-argus/client/sct/client.py,sha256=4se4wigNGDepEAMNeDg8GfpS6zadOSra09bfX8uNG8w,8675
+argus/client/driver_matrix_tests/client.py,sha256=3LIS2hwZ3wVKtQDEMiQGBsIoIcpKi29chheF_yRM704,7800
+argus/client/sct/client.py,sha256=GFBRCcwDeLaSvmC6Y6d5DA0prFbk7QOyGl4bvNAz0E8,9946
 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
@@ -68,7 +70,7 @@ 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.11.4.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-argus_alm-0.11.4.dist-info/METADATA,sha256=cgb7-Q4PO9uiL0kjWPIn09uc5FMTcFqyLV1MlmvVTD4,6824
-argus_alm-0.11.4.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-argus_alm-0.11.4.dist-info/RECORD,,
+argus_alm-0.11.6.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+argus_alm-0.11.6.dist-info/METADATA,sha256=IvmrSAERJd5cqZ2Dq-1fgMqNl-LyVbXQr7iLUJuzr_I,6824
+argus_alm-0.11.6.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+argus_alm-0.11.6.dist-info/RECORD,,

{argus_alm-0.11.4.dist-info → argus_alm-0.11.6.dist-info}/WHEEL

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