Use case-insenstivie prefixed logicalName in all operations

Author: tpellissier

README.md

@@ -41,8 +41,8 @@ Auth:
 | `delete` | `delete(logical_name, id)` | `None` | Delete one record. |
 | `delete` | `delete(logical_name, list[id], use_bulk_delete=True)` | `Optional[str]` | Delete many with async BulkDelete or sequential single-record delete. |
 | `query_sql` | `query_sql(sql)` | `list[dict]` | Constrained read-only SELECT via `?sql=`. |
-| `create_table` | `create_table(tablename, schema, solution_unique_name=None)` | `dict` | Creates custom table + columns. Friendly name (e.g. `SampleItem`) becomes schema `new_SampleItem`; explicit schema name (contains `_`) used as-is. Pass `solution_unique_name` to attach the table to a specific solution instead of the default solution. |
-| `create_column` | `create_column(tablename, columns)` | `list[str]` | Adds columns using a `{name: type}` mapping (same shape as `create_table` schema). Returns schema names for the created columns. |
+| `create_table` | `create_table(logical_name, schema, solution_unique_name=None)` | `dict` | Creates custom table + columns. Requires logical name with publisher prefix (e.g. `new_sampleitem`) and column names with same prefix (e.g. `{"new_code": "string"}`). Pass `solution_unique_name` to attach the table to a specific solution instead of the default solution. |
+| `create_column` | `create_column(tablename, columns)` | `list[str]` | Adds columns using a `{name: type}` mapping with publisher prefix (e.g. `{"new_category": "string"}`). Returns schema names for the created columns. |
 | `get_table_info` | `get_table_info(schema_name)` | `dict | None` | Basic table metadata by schema name (e.g. `new_SampleItem`). Friendly names not auto-converted. |
 | `list_tables` | `list_tables()` | `list[dict]` | Lists non-private tables. |
 | `delete_table` | `delete_table(tablename)` | `None` | Drops custom table. Accepts friendly or schema name; friendly converted to `new_<PascalCase>`. |
@@ -329,7 +329,7 @@ rec_id = client.create(logical, {name_attr: "Sample A"})[0]
 
 # Clean up
 client.delete(logical, rec_id)          # delete record
