NEMO-monitors 1.0.0__tar.gz

nemo_monitors-1.0.0/LICENSE

@@ -0,0 +1,6 @@
+# NIST Software Licensing Statement
+NIST-developed software is provided by NIST as a public service. You may use, copy, and distribute copies of the software in any medium, provided that you keep intact this entire notice. You may improve, modify, and create derivative works of the software or any portion of the software, and you may copy and distribute such modifications or works. Modified works should carry a notice stating that you changed the software and should note the date and nature of any such change. Please explicitly acknowledge the National Institute of Standards and Technology as the source of the software.
+
+NIST-developed software is expressly provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED, IN FACT, OR ARISING BY OPERATION OF LAW, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND DATA ACCURACY. NIST NEITHER REPRESENTS NOR WARRANTS THAT THE OPERATION OF THE SOFTWARE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ANY DEFECTS WILL BE CORRECTED. NIST DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF THE SOFTWARE OR THE RESULTS THEREOF, INCLUDING BUT NOT LIMITED TO THE CORRECTNESS, ACCURACY, RELIABILITY, OR USEFULNESS OF THE SOFTWARE.
+
+You are solely responsible for determining the appropriateness of using and distributing the software and you assume all risks associated with its use, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and the unavailability or interruption of operation. This software is not intended to be used in any situation where a failure could cause risk of injury or damage to property. The software developed by NIST employees is not subject to copyright protection within the United States.

nemo_monitors-1.0.0/NEMO_monitors/admin.py

