models Pacchetto

Metadati di chiave alternativi per una tabella Dataverse.

Risposta da una singola operazione all'interno di una richiesta batch.

Le risposte vengono restituite nell'ordine di invio. Per le operazioni aggiunte a un insieme di modifiche, le risposte vengono visualizzate nella posizione del set di modifiche in tale ordine.

Esempio:

   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}")

Risultato dell'esecuzione di una richiesta batch.

Contiene uno BatchItemResponse per ogni operazione HTTP inviata. Le operazioni che si espandono a più richieste HTTP (ad esempio add_columns con tre colonne) contribuiscono a tre voci.

Esempio:

   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}")

Definisce il comportamento a catena per le operazioni di relazione.

Valori validi per ogni parametro:

• "Catena": eseguire l'operazione su tutti i record correlati

• "NoCascade": non eseguire l'operazione sui record correlati

• "RemoveLink": rimuovere il collegamento alla relazione ma mantenere i record

• "Restrict": Impedisci l'operazione se esistono record correlati

Metadati di colonna da una definizione di tabella Dataverse.

Proxy Fluent per la compilazione di espressioni di filtro OData da un nome di colonna.

Restituito da col. Gli overload degli operatori e i metodi producono FilterExpression istanze che possono essere passate a QueryBuilder.where().

Esempio:

   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

Protocollo strutturale che consente di passare istanze di entità tipate a records.create() e records.update().

Implementare questo protocollo in qualsiasi classe di entità (dataclass, modello Pydantic, rollback manuale) per consentirne il passaggio direttamente alle operazioni CRUD senza specificare il nome della tabella o la conversione in dict manualmente.

Variabili di classe obbligatorie:

• __entity_logical_name__ — Nome dell'entità logica dataverse (ad esempio "account")

• __entity_set_name__ — Nome del set di entità OData (ad esempio "accounts")

Metodi di istanza obbligatori:

• to_dict() — restituire il payload del record come dict

• from_dict(data) — classmethod da ricostruire da una risposta dict

Esempio:

   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)

Opzioni strutturate per una $expand proprietà di navigazione.

Consente di specificare le opzioni annidate $select, $filter, $orderbye $top per un'espansione di una singola proprietà di navigazione, seguendo la sintassi OData $expand .

Esempio:

   # 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())

Oggetto query FetchXML inert. Non viene effettuata alcuna richiesta HTTP fino a execute quando non viene chiamato o execute_pages .

Ottenuto tramite client.query.fetchxml(xml).

Classe base per espressioni di filtro OData componibili.

Supporta gli overload degli operatori Python per la composizione logica:

• expr1 & expr2 Produce (expr1 and expr2)

• expr1 | expr2 Produce (expr1 or expr2)

• ~expr Produce not (expr)

Rappresenta un'etichetta che può avere più versioni localizzate.

Rappresenta un'etichetta localizzata con un codice di linguaggio.

Metadati per un attributo di ricerca.

Valori di required_level validi:

• "Nessuno": l'attributo è facoltativo

• "Consigliato": l'attributo è consigliato

• "ApplicationRequired": l'attributo è obbligatorio

Metadati per una relazione di entità molti-a-molti.

Metadati per una relazione di entità uno-a-molti.

Interfaccia Fluent per la compilazione e l'esecuzione di query OData su un client di sincronizzazione.

Fornisce il concatenamento dei metodi per costruire query complesse con espressioni di filtro componibili. Può essere usato autonomo (tramite build()) o associato a un client (tramite execute).

Dizionario tipizzato restituito da QueryBuilder.build().

Fornisce il completamento automatico dell'IDE quando si passano i risultati della compilazione a client.records.list() manualmente.

Wrapper iterabile intorno a un elenco di Record oggetti.

Restituito da execute (modalità flat) e list.

Compatibile con le versioni precedenti: for r in result continua a funzionare senza modifiche.

Modello restituito tipizzato per i metadati della relazione.

Restituito da create_one_to_many_relationship, create_many_to_many_relationshipget_relationship, e create_lookup_field.

Esempio:

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

Metadati di tabella con compatibilità con le versioni precedenti dict.Table metadata with dict-like backward compatibility.

Supporta sia l'accesso ai nuovi attributi (info.schema_name) che l'accesso con chiave dict legacy (info["table_schema_name"]) per garantire la compatibilità con le versioni precedenti con il codice scritto nell'API dict non elaborata.

Esempio:

   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

Rappresenta una singola operazione upsert destinata a un record in base alla chiave alternativa.

Usato con upsert per eseguire l'upsert di uno o più record identificati da chiavi alternative anziché da GUID primari.

Esempio:

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