argus-alm 0.12.4b2__py3-none-any.whl → 0.12.5__py3-none-any.whl

argus/client/base.py

@@ -7,6 +7,7 @@ from uuid import UUID
 import requests
 
 from argus.backend.util.enums import TestStatus
+from argus.client.generic_result import GenericResultTable
 from argus.client.sct.types import LogLink
 
 JSON = dict[str, Any] | list[Any] | int | str | float | bool | Type[None]
@@ -28,6 +29,8 @@ class ArgusClient:
         SET_STATUS = "/testrun/$type/$id/set_status"
         SET_PRODUCT_VERSION = "/testrun/$type/$id/update_product_version"
         SUBMIT_LOGS = "/testrun/$type/$id/logs/submit"
+        SUBMIT_RESULTS = "/testrun/$type/$id/submit_results"
+        FETCH_RESULTS = "/testrun/$type/$id/fetch_results"
         FINALIZE = "/testrun/$type/$id/finalize"
 
     def __init__(self, auth_token: str, base_url: str, api_version="v1") -> None:
@@ -190,3 +193,16 @@ class ArgusClient:
             }
         )
         self.check_response(response)
+
+    def submit_results(self, result: GenericResultTable) -> None:
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_RESULTS,
+            location_params={"type": self.test_type, "id": str(self.run_id)},
+            body={
+                **self.generic_body,
+                "run_id": str(self.run_id),
+                ** result.as_dict(),
+            }
+        )
+        self.check_response(response)
+

argus/client/driver_matrix_tests/client.py

@@ -1,77 +1,214 @@
+from functools import reduce
+from datetime import datetime
+from typing import TypedDict, Literal
+import re
+import logging
 from uuid import UUID
+from pathlib import Path
+from pprint import pformat
+from glob import glob
+from xml.etree import ElementTree
+
 from argus.backend.util.enums import TestStatus
 from argus.client.base import ArgusClient
+from argus.backend.plugins.driver_matrix_tests.raw_types import RawMatrixTestResult, RawMatrixTestCase
+
+
+LOGGER = logging.getLogger(__name__)
+
+TestTypeType = Literal['java', 'cpp', 'python', 'gocql']
+
+class AdaptedXUnitData(TypedDict):
+    timestamp: str
+
+
+def python_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    testsuites = list(xml.getroot().iter("testsuite"))
+
+    return {
+        "timestamp": testsuites[0].attrib.get("timestamp"),
+    }
+
+
+def java_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    testsuites = xml.getroot()
+    ts_now = datetime.utcnow().timestamp()
+    try:
+        time_taken = float(testsuites.attrib.get("time"))
+    except ValueError:
+        time_taken = 0.0
+
+    timestamp = datetime.utcfromtimestamp(ts_now - time_taken).isoformat()
+
+    return {
+        "timestamp": timestamp,
+    }
+
+
+def cpp_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    testsuites = xml.getroot()
+
+    return {
+        "timestamp": testsuites.attrib.get("timestamp"),
+    }
+
+
+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()
+    }
 
 
 class ArgusDriverMatrixClient(ArgusClient):
     test_type = "driver-matrix-tests"
-    schema_version: None = "v2"
+    schema_version: None = "v1"
 
