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

argus/backend/db.py

@@ -1,100 +0,0 @@
-from functools import cached_property
-import logging
-from typing import Optional
-from flask import g, Flask
-# pylint: disable=no-name-in-module
-from cassandra.policies import WhiteListRoundRobinPolicy
-from cassandra import ConsistencyLevel
-from cassandra.cluster import ExecutionProfile, EXEC_PROFILE_DEFAULT, Cluster
-from cassandra.cluster import PreparedStatement
-from cassandra.cqlengine.management import sync_table, sync_type
-from cassandra.cqlengine import connection
-from cassandra.query import dict_factory
-from cassandra.auth import PlainTextAuthProvider
-from argus.backend.util.config import Config
-
-from argus.backend.models.web import USED_MODELS, USED_TYPES
-
-LOGGER = logging.getLogger(__name__)
-
-
-class ScyllaCluster:
-    # pylint: disable=too-many-instance-attributes
-    APP_INSTANCE: Optional['ScyllaCluster'] = None
-
-    def __init__(self, config=None):
-        if not config:
-            config = Config.load_yaml_config()
-        self.config = config
-        self.auth_provider = PlainTextAuthProvider(
-            username=config["SCYLLA_USERNAME"], password=config["SCYLLA_PASSWORD"])
-        self.lb_policy = WhiteListRoundRobinPolicy(hosts=config["SCYLLA_CONTACT_POINTS"])
-        self.execution_profile = ExecutionProfile(
-            load_balancing_policy=self.lb_policy, consistency_level=ConsistencyLevel.QUORUM)
-        connection.setup(hosts=config["SCYLLA_CONTACT_POINTS"], default_keyspace=config["SCYLLA_KEYSPACE_NAME"],
-                         auth_provider=self.auth_provider,
-                         protocol_version=4,
-                         execution_profiles={EXEC_PROFILE_DEFAULT: self.execution_profile})
-        self.cluster: Cluster = connection.get_cluster(connection='default')
-        self.prepared_statements = {}
-        self.read_exec_profile = ExecutionProfile(
-            consistency_level=ConsistencyLevel.ONE,
-            row_factory=dict_factory,
-            load_balancing_policy=self.lb_policy
-        )
-        self.read_named_tuple_exec_profile = ExecutionProfile(
-            consistency_level=ConsistencyLevel.ONE,
-            load_balancing_policy=self.lb_policy
-        )
-        self.cluster.add_execution_profile("read_fast", self.read_exec_profile)
-        self.cluster.add_execution_profile("read_fast_named_tuple", self.read_named_tuple_exec_profile)
-
-    @cached_property
-    def session(self):
-        return self.cluster.connect(keyspace=self.config["SCYLLA_KEYSPACE_NAME"])
-
-    @classmethod
-    def get(cls, config: dict = None) -> 'ScyllaCluster':
-        if cls.APP_INSTANCE:
-            return cls.APP_INSTANCE
-
-        cls.APP_INSTANCE = cls(config)
-        return cls.APP_INSTANCE
-
-    @classmethod
-    def shutdown(cls):
-        if cls.APP_INSTANCE:
-            cls.APP_INSTANCE.cluster.shutdown()
-            cls.APP_INSTANCE = None
-
-    def prepare(self, query: str) -> PreparedStatement:
-        if not (statement := self.prepared_statements.get(query)):
-            LOGGER.info("Unprepared statement %s, preparing...", query)
-            statement = self.session.prepare(query=query)
-            self.prepared_statements[query] = statement
-        return statement
-
-    def sync_core_tables(self):
-        for udt in USED_TYPES:
-            LOGGER.info("Syncing type: %s..", udt.__name__)
-            sync_type(ks_name=self.config["SCYLLA_KEYSPACE_NAME"], type_model=udt)
-        LOGGER.info("Core Types synchronized.")
-        for model in USED_MODELS:
-            LOGGER.info("Syncing model: %s..", model.__name__)
-            sync_table(model, keyspaces=[self.config["SCYLLA_KEYSPACE_NAME"]])
-        LOGGER.info("Core Models synchronized.")
-
-    @classmethod
-    def get_session(cls):
-        cluster = cls.get()
-        if 'scylla_session' not in g:
-            g.scylla_session = cluster.session  # pylint: disable=assigning-non-slot
-        return g.scylla_session
-
-    @classmethod
-    def close_session(cls, error=None):  # pylint: disable=unused-argument
-        g.pop("scylla_session", None)
-
-    @classmethod
-    def attach_to_app(cls, app: Flask):
-        app.teardown_appcontext(cls.close_session)