@@ -0,0 +1,207 @@
+from django import forms
+from django.contrib import admin, messages
+from django.contrib.admin import register
+from django.contrib.admin.decorators import display
+from django.urls import reverse
+from django.utils.safestring import mark_safe
+
+from NEMO_monitors.models import (
+    DEFAULT_DATA_ENTRY_FIELDS,
+    Monitor,
+    MonitorAlertEmail,
+    MonitorAlertLog,
+    MonitorColumn,
+    MonitorData,
+)
+from NEMO.typing import QuerySetType
+from NEMO.utilities import new_model_copy
+
+
+def duplicate_monitor_configuration(model_admin, request, queryset: QuerySetType[Monitor]):
+    for monitor in queryset:
+        original_name = monitor.name
+        new_name = "Copy of " + monitor.name
+        try:
+            existing = Monitor.objects.filter(name=new_name, tool=monitor.tool)
+            if existing.exists():
+                messages.error(
+                    request,
+                    mark_safe(
+                        f'There is already a copy of {original_name} as '
+                        f'<a href="{reverse("admin:monitors_monitor_change", args=[existing.first().id])}">{new_name}</a>. '
+                        f'Change the copy\'s name and try again'
+                    ),
+                )
+                continue
+            new_monitor: Monitor = new_model_copy(monitor)
+            new_monitor.name = new_name
+            new_monitor.last_read = None
+            new_monitor.last_value = None
+            new_monitor.save()
+            messages.success(
+                request,
+                mark_safe(
+                    f'A duplicate of {original_name} has been made as '
+                    f'<a href="{reverse("admin:monitors_monitor_change", args=[new_monitor.id])}">{new_monitor.name}</a>'
+                ),
+            )
+        except Exception as error:
+            messages.error(
+                request, f"{original_name} could not be duplicated because of the following error: {str(error)}"
+            )
+
+
+@admin.action(description="Hide selected monitors")
+def hide_selected_monitors(model_admin, request, queryset: QuerySetType[Monitor]):
+    for monitor in queryset:
+        monitor.visible = False
+        monitor.save(update_fields=["visible"])
+
+
+@admin.action(description="Show selected monitors")
+def show_selected_monitors(model_admin, request, queryset: QuerySetType[Monitor]):
+    for monitor in queryset:
+        monitor.visible = True
+        monitor.save(update_fields=["visible"])
+
+
+@admin.action(description="Disable selected alerts")
+def disable_selected_alerts(model_admin, request, queryset: QuerySetType[MonitorAlertEmail]):
+    for monitor_alert in queryset:
+        monitor_alert.enabled = False
+        monitor_alert.save(update_fields=["enabled"])
+
+
+@admin.action(description="Enable selected alerts")
+def enable_selected_alerts(model_admin, request, queryset: QuerySetType[MonitorAlertEmail]):
+    for monitor_alert in queryset:
+        monitor_alert.enabled = True
+        monitor_alert.save(update_fields=["enabled"])
+
+
+class MonitorAdminForm(forms.ModelForm):
+    class Meta:
+        model = Monitor
+        exclude = ("last_read", "last_value")
+
+
+class MonitorColumnInline(admin.TabularInline):
+    model = MonitorColumn
+    fields = (
+        "name",
+        "data_type",
+        "unit_label",
+        "order",
+        "control_limits_mode",
+        "fixed_limit_min",
+        "fixed_limit_max",
+    )
+    ordering = ("order", "name")
+    verbose_name = "Data entry field"
+    verbose_name_plural = "Data entry fields"
+
+    def get_extra(self, request, obj=None, **kwargs):
+        if obj is None:
+            return len(DEFAULT_DATA_ENTRY_FIELDS)
+        return 1
+
+    def get_formset(self, request, obj=None, **kwargs):
+        formset_class = super().get_formset(request, obj, **kwargs)
+
+        class MonitorColumnFormSet(formset_class):
+            def __init__(self, *args, **inner_kwargs):
+                super().__init__(*args, **inner_kwargs)
+                if obj is None and not self.data:
+                    for index, (name, data_type) in enumerate(DEFAULT_DATA_ENTRY_FIELDS):
+                        if index < len(self.forms):
+                            self.forms[index].initial = {"name": name, "data_type": data_type, "order": index}
+
+        return MonitorColumnFormSet
+
+
+@register(Monitor)
+class MonitorAdmin(admin.ModelAdmin):
+    search_fields = ["name", "tool__name"]
+    form = MonitorAdminForm
+    inlines = [MonitorColumnInline]
+    list_display = (
+        "id",
+        "name",
+        "tool",
+        "visible",
+        "last_read",
+        "last_value",
+    )
+    list_filter = (
+        "visible",
+        ("tool", admin.RelatedOnlyFieldListFilter),
+    )
+    actions = [duplicate_monitor_configuration, hide_selected_monitors, show_selected_monitors]
+    autocomplete_fields = ["tool"]
+
+
+@register(MonitorData)
+class MonitorDataAdmin(admin.ModelAdmin):
+    list_display = (
+        "created_date",
+        "monitor",
+        "get_column_name",
+        "value",
+        "string_value",
+        "get_display_value",
+        "created_by",
+        "created_on",
+        "updated_by",
+        "updated_on",
+    )
+    date_hierarchy = "created_date"
+    list_filter = (
+        ("monitor", admin.RelatedOnlyFieldListFilter),
+        ("column", admin.RelatedOnlyFieldListFilter),
+        ("created_by", admin.RelatedOnlyFieldListFilter),
+    )
+    autocomplete_fields = ["monitor", "created_by", "updated_by"]
+    readonly_fields = ["created_on", "updated_on"]
+    search_fields = ("monitor__name", "monitor__tool__name", "created_by__username", "notes")
+
+    @display(ordering="column__name", description="Data entry field")
+    def get_column_name(self, obj: MonitorData):
+        return obj.column.name if obj.column else ""
+
+    @display(description="Display value")
+    def get_display_value(self, obj: MonitorData):
+        return obj.display_value()
+
+    def save_model(self, request, obj: MonitorData, form, change):
+        if not change and not obj.created_by_id:
+            obj.created_by = request.user
+        obj.updated_by = request.user
+        super().save_model(request, obj, form, change)
+
+
+@register(MonitorAlertEmail)
+class MonitorAlertEmailAdmin(admin.ModelAdmin):
+    list_display = (
+        "monitor",
+        "column",
+        "enabled",
+        "trigger_condition",
+        "trigger_no_data",
+        "recipient_emails",
+        "triggered_on",
+    )
+    actions = [disable_selected_alerts, enable_selected_alerts]
+    autocomplete_fields = ["monitor"]
+
+
+@register(MonitorAlertLog)
+class MonitorAlertLogAdmin(admin.ModelAdmin):
+    list_display = ["id", "time", "monitor", "column", "reset", "value"]
+    list_filter = [("monitor", admin.RelatedOnlyFieldListFilter), "value", "reset"]
+    date_hierarchy = "time"
+
+    def has_add_permission(self, request):
+        return False
+
+    def has_change_permission(self, request, obj=None):
+        return False

