argus-alm 0.14.2__py3-none-any.whl → 0.15.2__py3-none-any.whl

argus/backend/models/web.py

@@ -0,0 +1,403 @@
+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
+
+from argus.backend.models.github_issue import GithubIssue, IssueLink
+from argus.backend.models.plan import ArgusReleasePlan
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData, ArgusBestResultData, ArgusGraphView
+from argus.backend.models.runtime_store import RuntimeStore
+from argus.backend.models.view_widgets import WidgetHighlights, WidgetComment
+from argus.backend.models.argus_ai import ErrorEventEmbeddings, CriticalEventEmbeddings
+
+
+def uuid_now():
+    return uuid_from_time(datetime.utcnow())
+
+
+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:
+        return UserRoles.Manager in self.roles
+
+    def is_admin(self) -> bool:
+        return UserRoles.Admin in self.roles
+
+    def set_as_admin(self) -> None:
+        if UserRoles.Admin not in self.roles:
+            self.roles.append(UserRoles.Admin.value)
+
+    def set_as_manager(self) -> None:
+        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)
+    plan_id = columns.UUID(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()
+    plugin_subtype = 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"
+    ViewActionItemAssignee = "TYPE_VIEW_ACTION_ITEM_ASSIGNEE"
+    ViewHighlightMention = "TYPE_VIEW_HIGHLIGHT_MENTION"
+
+
+class ArgusNotificationSourceTypes(str, Enum):
+    TestRun = "TEST_RUN"
+    Schedule = "SCHEDULE"
+    Comment = "COMMENT"
+    ViewActionItem = "VIEW_ACTION_ITEM"
+    ViewHighlight = "VIEW_HIGHLIGHT"
+
+
+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):
+    # FIXME: Deprecated. To be removed.
+    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] = [
+    RuntimeStore,
+    User,
+    UserOauthToken,
+    Team,
+    WebFileStorage,
+    ArgusRelease,
+    ArgusUserView,
+    ArgusGroup,
+    ArgusTest,
+    ArgusTestRunComment,
+    ArgusEvent,
+    ReleasePlannerComment,
+    ArgusNotification,
+    ArgusSchedule,
+    ArgusScheduleAssignee,
+    ArgusScheduleGroup,
+    ArgusScheduleTest,
+    ArgusGenericResultMetadata,
+    ArgusGenericResultData,
+    ArgusBestResultData,
+    ArgusReleasePlan,
+    WidgetHighlights,
+    WidgetComment,
+    ArgusGraphView,
+    ErrorEventEmbeddings,
+    CriticalEventEmbeddings,
+    GithubIssue,
+    IssueLink,
+]
+
+USED_TYPES: list[UserType] = [
+
+]

argus/backend/plugins/core.py

