Move relationship methods to client.tables namespace

- Add create_one_to_many, create_many_to_many, delete_relationship,
  get_relationship, and create_lookup_field to TableOperations
- Remove flat relationship methods from DataverseClient (not yet published)
- Update relationships example and README to use client.tables.*
- Update tests to use namespaced API

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: tpellissier

README.md

@@ -112,7 +112,7 @@ The SDK provides a simple, pythonic interface for Dataverse operations:
 | Concept | Description |
 |---------|-------------|
 | **DataverseClient** | Main entry point; provides `records`, `query`, and `tables` namespaces |
-| **Namespaces** | Operations are organized into `client.records` (CRUD), `client.query` (queries), and `client.tables` (metadata) |
+| **Namespaces** | Operations are organized into `client.records` (CRUD), `client.query` (queries), and `client.tables` (metadata & relationships) |
 | **Records** | Dataverse records represented as Python dictionaries with column schema names |
 | **Schema names** | Use table schema names (`"account"`, `"new_MyTestTable"`) and column schema names (`"name"`, `"new_MyTestColumn"`). See: [Table definitions in Microsoft Dataverse](https://learn.microsoft.com/en-us/power-apps/developer/data-platform/entity-metadata) |
 | **Bulk Operations** | Efficient bulk processing for multiple records with automatic optimization |
@@ -287,7 +287,7 @@ relationship = OneToManyRelationshipMetadata(
     referenced_attribute="new_departmentid",
 )
 
-result = client.create_one_to_many_relationship(lookup, relationship)
+result = client.tables.create_one_to_many_relationship(lookup, relationship)
 print(f"Created lookup field: {result['lookup_schema_name']}")
 
 # Create a many-to-many relationship: Employee (N) <-> Project (N)
@@ -298,23 +298,23 @@ m2m_relationship = ManyToManyRelationshipMetadata(
     entity2_logical_name="new_project",
 )
 
-result = client.create_many_to_many_relationship(m2m_relationship)
+result = client.tables.create_many_to_many_relationship(m2m_relationship)
 print(f"Created M:N relationship: {result['relationship_schema_name']}")
 
 # Query relationship metadata
-rel = client.get_relationship("new_Department_Employee")
+rel = client.tables.get_relationship("new_Department_Employee")
 if rel:
     print(f"Found: {rel['SchemaName']}")
 
 # Delete a relationship
-client.delete_relationship(result['relationship_id'])
+client.tables.delete_relationship(result['relationship_id'])
 ```
 
 For simpler scenarios, use the convenience method:
 
 ```python
 # Quick way to create a lookup field with sensible defaults
-result = client.create_lookup_field(
+result = client.tables.create_lookup_field(
     referencing_table="contact",       # Child table gets the lookup field
     lookup_field_name="new_AccountId",
     referenced_table="account",        # Parent table being referenced

examples/advanced/relationships.py

@@ -41,11 +41,11 @@ def log_call(description):
 
 def delete_relationship_if_exists(client, schema_name):
     """Delete a relationship by schema name if it exists."""
-    rel = client.get_relationship(schema_name)
+    rel = client.tables.get_relationship(schema_name)
     if rel:
         rel_id = rel.get("MetadataId")
         if rel_id:
-            client.delete_relationship(rel_id)
+            client.tables.delete_relationship(rel_id)
             print(f"   (Cleaned up existing relationship: {schema_name})")
             return True
     return False
@@ -75,8 +75,8 @@ def cleanup_previous_run(client):
     # Delete tables
     for table_name in tables:
         try:
-            if client.get_table_info(table_name):
-                client.delete_table(table_name)
+            if client.tables.get(table_name):
+                client.tables.delete(table_name)
                 print(f"   (Cleaned up existing table: {table_name})")
         except Exception as e:
             print(f"   [WARN] Could not delete table {table_name}: {e}")
@@ -159,7 +159,7 @@ def main():
     log_call("Creating 'new_Department' table")
 
     dept_table = backoff(
-        lambda: client.create_table(
+        lambda: client.tables.create(
             "new_Department",
             {
                 "new_DepartmentCode": "string",
@@ -173,7 +173,7 @@ def main():
     log_call("Creating 'new_Employee' table")
 
     emp_table = backoff(
-        lambda: client.create_table(
+        lambda: client.tables.create(
             "new_Employee",
             {
                 "new_EmployeeNumber": "string",
@@ -187,7 +187,7 @@ def main():
     log_call("Creating 'new_Project' table")
 
     proj_table = backoff(
-        lambda: client.create_table(
+        lambda: client.tables.create(
             "new_Project",
             {
                 "new_ProjectCode": "string",
@@ -228,7 +228,7 @@ def main():
 
     # Create the relationship
     result = backoff(
-        lambda: client.create_one_to_many_relationship(
+        lambda: client.tables.create_one_to_many_relationship(
             lookup=lookup,
             relationship=relationship,
         )
@@ -252,7 +252,7 @@ def main():
     # Use the convenience method for simpler scenarios
     # An Employee has a Manager (who is a Contact in the system)
     result2 = backoff(
-        lambda: client.create_lookup_field(
+        lambda: client.tables.create_lookup_field(
             referencing_table=emp_table["table_logical_name"],
             lookup_field_name="new_ManagerId",
             referenced_table="contact",
@@ -285,7 +285,7 @@ def main():
     )
 
     result3 = backoff(
-        lambda: client.create_many_to_many_relationship(
+        lambda: client.tables.create_many_to_many_relationship(
             relationship=m2m_relationship,
         )
     )
@@ -304,7 +304,7 @@ def main():
 
     log_call("Retrieving 1:N relationship by schema name")
 
-    rel_metadata = client.get_relationship("new_Department_Employee")
+    rel_metadata = client.tables.get_relationship("new_Department_Employee")
     if rel_metadata:
         print(f"[OK] Found relationship: {rel_metadata.get('SchemaName')}")
         print(f"  Type: {rel_metadata.get('@odata.type')}")
@@ -315,7 +315,7 @@ def main():
 
     log_call("Retrieving M:N relationship by schema name")
 
-    m2m_metadata = client.get_relationship("new_employee_project")
+    m2m_metadata = client.tables.get_relationship("new_employee_project")
     if m2m_metadata:
         print(f"[OK] Found relationship: {m2m_metadata.get('SchemaName')}")
         print(f"  Type: {m2m_metadata.get('@odata.type')}")
@@ -338,21 +338,21 @@ def main():
         log_call("Deleting relationships")
         try:
             if rel_id_1:
-                backoff(lambda: client.delete_relationship(rel_id_1))
+                backoff(lambda: client.tables.delete_relationship(rel_id_1))
                 print(f"  [OK] Deleted relationship: new_Department_Employee")
         except Exception as e:
             print(f"  [WARN] Error deleting relationship 1: {e}")
 
         try:
             if rel_id_2:
-                backoff(lambda: client.delete_relationship(rel_id_2))
+                backoff(lambda: client.tables.delete_relationship(rel_id_2))
                 print(f"  [OK] Deleted relationship: contact->employee (Manager)")
         except Exception as e:
             print(f"  [WARN] Error deleting relationship 2: {e}")
 
         try:
             if rel_id_3:
-                backoff(lambda: client.delete_relationship(rel_id_3))
+                backoff(lambda: client.tables.delete_relationship(rel_id_3))
                 print(f"  [OK] Deleted relationship: new_employee_project")
         except Exception as e:
             print(f"  [WARN] Error deleting relationship 3: {e}")
@@ -361,7 +361,7 @@ def main():
         log_call("Deleting tables")
         for table_name in ["new_Employee", "new_Department", "new_Project"]:
             try:
-                backoff(lambda name=table_name: client.delete_table(name))
+                backoff(lambda name=table_name: client.tables.delete(name))
                 print(f"  [OK] Deleted table: {table_name}")
             except Exception as e:
                 print(f"  [WARN] Error deleting {table_name}: {e}")