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

argus/backend/models/argus_ai.py

@@ -0,0 +1,24 @@
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.models import Model
+
+
+class ErrorEventEmbeddings(Model):
+    __table_name__ = "error_event_embeddings"
+    run_id = columns.UUID(partition_key=True)
+    event_index = columns.Integer(primary_key=True)
+    start_time = columns.DateTime(static=True)
+    embedding = columns.List(value_type=columns.Float())
+    columns.BaseCollectionColumn._freeze_db_type(embedding)
+    similars_map = columns.Map(key_type=columns.UUID(), value_type=columns.Integer())
+    columns.BaseCollectionColumn._freeze_db_type(similars_map)
+
+
+class CriticalEventEmbeddings(Model):
+    __table_name__ = "critical_event_embeddings"
+    run_id = columns.UUID(partition_key=True)
+    event_index = columns.Integer(primary_key=True)
+    start_time = columns.DateTime(static=True)
+    embedding = columns.List(value_type=columns.Float())
+    columns.BaseCollectionColumn._freeze_db_type(embedding)
+    similars_map = columns.Map(key_type=columns.UUID(), value_type=columns.Integer())
+    columns.BaseCollectionColumn._freeze_db_type(similars_map)

argus/backend/models/github_issue.py

@@ -0,0 +1,60 @@
+from enum import unique
+from uuid import uuid4
+from datetime import datetime
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.usertype import UserType
+from cassandra.cqlengine import columns
+
+
+class IssueLabel(UserType):
+    id = columns.BigInt()
+    name = columns.Text()
+    color = columns.Text()
+    description = columns.Text()
+
+    def __hash__(self) -> int:
+        return hash((self.name, self.color, self.description))
+
+    def __eq__(self, other):
+        if isinstance(other, IssueLabel):
+            return self.name == other.name and self.color == other.color and self.description == other.description
+        return super().__eq__(other)
+
+
+class IssueAssignee(UserType):
+    login = columns.Text()
+    html_url = columns.Text()
+
+
+class GithubIssue(Model):
+    id = columns.UUID(primary_key=True, default=uuid4, partition_key=True)
+    user_id = columns.UUID(index=True)  # Internal Argus UserId
+    type = columns.Text()  # Can be: issues, pulls
+    owner = columns.Text()  # Org or the user to which the repo belongs to
+    repo = columns.Text()
+    number = columns.Integer()
+    state = columns.Text()  # Possible states: open, closed
+    title = columns.Text()
+    labels = columns.List(value_type=columns.UserDefinedType(user_type=IssueLabel))
+    assignees = columns.List(value_type=columns.UserDefinedType(user_type=IssueAssignee))
+    url = columns.Text(index=True)
+    added_on = columns.DateTime(default=datetime.utcnow)
+
+    def __hash__(self) -> int:
+        return hash((self.owner, self.repo, self.number))
+
+    def __eq__(self, other):
+        if isinstance(other, GithubIssue):
+            return self.owner == other.owner and self.repo == other.repo and self.number == other.number
+        return super().__eq__(other)
+
+    def __ne__(self, other):
+        return not self == other
+
+
+class IssueLink(Model):
+    run_id = columns.UUID(primary_key=True, required=True, partition_key=True)
+    issue_id = columns.UUID(primary_key=True, required=True)
+    release_id = columns.UUID(index=True)
+    group_id = columns.UUID(index=True)
+    test_id = columns.UUID(index=True)

argus/backend/models/plan.py

@@ -0,0 +1,24 @@
+import datetime
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.usertype import UserType
+from cassandra.util import uuid_from_time
+
+
+class ArgusReleasePlan(Model):
+    id = columns.TimeUUID(partition_key=True, default=lambda: uuid_from_time(datetime.datetime.now(tz=datetime.UTC)))
+    name = columns.Text(required=True)
+    completed = columns.Boolean(default=lambda: False)
+    description = columns.Text()
+    owner = columns.UUID(required=True)
+    participants = columns.List(value_type=columns.UUID)
+    target_version = columns.Ascii(index=True)
+    assignee_mapping = columns.Map(key_type=columns.UUID, value_type=columns.UUID)
+    release_id = columns.UUID(index=True)
+    tests = columns.List(value_type=columns.UUID)
+    groups = columns.List(value_type=columns.UUID)
+    view_id = columns.UUID(index=True)
+    created_from = columns.UUID(index=True)
+    creation_time = columns.DateTime(default=lambda: datetime.datetime.now(tz=datetime.UTC))
+    last_updated = columns.DateTime(default=lambda: datetime.datetime.now(tz=datetime.UTC))
+    ends_at = columns.DateTime()

argus/backend/models/result.py

