f3-data-models 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

f3_data_models/models.py

@@ -17,6 +17,7 @@ from sqlalchemy import (
     UniqueConstraint,
     Enum,
     Uuid,
+    inspect,
 )
 from typing_extensions import Annotated
 from sqlalchemy.orm import (
@@ -25,6 +26,7 @@ from sqlalchemy.orm import (
     Mapped,
     relationship,
 )
+from sqlalchemy.orm.attributes import InstrumentedAttribute
 import enum
 
 # Custom Annotations
@@ -150,6 +152,26 @@ class Base(DeclarativeBase):
             if c.key not in ["created", "updated"]
         }
 
+    def to_update_dict(self) -> Dict[InstrumentedAttribute, Any]:
+        update_dict = {}
+        mapper = inspect(self).mapper
+
+        # Add simple attributes
+        for attr in mapper.column_attrs:
+            if attr.key not in ["created", "updated", "id"]:
+                update_dict[attr] = getattr(self, attr.key)
+
+        # Add relationships
+        for rel in mapper.relationships:
+            related_value = getattr(self, rel.key)
+            if related_value is not None:
+                if rel.uselist:
+                    update_dict[rel] = [item for item in related_value]
+                    print(rel, update_dict[rel])
+                else:
+                    update_dict[rel] = related_value
+        return update_dict
+
     def __repr__(self):
         """
         Get a string representation of the model instance.

f3_data_models/testing.py

@@ -0,0 +1,33 @@
+from f3_data_models.models import Event, Day_Of_Week, Event_Cadence, EventType_x_Event
+import datetime
+from f3_data_models.utils import DbManager
+
+
+def test_update_event():
+    event = Event(
+        org_id=3,
+        location_id=2,
+        is_series=True,
+        is_active=True,
+        highlight=True,
+        start_date=datetime.date(2025, 2, 17),
+        end_date=datetime.date(2026, 2, 17),
+        start_time="0500",
+        end_time="0600",
+        event_x_event_types=[
+            EventType_x_Event(event_type_id=3),
+        ],
+        recurrence_pattern=Event_Cadence.weekly,
+        day_of_week=Day_Of_Week.monday,
+        recurrence_interval=1,
+        index_within_interval=1,
+        name="Test Event",
+    )
+    update_dict = event.to_update_dict()
+    DbManager.update_records(Event, [Event.id == 3], update_dict)
+
+    event = DbManager.get(Event, 3)
+
+
+if __name__ == "__main__":
+    test_update_event()

f3_data_models/utils.py

@@ -1,6 +1,6 @@
 import os
 from dataclasses import dataclass
-from typing import List, Optional, Tuple, TypeVar
+from typing import List, Optional, Tuple, TypeVar, Type, Generic  # noqa
 
 import sqlalchemy
 from sqlalchemy import Select, and_, select, inspect
@@ -9,7 +9,6 @@ from sqlalchemy.dialects.postgresql import insert
 from sqlalchemy.engine import Engine
 from sqlalchemy.orm import sessionmaker, joinedload
 from sqlalchemy.orm.collections import InstrumentedList
-from sqlalchemy.orm.attributes import flag_modified
 
 from f3_data_models.models import Base
 
@@ -17,6 +16,8 @@ from pydot import Dot
 from sqlalchemy_schemadisplay import create_schema_graph
 from google.cloud.sql.connector import Connector, IPTypes
 import pg8000
+from sqlalchemy.orm import class_mapper
+from sqlalchemy.orm.attributes import InstrumentedAttribute
 
 
 @dataclass
@@ -88,7 +89,7 @@ def _joinedloads(cls: T, query: Select, joinedloads: list | str) -> Select:
 
 
 class DbManager:
-    def get(cls: T, id: int, joinedloads: list | str = []) -> T:
+    def get(cls: Type[T], id: int, joinedloads: list | str = []) -> T:
         session = get_session()
         try:
             query = select(cls).filter(cls.id == id)
@@ -167,33 +168,57 @@ class DbManager:
             close_session(session)
 
     def update_record(cls: T, id, fields):
-        session = get_session()
-        # Fetch the object to be updated
-        obj = session.query(cls).get(id)
-        if not obj:
-            raise ValueError(f"Object with id {id} not found")
-
-        # Get the list of valid attributes for the class
-        valid_attributes = {attr.key for attr in inspect(cls).mapper.column_attrs}
-        valid_relationships = {rel.key for rel in inspect(cls).mapper.relationships}
-
-        # Update simple fields
-        for key, value in fields.items():
-            if key in valid_attributes and not isinstance(value, InstrumentedList):
-                setattr(obj, key, value)
-
-        # Update relationships
-        for key, value in fields.items():
-            if key in valid_relationships and isinstance(value, InstrumentedList):
-                related_objects = getattr(obj, key)
-                related_objects.clear()
-                related_objects.extend(value)
-
-        # Flag the object as modified to ensure changes are detected
-        flag_modified(obj, key)
-
-        # Commit the changes
-        session.commit()
+        with get_session() as session:
+            record = session.query(cls).get(id)
+            if not record:
+                raise ValueError(f"Record with id {id} not found in {cls.__name__}")
+
+            mapper = class_mapper(cls)
+            relationships = mapper.relationships.keys()
+            for attr, value in fields.items():
+                key = attr.key
+                if hasattr(cls, key) and key not in relationships:
+                    if isinstance(attr, InstrumentedAttribute):
+                        setattr(record, key, value)
+                elif key in relationships:
+                    # Handle relationships separately
+                    relationship = mapper.relationships[key]
+                    related_class = relationship.mapper.class_
+                    # find mapping of related_class
+                    og_primary_key = None
+                    for k in related_class.__table__.foreign_keys:
+                        if k.references(cls.__table__):
+                            og_primary_key = k.constraint.columns[0].name
+                            break
+
+                    if isinstance(value, list) and og_primary_key:
+                        # Delete existing related records
+                        related_class = relationship.mapper.class_
+                        related_relationships = class_mapper(
+                            related_class
+                        ).relationships.keys()
+                        session.query(related_class).filter(
+                            getattr(related_class, og_primary_key) == id
+                        ).delete()
+                        # Add new related records
+                        items = [item.__dict__ for item in value]
+                        for related_item in items:
+                            update_dict = {
+                                k: v
+                                for k, v in related_item.items()
+                                if hasattr(related_class, k)
+                                and k not in related_relationships
+                            }
+                            related_record = related_class(
+                                **{og_primary_key: id, **update_dict}
+                            )
+                            session.add(related_record)
+
+            try:
+                session.commit()
+            except pg8000.IntegrityError as e:
+                session.rollback()
+                raise e
 
     def update_records(cls, filters, fields):
         session = get_session()
@@ -207,21 +232,49 @@ class DbManager:
 
             for obj in objects:
                 # Update simple fields
-                for key, value in fields.items():
+                for attr, value in fields.items():
+                    key = attr.key
                     if key in valid_attributes and not isinstance(
                         value, InstrumentedList
                     ):
                         setattr(obj, key, value)
 
-                # Update relationships
-                for key, value in fields.items():
-                    if key in valid_relationships and isinstance(
-                        value, InstrumentedList
-                    ):
-                        related_objects = getattr(obj, key)
-                        related_objects.clear()
-                        related_objects.extend(value)
-                        flag_modified(obj, key)
+                # Update relationships separately
+                for attr, value in fields.items():
+                    key = attr.key
+                    if key in valid_relationships:
+                        # Handle relationships separately
+                        relationship = inspect(cls).mapper.relationships[key]
+                        related_class = relationship.mapper.class_
+                        # find mapping of related_class
+                        og_primary_key = None
+                        for k in related_class.__table__.foreign_keys:
+                            if k.references(cls.__table__):
+                                og_primary_key = k.constraint.columns[0].name
+                                break
+
+                        if isinstance(value, list) and og_primary_key:
+                            # Delete existing related records
+                            related_class = relationship.mapper.class_
+                            related_relationships = class_mapper(
+                                related_class
+                            ).relationships.keys()
+                            session.query(related_class).filter(
+                                getattr(related_class, og_primary_key) == obj.id
+                            ).delete()
+                            # Add new related records
+                            items = [item.__dict__ for item in value]
+                            for related_item in items:
+                                update_dict = {
+                                    k: v
+                                    for k, v in related_item.items()
+                                    if hasattr(related_class, k)
+                                    and k not in related_relationships
+                                }
+                                related_record = related_class(
+                                    **{og_primary_key: obj.id, **update_dict}
+                                )
+                                session.add(related_record)
 
             session.flush()
         finally:

{f3_data_models-0.3.6.dist-info → f3_data_models-0.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: f3-data-models
-Version: 0.3.6
+Version: 0.3.8
 Summary: The data schema and models for F3 Nation applications.
 License: MIT
 Author: Evan Petzoldt

f3_data_models-0.3.8.dist-info/RECORD

@@ -0,0 +1,7 @@
+f3_data_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+f3_data_models/models.py,sha256=jGxAG5Dmzhf2u4cLMUxY48yKENn5HC5N9_eUUSb31yc,45109
+f3_data_models/testing.py,sha256=Pd-TYvkeai2DuN9ubPPdqjo4xS_Zd3T1WGV7J_SXPdc,921
+f3_data_models/utils.py,sha256=UpNx1E_kmt8_1vN4fdFSy55yPCoDA2algzof_5EAJ2k,13835
+f3_data_models-0.3.8.dist-info/METADATA,sha256=Hza4-PUUC0sK4D-BJHGIx81WXrSjcS8PFYB98euxGhE,2716
+f3_data_models-0.3.8.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+f3_data_models-0.3.8.dist-info/RECORD,,

f3_data_models-0.3.6.dist-info/RECORD

@@ -1,6 +0,0 @@
-f3_data_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-f3_data_models/models.py,sha256=SLOXwM2BMnlGTwkVZfG3fM9hoksvPkcFRqzpEI4bm2Y,44293
-f3_data_models/utils.py,sha256=fGv-qHviSsUqHmYElBvYgWbqX5LAlTJCoKSMIqd8ioA,10738
-f3_data_models-0.3.6.dist-info/METADATA,sha256=G6dtENVh5a3JKZ4NdCl3DVY6dTybhdEl5jLvQmKnFHY,2716
-f3_data_models-0.3.6.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-f3_data_models-0.3.6.dist-info/RECORD,,