irie 0.0.0__py3-none-any.whl

irie/apps/prediction/views.py

@@ -0,0 +1,184 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+#
+#   This module implements the "Configure Predictors" page
+#
+#   Author: Claudio Perez
+#
+#----------------------------------------------------------------------------#
+import os
+import json
+
+from django.shortcuts import HttpResponse
+from django.template import loader, TemplateDoesNotExist
+from django.contrib.auth.decorators import login_required
+from django.core.exceptions import ObjectDoesNotExist
+
+from django.shortcuts import render
+
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.permissions import IsAuthenticated
+
+from apps.site.view_utils import raise404
+from apps.inventory.models import Asset
+from apps.prediction.predictor import PREDICTOR_TYPES, OpenSeesRunner
+from apps.prediction.models import PredictorModel
+from .forms import PredictorForm
+
+@login_required(login_url="/login/")
+def new_prediction(request):
+    context = {}
+
+    page_template = "form-submission.html" #request.path.split("/")[-1]
+    context["segment"] = page_template
+    html_template = loader.get_template("prediction/" + page_template)
+    return HttpResponse(html_template.render(context, request))
+
+
+#@login_required(login_url="/login/")
+@api_view(["GET", "POST", "PUT"])
+@permission_classes([IsAuthenticated])
+def predictor_api(request):
+
+    context = {"segment": "assets"}
+
+    context["predictor_types"] = list(reversed([
+           {"schema": json.dumps(cls.schema),
+            "name":   cls.__name__,
+            "title":  cls.schema["title"]}
+            for cls in set(PREDICTOR_TYPES.values())
+    ]))
+
+    calid = request.path.split("/")[-3]
+
+    try:
+        context["asset"] = Asset.objects.get(calid=calid)
+
+    except:
+        return HttpResponse(
+                loader.get_template("home/page-404-sidebar.html").render(context, request)
+               )
+
+    if request.method == "POST":
+        PREDICTOR_TYPES["BRACE2_CLI_PREDICTOR_T2"].create(context["asset"],request).save()
+
+    html_template = loader.get_template("prediction/asset-predictors.html")
+    return HttpResponse(html_template.render(context, request))
+
+
+# @api_view(["GET", "POST", "PUT"])
+@login_required(login_url="/login/")
+# @permission_classes([IsAuthenticated])
+def asset_predictors(request):
+
+    context = {"segment": "assets"}
+
+    context["predictor_types"] = list(reversed([
+           {"schema": json.dumps(cls.schema),
+            "name":   cls.__name__,
+            "title":  cls.schema.get("title", "NO TITLE")}
+            for cls in set(PREDICTOR_TYPES.values())
+    ]))
+
+    calid = request.path.split("/")[-3]
+    try:
+        context["asset"] = Asset.objects.get(calid=calid)
+    except:
+        return HttpResponse(
+                loader.get_template("home/page-404-sidebar.html").render(context, request)
+               )
+
+    if request.method == "POST":
+        PREDICTOR_TYPES["BRACE2_CLI_PREDICTOR_T2"].create(context["asset"],request).save()
+
+    html_template = loader.get_template("prediction/asset-predictors.html")
+    return HttpResponse(html_template.render(context, request))
+
+
+@login_required(login_url="/login/")
+def predictor_profile(request):
+
+    context = {}
+    html_template = loader.get_template("prediction/predictor-profile.html")
+    context["segment"] = "assets"
+
+    url_segs = request.path.split("/")
+    if len(url_segs) < 5:
+        return raise404(request, context)
+    else:
+        calid = url_segs[2]
+        preid = url_segs[4]
+
+    try:
+        asset = Asset.objects.get(calid=calid)
+    except ObjectDoesNotExist:
+        return raise404(request, context)
+
+    try:
+        predictor = PredictorModel.objects.get(pk=int(preid))
+    except ObjectDoesNotExist:
+        return raise404(request, context)
+
+    context["asset"] = asset
+    context["predictor"] = PREDICTOR_TYPES[predictor.protocol](predictor)
+
+
+    try:
+        return HttpResponse(html_template.render(context, request))
+
+    except TemplateDoesNotExist:
+        context["rendering"] = None
+        return HttpResponse(html_template.render(context, request))
+
+    except Exception as e:
+        if "DEBUG" in os.environ and os.environ["DEBUG"]:
+            raise e
+        html_template = loader.get_template("site/page-500.html")
+        return HttpResponse(html_template.render(context, request))
+
+
+@login_required(login_url="/login/")
+def predictor_upload(request):
+
+    context = {}
+    html_template = loader.get_template("prediction/predictor-upload.html")
+    context["segment"] = "assets"
+
+    context["title"] = "The Title"
+
+    if request.method == 'POST':
+        form = PredictorForm(request.POST, request.FILES)  # include request.FILES
+        if form.is_valid():
+            # Process the form data and uploaded file
+            asset = form.cleaned_data['asset']
+            uploaded_file = request.FILES['config_file']
+
+            with open(uploaded_file.name, 'wb+') as destination:
+                for chunk in uploaded_file.chunks():
+                    destination.write(chunk)
+
+            # Save the predictor
+            OpenSeesRunner.create(asset,None,form).save()
+
+            context = {}
+
+            return render(request, 'prediction/predictor-upload.html',
+                          context)
+    else:
+        form = PredictorForm()
+
+
+    try:
+        return render(request, 'prediction/predictor-upload.html', {'form': form})
+
+
+    except Exception as e:
+        if "DEBUG" in os.environ and os.environ["DEBUG"]:
+            raise e
+        html_template = loader.get_template("site/page-500.html")
+        return HttpResponse(html_template.render(context, request))
+
+

