auto create file column if it doesnt exist

Author: Max Wang

.claude/skills/dataverse-sdk/SKILL.md

@@ -199,7 +199,7 @@ client.delete_table("new_Product")
 client.upload_file(
     table_schema_name="account",
     record_id=account_id,
-    file_name_attribute="new_document",
+    file_name_attribute="new_document",  # If the file column doesn't exist, it will be created automatically
     path="/path/to/document.pdf"
 )
 ```

README.md

@@ -269,7 +269,7 @@ client.delete_table("new_Product")
 client.upload_file(
     table_schema_name="account",
     record_id=account_id,
-    file_name_attribute="new_document",
+    file_name_attribute="new_document",  # If the file column doesn't exist, it will be created automatically
     path="/path/to/document.pdf"
 )
 ```

examples/advanced/file_upload.py

@@ -48,12 +48,12 @@
 run_small = mode_int in (1, 3)
 run_chunk = mode_int in (2, 3)
 
-delete_table_choice = input("Delete the table at end? (y/N): ").strip() or "n"
-cleanup_table = delete_table_choice.lower() in ("y", "yes", "true", "1")
-
 delete_record_choice = input("Delete the created record at end? (Y/n): ").strip() or "y"
 cleanup_record = delete_record_choice.lower() in ("y", "yes", "true", "1")
 
+delete_table_choice = input("Delete the table at end? (y/N): ").strip() or "n"
+cleanup_table = delete_table_choice.lower() in ("y", "yes", "true", "1")
+
 credential = InteractiveBrowserCredential()
 client = DataverseClient(base_url=base_url, credential=credential)
 
@@ -183,7 +183,7 @@ def backoff(op, *, delays=(0, 2, 5, 10, 20, 20)):
 
 
 # --------------------------- Table ensure ---------------------------
-TABLE_SCHEMA_NAME = "new_FileSample"
+TABLE_SCHEMA_NAME = "new_FileSample111"
 
 
 def ensure_table():
@@ -192,7 +192,7 @@ def ensure_table():
     if existing:
         print({"table": TABLE_SCHEMA_NAME, "existed": True})
         return existing
-    log("client.create_table('new_FileSample', schema={'new_Title': 'string'})")
+    log(f"client.create_table('{TABLE_SCHEMA_NAME}', schema={{'new_Title': 'string'}})")
     info = backoff(lambda: client.create_table(TABLE_SCHEMA_NAME, {"new_Title": "string"}))
     print({"table": TABLE_SCHEMA_NAME, "existed": False, "metadata_id": info.get("metadata_id")})
     return info
@@ -214,99 +214,6 @@ def ensure_table():
 chunk_file_attr_schema = f"{attr_prefix}_ChunkDocument"  # attribute for streaming chunk upload demo
 chunk_file_attr_logical = f"{attr_prefix}_chunkdocument"  # expected logical name
 
-
-def ensure_file_attribute_generic(schema_name: str, label: str, key_prefix: str):
-    meta_id = table_info.get("metadata_id")
-    if not meta_id:
-        print({f"{key_prefix}_attribute": "skipped", "reason": "missing metadata_id"})
-        return False
-    odata = client._get_odata()
-    # Probe existing
-    try:
-        url = (
-            f"{odata.api}/EntityDefinitions({meta_id})/Attributes?$select=SchemaName&$filter="
-            f"SchemaName eq '{schema_name}'"
-        )
-        r = backoff(lambda: odata._request("get", url), delays=ATTRIBUTE_VISIBILITY_DELAYS)
-        val = []
-        try:
-            val = r.json().get("value", [])
-        except Exception:  # noqa: BLE001
-            pass
-        if any(a.get("SchemaName") == schema_name for a in val if isinstance(a, dict)):
-            return True
-    except Exception as ex:  # noqa: BLE001
-        print({f"{key_prefix}_file_attr_probe_error": str(ex)})
-
-    payload = {
-        "@odata.type": "Microsoft.Dynamics.CRM.FileAttributeMetadata",
-        "SchemaName": schema_name,
-        "DisplayName": {
-            "@odata.type": "Microsoft.Dynamics.CRM.Label",
-            "LocalizedLabels": [
-                {
-                    "@odata.type": "Microsoft.Dynamics.CRM.LocalizedLabel",
-                    "Label": label,
-                    "LanguageCode": int(client._config.language_code),
-                }
-            ],
-        },
-        "RequiredLevel": {"Value": "None"},
-    }
-    try:
-        url = f"{odata.api}/EntityDefinitions({meta_id})/Attributes"
-        backoff(lambda: odata._request("post", url, json=payload), delays=ATTRIBUTE_VISIBILITY_DELAYS)
-        print({f"{key_prefix}_file_attribute_created": True})
-        time.sleep(2)
-        return True
-    except Exception as ex:  # noqa: BLE001
-        resp = getattr(ex, "response", None)
-        body_l = None
-        try:
-            body_l = resp.text.lower() if getattr(resp, "text", None) else None
-        except Exception:  # noqa: BLE001
-            pass
-        if body_l and ("duplicate" in body_l or "exists" in body_l):
-            print({f"{key_prefix}_file_attribute_created": False, "reason": "already exists (race)"})
-            return True
-        print({f"{key_prefix}_file_attribute_created": False, "error": str(ex)})
-        return False
-
-
-def wait_for_attribute_visibility(logical_name: str, label: str):
-    if not logical_name or not entity_set:
-        return False
-    odata = client._get_odata()
-    probe_url = f"{odata.api}/{entity_set}?$top=1&$select={logical_name}"
-    waited = 0
-    last_error = None
-    for delay in ATTRIBUTE_VISIBILITY_DELAYS:
-        if delay:
-            time.sleep(delay)
-            waited += delay
-        try:
-            resp = odata._request("get", probe_url)
-            try:
-                resp.json()
-            except Exception:  # noqa: BLE001
-                pass
-            if waited:
-                print({f"{label}_attribute_visible_wait_seconds": waited})
-            return True
-        except Exception as ex:  # noqa: BLE001
-            last_error = ex
-            continue
-    raise RuntimeError(f"Timed out waiting for attribute '{logical_name}' to materialize") from last_error
-
-
-# Conditionally ensure each attribute only if its mode is selected
-if run_small:
-    ensure_file_attribute_generic(small_file_attr_schema, "Small Document", "small")
-    wait_for_attribute_visibility(small_file_attr_logical, "small")
-if run_chunk:
-    ensure_file_attribute_generic(chunk_file_attr_schema, "Chunk Document", "chunk")
-    wait_for_attribute_visibility(chunk_file_attr_logical, "chunk")
-
 # --------------------------- Record create ---------------------------
 record_id = None
 try:

src/PowerPlatform/Dataverse/claude_skill/SKILL.md

@@ -199,7 +199,7 @@ client.delete_table("new_Product")
 client.upload_file(
     table_schema_name="account",
     record_id=account_id,
-    file_name_attribute="new_document",
+    file_name_attribute="new_document",  # If the file column doesn't exist, it will be created automatically
     path="/path/to/document.pdf"
 )
 ```

src/PowerPlatform/Dataverse/client.py

@@ -661,9 +661,8 @@ def upload_file(
                 )
         """
         with self._scoped_odata() as od:
-            entity_set = od._entity_set_from_schema_name(table_schema_name)
             od._upload_file(
-                entity_set,
+                table_schema_name,
                 record_id,
                 file_name_attribute,
                 path,

src/PowerPlatform/Dataverse/data/_odata.py

@@ -896,6 +896,31 @@ def _get_attribute_metadata(
                 return item
         return None
 
+    def _wait_for_attribute_visibility(
+        self,
+        entity_set: str,
+        attribute_logical_name: str,
+        delays: tuple = (0, 3, 10, 20),
+    ) -> bool:
+        """Wait for a newly created attribute to become visible in the data API.
+
+        After creating an attribute via the metadata API, there can be a delay before
+        it becomes queryable in the data API. This method polls the entity set with
+        the attribute in the $select clause until it succeeds or all delays are exhausted.
+        """
+        import time
+
+        probe_url = f"{self.api}/{entity_set}?$top=1&$select={attribute_logical_name}"
+        for delay in delays:
+            if delay:
+                time.sleep(delay)
+            try:
+                self._request("get", probe_url)
+                return True
+            except Exception:  # noqa: BLE001
+                continue
+        return False
+
     # ---------------------- Enum / Option Set helpers ------------------
     def _build_localizedlabels_payload(self, translations: Dict[int, str]) -> Dict[str, Any]:
         """Build a Dataverse Label object from {<language_code>: <text>} entries.
@@ -1239,6 +1264,13 @@ def _attribute_payload(
                     "IsGlobal": False,
                 },
             }
+        if dtype_l == "file":
+            return {
+                "@odata.type": "Microsoft.Dynamics.CRM.FileAttributeMetadata",
+                "SchemaName": column_schema_name,
+                "DisplayName": self._label(label),
+                "RequiredLevel": {"Value": "None"},
+            }
         return None
 
     def _get_table_info(self, table_schema_name: str) -> Optional[Dict[str, Any]]:

src/PowerPlatform/Dataverse/data/_upload.py

@@ -13,7 +13,7 @@ class _ODataFileUpload:
 
     def _upload_file(
         self,
-        entity_set: str,
+        table_schema_name: str,
         record_id: str,
         file_name_attribute: str,
         path: str,
@@ -25,12 +25,12 @@ def _upload_file(
 
         Parameters
         ----------
-        entity_set : :class:`str`
-            Target entity set (plural logical name), e.g. "accounts".
+        table_schema_name : :class:`str`
+            Table schema name (singular logical name), e.g. "account".
         record_id : :class:`str`
             GUID of the target record.
         file_name_attribute : :class:`str`
-            Logical name of the file column attribute
+            Logical name of the file column attribute. If the column doesn't exist, it will be created.
         path : :class:`str`
             Local filesystem path to the file.
         mode : :class:`str` | None
@@ -42,6 +42,25 @@ def _upload_file(
         """
         import os
 
+        # Resolve entity set from table schema name
+        entity_set = self._entity_set_from_schema_name(table_schema_name)
+
+        # Check if the file column exists, create it if it doesn't
+        entity_metadata = self._get_entity_by_table_schema_name(table_schema_name)
+        if entity_metadata:
+            metadata_id = entity_metadata.get("MetadataId")
+            if metadata_id:
+                attr_metadata = self._get_attribute_metadata(metadata_id, file_name_attribute)
+                if not attr_metadata:
+                    # Attribute doesn't exist, create it
+                    self._create_columns(table_schema_name, {file_name_attribute: "file"})
+                    # Wait for the attribute to become visible in the data API
+                    if not self._wait_for_attribute_visibility(entity_set, file_name_attribute):
+                        raise RuntimeError(
+                            f"Attribute '{file_name_attribute}' was created but did not become visible "
+                            f"in the data API after 33 seconds (max retry timeout). The upload cannot proceed. Retry upload later might help."
+                        )
+
         mode = (mode or "auto").lower()
 
         if mode == "auto":