f3-data-models 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

f3_data_models/testing.py

@@ -0,0 +1,40 @@
+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=4),
+        ],
+        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.__dict__
+    DbManager.update_records(Event, [Event.id == 3], update_dict)
+
+    # with get_session() as session:
+    #     # delete event_x_event_types
+    #     session.query(EventType_x_Event).filter(
+    #         EventType_x_Event.event_id == 3
+    #     ).delete()
+    #     # add event_x_event_types
+    #     session.add(EventType_x_Event(event_id=3, event_type_id=4))
+    #     session.commit()
+
+
+if __name__ == "__main__":
+    test_update_event()

f3_data_models/utils.py

@@ -3,11 +3,12 @@ from dataclasses import dataclass
 from typing import List, Optional, Tuple, TypeVar
 
 import sqlalchemy
-from sqlalchemy import Select, and_, select
+from sqlalchemy import Select, and_, select, inspect
 
 from sqlalchemy.dialects.postgresql import insert
 from sqlalchemy.engine import Engine
 from sqlalchemy.orm import sessionmaker, joinedload
+from sqlalchemy.orm.collections import InstrumentedList
 
 from f3_data_models.models import Base
 
@@ -15,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
@@ -165,22 +168,112 @@ class DbManager:
             close_session(session)
 
     def update_record(cls: T, id, fields):
+        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 key, value in fields.items():
+                if hasattr(cls, key) and key not in relationships:
+                    attr = getattr(cls, key)
+                    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()
         try:
-            session.query(cls).filter(cls.id == id).update(
-                fields, synchronize_session="fetch"
-            )
-            session.flush()
-        finally:
-            session.commit()
-            close_session(session)
+            # Fetch the objects to be updated
+            objects = session.query(cls).filter(and_(*filters)).all()
+
+            # 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}
+
+            for obj in objects:
+                # 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 separately
+                for key, value in fields.items():
+                    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)
 
-    def update_records(cls: T, filters, fields):
-        session = get_session()
-        try:
-            session.query(cls).filter(and_(*filters)).update(
-                fields, synchronize_session="fetch"
-            )
             session.flush()
         finally:
             session.commit()

{f3_data_models-0.3.5.dist-info → f3_data_models-0.3.7.dist-info}/METADATA

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

f3_data_models-0.3.7.dist-info/RECORD

@@ -0,0 +1,7 @@
+f3_data_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+f3_data_models/models.py,sha256=SLOXwM2BMnlGTwkVZfG3fM9hoksvPkcFRqzpEI4bm2Y,44293
+f3_data_models/testing.py,sha256=vetCEBQC8R1hf0TcH3-lINXdlHMVIcjC6OhVWiiFWU0,1204
+f3_data_models/utils.py,sha256=5Hg0f1cPMYc-URdTbDTLMiG9rCFN5NskJ4lUHw1a2NU,13747
+f3_data_models-0.3.7.dist-info/METADATA,sha256=F34OA9YQW-60PwJ77YytFIHNL_-zMlbew6t23Rrdfm4,2716
+f3_data_models-0.3.7.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+f3_data_models-0.3.7.dist-info/RECORD,,

{f3_data_models-0.3.5.dist-info → f3_data_models-0.3.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.1
+Generator: poetry-core 2.1.1
 Root-Is-Purelib: true
 Tag: py3-none-any

f3_data_models-0.3.5.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=1hdZ2tvMiNibNZvwt0dx4PhPCw_pJGg1mG2cCvwc6CI,8857
-f3_data_models-0.3.5.dist-info/METADATA,sha256=L2i2GhGM0d1ueb9uQuHNqPJs_X1NbuJKdLD6jaKp6RM,2716
-f3_data_models-0.3.5.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-f3_data_models-0.3.5.dist-info/RECORD,,