irie 0.0.16__py3-none-any.whl → 0.0.17__py3-none-any.whl

irie/apps/events/views_events.py

@@ -55,8 +55,7 @@ def save_event(request, event, success_status):
 
 
     if len(errors) > 0:
-        return HttpResponse(json.dumps(
-            {
+        return HttpResponse(json.dumps({
                 "errors": errors
             }), status=status.HTTP_400_BAD_REQUEST)
 
@@ -69,10 +68,10 @@ def save_event(request, event, success_status):
                 ).serialize(serialize_data=False, summarize=True)
             )
         except:
-            return HttpResponse(json.dumps(
-                {
+            return HttpResponse(json.dumps({
                     "errors": ["Failed to parse ground motion file."]
-                }), status=status.HTTP_400_BAD_REQUEST)
+            }), status=status.HTTP_400_BAD_REQUEST)
+
     elif "motion_data" in request.data:
         motion_data = json.loads(request.data.get("motion_data"))
 
@@ -85,7 +84,6 @@ def save_event(request, event, success_status):
     # RECORD ID
     rec_id = motion_data.get("record_identifier", "")
 
-
     if EventRecord.objects.filter(record_identifier=rec_id).first():
         print("\n\nSKIPPING\n\n")
         return HttpResponse(json.dumps({"data": ""}), status=success_status)

irie/apps/inventory/filters.py

@@ -14,16 +14,48 @@ class AssetFilter(django_filters.FilterSet):
         method='filter_cesmd_exists'
     )
 
-    is_complete = django_filters.BooleanFilter(
-        field_name='is_complete',
-        label='Is Complete',
-        widget=CheckboxInput()
-    )
+    # is_complete = django_filters.BooleanFilter(
+    #     field_name='is_complete',
+    #     label='Is Complete',
+    #     widget=CheckboxInput()
+    # )
     district = django_filters.CharFilter(
         label='District',
         method='filter_district'
     )
 
+    max_year = django_filters.NumberFilter(
+        label='Max Year',
+        method='filter_year',
+        # widget=django_filters.widgets.DateInput(attrs={'type': 'date'})
+    )
+    # max_year = django_filters.DateFilter(
+    #     label='Max Year',
+    #     field_name='nbi_data__NBI_BRIDGE__Year Built',
+    #     lookup_expr='lte'
+    # )
+    def filter_year(self, queryset, name, value):
+        ids = {
+            asset.id for asset in queryset if (
+                asset.nbi_data and int(asset.nbi_data["NBI_BRIDGE"]["Year Built"] or 0) <= int(value) #.year
+            )
+        }
+        return queryset.filter(id__in=ids)
+        if value:
+            return queryset.filter(
+                nbi_data__NBI_BRIDGE__Year_Built__lte=int(value) #.year
+            )
+        return 
+    
+        if value:
+            filtered_ids = [
+                asset.id for asset in queryset if (
+                    asset.nbi_data and asset.nbi_data["NBI_BRIDGE"]["Year Built"] <= value.year
+                )
+            ]
+            return queryset.filter(id__in=filtered_ids)
+ 
+
     def filter_cesmd_exists(self, queryset, name, value):
         if value:  # Checkbox is checked
             return queryset.exclude(cesmd__isnull=True).exclude(cesmd__exact='')

irie/apps/inventory/models.py

@@ -10,6 +10,7 @@
 #----------------------------------------------------------------------------#
 from django.db import models
 from django.core.validators import int_list_validator
+from django.urls import reverse
 
 class Corridor(models.Model):
     id       = models.BigAutoField(primary_key=True)
@@ -41,6 +42,18 @@ class Asset(models.Model):
 
     def __str__(self):
         return f"{self.calid} - {self.name}"
+    
+    def get_absolute_url(self):
+        return reverse("asset_profile", args=[self.calid])
+    
+    @property 
+    def last_event(self):
+        from irie.apps.events.models import EventRecord
+        # TODO: use event_date
+        try:
+            return EventRecord.objects.filter(asset=self).latest("upload_date")
+        except EventRecord.DoesNotExist:
+            return None
 
     @property
     def predictors(self): # ->Dict[str, Predictor]:
@@ -54,7 +67,7 @@ class Asset(models.Model):
     @property
     def event_count(self):
         from irie.apps.events.models import EventRecord
