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

argus/backend/controller/admin_api.py

@@ -7,8 +7,8 @@ from flask import (
 )
 from argus.backend.error_handlers import handle_api_exception
 from argus.backend.service.release_manager import ReleaseEditPayload, ReleaseManagerService
-from argus.backend.service.user import api_login_required, check_roles
-from argus.backend.models.web import UserRoles
+from argus.backend.service.user import UserService, api_login_required, check_roles
+from argus.backend.models.web import User, UserRoles
 
 bp = Blueprint('admin_api', __name__, url_prefix='/api/v1')
 LOGGER = logging.getLogger(__name__)
@@ -287,3 +287,68 @@ def quick_toggle_group_enabled():
         "status": "ok",
         "response": res
     }
+
+
+@bp.route("/users", methods=["GET"])
+@check_roles(UserRoles.Admin)
+@api_login_required
+def user_info():
+    result = UserService().get_users_privileged()
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/user/<string:user_id>/email/set", methods=["POST"])
+@check_roles(UserRoles.Admin)
+@api_login_required
+def user_change_email(user_id: str):
+    payload = get_payload(request)
+
+    user = User.get(id=user_id)
+    result = UserService().update_email(user=user, new_email=payload["newEmail"])
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/user/<string:user_id>/delete", methods=["POST"])
+@check_roles(UserRoles.Admin)
+@api_login_required
+def user_delete(user_id: str):
+    result = UserService().delete_user(user_id=user_id)
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/user/<string:user_id>/password/set", methods=["POST"])
+@check_roles(UserRoles.Admin)
+@api_login_required
+def user_change_password(user_id: str):
+    payload = get_payload(request)
+
+    user = User.get(id=user_id)
+    result = UserService().update_password(user=user, old_password="", new_password=payload["newPassword"], force=True)
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+@bp.route("/user/<string:user_id>/admin/toggle", methods=["POST"])
+@check_roles(UserRoles.Admin)
+@api_login_required
+def user_toggle_admin(user_id: str):
+    result = UserService().toggle_admin(user_id=user_id)
+
+    return {
+        "status": "ok",
+        "response": result
+    }

argus/backend/controller/api.py

@@ -14,6 +14,7 @@ from argus.backend.controller.testrun_api import bp as testrun_bp
 from argus.backend.controller.team import bp as team_bp
 from argus.backend.controller.view_api import bp as view_bp
 from argus.backend.service.argus_service import ArgusService, ScheduleUpdateRequest
+from argus.backend.service.results_service import ResultsService
 from argus.backend.service.user import UserService, api_login_required
 from argus.backend.service.stats import ReleaseStatsCollector
 from argus.backend.models.web import ArgusRelease, ArgusGroup, ArgusTest, User, UserOauthToken
@@ -381,6 +382,19 @@ def test_info():
         "response": info
     }
 
+@bp.route("/test-results", methods=["GET"])
+@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))
+
+    return {
+        "status": "ok",
+        "response": info
+    }
 
 @bp.route("/test_run/comment/get", methods=["GET"])  # TODO: remove
 @api_login_required

argus/backend/controller/auth.py

@@ -5,7 +5,7 @@ from flask import (
 )
 from werkzeug.security import check_password_hash
 from argus.backend.models.web import User
-from argus.backend.service.user import UserService, load_logged_in_user, login_required
+from argus.backend.service.user import UserService, UserServiceException, load_logged_in_user, login_required
 
 bp = Blueprint('auth', __name__, url_prefix='/auth')
 
@@ -21,24 +21,26 @@ def login():
     session["csrf_token"] = token
 
     if request.method == 'POST':
-        username = request.form["username"]
-        password = request.form["password"]
-        error = None
         try:
-            user = User.get(username=username)
-        except User.DoesNotExist:
-            user = None
+            if "password" not in current_app.config.get("LOGIN_METHODS", []):
+                raise UserServiceException("Password Login is disabled")
+            username = request.form["username"]
+            password = request.form["password"]
 
-        if not user:
-            error = "User not found"
-        elif not check_password_hash(user.password, password):
-            error = "Incorrect Password"
+            try:
+                user: User = User.get(username=username)
+            except User.DoesNotExist:
+                raise UserServiceException("User not found")
+
+            if not check_password_hash(user.password, password):
+                raise UserServiceException("Incorrect Password")
 
