yspec

yspec

YSpec est un vérificateur simple mortel pour les structures. Il est particulièrement utile pour la validation de différents fichiers YAML / JSON

Utilisation de la CLI

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

Remarque: YSpec capable de prendre YAML / JSON pour le schéma et les données

Utilisation du code

 from yspec . checker import check

# Some code that prepares data and rules

check ( data , rules )

Format de schéma

Le schéma est un dict des règles. Chaque règle fait un contrôle selon le champ «Match». Le schéma doit inclure la règle «racine» qui est appliquée sur l'objet supérieur dans la structure.

Par exemple la structure (en yaml):

---
- ' string1 '
- ' string2 '

sera valable pour le schéma (en yaml):

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

Règles de correspondance

Matchs de type simples

Chaîne

 my_awesome_string :
  match : string 

Booléen

 my_awesome_bool :
  match : bool 

Entier

 my_awesome_int :
  match : int 

Flotter

 my_awesome_float :
  match : float 

Aucun

 empty_object :
  match : none 

N'importe lequel

 any_type :
  match : any

Matches de type récursiteur

Il y en a deux: dict et liste. Les deux ont la même logique de récursivité. Au début, nous appliquons quelques vérifications sur l'objet lui-même, puis appliquons une autre règle (ou la même) à des enfants (répertorier des éléments ou des valeurs de dict).

Liste

 my_list :
  match : list
  item : some_other_rule

La liste est un type de réapprovisionnement. Fist qu'il vérifie est l'objet une liste, puis il vérifie chaque élément en fonction de la règle dans «item» att.

Diction

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

C'est une règle qui décrit un dict qui a deux clés (Key1 et Key2). L'une des clés (Key2) est obligatoire. Key1 doit être vérifié selon la règle 'string_rule', tandis que toute autre touche avec tout autre nom (non key1 ou key2) sera vérifiée selon certains_other_rule.

Si nous avons supprimé default_item

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

Un dict pourrait être avec deux clés (Key1, Key2)

Échantillon de correspondances simples et de récursivité

Schéma:

---
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

Données:

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

Matchs spéciaux

Match

 constraint_list_item :
  match : one_of
  variants :
    - integer_rule
    - some_other_rule

Un de même le succès si l'une des règles du succès des "variantes".

S'établir

Supposons que vous deviez vérifier votre petite liste de fruits:

---
- apple
- plum

Vous pouvez utiliser Set Match pour cela. Dans la clause de variantes de SET correspond à toutes les valeurs possibles pour ce type:

---
root :
  match : list
  item : fruits

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

Sélection des clés

Parfois, vous devez effectuer des vérifications distinctes pour le dict qui ont une paire de clés / valeur.

Par exemple, vous avez les données suivantes:

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

Dans cet exemple, vous avez un dict qui a une charge utile différente dépend de la clé de type. Cela est possible à décrire avec le schéma suivant:

---
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