-    class Routes(ArgusClient.Routes):
-        SUBMIT_DRIVER_RESULT = "/driver_matrix/result/submit"
-        SUBMIT_DRIVER_FAILURE = "/driver_matrix/result/fail"
-        SUBMIT_ENV = "/driver_matrix/env/submit"
+    TEST_ADAPTERS = {
+        "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:
         super().__init__(auth_token, base_url, api_version)
         self.run_id = run_id
 
-    def submit_driver_matrix_run(self, job_name: str, job_url: str) -> None:
-        response = super().submit_run(run_type=self.test_type, run_body={
-            "run_id": str(self.run_id),
-            "job_name": job_name,
-            "job_url": job_url
-        })
+    def parse_build_environment(self, env_path: str) -> dict[str, str]:
+        with open(Path(env_path), mode="rt", encoding="utf-8") as env_file:
+            raw_env = env_file.read()
 
-        self.check_response(response)
+        result = {}
+        for line in raw_env.split("\n"):
+            if not line:
+                continue
+            LOGGER.debug("ENV: %s", line)
+            key, val = line.split(": ")
+            result[key] = val.strip()
 
-    def submit_driver_result(self, driver_name: str, driver_type: str, raw_junit_data: bytes):
-        """
-            Submit results of a single driver run
-        """
-        response = self.post(
-            endpoint=self.Routes.SUBMIT_DRIVER_RESULT,
-            location_params={},
-            body={
-                **self.generic_body,
-                "run_id": str(self.run_id),
-                "driver_name": driver_name,
-                "driver_type": driver_type,
-                "raw_xml": str(raw_junit_data, encoding="utf-8"),
-            }
-        )
-        self.check_response(response)
+        return result
 
-    def submit_driver_failure(self, driver_name: str, driver_type: str, failure_reason: str):
-        """
-            Submit a failure to run of a specific driver test
-        """
-        response = self.post(
-            endpoint=self.Routes.SUBMIT_DRIVER_FAILURE,
-            location_params={},
-            body={
-                **self.generic_body,
-                "run_id": str(self.run_id),
-                "driver_name": driver_name,
-                "driver_type": driver_type,
-                "failure_reason": failure_reason,
-            }
-        )
-        self.check_response(response)
+    def get_test_cases(self, cases: list[ElementTree.Element]) -> list[RawMatrixTestCase]:
+        raw_cases = []
+        for case in cases:
+            children = list(case.findall("./*"))
+            if len(children) > 0:
+                status = children[0].tag
+                message = f"{children[0].attrib.get('message', 'no-message')} ({children[0].attrib.get('type', 'no-type')})"
+            else:
+                status = "passed"
+                message = ""
+
+            raw_cases.append({
+                "name": case.attrib["name"],
+                "status": status,
+                "time": float(case.attrib.get("time", 0.0)),
+                "classname": case.attrib.get("classname", ""),
+                "message": message,
+            })
+
+        return raw_cases
+
+    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)
+
+        return match.groupdict() if match else {}
+
+    def get_passed_count(self, suite_attribs: dict[str, str]) -> int:
+        if (pass_count := suite_attribs.get("passed")):
+            return int(pass_count)
+        total = int(suite_attribs.get("tests", 0))
+        errors = int(suite_attribs.get("errors", 0))
+        skipped = int(suite_attribs.get("skipped", 0))
+        failures = int(suite_attribs.get("failures", 0))
+
+        return total - errors - skipped - failures
 
-    def submit_env(self, env_info: str):
-        """
-            Submit env-info file (Build-00.txt)
-        """
-        response = self.post(
-            endpoint=self.Routes.SUBMIT_ENV,
-            location_params={},
-            body={
-                **self.generic_body,
-                "run_id": str(self.run_id),
-                "raw_env": env_info,
+    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, test_type)
+        test_collection = {
+            "timestamp": adapted_data["timestamp"],
+            "name": xml_path.stem,
+            "driver_name": driver_info.get("driver_name"),
+            "tests": 0,
+            "failures": 0,
+            "errors": 0,
+            "disabled": 0,
+            "skipped": 0,
+            "passed": 0,
+            "time": 0.0,
+        }
+        all_suites = []
+        for suite in testsuites.iter("testsuite"):
+            raw_suite = {
+                "name": suite.attrib["name"],
+                "tests": int(suite.attrib.get("tests", 0)),
+                "failures": int(suite.attrib.get("failures", 0)),
+                "disabled": int(0),
+                "passed": self.get_passed_count(suite.attrib),
+                "skipped": int(suite.attrib.get("skipped", 0)),
+                "errors": int(suite.attrib.get("errors", 0)),
+                "time": float(suite.attrib["time"]),
+                "cases": self.get_test_cases(list(suite.iter("testcase")))
             }
-        )
+            all_suites.append(raw_suite)
+            test_collection["tests"] += raw_suite["tests"]
+            test_collection["failures"] += raw_suite["failures"]
+            test_collection["errors"] += raw_suite["errors"]
+            test_collection["disabled"] += raw_suite["disabled"]
+            test_collection["skipped"] += raw_suite["skipped"]
+            test_collection["passed"] += raw_suite["passed"]
+            test_collection["time"] += raw_suite["time"]
+
+        return {
+            **test_collection,
+            "suites": all_suites
+        }
+
+    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 = []
+        for xml in xmls:
+            result = self.parse_result_xml(Path(xml), test_type)
+            results.append(result)
+        return results
+
+    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)
+
+        self.submit_driver_matrix_run(job_name=build_id, job_url=build_url, test_environment=env, results=results)
+
+    def submit_driver_matrix_run(self, job_name: str, job_url: str,
+                                 results: list[RawMatrixTestResult], test_environment: dict[str, str]) -> None:
+        response = super().submit_run(run_type=self.test_type, run_body={
+            "run_id": str(self.run_id),
+            "job_name": job_name,
+            "job_url": job_url,
+            "test_environment": test_environment,
+            "matrix_results": results
+        })
+
         self.check_response(response)
 
     def set_matrix_status(self, status: TestStatus):