@@ -0,0 +1,187 @@
+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
+    visible = columns.Boolean(default=True)  # controls visibility in UI, True by default
+
+
+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())
+    sut_package_name = 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, new_rules: dict) -> "ArgusGenericResultMetadata":
+        """
+        Updates the validation rules based on the new input data.
+
+        For each key in new_rules:
+            - If the key exists in self.validation_rules, compare the new rule with the most recent one.
+                - If they differ, append the new rule.
+            - If the key does not exist in self.validation_rules, add the key with the new rule.
+
+        For keys in self.validation_rules but not in new_rules:
+            - If the most recent rule does not have all fields set to None, append a new rule with fields set to None.
+
+        :param new_rules: A dictionary where each key maps to a new rule dict.
+        :return: True if any rules were updated, False otherwise.
+        """
+        updated = False
+        input_data_keys = set(new_rules.keys())
+        existing_keys = set(self.validation_rules.keys())
+
+        # Handle existing keys in new input data
+        for key, new_rule_dict in new_rules.items():
+            rules_list = self.validation_rules.get(key, [])
+            most_recent_rule = rules_list[-1] if rules_list else None
+
+            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 != new_value:
+                        rules_match = False
+                        break
+            else:
+                rules_match = False  # No existing rule, need to add one
+
+            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[key] = rules_list
+                updated = True
+
+        # Handle keys missing in new input data
+        missing_keys = existing_keys - input_data_keys
+        for key in missing_keys:
+            rules_list = self.validation_rules.get(key, [])
+            most_recent_rule = rules_list[-1] if rules_list else None
+
+            fields_to_compare = [field for field in ValidationRules._fields if field != 'valid_from']
+            all_fields_none = True
+
+            if most_recent_rule:
+                for field in fields_to_compare:
+                    if getattr(most_recent_rule, field) is not None:
+                        all_fields_none = False
+                        break
+            else:
+                all_fields_none = False
+
+            if not all_fields_none:
+                new_rule = ValidationRules(
+                    valid_from=datetime.now(timezone.utc),
+                    best_pct=None,
+                    best_abs=None,
+                    fixed_limit=None
+                )
+                rules_list.append(new_rule)
+                self.validation_rules[key] = rules_list
+                updated = True
+
+        return updated
+
+    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 self.update_validation_rules(value):
+                    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_v2"
+    test_id = columns.UUID(partition_key=True)
+    name = columns.Text(partition_key=True)
+    result_date = columns.DateTime(primary_key=True, clustering_order="DESC")
+    key = columns.Ascii(primary_key=True)  # represents pair column:row
+    value = columns.Double()
+    run_id = columns.UUID()
+
+
+class ArgusGraphView(Model):
+    __table_name__ = "graph_view_v1"
+    test_id = columns.UUID(partition_key=True)
+    id = columns.UUID(primary_key=True)
+    name = columns.Text()
+    description = columns.Text()
+    # key: graph name, value: graph properties (e.g. size)
+    graphs = columns.Map(key_type=columns.Text(), value_type=columns.Ascii())

argus/backend/models/runtime_store.py

@@ -0,0 +1,58 @@
+from datetime import datetime, time
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine import columns
+
+
+class RuntimeStore(Model):
+    """
+        This model provides a way for the application to store configuration
+        data inside its database. Supports time, datetime, int, float, str, boolean values
+        and will automatically manage which type is being used.
+
+        Example:
+
+        prop = RuntimeStore()
+        prop.key = "my_property_value"
+        prop.value = 0
+        prop.save()
+
+    """
+    _type_map = {
+        float: "float",
+        bool: "boolean",
+        time: "time",
+        int: "int",
+        str: "text",
+        datetime: "datetime",
+    }
+    key = columns.Text(primary_key=True, partition_key=True, required=True)
+    value_type = columns.Ascii(required=True)
+    value_int = columns.Integer()
+    value_text = columns.Text()
+    value_ts = columns.Time()
+    value_date = columns.DateTime()
+    value_float = columns.Double()
+    value_boolean = columns.Boolean()
+
+    @property
+    def value(self) -> int | str | float | datetime:
+        match self.value_type:
+            case "float": return self.value_float
+            case "time": return self.value_ts
+            case "int": return self.value_int
+            case "text": return self.value_text
+            case "boolean": return self.value_boolean
+            case "datetime": return self.value_date
+
+    @value.setter
+    def value(self, v):
+        if not (type_name := self._type_map.get(type(v))):
+            raise ValueError(f"Unsupported type: {type(v)}")
+        match type_name:
+            case "float": self.value_float = v
+            case "time": self.value_ts = v
+            case "int": self.value_int = v
+            case "text": self.value_text = v
+            case "boolean": self.value_boolean = v
+            case "datetime": self.value_date = v
+        self.value_type = type_name

argus/backend/models/view_widgets.py

@@ -0,0 +1,25 @@
+from datetime import datetime, UTC
+
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.models import Model
+
+
+class WidgetHighlights(Model):
+    view_id = columns.UUID(partition_key=True, required=True)
+    index = columns.Integer(partition_key=True, required=True)
+    created_at = columns.DateTime(primary_key=True, clustering_order="DESC")
+    archived_at = columns.DateTime(default=datetime.fromtimestamp(0, tz=UTC))
+    creator_id = columns.UUID()
+    assignee_id = columns.UUID()
+    content = columns.Text()
+    completed = columns.Boolean(default=lambda: None)  # None means it's highlight, not an action item
+    comments_count = columns.TinyInt()
+
+
+class WidgetComment(Model):
+    view_id = columns.UUID(partition_key=True, required=True)
+    index = columns.Integer(partition_key=True, required=True)
+    highlight_at = columns.DateTime(partition_key=True, required=True)  # reference to WidgetHighlights.created_at
+    created_at = columns.DateTime(primary_key=True)
+    creator_id = columns.UUID()
+    content = columns.Text()