Récapitulatif

Introduction à la qualité des données avec Great Expectations

Davina Moossazadeh

Data Scientist

Chapitre 1 : Connexion aux données

Créer un contexte de données

context = gx.get_context()

Chapitre 1 : Connexion aux données

Se connecter aux données

Créer une source de données à partir du contexte :

data_source = context.data_sources.add_pandas(
    name: str
)

Créer un actif de données à partir de la source :

data_asset = data_source.add_dataframe_asset(
    name: str
)

Chapitre 1 : Connexion aux données

Lire les données par lots

Créer une définition de lot à partir de l'actif :

batch_definition = data_asset. \
add_batch_definition_whole_dataframe(
  name: str
)

Créer un lot à partir de la définition :

batch = batch_definition.get_batch(
  batch_parameters={"dataframe": dataframe}
)

Obtenir les premières lignes du DataFrame du lot :

batch.head(fetch_all: bool)

Obtenir la liste des colonnes du DataFrame du lot :

batch.columns()

Chapitre 2 : Définir des attentes

Créer des attentes

Créer une attente : gx.expectations.Expect...(...)

Créer une attente sur le nombre de lignes :

expectation = gx.expectations. \
ExpectTableRowCountToEqual(
    value: int
)

Valider l'attente :

validation_results = batch.validate(
    expect=expectation
)

Consulter les résultats de validation :

validation_results.describe()
validation_results.success
validation_results.result

Chapitre 2 : Définir des attentes

Attentes sur le schéma

Attentes sur la forme :

ExpectTableRowCountToEqual(value: int)
ExpectTableRowCountToBeBetween(
    min_value: int, max_value: int
)
ExpectTableColumnCountToEqual(
    value: int
)
ExpectTableColumnCountToBeBetween(
    min_value: int, max_value: int
)

Attentes sur les noms de colonnes :

ExpectTableColumnsToMatchSet(
    column_set: set
)
ExpectColumnToExist(column: str)

Chapitre 2 : Définir des attentes

Créer une suite d'attentes

Créer une suite d'attentes :

suite = gx.ExpectationSuite(name: str)

Ajouter une attente à la suite :

suite.add_expectation(expectation)

Accéder aux attentes de la suite :

suite.expectations

Valider une suite d'attentes :

validation_results = batch.validate(
    expect=suite
)

Consulter les résultats de validation :

validation_results.success
validation_results.describe()

Chapitre 2 : Définir des attentes

Valider des suites d'attentes

Ajouter une suite au contexte de données :

context.suites.add(suite)

Créer une définition de validation :

validation_definition = \
gx.ValidationDefinition(
  name: str, 
  data=batch_definition, 
  suite=suite
)

Exécuter la validation :

validation_results = \
validation_definition.run(
  batch_parameters={"dataframe": dataframe}
)

Consulter les résultats de validation :

validation_results.success
validation_results.describe()

Chapitre 3 : GX en pratique

Déployer des définitions de validation

Ajouter une définition de validation au contexte :

context.validation_definitions.add(
    validation_definition
)

Créer un point de contrôle :

checkpoint = gx.Checkpoint(
    name: str, 
    validation_definitions: list,
)

Exécuter le point de contrôle :

checkpoint_results = checkpoint.run(
    batch_parameters={
        "dataframe": dataframe
    }
)

Vérifier les résultats du point de contrôle :

checkpoint_results.success

Chapitre 3 : GX en pratique

Mettre à jour des suites d'attentes

Copier une attente :

expectation_copy = expectation.copy()
expectation_copy.id = None

Vérifier si l'attente est dans la suite :

expectation in suite.expectations

Supprimer une attente :

suite.delete_expectation(expectation)

Mettre à jour la valeur d'une attente :

expectation.value = new_value

Enregistrer les modifications de l'attente :

expectation.save()

Enregistrer les modifications de la suite :

suite.save()

Chapitre 3 : GX en pratique

Gérer les composants

Ajouter un composant au contexte de données :

context.data_sources.add(data_source)

context.suites.add(suite)

context.validation_definitions.add(
    validation_definition
)

context.checkpoints.add(checkpoint)

Récupérer un composant :

.get(name: str)

Lister les composants :

.all()

Supprimer un composant :

.delete(name: str)

Chapitre 4 : Tout sur les attentes

Attentes de base sur les colonnes

Attentes au niveau des lignes :

ExpectColumnValuesToNotBeNull(
    column: str
)
ExpectColumnValuesToBeOfType(
    column: str, type_: str
)

Attentes agrégées :

ExpectColumnDistinctValuesToEqualSet(
    column: str, value_set: set
)
ExpectColumnUniqueValueCountToBeBetween(
    column: str, 
    min_value: int, max_value: int
)
ExpectColumnValuesToBeUnique(column: str)
ExpectColumnMostCommonValueToBeInSet(
    column: str, value_set: set
)

Chapitre 4 : Tout sur les attentes

Attentes selon le type

Attentes numériques :

ExpectColumn<METRIC>ToBeBetween(
  column: str, min_value: int, max_value: int
)
# <METRIC> dans 
# {"Mean", "Median", "Stdev", "Sum"}

ExpectColumnValuesToBeBetween(
  column: str, min_value: int, max_value: int
)
ExpectColumnValuesToBeIncreasing(column: str)
ExpectColumnValuesToBeDecreasing(column: str)

Attentes sur les chaînes :

ExpectColumnValueLengthsToEqual(
  column: str, value: int
)
ExpectColumnValuesToMatchRegex(
  column: str, regex: str
)
ExpectColumnValuesToMatchRegexList(
  column: str, regex_list: list
)
ExpectColumnValuesToBe{Dateutil,Json}Parseable(
  column: str
)

Chapitre 4 : Tout sur les attentes

Attentes conditionnelles

expectation = gx.expectations.Expect...(
    expetation_parameters,
    ...,
    condition_parser='pandas',
    row_condition: str,
)

Derniers mots

Ressources :

https://docs.greatexpectations.io/docs/core/introduction

https://docs.greatexpectations.io/docs/reference

Galerie des attentes :

www.greatexpectations.io/expectations

Félicitations !

Introduction à la qualité des données avec Great Expectations