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

argus/backend/tests/results_service/test_best_results.py

@@ -1,70 +0,0 @@
-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/backend/util/common.py

@@ -1,65 +0,0 @@
-from itertools import islice
-import logging
-from typing import Callable, Iterable
-from uuid import UUID
-
-from flask import Request, Response, g
-
-from argus.backend.models.web import User
-
-
-LOGGER = logging.getLogger(__name__)
-FlaskView = Callable[..., Response]
-
-
-def first(iterable, value, key: Callable = None, predicate: Callable = None):
-    for elem in iterable:
-        if predicate and predicate(elem, value):
-            return elem
-        elif key and key(elem) == value:
-            return elem
-        elif elem == value:
-            return elem
-    return None
-
-
-def chunk(iterable: Iterable, slice_size = 90):
-    it = iter(iterable)
-    return iter(lambda: list(islice(it, slice_size)), [])
-
-
-def check_scheduled_test(test, group, testname):
-    return testname in (f"{group}/{test}", test)
-
-
-def strip_html_tags(text: str):
-    return text.replace("<", "&lt;").replace(">", "&gt;")
-
-
-def convert_str_list_to_uuid(lst: list[str]) -> list[UUID]:
-    return [UUID(s) for s in lst]
-
-
-def get_payload(client_request: Request) -> dict:
-    if not client_request.is_json:
-        raise Exception(
-            "Content-Type mismatch, expected application/json, got:",
-            client_request.content_type
-        )
-    request_payload = client_request.get_json()
-
-    return request_payload
-
-
-def current_user() -> User:
-    return g.user
-
-
-def get_build_number(build_job_url: str) -> int | None:
-    build_number = build_job_url.rstrip("/").split("/")[-1] if build_job_url else -1
-    if build_number:
-        try:
-            return int(build_number)
-        except ValueError:
-            LOGGER.error("Error parsing build number from %s: got %s as build_number", build_job_url, build_number)
-    return None

argus/backend/util/config.py

@@ -1,38 +0,0 @@
-import logging
-from pathlib import Path
-
-import yaml
-
-
-LOGGER = logging.getLogger(__name__)
-
-
-class Config:
-    CONFIG = None
-    CONFIG_PATHS = [
-        Path(__file__).parents[3] / "config" / "argus_web.yaml",
-        Path("argus_web.yaml"),
-        Path("../config/argus_web.yaml"),
-
-    ]
-
-    @classmethod
-    def locate_argus_web_config(cls) -> Path:
-        for config in cls.CONFIG_PATHS:
-            if config.exists():
-                return config
-            else:
-                LOGGER.debug("Tried %s as config, not found.", config)
-
-        raise Exception("Failed to locate web application config file!")
-
-    @classmethod
-    def load_yaml_config(cls) -> dict:
-        if cls.CONFIG:
-            return cls.CONFIG
-        path = cls.locate_argus_web_config()
-        with open(path, "rt", encoding="utf-8") as file:
-            config = yaml.safe_load(file)
-
-        cls.CONFIG = config
-        return config

argus/backend/util/encoders.py

@@ -1,41 +0,0 @@
-from datetime import datetime
-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
-
-
-LOGGER = logging.getLogger(__name__)
-
-class ArgusJSONEncoder(JSONEncoder):
-    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)
-
-
-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/backend/util/logsetup.py

@@ -1,81 +0,0 @@
-import logging
-from logging.config import dictConfig
-from flask import has_request_context, request
-
-# pylint: disable=line-too-long
-LOG_FORMAT_REQUEST = "[%(levelcolor)s%(levelname)s%(colorreset)s] %(grey)s<%(remote_addr)s - %(url)s - %(endpoint)s>%(colorreset)s - %(module)s::%(funcName)s - %(message)s"
-
-
-class ArgusRequestLogFormatter(logging.Formatter):
-    yellow = "\x1b[33;20m"
-    red = "\x1b[31;20m"
-    blue = "\x1b[34;20m"
-    bold_red = "\x1b[31;1m"
-    reset = "\x1b[0m"
-    grey = "\x1b[38;2;200;200;200m"
-    color_map = {
-        logging.DEBUG: grey,
-        logging.INFO: blue,
-        logging.WARNING: yellow,
-        logging.ERROR: red,
-        logging.CRITICAL: bold_red
-    }
-
-    def format(self, record: logging.LogRecord) -> str:
-        record.grey = self.grey
-        record.colorreset = self.reset
-        record.levelcolor = self.color_map.get(record.levelno, self.grey)
-        if has_request_context():
-            record.url = request.url
-            record.remote_addr = request.remote_addr
-            record.endpoint = request.endpoint
-        else:
-            record.url = ''
-            record.remote_addr = ''
-            record.endpoint = ''
-        return super().format(record)
-
-
-def setup_application_logging(log_level=logging.INFO):
-    dictConfig({
-        'version': 1,
-        'formatters': {
-            'request': {
-                'class': f"{__name__}.{ArgusRequestLogFormatter.__name__}",
-                'format': LOG_FORMAT_REQUEST,
-            }
-        },
-        'handlers': {
-            'main': {
-                'class': 'logging.StreamHandler',
-                'stream': 'ext://sys.stderr',
-                'formatter': 'request'
-            }
-        },
-        'loggers': {
-            'cassandra': {
-                'level': log_level,
-                'handlers': ['main']
-            },
-            'argus': {
-                'level': log_level,
-                'handlers': ['main']
-            },
-            'argus_backend': {
-                'level': log_level,
-                'handlers': ['main']
-            },
-            'werkzeug': {
-                'level': log_level,
-                'handlers': ['main']
-            },
-            'uwsgi': {
-                'level': log_level,
-                'handlers': ['main']
-            },
-            '__main__': {
-                'level': log_level,
-                'handlers': ['main']
-            },
-        }
-    })

