models Paquet

Métadonnées de clé alternatives pour une table Dataverse.

Réponse d’une seule opération au sein d’une demande de traitement par lots.

Les réponses sont retournées dans l’ordre de soumission. Pour les opérations ajoutées à un ensemble de modifications, les réponses apparaissent dans la position du jeu de modifications dans cet ordre.

Exemple :

   for item in result.responses:
       if item.is_success:
           print(f"[OK] {item.status_code} entity_id={item.entity_id}")
       else:
           print(f"[ERR] {item.status_code}: {item.error_message}")

Résultat de l’exécution d’une demande de lot.

Contient une BatchItemResponse par opération HTTP envoyée. Les opérations qui s’étendent à plusieurs requêtes HTTP (par exemple, add_columns avec trois colonnes) contribuent à trois entrées.

Exemple :

   result = client.batch.new().execute()
   print(f"Succeeded: {len(result.succeeded)}, Failed: {len(result.failed)}")
   for guid in result.entity_ids:
       print(f"[OK] entity_id: {guid}")

Définit le comportement en cascade pour les opérations de relation.

Valeurs valides pour chaque paramètre :

• « Cascade » : effectuer l’opération sur tous les enregistrements associés

• « NoCascade » : n’effectuez pas l’opération sur les enregistrements associés

• « RemoveLink » : supprimez le lien de relation, mais conservez les enregistrements

• « Restreindre » : empêcher l’opération si des enregistrements associés existent

Métadonnées de colonne à partir d’une définition de table Dataverse.

Proxy Fluent pour la création d’expressions de filtre OData à partir d’un nom de colonne.

Retourné par col. Les surcharges d’opérateur et les méthodes produisent des FilterExpression instances qui peuvent être passées à QueryBuilder.where().

Exemple :

   from PowerPlatform.Dataverse.models.filters import col

   expr = col("statecode") == 0               # equality
   expr = col("revenue") > 1_000_000          # comparison
   expr = col("name").like("Contoso%")        # startswith
   expr = col("name").is_null()               # null check
   expr = col("statecode").in_([0, 1])        # in

Protocole structurel permettant aux instances d’entité typées d’être passées à records.create() et records.update().

Implémentez ce protocole sur n’importe quelle classe d’entité (dataclass, modèle Pydantic, roulé manuellement) pour lui permettre d’être transmis directement aux opérations CRUD sans spécifier le nom de la table ou convertir manuellement en dict.

Variables de classe requises :

• __entity_logical_name__ — Nom d’entité logique Dataverse (par exemple "account")

• __entity_set_name__ — Nom du jeu d’entités OData (par exemple "accounts")

Méthodes d’instance requises :

• to_dict() — retourner une charge utile d’enregistrement en tant que dict

• from_dict(data) — classmethod à reconstruire à partir d’une réponse dict

Exemple :

   from dataclasses import dataclass
   from PowerPlatform.Dataverse import DataverseModel

   @dataclass
   class Account:
       __entity_logical_name__ = "account"
       __entity_set_name__ = "accounts"
       name: str = ""
       telephone1: str = ""

       def to_dict(self) -> dict:
           return {"name": self.name, "telephone1": self.telephone1}

       @classmethod
       def from_dict(cls, data: dict) -> "Account":
           return cls(
               name=data.get("name", ""),
               telephone1=data.get("telephone1", ""),
           )

   # isinstance() works today — Protocol is runtime_checkable:
   assert isinstance(Account(), DataverseModel)

   # Type your own helpers against the Protocol now:
   def save(entity: DataverseModel) -> None:
       data = entity.to_dict()
       client.records.create(entity.__entity_logical_name__, data)

Options structurées pour une $expand propriété de navigation.

Permet de spécifier des options imbriquées$select, $filteret $top$orderbydes options pour une extension de propriété de navigation unique, en suivant la syntaxe OData$expand.

Exemple :

   # Expand Account_Tasks with nested options
   opt = (ExpandOption("Account_Tasks")
          .select("subject", "createdon")
          .filter("contains(subject,'Task')")
          .order_by("createdon", descending=True)
          .top(5))

   query = (client.query.builder("account")
            .select("name")
            .expand(opt)
            .execute())

Objet de requête FetchXML inert. Aucune requête HTTP n’est effectuée tant qu’elle execute n’est pas appelée.execute_pages

Obtenu via client.query.fetchxml(xml).

Classe de base pour les expressions de filtre OData composables.

Prend en charge les surcharges d’opérateur Python pour la composition logique :

• expr1 & expr2 Produit (expr1 and expr2)

• expr1 | expr2 Produit (expr1 or expr2)

• ~expr Produit not (expr)

Représente une étiquette qui peut avoir plusieurs versions localisées.

Représente une étiquette localisée avec un code de langue.

Métadonnées d’un attribut de recherche.

Valeurs required_level valides :

• « None » : l’attribut est facultatif

• « Recommandé » : l’attribut est recommandé

• « ApplicationRequired » : l’attribut est requis

Métadonnées pour une relation d’entité plusieurs-à-plusieurs.

Métadonnées pour une relation d’entité un-à-plusieurs.

Interface Fluent pour la création et l’exécution de requêtes OData sur un client de synchronisation.

Fournit un chaînage de méthodes pour construire des requêtes complexes avec des expressions de filtre composables. Peut être utilisé autonome (via build()) ou lié à un client (via execute).

Dictionnaire typé retourné par QueryBuilder.build().

Fournit la saisie semi-automatique de l’IDE lors de la transmission manuelle des résultats de client.records.list() build.

Wrapper itérable autour d’une liste d’objets Record .

Retourné par execute (mode plat) et list.

Rétrocompatible : for r in result continue de fonctionner sans modification.

Modèle de retour typé pour les métadonnées de relation.

Retourné par create_one_to_many_relationship, create_many_to_many_relationship, get_relationshipet create_lookup_field.

Exemple :

   result = client.tables.create_one_to_many_relationship(lookup, relationship)
   print(result.relationship_schema_name)
   print(result.lookup_schema_name)

Métadonnées de table avec compatibilité descendante de type dicté.

Prend en charge l’accès aux nouveaux attributs () et l’accès à la clé de dictée héritéinfo.schema_name (info["table_schema_name"]) pour la compatibilité descendante avec le code écrit sur l’API de dictée brute.

Exemple :

   info = client.tables.create("new_Product", {"new_Price": "decimal"})
   print(info.schema_name)              # new attribute access
   print(info["table_schema_name"])     # legacy dict-key access

Représente une opération upsert unique ciblant un enregistrement par sa clé alternative.

Utilisé pour upsert upserter un ou plusieurs enregistrements identifiés par d’autres clés plutôt que par des GUID principaux.

Exemple :

   item = UpsertItem(
       alternate_key={"accountnumber": "ACC-001", "address1_postalcode": "98052"},
       record={"name": "Contoso Ltd", "telephone1": "555-0100"},
   )