argus/client/generic_result.py

@@ -0,0 +1,99 @@
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Union
+
+
+class Status(Enum):
+    PASS = auto()
+    WARNING = auto()
+    ERROR = auto()
+
+    def __str__(self):
+        return self.name
+
+
+class ResultType(Enum):
+    INTEGER = auto()
+    FLOAT = auto()
+    DURATION = auto()
+
+    def __str__(self):
+        return self.name
+
+
+@dataclass
+class ColumnMetadata:
+    name: str
+    unit: str
+    type: ResultType
+
+    def as_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "unit": self.unit,
+            "type": str(self.type)
+        }
+
+
+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.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.rows = []
+        return cls_instance
+
+
+@dataclass
+class Cell:
+    column: str
+    row: str
+    value: Union[int, float, str]
+    status: Status
+
+    def as_dict(self) -> dict:
+        return {
+            "column": self.column,
+            "row": self.row,
+            "value": self.value,
+            "status": str(self.status)
+        }
+
+
+@dataclass
+class GenericResultTable(metaclass=ResultTableMeta):
+    """
+    Base class for all Generic Result Tables in Argus. Use it as a base class for your result table.
+    """
+    sut_timestamp: int = 0  # automatic timestamp based on SUT version. Works only with SCT and refers to Scylla version.
+    sut_details: str = ""
+    results: list[Cell] = field(default_factory=list)
+
+    def as_dict(self) -> dict:
+        rows = []
+        for result in self.results:
+            if result.row not in rows:
+                rows.append(result.row)
+
+        meta_info = {
+            "name": self.name,
+            "description": self.description,
+            "columns_meta": [column.as_dict() for column in self.columns],
+            "rows_meta": rows
+        }
+        return {
+            "meta": meta_info,
+            "sut_timestamp": self.sut_timestamp,
+            "sut_details": self.sut_details,
+            "results": [result.as_dict() for result in self.results]
+        }
+
+    def add_result(self, column: str, row: str, value: Union[int, float, str], status: Status):
+        if column not in self.column_names:
+            raise ValueError(f"Column {column} not found in the table")
+        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.4b2.dist-info → argus_alm-0.12.5.dist-info}/METADATA

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

{argus_alm-0.12.4b2.dist-info → argus_alm-0.12.5.dist-info}/RECORD

@@ -7,27 +7,28 @@ argus/backend/controller/admin.py,sha256=2z29RX7ZQO_VTklSKH9RrEj-Ag2SsvyOaIzWDKr
 argus/backend/controller/admin_api.py,sha256=I2eQbU5f5rlQeL7eI4t9mRoxM3SJ5O-6fqLsHf0wcEU,6975
 argus/backend/controller/api.py,sha256=HvjpR4ug5NXiTdBlrFTBeq57YQ5Vl_jca-IT35sAuas,14203
 argus/backend/controller/auth.py,sha256=nwF_5uZLxPOCLm2ljLyw2OxGur6fmPM7WAAoGJLI_kk,2030
-argus/backend/controller/client_api.py,sha256=SM6HRlnoguxkPrqHzm42b5JsoQ2b8-1hTtfLWe832hc,3007
+argus/backend/controller/client_api.py,sha256=AsPkZVjvogEVbNnhqVftvVX-1MACmzJuULAoUj_95bw,3366
 argus/backend/controller/main.py,sha256=gYA0pqUBlLhpedkOetUX0V82qfe489frOEHPEtM-iHQ,8992
 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=92VI_FngMxr9SpKMhlEdSzambvbL4dpMtfx26Z3_Eso,12264