-        if not error:
             session.clear()
             session["user_id"] = str(user.id)
             session["csrf_token"] = token
-        flash(error, category="error")
+        except UserServiceException as exc:
+            flash(next(iter(exc.args), "No message"), category="error")
+        
         return redirect(url_for('main.home'))
 
     return render_template('auth/login.html.j2',

argus/backend/controller/client_api.py

@@ -23,6 +23,15 @@ def submit_run(run_type: str):
         "response": result
     }
 
+@bp.route("/testrun/<string:run_type>/<string:run_id>/get", methods=["GET"])
+@api_login_required
+def get_run(run_type: str, run_id: str):
+    result = ClientService().get_run(run_type=run_type, run_id=run_id)
+    return {
+        "status": "ok",
+        "response": result
+    }
+
 
 @bp.route("/testrun/<string:run_type>/<string:run_id>/heartbeat", methods=["POST"])
 @api_login_required
@@ -90,3 +99,14 @@ def run_finalize(run_type: str, run_id: str):
         "status": "ok",
         "response": result
     }
+
+
+@bp.route("/testrun/<string:run_type>/<string:run_id>/submit_results", methods=["POST"])
+@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
+    }

argus/backend/controller/main.py

@@ -152,6 +152,7 @@ def profile_oauth_github_callback():
     try:
         first_run_info = service.github_callback(req_code)
     except Exception as exc:  # pylint: disable=broad-except
+        LOGGER.error("An error occured in callback", exc_info=True)
         flash(message=exc.args[0], category="error")
         return redirect(url_for("main.error", type=403))
     if first_run_info:

argus/backend/controller/testrun_api.py

@@ -63,6 +63,17 @@ 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))
+    return {
+        "status": "ok",
+        "tables": tables
+    }
+
+
 @bp.route("/test/<string:test_id>/run/<string:run_id>/status/set", methods=["POST"])
 @api_login_required
 def set_testrun_status(test_id: str, run_id: str):

argus/backend/models/result.py

@@ -0,0 +1,63 @@
+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 ColumnMetadata(UserType):
+    name = columns.Ascii()
+    unit = columns.Text()
+    type = columns.Ascii()
+
+
+class ArgusGenericResultMetadata(Model):
+    __table_name__ = "generic_result_metadata_v1"
+    test_id = columns.UUID(partition_key=True)
+    name = columns.Text(required=True, primary_key=True)
+    description = columns.Text()
+    columns_meta = columns.List(value_type=columns.UserDefinedType(ColumnMetadata))
+    rows_meta = columns.List(value_type=columns.Ascii())
+
+    def __init__(self, **kwargs):
+        kwargs["columns_meta"] = [ColumnMetadata(**col) for col in kwargs.pop('columns_meta', [])]
+        super().__init__(**kwargs)
+
+    def update_if_changed(self, new_data: dict) -> None:
+        """
+        Updates table metadata if changed column/description or new rows were added.
+        See that rows can only be added, not removed once was sent.
+        Columns may be removed, but data in results table persists.
+        """
+        updated = False
+        for field, value in new_data.items():
+            if field == "columns_meta":
+                value = [ColumnMetadata(**col) for col in value]
+            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:
+                setattr(self, field, value)
+                updated = True
+
+        if updated:
+            self.save()
+
+class ArgusGenericResultData(Model):
+    __table_name__ = "generic_result_data_v1"
+    test_id = columns.UUID(partition_key=True)
+    name = columns.Text(partition_key=True)
+    run_id = columns.UUID(primary_key=True)
+    column = columns.Ascii(primary_key=True, index=True)
+    row = columns.Ascii(primary_key=True, index=True)
+    sut_timestamp = columns.DateTime()  # for sorting
+    value = columns.Double()
+    status = columns.Ascii()

argus/backend/models/web.py

@@ -6,6 +6,8 @@ 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
+
 
 def uuid_now():
     return uuid_from_time(datetime.utcnow())