@@ -0,0 +1,248 @@
+import logging
+from datetime import datetime
+from math import ceil
+from uuid import UUID
+from time import time
+
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.usertype import UserType
+from flask import Blueprint
+from argus.backend.db import ScyllaCluster
+from argus.backend.models.plan import ArgusReleasePlan
+from argus.backend.models.web import (
+    ArgusTest,
+    ArgusGroup,
+    ArgusRelease,
+    ArgusScheduleGroup,
+    ArgusSchedule,
+    ArgusScheduleTest,
+    ArgusScheduleAssignee
+)
+from argus.backend.util.common import chunk
+from argus.common.enums import TestInvestigationStatus, TestStatus
+
+LOGGER = logging.getLogger(__name__)
+
+
+class PluginModelBase(Model):
+    _plugin_name = "unknown"
+    # Metadata
+    build_id = columns.Text(required=True, partition_key=True)
+    start_time = columns.DateTime(required=True, primary_key=True, clustering_order="DESC",
+                                  default=datetime.utcnow, custom_index=True)
+    id = columns.UUID(index=True, required=True)
+    release_id = columns.UUID(index=True)
+    group_id = columns.UUID(index=True)
+    test_id = columns.UUID(index=True)
+    assignee = columns.UUID(index=True)
+    status = columns.Text(default=lambda: TestStatus.CREATED.value)
+    investigation_status = columns.Text(default=lambda: TestInvestigationStatus.NOT_INVESTIGATED.value)
+    heartbeat = columns.Integer(default=lambda: int(time()))
+    end_time = columns.DateTime(default=lambda: datetime.utcfromtimestamp(0))
+    build_job_url = columns.Text()
+    product_version = columns.Text(index=True)
+
+    # Test Logs Collection
+    logs = columns.List(value_type=columns.Tuple(columns.Text(), columns.Text()))
+
+    @classmethod
+    def table_name(cls) -> str:
+        return cls.__table_name__
+
+    @classmethod
+    def _stats_query(cls) -> str:
+        raise NotImplementedError()
+
+    def assign_categories(self):
+        key = self.build_id
+        try:
+            test: ArgusTest = ArgusTest.get(build_system_id=key)
+            self.release_id = test.release_id
+            self.group_id = test.group_id
+            self.test_id = test.id
+            if not test.plugin_name or test.plugin_name != self._plugin_name:
+                test.plugin_name = self._plugin_name
+                test.save()
+        except ArgusTest.DoesNotExist:
+            LOGGER.warning("Test entity missing for key \"%s\", run won't be visible until this is corrected", key)
+
+    def get_assignment(self, version: str | None = None) -> UUID | None:
+        associated_test: ArgusTest = ArgusTest.get(build_system_id=self.build_id)
+        associated_release: ArgusRelease = ArgusRelease.get(id=associated_test.release_id)
+
+        plans: list[ArgusReleasePlan] = list(ArgusReleasePlan.filter(release_id=associated_release.id))
+
+        if version:
+            plans = [plan for plan in plans if plan.target_version == version]
+
+        for plan in plans:
+            if associated_test.group_id in plan.groups:
+                return plan.assignee_mapping.get(associated_test.group_id, plan.owner)
+            if associated_test.id in plan.tests:
+                return plan.assignee_mapping.get(associated_test.id, plan.owner)
+
+        # FIXME: Legacy fallback until we fully migrate to new plans
+        return self._legacy_get_scheduled_assignee(associated_test=associated_test, associated_release=associated_release)
+
+    def get_scheduled_assignee(self) -> UUID:
+        return self.get_assignment()
+
+    def _legacy_get_scheduled_assignee(self, associated_test: ArgusTest, associated_release: ArgusRelease) -> UUID:
+        """
+            Iterate over all schedules (groups and tests) and return first available assignee
+        """
+        associated_group = ArgusGroup.get(id=associated_test.group_id)
+
+        scheduled_groups = ArgusScheduleGroup.filter(
+            release_id=associated_release.id,
+            group_id=associated_group.id,
+        ).all()
+
+        scheduled_tests = ArgusScheduleTest.filter(
+            release_id=associated_release.id,
+            test_id=associated_test.id
+        ).all()
+
+        unique_schedule_ids = {scheduled_obj.schedule_id for scheduled_obj in [
+            *scheduled_tests, *scheduled_groups]}
+
+        schedules = ArgusSchedule.filter(
+            release_id=associated_release.id,
+            id__in=tuple(unique_schedule_ids),
+        ).all()
+
+        today = datetime.utcnow()
+
+        valid_schedules = []
+        for schedule in schedules:
+            if schedule.period_start <= today <= schedule.period_end:
+                valid_schedules.append(schedule)
+
+        assignees_uuids = []
+        for schedule in valid_schedules:
+            assignees = ArgusScheduleAssignee.filter(
+                schedule_id=schedule.id
+            ).all()
+            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_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,))
+
+        return list(rows)
+
+    @classmethod
+    def get_jobs_meta_by_test_id(cls, test_id: UUID):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare(
+            f"SELECT build_id, start_time, id, test_id, release_id, group_id, status, investigation_status FROM {cls.table_name()} WHERE test_id = ?")
+        rows = cluster.session.execute(query=query, parameters=(test_id,))
+
+        return list(rows)
+
+    @classmethod
+    def prepare_investigation_status_update_query(cls, build_id: str, start_time: datetime, new_status: TestInvestigationStatus):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare(
+            f"UPDATE {cls.table_name()} SET investigation_status = ? WHERE build_id = ? AND start_time = ?")
+        bound_query = query.bind(values=(new_status.value, build_id, start_time))
+
+        return bound_query
+
+    @classmethod
+    def get_stats_for_release(cls, release: ArgusRelease, build_ids=list[str]):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare(cls._stats_query())
+        futures = []
+        step_size = 90
+
+        for step in range(0, ceil(len(build_ids) / step_size)):
+            start_pos = step*step_size
+            next_slice = build_ids[start_pos:start_pos+step_size]
+            futures.append(cluster.session.execute_async(query=query, parameters=(next_slice,)))
+
+        return futures
+
+    @classmethod
+    def get_run_meta_by_build_id(cls, build_id: str, limit: int = 10):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
+                                f"assignee, end_time, investigation_status, heartbeat FROM {cls.table_name()} WHERE build_id = ? LIMIT ?")
+        rows = cluster.session.execute(query=query, parameters=(build_id, limit))
+
+        return list(rows)
+
+    @classmethod
+    def get_run_meta_by_run_id(cls, run_id: UUID | str):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
+                                f"assignee, end_time, investigation_status, heartbeat FROM {cls.table_name()} WHERE id = ?")
+        rows = cluster.session.execute(query=query, parameters=(run_id,))
+
+        return list(rows)
+
+    @classmethod
+    def load_test_run(cls, run_id: UUID) -> 'PluginModelBase':
+        raise NotImplementedError()
+
+    @classmethod
+    def submit_run(cls, request_data: dict) -> 'PluginModelBase':
+        raise NotImplementedError()
+
+    @classmethod
+    def get_distinct_product_versions(cls, release: ArgusRelease) -> list[str]:
+        raise NotImplementedError()
+
+    @classmethod
+    def get_distinct_versions_for_view(cls, tests: list[ArgusTest]) -> list[str]:
+        cluster = ScyllaCluster.get()
+        statement = cluster.prepare(f"SELECT scylla_version FROM {cls.table_name()} WHERE build_id IN ?")
+        futures = []
+        for batch in chunk(tests):
+            futures.append(cluster.session.execute_async(query=statement,
+                           parameters=([t.build_system_id for t in batch],)))
+
+        rows = []
+        for future in futures:
+            rows.extend(future.result())
+        unique_versions = {r["scylla_version"] for r in rows if r["scylla_version"]}
+
+        return sorted(list(unique_versions), reverse=True)
+
+    def update_heartbeat(self):
+        self.heartbeat = int(time())
+
+    def change_status(self, new_status: TestStatus):
+        self.status = new_status.value
+
+    def change_investigation_status(self, new_investigation_status: TestInvestigationStatus):
+        self.investigation_status = new_investigation_status.value
+
+    def submit_product_version(self, version: str):
+        raise NotImplementedError()
+
+    def set_full_version(self, version: str):
+        self.product_version = version
+
+    def submit_logs(self, logs: list[dict]):
+        raise NotImplementedError()
+
+    def finish_run(self, payload: dict = None):
+        raise NotImplementedError()
+
+    def sut_timestamp(self, sut_package_name) -> float:
+        raise NotImplementedError()
+
+
+class PluginInfoBase:
+    name: str
+    controller: Blueprint
+    model: PluginModelBase
+    all_models: list[Model]
+    all_types: list[UserType]