Expose primary_name_attribute in TableInfo, fix prodev example E2E

SDK changes:
- _get_entity_by_table_schema_name now selects PrimaryNameAttribute and
  PrimaryIdAttribute from EntityDefinitions
- _create_table returns primary_name_attribute in its result dict
- TableInfo model includes primary_name_attribute and primary_id_attribute
  fields with legacy key access
- Fixes #148: tables.create() now exposes the primary column logical name

Example changes:
- prodev_quick_start.py uses result.primary_name_attribute from tables.create()
  to construct correct record payloads (fixes the demo_*_name column error)
- Both examples verified E2E against live Dataverse

Author: Saurabh Badenkal

examples/advanced/datascience_risk_assessment.py

@@ -20,6 +20,11 @@
     4) Write risk assessments back to Dataverse
     5) Produce a summary report
 
+    Note: This example reads from existing Dataverse tables (account,
+    incident, opportunity) and does not create or delete any tables.
+    Step 4 (write-back) is disabled by default -- uncomment it in
+    run_risk_pipeline() to write risk scores back to account records.
+
 Prerequisites (required -- included in SDK dependencies):
     pip install PowerPlatform-Dataverse-Client
     pip install azure-identity

examples/advanced/prodev_quick_start.py

@@ -16,6 +16,10 @@
     5) Query and join data across tables
     6) Clean up (delete tables)
 
+    Note: The last step (cleanup) automatically deletes all demo tables.
+    Comment out the cleanup() call in run_demo() if you want to keep the
+    tables in your environment for inspection.
+
 Why pandas DataFrames?
     This example uses client.dataframe (pandas) instead of raw dict/list CRUD
     because DataFrames provide significant advantages for multi-record operations:
@@ -53,12 +57,14 @@
 
 from PowerPlatform.Dataverse.client import DataverseClient
 
-# -- Table schema names (prefixed to avoid collisions) --
-PREFIX = f"demo_{uuid.uuid4().hex[:6]}"
-TABLE_CUSTOMER = f"{PREFIX}_Customer"
-TABLE_PROJECT = f"{PREFIX}_Project"
-TABLE_TASK = f"{PREFIX}_Task"
-TABLE_TIMEENTRY = f"{PREFIX}_TimeEntry"
+# -- Table schema names --
+# Uses the standard 'new_' publisher prefix (default Dataverse publisher).
+# A unique suffix avoids collisions with existing tables.
+SUFFIX = uuid.uuid4().hex[:6]
+TABLE_CUSTOMER = f"new_DemoCustomer{SUFFIX}"
+TABLE_PROJECT = f"new_DemoProject{SUFFIX}"
+TABLE_TASK = f"new_DemoTask{SUFFIX}"
+TABLE_TIMEENTRY = f"new_DemoTimeEntry{SUFFIX}"
 
 # -- Output folder for exported data (relative to this script) --
 _SCRIPT_DIR = Path(__file__).resolve().parent
@@ -100,19 +106,19 @@ def run_demo(client):
     print(f"[INFO] Output folder: {OUTPUT_DIR.resolve()}")
 
     # -- Step 1: Create 4 tables --
-    step1_create_tables(client)
+    primary_name_col = step1_create_tables(client)
 
     # -- Step 2: Create relationships --
     step2_create_relationships(client)
 
     # -- Step 3: Populate with sample data --
-    customer_ids, project_ids, task_ids = step3_populate_data(client)
+    customer_ids, project_ids, task_ids = step3_populate_data(client, primary_name_col)
 
     # -- Step 4: Query and analyze --
-    step4_query_and_analyze(client, customer_ids)
+    step4_query_and_analyze(client, customer_ids, primary_name_col)
 
     # -- Step 5: Update and delete --
-    step5_update_and_delete(client, task_ids)
+    step5_update_and_delete(client, task_ids, primary_name_col)
 
     # -- Step 6: Cleanup --
     cleanup(client)
@@ -134,15 +140,18 @@ def step1_create_tables(client):
     print("-" * 60)
 
     # Customer table
-    client.tables.create(
+    result = client.tables.create(
         TABLE_CUSTOMER,
         {
             f"{TABLE_CUSTOMER}_Email": "string",
             f"{TABLE_CUSTOMER}_Industry": "string",
             f"{TABLE_CUSTOMER}_Revenue": "money",
         },
     )
-    print(f"[OK] Created table: {TABLE_CUSTOMER}")
+    # The primary name column logical name is returned by tables.create()
+    # so we know exactly what key to use in create payloads.
+    primary_name_col = result.primary_name_attribute
+    print(f"[OK] Created table: {TABLE_CUSTOMER} (primary column: {primary_name_col})")
 
     # Project table
     client.tables.create(
@@ -176,7 +185,10 @@ def step1_create_tables(client):
         },
     )
     print(f"[OK] Created table: {TABLE_TIMEENTRY}")