@@ -377,6 +379,8 @@ USED_MODELS: list[Model] = [
     ArgusScheduleAssignee,
     ArgusScheduleGroup,
     ArgusScheduleTest,
+    ArgusGenericResultMetadata,
+    ArgusGenericResultData,
 ]
 
 USED_TYPES: list[UserType] = [

argus/backend/plugins/core.py

@@ -105,16 +105,16 @@ class PluginModelBase(Model):
             assignees = ArgusScheduleAssignee.filter(
                 schedule_id=schedule.id
             ).all()
-            assignees_uuids.append(*[assignee.assignee for assignee in assignees])
+            assignees_uuids.extend([assignee.assignee for assignee in assignees])
 
         return assignees_uuids[0] if len(assignees_uuids) > 0 else None
 
     @classmethod
-    def get_jobs_assigned_to_user(cls, user: User):
+    def get_jobs_assigned_to_user(cls, user_id: str | UUID):
         cluster = ScyllaCluster.get()
         query = cluster.prepare("SELECT build_id, start_time, release_id, group_id, assignee, "
                                 f"test_id, id, status, investigation_status, build_job_url, scylla_version FROM {cls.table_name()} WHERE assignee = ?")
-        rows = cluster.session.execute(query=query, parameters=(user.id,))
+        rows = cluster.session.execute(query=query, parameters=(user_id,))
 
         return list(rows)
 
@@ -213,6 +213,8 @@ class PluginModelBase(Model):
     def finish_run(self, payload: dict = None):
         raise NotImplementedError()
 
+    def sut_timestamp(self) -> float:
+        raise NotImplementedError()
 
 class PluginInfoBase:
     # pylint: disable=too-few-public-methods

argus/backend/plugins/sct/testrun.py

@@ -109,6 +109,7 @@ class SCTTestRun(PluginModelBase):
     stress_cmd = columns.Text()
 
     histograms = columns.List(value_type=columns.Map(key_type=columns.Text(), value_type=columns.UserDefinedType(user_type=PerformanceHDRHistogram)))
+    test_method = columns.Ascii()
 
     @classmethod
     def _stats_query(cls) -> str:
@@ -199,6 +200,7 @@ class SCTTestRun(PluginModelBase):
 
             run.config_files = req.sct_config.get("config_files")
             run.region_name = regions
+            run.test_method = req.sct_config.get("test_method")
             run.save()
 
         return run
@@ -249,6 +251,13 @@ class SCTTestRun(PluginModelBase):
 
         self._collect_event_message(event, event_message)
 
+    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()
+                + int(scylla_package.revision_id, 16) % 1000000 / 1000000)
+
 
 class SCTJunitReports(Model):
     test_id = columns.UUID(primary_key=True, partition_key=True, required=True)

argus/backend/service/argus_service.py

@@ -459,8 +459,13 @@ class ArgusService:
                 self.update_schedule_comment({"newComment": comment, "releaseId": test.release_id, "groupId": test.group_id, "testId": test.id})
 
         schedule_assignee: ArgusScheduleAssignee = ArgusScheduleAssignee.get(schedule_id=schedule_id)
-        schedule_assignee.assignee = assignee
-        schedule_assignee.save()
+        new_assignee = ArgusScheduleAssignee()
+        new_assignee.assignee = assignee
+        new_assignee.release_id = schedule_assignee.release_id
+        new_assignee.schedule_id = schedule_assignee.schedule_id
+        new_assignee.save()
+        schedule_assignee.delete()
+
         return True
 
     def delete_schedule(self, payload: dict) -> dict:
@@ -493,11 +498,16 @@ class ArgusService:
         full_schedule["assignees"] = [assignee.assignee for assignee in assignees]
 
         if len(assignees) > 0:
-            schedule_user = User.get(id=assignees[0].assignee)
+            try:
+                schedule_user = User.get(id=assignees[0].assignee)
+            except User.DoesNotExist:
+                schedule_user = User()
+                schedule_user.id = assignees[0].assignee
+                LOGGER.warning("Deleting orphaned user assignments")
             service = TestRunService()
 
             for model in all_plugin_models():
-                for run in model.get_jobs_assigned_to_user(schedule_user):
+                for run in model.get_jobs_assigned_to_user(schedule_user.id):
                     if run["release_id"] != release.id:
                         continue
                     if run["test_id"] not in full_schedule["tests"]:
@@ -644,7 +654,7 @@ class ArgusService:
         today = datetime.datetime.now()
         validity_period = today - datetime.timedelta(days=current_app.config.get("JOB_VALIDITY_PERIOD_DAYS", 30))
         for plugin in all_plugin_models():