irie/apps/prediction/views_api.py

@@ -0,0 +1,216 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+#
+#   This module is responsible for implementing the API endpoint for
+#   scraping evaluation data
+#
+#   Author: Claudio Perez
+#
+#----------------------------------------------------------------------------#
+import json
+import datetime
+from threading import Thread
+from django.shortcuts import render
+from django.core.exceptions import ObjectDoesNotExist
+from django.shortcuts import HttpResponse
+from django.forms.models import model_to_dict
+
+from rest_framework.parsers import JSONParser,MultiPartParser,FormParser
+from rest_framework.decorators import api_view, permission_classes, parser_classes
+from rest_framework import status
+from rest_framework.permissions import IsAuthenticated
+
+from .models import Event
+from apps.inventory.models import Asset
+# from apps.evaluation.evaluation import (run_evaluation,
+#                                         add_evaluation)
+from apps.evaluation.models import Evaluation
+import quakeio
+
+
+def serialize_event(event):
+    serialized = model_to_dict(event)
+    serialized["upload_date"] = str(event.upload_date)
+
+    if event.event_file:
+        serialized["event_file"] = event.event_file.path
+    else:
+        serialized["event_file"] = None
+
+    #serialized["data_str"] = json.loads(event.data_str) if event.data_str else {}
+    return serialized
+
+
+def save_event(request, event, success_status):
+    errors = []
+
+    # DATE
+    upload_date = datetime.datetime.now()
+
+    # UPLOAD DATA
+    upload_data = request.data.get("upload_data", "{}")
+    if upload_data == "":
+        errors.append({"upload_data": "This field is required"})
+
+    # EVENT FILE
+    try:
+        event_file = request.FILES["event_file"]
+    except KeyError:
+        event_file = None
+#       errors.append({"event_file": "This field is required"})
+    except Exception as e:
+        errors.append({"event_file": str(e)})
+
+
+    if len(errors) > 0:
+        return HttpResponse(json.dumps(
+            {
+                "errors": errors
+            }), status=status.HTTP_400_BAD_REQUEST)
+
+    # MOTION DATA
+    if event_file is not None:
+        try:
+            motion_data = (
+                quakeio.read(
+                    event_file.temporary_file_path(), input_format="csmip.zip"
+                ).serialize(serialize_data=False, summarize=True)
+            )
+        except:
+            return HttpResponse(json.dumps(
+                {
+                    "errors": ["Failed to parse ground motion file."]
+                }), status=status.HTTP_400_BAD_REQUEST)
+    elif "motion_data" in request.data:
+        motion_data = json.loads(request.data.get("motion_data"))
+
+    else:
+        return HttpResponse(json.dumps(
+            {
+                "errors": ["No motion_data provided."]
+            }), status=status.HTTP_400_BAD_REQUEST)
+
+    # RECORD ID
+    rec_id = motion_data.get("record_identifier", "")
+
+
+    # CREATE EVENT
+    if event is None:
+        # Doing a PUT
+        event = Event.objects.filter(record_identifier=rec_id).first()
+        if event is None:
+            print("PUT: creating", rec_id, "\n\n")
+            event = Event()
+        else:
+            print("PUT: updating", rec_id, "\n\n")
+            upload_date = event.upload_date
+
+
+    event.upload_date = upload_date
+    event.upload_data = json.loads(upload_data)
+    event.record_identifier = rec_id
+    event.motion_data = motion_data
+    event.cesmd = "CE" + event.motion_data["station_number"]
+    event.asset = Asset.objects.get(cesmd="CE" + event.motion_data["station_number"])
+    event.event_file = event_file
+#   if event_file is not None:
+
+    event.save()
+
+
+    # CREATE EVALUATION
+    if "evaluation" in request.data:
+        # TODO: check for parse error
+        eval_data = json.loads(request.data["evaluation"])
+    else:
+        eval_data = None
+
+
+    Evaluation.create(event, event.asset, eval_data)
+
+
+
+
+    # EMAIL
+    # Get users
+    from django.contrib.auth import get_user_model
+    User  = get_user_model()
+    users = User.objects.all()
+
+    station_name = event.motion_data["station_name"]
+
+    event.email_notify(
+        subject   = f"BRACE2: New event at '{station_name}'",
+
+        message      = ("A new event has been sent to the BRACE2 platform. "
+                       'visit  https://brace2-peer.ist.berkeley.edu/static/dmp/index.html for details.'),
+        html_message = ("A new event has been sent to the BRACE2 platform. "
+                       'visit <a href="https://brace2-peer.ist.berkeley.edu/static/dmp/index.html">here</a> for details.'),
+        fail_silently=True,
+        recipients=[user.email for user in users] + ["brace2-peer@mailinator.com"]
+    )
+
+    return HttpResponse(json.dumps({"data": serialize_event(event)}), status=success_status)
+
+
+
+def index(request):
+    context = {}
+    return render(request, "events/events.html", context=context)
+
+
+@api_view(["GET", "POST", "PUT"])
+@permission_classes([IsAuthenticated])
+def events(request):
+    # if request.user.is_anonymous:
+    #     return HttpResponse(json.dumps({"detail": "Not authorized"}), status=status.HTTP_401_UNAUTHORIZED)
+
+    if request.method == "GET":
+        events_data = Event.objects.all()
+
+        events_count = events_data.count()
+
+        page_size = int(request.GET.get("page_size", events_count))
+        page_no = int(request.GET.get("page_no", 0))
+        events_data = list(events_data[page_no * page_size:page_no * page_size + page_size])
+
+        events_data = [serialize_event(event) for event in events_data]
+        return HttpResponse(json.dumps({"count": events_count, "data": events_data}), status=status.HTTP_200_OK)
+
+    elif request.method == "POST":
+        event = Event()
+        return save_event(request, event, status.HTTP_201_CREATED)
+
+    elif request.method == "PUT":
+        return save_event(request, None, status.HTTP_201_CREATED)
+
+    return HttpResponse(json.dumps({"detail": "Wrong method"}), status=status.HTTP_501_NOT_IMPLEMENTED)
+
+
+@api_view(['GET', 'PUT', 'DELETE'])
+@parser_classes([JSONParser,MultiPartParser])
+@permission_classes([IsAuthenticated])
+def event(request, event_id):
+    #if request.user.is_anonymous:
+    #    return HttpResponse(json.dumps({"detail": "Not authorized"}), status=status.HTTP_401_UNAUTHORIZED)
+
+    try:
+        event = Event.objects.get(pk=event_id)
+    except ObjectDoesNotExist:
+        return HttpResponse(json.dumps({"detail": "Not found"}), status=status.HTTP_404_NOT_FOUND)
+
+    if request.method == "GET":
+        return HttpResponse(json.dumps({"data": serialize_event(event)}), status=status.HTTP_200_OK)
+
+    if request.method == "PUT":
+        return save_event(request, event, status.HTTP_200_OK)
+
+    if request.method == "DELETE":
+        event.delete()
+        return HttpResponse(json.dumps({"detail": "deleted"}), status=status.HTTP_410_GONE)
+
+    return HttpResponse(json.dumps({"detail": "Wrong method"}), status=status.HTTP_501_NOT_IMPLEMENTED)
+