nemo_monitors-1.0.0/NEMO_monitors/alerts.py

@@ -0,0 +1,36 @@
+from logging import getLogger
+
+from NEMO_monitors.models import Monitor, MonitorAlert, MonitorData
+
+alerts_logger = getLogger(__name__)
+
+
+def process_alerts_for_monitor_data(monitor: Monitor, monitor_data: MonitorData = None):
+    """Run every enabled alert for this monitor, optionally scoped to one data point."""
+    try:
+        monitor_alerts = []
+        for sub_class in MonitorAlert.__subclasses__():
+            monitor_alerts.extend(sub_class.objects.filter(enabled=True, monitor=monitor))
+        for alert in monitor_alerts:
+            if (
+                monitor_data is not None
+                and alert.column_id
+                and monitor_data.column_id != alert.column_id
+            ):
+                continue
+            alert.process(monitor_data)
+    except Exception as e:
+        alerts_logger.error(e)
+
+
+def process_alerts(monitor: Monitor, monitor_data: MonitorData = None):
+    """Backward-compatible alias for process_alerts_for_monitor_data."""
+    process_alerts_for_monitor_data(monitor, monitor_data)
+
+
+def process_alerts_after_bulk_create(monitor: Monitor, created_rows):
+    """Process alerts after bulk_create (which does not fire post_save signals)."""
+    if not created_rows:
+        return
+    for row in created_rows:
+        process_alerts_for_monitor_data(monitor, row)

nemo_monitors-1.0.0/NEMO_monitors/api.py