-            for run in plugin.get_jobs_assigned_to_user(user=user):
+            for run in plugin.get_jobs_assigned_to_user(user_id=user.id):
                 if run["start_time"] >= validity_period:
                     yield run
 

argus/backend/service/build_system_monitor.py

@@ -20,9 +20,9 @@ class ArgusTestsMonitor(ABC):
 
     def __init__(self) -> None:
         self._cluster = ScyllaCluster.get()
-        self._existing_releases = list(ArgusRelease.all())
-        self._existing_groups = list(ArgusGroup.all())
-        self._existing_tests = list(ArgusTest.all())
+        self._existing_releases = list(ArgusRelease.objects().limit(None))
+        self._existing_groups = list(ArgusGroup.objects().limit(None))
+        self._existing_tests = list(ArgusTest.objects().limit(None))
         self._filtered_groups: list[str] = self.BUILD_SYSTEM_FILTERED_PREFIXES
 
     def create_release(self, release_name):

argus/backend/service/client_service.py

@@ -1,5 +1,6 @@
 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.util.enums import TestStatus
@@ -25,6 +26,14 @@ class ClientService:
         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:
+            run = model.get(id=run_id)
+        except model.DoesNotExist:
+            return None
+        return run
 
     def heartbeat(self, run_type: str, run_id: str) -> int:
         model = self.get_model(run_type)
@@ -69,3 +78,24 @@ class ClientService:
         run.save()
 
         return "Finalized"
+
+    def submit_results(self, run_type: str, run_id: str, results: dict) -> 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"])
+        else:
+            ArgusGenericResultMetadata(test_id=run.test_id, **results["meta"]).save()
+        if results.get("sut_timestamp", 0) == 0:
+            results["sut_timestamp"] = run.sut_timestamp()  # automatic sut_timestamp
+        table_name = results["meta"]["name"]
+        sut_timestamp = results["sut_timestamp"]
+        for cell in results["results"]:
+            ArgusGenericResultData(test_id=run.test_id,
+                                   run_id=run.id,
+                                   name=table_name,
+                                   sut_timestamp=sut_timestamp,
+                                   **cell
+                                   ).save()
+        return "Submitted"

argus/backend/service/jenkins_service.py

@@ -220,7 +220,9 @@ class JenkinsService:
     def build_job(self, build_id: str, params: dict, user_override: str = None):
         queue_number = self._jenkins.build_job(build_id, {
             **params,
-            self.RESERVED_PARAMETER_NAME: g.user.username if not user_override else user_override
+            # use the user's email as the default value for the requested by user parameter,
+            # so it would align with how SCT default works, on runs not trigger by argus
+            self.RESERVED_PARAMETER_NAME: g.user.email.split('@')[0] if not user_override else user_override
         })
         return queue_number
 

argus/backend/service/results_service.py