argus/backend/error_handlers.py

@@ -1,21 +0,0 @@
-import logging
-from traceback import format_exception
-from flask import request
-
-LOGGER = logging.getLogger(__name__)
-
-
-class APIException(Exception):
-    pass
-
-
-def handle_api_exception(exception: Exception):
-    LOGGER.error("Exception in %s\n%s", request.endpoint, "".join(format_exception(exception)))
-
-    return {
-        "status": "error",
-        "response": {
-            "exception": exception.__class__.__name__,
-            "arguments": exception.args
-        }
-    }

argus/backend/events/event_processors.py

@@ -1,34 +0,0 @@
-from argus.backend.models.web import ArgusEventTypes
-
-
-def event_process_posted_comment(event: dict) -> dict:
-    return event["message"].format(**event)
-
-
-def event_process_status_changed(event: dict) -> dict:
-    return event["message"].format(**event)
-
-
-def event_process_investigation_status_changed(event: dict) -> dict:
-    return event["message"].format(**event)
-
-
-def event_process_assignee_changed(event: dict) -> dict:
-    return event["message"].format(**event)
-
-
-def event_process_issue_added(event: dict) -> dict:
-    return event["message"].format(**event)
-
-
-EVENT_PROCESSORS = {
-    ArgusEventTypes.AssigneeChanged: event_process_assignee_changed,
-    ArgusEventTypes.TestRunStatusChanged: event_process_status_changed,
-    ArgusEventTypes.TestRunCommentPosted: event_process_posted_comment,
-    ArgusEventTypes.TestRunCommentUpdated: event_process_posted_comment,
-    ArgusEventTypes.TestRunCommentDeleted: event_process_posted_comment,
-    ArgusEventTypes.TestRunIssueAdded: event_process_issue_added,
-    ArgusEventTypes.TestRunIssueRemoved: event_process_issue_added,
-    ArgusEventTypes.TestRunInvestigationStatusChanged: event_process_investigation_status_changed,
-    ArgusEventTypes.TestRunBatchInvestigationStatusChange: event_process_investigation_status_changed,
-}

argus/backend/models/result.py

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

argus/backend/models/web.py

