territories-dashboard-lib 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

territories_dashboard_lib/indicators_lib/enums.py

@@ -0,0 +1,59 @@
+from django.db import models
+
+
+class AggregationFunctions(models.TextChoices):
+    DISCRETE_COMPONENT_2 = "discrete"
+    REPEATED_COMPONENT_2 = "repeated"
+
+
+class MeshLevel(models.TextChoices):
+    National = "fr"
+    Region = "reg"
+    Department = "dep"
+    Epci = "epci"
+    Town = "com"
+
+
+class GeoLevel(models.TextChoices):
+    France = "fr"
+    Region = "reg"
+    Department = "dep"
+    Epci = "epci"
+    Town = "com"
+
+
+class FranceGeoLevel(models.TextChoices):
+    All = "FR0,FR1,FR2"
+    METRO = "FR0,FR1"
+    METRO_HORS_IDF = "FR0"
+
+
+FRANCE_GEOLEVEL_TITLES = {
+    FranceGeoLevel.All: "France entière",
+    FranceGeoLevel.METRO: "France métropolitaine",
+    FranceGeoLevel.METRO_HORS_IDF: "France métropolitaine hors IDF",
+}
+
+FRANCE_DB_VALUES = {
+    FranceGeoLevel.All: "FR_TOT",
+    FranceGeoLevel.METRO: "FR_METRO",
+    FranceGeoLevel.METRO_HORS_IDF: "FR_METRO_HORS_IDF",
+}
+
+
+DEFAULT_MESH = MeshLevel.Region
+
+MESH_TITLES = {
+    MeshLevel.National: "France entière",
+    MeshLevel.Region: "Région",
+    MeshLevel.Department: "Département",
+    MeshLevel.Epci: "Intercommunalité",
+    MeshLevel.Town: "Commune",
+}
+
+MESH_DB = {
+    MeshLevel.Region: "REG",
+    MeshLevel.Department: "DEP",
+    MeshLevel.Epci: "EPCI",
+    MeshLevel.Town: "DEPCOM",
+}

territories_dashboard_lib/indicators_lib/export.py

@@ -0,0 +1,29 @@
+import csv
+
+from django.http import HttpRequest, HttpResponse
+
+from territories_dashboard_lib.tracking_lib.enums import EventType
+from territories_dashboard_lib.tracking_lib.logic import track_event
+
+from .models import Indicator
+
+
+def export_to_csv(
+    request: HttpRequest, indicator: Indicator, graph_name: str, data: list[dict]
+):
+    response = HttpResponse(content_type="text/csv")
+    response["Content-Disposition"] = (
+        f'attachment; filename="{indicator.name}_{graph_name}.csv"'
+    )
+    writer = csv.writer(response)
+    if data:
+        writer.writerow(data[0].keys())
+    for row in data:
+        writer.writerow(row.values())
+    response = track_event(
+        request=request,
+        response=response,
+        event_name=EventType.download,
+        data={"indicator": indicator.name, "objet": graph_name},
+    )
+    return response

territories_dashboard_lib/indicators_lib/format.py

@@ -0,0 +1,34 @@
+def _get_precision(value, force_integer):
+    return f"{value:.0f}" if force_integer else f"{value:.1f}"
+
+
+def _remove_useless_0(value):
+    if "." in value:
+        value = value.rstrip("0").rstrip(".")
+    return value
+
+
+def format_indicator_value(value, force_integer=False):
+    if value is None:
+        return "-"
+
+    abs_value = abs(value)
+
+    if abs_value > 999999:
+        nb = _remove_useless_0(_get_precision((value / 1_000_000), force_integer)) + "M"
+    elif abs_value > 999:
+        nb = _remove_useless_0(_get_precision((value / 1_000), force_integer)) + "k"
+
+    else:
+        nb = _remove_useless_0(_get_precision(value, force_integer))
+    return nb.replace(".", ",")
+
+
+def _format_value(k, v):
+    if k.lower().startswith("valeur"):
+        v = format_indicator_value(v)
+    return v
+
+
+def format_data(data):
+    return {k: _format_value(k, v) for k, v in data.items()}

territories_dashboard_lib/indicators_lib/methodo_pdf.py