@@ -0,0 +1,140 @@
+import copy
+import logging
+import math
+from typing import List, Dict, Any
+from uuid import UUID
+
+from argus.backend.db import ScyllaCluster
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
+
+LOGGER = logging.getLogger(__name__)
+
+default_options = {
+    "scales": {
+        "y": {
+            "beginAtZero": True,
+            "title": {
+                "display": True,
+                "text": ''
+            }
+        },
+        "x": {
+            "type": "time",
+            "time": {
+                "unit": "day",
+                "displayFormats": {
+                    "day": "yyyy-MM-dd",
+                },
+            },
+            "title": {
+                "display": True,
+                "text": 'SUT Date'
+            }
+        },
+    },
+    "elements": {
+        "line": {
+            "tension": .1,
+        }
+    },
+    "plugins": {
+        "legend": {
+            "position": 'top',
+        },
+        "title": {
+            "display": True,
+            "text": ''
+        }
+    }
+}
+
+colors = [
+    'rgba(255, 0, 0, 1.0)',  # Red
+    'rgba(0, 255, 0, 1.0)',  # Green
+    'rgba(0, 0, 255, 1.0)',  # Blue
+    'rgba(0, 255, 255, 1.0)',  # Cyan
+    'rgba(255, 0, 255, 1.0)',  # Magenta
+    'rgba(255, 255, 0, 1.0)',  # Yellow
+    'rgba(255, 165, 0, 1.0)',  # Orange
+    'rgba(128, 0, 128, 1.0)',  # Purple
+    'rgba(50, 205, 50, 1.0)',  # Lime
+    'rgba(255, 192, 203, 1.0)',  # Pink
+    'rgba(0, 128, 128, 1.0)',  # Teal
+    'rgba(165, 42, 42, 1.0)',  # Brown
+    'rgba(0, 0, 128, 1.0)',  # Navy
+    'rgba(128, 128, 0, 1.0)',  # Olive
+    'rgba(255, 127, 80, 1.0)'  # Coral
+]
+
+
+def get_sorted_data_for_column_and_row(data: List[Dict[str, Any]], 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'])
+
+
+def get_min_max_y(datasets: List[Dict[str, Any]]) -> (float, float):
+    """0.5 - 1.5 of min/max of 50% results"""
+    y = [entry['y'] for dataset in datasets for entry in dataset['data']]
+    if not y:
+        return 0, 0
+    sorted_y = sorted(y)
+    lower_percentile_index = int(0.25 * len(sorted_y))
+    upper_percentile_index = int(0.75 * len(sorted_y)) - 1
+    y_min = sorted_y[lower_percentile_index]
+    y_max = sorted_y[upper_percentile_index]
+    return math.floor(0.5 * y_min), math.ceil(1.5 * y_max)
+
+
+def round_datasets_to_min_max(datasets: List[Dict[str, Any]], min_y: float, max_y: float) -> List[Dict[str, Any]]:
+    """Round values to min/max and provide original value for tooltip"""
+    for dataset in datasets:
+        for entry in dataset['data']:
+            val = entry['y']
+            if val > max_y:
+                entry['y'] = max_y
+                entry['ori'] = val
+            elif val < min_y:
+                entry['y'] = min_y
+                entry['ori'] = val
+    return datasets
+
+
+def create_chartjs(table, data):
+    graphs = []
+    for column in table.columns_meta:
+        datasets = [
+            {"label": row,
+             "borderColor": colors[idx % len(colors)],
+             "borderWidth": 3,
+             "showLine": True,
+             "data": get_sorted_data_for_column_and_row(data, column.name, row)} for idx, row in enumerate(table.rows_meta)]
+        min_y, max_y = get_min_max_y(datasets)
+        datasets = round_datasets_to_min_max(datasets, min_y, max_y)
+        if not min_y + max_y:
+            # filter out those without 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"]["min"] = min_y
+        options["scales"]["y"]["max"] = max_y
+        graphs.append({"options": options, "data":
+            {"datasets": datasets}})
+    return graphs
+
+
+class ResultsService:
+
+    def __init__(self, database_session=None):
+        self.session = database_session if database_session else ScyllaCluster.get_session()
+
+    def get_results(self, test_id: UUID):
+        graphs = []
+        res = ArgusGenericResultMetadata.objects(test_id=test_id).all()
+        for table in res:
+            data = ArgusGenericResultData.objects(test_id=test_id, name=table.name).all()
+            graphs.extend(create_chartjs(table, data))
+        return graphs

argus/backend/service/testrun.py

@@ -13,6 +13,7 @@ from flask import g
 from cassandra.query import BatchStatement, ConsistencyLevel
 from cassandra.cqlengine.query import BatchQuery
 from argus.backend.db import ScyllaCluster
+from argus.backend.models.result import ArgusGenericResultMetadata
 
 from argus.backend.models.web import (
     ArgusEvent,
@@ -222,7 +223,7 @@ class TestRunService:
         mentions = set(mentions)
         for potential_mention in re.findall(self.RE_MENTION, message_stripped):
             if user := User.exists_by_name(potential_mention.lstrip("@")):
-                mentions.add(user)
+                mentions.add(user) if user.id != g.user.id else None
 
         test: ArgusTest = ArgusTest.get(id=test_id)
         plugin = self.get_plugin(test.plugin_name)
@@ -306,6 +307,29 @@ 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()
         token = None

argus/backend/service/user.py

@@ -17,6 +17,9 @@ from argus.backend.models.web import User, UserOauthToken, UserRoles, WebFileSto
 from argus.backend.util.common import FlaskView
 
 
+class UserServiceException(Exception):
+    pass
+
 class GithubOrganizationMissingError(Exception):
     pass
 
@@ -29,6 +32,8 @@ class UserService:
 
     @staticmethod
     def check_roles(roles: list[UserRoles] | UserRoles, user: User) -> bool:
+        if not user:
+            return False
         if isinstance(roles, str):
             return roles in user.roles
         elif isinstance(roles, list):
@@ -38,6 +43,8 @@ class UserService:
         return False
 
     def github_callback(self, req_code: str) -> dict | None:
+        if "gh" not in current_app.config.get("LOGIN_METHODS", []):
+            raise UserServiceException("Github Login is disabled")
         # pylint: disable=too-many-locals
         oauth_response = requests.post(
             "https://github.com/login/oauth/access_token",
@@ -90,7 +97,10 @@ class UserService:
         except User.DoesNotExist:
             user = User()
             user.username = user_info.get("login")
-            user.email = email_info[-1].get("email")
+            # pick only scylladb.com emails
+            scylla_email = next(iter([email.get("email") for email in email_info if email.get("email").endswith("@scylladb.com")]), None)
+            primary_email = next(iter([email.get("email") for email in email_info if email.get("primary") and email.get("verified")]), None)
+            user.email = scylla_email or primary_email
             user.full_name = user_info.get("name", user_info.get("login"))
             user.registration_date = datetime.utcnow()
             user.roles = ["ROLE_USER"]
@@ -137,6 +147,15 @@ class UserService:
     def get_users(self) -> dict:
         users = User.all()
         return {str(user.id): user.to_json() for user in users}
+    
+    def get_users_privileged(self) -> dict:
+        users = User.all()
+        users = {str(user.id): dict(user.items()) for user in users}
+        for user in users.values():
+            user.pop("password")
+            user.pop("api_token")
+
+        return users
 
     def generate_token(self, user: User):
         token_digest = f"{user.username}-{int(time())}-{base64.encodebytes(os.urandom(128)).decode(encoding='utf-8')}"
@@ -150,13 +169,51 @@ class UserService:
         user.email = new_email
         user.save()
 
-    def update_password(self, user: User, old_password: str, new_password: str):
-        if check_password_hash(user.password, old_password):
-            raise Exception("Incorrect old password")
+        return True
+
+    def toggle_admin(self, user_id: str):
+        user: User = User.get(id=user_id)
+
+        if user.id == g.user.id:
+            raise UserServiceException("Cannot toggle admin role from yourself.")
+
+        is_admin = UserService.check_roles(UserRoles.Admin, user)
+
+        if is_admin:
+            user.roles.remove(UserRoles.Admin)
+        else:
+            user.set_as_admin()
+
+        user.save()
+        return True
+
+    def delete_user(self, user_id: str):
+        user: User = User.get(id=user_id)
+        if user.id == g.user.id:
+            raise UserServiceException("Cannot delete user that you are logged in as.")
+
+        if user.is_admin():
+            raise UserServiceException("Cannot delete admin users. Unset admin flag before deleting")
+
+        user.delete()
+
+        return True
+
+    def update_password(self, user: User, old_password: str, new_password: str, force = False):
+        if not check_password_hash(user.password, old_password) and not force:
+            raise UserServiceException("Incorrect old password")
+
+        if not new_password:
+            raise UserServiceException("Empty new password")
+
+        if len(new_password) < 5:
+            raise UserServiceException("New password is too short")
 
         user.password = generate_password_hash(new_password)
         user.save()
 
+        return True
+
     def update_name(self, user: User, new_name: str):
         user.full_name = new_name
         user.save()

argus/backend/service/views.py

@@ -110,9 +110,9 @@ class UserViewService:
                 search_func = facet_wrapper(query_func=search_func, facet_query=value, facet_type=facet)
 
 
-        all_tests = ArgusTest.all()
-        all_releases = ArgusRelease.all()
-        all_groups = ArgusGroup.all()
+        all_tests = ArgusTest.objects().limit(None)
+        all_releases = ArgusRelease.objects().limit(None)
+        all_groups = ArgusGroup.objects().limit(None)
         release_by_id = {release.id: partial(self.index_mapper, type="release")(release) for release in all_releases}
         group_by_id = {group.id: partial(self.index_mapper, type="group")(group) for group in all_groups}
         index = [self.index_mapper(t) for t in all_tests]

argus/backend/util/config.py

@@ -10,8 +10,10 @@ LOGGER = logging.getLogger(__name__)
 class Config:
     CONFIG = None
     CONFIG_PATHS = [
-        Path("./config/argus_web.yaml"),
+        Path(__file__).parents[3] / "config" / "argus_web.yaml",
         Path("argus_web.yaml"),
+        Path("../config/argus_web.yaml"),
+
     ]
 
     @classmethod

argus/backend/util/encoders.py

@@ -3,6 +3,7 @@ import logging
 from json.encoder import JSONEncoder
 from uuid import UUID
 
+from flask.json.provider import DefaultJSONProvider
 import cassandra.cqlengine.usertype as ut
 import cassandra.cqlengine.models as m
 
@@ -22,3 +23,19 @@ class ArgusJSONEncoder(JSONEncoder):
                 return o.strftime("%Y-%m-%dT%H:%M:%SZ")
             case _:
                 return super().default(o)
+
+
+class ArgusJSONProvider(DefaultJSONProvider):
+
+    def default(self, o):
+        match o:
+            case UUID():
+                return str(o)
+            case ut.UserType():
+                return dict(o.items())
+            case m.Model():
+                return dict(o.items())
+            case datetime():
+                return o.strftime("%Y-%m-%dT%H:%M:%SZ")
+            case _:
+                return super().default(o)

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]
@@ -23,11 +24,14 @@ class ArgusClient:
     class Routes():
         # pylint: disable=too-few-public-methods
         SUBMIT = "/testrun/$type/submit"
+        GET = "/testrun/$type/$id/get"
         HEARTBEAT = "/testrun/$type/$id/heartbeat"
         GET_STATUS = "/testrun/$type/$id/get_status"
         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:
@@ -122,7 +126,23 @@ class ArgusClient:
             **self.generic_body,
             **run_body
         })