+argus/backend/controller/testrun_api.py,sha256=nJZz2VhyNUWMyHdOmnK-BbxT7ifMLrMPZl8qh9tjVpM,12571
 argus/backend/controller/view_api.py,sha256=rI7LwcS7keK37nYx76D9StFV_rLHcNkHan8OhFgBrhM,4106
 argus/backend/db.py,sha256=bBiraYD05Qex28yZHjSP1bRlcMsc6oTYGt792zXmaHo,4101
 argus/backend/error_handlers.py,sha256=IEjz7Vzfldv1PTOeHrpRWmRsgBrHtAW0PXHUJZDovAE,480
 argus/backend/events/event_processors.py,sha256=bsmBayiXvlGn3aqiT2z9WgwnVBRtn2cRqkgn4pLodck,1291
 argus/backend/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-argus/backend/models/web.py,sha256=nl9sCOaPT53UKcZwguQB1DVm523Scgw7d2Rs4xaC9x4,12943
+argus/backend/models/result.py,sha256=jkdwC7bP_KOysAnfB6YcgKIFX_9Tya9Hpe_Zw-YU3x8,1319
+argus/backend/models/web.py,sha256=4K1Gj70nugmuW3sv0Sv5M_sVSmEhfJgxRE670qChGzo,13095
 argus/backend/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-argus/backend/plugins/core.py,sha256=kMp2zrEcgAZP0D4yw_dzY5uD8DcC19CoZ_E7urH0f0k,8608
-argus/backend/plugins/driver_matrix_tests/controller.py,sha256=GdPpProzsVXQw8A4h2IS8inUPdr_Q4IN93i6ocOThS8,2213
-argus/backend/plugins/driver_matrix_tests/model.py,sha256=Wqot8rOYqroYV7cn60ltlarnuIuYrL2qyrk13NwLeT4,15419
+argus/backend/plugins/core.py,sha256=p5VZ3OJPWf3IUzNZbVKW7pG5iysrtTvOCFX3C1HMU0Y,8678
+argus/backend/plugins/driver_matrix_tests/controller.py,sha256=9Q6QCripzM528SGsQnYupM6k7HW7hUzkNyjJFiXXfEw,739
+argus/backend/plugins/driver_matrix_tests/model.py,sha256=8iq9YqHcSSur2N4nZtD6Fn-07F5NN7uVxAu5rauCzUA,7025
 argus/backend/plugins/driver_matrix_tests/plugin.py,sha256=72ESU7s8C6ovVMfJTlYwtaokdvRp_HJF1_czm1UMhKg,745
-argus/backend/plugins/driver_matrix_tests/raw_types.py,sha256=KwbwsvS52RzOZb7_PT7kkYkChNzRH-MpKoO_eeZNDIk,1153
-argus/backend/plugins/driver_matrix_tests/service.py,sha256=98m6IyPsbenq0O-EtGaW0tiQVuM2yGX41xNCO3icmnc,2524
-argus/backend/plugins/driver_matrix_tests/udt.py,sha256=WRtnJU1dZcLXZJQgfU0mgjNzK_DyVhNgLTzr-aXX8K8,1394
+argus/backend/plugins/driver_matrix_tests/raw_types.py,sha256=A108HCnv5q0RHfNRhUJrTpRy3fG7sPxr9Sk4gfsbooU,600
+argus/backend/plugins/driver_matrix_tests/service.py,sha256=dxb8VGTJLIyVqVrZ4RtzCXgnmS2qg2RAGhcp_SARt9I,1737
+argus/backend/plugins/driver_matrix_tests/udt.py,sha256=6lydzF3AQHm3GR5bKEDu1xLPYsLaBL3o-wu9NpabbqA,1134
 argus/backend/plugins/generic/model.py,sha256=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
@@ -36,7 +37,7 @@ argus/backend/plugins/sct/controller.py,sha256=NF11JLoUJ13whghlxRrVex9rLMgFtlkcz
 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=NopC3Gnzf2m65S_E4DedAlgnbFvyaMQH5aLJip6ZPrE,9660
+argus/backend/plugins/sct/testrun.py,sha256=u0jDFVMo1v4w0_IXRp3BzIjgDIScre20fd3bCLzZl-c,10166
 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
@@ -45,14 +46,14 @@ 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=d1NrCQmcE_1NmkV761dheBL43Vk0n-oP0S4IZtQzJUQ,28832
 argus/backend/service/build_system_monitor.py,sha256=E8Ro1HBMfktxqcCHLPuXwzohkdgrls7pYro-VSG_CMs,8248
