igs-slm 0.1.0b0__py3-none-any.whl

slm/api/serializers.py

@@ -0,0 +1,132 @@
+import json
+
+from django.template.loader import get_template
+from django.utils.functional import cached_property
+from lxml import etree
+from rest_framework import serializers
+
+from slm.defines import GeodesyMLVersion, SiteLogFormat, SiteLogStatus
+from slm.models import Site
+
+
+class _Heading:
+    pass
+
+
+_heading = _Heading()
+
+
+class SiteLogSerializer(serializers.BaseSerializer):
+    site = None
+    epoch = None
+    epoch_param = None
+    published_param = True
+    is_published = None
+    graphic = ""
+
+    text_tmpl = get_template("slm/sitelog/legacy.log")
+    text_9char_tmpl = get_template("slm/sitelog/ascii_9char.log")
+
+    xml_parser = etree.XMLParser(remove_blank_text=True)
+
+    def __init__(self, *args, instance, epoch=None, published=True, **kwargs):
+        self.site = instance
+        self.epoch_param = epoch
+        self.epoch = epoch
+        self.published_param = (bool(epoch) or published) or None
+        self.is_published = self.published_param or (
+            self.site.status not in SiteLogStatus.unpublished_states()
+        )
+        if self.epoch is None:
+            self.epoch = (
+                self.site.last_publish
+                if self.published_param
+                else self.site.last_update or self.site.created
+            )
+        super().__init__(*args, instance=instance, **kwargs)
+
+    def xml(self, version):
+        return etree.tostring(
+            etree.fromstring(
+                version.template.render(
+                    {
+                        **self.context,
+                        "identifier": self.site.get_filename(
+                            log_format=SiteLogFormat.GEODESY_ML, epoch=self.epoch_param
+                        ).split(".")[0],
+                        "files": self.site.sitefileuploads.public().order_by(
+                            "timestamp"
+                        ),
+                    }
+                ).encode(),
+                parser=self.xml_parser,
+            ),
+            pretty_print=True,
+        ).decode()
+
+    @cached_property
+    def json(self):
+        # todo
+        return json.dumps({})
+
+    def format(self, log_format, version=None):
+        if log_format == SiteLogFormat.LEGACY:
+            return self.text
+        elif log_format == SiteLogFormat.ASCII_9CHAR:
+            return self.text_9char
+        elif log_format == SiteLogFormat.GEODESY_ML:
+            return self.xml(version=(version or GeodesyMLVersion.latest()))
+        raise NotImplementedError(
+            f"Serialization for format {log_format} is not yet implemented."
+        )
+
+    def section_name(self, name):
+        if name.startswith("site"):
+            return name[4:]
+        return name
+
+    @cached_property
+    def context(self):
+        def sort(subsections):
+            if subsections:
+                return subsections.sort()
+            return subsections
+
+        # todo put this logic on the site model?
+        graphic = ""
+        if self.published_param:
+            ant = self.site.siteantenna_set.published(epoch=self.epoch_param).last()
+            graphic = ant.graphic if ant else ""
+        else:
+            antennas = self.site.siteantenna_set.head(
+                epoch=self.epoch_param, include_deleted=False
+            ).sort(reverse=True)
+            if antennas:
+                graphic = antennas[0].graphic
+
+        return {
+            "site": self.site,
+            **{
+                self.section_name(section.field): (
+                    getattr(self.site, section.accessor).published(
+                        epoch=self.epoch_param
+                    )
+                    if self.published_param
+                    else sort(
+                        getattr(self.site, section.accessor).head(
+                            epoch=self.epoch_param, include_deleted=False
+                        )
+                    )
+                )
+                for section in Site.sections()
+            },
+            "graphic": graphic,
+        }
+
+    @cached_property
+    def text(self):
+        return self.text_tmpl.render({**self.context, "include_templates": True})
+
+    @cached_property
+    def text_9char(self):
+        return self.text_9char_tmpl.render({**self.context, "include_templates": True})

slm/api/views.py