-    
+
+    def get_run(self, run_type: str = None, run_id: UUID | str = None) -> requests.Response:
+
+        if not run_type and hasattr(self, "test_type"):
+            run_type = self.test_type
+
+        if not run_id and hasattr(self, "run_id"):
+            run_id = self.run_id
+
+        if not (run_type and run_id):
+            raise ValueError("run_type and run_id must be set in func params or object attributes")
+
+        response = self.get(endpoint=self.Routes.GET, location_params={"type": run_type, "id": run_id })
+        self.check_response(response)
+
+        return response.json()["response"]
+
     def get_status(self, run_type: str = None, run_id: UUID = None) -> TestStatus:
         if not run_type and hasattr(self, "test_type"):
             run_type = self.test_type
@@ -190,3 +210,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/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_alm-0.12.4b2.dist-info → argus_alm-0.12.7.dist-info}/METADATA

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

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

@@ -4,24 +4,25 @@ argus/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/cli.py,sha256=fWSS1m0mhQeCwfH58Qfs4Cicxc95IKi9vwmQn3SUYs0,1346
 argus/backend/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/controller/admin.py,sha256=2z29RX7ZQO_VTklSKH9RrEj-Ag2SsvyOaIzWDKr0ahQ,575
-argus/backend/controller/admin_api.py,sha256=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/main.py,sha256=gYA0pqUBlLhpedkOetUX0V82qfe489frOEHPEtM-iHQ,8992
+argus/backend/controller/admin_api.py,sha256=lj5g6rdoKN9X13H9hXmKYx_-9tftt6HSftiNFLCr_kY,8567
+argus/backend/controller/api.py,sha256=3TmNyrQXG4AfsHBAGFpUcDemaOlU_ePyx1S6qZsVABs,14613
+argus/backend/controller/auth.py,sha256=rGKgqqjfiZOnoOEpthg5JTd1BuotcEk0S95z_USrgN4,2291
+argus/backend/controller/client_api.py,sha256=IKDIX4rVZgSp5g35ptR1Yx00bAWXm0aRGt6vAroDV74,3646
+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=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=WNB7nfjLBRwbvWcGW8Y1Co4gWYYwvFeHZb9CW5mw1PM,2216
+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/core.py,sha256=UsrK8oWyhpDSLEcnqAQsEqYVUIX0eCQB862Em7GMQLo,8690
 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/driver_matrix_tests/plugin.py,sha256=72ESU7s8C6ovVMfJTlYwtaokdvRp_HJF1_czm1UMhKg,745