-argus/backend/service/client_service.py,sha256=CS5esppd9s-SgUYE-HVLkfz-MrN8zxPouf9e4VlPV_M,2326
+argus/backend/service/client_service.py,sha256=shcDLlCxHNUBuYxE8sjkAPfzqLict-BDllCVlUm8mFs,3273
 argus/backend/service/event_service.py,sha256=iYeqxN2QCYTjYB1WPPv4BEFLXG0Oz3TvskkaK4v9pVY,654
 argus/backend/service/jenkins_service.py,sha256=PKmu44kAEWl-Dw7f8gXkKhwRkV4yWy-B4CmFxv7c6-8,9685
 argus/backend/service/notification_manager.py,sha256=h00Ej_-hH9H7pq0wah_1TH8dnpPyPNsgVJNO1rwJi7o,7011
 argus/backend/service/release_manager.py,sha256=d1J6llBb4aKgFPrsPTPYpV9NnGx772jeORZjs-ojYGE,7771
 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=ZM0D38IQpbrmia1GlCfLK02ZLwp_pbpUuQPN8BwibAw,21432
+argus/backend/service/testrun.py,sha256=RmkjdcaKiFguYwIw3g6tFZHIIw5NdVefqXkhdYc4vDw,22310
 argus/backend/service/user.py,sha256=N3t43rgKMnSsPXU5R9bigEEGbPjYrc6MsJtof3z7kDE,9027
 argus/backend/service/views.py,sha256=amkyOQgHSP3YEDqiFHAhOiNzNCLk2sLkruTB2_IagDQ,11244
 argus/backend/template_filters.py,sha256=04PHl0DiN4PBHQ82HMAmTfww09fGMXcYy-I5BU_b1s4,682
@@ -64,11 +65,12 @@ argus/backend/util/logsetup.py,sha256=XWyFLC1_J5G8NcR7oC9l-Pf02ybAvEZR95y5LoY4W4
 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=-R-BINTolY06lUQLOLGlsWzza4fBdtLBW-4V3NT64vg,6755
-argus/client/driver_matrix_tests/cli.py,sha256=PIK4IyA4qku7jCnJ8A0i59DeVl1jvMWYukeMOqUQ0jM,6346
-argus/client/driver_matrix_tests/client.py,sha256=UPryBku2rg6IV2wKKDkclXHnH3r6EYwWdds65wLC-KU,2748
+argus/client/base.py,sha256=etjUxHIlbGNTrvPtvFQYKFYGazuo7avnP8Z__NI6ZyE,7358
+argus/client/driver_matrix_tests/client.py,sha256=ekuTkEZbcVqhg6DAC6PvGuC9bXuu4DSOjk96vcLzmuQ,7817
 argus/client/generic/cli.py,sha256=IJkgEZ5VOAeqp5SlLM13Y5m8e34Cqnyz8WkfeKoN7so,2208
 argus/client/generic/client.py,sha256=l4PDjDy65Mm2OI9ZLSnyd8_2i4Ei1Pp9yRt3bRX8s2Y,1114
+argus/client/generic_result.py,sha256=Xg3MwwulHH7dGk_pwwbVOm4cHzV4qbfHaFD0VteFVHI,2666
+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
@@ -80,8 +82,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.4b2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-argus_alm-0.12.4b2.dist-info/METADATA,sha256=bF-azdmr9Fwi30Aj_jt1znGiMdXenmDqAUMC0TeV1hA,3510
-argus_alm-0.12.4b2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-argus_alm-0.12.4b2.dist-info/entry_points.txt,sha256=pcYW8nxZuDaymxE8tn86K0dq8eEodUdiS0sSvwEQ_zU,137
-argus_alm-0.12.4b2.dist-info/RECORD,,
+argus_alm-0.12.5.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+argus_alm-0.12.5.dist-info/METADATA,sha256=IaMdyKUclP6Zdzy58_4wulhMbGQIOblEXaMnGAKcEa8,3508
+argus_alm-0.12.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+argus_alm-0.12.5.dist-info/entry_points.txt,sha256=zEqrAK95P8AAhKbwO4lgrQzKBWqCzHH9zlUPCaCVHoQ,69
+argus_alm-0.12.5.dist-info/RECORD,,

{argus_alm-0.12.4b2.dist-info → argus_alm-0.12.5.dist-info}/entry_points.txt

@@ -1,4 +1,3 @@
 [console_scripts]
 argus-client-generic=argus.client.generic.cli:cli
-argus-driver-matrix-client=argus.client.driver_matrix_tests.cli:cli