f3-data-models 0.4.3__tar.gz → 0.4.6__tar.gz

{f3_data_models-0.4.3 → f3_data_models-0.4.6}/PKG-INFO

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

{f3_data_models-0.4.3 → f3_data_models-0.4.6}/f3_data_models/models.py

@@ -777,13 +777,12 @@ class User(Base):
     """  # noqa: E501
 
     __tablename__ = "users"
-    __table_args__ = (Index("idx_users_email", func.lower("email"), unique=True),)
 
     id: Mapped[intpk]
     f3_name: Mapped[Optional[str]]
     first_name: Mapped[Optional[str]]
     last_name: Mapped[Optional[str]]
-    email: Mapped[str] = mapped_column(CIText)
+    email: Mapped[str] = mapped_column(CIText, unique=True)
     phone: Mapped[Optional[str]]
     emergency_contact: Mapped[Optional[str]]
     emergency_phone: Mapped[Optional[str]]

f3_data_models-0.4.6/f3_data_models/testing.py

@@ -0,0 +1,27 @@
+from f3_data_models.models import Location
+from f3_data_models.utils import DbManager
+
+
+def test_update_event():
+    DbManager.update_record(
+        Location,
+        2,
+        {
+            "name": "The Beach",
+            "description": None,
+            "is_active": True,
+            "latitude": 22.0356,
+            "longitude": -159.3377,
+            "address_street": None,
+            "address_street2": None,
+            "address_city": None,
+            "address_state": None,
+            "address_zip": None,
+            "address_country": None,
+            "org_id": 5,
+        },
+    )
+
+
+if __name__ == "__main__":
+    test_update_event()

{f3_data_models-0.4.3 → f3_data_models-0.4.6}/f3_data_models/utils.py

@@ -1,24 +1,20 @@
 import os
 from dataclasses import dataclass
-from typing import List, Optional, Tuple, TypeVar, Type, Generic  # noqa
+from typing import Generic, List, Optional, Tuple, Type, TypeVar  # noqa
 
+import pg8000
 import sqlalchemy
-from sqlalchemy import Select, and_, select, inspect
-
+from google.cloud.sql.connector import Connector, IPTypes
+from pydot import Dot
+from sqlalchemy import Select, and_, inspect, select
 from sqlalchemy.dialects.postgresql import insert
 from sqlalchemy.engine import Engine
-from sqlalchemy.orm import sessionmaker, joinedload
+from sqlalchemy.orm import class_mapper, joinedload, sessionmaker
 from sqlalchemy.orm.collections import InstrumentedList
+from sqlalchemy_schemadisplay import create_schema_graph
 
 from f3_data_models.models import Base
 
-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
 class DatabaseField:
@@ -53,9 +49,7 @@ def get_engine(echo=False) -> Engine:
             )
             return conn
 
-        engine = sqlalchemy.create_engine(
-            "postgresql+pg8000://", creator=get_connection, echo=echo
-        )
+        engine = sqlalchemy.create_engine("postgresql+pg8000://", creator=get_connection, echo=echo)
     return engine
 
 
@@ -81,10 +75,7 @@ T = TypeVar("T")
 
 def _joinedloads(cls: T, query: Select, joinedloads: list | str) -> Select:
     if joinedloads == "all":
-        joinedloads = [
-            getattr(cls, relationship.key)
-            for relationship in cls.__mapper__.relationships
-        ]
+        joinedloads = [getattr(cls, relationship.key) for relationship in cls.__mapper__.relationships]
     return query.options(*[joinedload(load) for load in joinedloads])
 
 
@@ -101,9 +92,7 @@ class DbManager:
             session.rollback()
             close_session(session)
 
-    def find_records(
-        cls: T, filters: Optional[List], joinedloads: List | str = []
-    ) -> List[T]:
+    def find_records(cls: T, filters: Optional[List], joinedloads: List | str = []) -> List[T]:
         session = get_session()
         try:
             query = select(cls)
@@ -117,9 +106,7 @@ class DbManager:
             session.rollback()
             close_session(session)
 
-    def find_first_record(
-        cls: T, filters: Optional[List], joinedloads: List | str = []
-    ) -> T:
+    def find_first_record(cls: T, filters: Optional[List], joinedloads: List | str = []) -> T:
         session = get_session()
         try:
             query = select(cls)
@@ -136,21 +123,14 @@ class DbManager:
     def find_join_records2(left_cls: T, right_cls: T, filters) -> List[Tuple[T]]:
         session = get_session()
         try:
-            records = (
-                session.query(left_cls, right_cls)
-                .join(right_cls)
-                .filter(and_(*filters))
-                .all()
-            )
+            records = session.query(left_cls, right_cls).join(right_cls).filter(and_(*filters)).all()
             session.expunge_all()
             return records
         finally:
             session.rollback()
             close_session(session)
 
-    def find_join_records3(
-        left_cls: T, right_cls1: T, right_cls2: T, filters, left_join=False
-    ) -> List[Tuple[T]]:
+    def find_join_records3(left_cls: T, right_cls1: T, right_cls2: T, filters, left_join=False) -> List[Tuple[T]]:
         session = get_session()
         try:
             records = (
@@ -176,10 +156,14 @@ class DbManager:
             mapper = class_mapper(cls)
             relationships = mapper.relationships.keys()
             for attr, value in fields.items():
-                key = attr.key
+                key = attr if isinstance(attr, str) else attr.key
+                print(f"key: {key}, value: {value}")
                 if hasattr(cls, key) and key not in relationships:
-                    if isinstance(attr, InstrumentedAttribute):
-                        setattr(record, key, value)
+                    setattr(record, key, value)
+                    # if isinstance(attr, InstrumentedAttribute):
+                    #     setattr(record, key, value)
+                    # else:
+                    #     setattr(record, key, value)
                 elif key in relationships:
                     # Handle relationships separately
                     relationship = mapper.relationships[key]
@@ -194,27 +178,21 @@ class DbManager:
                     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()
+                        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
+                                if hasattr(related_class, k) and k not in related_relationships
                             }
-                            related_record = related_class(
-                                **{og_primary_key: id, **update_dict}
-                            )
+                            related_record = related_class(**{og_primary_key: id, **update_dict})
                             session.add(related_record)
 
             try:
+                print(record)
                 session.commit()
             except pg8000.IntegrityError as e:
                 session.rollback()
@@ -234,9 +212,7 @@ class DbManager:
                 # Update simple fields
                 for attr, value in fields.items():
                     key = attr.key
-                    if key in valid_attributes and not isinstance(
-                        value, InstrumentedList
-                    ):
+                    if key in valid_attributes and not isinstance(value, InstrumentedList):
                         setattr(obj, key, value)
 
                 # Update relationships separately
@@ -256,9 +232,7 @@ class DbManager:
                         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()
+                            related_relationships = class_mapper(related_class).relationships.keys()
                             session.query(related_class).filter(
                                 getattr(related_class, og_primary_key) == obj.id
                             ).delete()
@@ -268,12 +242,9 @@ class DbManager:
                                 update_dict = {
                                     k: v
                                     for k, v in related_item.items()
-                                    if hasattr(related_class, k)
-                                    and k not in related_relationships
+                                    if hasattr(related_class, k) and k not in related_relationships
                                 }
-                                related_record = related_class(
-                                    **{og_primary_key: obj.id, **update_dict}
-                                )
+                                related_record = related_class(**{og_primary_key: obj.id, **update_dict})
                                 session.add(related_record)
 
             session.flush()
@@ -307,11 +278,7 @@ class DbManager:
         session = get_session()
         try:
             for record in records:
-                record_dict = {
-                    k: v
-                    for k, v in record.__dict__.items()
-                    if k != "_sa_instance_state"
-                }
+                record_dict = {k: v for k, v in record.__dict__.items() if k != "_sa_instance_state"}
                 stmt = insert(cls).values(record_dict).on_conflict_do_nothing()
                 session.execute(stmt)
             session.flush()
@@ -323,15 +290,9 @@ class DbManager:
         session = get_session()
         try:
             for record in records:
-                record_dict = {
-                    k: v
-                    for k, v in record.__dict__.items()
-                    if k != "_sa_instance_state"
-                }
+                record_dict = {k: v for k, v in record.__dict__.items() if k != "_sa_instance_state"}
                 stmt = insert(cls).values(record_dict)
-                update_dict = {
-                    c.name: getattr(record, c.name) for c in cls.__table__.columns
-                }
+                update_dict = {c.name: getattr(record, c.name) for c in cls.__table__.columns}
                 stmt = stmt.on_conflict_do_update(
                     index_elements=[cls.__table__.primary_key.columns.keys()],
                     set_=update_dict,

{f3_data_models-0.4.3 → f3_data_models-0.4.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "f3-data-models"
-version = "0.4.3"
+version = "0.4.6"
 description = "The data schema and models for F3 Nation applications."
 authors = ["Evan Petzoldt <evan.petzoldt@protonmail.com>"]
 readme = "README.md"

f3_data_models-0.4.3/f3_data_models/testing.py

@@ -1,34 +0,0 @@
-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="0400",
-        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_record(Event, 3, update_dict)
-
-    # event = DbManager.get(Event, 3)
-    DbManager.delete_records(Event, [Event.series_id == 3])
-
-
-if __name__ == "__main__":
-    test_update_event()