-client.delete_table("SampleItem")       # delete table (friendly name or explicit schema new_SampleItem)
+client.delete_table("new_sampleitem") # delete table by logical name
 ```
 
 Notes:

examples/advanced/file_upload.py

@@ -161,8 +161,8 @@ def ensure_table():
     if existing:
         print({"table": TABLE_SCHEMA_NAME, "existed": True})
         return existing
-    log("client.create_table('new_FileSample', schema={title})")
-    info = client.create_table(TABLE_SCHEMA_NAME, {"title": "string"})
+    log("client.create_table('new_filesample', schema={new_title})")
+    info = client.create_table(TABLE_SCHEMA_NAME, {"new_title": "string"})
     print({"table": TABLE_SCHEMA_NAME, "existed": False, "metadata_id": info.get('metadata_id')})
     return info
 

examples/basic/quickstart.py

@@ -95,9 +95,11 @@ class Status(IntEnum):
 # Check for existing table using list_tables
 log_call("client.list_tables()")
 tables = client.list_tables()
-existing_table = next((t for t in tables if t.get("SchemaName") == "new_SampleItem"), None)
+
+# LogicalName should be lowercase, but let's be defensive with case-insensitive comparison
+existing_table = next((t for t in tables if t.get("LogicalName", "").lower() == "new_sampleitem"), None)
 if existing_table:
-	table_info = client.get_table_info("new_SampleItem")
+	table_info = client.get_table_info("new_sampleitem")
 	created_this_run = False
 	print({
 		"table": table_info.get("entity_schema"),
@@ -106,20 +108,19 @@ class Status(IntEnum):
 		"logical": table_info.get("entity_logical_name"),
 		"metadata_id": table_info.get("metadata_id"),
 	})
-
 else:
 	# Create it since it doesn't exist
 	try:
-		log_call("client.create_table('new_SampleItem', schema={code,count,amount,when,active,status<enum>})")
+		log_call("client.create_table('new_sampleitem', schema={new_code,new_count,new_amount,new_when,new_active,new_status<enum>})")
 		table_info = client.create_table(
-			"new_SampleItem",
+			"new_sampleitem",
 			{
-				"code": "string",
-				"count": "int",
-				"amount": "decimal",
-				"when": "datetime",
-				"active": "bool",
-				"status": Status,
+				"new_code": "string",
+				"new_count": "int",
+				"new_amount": "decimal",
+				"new_when": "datetime",
+				"new_active": "bool",
+				"new_status": Status,
 			},
 		)
 		created_this_run = True if table_info and table_info.get("columns_created") else False
@@ -146,11 +147,11 @@ class Status(IntEnum):
 				pass
 		# Fail fast: all operations must use the custom table
 		sys.exit(1)
-entity_schema = table_info.get("entity_schema") or "new_SampleItem"
-logical = table_info.get("entity_logical_name")
+entity_schema = table_info.get("entity_schema") or "new_Sampleitem"
+logical = table_info.get("entity_logical_name") or "new_sampleitem"
 metadata_id = table_info.get("metadata_id")
 if not metadata_id:
-	refreshed_info = client.get_table_info(entity_schema) or {}
+	refreshed_info = client.get_table_info(logical) or {}
 	metadata_id = refreshed_info.get("metadata_id")
 	if metadata_id:
 		table_info["metadata_id"] = metadata_id
@@ -553,8 +554,8 @@ def run_paging_demo(label: str, *, top: Optional[int], page_size: Optional[int])
 scratch_column = f"scratch_{int(time.time())}"
 column_payload = {scratch_column: "string"}
 try:
-	log_call(f"client.create_column('{entity_schema}', {repr(column_payload)})")
-	column_create = client.create_columns(entity_schema, column_payload)
+	log_call(f"client.create_column('{logical}', {repr(column_payload)})")
+	column_create = client.create_columns(logical, column_payload)
 	if not isinstance(column_create, list) or not column_create:
 		raise RuntimeError("create_column did not return schema list")
 	created_details = column_create
@@ -589,10 +590,10 @@ def _metadata_after_create():
 			attr_type_before = raw_type
 			lowered = raw_type.lower()
 	delete_target = attribute_schema or scratch_column
-	log_call(f"client.delete_column('{entity_schema}', '{delete_target}')")
+	log_call(f"client.delete_column('{logical}', '{delete_target}')")
 
 	def _delete_column():
-		return client.delete_columns(entity_schema, delete_target)
+		return client.delete_columns(logical, delete_target)
 
 	column_delete = backoff_retry(
 		_delete_column,

src/dataverse_sdk/client.py

@@ -372,13 +372,12 @@ def query_sql(self, sql: str):
         return self._get_odata()._query_sql(sql)
 
     # Table metadata helpers
-    def get_table_info(self, tablename: str) -> Optional[Dict[str, Any]]:
+    def get_table_info(self, logical_name: str) -> Optional[Dict[str, Any]]:
         """
         Get basic metadata for a custom table if it exists.
-
-        :param tablename: Table friendly name (e.g. ``"SampleItem"``) or full schema name
-            (e.g. ``"new_SampleItem"``).
-        :type tablename: str
+        :param logical_name: Table logical name with publisher prefix (e.g. ``"new_sampleitem"``).
+            Lookup is case-insensitive (e.g., ``"new_SampleItem"`` will also work).
+        :type logical_name: str
 
         :return: Dictionary containing table metadata with keys ``entity_schema``,
             ``entity_logical_name``, ``entity_set_name``, and ``metadata_id``.
@@ -388,28 +387,25 @@ def get_table_info(self, tablename: str) -> Optional[Dict[str, Any]]:
         Example:
             Retrieve table metadata::
 
-                info = client.get_table_info("SampleItem")
-                if info:
+                info = client.get_table_info("new_sampleitem")                if info:
                     print(f"Logical name: {info['entity_logical_name']}")
                     print(f"Entity set: {info['entity_set_name']}")
         """
-        return self._get_odata()._get_table_info(tablename)
+        return self._get_odata()._get_table_info(logical_name)
 
     def create_table(
         self,
-        tablename: str,
+        logical_name: str,
         schema: Dict[str, Any],
         solution_unique_name: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
         Create a simple custom table with specified columns.
 
-        :param tablename: Table friendly name (e.g. ``"SampleItem"``) or full schema name
-            (e.g. ``"new_SampleItem"``). If a publisher prefix is not included, the default
-            publisher prefix will be applied.
-        :type tablename: str
-        :param schema: Dictionary mapping column logical names (without prefix) to their types.
-            Supported types:
+        :param logical_name: Table logical name with publisher prefix (e.g. ``"new_orders"``).
+            Both table and column names must include the publisher prefix (default is ``"new_"``).
+        :type logical_name: str
+        :param schema: Dictionary mapping column logical names (with prefix) to their types.
 
             - Primitive types: ``"string"``, ``"int"``, ``"decimal"``, ``"float"``, ``"datetime"``, ``"bool"``
             - Enum subclass (IntEnum preferred): Creates a local option set. Optional multilingual
@@ -432,10 +428,11 @@ class ItemStatus(IntEnum):
             ``entity_set_name``, ``entity_logical_name``, ``metadata_id``, and ``columns_created``.
         :rtype: dict
 
-        :raises ~dataverse_sdk.errors.MetadataError: If table creation fails or the schema is invalid.
+        :raises ~dataverse_sdk.errors.HttpError: If server rejects the metadata (invalid names, missing prefix, etc.).
+        :raises ~dataverse_sdk.errors.MetadataError: If table creation fails.
 
         Example:
-            Create a table with simple columns::
+            Create a table with simple columns (using default publisher prefix ``new_``)::
 
                 from enum import IntEnum
 
@@ -444,30 +441,27 @@ class ItemStatus(IntEnum):
                     INACTIVE = 2
 
                 schema = {
-                    "title": "string",
-                    "quantity": "int",
-                    "price": "decimal",
-                    "available": "bool",
-                    "status": ItemStatus
+                    "new_title": "string",
+                    "new_quantity": "int",
+                    "new_price": "decimal",
+                    "new_available": "bool",
+                    "new_status": ItemStatus
                 }
-
-                result = client.create_table("SampleItem", schema)
+                result = client.create_table("new_sampleitem", schema)
                 print(f"Created table: {result['entity_logical_name']}")
                 print(f"Columns: {result['columns_created']}")
         """
         return self._get_odata()._create_table(
-            tablename,
+            logical_name,
             schema,
             solution_unique_name,
         )
 
-    def delete_table(self, tablename: str) -> None:
+    def delete_table(self, logical_name: str) -> None:
         """
-        Delete a custom table by name.
-
-        :param tablename: Table friendly name (e.g. ``"SampleItem"``) or full schema name
-            (e.g. ``"new_SampleItem"``).
-        :type tablename: str
+        Delete a custom table by logical name.
+        :param logical_name: Table logical name with publisher prefix (e.g. ``"new_sampleitem"``).
+        :type logical_name: str
 
         :raises ~dataverse_sdk.errors.MetadataError: If the table does not exist or deletion fails.
 
@@ -478,9 +472,9 @@ def delete_table(self, tablename: str) -> None:
         Example:
             Delete a custom table::
 
-                client.delete_table("SampleItem")
+                client.delete_table("new_sampleitem")
         """
-        self._get_odata()._delete_table(tablename)
+        self._get_odata()._delete_table(logical_name)
 
     def list_tables(self) -> list[str]:
         """
@@ -500,63 +494,59 @@ def list_tables(self) -> list[str]:
 
     def create_columns(
         self,
-        tablename: str,
+        logical_name: str,
         columns: Dict[str, Any],
     ) -> List[str]:
         """
         Create one or more columns on an existing table using a schema-style mapping.
 
-        :param tablename: Friendly name ("SampleItem") or full schema name ("new_SampleItem").
-        :type tablename: str
-        :param columns: Mapping of logical names (without prefix) to supported types. Primitive types include
+        :param logical_name: Table logical name with publisher prefix (e.g. ``"new_sampleitem"``).
+        :type logical_name: str
+        :param columns: Mapping of column names with publisher prefix to supported types. Primitive types include
             ``string``, ``int``, ``decimal``, ``float``, ``datetime``, and ``bool``. Enum subclasses (IntEnum preferred)
             generate a local option set and can specify localized labels via ``__labels__``.
         :type columns: Dict[str, Any]
-        :returns: Schema names for the columns that were created.
+        :returns: Logical names for the columns that were created.
         :rtype: list[str]
         Example:
             Create two columns on the custom table::
-
                 created = client.create_columns(
-                    "new_SampleItem",
+                    "new_sampleitem",
                     {
-                        "scratch": "string",
-                        "flags": "bool",
+                        "new_scratch": "string",
+                        "new_flags": "bool",
                     },
                 )
                 print(created)
         """
         return self._get_odata()._create_columns(
-            tablename,
+            logical_name,
             columns,
         )
 
     def delete_columns(
         self,
-        tablename: str,
+        logical_name: str,
         columns: Union[str, List[str]],
     ) -> List[str]:
         """
         Delete one or more columns from a table.
-
-        :param tablename: Friendly or schema name of the table.
-        :type tablename: str
-        :param columns: Column name or list of column names to remove. Friendly names are normalized to schema
-            names using the same prefix logic as ``create_columns``.
+        :param logical_name: Table logical name with publisher prefix (e.g. ``"new_sampleitem"``).
+        :type logical_name: str
+        :param columns: Column name or list of column names to remove with publisher prefix (e.g. ``"new_scratch"``).
         :type columns: str | list[str]
-        :returns: Schema names for the columns that were removed.
+        :returns: Logical names for the columns that were removed.
         :rtype: list[str]
         Example:
-            Remove two custom columns by schema name:
-
+            Remove two custom columns:
                 removed = client.delete_columns(
-                    "new_SampleItem",
-                    ["new_Scratch", "new_Flags"],
+                    "new_sampleitem",
+                    ["new_scratch", "new_flags"],
                 )
                 print(removed)
         """
         return self._get_odata()._delete_columns(
-            tablename,
+            logical_name,
             columns,
         )