irie/apps/site/admin.py

@@ -0,0 +1 @@
+from django.contrib import admin

irie/apps/site/config.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class MyConfig(AppConfig):
+    name = "apps.site"
+    label = "apps_site"

irie/apps/site/migrations/__init__.py

@@ -0,0 +1 @@
+

irie/apps/site/models.py

@@ -0,0 +1,2 @@
+from django.db import models
+from django.contrib.auth.models import User

irie/apps/site/templatetags/indexing.py

@@ -0,0 +1,7 @@
+from django import template
+register = template.Library()
+
+@register.filter
+def index(indexable, i):
+    return indexable[i]
+

irie/apps/site/tests.py

@@ -0,0 +1 @@
+from django.test import TestCase

irie/apps/site/urls.py

@@ -0,0 +1,8 @@
+from django.urls import path, re_path
+from apps.site import views, view_sdof
+
+urlpatterns = [
+    path("", views.index, name="home"),
+    path("about/", views.about, name="about"),
+    re_path(r"^sdof/.*", view_sdof.earthquake_fitter, name="sdof"),
+]

irie/apps/site/view_sdof.py

@@ -0,0 +1,40 @@
+import os
+import json
+
+from django import template
+from django.contrib.auth.decorators import login_required
+from django.http import HttpResponse, HttpResponseRedirect
+from django.template import loader
+from django.urls import reverse
+
+import quakeio
+
+from apps.events.models import Event
+
+
+@login_required(login_url="/login/")
+def earthquake_fitter(request):
+    try:
+        load_template = "EarthquakeResponse.html"
+
+        pk = request.path.split("/")[2]
+
+        context = {}
+
+        context["event"] = Event.objects.filter(pk=pk)[0]
+
+        try:
+            context["event_data"] = quakeio.read(
+                context["event"].event_file.path, input_format="csmip.zip"
+            ).serialize(serialize_data=True, summarize=False)
+        except:
+            context["event_data"] = {}
+
+        html_template = loader.get_template("events/" + load_template)
+        return HttpResponse(html_template.render(context, request))
+
+    except Exception as e:
+        if "DEBUG" in os.environ and os.environ["DEBUG"]:
+            raise e
+        html_template = loader.get_template("home/page-500.html")
+        return HttpResponse(html_template.render(context, request))