@@ -36,39 +37,41 @@ 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=vd44G99mqdR4mAb4hEou48xZN5r1OTg8QTVaawGx9p8,10264
 argus/backend/plugins/sct/types.py,sha256=Gw1y4iqYguqNqTh_GopLDFho8vuGaOGuK7fjaHYhAOQ,1326
 argus/backend/plugins/sct/udt.py,sha256=V_x8_yw8rV7Q_QRBYayqtTNsPdZvjzOxWpRhXP1XAzs,3119
 argus/backend/plugins/sirenada/model.py,sha256=KVnI75BacuBryc5lR_Aai-mEOs7CB9xxhb7J-YRU3bc,4705
 argus/backend/plugins/sirenada/plugin.py,sha256=AlQAakwy3u-OqAqqK3RonUR5oDm-JoiwBUDUF3YEVP4,447
 argus/backend/plugins/sirenada/types.py,sha256=Gm3XMK9YJoozVaeM9XE7n8iRxA6PKBrS23Mo2vJfdLs,697
 argus/backend/service/admin.py,sha256=_VnWl3CkZBOAie_pPbd9sbXZUpBf2SApyNoFZLfB_QI,637
-argus/backend/service/argus_service.py,sha256=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/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/event_service.py,sha256=iYeqxN2QCYTjYB1WPPv4BEFLXG0Oz3TvskkaK4v9pVY,654
-argus/backend/service/jenkins_service.py,sha256=PKmu44kAEWl-Dw7f8gXkKhwRkV4yWy-B4CmFxv7c6-8,9685
+argus/backend/service/jenkins_service.py,sha256=njomagkliIWKisR9FmhKKqZ8y9NijyJ3hUQe23gl2U4,9878
 argus/backend/service/notification_manager.py,sha256=h00Ej_-hH9H7pq0wah_1TH8dnpPyPNsgVJNO1rwJi7o,7011
 argus/backend/service/release_manager.py,sha256=d1J6llBb4aKgFPrsPTPYpV9NnGx772jeORZjs-ojYGE,7771