@@ -0,0 +1,118 @@
+from NEMO.serializers import ModelSerializer
+from NEMO.views.api import ModelViewSet, boolean_filters, datetime_filters, key_filters, number_filters, string_filters
+from drf_excel.mixins import XLSXFileMixin
+from rest_flex_fields.serializers import FlexFieldsSerializerMixin
+from rest_framework.serializers import DateTimeField
+from rest_framework.viewsets import ReadOnlyModelViewSet
+
+from NEMO_monitors.models import (
+    Monitor,
+    MonitorAlertEmail,
+    MonitorAlertLog,
+    MonitorData,
+)
+
+
+class MonitorSerializer(FlexFieldsSerializerMixin, ModelSerializer):
+    class Meta:
+        model = Monitor
+        fields = "__all__"
+        expandable_fields = {
+            "tool": "NEMO.serializers.ToolSerializer",
+        }
+
+
+class MonitorDataSerializer(FlexFieldsSerializerMixin, ModelSerializer):
+    created_date = DateTimeField()
+    created_on = DateTimeField(read_only=True)
+    updated_on = DateTimeField(read_only=True)
+
+    class Meta:
+        model = MonitorData
+        fields = "__all__"
+        read_only_fields = ("created_on", "updated_on")
+        expandable_fields = {
+            "monitor": "NEMO_monitors.api.MonitorSerializer",
+            "created_by": "NEMO.serializers.UserSerializer",
+            "updated_by": "NEMO.serializers.UserSerializer",
+        }
+
+
+class MonitorAlertEmailSerializer(FlexFieldsSerializerMixin, ModelSerializer):
+    class Meta:
+        model = MonitorAlertEmail
+        fields = "__all__"
+        expandable_fields = {
+            "monitor": "NEMO_monitors.api.MonitorSerializer",
+        }
+
+
+class MonitorAlertLogSerializer(FlexFieldsSerializerMixin, ModelSerializer):
+    class Meta:
+        model = MonitorAlertLog
+        fields = "__all__"
+        expandable_fields = {
+            "monitor": "NEMO_monitors.api.MonitorSerializer",
+        }
+
+
+class MonitorViewSet(ModelViewSet):
+    filename = "monitors"
+    queryset = Monitor.objects.all()
+    serializer_class = MonitorSerializer
+    filterset_fields = {
+        "id": key_filters,
+        "name": string_filters,
+        "visible": boolean_filters,
+        "tool": key_filters,
+        "last_read": datetime_filters,
+        "last_value": number_filters,
+    }
+
+
+class MonitorDataViewSet(ModelViewSet):
+    filename = "monitor_data"
+    queryset = MonitorData.objects.all()
+    serializer_class = MonitorDataSerializer
+    filterset_fields = {
+        "id": key_filters,
+        "monitor": key_filters,
+        "created_date": datetime_filters,
+        "created_on": datetime_filters,
+        "updated_on": datetime_filters,
+        "created_by": key_filters,
+        "updated_by": key_filters,
+        "value": number_filters,
+        "notes": string_filters,
+    }
+
+
+class MonitorAlertEmailViewSet(ModelViewSet):
+    filename = "monitor_alert_emails"
+    queryset = MonitorAlertEmail.objects.all()
+    serializer_class = MonitorAlertEmailSerializer
+    filterset_fields = {
+        "id": key_filters,
+        "enabled": boolean_filters,
+        "monitor": key_filters,
+        "trigger_no_data": boolean_filters,
+        "trigger_condition": string_filters,
+        "triggered_on": datetime_filters,
+        "column": key_filters,
+        "recipient_emails": string_filters,
+    }
+
+
+class MonitorAlertLogViewSet(XLSXFileMixin, ReadOnlyModelViewSet):
+    filename = "monitor_alert_logs"
+    queryset = MonitorAlertLog.objects.all()
+    serializer_class = MonitorAlertLogSerializer
+    filterset_fields = {
+        "id": key_filters,
+        "monitor": key_filters,
+        "time": datetime_filters,
+        "value": number_filters,
+        "reset": boolean_filters,
+        "condition": string_filters,
+        "no_data": boolean_filters,
+    }

nemo_monitors-1.0.0/NEMO_monitors/apps.py

@@ -0,0 +1,31 @@
+from importlib.metadata import PackageNotFoundError
+
+from django.apps import AppConfig
+
+# Wheel / PyPI name from pyproject.toml [project].name — NOT the same as AppConfig.name
+DISTRIBUTION_NAME = "NEMO-monitors"
+
+
+class MonitorsConfig(AppConfig):
+    name = "NEMO_monitors"
+    label = "monitors"
+    verbose_name = "Monitors"
+    default_auto_field = "django.db.models.AutoField"
+
+    def ready(self):
+        try:
+            from NEMO.plugins.utils import check_extra_dependencies
+        except ImportError:
+            return
+
+        # get_extra_requires() looks up importlib.metadata.distribution(app_name).
+        # That expects the *installed distribution* name (hyphenated PyPI name), not the
+        # Python package path (NEMO_monitors). When running only from NEMO/plugins
+        # without pip installing the wheel into the active interpreter, the dist is absent
+        # — skip the check instead of crashing.
+        for dist_name in (DISTRIBUTION_NAME, "nemo-monitors", "NEMO-tool-monitors", "nemo-tool-monitors"):
+            try:
+                check_extra_dependencies(dist_name, ["NEMO", "NEMO-CE"])
+                return
+            except PackageNotFoundError:
+                continue