@@ -0,0 +1,148 @@
+from datetime import datetime
+
+from django.db.models import Q
+from django.http import FileResponse
+from django.utils.translation import gettext as _
+from django_filters import filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework import mixins, renderers, viewsets
+
+from slm.api.filter import InitialValueFilterSet, SLMDateTimeFilter
+from slm.defines import SiteLogFormat
+from slm.models import ArchivedSiteLog, ArchiveIndex
+
+
+class LegacyRenderer(renderers.BaseRenderer):
+    """
+    Renderer which serializes to legacy format.
+    """
+
+    media_type = SiteLogFormat.LEGACY.mimetype
+    format = SiteLogFormat.LEGACY
+
+    def render(self, data, accepted_media_type=None, renderer_context=None):
+        return b""
+
+
+class ASCIIRenderer(renderers.BaseRenderer):
+    """
+    Renderer which serializes to legacy format.
+    """
+
+    media_type = SiteLogFormat.ASCII_9CHAR.mimetype
+    format = SiteLogFormat.ASCII_9CHAR
+
+    def render(self, data, accepted_media_type=None, renderer_context=None):
+        return b""
+
+
+class GeodesyMLRenderer(renderers.BaseRenderer):
+    """
+    Renderer which serializes to GeodesyML format.
+    """
+
+    media_type = SiteLogFormat.GEODESY_ML.mimetype
+    format = SiteLogFormat.GEODESY_ML
+
+    def render(self, data, accepted_media_type=None, renderer_context=None):
+        return b""
+
+
+class JSONRenderer(renderers.BaseRenderer):
+    """
+    Renderer which serializes to GeodesyML format.
+    """
+
+    media_type = SiteLogFormat.JSON.mimetype
+    format = SiteLogFormat.JSON
+
+    def render(self, data, accepted_media_type=None, renderer_context=None):
+        return b""
+
+
+class BaseSiteLogDownloadViewSet(mixins.RetrieveModelMixin, viewsets.GenericViewSet):
+    renderer_classes = [ASCIIRenderer, LegacyRenderer, GeodesyMLRenderer]
+
+    site = None
+
+    lookup_field = "site__name__istartswith"
+    lookup_url_kwarg = "site"
+
+    queryset = ArchiveIndex.objects.all()
+
+    class ArchiveIndexFilter(InitialValueFilterSet):
+        epoch = SLMDateTimeFilter(
+            method="at_epoch",
+            initial=lambda: datetime.now(),
+            help_text=_("Get the log that was active at this given date or datetime."),
+        )
+
+        name_len = filters.NumberFilter(
+            method="noop",
+            help_text=_(
+                "The number of characters to include in the filename from the "
+                "start of the 9 character site name."
+            ),
+        )
+
+        lower_case = filters.BooleanFilter(
+            method="noop", help_text=_("If true filename will be lowercase.")
+        )
+
+        def at_epoch(self, queryset, name, value):
+            return queryset.filter(
+                Q(begin__lte=value) & (Q(end__isnull=True) | Q(end__gt=value))
+            )
+
+        def noop(self, queryset, _1, _2):
+            return queryset
+
+        class Meta:
+            model = ArchiveIndex
+            fields = ["name_len", "epoch", "lower_case"]
+
+    filter_backends = (DjangoFilterBackend,)
+    filterset_class = ArchiveIndexFilter
+
+    def get_format_suffix(self, **kwargs):
+        requested_format = super().get_format_suffix(**kwargs)
+
+        # if the site name is a 4-id return the old 4char log format
+        if "site" in kwargs and len(kwargs["site"]) == 4 and requested_format == "log":
+            return SiteLogFormat.LEGACY
+
+        # match suffix first
+        for fmt in reversed(SiteLogFormat):
+            if fmt.ext == requested_format:
+                return fmt
+
+        # if that fails accept alts by priority
+        return SiteLogFormat(requested_format)
+
+    def retrieve(self, request, *args, **kwargs):
+        """
+        Download the site log rendered in the specified format - preferencing
+        the HTTP_ACCEPTS header over the format parameter. In most cases
+        from_site will fetch the archived log from disk, but if a format that
+        was not previously rendered is requested from_site might first create
+        a new ArchivedSiteLog. If no index is found and allow_unpublished is
+        true a new site log will be rendered from the current HEAD state.
+
+        :param request:
+        :param args:
+        :param kwargs:
+        :return:
+        """
+        index = self.get_object()
+        archived = ArchivedSiteLog.objects.from_index(
+            index=index, log_format=request.accepted_renderer.format
+        )
+        return FileResponse(
+            archived.file,
+            filename=index.site.get_filename(
+                log_format=archived.log_format,
+                epoch=index.begin,
+                name_len=request.GET.get("name_len", None),
+                lower_case=request.GET.get("lower_case", False),
+            ),
+        )

slm/apps.py

