shotgrid-orm 0.3.1__tar.gz → 0.3.3__tar.gz

{shotgrid_orm-0.3.1/src/shotgrid_orm.egg-info → shotgrid_orm-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgrid_orm
-Version: 0.3.1
+Version: 0.3.3
 Summary: Shotgrid SQLAlchemy ORM Generator - creates Python classes from a schema.
 Author-email: John Em Tran <johnemtran@gmail.com>
 License: The MIT License (MIT)

{shotgrid_orm-0.3.1 → shotgrid_orm-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shotgrid_orm"
-version = "0.3.1"
+version = "0.3.3"
 authors = [
   { name="John Em Tran", email="johnemtran@gmail.com" },
 ]

{shotgrid_orm-0.3.1 → shotgrid_orm-0.3.3}/src/shotgrid_orm/classes.py

@@ -258,11 +258,16 @@ class SGORM:
                         if field_type_value == "entity":
                             t_annotations[f"{field_code}_id"] = Mapped[Optional[int]]
                             if len(valid_types) == 1:
-                                # Single valid type: FK to target table; _type column is redundant.
-                                t_namespace[f"{field_code}_id"] = mapped_column(
-                                    sa.BigInteger, sa.ForeignKey(f"{valid_types[0]}.id")
-                                )
-                                self.info(f"  -> FK to {valid_types[0]}.id, no _type column")
+                                v_table = valid_types[0]
+                                if v_table in self.sg_schema and v_table not in self.ignored_tables:
+                                    # Single valid type: FK to target table; _type column is redundant.
+                                    t_namespace[f"{field_code}_id"] = mapped_column(
+                                        sa.BigInteger, sa.ForeignKey(f"{v_table}.id")
+                                    )
+                                    self.info(f"  -> FK to {v_table}.id, no _type column")
+                                else:
+                                    t_namespace[f"{field_code}_id"] = mapped_column(sa.BigInteger)
+                                    self.info(f"  -> {v_table} not in schema, plain BigInteger (no FK)")
                             else:
                                 # Zero or multiple valid types: keep _type for runtime disambiguation.
                                 # NOTE: For ORM navigation of polymorphic refs, consider

{shotgrid_orm-0.3.1 → shotgrid_orm-0.3.3}/src/shotgrid_orm/sgtypes.py

@@ -36,6 +36,7 @@ sg_types = {
     "currency": {"hint": Mapped[float], "type": mapped_column(Float)},
     "date": {"hint": Mapped[str], "type": mapped_column(String)},
     "date_time": {"hint": Mapped[datetime], "type": mapped_column(DateTime)},
+    "duration": {"hint": Mapped[int], "type": mapped_column(Integer)},
     # NOTE: Entity types are stored as integer IDs. Relationship mappings are handled
     # in classes.py by creating _id and _type fields for polymorphic associations.
     # Full SQLAlchemy relationship() support could be added in future versions.
@@ -71,6 +72,7 @@ sg_types_optional = {
     "currency": {"hint": Mapped[Optional[float]], "type": mapped_column(Float)},
     "date": {"hint": Mapped[Optional[str]], "type": mapped_column(String)},
     "date_time": {"hint": Mapped[Optional[datetime]], "type": mapped_column(DateTime)},
+    "duration": {"hint": Mapped[Optional[int]], "type": mapped_column(Integer)},
     # NOTE: Entity types are stored as integer IDs. Relationship mappings are handled
     # in classes.py by creating _id and _type fields for polymorphic associations.
     "entity": {"hint": Mapped[Optional[int]], "type": mapped_column(Integer)},

{shotgrid_orm-0.3.1 → shotgrid_orm-0.3.3/src/shotgrid_orm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgrid_orm
-Version: 0.3.1
+Version: 0.3.3
 Summary: Shotgrid SQLAlchemy ORM Generator - creates Python classes from a schema.
 Author-email: John Em Tran <johnemtran@gmail.com>
 License: The MIT License (MIT)

{shotgrid_orm-0.3.1 → shotgrid_orm-0.3.3}/tests/test_sgorm.py

@@ -197,6 +197,66 @@ def test_multi_entity_field_multi_valid_type_keeps_type_col(sg_orm):
     assert hasattr(Asset, "task_assignees_type")
 
 
+def test_dangling_fk_not_generated(tmp_path):
+    """entity field whose single valid_type is absent from the schema must not emit a FK.
+
+    Reproduces: 'Foreign key associated with column ... could not find table ...'
+    which previously crashed metadata.create_all() for internal SG entities like
+    AppWelcome that are referenced by other tables but not present in the schema.
+    """
+    import json
+
+    schema = {
+        "Child": {
+            "name": {"visible": True},
+            "fields": {
+                "id": {
+                    "data_type": {"value": "number"},
+                    "editable": False,
+                    "entity_type": {"value": "Child"},
+                    "mandatory": {"value": False},
+                    "name": {"value": "id"},
+                    "properties": {"default_value": {"value": None}},
+                    "unique": False,
+                    "visible": {"value": True},
+                },
+                "ghost_link": {
+                    # Single valid type that is NOT in this schema
+                    "data_type": {"value": "entity"},
+                    "editable": True,
+                    "entity_type": {"value": "Child"},
+                    "mandatory": {"value": False},
+                    "name": {"value": "ghost_link"},
+                    "properties": {
+                        "default_value": {"value": None},
+                        "valid_types": {"value": ["GhostEntity"]},
+                    },
+                    "unique": False,
+                    "visible": {"value": True},
+                },
+            },
+        }
+    }
+
+    schema_path = tmp_path / "schema.json"
+    schema_path.write_text(json.dumps(schema))
+
+    orm = SGORM(sg_schema_type=SchemaType.JSON_FILE, sg_schema_source=str(schema_path), echo=False)
+
+    # Must not raise when creating tables — no dangling FK
+    engine = create_engine("sqlite+pysqlite:///:memory:", echo=False)
+    orm.Base.metadata.create_all(engine)  # Would raise before the fix
+
+    # The column must exist but without a FK constraint
+    inspector = inspect(engine)
+    fks = inspector.get_foreign_keys("Child")
+    ghost_fks = [fk for fk in fks if "ghost_link_id" in fk["constrained_columns"]]
+    assert len(ghost_fks) == 0, "No FK should be generated for a target table absent from the schema"
+
+    Child = orm["Child"]
+    assert hasattr(Child, "ghost_link_id"), "ghost_link_id column must still be present"
+
+
 def test_entity_field_fk_enforced_in_db(sg_orm, test_db_path):
     """FK constraints appear on single-type entity fields but not on multi-type fields."""
     from sqlalchemy import create_engine
@@ -216,3 +276,62 @@ def test_entity_field_fk_enforced_in_db(sg_orm, test_db_path):
     asset_fks = inspector.get_foreign_keys("Asset")
     entity_source_fks = [fk for fk in asset_fks if "entity_source_id" in fk["constrained_columns"]]
     assert len(entity_source_fks) == 0, "Asset.entity_source_id must NOT have a FK (polymorphic field)"
+
+
+def test_duration_field_type(tmp_path):
+    """duration fields are numeric (integer minutes) and persist as Integer columns."""
+    import json
+
+    from sqlalchemy.types import Integer
+
+    schema = {
+        "Task": {
+            "name": {"visible": True},
+            "fields": {
+                "id": {
+                    "data_type": {"value": "number"},
+                    "editable": False,
+                    "entity_type": {"value": "Task"},
+                    "mandatory": {"value": False},
+                    "name": {"value": "id"},
+                    "properties": {"default_value": {"value": None}},
+                    "unique": False,
+                    "visible": {"value": True},
+                },
+                "duration": {
+                    "data_type": {"value": "duration"},
+                    "editable": True,
+                    "entity_type": {"value": "Task"},
+                    "mandatory": {"value": False},
+                    "name": {"value": "duration"},
+                    "properties": {"default_value": {"value": None}},
+                    "unique": False,
+                    "visible": {"value": True},
+                },
+            },
+        }
+    }
+
+    schema_path = tmp_path / "schema.json"
+    schema_path.write_text(json.dumps(schema))
+
+    orm = SGORM(sg_schema_type=SchemaType.JSON_FILE, sg_schema_source=str(schema_path), echo=False)
+    Task = orm["Task"]
+    assert Task is not None
+    assert hasattr(Task, "duration")
+
+    engine = create_engine("sqlite+pysqlite:///:memory:", echo=False)
+    orm.Base.metadata.create_all(engine)
+
+    # Duration column must map to an integer type.
+    duration_col = next(c for c in Task.__table__.columns if c.name == "duration")
+    assert isinstance(duration_col.type, Integer)
+
+    # Round-trip a value to ensure persistence works.
+    session = Session(engine)
+    task = Task(id=1, duration=120)
+    session.add(task)
+    session.commit()
+    retrieved = session.get(Task, 1)
+    assert retrieved.duration == 120
+    session.close()