BDMS 233: transfer updates

.pre-commit-config.yaml

@@ -16,15 +16,15 @@ repos:
           '--statistics'
           ]
         exclude: ^db/__init__.py$ # all models need to be imported for Alembic, but are not used directly
-  - repo: local
-    hooks:
-      - id: pytest
-        name: pytest
-        entry: pytest  # Or your specific test command, e.g., poetry run pytest
-        language: system
-        types: [python] # Specify relevant file types for your tests
-        pass_filenames: false
-        always_run: true
+#  - repo: local
+#    hooks:
+#      - id: pytest
+#        name: pytest
+#        entry: pytest  # Or your specific test command, e.g., poetry run pytest
+#        language: system
+#        types: [python] # Specify relevant file types for your tests
+#        pass_filenames: false
+#        always_run: true
 
   # - repo: https://github.com/pre-commit/mirrors-mypy
   #   rev: v1.10.0  # Use the latest stable version or pin to your preference

core/enums.py

@@ -24,7 +24,9 @@
 )
 CasingMaterial: type[Enum] = build_enum_from_lexicon_category("casing_material")
 CollectionMethod: type[Enum] = build_enum_from_lexicon_category("collection_method")
-ConstructionMethod: type[Enum] = build_enum_from_lexicon_category("construction_method")
+WellConstructionMethod: type[Enum] = build_enum_from_lexicon_category(
+    "well_construction_method"
+)
 ContactType: type[Enum] = build_enum_from_lexicon_category("contact_type")
 CoordinateMethod: type[Enum] = build_enum_from_lexicon_category("coordinate_method")
 WellPurpose: type[Enum] = build_enum_from_lexicon_category("well_purpose")
@@ -68,8 +70,13 @@
 Vertical_datum: type[Enum] = build_enum_from_lexicon_category("vertical_datum")
 ScreenType: type[Enum] = build_enum_from_lexicon_category("screen_type")
 SensorType: type[Enum] = build_enum_from_lexicon_category("sensor_type")
+WellPumpType: type[Enum] = build_enum_from_lexicon_category("well_pump_type")
+PermissionType: type[Enum] = build_enum_from_lexicon_category("permission_type")
 GroupType: type[Enum] = build_enum_from_lexicon_category("group_type")
 MonitoringFrequency: type[Enum] = build_enum_from_lexicon_category(
     "monitoring_frequency"
 )
+AquiferType: type[Enum] = build_enum_from_lexicon_category("aquifer_type")
+GeographicScale: type[Enum] = build_enum_from_lexicon_category("geographic_scale")
+Lithology: type[Enum] = build_enum_from_lexicon_category("lithology")
 # ============= EOF =============================================

db/__init__.py

@@ -33,7 +33,7 @@
 from db.notes import *
 from db.observation import *
 from db.parameter import *
-from db.permission import *
+from db.permission_history import *
 from db.publication import *
 from db.regulatory_limit import *
 from db.sample import *
@@ -43,6 +43,11 @@
 from db.transducer import *
 from db.measuring_point_history import *
 from db.data_provenance import *