@@ -0,0 +1,323 @@
+import sys
+from pprint import pformat
+
+from django.apps import AppConfig, apps
+from django.conf import settings
+from django.core.checks import Error, Tags, Warning, register
+from django.db.models.signals import (
+    post_delete,
+    post_init,
+    post_migrate,
+    post_save,
+    pre_delete,
+)
+from django.dispatch import Signal
+from django.utils.module_loading import import_string
+from django.utils.translation import gettext as _
+
+from slm.defines import GeodesyMLVersion
+from slm.signals import signal_name
+from slm.utils import clear_caches
+
+
+@register("slm", Tags.security)
+def check_permission_groups_setting(**kwargs):
+    error_id = "slm.E002"
+    header = _("settings.SLM_DEFAULT_PERMISSION_GROUPS is invalid")
+    group_setting = getattr(settings, "SLM_DEFAULT_PERMISSION_GROUPS", {})
+    errors = []
+    if group_setting:
+        for group_name, permissions in group_setting.items():
+            if not isinstance(group_name, str):
+                errors.append(
+                    Error(
+                        header,
+                        hint=_("{} is not a group name string.").format(
+                            str(group_name)
+                        ),
+                        id=error_id,
+                    )
+                )
+                continue
+
+            try:
+                for perm in permissions:
+                    if not isinstance(perm, str):
+                        errors.append(
+                            Error(
+                                header,
+                                hint=_(
+                                    "SLM_DEFAULT_PERMISSION_GROUPS[{}][{}] is not "
+                                    "a permission codename string."
+                                    "instead of {}."
+                                ).format(group_name, str(perm)),
+                                id=error_id,
+                            )
+                        )
+
+            except TypeError:
+                errors.append(
+                    Error(
+                        header,
+                        hint=_(
+                            "{} must be an iterable list of permission code names "
+                            "instead of {}."
+                        ).format(group_name, type(permissions)),
+                        id=error_id,
+                    )
+                )
+    return errors
+
+
+@register("slm", Tags.security)
+def check_permissions_setting(**kwargs):
+    warning_id = "slm.W001"
+    permissions = getattr(settings, "SLM_PERMISSIONS", None)
+    if permissions:
+        try:
+            from django.utils.module_loading import import_string
+
+            import_string(permissions)
+        except ImportError:
+            return [
+                Warning(
+                    _(
+                        f"Was unable to load SLM_PERMISSIONS callable: "
+                        f"{permissions}"
+                    ),
+                    hint=_(
+                        "Set SLM_PERMISSIONS to the import string for a "
+                        "callable that returns a queryset of valid system"
+                        "permissions."
+                    ),
+                    id=warning_id,
+                )
+            ]
+    return []
+
+
+@register("slm", Tags.signals)
+def check_automated_alerts(**kwargs):
+    error_id = "slm.E001"
+
+    def alert_conf_error(hint):
+        return Error(_("settings.SLM_AUTOMATED_ALERTS is incorrect."), hint, error_id)
+
+    alerts = getattr(settings, "SLM_AUTOMATED_ALERTS", {})
+    if not isinstance(alerts, dict):
+        return [
+            alert_conf_error(
+                _(
+                    "SLM_AUTOMATED_ALERTS is a {} but it must be a dictionary"
+                    "keyed on Alert model labels, the values are dictionaries "
+                    "containing the signals configured to issue the alert and/or"
+                    "rescind the alert and any default Alert model parameter "
+                    "overrides."
+                ).format(type(alerts))
+            )
+        ]
+    errors = []
+    for alert, config in alerts.items():
+        try:
+            AlertModel = apps.get_model(*alert.split(".", 1))
+        except LookupError:
+            errors.append(
+                alert_conf_error(
+                    _(
+                        "SLM_AUTOMATED_ALERTS[{}] is not a registered model label."
+                    ).format(alert)
+                )
+            )
+            continue
+        if not AlertModel.automated:
+            errors.append(
+                alert_conf_error(
+                    _("SLM_AUTOMATED_ALERTS[{}] is a non-automated alert type.").format(
+                        alert
+                    )
+                )
+            )
+            continue
+
+        if not isinstance(AlertModel.objects.SUPPORTED_SIGNALS, dict):
+            errors.append(
+                alert_conf_error(
+                    _(
+                        "{}.objects.SUPPORTED_SIGNALS must be a dictionary keyed "
+                        "with `issue` and `rescind` signal lists that are supported."
+                    ).format(AlertModel.__name__)
+                )
+            )
+            continue
+
+        def check_signals(signal_type):
+            for signal in config.get(signal_type, []):
+                try:
+                    signal = import_string(signal)
+                    if not isinstance(signal, Signal):
+                        errors.append(
+                            alert_conf_error(
+                                _(
+                                    "SLM_AUTOMATED_ALERTS[{}][{}][{}] is not a "
+                                    "Signal"
+                                ).format(alert, signal_type, signal_name(signal)),
+                            )
+                        )
+                except ImportError:
+                    errors.append(
+                        alert_conf_error(
+                            _(
+                                "SLM_AUTOMATED_ALERTS[{}][{}] contains a non "
+                                "existent trigger signal ({})."
+                            ).format(alert, signal_type, signal_name(signal))
+                        )
+                    )
+                    continue
+
+                if signal not in AlertModel.objects.SUPPORTED_SIGNALS.get(
+                    signal_type, []
+                ):
+                    errors.append(
+                        alert_conf_error(
+                            _(
+                                "SLM_AUTOMATED_ALERTS[{}][{}] contains an "
+                                "unsupported signal ({}) for alerts of type "
+                                "{}. Must be one of:\n{}"
+                            ).format(
+                                alert,
+                                signal_type,
+                                signal_name(signal),
+                                AlertModel,
+                                pformat(
+                                    [
+                                        signal_name(sig)
+                                        for sig in AlertModel.objects.SUPPORTED_SIGNALS[
+                                            signal_type
+                                        ]
+                                    ]
+                                ),
+                            )
+                        )
+                    )
+
+        check_signals("issue")
+        check_signals("rescind")
+    return errors
+
+
+def alert_save(sender, instance, created, raw, using, update_fields, **kwargs):
+    from slm.signals import alert_issued
+
+    if created:
+        alert_issued.send(sender=sender, alert=instance)
+
+
+def cache_realalert(sender, instance, using, **kwargs):
+    """
+    Cache real alert instance onto the model because we wont be able
+    to get it in post because it no longer exists.
+    """
+    #
+    instance._slm_real_alert = instance.get_real_instance()
+
+
+def alert_delete(sender, instance, using, **kwargs):
+    from slm.signals import alert_cleared
+
+    alert_cleared.send(
+        sender=sender, alert=getattr(instance, "_slm_real_alert", instance)
+    )
+
+
+def site_init(sender, instance, **kwargs):
+    # publishing may be tracked through a status update or if the
+    # last_publish timestamp changes
+
+    # an infinite recursion loop is triggered if you access a deferred
+    # field in a model's init(). We guard against that case here, which
+    # can happen when related fields are deleted. Such cases should
+    # not involve a status update
+    deferred = instance.get_deferred_fields()
+    if "status" not in deferred and "last_publish" not in deferred:
+        instance._slm_pre_status = instance.status
+        instance._slm_last_publish = instance.last_publish
+        if instance.pk is None:
+            instance._slm_pre_status = None
+            instance._slm_last_publish = None
+
+
+def site_save(sender, instance, created, raw, using, update_fields, **kwargs):
+    from slm.models import Site
+    from slm.signals import site_status_changed
+
+    if (
+        hasattr(instance, "_slm_pre_status")
+        and instance._slm_pre_status != instance.status
+    ) or (  # todo why this second clause?
+        hasattr(instance, "_slm_last_publish")
+        and instance._slm_last_publish != instance.last_publish
+    ):
+        site_status_changed.send(
+            sender=Site,
+            site=instance,
+            previous_status=instance._slm_pre_status,
+            new_status=instance.status,
+        )
+
+
+def user_save(sender, instance, created, raw, using, update_fields, **kwargs):
+    """Clear any relevant caches whenever a user is saved."""
+    clear_caches()
+
+
+def populate_groups(**kwargs):
+    from django.contrib.auth.models import Group, Permission
+
+    for group_name, permissions in getattr(
+        settings, "SLM_DEFAULT_PERMISSION_GROUPS", {}
+    ).items():
+        group, created = Group.objects.get_or_create(name=group_name)
+        if created:
+            group.permissions.set(Permission.objects.filter(codename__in=permissions))
+            group.save()
+
+
+class SLMConfig(AppConfig):
+    name = "slm"
+
+    # space is used as a workaround to alphabetically push SLM to the
+    # top of the admin
+    verbose_name = " SLM"
+
+    def ready(self):
+        from django.contrib.auth import get_user_model
+
+        from slm.models import Alert, Site
+        from slm.receivers import register as register_receivers
+
+        register_receivers()
+
+        post_init.connect(site_init, sender=Site)
+        post_save.connect(site_save, sender=Site)
+        post_save.connect(user_save, sender=get_user_model())
+        post_migrate.connect(populate_groups)
+
+        for alert in Alert.objects.classes():
+            post_save.connect(alert_save, sender=alert)
+            pre_delete.connect(cache_realalert, sender=Alert)
+            post_delete.connect(alert_delete, sender=Alert)
+
+        # load schemas into memory - this can take a few moments and requires
+        # a live internet connection
+        xsd_preload = getattr(
+            settings, "SLM_PRELOAD_SCHEMAS", [geo for geo in GeodesyMLVersion]
+        )
+
+        if (
+            xsd_preload
+            and not getattr(settings, "SLM_MANAGEMENT_MODE", False)
+            and not (len(sys.argv) >= 2 and sys.argv[1] == "runserver")
+        ):
+            from slm.parsing.xsd import load_schemas
+
+            load_schemas()