models Pacote

Metadados chave alternativos para uma tabela Dataverse.

Resposta de uma única operação dentro de um pedido por lote.

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

Example:

   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 um pedido em lote.

Contém uma BatchItemResponse por cada operação HTTP submetida. Operações que se expandem para múltiplos pedidos HTTP (por exemplo, add_columns com três colunas) contribuem com três entradas.

Example:

   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 comportamento em cascata para operações de relação.

Valores válidos para cada parâmetro:

• "Cascata": Realizar a operação em todos os registos relacionados

• "NoCascade": Não realizar a operação em registos relacionados

• "RemoveLink": Remover o link da relação mas manter os registos

• "Restrição": Impedir a operação se existirem registos relacionados

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

Proxy fluente para construir expressões de filtro OData a partir de um nome de coluna.

Retornado por col. Sobrecargas de operadores e métodos produzem FilterExpression instâncias que podem ser passadas para QueryBuilder.where().

Example:

   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 que permite a passagem de instâncias de entidades tipadas para records.create() e records.update().

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

Variáveis de classe obrigatórias:

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

• __entity_set_name__ — Nome do conjunto da entidade OData (por exemplo, "accounts")

Métodos de instância obrigatórios:

• to_dict() — devolver carga útil de registo como dict

• from_dict(data) — método de classe para reconstruir a partir de uma resposta dict

Example:

   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 aninhados , , , e $top opções para uma única expansão de propriedade de navegação, seguindo a sintaxe OData$expand. $orderby$filter$select

Example:

   # 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 inerte. Não é feito nenhum pedido HTTP até execute ou execute_pages é chamado.

Obtido via client.query.fetchxml(xml).

Classe base para expressões de filtro OData componíveis.

Suporta sobrecargas de operadores em Python para composição lógica:

• expr1 & expr2 produz (expr1 and expr2)

• expr1 | expr2 produz (expr1 or expr2)

• ~expr produz not (expr)

Representa uma etiqueta que pode ter múltiplas versões localizadas.

Representa uma etiqueta localizada com um código de língua.

Metadados para um atributo de consulta.

Valores de required_level válidos:

• "Nenhum": O atributo é opcional

• "Recomendado": O atributo é recomendado

• "ApplicationRequired": O atributo é obrigatório

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

Metadados para uma relação de entidade um-para-muitas.

Interface fluente para construir e executar consultas OData contra um cliente de sincronização.

Fornece cadeia de métodos para construir consultas complexas com expressões de filtro componíveis. Pode ser usado de forma autónoma (via build()) ou vinculado a um cliente (via execute).

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

Fornece autocompletar o IDE ao passar manualmente os resultados client.records.list() da compilação.

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

Devolvido por execute (modo plano) e list.

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

Modelo de retorno tipado para metadados de relações.

Retornado por create_one_to_many_relationship, create_many_to_many_relationship, get_relationship, e create_lookup_field.

Example:

   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 retroativa semelhante a um dict.

Suporta tanto o acesso a novos atributos (info.schema_name) como o acesso legado à chave dict (info["table_schema_name"]) para compatibilidade retroativa com código escrito contra a API bruta do dict.

Example:

   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 registo pela sua chave alternativa.

Usado com upsert para upserar um ou mais registos identificados por chaves alternativas em vez de GUIDs principais.

Example:

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