+from db.aquifer_system import *
+from db.geologic_formation import *
+from db.thing_aquifer_association import *
+from db.thing_geologic_formation_association import *
+from db.aquifer_type import *
 
 from sqlalchemy import (
     func,

db/aquifer_system.py

@@ -0,0 +1,84 @@
+"""
+SQLAlchemy model for the AquiferSystem table.
+
+This is a master reference table for aquifer systems and hydrogeologic units.
+"""
+
+from typing import List, TYPE_CHECKING
+
+from sqlalchemy import Text, Index
+from sqlalchemy.orm import relationship, Mapped, mapped_column
+from sqlalchemy.ext.associationproxy import association_proxy, AssociationProxy
+from geoalchemy2 import Geometry
+
+from db.base import Base, AutoBaseMixin, ReleaseMixin
+from db.lexicon import lexicon_term
+
+from constants import SRID_WGS84
+
+if TYPE_CHECKING:
+    from db.thing import WellScreen, ThingAquiferAssociation, Thing
+    from db.aquifer_type import AquiferType
+
+
+class AquiferSystem(Base, AutoBaseMixin, ReleaseMixin):
+    __versioned__ = {}
+
+    name: Mapped[str] = mapped_column(
+        nullable=False,
+        unique=True,
+        comment="The full, human-readable name of the aquifer system (e.g., 'Ogallala Aquifer').",
+    )
+    description: Mapped[str] = mapped_column(
+        Text,
+        nullable=True,
+        comment="A detailed description of the aquifer system, its characteristics, and its significance.",
+    )
+    # Lexicon terms were retrieved from NMAquifer's 'LU_AquiferType' table.
+    primary_aquifer_type: Mapped[str] = lexicon_term(
+        nullable=False,
+        comment="A controlled vocabulary field to classify the aquifer system as a whole (e.g., 'Unconfined', 'Confined', 'Perched').",
+    )
+    geographic_scale: Mapped[str] = lexicon_term(
+        nullable=False,
+        comment="A controlled vocabulary field to classify the aquifer's geographic scale (e.g., 'Major', 'Regional', 'Local').",
+    )
+    boundary: Mapped[Geometry] = mapped_column(
+        Geometry(geometry_type="MULTIPOLYGON", srid=SRID_WGS84, spatial_index=True),
+        nullable=True,
+        comment="A spatial representation of the aquifer system's boundary.",
+    )
+    # Hierarchical relationship fields (may be implemented in future iterations)
+    # Example: High Plains Aquifer (parent) contains Ogallala Aquifer (child)
+    # parent_id = Column(Integer, ForeignKey('aquifer_system.id'))
+    # parent = relationship('AquiferSystem', remote_side=[id], backref='subsystems')
+
+    # --- Relationships ---
+    # One-To-Many: An AquiferSystem can be associated with many wells (Things) via the ThingAquiferAssociation join table.
+    thing_associations: Mapped[List["ThingAquiferAssociation"]] = relationship(
+        "ThingAquiferAssociation",
+        back_populates="aquifer_system",
+        cascade="all, delete-orphan",
+        passive_deletes=True,
+    )
+
+    # One-To-Many: An AquiferSystem can be the target for many individual WellScreens.
+    well_screens: Mapped[List["WellScreen"]] = relationship(
+        "WellScreen",
+        back_populates="aquifer_system",
+        cascade="all, delete-orphan",
+        passive_deletes=True,
+    )
+
+    # --- Association Proxies ---
+    # Proxy to directly access Things (wells) associated with this AquiferSystem.
+    things: AssociationProxy[List["Thing"]] = association_proxy(
+        "thing_associations", "thing"
+    )
+    # Proxy to directly access all AquiferTypes associated with this AquiferSystem.
+    aquifer_types: AssociationProxy[List["AquiferType"]] = association_proxy(
+        "thing_associations", "aquifer_types"
+    )
+
+    # --- Table Arguments ---
+    __table_args__ = (Index("ix_aquifersystem_name", "name"),)

db/aquifer_type.py

@@ -0,0 +1,58 @@
+"""
+SQLAlchemy model for the AquiferType table.
+
+This table stores the specific aquifer characteristics/types associated with
+a Thing-AquiferSystem relationship. It allows capturing that a single aquifer
+can have multiple characteristics simultaneously.
+
+Example:
+    A well in the "Ogallala" aquifer might tap portions that are both
+    "Fractured" AND "Confined". This would create:
+    - One AquiferSystem: "Ogallala"
+    - One ThingAquiferAssociation: linking well to Ogallala
+    - Two AquiferType records: "Fractured" and "Confined"
+"""
+
+from typing import TYPE_CHECKING
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import relationship, Mapped, mapped_column
+
+from db.base import Base, AutoBaseMixin, ReleaseMixin, lexicon_term
+
+if TYPE_CHECKING:
+    from db.thing_aquifer_association import ThingAquiferAssociation
+
+
+class AquiferType(Base, AutoBaseMixin, ReleaseMixin):
+    """
+    Represents the specific aquifer types/characteristics for a
+    Thing-AquiferSystem association.
+
+    This allows modeling the fact that:
+    - A single aquifer can have multiple characteristics
+    - Different wells may tap different characteristics of the same aquifer
+    - Characteristics are attributes of the relationship, not the aquifer itself
+
+    Fields from WellData CSV:
+        - AquiferType: May contain multiple codes (e.g., "FC" = Fractured + Confined)
+        - Each code becomes a separate AquiferType record
+    """
+
+    # --- Columns ---
+    thing_aquifer_association_id: Mapped[int] = mapped_column(
+        ForeignKey("thing_aquifer_association.id", ondelete="CASCADE"),
+        nullable=False,
+        comment="Links to the Thing-Aquifer association this type describes.",
+    )
+    aquifer_type: Mapped[str] = lexicon_term(
+        nullable=False,
+        comment="Controlled vocabulary for aquifer hydrologic properties. "
+        "Examples: 'Unconfined', 'Confined', 'Perched', 'Fractured', 'Unconsolidated'.",
+    )
+
+    # --- Relationships ---
+    # Many-to-One: Multiple aquifer types can belong to one association
+    thing_aquifer_association: Mapped["ThingAquiferAssociation"] = relationship(
+        "ThingAquiferAssociation", back_populates="aquifer_types"
+    )

db/base.py

@@ -53,7 +53,6 @@
     declared_attr,
     Mapped,
     mapped_column,
-    relationship,
 )
 from sqlalchemy_continuum import make_versioned
 from sqlalchemy_searchable import make_searchable
