argus-alm 0.12.7__py3-none-any.whl → 0.12.9__py3-none-any.whl

argus/backend/cli.py

@@ -15,6 +15,9 @@ LOGGER = logging.getLogger(__name__)
 @click.command('sync-models')
 @with_appcontext
 def sync_models_command():
+    sync_models()
+
+def sync_models():
     cluster = ScyllaCluster.get()
     cluster.sync_core_tables()
     LOGGER.info("Synchronizing plugin types...")
@@ -29,7 +32,6 @@ def sync_models_command():
     LOGGER.info("Plugins ready.")
     click.echo("All models synchronized.")
 
-
 @cli_bp.cli.add_command
 @click.command('scan-jenkins')
 @with_appcontext

argus/backend/controller/api.py

@@ -4,7 +4,7 @@ import requests
 from flask import (
     Blueprint,
     g,
-    request
+    request, Response
 )
 from flask.json import jsonify
 from argus.backend.error_handlers import handle_api_exception
@@ -382,18 +382,21 @@ def test_info():
         "response": info
     }
 
-@bp.route("/test-results", methods=["GET"])
+@bp.route("/test-results", methods=["GET", "HEAD"])
 @api_login_required
 def test_results():
     test_id = request.args.get("testId")
     if not test_id:
         raise Exception("No testId provided")
     service = ResultsService()
-    info = service.get_results(test_id=UUID(test_id))
+    if request.method == 'HEAD':
+        exists = service.is_results_exist(test_id=UUID(test_id))
+        return Response(status=200 if exists else 404)
+    graphs, ticks = service.get_test_graphs(test_id=UUID(test_id))
 
     return {
         "status": "ok",
-        "response": info
+        "response": {"graphs": graphs, "ticks": ticks}
     }
 
 @bp.route("/test_run/comment/get", methods=["GET"])  # TODO: remove

argus/backend/controller/client_api.py

@@ -105,8 +105,4 @@ def run_finalize(run_type: str, run_id: str):
 @api_login_required
 def submit_results(run_type: str, run_id: str):
     payload = get_payload(request)
-    result = ClientService().submit_results(run_type=run_type, run_id=run_id, results=payload)
-    return {
-        "status": "ok",
-        "response": result
-    }
+    return ClientService().submit_results(run_type=run_type, run_id=run_id, results=payload)

argus/backend/controller/testrun_api.py

@@ -8,6 +8,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.results_service import ResultsService
 from argus.backend.service.testrun import TestRunService
 from argus.backend.service.user import api_login_required
 from argus.backend.util.common import get_payload
@@ -67,7 +68,7 @@ def test_run_activity(run_id: str):
 @bp.route("/run/<string:test_id>/<string:run_id>/fetch_results", methods=["GET"])
 @api_login_required
 def fetch_results(test_id: str, run_id: str):
