Comment utiliser Pandas avec Django ORM

#
# Settings file
#

import os

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.2/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'SECRET_KEY'


# Application definition

INSTALLED_APPS = [
    'example_project'
]

WSGI_APPLICATION = 'django_pandas.wsgi.application'

# Database
# https://docs.djangoproject.com/en/2.2/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

#
# Déclaration des modèles de l'application example_project
#


from django.db import models


class Manager(models.Model):
    """Chaque employé a un manager"""
    name = models.CharField(max_length=200, verbose_name='Manager')

    def __str__(self):
        return self.name

    class Meta:
        db_table = 'manager'
        verbose_name = 'Manager'
        verbose_name_plural = 'Managers'


class Job(models.Model):
    """Chaque développeur a un job"""
    name = models.CharField(max_length=200, verbose_name='Job')

    def __str__(self):
        return self.name

    class Meta:
        db_table = 'job'
        verbose_name = 'Job'
        verbose_name_plural = 'Jobs'


class Developer(models.Model):
    """Model des développeurs"""
    name = models.CharField(max_length=200, verbose_name='Name')
    age = models.IntegerField(default=0, verbose_name='Age')
    job = models.ForeignKey(
        Job,
        verbose_name='Job',
        related_name='dev_job',
        null=True,
        blank=True,
        on_delete=models.DO_NOTHING
    )
    manager = models.ForeignKey(
        Manager,
        verbose_name='Manager',
        related_name='dev_manager',
        null=True,
        blank=True,
        on_delete=models.DO_NOTHING
    )
    date = models.DateField(verbose_name='Date')

    def __str__(self):
        return '{dev_name} - {job} <{manager}>'.format(
            dev_name=self.name,
            job=self.job,
            manager=self.manager
        )

    class Meta:
        db_table = 'developer'
        verbose_name = 'Developer'
        verbose_name_plural = 'Developers'

import openpyxl

def read_excel_file(file_path='', sheet_name='Sheet1'):
    """On va lire le document EXCEL avec openpyxl
    NB: On peut le lire directement avec Pandas
    Mais je préfère le lire avec openpyxl ...
    Parce que je veux controler ce que je fais :D"""
    wb = openpyxl.load_workbook(file_path)
    ws = wb[sheet_name]
    # Balayer les colonnes une par une et générer des sous listes
    # Qui vont contenir les noms des colonnes (première position)
    # ensuite chaque transposer les données des colonnes
    # pour créer des sous listes qui vont contenir les données de chaque ligne
    # sous forme d'une sous liste de la liste finale
    # Ceci dit:
    # colonnes = values[0]
    # lignes = values[1:]
    values = [[k.value for k in elm] for elm in zip(*ws.columns)]
    return values

from django.db.models import transaction
from example_project import models

def insert_data(values):
    """Insertion des données dans la database"""
    with transaction.atomic():
        for name, age, job_name, date, manager_name in values:
            manager, _ = models.Manager.objects.get_or_create(
                name=manager_name
            )
            job, _ = models.Job.objects.get_or_create(name=job_name)
            developer, _ = models.Developer.objects.get_or_create(
                manager=manager,
                job=job,
                name=name,
                age=age,
                date=date
            )
            print(developer)

from example_project import models

def read_data():
    """Read data from Database"""
    # Ceci sont les noms des colonnes de notre base de données
    names = [
        'id',
        'name',
        'age',
        'job__name',  # Ceci permet à Django ORM d'accèder au contenu du ForeignKey
        'manager__name',  # Permet à django ORM d'accèder au contenu du ForeignKey
        'date'
    ]
    # retourner une liste contenant par ordre les valeurs des noms de colonnes insérés
    return models.Developer.objects.all().values_list(*names)

from example_project import models
import pandas as pd

def create_df(data):
    """Create DataFrame from database"""
    # Ceci permet de générer une liste des verbose_name qu'on a utilisé
    # Dans la définition de nos models dans l'ORM de Django
    # Et dans notre cas, ces verbose_name sont identiques aux noms 
    # de colonnes du document EXCEL
    column_names = [
        field.verbose_name for field in models.Developer._meta.fields
    ]
    return pd.DataFrame(
        data,
        columns=column_names
    )

from django.db.models import Avg, Sum
from example_project import models

def pprint(dataframe=None, database=None, field='', header=''):
    """Pretty print data"""
    print('#' * 5, header, '#' * 5)
    if database:
        print("""Database: {field}: {data}""".format(
            field=field,
            data=database.get(field)
        ))
    if dataframe:
        print("""DataFrame: {field}: {data}""".format(
            field=field,
            data=dataframe
        ))
    print()


def operations(df):
    """Faire les memes opérations sur la database et sur le DataFrame"""
    # Average age
    db_avg = models.Developer.objects.all().aggregate(
        average=Avg('age')
    )
    df_avg = df['Age'].mean()
    pprint(
        dataframe=df_avg,
        database=db_avg,
        field='average',
        header='Average Age'
    )
    # Sum age
    db_sum = models.Developer.objects.all().aggregate(
        sum=Sum('age')
    )
    df_sum = df['Age'].sum()
    pprint(
        dataframe=df_sum,
        database=db_sum,
        field='sum',
        header='Sum Age'
    )
    # Average age uniquement pour Manager == Chiheb
    db_avg_chiheb = models.Developer.objects.filter(
        manager__name='Chiheb'
    ).aggregate(
        average=Avg('age')
    )
    df_avg_chiheb = df.loc[df['Manager'].isin(['Chiheb'])]['Age'].mean()
    pprint(
        dataframe=df_avg_chiheb,
        database=db_avg_chiheb,
        field='average',
        header='Average only chiheb'
    )
    # Average age uniquement pour job = Python developer
    db_avg_python = models.Developer.objects.filter(
        job__name='Python developer'
    ).aggregate(
        average=Avg('age')
    )
    df_avg_python = df.loc[df['Job'].isin(['Python developer'])]['Age'].mean()
    pprint(
        dataframe=df_avg_python,
        database=db_avg_python,
        field='average',
        header='Average Age only Python developer'
    )