nemo_monitors-1.0.0/NEMO_monitors/control_limits.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import statistics
+from typing import List, Optional
+
+from NEMO_monitors.models import CONTROL_LIMITS_FIXED, CONTROL_LIMITS_STATISTICAL
+
+
+def _numeric_values(values: List[Optional[float]]) -> List[float]:
+    result: List[float] = []
+    for value in values:
+        if value is None:
+            continue
+        try:
+            result.append(float(value))
+        except (TypeError, ValueError):
+            continue
+    return result
+
+
+def compute_control_limits(
+    values: List[Optional[float]],
+    mode: str,
+    fixed_min: Optional[float] = None,
+    fixed_max: Optional[float] = None,
+) -> Optional[dict]:
+    """
+    Compute control limit lines for chart display.
+
+    Statistical mode: centerline (mean), UCL/LCL at mean ± 3σ (sample stdev, n >= 2).
+    Fixed mode: LCL from fixed_min, UCL from fixed_max; no centerline.
+    Returns None when limits cannot be computed.
+    """
+    if mode == CONTROL_LIMITS_STATISTICAL:
+        numeric = _numeric_values(values)
+        if len(numeric) < 2:
+            return None
+        centerline = statistics.mean(numeric)
+        sigma = statistics.stdev(numeric)
+        return {
+            "centerline": centerline,
+            "ucl": centerline + 3 * sigma,
+            "lcl": centerline - 3 * sigma,
+        }
+
+    if mode == CONTROL_LIMITS_FIXED:
+        if fixed_min is None and fixed_max is None:
+            return None
+        result = {}
+        if fixed_min is not None:
+            result["lcl"] = float(fixed_min)
+        if fixed_max is not None:
+            result["ucl"] = float(fixed_max)
+        return result or None
+
+    return None

nemo_monitors-1.0.0/NEMO_monitors/customizations.py

@@ -0,0 +1,10 @@
+from NEMO.decorators import customization
+from NEMO.views.customization import CustomizationBase
+
+
+@customization(key="monitors", title="Monitor data")
+class MonitorCustomization(CustomizationBase):
+    variables = {
+        "monitor_default_daterange": "last_year",
+        "monitor_default_refresh_rate": "0",
+    }

nemo_monitors-1.0.0/NEMO_monitors/html_utils.py

@@ -0,0 +1,35 @@
+import re
+from typing import Optional
+
+_HREF_ATTR_RE = re.compile(
+    r"""(<a\s[^>]*\bhref\s*=\s*)(['"])(.*?)\2""",
+    re.IGNORECASE | re.DOTALL,
+)
+
+
+def normalize_external_href(href: str) -> str:
+    """Turn bare domains (e.g. google.com) into absolute https URLs."""
+    href = (href or "").strip()
+    if not href:
+        return href
+    lower = href.lower()
+    if lower.startswith(("#", "/", "mailto:", "tel:", "javascript:", "data:")):
+        return href
+    if lower.startswith("//") or lower.startswith("http://") or lower.startswith("https://"):
+        return href
+    host = href.split("/", 1)[0].split("?", 1)[0].split("#", 1)[0]
+    if "." in host and not host.startswith("."):
+        return f"https://{href}"
+    return href
+
+
+def normalize_description_links(html: Optional[str]) -> str:
+    """Fix anchor hrefs in monitor description HTML so bare domains are absolute."""
+    if not html:
+        return ""
+
+    def replace_href(match: re.Match) -> str:
+        prefix, quote, href = match.group(1), match.group(2), match.group(3)
+        return f"{prefix}{quote}{normalize_external_href(href)}{quote}"
+
+    return _HREF_ATTR_RE.sub(replace_href, html)