+argus/backend/service/results_service.py,sha256=t2IW05avpl1bl8TJDjGo_bt0gswwoM-4vOnnekGCVAc,4528
 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/user.py,sha256=N3t43rgKMnSsPXU5R9bigEEGbPjYrc6MsJtof3z7kDE,9027
-argus/backend/service/views.py,sha256=amkyOQgHSP3YEDqiFHAhOiNzNCLk2sLkruTB2_IagDQ,11244
+argus/backend/service/testrun.py,sha256=fPME2Eq02rKobL_QxFwR2jXn5bG_RSS4EN1UVMzRRPY,22735
+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/util/common.py,sha256=vLMit9ZBBN8S4-dw32LIhjtaEOX_5hwWneHILS_SNBg,1723
-argus/backend/util/config.py,sha256=Sm0LCRkabYaSUkXNPglyjMr45GCDBNXqJLkmB_s51f0,860
-argus/backend/util/encoders.py,sha256=VxOnUanHP9FjcaobYupV-pZ3Udzrrrq7zZcbNpVXaKM,646
+argus/backend/util/config.py,sha256=1HpHm8Du6yz61gwAE1vR6uwuHCStaSerirbEhBLnDws,927
+argus/backend/util/encoders.py,sha256=5AfJbs2V3gOOg5LtFLZAtBqlnSdX8HHITT7r9Wu-law,1129
 argus/backend/util/enums.py,sha256=EhTQrgedlEz5sDYJ1gFnE2eC2nc1neQCRgzOgssQvWY,749
 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=-R-BINTolY06lUQLOLGlsWzza4fBdtLBW-4V3NT64vg,6755
+argus/client/base.py,sha256=ihSNHlcpChYafooUHnzFI8aYqIkk4fD_qVF4iYIDbQ8,7994
 argus/client/driver_matrix_tests/cli.py,sha256=PIK4IyA4qku7jCnJ8A0i59DeVl1jvMWYukeMOqUQ0jM,6346
 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/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 +83,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.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.4b2.dist-info → argus_alm-0.12.7.dist-info}/WHEEL

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