@@ -0,0 +1,99 @@
+import base64
+import os
+import subprocess
+from tempfile import NamedTemporaryFile
+
+from django.conf import settings
+from markdown import markdown
+
+
+def _html_to_pdf(html_content, output_pdf_path):
+    try:
+        process = subprocess.Popen(
+            [
+                "wkhtmltopdf",
+                "-",
+                output_pdf_path,
+            ],  # '-' tells wkhtmltopdf to read from stdin
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        stdout, stderr = process.communicate(input=html_content.encode("utf-8"))
+        if process.returncode != 0:
+            print("Error:", stderr.decode("utf-8"))
+        else:
+            print(f"PDF successfully created at: {output_pdf_path}")
+    except FileNotFoundError:
+        print("Error: wkhtmltopdf not found. Ensure it is installed and in your PATH.")
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+
+def _generate_pdf_from_methodo(indicator, output_path):
+    html = markdown(indicator.methodo)
+    relative_logo_path = "whitenoise_root/ministere_logo.png"
+    logo_path = os.path.join(settings.BASE_DIR, relative_logo_path)
+    with open(logo_path, "rb") as fd:
+        encoded_logo = base64.b64encode(fd.read()).decode("utf-8")
+    html = (
+        """
+    <!DOCTYPE html>
+    <html lang="fr">
+    <head>
+        <meta charset="UTF-8">
+        <title>Accents Test</title>
+        <style>
+            body {
+                font-family: Tahoma, Arial, sans-serif;
+            }
+        </style>
+    </head>
+    <body>
+    <header>
+        <table>
+            <tr>
+                <td>
+                """
+        + f'<img width="150px" src="data:image/png;base64,{encoded_logo}"/>'
+        + """
+                </td>
+                <td style="padding-left: 64px;">
+                    <div style="font-size: 30px; font-weight: 600; margin-bottom: 8px;">Tableau de bord des mobilités durables</div>
+                    <div>Fiche méthodologique</div>
+                </td>
+            </tr>
+        </table>
+    </header>
+    <main>
+    """
+        + f"<h1>{indicator.title}</h1>"
+        + f"<p>Thématique : {indicator.sub_theme.theme.title} / {indicator.sub_theme.title}</p>"
+        + html
+        + """
+    </main>
+    </body>
+    </html>
+    """
+    )
+    _html_to_pdf(html, output_path)
+
+
+def reset_methodo_file(indicator):
+    # Create a temporary file for the PDF
+    with NamedTemporaryFile(delete=False, suffix=".pdf") as temp_file:
+        pdf_path = temp_file.name
+
+    # Generate the PDF
+    _generate_pdf_from_methodo(indicator, pdf_path)
+
+    # Read the binary content of the generated PDF file
+    with open(pdf_path, "rb") as pdf_file:
+        pdf_content = pdf_file.read()
+
+    # Save the binary content to the BinaryField
+    indicator.methodo_file = pdf_content
+    indicator.save()
+
+    # Clean up temporary file
+    os.remove(pdf_path)

territories_dashboard_lib/indicators_lib/migrations/0001_initial.py

@@ -0,0 +1,138 @@
+# Generated by Django 5.2.3 on 2025-06-19 07:13
+
+import django.db.models.deletion
+import martor.models
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='SubTheme',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('name', models.CharField(max_length=64, unique=True)),
+                ('index_in_theme', models.IntegerField(default=0)),
+                ('title', models.CharField(max_length=128)),
+                ('description', models.TextField(blank=True, default='')),
+            ],
+            options={
+                'verbose_name': '2 - Sous-thème',
+                'ordering': ('theme', 'index_in_theme'),
+            },
+        ),
+        migrations.CreateModel(
+            name='Indicator',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('is_active', models.BooleanField(default=True)),
+                ('index_in_theme', models.IntegerField(default=0)),
+                ('name', models.CharField(max_length=32, unique=True)),
+                ('title', models.CharField(max_length=128)),
+                ('db_table_prefix', models.CharField(max_length=128)),
+                ('is_composite', models.BooleanField(default=False)),
+                ('show_alternative', models.BooleanField(default=True, help_text='Pour certains indicateurs composites (par exemple les moyennes) on ne veut pas afficher la valeur alternative.', verbose_name='Afficher la valeur alternative')),
+                ('aggregation_constant', models.DecimalField(decimal_places=5, default=1, max_digits=10)),
+                ('aggregation_function', models.CharField(choices=[('discrete', 'Discrete Component 2'), ('repeated', 'Repeated Component 2')], default='repeated', max_length=8)),
+                ('unite', models.CharField(max_length=32)),
+                ('unite_nom_accessible', models.CharField(blank=True, default='', help_text="Nom accessible de l'unité qui sera lu par le lecteur d'écran.", max_length=64)),
+                ('unite_alternative', models.CharField(blank=True, default=None, max_length=32, null=True)),
+                ('unite_alternative_nom_accessible', models.CharField(blank=True, default='', help_text="Nom accessible de l'unité alternative qui sera lu par le lecteur d'écran.", max_length=64)),
+                ('flows_db_table_prefix', models.CharField(blank=True, help_text='Les données des flux seront affichés sur la carte et le graphique de Sankey.', max_length=128, null=True, verbose_name='Table des flux (prefix)')),
+                ('flows_dimension', models.CharField(blank=True, help_text='Nom de la colonne des dimensions de la table des flux', max_length=32, null=True, verbose_name='Dimension des flux')),
+                ('show_evolution', models.BooleanField(default=False)),
+                ('source', models.TextField(blank=True, default='')),
+                ('description', models.TextField(blank=True, default='')),
+                ('methodo', martor.models.MartorField(blank=True, default='')),
+                ('methodo_file', models.BinaryField(blank=True, null=True)),
+                ('secondary_indicator', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='indicators_lib.indicator', verbose_name='Second indicateur à afficher sur la carte')),
+                ('sub_theme', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='indicators', to='indicators_lib.subtheme')),
+            ],
+            options={
+                'verbose_name': '3 - Indicateur',
+                'ordering': ('sub_theme', 'index_in_theme'),
+            },
+        ),
+        migrations.CreateModel(
+            name='Dimension',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('db_name', models.TextField()),
+                ('title', models.TextField()),
+                ('is_breakdown', models.BooleanField(default=False, help_text="Dans le cas de plusieurs dimensions pour un indicateur, l'une d'entre elles doit être la dimension de réparition pour les graphiques.", verbose_name='Répartir selon cette dimension')),
+                ('indicator', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='dimensions', to='indicators_lib.indicator')),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Theme',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('ordering', models.IntegerField(default=0)),
+                ('name', models.CharField(max_length=64, unique=True)),
+                ('title', models.CharField(max_length=128)),
+                ('objectif_theme', models.TextField(blank=True)),
+                ('action_theme', models.TextField(blank=True)),
+            ],
+            options={
+                'verbose_name': '1 - Thème',
+                'ordering': ('ordering',),
+                'indexes': [models.Index(fields=['name'], name='indicators__name_fea408_idx')],
+            },
+        ),
+        migrations.AddField(
+            model_name='subtheme',
+            name='theme',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='sub_themes', to='indicators_lib.theme'),
+        ),
+        migrations.CreateModel(
+            name='Filter',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('db_name', models.CharField(max_length=128)),
+                ('order', models.IntegerField(default=0)),
+                ('default', models.BooleanField(default=True)),
+                ('dimension', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='filters', to='indicators_lib.dimension')),
+            ],
+            options={
+                'verbose_name': 'Filtre',
+                'ordering': ('dimension', 'order', 'db_name'),
+                'indexes': [models.Index(fields=['db_name'], name='indicators__db_name_d32459_idx'), models.Index(fields=['dimension', 'order'], name='indicators__dimensi_aa3fdf_idx')],
+                'unique_together': {('dimension', 'db_name')},
+            },
+        ),
+        migrations.AddIndex(
+            model_name='indicator',
+            index=models.Index(fields=['sub_theme'], name='indicators__sub_the_b49caf_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='indicator',
+            index=models.Index(fields=['name'], name='indicators__name_c5606a_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='subtheme',
+            index=models.Index(fields=['theme', 'index_in_theme'], name='indicators__theme_i_0cbbc1_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='subtheme',
+            index=models.Index(fields=['name'], name='indicators__name_79c542_idx'),
+        ),
+    ]

territories_dashboard_lib/indicators_lib/models.py

@@ -0,0 +1,230 @@
+from django.db import models
+from martor.models import MartorField
+
+from territories_dashboard_lib.commons.models import CommonModel
+from territories_dashboard_lib.indicators_lib.enums import AggregationFunctions
+from territories_dashboard_lib.indicators_lib.refresh_filters import refresh_filters
+
+
+class Theme(CommonModel):
+    # TODO: make it primary key
+    # django.db.utils.OperationalError: foreign key mismatch -
+    # "tdbmd_indicators_indicatorsubtheme" referencing "tdbmd_indicators_indicatortheme"
+    ordering = models.IntegerField(default=0)
+    ordering.verbose_name = "Ordre dans la sidebar"
+    name = models.CharField(max_length=64, unique=True)
+    name.verbose_name = "Nom (~id, URL)"
+    title = models.CharField(max_length=128)
+    title.verbose_name = "Titre (affiché)"
+    objectif_theme = models.TextField(blank=True)
+    objectif_theme.verbose_name = "Objectif"
+    action_theme = models.TextField(blank=True)
+    action_theme.verbose_name = "Actions"
+
+    def is_displayed_on_app(self):
+        return self.sub_themes.all().exists()
+
+    is_displayed_on_app.__name__ = "Visible ?"
+    is_displayed_on_app.boolean = True
+
+    def subthemes_count(self):
+        return self.sub_themes.count()
+
+    subthemes_count.__name__ = "Nb sous-thèmes"
+
+    def indicators_count(self):
+        return sum(
+            [sub_theme.indicators_count() for sub_theme in self.sub_themes.all()]
+        )
+
+    indicators_count.__name__ = "Total indicateurs"
+
+    def __str__(self):
+        return self.title
+
+    class Meta:
+        ordering = ("ordering",)
+        verbose_name = "1 - Thème"
+        indexes = [
+            models.Index(fields=["name"]),
+        ]
+
+
+class SubTheme(CommonModel):
+    name = models.CharField(max_length=64, unique=True)
+    name.verbose_name = "Nom (~id, URL)"
+    theme = models.ForeignKey(
+        Theme, on_delete=models.CASCADE, related_name="sub_themes"
+    )
+    theme.verbose_name = "Thème"
+    index_in_theme = models.IntegerField(default=0)
+    index_in_theme.verbose_name = "Ordre thème"
+    title = models.CharField(max_length=128)
+    title.verbose_name = "Titre (affiché)"
+    description = models.TextField(default="", blank=True)
+
+    def __str__(self):
+        return f"{self.theme.title} > {self.title}"
+
+    def indicators_count(self):
+        return self.indicators.count()
+
+    def is_displayed_on_app(self):
+        return self.indicators.all().exists()
+
+    indicators_count.__name__ = "Nb indicateurs"
+    is_displayed_on_app.__name__ = "Visible ?"
+    is_displayed_on_app.boolean = True
+
+    class Meta:
+        ordering = ("theme", "index_in_theme")
+        verbose_name = "2 - Sous-thème"
+        indexes = [
+            models.Index(fields=["theme", "index_in_theme"]),
+            models.Index(fields=["name"]),
+        ]
+
+
+class Indicator(CommonModel):
+    is_active = models.BooleanField(default=True)
+    is_active.verbose_name = "Actif ?"
+    sub_theme = models.ForeignKey(
+        SubTheme, on_delete=models.CASCADE, related_name="indicators"
+    )
+    sub_theme.verbose_name = "Sous-thème"
+    index_in_theme = models.IntegerField(default=0)  # TODO: is it necessary?
+    index_in_theme.verbose_name = "Ordre sous-thème"
+    name = models.CharField(max_length=32, unique=True)
+    name.verbose_name = "Nom (~id, URL)"
+    title = models.CharField(max_length=128)
+    title.verbose_name = "Titre (affiché)"
+    # Indicator's DB attributes
+    db_table_prefix = models.CharField(max_length=128)
+    db_table_prefix.verbose_name = "Préfixe dans la DB"
+    is_composite = models.BooleanField(default=False)
+    is_composite.verbose_name = "Indicateur composite"
+    show_alternative = models.BooleanField(
+        default=True,
+        verbose_name="Afficher la valeur alternative",
+        help_text="Pour certains indicateurs composites (par exemple les moyennes) on ne veut pas afficher la valeur alternative.",
+    )
+    aggregation_constant = models.DecimalField(
+        default=1, decimal_places=5, max_digits=10
+    )
+    aggregation_constant.verbose_name = "Constante d'agrégation"
+    aggregation_function = models.CharField(
+        default=AggregationFunctions.REPEATED_COMPONENT_2,
+        max_length=8,
+        choices=AggregationFunctions.choices,
+    )
+    aggregation_function.verbose_name = "Fonction d'agrégation"
+    unite = models.CharField(max_length=32)
+    unite.verbose_name = "Unité (affichée)"
+    unite_nom_accessible = models.CharField(
+        max_length=64,
+        default="",
+        blank=True,
+        help_text="Nom accessible de l'unité qui sera lu par le lecteur d'écran.",
+    )
+    unite_alternative = models.CharField(
+        default=None, null=True, blank=True, max_length=32
+    )
+    unite_alternative.verbose_name = "Unité alternative (affichée)"
+    unite_alternative_nom_accessible = models.CharField(
+        max_length=64,
+        default="",
+        blank=True,
+        help_text="Nom accessible de l'unité alternative qui sera lu par le lecteur d'écran.",
+    )
+    secondary_indicator = models.ForeignKey(
+        "indicators_lib.Indicator",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        verbose_name="Second indicateur à afficher sur la carte",
+    )
+    flows_db_table_prefix = models.CharField(
+        null=True,
+        blank=True,
+        max_length=128,
+        verbose_name="Table des flux (prefix)",
+        help_text="Les données des flux seront affichés sur la carte et le graphique de Sankey.",
+    )
+    flows_dimension = models.CharField(
+        null=True,
+        blank=True,
+        max_length=32,
+        verbose_name="Dimension des flux",
+        help_text="Nom de la colonne des dimensions de la table des flux",
+    )
+    # Descriptive attributes
+    show_evolution = models.BooleanField(default=False)
+    show_evolution.verbose_name = "Activer l'historique"
+    source = models.TextField(default="", blank=True)
+    description = models.TextField(default="", blank=True)
+    methodo = MartorField(default="", blank=True)
+    methodo.verbose_name = "Méthodologie (markdown)"
+    methodo_file = models.BinaryField(null=True, blank=True)
+
+    def __str__(self):
+        return self.title
+
+    def get_theme_title(self):
+        return self.sub_theme.theme.title
+
+    get_theme_title.short_description = "Thème"
+
+    class Meta:
+        ordering = ("sub_theme", "index_in_theme")
+        verbose_name = "3 - Indicateur"
+        indexes = [
+            models.Index(fields=["sub_theme"]),
+            models.Index(fields=["name"]),
+        ]
+
+
+class Dimension(CommonModel):
+    indicator = models.ForeignKey(
+        Indicator, on_delete=models.CASCADE, related_name="dimensions"
+    )
+    db_name = models.TextField()
+    title = models.TextField()
+    is_breakdown = models.BooleanField(
+        default=False,
+        verbose_name="Répartir selon cette dimension",
+        help_text="Dans le cas de plusieurs dimensions pour un indicateur, l'une d'entre elles doit être la dimension de réparition pour les graphiques.",
+    )
+
+    def save(self, *args, **kwargs):
+        is_new = self.pk is None
+        result = super().save(*args, **kwargs)
+        if is_new:
+            try:
+                refresh_filters(self)
+            except Exception as e:
+                print(e)
+        return result
+
+
+class Filter(CommonModel):
+    dimension = models.ForeignKey(
+        Dimension, related_name="filters", on_delete=models.CASCADE
+    )
+    db_name = models.CharField(max_length=128)
+    db_name.verbose_name = "Nom dans la BDD"
+    order = models.IntegerField(default=0)
+    order.verbose_name = "Ordre"
+    default = models.BooleanField(default=True)
+    default.verbose_name = "Sélectionné par défaut ?"
+
+    def __str__(self):
+        return self.db_name
+
+    class Meta:
+        ordering = ("dimension", "order", "db_name")
+        verbose_name = "Filtre"
+        indexes = [
+            models.Index(fields=["db_name"]),
+            models.Index(fields=["dimension", "order"]),
+        ]
+        unique_together = ("dimension", "db_name")

territories_dashboard_lib/indicators_lib/payloads.py

@@ -0,0 +1,54 @@
+from typing import Annotated, Optional
+
+from pydantic import BaseModel, BeforeValidator, Field
+
+from .enums import MeshLevel
+
+
+class Territory(BaseModel):
+    id: str
+    mesh: MeshLevel
+
+
+def validate_territory(value):
+    if value and "-" in value:
+        return {"id": value.split("-")[0], "mesh": value.split("-")[1]}
+
+
+class BasePayload(BaseModel):
+    territory: Annotated[Territory, BeforeValidator(validate_territory)]
+
+
+class SubMeshPayload(BasePayload):
+    submesh: MeshLevel
+
+
+class FlowsPayload(SubMeshPayload):
+    prefix: str
+    dimension: str | None = None
+
+
+class ComparisonQueryPayload(SubMeshPayload):
+    cmp_territory: Annotated[
+        Territory, BeforeValidator(validate_territory), Field(alias="cmp-territory")
+    ]
+
+
+class OptionalComparisonQueryPayload(SubMeshPayload):
+    cmp_territory: Annotated[
+        Optional[Territory],
+        BeforeValidator(validate_territory),
+        Field(default=None, alias="cmp-territory"),
+    ]
+
+
+class IndicatorTablePayload(SubMeshPayload):
+    column_order: str | None = None
+    column_order_flow: str | None = None
+    pagination: int = 1
+    limit: int = 20
+    previous_limit: int | None = None
+    search: str | None = None
+    year: int | None = None
+    flows: bool | None = False
+    focus: bool | None = False