Refactor _ODataClient to improve $select parameter handling and enhance TableInfo model with deprecated property aliases and additional relationship attributes

Author: maksii

src/PowerPlatform/Dataverse/data/_odata.py

@@ -1535,9 +1535,14 @@ def _get_table_metadata(
         params: Dict[str, str] = {}
         if select is not None and isinstance(select, str):
             raise TypeError("select must be a list of property names, not a bare string")
-        base_fields = {"MetadataId", "LogicalName", "SchemaName", "EntitySetName"}
+        base_fields = ["EntitySetName", "LogicalName", "MetadataId", "SchemaName"]
         if select:
-            merged = list(base_fields | set(select))
+            seen = set(base_fields)
+            merged = list(base_fields)
+            for f in select:
+                if f not in seen:
+                    merged.append(f)
+                    seen.add(f)
         else:
             merged = list(base_fields)
         params["$select"] = ",".join(merged)

src/PowerPlatform/Dataverse/models/table_info.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import warnings
 from dataclasses import dataclass, field
 from typing import Any, ClassVar, Dict, Iterator, KeysView, List, Optional
 
@@ -63,6 +64,38 @@ class ColumnInfo:
     max_length: Optional[int] = None
     metadata_id: Optional[str] = None
 
+    # ---------------------------------------------- deprecated property aliases
+
+    @property
+    def type(self) -> str:
+        """Column type name (deprecated, use ``attribute_type_name`` or ``attribute_type``)."""
+        warnings.warn(
+            "ColumnInfo.type is deprecated. Use attribute_type_name or attribute_type instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.attribute_type_name or self.attribute_type
+
+    @property
+    def is_primary(self) -> bool:
+        """Whether this is the primary name column (deprecated, use ``is_primary_name``)."""
+        warnings.warn(
+            "ColumnInfo.is_primary is deprecated. Use is_primary_name instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.is_primary_name
+
+    @property
+    def is_required(self) -> bool:
+        """Whether the column is required (deprecated, use ``required_level``)."""
+        warnings.warn(
+            "ColumnInfo.is_required is deprecated. Use required_level instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.required_level not in (None, "", "None")
+
     @classmethod
     def from_api_response(cls, data: Dict[str, Any]) -> ColumnInfo:
         """Create from a raw Dataverse ``AttributeMetadata`` API response.
@@ -154,6 +187,10 @@ class TableInfo:
     description: Optional[str] = None
     columns: Optional[List[ColumnInfo]] = field(default=None, repr=False)
     columns_created: Optional[List[str]] = field(default=None, repr=False)
+    one_to_many_relationships: Optional[List[Dict[str, Any]]] = field(default=None, repr=False)
+    many_to_one_relationships: Optional[List[Dict[str, Any]]] = field(default=None, repr=False)
+    many_to_many_relationships: Optional[List[Dict[str, Any]]] = field(default=None, repr=False)
+    _extra: Dict[str, Any] = field(default_factory=dict, repr=False, compare=False)
 
     # Maps legacy dict keys (used by existing code) to attribute names.
     _LEGACY_KEY_MAP: ClassVar[Dict[str, str]] = {
@@ -171,16 +208,24 @@ def _resolve_key(self, key: str) -> str:
         return self._LEGACY_KEY_MAP.get(key, key)
 
     def __getitem__(self, key: str) -> Any:
+        if key in self._extra:
+            return self._extra[key]
         attr = self._resolve_key(key)
         if hasattr(self, attr):
-            return getattr(self, attr)
+            val = getattr(self, attr)
+            if val is not None or key in self._LEGACY_KEY_MAP:
+                return val
         raise KeyError(key)
 
     def __contains__(self, key: object) -> bool:
         if not isinstance(key, str):
             return False
+        if key in self._extra:
+            return True
         attr = self._resolve_key(key)
-        return hasattr(self, attr)
+        if not hasattr(self, attr):
+            return False
+        return getattr(self, attr) is not None
 
     def __iter__(self) -> Iterator[str]:
         return iter(self._LEGACY_KEY_MAP)
@@ -246,13 +291,22 @@ def from_api_response(cls, response_data: Dict[str, Any]) -> TableInfo:
         desc_label = desc_obj.get("UserLocalizedLabel") or {}
         description = desc_label.get("Label")
 
+        # Parse columns if Attributes are present
+        columns = None
+        if "Attributes" in response_data:
+            columns = [ColumnInfo.from_api_response(a) for a in response_data["Attributes"]]
+
         return cls(
             schema_name=response_data.get("SchemaName", ""),
             logical_name=response_data.get("LogicalName", ""),
             entity_set_name=response_data.get("EntitySetName", ""),
             metadata_id=response_data.get("MetadataId", ""),
             display_name=display_name,
             description=description,
+            columns=columns,
+            one_to_many_relationships=response_data.get("OneToManyRelationships"),
+            many_to_one_relationships=response_data.get("ManyToOneRelationships"),
+            many_to_many_relationships=response_data.get("ManyToManyRelationships"),
         )
 
     # -------------------------------------------------------------- conversion

src/PowerPlatform/Dataverse/operations/tables.py

@@ -187,10 +187,20 @@ def get(
             ``many_to_many_relationships``.
         :type include_relationships: :class:`bool`
 
-        :return: Dictionary containing ``table_schema_name``,
-            ``table_logical_name``, ``entity_set_name``, and ``metadata_id``.
-            Returns None if the table is not found.
-        :rtype: :class:`dict` or None
+        :return: A :class:`~PowerPlatform.Dataverse.models.table_info.TableInfo`
+            instance containing table metadata, or ``None`` if the table is
+            not found. Supports dict-like key access for backward
+            compatibility.
+            When ``include_columns`` is ``True``, the ``columns`` attribute
+            contains a list of
+            :class:`~PowerPlatform.Dataverse.models.table_info.ColumnInfo`
+            instances.  When ``include_relationships`` is ``True``, the
+            ``one_to_many_relationships``, ``many_to_one_relationships``, and
+            ``many_to_many_relationships`` attributes are populated.
+            Extra properties requested via ``select`` are accessible via
+            dict-like key access (e.g., ``info["DisplayName"]``).
+        :rtype: :class:`~PowerPlatform.Dataverse.models.table_info.TableInfo`
+            or None
 
         Example::
 
@@ -201,11 +211,13 @@ def get(
 
             # Extended with columns
             info = client.tables.get("account", include_columns=True)
-            for col in info.get("columns", []):
+            for col in info.columns:
                 print(f"{col.logical_name} ({col.attribute_type})")
 
             # Extended with relationships
             info = client.tables.get("account", include_relationships=True)
+            for rel in info.one_to_many_relationships:
+                print(rel["SchemaName"])
         """
         # Normalize empty list to None so callers passing select=[] get the
         # lightweight path instead of an expensive full-entity-definition fetch.
@@ -232,35 +244,15 @@ def get(
         if raw is None:
             return None
 
-        # Build result dict starting with the standard 4 fields
-        result: Dict[str, Any] = {
-            "table_schema_name": raw.get("SchemaName", table),
-            "table_logical_name": raw.get("LogicalName"),
-            "entity_set_name": raw.get("EntitySetName"),
-            "metadata_id": raw.get("MetadataId"),
-        }
+        info = TableInfo.from_api_response(raw)
 
-        # Include any extra selected entity properties
+        # Store any extra selected entity properties
         if select:
             for prop in select:
                 if prop not in ("SchemaName", "LogicalName", "EntitySetName", "MetadataId"):
-                    result[prop] = raw.get(prop)
-
-        # Convert expanded Attributes into ColumnInfo instances
-        if include_columns and "Attributes" in raw:
-            result["columns"] = [ColumnInfo.from_api_response(a) for a in raw["Attributes"]]
-
-        # Include expanded relationship collections as raw dicts
-        if include_relationships:
-            for raw_key, result_key in (
-                ("OneToManyRelationships", "one_to_many_relationships"),
-                ("ManyToOneRelationships", "many_to_one_relationships"),
-                ("ManyToManyRelationships", "many_to_many_relationships"),
-            ):
-                if raw_key in raw:
-                    result[result_key] = raw[raw_key]
+                    info._extra[prop] = raw.get(prop)
 
-        return result
+        return info
 
     # -------------------------------------------------------------- get_columns
 
@@ -382,7 +374,8 @@ def get_column_options(
 
         :return: Option set information with available choices, or ``None`` if
             the column is not a Picklist, MultiSelect, Boolean, Status, or
-            State type.
+            State type. Also returns ``None`` if the table or column does not
+            exist (404).
         :rtype: :class:`~PowerPlatform.Dataverse.models.table_info.OptionSetInfo`
             or None