argus/backend/util/module_loaders.py

@@ -1,30 +0,0 @@
-import sys
-from functools import wraps
-from typing import Callable
-
-
-def is_filter(filter_name: str) -> Callable:
-    def outer_wrapper(func):
-        func.is_filter = True
-        func.filter_name = filter_name
-
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs)
-
-        return wrapper
-
-    return outer_wrapper
-
-
-def export_functions(module_name: str, attr: str) -> list[Callable]:
-    module = sys.modules[module_name]
-    funcs = []
-
-    for member in dir(module):
-        export = getattr(module, member)
-        applicable_export = getattr(export, attr, False)
-        if applicable_export:
-            funcs.append(export)
-
-    return funcs

argus/backend/util/send_email.py

@@ -1,91 +0,0 @@
-import smtplib
-from typing import List, Set
-from smtplib import SMTPException
-
-from email.mime.multipart import MIMEMultipart
-from email.mime.text import MIMEText
-from flask import current_app
-from flask import render_template
-
-class Email:
-    #  pylint: disable=too-many-instance-attributes
-    """
-    Responsible for sending emails
-    """
-    _attachments_size_limit = 10485760  # 10Mb = 20 * 1024 * 1024
-    _body_size_limit = 26214400  # 25Mb = 20 * 1024 * 1024
-
-    def __init__(self, init_connection=True):
-        self.sender: str = ""
-        self._password: str = ""
-        self._user: str = ""
-        self._server_host: str = ""
-        self._server_port: int = 0
-        self._connection: smtplib.SMTP | None = None
-        self._retrieve_credentials()
-        if init_connection:
-            self._connect()
-
-    def _retrieve_credentials(self):
-        self.sender = current_app.config["EMAIL_SENDER"]
-        self._password = current_app.config["EMAIL_SENDER_PASS"]
-        self._user = current_app.config["EMAIL_SENDER_USER"]
-        self._server_host = current_app.config["EMAIL_SERVER"]
-        self._server_port = int(current_app.config["EMAIL_SERVER_PORT"])
-
-    def _connect(self):
-        try:
-            self._connection = smtplib.SMTP(host=self._server_host, port=self._server_port)
-            self._connection.ehlo()
-            self._connection.starttls()
-            self._connection.login(user=self._user, password=self._password)
-        except SMTPException as details:
-            current_app.logger.error("Failed to initialize smtp session %s", details)
-
-    def _is_connection_open(self):
-        if not self._connection:
-            return False
-        try:
-            status, _ =  self._connection.noop()
-        except SMTPException:
-            status = -1
-
-        return True if status == 250 else False
-
-    def _prepare_email(self, subject:str,
-                      content: str,
-                      recipients: List[str],
-                      html: bool = True):  # pylint: disable=too-many-arguments
-        msg = MIMEMultipart()
-        msg['subject'] = subject
-        msg['from'] = self.sender
-        assert recipients, "No recipients provided"
-        msg['to'] = ','.join(recipients)
-        if html:
-            text_part = MIMEText(content, "html")
-        else:
-            text_part = MIMEText(content, "plain")
-        msg.attach(text_part)
-        email = msg.as_string()
-        return email
-
-    def send(self, subject, content, recipients, html=True):  # pylint: disable=too-many-arguments
-        """
-        :param subject: text
-        :param content: text/html
-        :param recipients: iterable, list of recipients
-        :param html: True/False
-        :param files: paths of the files that will be attached to the email
-        :return:
-        """
-        email = self._prepare_email(subject, content, recipients, html)
-        self._send_email(recipients, email)
-
-    def _send_email(self, recipients, email):
-        if not self._is_connection_open():
-            self._connect()
-        self._connection.sendmail(self.sender, recipients, email)
-
-    def __del__(self):
-        if self._connection:
-            self._connection.quit()

argus/client/generic_result_old.py

@@ -1,143 +0,0 @@
-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/db/argus_json.py

@@ -1,14 +0,0 @@
-from datetime import datetime
-import json
-from uuid import UUID
-
-
-class ArgusJSONEncoder(json.JSONEncoder):
-    def default(self, obj):
-        match obj:
-            case UUID():
-                return str(obj)
-            case datetime():
-                return obj.isoformat(sep=' ', timespec='milliseconds')
-            case _:
-                return json.JSONEncoder.default(self, obj)