yspec

YSpec

O YSPEC é um verificador simples e mortal para estruturas. É especialmente útil para a validação de diferentes arquivos YAML/JSON

Uso da CLI

yspec ./schema.yaml /tmp/data.json

NOTA: YSPEC capaz de levar Yaml/JSON para esquema e dados

Uso do código

 from yspec . checker import check

# Some code that prepares data and rules

check ( data , rules )

Formato de esquema

Esquema é um ditado de regras. Toda regra faz algumas verificações de acordo com o campo 'Match'. O esquema deve incluir a regra 'raiz', que é aplicada no objeto superior na estrutura.

Por exemplo, estrutura (em YAML):

---
- ' string1 '
- ' string2 '

será válido para o esquema (em YAML):

---
root :
  match : list
  item : string
  
string :
  match : string 

Regras de correspondência

Tipo simples corresponde

Corda

 my_awesome_string :
  match : string 

Booleano

 my_awesome_bool :
  match : bool 

Inteiro

 my_awesome_int :
  match : int 

Flutuador

 my_awesome_float :
  match : float 

Nenhum

 empty_object :
  match : none 

Qualquer

 any_type :
  match : any

Matches do tipo de recursão

Existem dois deles: Dict and List. Ambos têm a mesma lógica de recursão. No começo, aplicamos algumas verificações no próprio objeto e, em seguida, aplicamos outra (ou a mesma) regra aos filhos (elementos da lista ou valores do dicto).

Lista

 my_list :
  match : list
  item : some_other_rule

A lista é do tipo recurnte. FIST It Checks é o objeto A Lista e, em seguida, ele verifique todos os elementos de acordo com a regra em 'Item' Att.

Dito

 my_list :
  match : dict
  items :
    key1 : string_rule
    key2 : integer_rule
  default_item : some_other_rule
  required_items :
    - key2

Essa é uma regra que descreve um ditado que possui duas teclas (KEY1 e KEY2). Uma das chaves (KEY2) é obrigatória. Key1 deve ser verificado de acordo com a regra 'String_rule', enquanto quaisquer outras teclas com qualquer outro nome (não -key1 ou key2) serão verificadas de acordo com algum_other_rule.

Se removermos o default_item

 my_list :
  match : dict
  items :
    key1 : string_rule
    key2 : integer_rule
  required_items :
    - key2

Um dicto pode ser com duas teclas (KEY1, KEY2) máximo

Amostra de correspondências simples e de recursão

Esquema:

---
boolean :
  match : bool

string :
  match : string

integer :
  match : int

float :
  match : float

list :
  match : list
  item : string

root :
  match : dict
  items :
    key1 : boolean
    key2 : string
    key3 : integer
    key4 : float
    key5 : list

Dados:

---
key1 : true
key2 : " That is a string "
key3 : 1
key4 : 1.0
key5 :
  - " One more string "
  - " Another string "

Partidas especiais

OFEOF

 constraint_list_item :
  match : one_of
  variants :
    - integer_rule
    - some_other_rule

OFE de combinar o sucesso se alguma das regras do sucesso "variantes".

Defina a partida

Suponha que você precise verificar sua pequena lista de frutas:

---
- apple
- plum

Você pode usar o conjunto de correspondência para ele. Na cláusula de variantes do conjunto, você liste todos os valores possíveis para este tipo:

---
root :
  match : list
  item : fruits

fruits :
  match : set
  variants :
    - apple
    - orange
    - plum 

Seleção de chaves do ditado

Algumas vezes, você precisa fazer verificações separadas para o DICT que possuem algum par de chaves/valores.

Por exemplo, você tem os seguintes dados:

---
- type : type1
  payload :
    - 1
    - 1
- type : type2
  payload :
    - " that is a string "
    - " that is a string2 "

Nesse exemplo, você tem um ditado que possui uma carga útil diferente depende da tecla Type. Isso é possível descrever com o seguinte esquema:

---
root :
  match : list
  item : list_item

list_item :
  match : dict_key_selection
  selector : type
  variants :
    type1 : dict_with_int
    type2 : dict_with_string

dict_with_int :
  match : dict
  items :
    type : string
    payload : list_of_int
  required_items :
    - type
    - payload

dict_with_string :
  match : dict
  items :
    type : string
    payload : list_of_string
  required_items :
    - type
    - payload
  

list_of_int :
  match : list
  item : int
  
int :
  match : int
  
list_of_string :
  match : list
  item : string
  
string :
  match : string