-    print(f"[OK] All 4 tables created with prefix '{PREFIX}'")
+    print(f"[OK] All 4 tables created (suffix: {SUFFIX})")
+    print(f"[INFO] Primary name column: '{primary_name_col}'")
+
+    return primary_name_col
 
 
 # ================================================================
@@ -225,7 +237,7 @@ def step2_create_relationships(client):
 # ================================================================
 
 
-def step3_populate_data(client):
+def step3_populate_data(client, primary_name_col):
     """Create sample records using client.dataframe.create().
 
     Why DataFrames here instead of client.records.create()?
@@ -252,10 +264,8 @@ def step3_populate_data(client):
     print("-" * 60)
 
     # -- Customers --
-    # Note: The primary column logical name is {prefix}_name (lowercase),
-    # and custom column logical names follow the same lowercase convention.
-    # The SDK lowercases keys automatically, so we use the schema names here.
-    name_col = f"{PREFIX}_Name"
+    # Use the primary name column returned by tables.create()
+    name_col = primary_name_col
     customers_df = pd.DataFrame(
         [
             {
@@ -364,15 +374,15 @@ def step3_populate_data(client):
 # ================================================================
 
 
-def step4_query_and_analyze(client, customer_ids):
+def step4_query_and_analyze(client, customer_ids, primary_name_col):
     """Query data and demonstrate DataFrame analysis."""
     print("\n" + "-" * 60)
     print("STEP 4: Query and analyze data")
     print("-" * 60)
 
     # Query all projects as a DataFrame
     # Note: select uses logical names (lowercase). The SDK lowercases automatically.
-    name_attr = f"{PREFIX}_name"  # primary column logical name
+    name_attr = primary_name_col
     projects = client.dataframe.get(
         TABLE_PROJECT,
         select=[
@@ -437,7 +447,7 @@ def step4_query_and_analyze(client, customer_ids):
 # ================================================================
 
 
-def step5_update_and_delete(client, task_ids):
+def step5_update_and_delete(client, task_ids, primary_name_col):
     """Demonstrate update and delete with DataFrames."""
     print("\n" + "-" * 60)
     print("STEP 5: Update and delete records")
@@ -461,10 +471,9 @@ def step5_update_and_delete(client, task_ids):
     print(f"[OK] Deleted 1 task")
 
     # Verify
-    name_attr = f"{PREFIX}_name"
     remaining = client.dataframe.get(
         TABLE_TASK,
-        select=[name_attr, status_col],
+        select=[primary_name_col, status_col],
     )
     print(f"\n  Remaining tasks ({len(remaining)}):")
     print(f"{remaining.to_string(index=False)}")

src/PowerPlatform/Dataverse/data/_odata.py

@@ -960,7 +960,7 @@ def _get_entity_by_table_schema_name(
         logical_lower = table_schema_name.lower()
         logical_escaped = self._escape_odata_quotes(logical_lower)
         params = {
-            "$select": "MetadataId,LogicalName,SchemaName,EntitySetName",
+            "$select": "MetadataId,LogicalName,SchemaName,EntitySetName,PrimaryNameAttribute,PrimaryIdAttribute",
             "$filter": f"LogicalName eq '{logical_escaped}'",
         }
         r = self._request("get", url, params=params, headers=headers)
@@ -1445,6 +1445,8 @@ def _get_table_info(self, table_schema_name: str) -> Optional[Dict[str, Any]]:
             "table_logical_name": ent.get("LogicalName"),
             "entity_set_name": ent.get("EntitySetName"),
             "metadata_id": ent.get("MetadataId"),
+            "primary_name_attribute": ent.get("PrimaryNameAttribute"),
+            "primary_id_attribute": ent.get("PrimaryIdAttribute"),
             "columns_created": [],
         }
 
@@ -1689,6 +1691,8 @@ def _create_table(
             "table_logical_name": metadata.get("LogicalName"),
             "entity_set_name": metadata.get("EntitySetName"),
             "metadata_id": metadata.get("MetadataId"),
+            "primary_name_attribute": metadata.get("PrimaryNameAttribute"),
+            "primary_id_attribute": metadata.get("PrimaryIdAttribute"),
             "columns_created": created_cols,
         }
 

src/PowerPlatform/Dataverse/models/table_info.py

@@ -112,6 +112,8 @@ class TableInfo:
     logical_name: str = ""
     entity_set_name: str = ""
     metadata_id: str = ""
+    primary_name_attribute: Optional[str] = None
+    primary_id_attribute: Optional[str] = None
     display_name: Optional[str] = None
     description: Optional[str] = None
     columns: Optional[List[ColumnInfo]] = field(default=None, repr=False)
@@ -123,6 +125,8 @@ class TableInfo:
         "table_logical_name": "logical_name",
         "entity_set_name": "entity_set_name",
         "metadata_id": "metadata_id",
+        "primary_name_attribute": "primary_name_attribute",
+        "primary_id_attribute": "primary_id_attribute",
         "columns_created": "columns_created",
     }
 
@@ -187,6 +191,8 @@ def from_dict(cls, data: Dict[str, Any]) -> TableInfo:
             logical_name=data.get("table_logical_name", ""),
             entity_set_name=data.get("entity_set_name", ""),
             metadata_id=data.get("metadata_id", ""),
+            primary_name_attribute=data.get("primary_name_attribute"),
+            primary_id_attribute=data.get("primary_id_attribute"),
             columns_created=data.get("columns_created"),
         )
 
@@ -213,6 +219,8 @@ def from_api_response(cls, response_data: Dict[str, Any]) -> TableInfo:
             logical_name=response_data.get("LogicalName", ""),
             entity_set_name=response_data.get("EntitySetName", ""),
             metadata_id=response_data.get("MetadataId", ""),
+            primary_name_attribute=response_data.get("PrimaryNameAttribute"),
+            primary_id_attribute=response_data.get("PrimaryIdAttribute"),
             display_name=display_name,
             description=description,
         )

tests/unit/models/test_table_info.py

@@ -49,11 +49,19 @@ def test_legacy_key_iteration(self):
         keys = list(self.info)
         self.assertEqual(
             keys,
-            ["table_schema_name", "table_logical_name", "entity_set_name", "metadata_id", "columns_created"],
+            [
+                "table_schema_name",
+                "table_logical_name",
+                "entity_set_name",
+                "metadata_id",
+                "primary_name_attribute",
+                "primary_id_attribute",
+                "columns_created",
+            ],
         )
 
     def test_len(self):
-        self.assertEqual(len(self.info), 5)
+        self.assertEqual(len(self.info), 7)
 
     def test_keys_values_items(self):
         self.assertEqual(list(self.info.keys()), list(self.info._LEGACY_KEY_MAP.keys()))
@@ -76,20 +84,41 @@ def test_from_dict(self):
             "table_logical_name": "new_product",
             "entity_set_name": "new_products",
             "metadata_id": "meta-guid-1",
+            "primary_name_attribute": "new_name",
+            "primary_id_attribute": "new_productid",
             "columns_created": ["new_Price"],
         }
         info = TableInfo.from_dict(data)
         self.assertEqual(info.schema_name, "new_Product")
         self.assertEqual(info.logical_name, "new_product")
         self.assertEqual(info.entity_set_name, "new_products")
         self.assertEqual(info.metadata_id, "meta-guid-1")
+        self.assertEqual(info.primary_name_attribute, "new_name")
+        self.assertEqual(info.primary_id_attribute, "new_productid")
         self.assertEqual(info.columns_created, ["new_Price"])
 
     def test_from_dict_missing_keys(self):
         info = TableInfo.from_dict({})
         self.assertEqual(info.schema_name, "")
+        self.assertIsNone(info.primary_name_attribute)
+        self.assertIsNone(info.primary_id_attribute)
         self.assertIsNone(info.columns_created)
 
+    def test_from_dict_legacy_access_primary_fields(self):
+        """Primary fields are accessible via legacy dict-key access."""
+        data = {
+            "table_schema_name": "new_Product",
+            "table_logical_name": "new_product",
+            "entity_set_name": "new_products",
+            "metadata_id": "meta-guid-1",
+            "primary_name_attribute": "new_name",
+            "primary_id_attribute": "new_productid",
+            "columns_created": [],
+        }
+        info = TableInfo.from_dict(data)
+        self.assertEqual(info["primary_name_attribute"], "new_name")
+        self.assertEqual(info["primary_id_attribute"], "new_productid")
+
 
 class TestTableInfoFromApiResponse(unittest.TestCase):
     """Tests for TableInfo.from_api_response factory (PascalCase keys)."""
@@ -100,6 +129,8 @@ def test_from_api_response(self):
             "LogicalName": "account",
             "EntitySetName": "accounts",
             "MetadataId": "meta-guid-2",
+            "PrimaryNameAttribute": "name",
+            "PrimaryIdAttribute": "accountid",
             "DisplayName": {"UserLocalizedLabel": {"Label": "Account", "LanguageCode": 1033}},
             "Description": {"UserLocalizedLabel": {"Label": "Business account", "LanguageCode": 1033}},
         }
@@ -108,6 +139,8 @@ def test_from_api_response(self):
         self.assertEqual(info.logical_name, "account")
         self.assertEqual(info.entity_set_name, "accounts")
         self.assertEqual(info.metadata_id, "meta-guid-2")
+        self.assertEqual(info.primary_name_attribute, "name")
+        self.assertEqual(info.primary_id_attribute, "accountid")
         self.assertEqual(info.display_name, "Account")
         self.assertEqual(info.description, "Business account")