models Pacote

Metadados de chave alternativos para uma tabela do Dataverse.

Resposta de uma única operação dentro de uma solicitação em lote.

As respostas são retornadas na ordem de envio. Para operações adicionadas a um conjunto de alterações, as respostas aparecem na posição do conjunto de alterações nessa ordem.

Exemplo:

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

Resultado da execução de uma solicitação em lote.

Contém uma BatchItemResponse por operação HTTP enviada. As operações que se expandem para várias solicitações HTTP (por exemplo, add_columns com três colunas) contribuem com três entradas.

Exemplo:

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

Define o comportamento em cascata para operações de relação.

Valores válidos para cada parâmetro:

• "Cascade": executar a operação em todos os registros relacionados

• "NoCascade": não execute a operação em registros relacionados

• "RemoveLink": remover o link de relação, mas manter os registros

• "Restrict": impedir a operação se houver registros relacionados

Metadados de coluna de uma definição de tabela do Dataverse.

Proxy fluente para a criação de expressões de filtro OData de um nome de coluna.

Retornado por col. As sobrecargas e os métodos do operador produzem FilterExpression instâncias que podem ser passadas para QueryBuilder.where().

Exemplo:

   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

Protocolo Estrutural permitindo que instâncias de entidade tipadas sejam passadas para records.create() e records.update().

Implemente este Protocolo em qualquer classe de entidade (dataclass, modelo Pydantic, laminado manualmente) para permitir que ele seja passado diretamente para operações CRUD sem especificar o nome da tabela ou converter em ditado manualmente.

Variáveis de classe necessárias:

• __entity_logical_name__ — Nome da entidade lógica do dataverse (por exemplo "account")

• __entity_set_name__ — Nome do conjunto de entidades OData (por exemplo "accounts")

Métodos de instância necessários:

• to_dict() — retornar o conteúdo do registro como dict

• from_dict(data) — classmethod para reconstruir a partir de uma resposta dict

Exemplo:

   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)

Opções estruturadas para uma $expand propriedade de navegação.

Permite especificar , e $orderby$filteropções aninhadas$select, e $top opções para uma única expansão de propriedade de navegação, seguindo a sintaxe OData$expand.

Exemplo:

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

Objeto de consulta FetchXML inert. Nenhuma solicitação HTTP é feita até execute ou execute_pages é chamada.

Obtido por .client.query.fetchxml(xml)

Classe base para expressões de filtro OData composable.

Dá suporte a sobrecargas de operador Python para composição lógica:

• expr1 & expr2 Produz (expr1 and expr2)

• expr1 | expr2 Produz (expr1 or expr2)

• ~expr Produz not (expr)

Representa um rótulo que pode ter várias versões localizadas.

Representa um rótulo localizado com um código de idioma.

Metadados para um atributo de pesquisa.

Valores de required_level válidos:

• "Nenhum": o atributo é opcional

• "Recomendado": o atributo é recomendado

• "ApplicationRequired": o atributo é necessário

Metadados para uma relação de entidade muitos para muitos.

Metadados para uma relação de entidade um para muitos.

Interface fluente para compilar e executar consultas OData em um cliente de sincronização.

Fornece encadeamento de métodos para construir consultas complexas com expressões de filtro composáveis. Pode ser usado autônomo (via build()) ou associado a um cliente (via execute).

Dicionário digitado retornado por QueryBuilder.build().

Fornece o preenchimento automático do IDE ao passar os resultados do client.records.list() build manualmente.

Wrapper iterável em torno de uma lista de Record objetos.

Retornado por execute (modo simples) e list.

Compatível com versões anteriores: for r in result continua funcionando sem alterações.

Modelo de retorno digitado para metadados de relação.

Retornado por create_one_to_many_relationship, create_many_to_many_relationship, get_relationshipe create_lookup_field.

Exemplo:

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

Metadados de tabela com compatibilidade com versões anteriores semelhantes a ditados.

Dá suporte ao novo acesso de atributo (info.schema_name) e ao acesso de chave de ditado herdado (info["table_schema_name"]) para compatibilidade com o código gravado na API de ditado bruto.

Exemplo:

   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

Representa uma única operação upsert direcionada a um registro por sua chave alternativa.

Usado para upsert upsert um ou mais registros identificados por chaves alternativas em vez de GUIDs primários.

Exemplo:

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