-        return len(EventRecord.objects.filter(asset=self)) 
+        return EventRecord.objects.filter(asset=self).count()
 
     @property
     def rendering(self):

irie/apps/inventory/sitemaps.py

@@ -0,0 +1,19 @@
+
+from django.contrib.sitemaps import Sitemap
+from django.urls import reverse
+from .models import Asset  # Replace with your model
+
+class InventorySitemap(Sitemap):
+    changefreq = "weekly"  # Change frequency of the content
+    priority = 0.5  # Priority of the URLs in the sitemap
+
+    def items(self):
+        # Return a queryset of objects for the sitemap
+        return Asset.objects.exclude(cesmd__isnull=True)
+
+    def lastmod(self, obj):
+        # Return the last modification date of an object
+        if event := obj.last_event:
+            return event.upload_date
+        return None
+

irie/apps/inventory/views.py

@@ -140,7 +140,6 @@ def dashboard(request):
         return HttpResponse(html_template.render(context, request))
 
 
-
 @login_required(login_url="/login/")
 def asset_event_report(request):
     from irie.apps.evaluation.models import Evaluation
@@ -173,7 +172,7 @@ def asset_event_report(request):
 
 
 
-@login_required(login_url="/login/")
+# @login_required(login_url="/login/")
 def asset_profile(request, calid):
 
     context = {}
@@ -209,10 +208,6 @@ def asset_profile(request, calid):
     except: 
         pass 
 
-    try:
-        context["mountains"] = make_mountains(asset)
-    except:
-        pass
 
     context["tables"] = _make_tables(asset)
 
@@ -298,7 +293,7 @@ def _make_tables(asset):
 
 
 