@@ -1,389 +0,0 @@
-from uuid import UUID, uuid1, uuid4
-from datetime import datetime
-from enum import Enum, IntEnum, auto
-from cassandra.cqlengine.models import Model
-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, ArgusBestResultData
-
-
-def uuid_now():
-    return uuid_from_time(datetime.utcnow())
-
-# pylint: disable=invalid-name
-
-
-class ArgusTestException(Exception):
-    pass
-
-
-class UserRoles(str, Enum):
-    User = "ROLE_USER"
-    Manager = "ROLE_MANAGER"
-    Admin = "ROLE_ADMIN"
-
-
-class User(Model):
-    id = columns.UUID(primary_key=True, default=uuid4)
-    username = columns.Text(index=True)
-    full_name = columns.Text()
-    password = columns.Text()
-    email = columns.Text(index=True)
-    registration_date = columns.DateTime()
-    roles = columns.List(value_type=columns.Text)
-    picture_id = columns.UUID(default=None)
-    api_token = columns.Text(index=True)
-
-    def __hash__(self) -> int:
-        return hash(self.id)
-
-    def is_manager(self) -> bool:
-        # pylint: disable=unsupported-membership-test
-        return UserRoles.Manager in self.roles
-
-    def is_admin(self) -> bool:
-        # pylint: disable=unsupported-membership-test
-        return UserRoles.Admin in self.roles
-
-    def set_as_admin(self) -> None:
-        # pylint: disable=unsupported-membership-test
-        if UserRoles.Admin not in self.roles:
-            self.roles.append(UserRoles.Admin.value)
-
-    def set_as_manager(self) -> None:
-        # pylint: disable=unsupported-membership-test
-        if UserRoles.Manager not in self.roles:
-            self.roles.append(UserRoles.Manager.value)
-
-    def get_id(self):
-        return str(self.id)
-
-    @classmethod
-    def exists(cls, user_id: UUID):
-        try:
-            user = cls.get(id=user_id)
-            if user:
-                return user
-        except cls.DoesNotExist:
-            pass
-        return None
-
-    @classmethod
-    def exists_by_name(cls, name: str):
-        try:
-            user = cls.get(username=name)
-            if user:
-                return user
-        except cls.DoesNotExist:
-            pass
-        return None
-
-    def __str__(self):
-        return f"User('{self.id}','{self.username}')"
-
-    def to_json(self):
-        return {
-            "id": str(self.id),
-            "username": self.username,
-            "full_name": self.full_name,
-            "picture_id": self.picture_id
-        }
-
-
-class Team(Model):
-    id = columns.UUID(primary_key=True, default=uuid4)
-    name = columns.Text(required=True)
-    leader = columns.UUID(index=True, required=True)
-    members = columns.List(value_type=columns.UUID)
-    motd = columns.Text()
-
-class UserOauthToken(Model):
-    id = columns.UUID(primary_key=True, default=uuid4)
-    user_id = columns.UUID(index=True, required=True)
-    kind = columns.Text(required=True, index=True)
-    token = columns.Text(required=True)
-
-
-class ArgusRelease(Model):
-    __table_name__ = "argus_release_v2"
-    id = columns.UUID(primary_key=True, default=uuid4)
-    name = columns.Text(index=True, required=True)
-    pretty_name = columns.Text()
-    description = columns.Text()
-    github_repo_url = columns.Text()
-    valid_version_regex = columns.Text()
-    assignee = columns.List(value_type=columns.UUID)
-    picture_id = columns.UUID()
-    enabled = columns.Boolean(default=lambda: True)
-    perpetual = columns.Boolean(default=lambda: False)
-    dormant = columns.Boolean(default=lambda: False)
-
-    def __eq__(self, other):
-        if isinstance(other, ArgusRelease):
-            return self.name == other.name
-        else:
-            return super().__eq__(other)
-
-
-class ArgusGroup(Model):
-    __table_name__ = "argus_group_v2"
-    id = columns.UUID(primary_key=True, default=uuid4)
-    release_id = columns.UUID(required=True, index=True)
-    name = columns.Text(required=True, index=True)
-    pretty_name = columns.Text()
-    description = columns.Text()
-    assignee = columns.List(value_type=columns.UUID)
-    build_system_id = columns.Text()
-    enabled = columns.Boolean(default=lambda: True)
-
-    def __hash__(self) -> int:
-        return hash((self.id, self.release_id))
-
-    def __eq__(self, other):
-        if isinstance(other, ArgusGroup):
-            return self.name == other.name and self.release_id == other.release_id
-        else:
-            return super().__eq__(other)
-
-
-class ArgusUserView(Model):
-    id = columns.UUID(primary_key=True, partition_key=True, default=uuid4)
-    name = columns.Text(required=True, index=True)
-    display_name = columns.Text()
-    description = columns.Text()
-    user_id = columns.UUID(required=True, index=True)
-    tests = columns.List(value_type=columns.UUID, default=lambda: [])
-    release_ids = columns.List(value_type=columns.UUID, default=lambda: [])
-    group_ids = columns.List(value_type=columns.UUID, default=lambda: [])
-    created = columns.DateTime(default=datetime.utcnow)
-    last_updated = columns.DateTime(default=datetime.utcnow)
-    widget_settings = columns.Text(required=True)
-
-
-class ArgusTest(Model):
-    __table_name__ = "argus_test_v2"
-    id = columns.UUID(primary_key=True, default=uuid4)
-    group_id = columns.UUID(required=True, index=True)
-    release_id = columns.UUID(required=True, index=True)
-    name = columns.Text(required=True, index=True)
-    pretty_name = columns.Text()
-    description = columns.Text()
-    assignee = columns.List(value_type=columns.UUID)
-    build_system_id = columns.Text(index=True)
-    enabled = columns.Boolean(default=lambda: True)
-    build_system_url = columns.Text()
-    plugin_name = columns.Text()
-
-    def __eq__(self, other):
-        if isinstance(other, ArgusTest):
-            return self.name == other.name and self.group_id == other.group_id and self.release_id == other.release_id
-        else:
-            return super().__eq__(other)
-
-    def validate_build_system_id(self):
-        try:
-            t = ArgusTest.get(build_system_id=self.build_system_id)
-            if t.id != self.id:
-                raise ArgusTestException("Build Id is already used by another test", t.id, self.id)
-        except ArgusTest.DoesNotExist:
-            pass
-
-
-class ArgusTestRunComment(Model):
-    id = columns.UUID(primary_key=True, default=uuid4, partition_key=True)
-    test_run_id = columns.UUID(required=True, index=True)
-    user_id = columns.UUID(required=True, index=True)
-    release_id = columns.UUID(required=True, index=True)
-    test_id = columns.UUID(required=True, index=True)
-    posted_at = columns.Integer(
-        required=True, clustering_order="desc", primary_key=True)
-    message = columns.Text(min_length=1, max_length=65535)
-    mentions = columns.List(value_type=columns.UUID, default=[])
-    reactions = columns.Map(key_type=columns.Text, value_type=columns.Integer)
-
-
-class ArgusEventTypes(str, Enum):
-    AssigneeChanged = "ARGUS_ASSIGNEE_CHANGE"
-    TestRunStatusChanged = "ARGUS_TEST_RUN_STATUS_CHANGE"
-    TestRunInvestigationStatusChanged = "ARGUS_TEST_RUN_INVESTIGATION_STATUS_CHANGE"
-    TestRunBatchInvestigationStatusChange = "ARGUS_TEST_RUN_INVESTIGATION_BATCH_STATUS_CHANGE"
-    TestRunCommentPosted = "ARGUS_TEST_RUN_COMMENT_POSTED"
-    TestRunCommentUpdated = "ARGUS_TEST_RUN_COMMENT_UPDATED"
-    TestRunCommentDeleted = "ARGUS_TEST_RUN_COMMENT_DELETED"
-    TestRunIssueAdded = "ARGUS_TEST_RUN_ISSUE_ADDED"
-    TestRunIssueRemoved = "ARGUS_TEST_RUN_ISSUE_REMOVED"
-
-
-class ArgusEvent(Model):
-    id = columns.UUID(primary_key=True, default=uuid4, partition_key=True)
-    release_id = columns.UUID(index=True)
-    group_id = columns.UUID(index=True)
-    test_id = columns.UUID(index=True)
-    run_id = columns.UUID(index=True)
-    user_id = columns.UUID(index=True)
-    kind = columns.Text(required=True, index=True)
-    body = columns.Text(required=True)
-    created_at = columns.DateTime(required=True)
-
-
-class ArgusNotificationTypes(str, Enum):
-    Mention = "TYPE_MENTION"
-    StatusChange = "TYPE_STATUS_CHANGE"
-    AssigneeChange = "TYPE_ASSIGNEE_CHANGE"
-    ScheduleChange = "TYPE_SCHEDULE_CHANGE"
-
-
-class ArgusNotificationSourceTypes(str, Enum):
-    TestRun = "TEST_RUN"
-    Schedule = "SCHEDULE"
-    Comment = "COMMENT"
-
-
-class ArgusNotificationState(IntEnum):
-    UNREAD = auto()
-    READ = auto()
-
-
-class ArgusNotification(Model):
-    receiver = columns.UUID(primary_key=True, partition_key=True)
-    id = columns.TimeUUID(primary_key=True, clustering_order="DESC", default=uuid_now)
-    type = columns.Text(required=True)
-    state = columns.SmallInt(required=True, default=lambda: ArgusNotificationState.UNREAD)
-    sender = columns.UUID(required=True)
-    source_type = columns.Text(required=True)
-    source_id = columns.UUID(required=True)
-    title = columns.Text(required=True, max_length=1024)
-    content = columns.Text(required=True, max_length=65535)
-
-    def to_dict_short_summary(self) -> dict:
-        return {
-            "receiver": self.receiver,
-            "sender": self.sender,
-            "id": self.id,
-            "created": unix_time_from_uuid1(self.id) * 1000,
-            "title": self.title,
-            "state": self.state,
-        }
-
-    def to_dict(self) -> dict:
-        return {
-            "receiver": self.receiver,
-            "sender": self.sender,
-            "id": self.id,
-            "created": unix_time_from_uuid1(self.id) * 1000,
-            "title": self.title,
-            "type": self.type,
-            "content": self.content,
-            "source": self.source_type,
-            "source_id": self.source_id,
-            "state": self.state,
-        }
-
-
-class ArgusGithubIssue(Model):
-    # pylint: disable=too-many-instance-attributes
-    id = columns.UUID(primary_key=True, default=uuid4, partition_key=True)
-    added_on = columns.DateTime(default=datetime.utcnow)
-    release_id = columns.UUID(index=True)
-    group_id = columns.UUID(index=True)
-    test_id = columns.UUID(index=True)
-    run_id = columns.UUID(index=True)
-    user_id = columns.UUID(index=True)
-    type = columns.Text()
-    owner = columns.Text()
-    repo = columns.Text()
-    issue_number = columns.Integer()
-    last_status = columns.Text()
-    title = columns.Text()
-    url = columns.Text()
-
-    def __hash__(self) -> int:
-        return hash((self.owner, self.repo, self.issue_number))
-
-    def __eq__(self, other):
-        if isinstance(other, ArgusGithubIssue):
-            return self.owner == other.owner and self.repo == other.repo and self.issue_number == other.issue_number
-        return super().__eq__(other)
-
-    def __ne__(self, other):
-        return not self == other
-
-
-class ArgusSchedule(Model):
-    __table_name__ = "argus_schedule_v4"
-    release_id = columns.UUID(primary_key=True, required=True)
-    id = columns.TimeUUID(primary_key=True, default=uuid1, clustering_order="DESC")
-    period_start = columns.DateTime(required=True, default=datetime.utcnow)
-    period_end = columns.DateTime(required=True, primary_key=True, clustering_order="DESC")
-    tag = columns.Text(default="")
-
-
-class ArgusScheduleAssignee(Model):
-    __table_name__ = "argus_schedule_user_v3"
-    assignee = columns.UUID(primary_key=True)
-    id = columns.TimeUUID(primary_key=True, default=uuid1,
-                          clustering_order="DESC")
-    schedule_id = columns.TimeUUID(required=True, index=True)
-    release_id = columns.UUID(required=True)
-
-
-class ArgusScheduleTest(Model):
-    __table_name__ = "argus_schedule_test_v5"
-    test_id = columns.UUID(primary_key=True, required=True)
-    id = columns.TimeUUID(primary_key=True, default=uuid1,
-                          clustering_order="DESC")
-    schedule_id = columns.TimeUUID(required=True, index=True)
-    release_id = columns.UUID(partition_key=True)
-
-
-class ArgusScheduleGroup(Model):
-    __table_name__ = "argus_schedule_group_v3"
-    group_id = columns.UUID(partition_key=True, required=True)
-    id = columns.TimeUUID(primary_key=True, default=uuid1,
-                          clustering_order="DESC")
-    schedule_id = columns.TimeUUID(required=True, index=True)
-    release_id = columns.UUID(partition_key=True)
-
-
-class ReleasePlannerComment(Model):
-    __table_name__ = "argus_planner_comment_v2"
-    release = columns.UUID(primary_key=True)
-    group = columns.UUID(primary_key=True)
-    test = columns.UUID(primary_key=True)
-    comment = columns.Text(default=lambda: "")
-
-
-class WebFileStorage(Model):
-    id = columns.UUID(primary_key=True, default=uuid4)
-    filepath = columns.Text(min_length=1)
-    filename = columns.Text(min_length=1)
-
-
-USED_MODELS: list[Model] = [
-    User,
-    UserOauthToken,
-    Team,
-    WebFileStorage,
-    ArgusRelease,
-    ArgusUserView,
-    ArgusGroup,
-    ArgusTest,
-    ArgusTestRunComment,
-    ArgusEvent,
-    ArgusGithubIssue,
-    ReleasePlannerComment,
-    ArgusNotification,
-    ArgusSchedule,
-    ArgusScheduleAssignee,
-    ArgusScheduleGroup,
-    ArgusScheduleTest,
-    ArgusGenericResultMetadata,
-    ArgusGenericResultData,
-    ArgusBestResultData,
-]
-
-USED_TYPES: list[UserType] = [
-
-]