irie/apps/site/view_utils.py

@@ -0,0 +1,13 @@
+import os
+from django.http import HttpResponse, HttpResponseRedirect
+from django.template import loader
+
+def raise404(request, context={}, error=None):
+    "Convenience function for responding with a 404 code (page not found)"
+    if error is not None and "DEBUG" in os.environ and os.environ["DEBUG"]:
+        raise error
+    if "segment" in context:
+        html_template = loader.get_template("home/page-404-sidebar.html")
+    else:
+        html_template = loader.get_template("home/page-404.html")
+    return HttpResponse(html_template.render(context, request))

irie/apps/site/views.py

@@ -0,0 +1,88 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+#
+# Each function in this file is responsible
+# for rendering a web page. This generally
+# consists of the following:
+#
+# - Extracting information from the URL (available from
+#   the `request` variable. For example, the URL may contain
+#   the CALID of the bridge that the page is about.
+# - Collecting neccessary data into a `context` dictionary.
+#   This typically involves a database querry, or reading from
+#   a static record like the inventory.bridges.BRIDGES dictionary.
+# - Finally, selecting an HTML template and rendering it against
+#   the assembled `context` dictionary.
+#
+# NOTE: In the future, the static data in the inventory app should
+#       be moved to the database. However, given the active pace of
+#       research and development that would require changes to this
+#       model, it is currently better as implemented.
+#
+#----------------------------------------------------------------------------#
+#
+# Fall 2022, BRACE2 Team
+# Berkeley, CA
+#
+#----------------------------------------------------------------------------#
+
+import os
+from django import template
+from django.contrib.auth.decorators import login_required
+from django.http import HttpResponse, HttpResponseRedirect
+from django.template import loader
+from django.urls import reverse
+
+
+def index(request):
+    "Return the primary landing page."
+    context = {
+        "segment": "index",
+        "authenticated": request.user.is_authenticated
+    }
+    html_template = loader.get_template("site/index.html")
+    return HttpResponse(html_template.render(context, request))
+
+
+def about(request):
+    "Return the About page."
+    context = {
+        "segment": "about",
+        "authenticated": request.user.is_authenticated
+    }
+    html_template = loader.get_template("site/about.html")
+    return HttpResponse(html_template.render(context, request))
+
+
+@login_required(login_url="/login/")
+def admin(request):
+    """
+    Return the administrator's dashboard page
+    """
+    context = {}
+
+    try:
+        page_template = request.path.split("/")[-1]
+        context["segment"] = page_template
+
+        if page_template == "admin":
+            return HttpResponseRedirect(reverse("admin:index"))
+
+        html_template = loader.get_template("site/" + page_template)
+        return HttpResponse(html_template.render(context, request))
+
+    except template.TemplateDoesNotExist as e:
+        return raise404(request, context, e)
+
+    except Exception as e:
+        if "DEBUG" in os.environ and os.environ["DEBUG"]:
+            raise e
+        html_template = loader.get_template("site/page-500.html")
+        return HttpResponse(html_template.render(context, request))
+
+
+
+

irie/core/__init__.py

@@ -0,0 +1,5 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#

irie/core/asgi.py

@@ -0,0 +1,12 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+
+import os
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "core.settings")
+
+application = get_asgi_application()