-@login_required(login_url="/login/")
+# @login_required(login_url="/login/")
 def asset_table(request):
     """
     Returns a table of all assets in the database, paginated

irie/apps/prediction/forms.py

@@ -10,7 +10,10 @@ class PredictorForm(forms.ModelForm):
     class Meta:
         model = PredictorModel
         fields = '__all__'
-        exclude = ['render_file', 'asset', 'metrics', 'active', 
+        exclude = ['render_file', 
+                   'asset', 
+                   'metrics', 
+                   'active', 
                    'entry_point', 
                    'config', 
                    'protocol']

irie/apps/prediction/predictor.py

@@ -10,285 +10,16 @@
 #
 #----------------------------------------------------------------------------#
 from __future__ import annotations
-import sys
-import json
-import subprocess
-from pathlib import Path
 from typing import Dict
 
-from .runners import (
-    Runner, RunID,
-    classproperty
-)
+from .runners import Runner, RunID
 from .runners.opensees import OpenSeesRunner
-
-class Event: pass
-
-
-class PredictorType1(Runner):
-    @property
-    def platform(self):
-        return self.conf.get("platform", "")
-
-    @classmethod
-    def create(cls, asset, request):
-        from .models import PredictorModel
-        predictor = PredictorModel()
-        data = json.loads(request.data.get("json"))
-        predictor.entry_point = [
-            sys.executable, "-m", "opensees"
-        ]
-        data["metrics"] = []
-
-        predictor.name = data.pop("name")
-        predictor.config = data
-        predictor.asset = asset
-        predictor.protocol = "IRIE_PREDICTOR_T1"
-        predictor.active = False
-        return predictor
-
-
-    @classproperty
-    def schema(cls):
-        from .runners.opensees import schemas
-        return {
-            "title": "Structural Model",
-            "options": {"disable_collaps": True},
-            "schema": "http://json-schema.org/draft-04/schema#",
-            "type": "object",
-            "properties": {
-                "platform": {
-                  "type": "string",
-                  "title": "Platform",
-                  "enum": ["OpenSees","CSiBridge"]
-                },
-                "model":    schemas.load("hwd_conf.schema.json"),
-                "analysis": schemas.load("hwd_analysis.schema.json"),
-            }
-        }
-
-    def newPrediction(self, event: Event) -> RunID:
-        self.event = event
-        event_file = Path(event.event_file.path).resolve()
-        command = [*self.entry_point, "new", event_file]
-        run_id = subprocess.check_output(command).decode().strip()
-        return RunID(int(run_id))
-
-    def runPrediction(self, run_id: RunID):
-        command = [*self.entry_point, "run", str(run_id)]
-
-        if "scale" in self.event.upload_data:
-            command.extend(["--scale", str(float(self.event.upload_data["scale"]))])
-        print(":: Running ", command, file=sys.stderr)
-        subprocess.check_output(command)
-
-        print(f":: Model {self.name} returned", file=sys.stderr)
-        return
-
-    def getMetricData(self, run, metric):
-        try:
-            return json.loads(subprocess.check_output([*self.entry_point, "get", str(run), metric]).decode())
-        except json.decoder.JSONDecodeError:
-            return {}
-
-
-class PredictorType2(Runner):
-    platform = "mdof"
-
-    schema = {
-      "title": "System ID",
-      "name": "P2",
-      "type": "object",
-      "required": [
-        "name",
-        "decimation",
-        "method",
-        "channels"
-      ],
-      "properties": {
-        "name": {
-          "type": "string",
-          "title": "Name",
-          "description": "Predictor name",
-          "minLength": 2,
-          # "default": "S1"
-        },
-        "method": {
-          "type": "string",
-          "title": "Method",
-          "enum": ["Fourier Spectrum","Response Spectrum","SRIM","OKID"]
-        },
-        "decimation": {
-          "type": "integer",
-          "title": "Decimation",
-          "default": 1,
-          "minimum": 1,
-          "maximum": 8
-        },
-        "order": {
-          "type": "integer",
-          "title": "Model Order",
-          "default": 8,
-          "minimum": 2,
-          "maximum": 64,
-          "options": {"dependencies": {"method": ["SRIM","OKID"]}}
-        },
-        "horizon": {
-          "type": "integer",
-          "title": "Prediction Horizon",
-          "default": 100,
-          "minimum": 50,
-          "maximum": 500,
-          "options": {"dependencies": {"method": ["SRIM"]}}
-        },
-        "period_band": {
-          "type": "string",
-          "title": "Period Band",
-          "default": "[0.1,2.3]",
-          "options": {"dependencies": {"method": ["Fourier Spectrum"]}},
-          "description": "[0.1,2.3] if interested in periods between 0.1 seconds and 2.3 seconds"
-        },
-        "damping": {
-          "type": "float",
-          "title": "Damping",
-          "default": 0.02,
-          "options": {"dependencies": {"method": ["Response Spectrum"]}},
-          "description": "assumed damping ratio"
-        },
-        "channels": {
-          "type": "array",
-          "format": "table",
-          "title": "Channels",
-          "uniqueItems": True,
-          "items": {
-            "title": "Acceleration",
-            "type": "object",
-            "properties": {
-              "type": {
-                "type": "string",
-                "enum": ["output","input"],
-                "default": "output"
-              },
-              "id": {"type": "integer", "description": "Number identifying signal channel"}
-            }
-          },
-          "default": [{"type": "output", "id": 1}]
-        }
-      }
-    }
-
-    @classmethod
-    def create(cls, asset, request):
-        from .models import PredictorModel
-        predictor = PredictorModel()
-        data = json.loads(request.data.get("json"))
-        method = {
-                "Fourier Spectrum": "fourier",
-                "Response Spectrum": "response",
-                "FDD": "fdd",
-                "OKID": "okid-era",
-                "SRIM": "srim"
-        }[data.pop("method")]
-        predictor.entry_point = [
-                sys.executable, "-m", "mdof", method
-        ]
-        data["outputs"] = [i["id"] for i in data["channels"] if i["type"] == "output"]
-        data["inputs"]  = [i["id"] for i in data["channels"] if i["type"] == "input"]
-        data["threads"] = 4
-        data["metrics"] = ["SPECTRAL_SHIFT_IDENTIFICATION"]
-        del data["channels"]
-
-        predictor.name = data.pop("name")
-        predictor.config = data
-        predictor.asset = asset
-        predictor.protocol = "IRIE_PREDICTOR_T2"
-        predictor.active = True
-        return predictor
-
-
-    def newPrediction(self, event):
-        self.event = event
-        return RunID(1)
-
-    def runPrediction(self, run_id: RunID) -> bool:
-        event_file = Path(self.event.event_file.path).resolve()
-        command = [*self.entry_point,
-                   "--config", 
-                   json.dumps(self.conf),
-                   event_file]
-
-        if False:
-            command = [*self.entry_point,
-                       event_file,
-                       *map(str, self.conf.get("argv", []))]
-        try:
-            self.metric_details = json.loads(
-                subprocess.check_output(command).decode()
-            )
-            return True
-        except Exception as e:
-            self.metric_data = {"error": str(e)}
-            return False
-
-    def getMetricData(self, run, metric):
-        if not hasattr(self, "metric_details"):
-            raise Exception(f"Error {self.name}({id(self)}), {run}")
-        return self.metric_details
-
-
-class PredictorType4(Runner):
-    platform = "csi"
-
-    @classmethod
-    def create(cls, asset, request, config):
-        from .models import PredictorModel
-        predictor = PredictorModel()
-
-        predictor.entry_point = [
-                sys.executable, "-m", "opensees"
-        ]
-
-        predictor.name = config.pop("name")
-        predictor.config = config
-        predictor.asset = asset
-        predictor.protocol = "IRIE_PREDICTOR_T4"
-        predictor.active = True
-        return predictor
-
-
-    def newPrediction(self, event):
-        self.event = event
-        return RunID(1)
-
-    def runPrediction(self, run_id: RunID) -> bool:
-        event_file = Path(self.event.event_file.path).resolve()
-        command = [*self.entry_point,
-                   "--config", json.dumps(self.conf),
-                   event_file]
-        if False:
-            command = [*self.entry_point,
-                       event_file,
-                       *map(str, self.conf.get("argv", []))]
-
-        try:
-            self.metric_details = json.loads(
-                subprocess.check_output(command).decode()
-            )
-            return True
-        except Exception as e:
-            self.metric_details = {"error": str(e)}
-            return False
-
-    def getMetricData(self, run, metric):
-        if not hasattr(self, "metric_details"):
-            raise Exception(f"Error {self.name}({id(self)}), {run}")
-        return self.metric_details
-
+from .runners.ssid import SystemIdRunner 
 
 PREDICTOR_TYPES : Dict[str, Runner] = {
-    "IRIE_PREDICTOR_V1" : PredictorType1,
-    "IRIE_PREDICTOR_T2" : PredictorType2,
-    "" :                  PredictorType2,
+    # "IRIE_PREDICTOR_V1" : PredictorType1,
+    "IRIE_PREDICTOR_T2" : SystemIdRunner,
+    "" :                  SystemIdRunner,
 #   "IRIE_PREDICTOR_T3" : PredictorType3,
     "IRIE_PREDICTOR_T4" : OpenSeesRunner,
 }

irie/apps/prediction/runners/__init__.py

@@ -11,28 +11,30 @@ class classproperty(property):
 
 
 class Runner:
-    def __init__(self, conf: dict):
+    def __init__(self, pred: dict):
 
-        if isinstance(conf, dict):
+        if isinstance(pred, dict):
             # Create from dict when posted from API; this
             # is used to create a new PredictorModel
-            self.name: str   = conf["name"]
-            self.description = conf.get("description", "")
-            self.conf        = conf["config"]
-            self.metrics     = conf["metrics"]
-            self.entry_point = conf["entry_point"]
-            self.active = conf.get("active", True)
+            self.name: str   = pred["name"]
+            self.description = pred.get("description", "")
+            self.conf        = pred["config"]
+            self.metrics     = pred["metrics"]
+            self.entry_point = pred["entry_point"]
+            self.active = pred.get("active", True)
         else:
             # Create from PredictorModel when loaded from database.
             # This is done when running analysis
-            self.name: str = conf.name
+            self.id = pred.id
+            self.asset = pred.asset
+            self.name: str = pred.name
             self.description = "" # conf.description
-            self.conf = conf.config
-            self.entry_point = conf.entry_point
-            self.metrics = conf.metrics
-            self.active = conf.active
-            if conf.config_file:
-                self.model_file = Path(conf.config_file.path).resolve()
+            self.conf = pred.config
+            self.entry_point = pred.entry_point
+            self.metrics = pred.metrics
+            self.active = pred.active
+            if pred.config_file:
+                self.model_file = Path(pred.config_file.path).resolve()
                 self.out_dir = Path(__file__).parents[0]/"Predictions"
                 self.runs = {}