@@ -179,25 +178,6 @@ def properties(self):
 # ============= Polymorphic Helper Mixins =============================================
 
 
-class PermissionMixin:
-    """
-    Mixin for models that can have permissions (e.g., Thing, Location).
-    It automatically creates a polymorphic One-to-Many relationship to the
-    Permission table.
-    """
-
-    @declared_attr
-    def permissions(self):
-        # One-to-Many polymorphic relationship
-        return relationship(
-            "Permission",
-            primaryjoin=f"and_({self.__name__}.id==foreign(Permission.permissible_id), "
-            f"Permission.permissible_type=='{self.__name__}')",
-            lazy="selectin",
-            viewonly=True,
-        )
-
-
 class User(Base):
     """Represents a user in the system."""
 

db/contact.py

@@ -26,7 +26,7 @@
     from db.field import FieldEventParticipant, FieldEvent
     from db.thing import Thing
     from db.publication import Author, AuthorContactAssociation
-    from db.permission import Permission
+    from db.permission_history import PermissionHistory
 
 
 class ThingContactAssociation(Base, AutoBaseMixin):
@@ -74,8 +74,10 @@ class Contact(Base, AutoBaseMixin, ReleaseMixin):
     )
 
     # One-To-Many: A Contact can grant many Permissions.
-    permissions: Mapped[List["Permission"]] = relationship(
-        "Permission", back_populates="contact", cascade="all, delete, delete-orphan"
+    permissions: Mapped[List["PermissionHistory"]] = relationship(
+        "PermissionHistory",
+        back_populates="contact",
+        cascade="all, delete, delete-orphan",
     )
     # One-To-Many: A Contact can be associated with many Authors (in Publications).
     author_associations: Mapped[List["AuthorContactAssociation"]] = relationship(

db/data_provenance.py

@@ -19,7 +19,7 @@
 from sqlalchemy import Integer, Index, and_
 from sqlalchemy.orm import relationship, Mapped, mapped_column, declared_attr, foreign
 
-from db.base import Base, AutoBaseMixin, ReleaseMixin, pascal_to_snake
+from db.base import Base, AutoBaseMixin, ReleaseMixin
 
 from db import lexicon_term
 
@@ -53,9 +53,13 @@ class DataProvenance(AutoBaseMixin, ReleaseMixin, Base):
     )
     # Values from the following NMAquifer tables are included as `origin_source` terms in the lexicon:
     # 'LU_DataSource', 'LU_Depth_CompletionSource'.
-    origin_source: Mapped[str] = lexicon_term(
+    origin_type: Mapped[str] = lexicon_term(
         nullable=True,
-        comment="Indicates the origin source of the data (e.g'Driller's Log', 'Well Report'.",
+        comment="Indicates the type of origin the data (e.g'Driller's Log', 'Well Report'.",
+    )
+    origin_source: Mapped[str] = mapped_column(
+        nullable=True,
+        comment="The specific source of the data (e.g., 'J. Brown Thesis, \"I like APIs\", Pomona College, 1994').",
     )
     # Values from the following NMAquifer tables are included as `collection_method` terms in the lexicon:
     # 'LU_AltitudeMethod','LU_CoordinateMethod'.
@@ -116,7 +120,7 @@ def data_provenance(cls):
             "DataProvenance",
             primaryjoin=and_(
                 cls.id == foreign(DataProvenance.target_id),
-                DataProvenance.target_table == pascal_to_snake(cls.__name__),
+                DataProvenance.target_table == cls.__tablename__,
             ),
             lazy="selectin",
             viewonly=True,

db/field.py

@@ -4,6 +4,7 @@
 from sqlalchemy.ext.associationproxy import association_proxy, AssociationProxy
 from typing import TYPE_CHECKING
 
+from db.notes import NotesMixin
 from db.base import Base, AutoBaseMixin, ReleaseMixin, lexicon_term
 
 if TYPE_CHECKING:
@@ -52,7 +53,7 @@ class FieldEventParticipant(Base, AutoBaseMixin, ReleaseMixin):
     )
 
 
-class FieldEvent(Base, AutoBaseMixin, ReleaseMixin):
+class FieldEvent(Base, AutoBaseMixin, ReleaseMixin, NotesMixin):
     """
     This table serves as the master log for all field visits. Each
     record in this table represents a single, continuous collection event at a
@@ -82,10 +83,6 @@ class FieldEvent(Base, AutoBaseMixin, ReleaseMixin):
         nullable=False,
         comment="Date and time of the field event.",
     )
-    notes: Mapped[str] = mapped_column(
-        nullable=True,
-        comment="Notes or comments about the field event.",
-    )
     # --- Relationships ---
     thing: Mapped["Thing"] = relationship(back_populates="field_events")
     field_activities: Mapped[list["FieldActivity"]] = relationship(