-    tables = TestRunService().fetch_results(test_id=UUID(test_id), run_id=UUID(run_id))
+    tables = ResultsService().get_run_results(test_id=UUID(test_id), run_id=UUID(run_id))
     return {
         "status": "ok",
         "tables": tables

argus/backend/db.py

@@ -54,7 +54,7 @@ class ScyllaCluster:
         return self.cluster.connect(keyspace=self.config["SCYLLA_KEYSPACE_NAME"])
 
     @classmethod
-    def get(cls, config: Config = None) -> 'ScyllaCluster':
+    def get(cls, config: dict = None) -> 'ScyllaCluster':
         if cls.APP_INSTANCE:
             return cls.APP_INSTANCE
 

argus/backend/models/result.py

@@ -1,19 +1,21 @@
+import math
+from datetime import datetime, timezone
+
 from cassandra.cqlengine import columns
 from cassandra.cqlengine.models import Model
 from cassandra.cqlengine.usertype import UserType
-from enum import Enum
-
-
-class Status(Enum):
-    PASS = 0
-    WARNING = 1
-    ERROR = 2
 
+class ValidationRules(UserType):
+    valid_from = columns.DateTime()
+    best_pct = columns.Double()  # max value limit relative to best result in percent unit
+    best_abs = columns.Double()  # max value limit relative to best result in absolute unit
+    fixed_limit = columns.Double()  # fixed limit
 
 class ColumnMetadata(UserType):
     name = columns.Ascii()
     unit = columns.Text()
     type = columns.Ascii()
+    higher_is_better = columns.Boolean()  # used for tracking best results, if None - no tracking
 
 
 class ArgusGenericResultMetadata(Model):
@@ -22,13 +24,68 @@ class ArgusGenericResultMetadata(Model):
     name = columns.Text(required=True, primary_key=True)
     description = columns.Text()
     columns_meta = columns.List(value_type=columns.UserDefinedType(ColumnMetadata))
+    validation_rules = columns.Map(key_type=columns.Ascii(), value_type=columns.List(columns.UserDefinedType(ValidationRules)))
     rows_meta = columns.List(value_type=columns.Ascii())
 
     def __init__(self, **kwargs):
         kwargs["columns_meta"] = [ColumnMetadata(**col) for col in kwargs.pop('columns_meta', [])]
+        validation_rules = kwargs.pop('validation_rules', {})
+
+        if validation_rules:
+            for column, rule in validation_rules.items():
+                if not isinstance(rule, list):
+                    rule['valid_from'] = datetime.now(timezone.utc)
+                    validation_rules[column] = [rule]
+            kwargs["validation_rules"] = {k: [ValidationRules(**rules) for rules in v] for k, v in validation_rules.items()}
         super().__init__(**kwargs)
 
-    def update_if_changed(self, new_data: dict) -> None:
+    def update_validation_rules(self, key: str, new_rule_dict: dict) -> bool:
+        """
+        Checks if the most recent ValidationRule for the given key matches the new_rule_dict.
+        If not, adds the new rule to the list with the current timestamp.
+
+        :param key: The key (column name) in the validation_rules map to update.
+        :param new_rule_dict: A dictionary containing the new validation rule values.
+        :return: True if a new rule was added, False if the existing rule matches.
+        """
+        rules_list = self.validation_rules.get(key, [])
+        most_recent_rule = None
+
+        if rules_list:
+            most_recent_rule = rules_list[-1]
+
+        fields_to_compare = [field for field in ValidationRules._fields if field != 'valid_from']
+        rules_match = True
+        if most_recent_rule:
+            for field in fields_to_compare:
+                db_value = getattr(most_recent_rule, field)
+                new_value = new_rule_dict.get(field)
+                if db_value is None and new_value is None:
+                    continue
+                if db_value is None or new_value is None:
+                    rules_match = False
+                    break
+                if not math.isclose(db_value, new_value, rel_tol=1e-9, abs_tol=0.0):
+                    rules_match = False
+                    break
+        else:
+            rules_match = False
+
+        if not rules_match:
+            new_rule = ValidationRules(
+                valid_from=datetime.now(timezone.utc),
+                best_pct=new_rule_dict.get('best_pct'),
+                best_abs=new_rule_dict.get('best_abs'),
+                fixed_limit=new_rule_dict.get('fixed_limit')
+            )
+            rules_list.append(new_rule)
+            self.validation_rules = self.validation_rules or {}
+            self.validation_rules.update({key: rules_list})
+            return True
+
+        return False  # Existing rule matches
+
+    def update_if_changed(self, new_data: dict) -> "ArgusGenericResultMetadata":
         """
         Updates table metadata if changed column/description or new rows were added.
         See that rows can only be added, not removed once was sent.
@@ -38,18 +95,26 @@ class ArgusGenericResultMetadata(Model):
         for field, value in new_data.items():
             if field == "columns_meta":
                 value = [ColumnMetadata(**col) for col in value]
+                if self.columns_meta != value:
+                    self.columns_meta = value
+                    updated = True
             elif field == "rows_meta":
                 added_rows = []
                 for row in value:
                     if row not in self.rows_meta:
                         added_rows.append(row)
-                value = self.rows_meta + added_rows
-            if getattr(self, field) != value:
+                        updated = True
+                self.rows_meta += added_rows
+            elif field == "validation_rules":
+                if any([self.update_validation_rules(key, rules) for key, rules in value.items()]):
+                    updated = True
+            elif getattr(self, field) != value:
                 setattr(self, field, value)
                 updated = True
 
         if updated:
             self.save()
+        return self
 
 class ArgusGenericResultData(Model):
     __table_name__ = "generic_result_data_v1"
@@ -60,4 +125,14 @@ class ArgusGenericResultData(Model):
     row = columns.Ascii(primary_key=True, index=True)
     sut_timestamp = columns.DateTime()  # for sorting
     value = columns.Double()
+    value_text = columns.Text()
     status = columns.Ascii()
+
+class ArgusBestResultData(Model):
+    __table_name__ = "generic_result_best_v1"
+    test_id = columns.UUID(partition_key=True)
+    name = columns.Text(partition_key=True)
+    key = columns.Ascii(primary_key=True)  # represents pair column:row
+    result_date = columns.DateTime(primary_key=True, clustering_order="DESC")
+    value = columns.Double()
+    run_id = columns.UUID()

argus/backend/models/web.py

@@ -6,7 +6,7 @@ from cassandra.cqlengine.usertype import UserType
 from cassandra.cqlengine import columns
 from cassandra.util import uuid_from_time, unix_time_from_uuid1  # pylint: disable=no-name-in-module
 
-from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData, ArgusBestResultData
 
 
 def uuid_now():
@@ -381,6 +381,7 @@ USED_MODELS: list[Model] = [
     ArgusScheduleTest,
     ArgusGenericResultMetadata,
     ArgusGenericResultData,
+    ArgusBestResultData,
 ]
 
 USED_TYPES: list[UserType] = [

argus/backend/plugins/loader.py

@@ -30,7 +30,7 @@ def plugin_loader() -> dict[str, PluginInfoBase]:
 
 
 AVAILABLE_PLUGINS = plugin_loader()
-
+print(AVAILABLE_PLUGINS)
 
 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]

argus/backend/plugins/sct/testrun.py

@@ -1,6 +1,6 @@
 from enum import Enum
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 from dataclasses import dataclass, field
 from typing import Optional
 from uuid import UUID
@@ -254,8 +254,15 @@ class SCTTestRun(PluginModelBase):
     def sut_timestamp(self) -> float:
         """converts scylla-server date to timestamp and adds revision in subseconds precision to diffirentiate
         scylla versions from the same day. It's not perfect, but we don't know exact version time."""
-        scylla_package = [package for package in self.packages if package.name == "scylla-server"][0]
-        return (datetime.strptime(scylla_package.date, '%Y%m%d').timestamp()
+        try:
+            scylla_package_upgraded = [package for package in self.packages if package.name == "scylla-server-upgraded"][0]
+        except IndexError:
+            scylla_package_upgraded = None
+        try:
+            scylla_package = [package for package in self.packages if package.name == "scylla-server"][0]
+        except IndexError:
+            raise ValueError("Scylla package not found in packages - cannot determine SUT timestamp")
+        return (datetime.strptime(scylla_package.date, '%Y%m%d').replace(tzinfo=timezone.utc).timestamp()
                 + int(scylla_package.revision_id, 16) % 1000000 / 1000000)
 
 

argus/backend/service/client_service.py

@@ -1,8 +1,14 @@
+import operator
+from dataclasses import asdict, is_dataclass
+from datetime import datetime, timezone
+from functools import partial
 from uuid import UUID
+
 from argus.backend.db import ScyllaCluster
 from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
 from argus.backend.plugins.core import PluginModelBase
 from argus.backend.plugins.loader import AVAILABLE_PLUGINS
+from argus.backend.service.results_service import ResultsService, Cell
 from argus.backend.util.enums import TestStatus
 
 
@@ -25,8 +31,9 @@ class ClientService:
     def submit_run(self, run_type: str, request_data: dict) -> str:
         model = self.get_model(run_type)
         model.submit_run(request_data=request_data)
+
         return "Created"
-    
+
     def get_run(self, run_type: str, run_id: str):
         model = self.get_model(run_type)
         try:
@@ -79,23 +86,37 @@ class ClientService:
 
         return "Finalized"
 
-    def submit_results(self, run_type: str, run_id: str, results: dict) -> str:
+    def submit_results(self, run_type: str, run_id: str, results: dict) -> dict[str, str]:
         model = self.get_model(run_type)
-        run = model.load_test_run(UUID(run_id))
-        existing_table = ArgusGenericResultMetadata.objects(test_id=run.test_id, name=results["meta"]["name"]).first()
-        if existing_table:
-            existing_table.update_if_changed(results["meta"])
+        try:
+            run = model.load_test_run(UUID(run_id))
+        except model.DoesNotExist:
+            return {"status": "error", "response": {
+                "exception": "DoesNotExist",
+                "arguments": [run_id]
+            }}
+        table_name = results["meta"]["name"]
+        results_service = ResultsService()
+        cells = [Cell(**cell) for cell in results["results"]]
+        table_metadata = results_service.get_table_metadata(test_id=run.test_id, table_name=table_name)
+        if table_metadata:
+            table_metadata = table_metadata.update_if_changed(results["meta"])
         else:
-            ArgusGenericResultMetadata(test_id=run.test_id, **results["meta"]).save()
+            table_metadata = ArgusGenericResultMetadata(test_id=run.test_id, **results["meta"])
+            table_metadata.save()
         if results.get("sut_timestamp", 0) == 0:
             results["sut_timestamp"] = run.sut_timestamp()  # automatic sut_timestamp
+        results["sut_timestamp"] = datetime.fromtimestamp(results["sut_timestamp"])
+        best_results = results_service.update_best_results(test_id=run.test_id, table_name=table_name, table_metadata=table_metadata,
+                                                           cells=cells, run_id=run_id)
         table_name = results["meta"]["name"]
         sut_timestamp = results["sut_timestamp"]
-        for cell in results["results"]:
+        for cell in cells:
+            cell.update_cell_status_based_on_rules(table_metadata, best_results)
             ArgusGenericResultData(test_id=run.test_id,
                                    run_id=run.id,
                                    name=table_name,
                                    sut_timestamp=sut_timestamp,
-                                   **cell
+                                   **asdict(cell)
                                    ).save()
-        return "Submitted"
+        return {"status": "ok", "message": "Results submitted"}

argus/backend/service/notification_manager.py

@@ -93,7 +93,8 @@ class NotificationSenderBase:
 
 class ArgusDBNotificationSaver(NotificationSenderBase):
     CONTENT_TEMPLATES = {
-        ArgusNotificationTypes.Mention: lambda p: render_template("notifications/mention.html.j2", **p if p else {})
+        ArgusNotificationTypes.Mention: lambda p: render_template("notifications/mention.html.j2", **p if p else {}),
+        ArgusNotificationTypes.AssigneeChange: lambda p: render_template("notifications/assigned.html.j2", **p if p else {}),
     }
 
     def send_notification(self, receiver: UUID, sender: UUID, notification_type: ArgusNotificationTypes, source_type: ArgusNotificationSourceTypes,
@@ -117,7 +118,8 @@ class ArgusDBNotificationSaver(NotificationSenderBase):
 class EmailNotificationServiceSender(NotificationSenderBase):
     CONTENT_TEMPLATES = {
         ArgusNotificationTypes.Mention: lambda p: render_template(
-            "notifications/email_mention.html.j2", **p if p else {})
+            "notifications/email_mention.html.j2", **p if p else {}),
+        ArgusNotificationTypes.AssigneeChange: lambda p: render_template("notifications/assigned_email.html.j2", **p if p else {}),
     }
 
     def __init__(self):

argus/backend/service/results_service.py

@@ -1,14 +1,61 @@
 import copy
 import logging
 import math
+import operator
+from datetime import datetime, timezone
+from functools import partial
 from typing import List, Dict, Any
 from uuid import UUID
 
+from dataclasses import dataclass
 from argus.backend.db import ScyllaCluster
-from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData, ArgusBestResultData
 
 LOGGER = logging.getLogger(__name__)
 
+
+@dataclass
+class BestResult:
+    key: str
+    value: float
+    result_date: datetime
+    run_id: str
+
+
+@dataclass
+class Cell:
+    column: str
+    row: str
+    status: str
+    value: Any | None = None
+    value_text: str | None = None
+
+    def update_cell_status_based_on_rules(self, table_metadata: ArgusGenericResultMetadata, best_results: dict[str, BestResult],
+                                          ) -> None:
+        column_validation_rules = table_metadata.validation_rules.get(self.column)
+        rules = column_validation_rules[-1] if column_validation_rules else {}
+        higher_is_better = next((col.higher_is_better for col in table_metadata.columns_meta if col.name == self.column), None)
+        if not rules or self.status != "UNSET" or higher_is_better is None:
+            return
+        is_better = partial(operator.gt, self.value) if higher_is_better else partial(operator.lt, self.value)
+        key = f"{self.column}:{self.row}"
+        limits = []
+        if rules.fixed_limit is not None:
+            limits.append(rules.fixed_limit)
+
+        if best_result := best_results.get(key):
+            best_value = best_result.value
+            if (best_pct := rules.best_pct) is not None:
+                multiplier = 1 - best_pct / 100 if higher_is_better else 1 + best_pct / 100
+                limits.append(best_value * multiplier)
+            if (best_abs := rules.best_abs) is not None:
+                limits.append(best_value - best_abs if higher_is_better else best_value + best_abs)
+        if all(is_better(limit) for limit in limits):
+            self.status = "PASS"
+        else:
+            self.status = "ERROR"
+
+
 default_options = {
     "scales": {
         "y": {
@@ -67,12 +114,12 @@ colors = [
 ]
 
 
-def get_sorted_data_for_column_and_row(data: List[Dict[str, Any]], column: str, row: str) -> List[Dict[str, Any]]:
+def get_sorted_data_for_column_and_row(data: List[ArgusGenericResultData], column: str, row: str) -> List[Dict[str, Any]]:
     return sorted([{"x": entry.sut_timestamp.strftime('%Y-%m-%dT%H:%M:%SZ'),
                     "y": entry.value,
                     "id": entry.run_id}
-                   for entry in data if entry['column'] == column and entry['row'] == row],
-                  key=lambda x: x['x'])
+                   for entry in data if entry.column == column and entry.row == row],
+                  key=lambda point: point["x"])
 
 
 def get_min_max_y(datasets: List[Dict[str, Any]]) -> (float, float):
@@ -105,6 +152,9 @@ def round_datasets_to_min_max(datasets: List[Dict[str, Any]], min_y: float, max_
 def create_chartjs(table, data):
     graphs = []
     for column in table.columns_meta:
+        if column.type == "TEXT":
+            # skip text columns
+            continue
         datasets = [
             {"label": row,
              "borderColor": colors[idx % len(colors)],
@@ -118,7 +168,7 @@ def create_chartjs(table, data):
             continue
         options = copy.deepcopy(default_options)
         options["plugins"]["title"]["text"] = f"{table.name} - {column.name}"
-        options["scales"]["y"]["title"]["text"] = f"[{column.unit}]"
+        options["scales"]["y"]["title"]["text"] = f"[{column.unit}]" if column.unit else ""
         options["scales"]["y"]["min"] = min_y
         options["scales"]["y"]["max"] = max_y
         graphs.append({"options": options, "data":
@@ -126,15 +176,142 @@ def create_chartjs(table, data):
     return graphs
 
 
+def calculate_graph_ticks(graphs: List[Dict]) -> dict[str, str]:
+    min_x, max_x = None, None
+
+    for graph in graphs:
+        for dataset in graph["data"]["datasets"]:
+            if not dataset["data"]:
+                continue
+            first_x = dataset["data"][0]["x"]
+            last_x = dataset["data"][-1]["x"]
+            if min_x is None or first_x < min_x:
+                min_x = first_x
+            if max_x is None or last_x > max_x:
+                max_x = last_x
+    return {"min": min_x[:10], "max": max_x[:10]}
+
+
 class ResultsService:
 
-    def __init__(self, database_session=None):
-        self.session = database_session if database_session else ScyllaCluster.get_session()
+    def __init__(self):
+        self.cluster = ScyllaCluster.get()
 
-    def get_results(self, test_id: UUID):
+    def _get_tables_metadata(self, test_id: UUID) -> list[ArgusGenericResultMetadata]:
+        query_fields = ["name", "description", "columns_meta", "rows_meta"]
+        raw_query = (f"SELECT {','.join(query_fields)}"
+                     f" FROM generic_result_metadata_v1 WHERE test_id = ?")
+        query = self.cluster.prepare(raw_query)
+        tables_meta = self.cluster.session.execute(query=query, parameters=(test_id,))
+        return [ArgusGenericResultMetadata(**table) for table in tables_meta]
+
+    def get_table_metadata(self, test_id: UUID, table_name: str) -> ArgusGenericResultMetadata:
+        raw_query = ("SELECT * FROM generic_result_metadata_v1 WHERE test_id = ? AND name = ?")
+        query = self.cluster.prepare(raw_query)
+        table_meta = self.cluster.session.execute(query=query, parameters=(test_id, table_name))
+        return [ArgusGenericResultMetadata(**table) for table in table_meta][0] if table_meta else None
+
+    def get_run_results(self, test_id: UUID, run_id: UUID) -> list[dict]:
+        query_fields = ["column", "row", "value", "value_text", "status"]
+        raw_query = (f"SELECT {','.join(query_fields)},WRITETIME(status) as ordering"
+                     f" FROM generic_result_data_v1 WHERE test_id = ? AND run_id = ? AND name = ?")
+        query = self.cluster.prepare(raw_query)
+        tables_meta = self._get_tables_metadata(test_id=test_id)
+        tables = []
+        for table in tables_meta:
+            cells = self.cluster.session.execute(query=query, parameters=(test_id, run_id, table.name))
+            if not cells:
+                continue
+            cells = [dict(cell.items()) for cell in cells]
+            tables.append({'meta': {
+                'name': table.name,
+                'description': table.description,
+                'columns_meta': table.columns_meta,
+                'rows_meta': table.rows_meta,
+            },
+                'cells': [{k: v for k, v in cell.items() if k in query_fields} for cell in cells],
+                'order': min([cell['ordering'] for cell in cells] or [0])})
+        return sorted(tables, key=lambda x: x['order'])
+
+    def get_test_graphs(self, test_id: UUID):
+        query_fields = ["run_id", "column", "row", "value", "status", "sut_timestamp"]
+        raw_query = (f"SELECT {','.join(query_fields)}"
+                     f" FROM generic_result_data_v1 WHERE test_id = ? AND name = ? LIMIT 2147483647")
+        query = self.cluster.prepare(raw_query)
+        tables_meta = self._get_tables_metadata(test_id=test_id)
         graphs = []
-        res = ArgusGenericResultMetadata.objects(test_id=test_id).all()
-        for table in res:
-            data = ArgusGenericResultData.objects(test_id=test_id, name=table.name).all()
+        for table in tables_meta:
+            data = self.cluster.session.execute(query=query, parameters=(test_id, table.name))
+            data = [ArgusGenericResultData(**cell) for cell in data]
+            if not data:
+                continue
             graphs.extend(create_chartjs(table, data))
-        return graphs
+        ticks = calculate_graph_ticks(graphs)
+        return graphs, ticks
+
+    def is_results_exist(self, test_id: UUID):
+        """Verify if results for given test id exist at all."""
+        return bool(ArgusGenericResultMetadata.objects(test_id=test_id).only(["name"]).limit(1))
+
+    def get_best_results(self, test_id: UUID, name: str) -> List[BestResult]:
+        query_fields = ["key", "value", "result_date", "run_id"]
+        raw_query = (f"SELECT {','.join(query_fields)}"
+                     f" FROM generic_result_best_v1 WHERE test_id = ? and name = ?")
+        query = self.cluster.prepare(raw_query)
+        best_results = self.cluster.session.execute(query=query, parameters=(test_id, name))
+        return [BestResult(**best) for best in best_results]
+
+    @staticmethod
+    def _update_best_value(best_results: dict[str, list[dict]], higher_is_better_map: dict[str, bool | None], cells: list[dict],
+                           sut_timestamp: float, run_id: str
+                           ) -> dict[str, list[dict]]:
+
+        for cell in cells:
+            if "column" not in cell or "row" not in cell or "value" not in cell:
+                continue
+            column, row, value = cell["column"], cell["row"], cell["value"]
+            key_name = f"{column}_{row}"
+            if higher_is_better_map[column] is None:
+                # skipping updating best value when higher_is_better is not set (not enabled by user)
+                return best_results
+            if key_name not in best_results:
+                best_results[key_name] = []
+                current_best = None
+            else:
+                current_best = best_results[key_name][-1]
+                if current_best["sut_timestamp"].timestamp() > sut_timestamp:
+                    # skip updating best value when testing older version than current best
+                    # as would have to update all values between these dates to make cells statuses to be consistent
+                    return best_results
+
+            is_better = partial(operator.gt, value) if higher_is_better_map[column] else partial(operator.lt, value)
+            if current_best is None or is_better(current_best["value"]):
+                best_results[key_name].append({"sut_timestamp": sut_timestamp, "value": value, "run_id": run_id})
+        return best_results
+
+    def update_best_results(self, test_id: UUID, table_name: str, cells: list[Cell],
+                            table_metadata: ArgusGenericResultMetadata, run_id: str) -> dict[str, BestResult]:
+        """update best results for given test_id and table_name based on cells values - if any value is better than current best"""
+        higher_is_better_map = {meta["name"]: meta.higher_is_better for meta in table_metadata.columns_meta}
+        best_results = {}
+        for best in self.get_best_results(test_id=test_id, name=table_name):
+            if best.key not in best_results:
+                best_results[best.key] = best
+
+        for cell in cells:
+            if cell.value is None:
+                # textual value, skip
+                continue
+            key = f"{cell.column}:{cell.row}"
+            if higher_is_better_map[cell.column] is None:
+                # skipping updating best value when higher_is_better is not set (not enabled by user)
+                continue
+            current_best = best_results.get(key)
+            is_better = partial(operator.gt, cell.value) if higher_is_better_map[cell.column] \
+                else partial(operator.lt, cell.value)
+            if current_best is None or is_better(current_best.value):
+                result_date = datetime.now(timezone.utc)
+                best_results[key] = BestResult(key=key, value=cell.value, result_date=result_date, run_id=run_id)
+                ArgusBestResultData(test_id=test_id, name=table_name, key=key, value=cell.value, result_date=result_date,
+                                    run_id=run_id).save()
+        return best_results

argus/backend/service/testrun.py

@@ -203,6 +203,22 @@ class TestRunService:
             group_id=test.group_id,
             test_id=test.id
         )
+        if new_assignee_user.id != g.user.id:
+            self.notification_manager.send_notification(
+                receiver=new_assignee_user.id,
+                sender=g.user.id,
+                notification_type=ArgusNotificationTypes.AssigneeChange,
+                source_type=ArgusNotificationSourceTypes.TestRun,
+                source_id=run.id,
+                source_message=str(run.test_id),
+                content_params={
+                    "username": g.user.username,
+                    "run_id": run.id,
+                    "test_id": test.id,
+                    "build_id": run.build_id,
+                    "build_number": get_build_number(run.build_job_url),
+                }
+            )
         return {
             "test_run_id": run.id,
             "assignee": str(new_assignee_user.id) if new_assignee_user else None
@@ -307,28 +323,6 @@ class TestRunService:
         }
         return response
 
-    def fetch_results(self, test_id: UUID, run_id: UUID) -> list[dict]:
-        cluster = ScyllaCluster.get()
-        query_fields = ["column", "row", "value", "status"]
-        raw_query = (f"SELECT {','.join(query_fields)},WRITETIME(value) as ordering "
-                     f"FROM generic_result_data_v1 WHERE test_id = ? AND run_id = ? AND name = ?")
-        query = cluster.prepare(raw_query)
-        tables_meta = ArgusGenericResultMetadata.filter(test_id=test_id)
-        tables = []
-        for table in tables_meta:
-            cells = cluster.session.execute(query=query, parameters=(test_id, run_id, table.name))
-            if not cells:
-                continue
-            cells = [dict(cell.items()) for cell in cells]
-            tables.append({'meta': {
-                'name': table.name,
-                'description': table.description,
-                'columns_meta': table.columns_meta,
-                'rows_meta': table.rows_meta,
-            },
-                'cells': [{k: v for k, v in cell.items() if k in query_fields} for cell in cells],
-                'order': min([cell['ordering'] for cell in cells] or [0])})
-        return sorted(tables, key=lambda x: x['order'])
 
     def submit_github_issue(self, issue_url: str, test_id: UUID, run_id: UUID):
         user_tokens = UserOauthToken.filter(user_id=g.user.id).all()

argus/backend/tests/argus_web.test.yaml

@@ -0,0 +1,39 @@
+# BASE URL FOR ARGUS APPLICATION
+BASE_URL: "https://argus.scylladb.com"
+# Main DB Cluster contact points
+SCYLLA_CONTACT_POINTS:
+  - 172.18.0.2
+# Username
+SCYLLA_USERNAME: cassandra
+# Password
+SCYLLA_PASSWORD: cassandra
+# Default keyspace (can be created using 'create-keyspace' command with RF set to the number of contact points)
+SCYLLA_KEYSPACE_NAME: test_argus
+# Replication factor used - if set, will override contact_points as amount of nodes for replication
+# SCYLLA_REPLICATION_FACTOR: 3
+LOGIN_METHODS:
+  - gh
+# Application log level
+APP_LOG_LEVEL: INFO
+# Secret key used to match session data
+SECRET_KEY: MUSTBEUNIQUE1
+# Client ID of a github oauth application
+GITHUB_CLIENT_ID: not_set
+# Scopes used for Github Application:
+# GITHUB_SCOPES: 'user:email read:user read:org repo'
+# Client secret of a github oauth application
+GITHUB_CLIENT_SECRET: not_set
+# Github personal access token
+GITHUB_ACCESS_TOKEN: unknown
+# List of required organization names (Comment out to disable organization requirement)
+GITHUB_REQUIRED_ORGANIZATIONS:
+  # at least one is required for user to successfully authenticate
+BUILD_SYSTEM_FILTERED_PREFIXES:
+  - prefixToExclude
+JENKINS_URL: https://jenkins.scylladb.com
+JENKINS_USER: not_set
+JENKINS_API_TOKEN_NAME: not_set
+JENKINS_API_TOKEN: not_set
+JENKINS_MONITORED_RELEASES:
+  - not_set
+

argus/backend/tests/conftest.py

@@ -0,0 +1,44 @@
+import os
+from pathlib import Path
+from unittest.mock import patch
+
+from _pytest.fixtures import fixture
+
+from argus.backend.cli import sync_models
+from argus.backend.db import ScyllaCluster
+from argus.backend.service.client_service import ClientService
+from argus.backend.service.release_manager import ReleaseManagerService
+from argus.backend.util.config import Config
+import logging
+os.environ['CQLENG_ALLOW_SCHEMA_MANAGEMENT'] = '1'
+logging.getLogger('cassandra').setLevel(logging.WARNING)
+logging.getLogger('cassandra.connection').setLevel(logging.WARNING)
+logging.getLogger('cassandra.pool').setLevel(logging.WARNING)
+logging.getLogger('cassandra.cluster').setLevel(logging.WARNING)
+
+def truncate_all_tables(session):
+    for table in session.cluster.metadata.keyspaces[session.keyspace].tables:
+        session.execute(f"TRUNCATE {table}")
+
+
+@fixture(autouse=True, scope='session')
+def argus_db():
+    Config.CONFIG_PATHS = [Path(__file__).parent / "argus_web.test.yaml"]
+    config = Config.load_yaml_config()
+    database = ScyllaCluster.get(config)
+    session = database.cluster.connect(keyspace=config["SCYLLA_KEYSPACE_NAME"])
+    ScyllaCluster.get_session = lambda: session  # monkey patching to escape need for flask app context
+
+    sync_models()
+    truncate_all_tables(database.session)
+    yield database
+    database.shutdown()
+
+
+@fixture(autouse=True, scope='session')
+def release_manager_service(argus_db):
+    return ReleaseManagerService()
+
+@fixture(autouse=True, scope='session')
+def client_service(argus_db):
+    return ClientService()

argus/backend/tests/results_service/test_best_results.py

@@ -0,0 +1,70 @@
+import logging
+import uuid
+from dataclasses import asdict
+from typing import Optional, Dict
+
+from _pytest.fixtures import fixture
+
+from argus.backend.plugins.sct.testrun import SCTTestRunSubmissionRequest
+from argus.client.generic_result import GenericResultTable, ColumnMetadata, ResultType, ValidationRule
+
+LOGGER = logging.getLogger(__name__)
+
+@fixture(autouse=True, scope='session')
+def release(release_manager_service):
+    return release_manager_service.create_release("best_results", "best_results", False)
+
+
+@fixture(autouse=True, scope='session')
+def group(release_manager_service, release):
+    return release_manager_service.create_group("br_group", "best_results", build_system_id="best_results", release_id=str(release.id))
+
+def get_fake_test_run(
+    schema_version: str = "1.0.0",
+    run_id: str = str(uuid.uuid4()),
+    job_name: str = "default_job_name",
+    job_url: str = "http://example.com",
+    started_by: str = "default_user",
+    commit_id: str = "default_commit_id",
+    sct_config: dict | None = None,
+    origin_url: str | None = None,
+    branch_name: str | None = "main",
+    runner_public_ip: str | None = None,
+    runner_private_ip: str | None = None
+) -> tuple[str, dict]:
+    return "scylla-cluster-tests", asdict(SCTTestRunSubmissionRequest(
+        schema_version=schema_version,
+        run_id=run_id,
+        job_name=job_name,
+        job_url=job_url,
+        started_by=started_by,
+        commit_id=commit_id,
+        sct_config=sct_config,
+        origin_url=origin_url,
+        branch_name=branch_name,
+        runner_public_ip=runner_public_ip,
+        runner_private_ip=runner_private_ip
+    ))
+
+class SampleTable(GenericResultTable):
+    class Meta:
+        name = "Test Table Name"
+        description = "Test Table Description"
+        Columns = [ColumnMetadata(name="float col name", unit="ms", type=ResultType.FLOAT, higher_is_better=False),
+                   ColumnMetadata(name="int col name", unit="ms", type=ResultType.INTEGER, higher_is_better=False),
+                   ColumnMetadata(name="duration col name", unit="s", type=ResultType.DURATION, higher_is_better=False),
+                   ColumnMetadata(name="non tracked col name", unit="", type=ResultType.FLOAT),
+                   ColumnMetadata(name="text col name", unit="", type=ResultType.TEXT),
+                   ]
+        ValidationRules = {"float col name": ValidationRule(best_abs=4),
+                           "int col name": ValidationRule(best_pct=50, best_abs=5),
+                           "duration col name": ValidationRule(fixed_limit=590)
+                           }
+
+def test_argus_tracks_best_result(release_manager_service, client_service, release, group):
+    test = release_manager_service.create_test('track_best_result', 'track_best_result', 'track_best_result', 'track_best_result',
+                                               group_id=str(group.id), release_id=str(release.id), plugin_name='sct')
+    print(test)
+    LOGGER.warning(f"available plugins: {client_service.PLUGINS}")
+    client_service.submit_run(*get_fake_test_run())
+    assert test

argus/client/generic_result.py

@@ -7,6 +7,7 @@ class Status(Enum):
     PASS = auto()
     WARNING = auto()
     ERROR = auto()
+    UNSET = auto()
 
     def __str__(self):
         return self.name
@@ -16,6 +17,7 @@ class ResultType(Enum):
     INTEGER = auto()
     FLOAT = auto()
     DURATION = auto()
+    TEXT = auto()
 
     def __str__(self):
         return self.name
@@ -26,15 +28,30 @@ class ColumnMetadata:
     name: str
     unit: str
     type: ResultType
+    higher_is_better: bool = None
 
     def as_dict(self) -> dict:
         return {
             "name": self.name,
             "unit": self.unit,
-            "type": str(self.type)
+            "type": str(self.type),
+            "higher_is_better": self.higher_is_better
         }
 
 
+@dataclass
+class ValidationRule:
+    best_pct: float | None = None  # max value limit relative to best result in percent unit
+    best_abs: float | None = None  # max value limit relative to best result in absolute unit
+    fixed_limit: float | None = None
+
+    def as_dict(self) -> dict:
+        return {
+            "best_pct": self.best_pct,
+            "best_abs": self.best_abs,
+            "fixed_limit": self.fixed_limit
+        }
+
 class ResultTableMeta(type):
     def __new__(cls, name, bases, dct):
         cls_instance = super().__new__(cls, name, bases, dct)
@@ -44,8 +61,16 @@ class ResultTableMeta(type):
             cls_instance.name = meta.name
             cls_instance.description = meta.description
             cls_instance.columns = meta.Columns
-            cls_instance.column_names = {column.name for column in cls_instance.columns}
+            cls_instance.column_types = {column.name: column.type for column in cls_instance.columns}
             cls_instance.rows = []
+            for col_name, rule in meta.ValidationRules.items():
+                if col_name not in cls_instance.column_types:
+                    raise ValueError(f"ValidationRule column {col_name} not found in the table")
+                if cls_instance.column_types[col_name] == ResultType.TEXT:
+                    raise ValueError(f"Validation rules don't apply to TEXT columns")
+                if not isinstance(rule, ValidationRule):
+                    raise ValueError(f"Validation rule for column {col_name} is not of type ValidationRule")
+            cls_instance.validation_rules = meta.ValidationRules
         return cls_instance
 
 
@@ -57,12 +82,13 @@ class Cell:
     status: Status
 
     def as_dict(self) -> dict:
-        return {
+        cell = {"value_text": self.value} if isinstance(self.value, str) else {"value": self.value}
+        cell.update({
             "column": self.column,
             "row": self.row,
-            "value": self.value,
             "status": str(self.status)
-        }
+        })
+        return cell
 
 
 @dataclass
@@ -84,7 +110,8 @@ class GenericResultTable(metaclass=ResultTableMeta):
             "name": self.name,
             "description": self.description,
             "columns_meta": [column.as_dict() for column in self.columns],
-            "rows_meta": rows
+            "rows_meta": rows,
+            "validation_rules": {k: v.as_dict() for k, v in self.validation_rules.items()}
         }
         return {
             "meta": meta_info,
@@ -94,6 +121,8 @@ class GenericResultTable(metaclass=ResultTableMeta):
         }
 
     def add_result(self, column: str, row: str, value: Union[int, float, str], status: Status):
-        if column not in self.column_names:
+        if column not in self.column_types:
             raise ValueError(f"Column {column} not found in the table")
+        if isinstance(value, str) and self.column_types[column] != ResultType.TEXT:
+            raise ValueError(f"Column {column} is not of type TEXT")
         self.results.append(Cell(column=column, row=row, value=value, status=status))

argus/client/generic_result_old.py

@@ -0,0 +1,143 @@
+from dataclasses import dataclass, field, asdict
+from typing import Dict, List, Tuple, Union, Type
+from uuid import UUID
+from enum import Enum
+import json
+
+
+
+class Status(Enum):
+    PASS = 1
+    WARNING = 2
+    ERROR = 3
+
+
+class ResultType(Enum):
+    INTEGER = int
+    FLOAT = float
+    TEXT = str
+
+
+@dataclass
+class ColumnMetadata:
+    id: int
+    unit: str
+    type: ResultType
+
+
+@dataclass
+class Result:
+    value: Union[int, float, str]
+    status: Status
+
+
+class ResultTableMeta(type):
+    def __new__(cls, name, bases, dct):
+        cls_instance = super().__new__(cls, name, bases, dct)
+        meta = dct.get('Meta')
+
+        if meta:
+            cls_instance.table_name = meta.table_name
+            cls_instance.columns_map = {col_name: ColumnMetadata(id=col_id, unit=unit, type=result_type)
+                                        for col_name, (col_id, unit, result_type) in meta.Columns.items()}
+            cls_instance.rows_map = {row_name: row_id
+                                     for row_name, row_id in meta.Rows.items()}
+        return cls_instance
+
+
+class Row:
+    def __init__(self, columns_map: Dict[str, ColumnMetadata]):
+        self.columns_map = columns_map
+        self.data: Dict[str, Result] = {}
+
+    def __getitem__(self, column_name: str) -> Result:
+        return self.data[column_name]
+
+    def __setitem__(self, column_name: str, result: Result):
+        if column_name not in self.columns_map:
+            raise ValueError(f"Column name '{column_name}' not found in columns_map.")
+        column_metadata = self.columns_map[column_name]
+        if not isinstance(result.value, column_metadata.type.value):
+            raise ValueError(f"Value {result.value} for column '{column_name}' is not of type {column_metadata.type.name}")
+        self.data[column_name] = result
+
+
+@dataclass
+class BaseResultTable(metaclass=ResultTableMeta):
+    results: Dict[str, Row] = field(default_factory=dict)
+
+    def as_dict(self) -> dict:
+        results_list = []
+        for row_name, row in self.results.items():
+            row_id = self.rows_map.get(row_name)
+            for column_name, result in row.data.items():
+                column_metadata = self.columns_map.get(column_name)
+                results_list.append({
+                    "column_id": column_metadata.id,
+                    "row_id": row_id,
+                    "result": result.value,
+                    "status": result.status.value
+                })
+
+        meta_info = {
+            "table_name": self.table_name,
+            "columns": {name: {"id": meta.id, "unit": meta.unit, "type": meta.type.name} for name, meta in self.columns_map.items()},
+            "rows": self.rows_map
+        }
+        return {
+            "meta": meta_info,
+            "results": results_list
+        }
+
+    def to_json(self) -> str:
+        dict_result = self.as_dict()
+        return json.dumps(dict_result, default=str)
+
+    def __getitem__(self, row_name: str) -> Row:
+        if row_name not in self.rows_map:
+            raise ValueError(f"Row name '{row_name}' not found in rows_map.")
+        if row_name not in self.results:
+            self.results[row_name] = Row(self.columns_map)
+        return self.results[row_name]
+
+
+# Example of a specific result table with its own metadata
+class LatencyResultTable(BaseResultTable):
+    class Meta:
+        table_name = "latency_percentile_write"
+        Columns = {
+            "latency": (1, "ms", ResultType.FLOAT),
+            "op_rate": (2, "ops", ResultType.INTEGER)
+        }
+        Rows = {
+            "mean": 1,
+            "p99": 2
+        }
+
+
+# Client code example
+if __name__ == "__main__":
+    class LatencyResultTable(BaseResultTable):
+        class Meta:
+            table_name = "latency_percentile_write"
+            Columns = {
+                "latency": (1, "ms", ResultType.FLOAT),
+                "op_rate": (2, "ops", ResultType.INTEGER)
+            }
+            Rows = {
+                "mean": 1,
+                "p99": 2
+            }
+
+    result_table = LatencyResultTable()
+
+    result_table["mean"]["latency"] = Result(value=1.1, status=Status.WARNING)
+    result_table["mean"]["op_rate"] = Result(value=59988, status=Status.ERROR)
+    result_table["p99"]["latency"] = Result(value=2.7, status=Status.PASS)
+    result_table["p99"]["op_rate"] = Result(value=59988, status=Status.WARNING)
+
+    from argus.client.sct.client import ArgusSCTClient
+
+    run_id = UUID("24e09748-bba4-47fd-a615-bf7ea2c425eb")
+    client = ArgusSCTClient(run_id, auth_token="UO+2GXL9XqSgcVJijWk5WnbPXPit5ot5nfkLAHAr7SaqROfSCWycabpp/wxyY8+I", base_url="http://localhost:5000")
+    client.submit_results(result_table)

{argus_alm-0.12.7.dist-info → argus_alm-0.12.9.dist-info}/METADATA

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

{argus_alm-0.12.7.dist-info → argus_alm-0.12.9.dist-info}/RECORD

@@ -1,26 +1,26 @@
 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=fWSS1m0mhQeCwfH58Qfs4Cicxc95IKi9vwmQn3SUYs0,1346
+argus/backend/cli.py,sha256=ULa9KVv7RR3DVHKlYvsSdIfbX5s-VuiPuhWWRfPkdGU,1383
 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=lj5g6rdoKN9X13H9hXmKYx_-9tftt6HSftiNFLCr_kY,8567
-argus/backend/controller/api.py,sha256=3TmNyrQXG4AfsHBAGFpUcDemaOlU_ePyx1S6qZsVABs,14613
+argus/backend/controller/api.py,sha256=722KPfrclfxHHf7eUai-ZRv9L-3ehs6FGHr5Qs6AsIU,14827
 argus/backend/controller/auth.py,sha256=rGKgqqjfiZOnoOEpthg5JTd1BuotcEk0S95z_USrgN4,2291
-argus/backend/controller/client_api.py,sha256=IKDIX4rVZgSp5g35ptR1Yx00bAWXm0aRGt6vAroDV74,3646
+argus/backend/controller/client_api.py,sha256=ZUVDnaO9b6OesEVvYlqegnkx50vnwCAq8aCNCFPk3JA,3574
 argus/backend/controller/main.py,sha256=EXrwvGq2TyebT8a54Ojkxq-o5_QOhm0w51M53G0h_n0,9060
 argus/backend/controller/notification_api.py,sha256=wz7V4nE6Mxclpq78P8gNnCyeQ7xA9BBJjZ-dPhLLd2I,1964
 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=nJZz2VhyNUWMyHdOmnK-BbxT7ifMLrMPZl8qh9tjVpM,12571
+argus/backend/controller/testrun_api.py,sha256=MCcVmbfNuyODCVbxF8TfcvVu9sMT0xO1UzS4VgumQiM,12638
 argus/backend/controller/view_api.py,sha256=rI7LwcS7keK37nYx76D9StFV_rLHcNkHan8OhFgBrhM,4106
-argus/backend/db.py,sha256=bBiraYD05Qex28yZHjSP1bRlcMsc6oTYGt792zXmaHo,4101
+argus/backend/db.py,sha256=IgeGjZKTHSoyGrd5f2A7uYn6Pm6DU2-ZIESHmfJwkoE,4099
 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/result.py,sha256=WNB7nfjLBRwbvWcGW8Y1Co4gWYYwvFeHZb9CW5mw1PM,2216
-argus/backend/models/web.py,sha256=4K1Gj70nugmuW3sv0Sv5M_sVSmEhfJgxRE670qChGzo,13095
+argus/backend/models/result.py,sha256=DOgxHwerJIyMsqsbDdMYSojkUPiWsu6mHCq9B8JpaBA,5899
+argus/backend/models/web.py,sha256=eJybumxShBrFIdi0H0zHcEuAusfpZKpDrZ4Bxl_JyUY,13141
 argus/backend/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/plugins/core.py,sha256=UsrK8oWyhpDSLEcnqAQsEqYVUIX0eCQB862Em7GMQLo,8690
 argus/backend/plugins/driver_matrix_tests/controller.py,sha256=GdPpProzsVXQw8A4h2IS8inUPdr_Q4IN93i6ocOThS8,2213
@@ -32,12 +32,12 @@ argus/backend/plugins/driver_matrix_tests/udt.py,sha256=WRtnJU1dZcLXZJQgfU0mgjNz
 argus/backend/plugins/generic/model.py,sha256=QLVO7QhGr38Hz0VO-BlDYF7LhRX7Pl049vw4W_VMT8o,3302
 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=6PUrMjXKoCSDazMRkUHt8qxpniRhuqhY8Tof8lzeunk,1390
+argus/backend/plugins/loader.py,sha256=L3OUNt0e2RrxGD5dIl0PonEAKZj0f9gXcpk7_ifjVuc,1414
 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=ygAL85BkyyovJ1xHktlCQJdJS8CrerJZ_Tbr3EXqsg4,22021
-argus/backend/plugins/sct/testrun.py,sha256=vd44G99mqdR4mAb4hEou48xZN5r1OTg8QTVaawGx9p8,10264
+argus/backend/plugins/sct/testrun.py,sha256=O7LanXF-fHiHfUAqsr7ALhTmcpVfjAYQODQTdB-u3Ig,10656
 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
@@ -46,18 +46,23 @@ argus/backend/plugins/sirenada/types.py,sha256=Gm3XMK9YJoozVaeM9XE7n8iRxA6PKBrS2
 argus/backend/service/admin.py,sha256=_VnWl3CkZBOAie_pPbd9sbXZUpBf2SApyNoFZLfB_QI,637
 argus/backend/service/argus_service.py,sha256=YF6El9CyIelePDrCydVn4K82sd7CzCoZNmcvn2ZeR9I,29266
 argus/backend/service/build_system_monitor.py,sha256=QB7RfMMuA2VJ4oUAOAqLxOwxqaQE52_4ZhsASVcoXkU,8296
-argus/backend/service/client_service.py,sha256=wcL_Yv_6Q5P4JnvrBMFA_SGVwZqTdK0tjj8q_yt_MAk,3726
+argus/backend/service/client_service.py,sha256=XAAZ8VOVg2ppwcWVh8asGvYdlMuqFWjkcF-z-DCKD9c,4754
 argus/backend/service/event_service.py,sha256=iYeqxN2QCYTjYB1WPPv4BEFLXG0Oz3TvskkaK4v9pVY,654
 argus/backend/service/jenkins_service.py,sha256=njomagkliIWKisR9FmhKKqZ8y9NijyJ3hUQe23gl2U4,9878
-argus/backend/service/notification_manager.py,sha256=h00Ej_-hH9H7pq0wah_1TH8dnpPyPNsgVJNO1rwJi7o,7011
+argus/backend/service/notification_manager.py,sha256=hOeFTZ8HhcFa7Ifo9aS-DUsivo5MoCTHyjmUgvH2fyY,7271
 argus/backend/service/release_manager.py,sha256=d1J6llBb4aKgFPrsPTPYpV9NnGx772jeORZjs-ojYGE,7771
-argus/backend/service/results_service.py,sha256=t2IW05avpl1bl8TJDjGo_bt0gswwoM-4vOnnekGCVAc,4528
+argus/backend/service/results_service.py,sha256=WeVeJbOOA1KJCTw3vIUcbWE4YqldwwnTT-mYJMnUqvA,13415
 argus/backend/service/stats.py,sha256=-V94A8EUlQBvwG53oJTL4U1EzR4vciEF7Niu-efTL6Y,22713
 argus/backend/service/team_manager_service.py,sha256=zY5dvy3ffvQbJuXBvlWKE5dS5LQ3ss6tkFE-cwFZsdw,3010
-argus/backend/service/testrun.py,sha256=fPME2Eq02rKobL_QxFwR2jXn5bG_RSS4EN1UVMzRRPY,22735
+argus/backend/service/testrun.py,sha256=L9JC0D9J8D5QkuT_HxFBK_Z31j1rdiT1cRo7s4zjhqo,22251
 argus/backend/service/user.py,sha256=DC8fII7mElWGB-pMGyn4uzaJHIbmxzh_ZWf2POmlBkU,10936
 argus/backend/service/views.py,sha256=gUzwQv3fasGh0hRvivCr64XooQhG3c1V1KcxgMjC2qM,11292
 argus/backend/template_filters.py,sha256=04PHl0DiN4PBHQ82HMAmTfww09fGMXcYy-I5BU_b1s4,682
+argus/backend/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argus/backend/tests/argus_web.test.yaml,sha256=_ompiLY3zXuGjuMenIR0UtJmkTW3RjFWejFS05o850I,1325
+argus/backend/tests/conftest.py,sha256=rg1KVQhO0wEs98HYV4kwtQxODUXq-S1MUy9_53v8qbI,1561
+argus/backend/tests/results_service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argus/backend/tests/results_service/test_best_results.py,sha256=JE1sOecg_TPmdcpteSUMSFx4VFwXUvyJ3736R8l7IiU,3095
 argus/backend/util/common.py,sha256=vLMit9ZBBN8S4-dw32LIhjtaEOX_5hwWneHILS_SNBg,1723
 argus/backend/util/config.py,sha256=1HpHm8Du6yz61gwAE1vR6uwuHCStaSerirbEhBLnDws,927
 argus/backend/util/encoders.py,sha256=5AfJbs2V3gOOg5LtFLZAtBqlnSdX8HHITT7r9Wu-law,1129
@@ -71,7 +76,8 @@ argus/client/driver_matrix_tests/cli.py,sha256=PIK4IyA4qku7jCnJ8A0i59DeVl1jvMWYu
 argus/client/driver_matrix_tests/client.py,sha256=UPryBku2rg6IV2wKKDkclXHnH3r6EYwWdds65wLC-KU,2748
 argus/client/generic/cli.py,sha256=IJkgEZ5VOAeqp5SlLM13Y5m8e34Cqnyz8WkfeKoN7so,2208
 argus/client/generic/client.py,sha256=l4PDjDy65Mm2OI9ZLSnyd8_2i4Ei1Pp9yRt3bRX8s2Y,1114
-argus/client/generic_result.py,sha256=Xg3MwwulHH7dGk_pwwbVOm4cHzV4qbfHaFD0VteFVHI,2666
+argus/client/generic_result.py,sha256=Fyo-ooFoO-w64BbXAlPgg0XOuuozTjv-51rAdsxecno,4197
+argus/client/generic_result_old.py,sha256=Oi15Gu8WbXK_WruF0IU-Fokr-I1k8mzg1MpHbmpt50M,4662
 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
@@ -83,8 +89,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.7.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-argus_alm-0.12.7.dist-info/METADATA,sha256=5mRLCu-5qnJwLHJmwc3yBlZaBqr_ihdnXb2vo_yiqjs,3508
-argus_alm-0.12.7.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-argus_alm-0.12.7.dist-info/entry_points.txt,sha256=pcYW8nxZuDaymxE8tn86K0dq8eEodUdiS0sSvwEQ_zU,137
-argus_alm-0.12.7.dist-info/RECORD,,
+argus_alm-0.12.9.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+argus_alm-0.12.9.dist-info/METADATA,sha256=i8u6MV6uYgTu74q8FWwy7eYWDaMmrMGrh0VNRF01-k8,3508
+argus_alm-0.12.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+argus_alm-0.12.9.dist-info/entry_points.txt,sha256=pcYW8nxZuDaymxE8tn86K0dq8eEodUdiS0sSvwEQ_zU,137
+argus_alm-0.12.9.dist-info/RECORD,,

{argus_alm-0.12.7.dist-info → argus_alm-0.12.9.dist-info}/WHEEL

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