nupes-elections-front/src/Elections2024.js

@@ -16,7 +16,7 @@ import 'leaflet/dist/leaflet.css'
 
 highchartsItem(Highcharts)
 
-export default function ElectionsEuropeennes2024() {
+export default function Election2024() {
   const {typeResultats, zoneId} = useParams()
 
   const [grouperParBloc, setGrouperParBloc] = useState(false)
@@ -25,8 +25,7 @@ export default function ElectionsEuropeennes2024() {
   const [nuances, setNuances] = useState([])
   const [listes, setListes] = useState([])
   const [resultats, setResultats] = useState([])
-  const [typeSousZone, setTypeSousZone] = useState("region")
-  const tour = 1
+  const [typeZone, setTypeZone] = useState("region")
 
   useEffect(() => {
     fetch("/data/resultats/europeennes/2024/blocs.json").then(response => response.json())
@@ -47,20 +46,12 @@ export default function ElectionsEuropeennes2024() {
     }
   }, [typeResultats, zoneId])
 
-  const zoneInfo = useMemo(() => resultats?.zone ?? {}, [resultats])
-  const nomZone = useMemo(() => getNomZone(typeResultats, zoneInfo), [typeResultats, zoneInfo])
+  const nomZone = useMemo(() => getNomZone(typeResultats, resultats),
+    [typeResultats, resultats])
 
-  const donnees = useMemo(() => {
-    if (tour === 1)
-      return resultats?.tour1 ?? {}
-    else if (tour === 2)
-      return resultats?.tour2 ?? {}
-    else
-      return {}
-  }, [resultats, tour])
-  const [voixParBloc, voixParNuance] = regrouperVoix(donnees.voix, listes, blocs, nuances)
+  const [voixParBloc, voixParNuance] = regrouperVoix(resultats.voix, listes, blocs, nuances)
 
-  const siegesParListe = calculerSieges(listes, donnees, retirerSeuil ? 0 : 0.05)
+  const siegesParListe = calculerSieges(listes, resultats, retirerSeuil ? 0 : 0.05)
   const [siegesParBloc, siegesParNuance] = regrouperVoix(siegesParListe, listes, blocs, nuances)
 
   return <>
@@ -68,21 +59,22 @@ export default function ElectionsEuropeennes2024() {
       <Toolbar>
         <GroupementParBloc grouperParBloc={grouperParBloc} setGrouperParBloc={setGrouperParBloc} />
         <RetirerSeuil retirerSeuil={retirerSeuil} setRetirerSeuil={setRetirerSeuil} />
-        <SelectionAffichage typeResultats={typeResultats} typeSousZone={typeSousZone} setTypeSousZone={setTypeSousZone} />
+        <SelectionAffichage typeResultats={typeResultats} typeZone={typeZone} setTypeZone={setTypeZone} />
       </Toolbar>
     </AppBar>
     <Container>
       <HistogrammeVoix titre={`Résultats des élections européennes 2024 : ${nomZone}`}
-                       resultats={donnees} voixParNuance={voixParNuance} voixParBloc={voixParBloc}
+                       resultats={resultats} voixParNuance={voixParNuance} voixParBloc={voixParBloc}
                        blocs={blocs} nuances={nuances} grouperParBloc={grouperParBloc} />
       <CompositionHemicycle titre={`Eurodéputé⋅es français⋅es dans l'hémicycle européen 2024 : ${nomZone}`}
                             blocs={blocs} nuances={nuances} siegesParBloc={siegesParBloc} siegesParNuance={siegesParNuance}
                             grouperParBloc={grouperParBloc} />
-      <TableauResultatsEuropeennes blocs={blocs} nuances={nuances} listes={listes} resultats={donnees} siegesParListe={siegesParListe} />
-      <TableauParticipation resultats={donnees} />
-      <CarteResultats typeElection={"europeennes"} anneeElection={"2024"} typeResultats={typeResultats} zoneInfo={zoneInfo}
-                      typeSousZone={typeSousZone} candidats={listes} blocs={blocs} nuances={nuances} tour={tour}
-                      grouperParBloc={grouperParBloc} />
+      <TableauResultatsEuropeennes blocs={blocs} nuances={nuances} listes={listes} resultats={resultats} siegesParListe={siegesParListe} />
+      <TableauParticipation resultats={resultats} />
+      <CarteResultats typeElection={"europeennes"} anneeElection={"2024"}
+                      typeResultats={typeResultats} resultats={resultats} typeZone={typeZone}
+                      candidats={listes} blocs={blocs} nuances={nuances}
+                      voixParBloc={voixParBloc} voixParNuance={voixParNuance} grouperParBloc={grouperParBloc} />
     </Container>
   </>
 }

nupes-elections-front/src/includes/composants_elections.js

@@ -184,37 +184,23 @@ export function RetirerSeuil({retirerSeuil, setRetirerSeuil}) {
                            label="Retirer le seuil des 5 %" />
 }
 
-export function SelectionTour({tour, setTour}) {
-  return <FormControl>
-    <InputLabel>
-      Zone à afficher
-  </InputLabel>
-    <Select value={tour}
-            onChange={event => setTour(parseInt(event.target.value.toString()))}
-            label="Tour">
-      <MenuItem value="1">Tour 1</MenuItem>
-      <MenuItem value="2">Tour 2</MenuItem>
-    </Select>
-  </FormControl>
-}
-
-export function SelectionAffichage({typeResultats, typeSousZone, setTypeSousZone}) {
+export function SelectionAffichage({typeResultats, typeZone, setTypeZone}) {
   const items = useMemo(() => {
     const items = []
     if (typeResultats === "france") {
-      setTypeSousZone("region")
+      setTypeZone("region")
       items.push(<MenuItem value="region">Région</MenuItem>)
     }
 
     if (typeResultats === "france" || typeResultats === "region") {
       if (typeResultats !== "france")
-        setTypeSousZone("departement")
+        setTypeZone("departement")
       items.push(<MenuItem value="departement">Département</MenuItem>)
     }
 
     if (typeResultats === "france" || typeResultats === "region" || typeResultats === "departement") {
       if (typeResultats !== "france" && typeResultats !== "region")
-        setTypeSousZone("circonscription")
+        setTypeZone("circonscription")
       items.push(<MenuItem value="circonscription">Circonscription</MenuItem>)
     }
 
@@ -223,19 +209,19 @@ export function SelectionAffichage({typeResultats, typeSousZone, setTypeSousZone
     }
 
     if (typeResultats === "circonscription" || typeResultats === "commune" || typeResultats === "bureau_vote") {
-      setTypeSousZone("bureau_vote")
+      setTypeZone("bureau_vote")
       items.push(<MenuItem value="bureau_vote">Bureau de vote</MenuItem>)
     }
 
     return items
-  }, [typeResultats, setTypeSousZone])
+  }, [typeResultats, setTypeZone])
 
   return <FormControl>
     <InputLabel>
       Zone à afficher
   </InputLabel>
-    <Select value={typeSousZone}
-            onChange={event => setTypeSousZone(event.target.value)}
+    <Select value={typeZone}
+            onChange={event => setTypeZone(event.target.value)}
             label="Zone à afficher">
       {items}
     </Select>
@@ -243,26 +229,23 @@ export function SelectionAffichage({typeResultats, typeSousZone, setTypeSousZone
 }
 
 
-function ZoneGeoJSON({typeElection, anneeElection, resultatsZone, typeSousZone,
-                       candidats, blocs, nuances, tour, grouperParBloc = false}) {
-  const sousZoneInfo = resultatsZone.zone
-  const donnees = resultatsZone ? (tour === 1 ? resultatsZone.tour1 : resultatsZone.tour2) : {}
-
+function ZoneGeoJSON({typeElection, anneeElection, resultatsZone, typeZone,
+                       candidats, blocs, nuances, grouperParBloc = false}) {
   const [idZone, nomZone] = useMemo(() => {
-    if (!sousZoneInfo)
+    if (!resultatsZone[typeZone])
       return ["", ""]
 
-    if (typeSousZone === "region" || typeSousZone === "departement" || typeSousZone === "commune")
-      return [sousZoneInfo.code_insee, sousZoneInfo.nom]
-    else if (typeSousZone === "circonscription")
-      return [sousZoneInfo.id, `Circonscription ${sousZoneInfo.id}`]
-    else if (typeSousZone === "bureau_vote")
-      return [sousZoneInfo.id, sousZoneInfo.libelle]
+    if (typeZone === "region" || typeZone === "departement" || typeZone === "commune")
+      return [resultatsZone[typeZone].code_insee, resultatsZone[typeZone].nom]
+    else if (typeZone === "circonscription")
+      return [resultatsZone.circonscription.id, `Circonscription ${resultatsZone.circonscription.id}`]
+    else if (typeZone === "bureau_vote")
+      return [resultatsZone.bureau_vote.id, resultatsZone.bureau_vote.libelle]
     else
       return ["", ""]
-  }, [typeSousZone, sousZoneInfo])
+  }, [typeZone, resultatsZone])
 
-  const voixCandidats = useMemo(() => donnees?.voix ?? {}, [resultatsZone])
+  const voixCandidats = useMemo(() => resultatsZone?.voix ?? {}, [resultatsZone])
   const candidatsTries = trierCandidats(candidats, voixCandidats)
 
   const [voixParBloc, voixParNuance] = regrouperVoix(voixCandidats, candidats, blocs, nuances)
@@ -288,58 +271,59 @@ function ZoneGeoJSON({typeElection, anneeElection, resultatsZone, typeSousZone,
   }
 
   return <GeoJSON
-    data={{'type': "Feature", 'geometry': resultatsZone.zone.geometry}}
+    data={{'type': "Feature", 'geometry': resultatsZone.geometry}}
     style={{fillColor: couleur, fillOpacity: 0.5, color: 'white', weight: 1}}>
     <Popup>
-      <strong><a href={`/elections/${typeElection}/${anneeElection}/${typeSousZone}/${idZone}/`}>{nomZone}</a></strong>
+      <strong><a href={`/elections/${typeElection}/${anneeElection}/${typeZone}/${idZone}/`}>{nomZone}</a></strong>
       <ul>
         {candidatsTries.slice(0, 5).map(candidat =>
           <li key={candidat.numero}>
-            {candidat.nom} : {voixCandidats[candidat.numero]} ({(100 * voixCandidats[candidat.numero] / donnees.exprimes).toFixed(2)} %)
+            {candidat.nom} : {voixCandidats[candidat.numero]} ({(100 * voixCandidats[candidat.numero] / resultatsZone.exprimes).toFixed(2)} %)
           </li>)}
       </ul>
     </Popup>
   </GeoJSON>
 }
 
-function ContenuCarte({typeElection, anneeElection, zoneInfo, typeSousZone, candidats, blocs, nuances, tour,
-                        grouperParBloc = false}) {
+function ContenuCarte({typeElection, anneeElection, typeResultats, resultats,
+                        typeZone, candidats, blocs, nuances, grouperParBloc = false}) {
   const map = useMap()
   const [resultatsZones, setResultatsZones] = useState([])
 
   const zones = useMemo(() => {
-    if (!zoneInfo)
+    const data = resultats[typeResultats]
+    if (!data)
       return []
 
-    if (typeSousZone === "region")
-      return zoneInfo?.regions ?? []
-    else if (typeSousZone === "departement")
-      return zoneInfo?.departements ?? []
-    else if (typeSousZone === "circonscription")
-      return zoneInfo?.circonscriptions ?? []
-    else if (typeSousZone === "commune")
-      return zoneInfo?.communes ?? []
-    else if (typeSousZone === "bureau_vote") {
-      if (zoneInfo.type === "bureau_vote")
-        return zoneInfo ? [zoneInfo.id] : []
+    if (typeZone === "region")
+      return data?.regions ?? []
+    else if (typeZone === "departement")
+      return data?.departements ?? []
+    else if (typeZone === "circonscription")
+      return data?.circonscriptions ?? []
+    else if (typeZone === "commune")
+      return data?.communes ?? []
+    else if (typeZone === "bureau_vote") {
+      if (typeResultats === "bureau_vote")
+        return data ? [data.id] : []
       else
-        return zoneInfo?.bureaux_vote ?? []
+        return data?.bureaux_vote ?? []
     }
     else
       return []
-  }, [zoneInfo, typeSousZone])
+  }, [typeResultats, resultats, typeZone])
 
   useEffect(() => {
-    if (zoneInfo.type === "france")
+    if (typeResultats === "france")
       return
 
-    const geometry = zoneInfo.geometry
+    const geometry = resultats.geometry
     if (geometry) {
       // On centre la carte sur la zone
       const geometry_bbox = bbox(geometry)
       map.fitBounds([[geometry_bbox[1], geometry_bbox[0]], [geometry_bbox[3], geometry_bbox[2]]])
     }
-  }, [zoneInfo, map])
+  }, [typeResultats, resultats, map])
 
   useEffect(() => {
     if (!zones)
@@ -348,33 +332,32 @@ function ContenuCarte({typeElection, anneeElection, zoneInfo, typeSousZone, cand
     setResultatsZones(resultatsZones => [])
 
     zones.forEach(zoneId => {
-      fetch(`/data/resultats/${typeElection}/${anneeElection}/${typeSousZone}/${zoneId}.json`)
+      fetch(`/data/resultats/${typeElection}/${anneeElection}/${typeZone}/${zoneId}.json`)
         .then(response => response.json())
         .then(resultatsZone => setResultatsZones(resultatsZones => [...resultatsZones, resultatsZone]))
     })
-  }, [typeElection, anneeElection, typeSousZone, zones])
+  }, [typeElection, anneeElection, typeZone, zones, resultats])
 
-  function getZoneIdentifier(typeSousZone, zone) {
-    if (typeSousZone === "region" || typeSousZone === "departement" || typeSousZone === "commune")
+  function getZoneIdentifier(typeZone, zone) {
+    if (typeZone === "region" || typeZone === "departement" || typeZone === "commune")
       return zone.code_insee
-    else if (typeSousZone === "circonscription" || typeSousZone === "bureau_vote")
+    else if (typeZone === "circonscription" || typeZone === "bureau_vote")
       return zone.id
     else
       return ""
   }
 
   return <>
-    {resultatsZones.filter(resultatsZone => resultatsZone.zone.geometry['type'])
-      .map(resultatsZone =>
-      <ZoneGeoJSON key={getZoneIdentifier(resultatsZone.zone)}
+    {resultatsZones.filter(resultatsZone => resultatsZone.geometry['type']).map(resultatsZone =>
+      <ZoneGeoJSON key={getZoneIdentifier(resultatsZone[typeZone])}
                    typeElection={typeElection} anneeElection={anneeElection}
-                   resultatsZone={resultatsZone} typeSousZone={typeSousZone} candidats={candidats}
-                   blocs={blocs} nuances={nuances} tour={tour} grouperParBloc={grouperParBloc}/>)}
+                   resultatsZone={resultatsZone} typeZone={typeZone} candidats={candidats}
+                   blocs={blocs} nuances={nuances} grouperParBloc={grouperParBloc}/>)}
   </>
 }
 
-export function CarteResultats({typeElection, anneeElection, typeResultats, zoneInfo, typeSousZone, candidats,
-                                 blocs, nuances, tour, grouperParBloc = false}) {
+export function CarteResultats({typeElection, anneeElection, typeResultats, resultats,
+                                 typeZone, candidats, blocs, nuances, grouperParBloc = false}) {
   const center = typeResultats === "france" ? [46.603354, 1.888334] : [0, 0]
 
   return <>
@@ -383,9 +366,9 @@ export function CarteResultats({typeElection, anneeElection, typeResultats, zone
         attribution='&copy; Les contributeur⋅rices <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a>'
         url="https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"
       />
-      <ContenuCarte typeElection={typeElection} anneeElection={anneeElection}
-                    zoneInfo={zoneInfo} typeSousZone={typeSousZone} candidats={candidats}
-                    blocs={blocs} nuances={nuances} tour={tour} grouperParBloc={grouperParBloc} />
+      <ContenuCarte typeElection={typeElection} anneeElection={anneeElection} typeResultats={typeResultats}
+                    resultats={resultats} typeZone={typeZone} candidats={candidats}
+                    blocs={blocs} nuances={nuances} grouperParBloc={grouperParBloc} />
   </MapContainer>
   </>
 }

nupes-elections-front/src/utils.js

@@ -1,18 +1,18 @@
-export function getNomZone(typeResultats, zoneInfo) {
-  if (!zoneInfo)
+export function getNomZone(typeResultats, resultats) {
+  if (!resultats || resultats.length === 0)
     return ""
   else if (typeResultats === "france")
     return "France"
   else if (typeResultats === "region")
-    return `Région ${zoneInfo.nom}`
+    return `Région ${resultats.region.nom}`
   else if (typeResultats === "departement")
-    return `Département ${zoneInfo.nom}`
+    return `Département ${resultats.departement.nom}`
   else if (typeResultats === "circonscription")
-    return `Circonscription ${zoneInfo.id}`
+    return `Circonscription ${resultats.circonscription.id}`
   else if (typeResultats === "commune")
-    return `Commune ${zoneInfo.nom}`
+    return `Commune ${resultats.commune.nom}`
   else if (typeResultats === "bureau_vote")
-    return zoneInfo.libelle
+    return resultats.bureau_vote.libelle
 }
 
 export function trierCandidats(candidats, voix_par_candidat) {

nupes/scripts/europeennes2024/export_resultats.py

@@ -8,7 +8,7 @@ from tqdm import tqdm
 from nupes.models.geographie import Circonscription, BureauVote
 from nupes.models.europeennes2024 import *
 
-DATA_DIR = Path(__file__).parent.parent.parent.parent / 'data'
+DATA_DIR = Path(__file__).parent.parent.parent / 'data'
 
 
 def exporter_listes(engine: Engine, verbose: bool = False) -> None:
@@ -17,11 +17,7 @@ def exporter_listes(engine: Engine, verbose: bool = False) -> None:
         blocs_json = []
 
         for bloc in blocs:
-            bloc_json = {
-                'id': bloc.id,
-                'nom': bloc.nom,
-                'couleur': bloc.couleur,
-            }
+            bloc_json = {'id': bloc.id, 'nom': bloc.nom, 'couleur': bloc.couleur}
             blocs_json.append(bloc_json)
 
         file = DATA_DIR / "resultats" / "europeennes" / "2024" / "blocs.json"
@@ -35,11 +31,7 @@ def exporter_listes(engine: Engine, verbose: bool = False) -> None:
         nuances_json = []
 
         for nuance in nuances:
-            nuance_json = {
-                'code': nuance.code,
-                'nom': nuance.nom,
-                'couleur': nuance.couleur,
-            }
+            nuance_json = {'code': nuance.code, 'nom': nuance.nom, 'couleur': nuance.couleur}
             nuances_json.append(nuance_json)
 
         file = DATA_DIR / "resultats" / "europeennes" / "2024" / "nuances.json"
@@ -54,25 +46,13 @@ def exporter_listes(engine: Engine, verbose: bool = False) -> None:
 
         for liste in listes:
             candidats = [
-                {
-                    'ordre': candidat.ordre,
-                    'nom': candidat.nom,
-                    'prenom': candidat.prenom,
-                    'sexe': candidat.sexe.value,
-                    'date_naissance': candidat.date_naissance.isoformat(),
-                    'profession': candidat.profession,
-                    'code_personnalite': candidat.code_personnalite.value,
-                    'sortant': candidat.sortant
-                }
+                {'ordre': candidat.ordre, 'nom': candidat.nom, 'prenom': candidat.prenom, 'sexe': candidat.sexe.value,
+                 'date_naissance': candidat.date_naissance.isoformat(), 'profession': candidat.profession,
+                 'code_personnalite': candidat.code_personnalite.value, 'sortant': candidat.sortant}
                 for candidat in liste.candidats
             ]
-            liste_json = {
-                'numero': liste.numero,
-                'nom': liste.nom,
-                'nuance': liste.nuance_id,
-                'bloc': liste.bloc.nom,
-                'candidats': candidats,
-            }
+            liste_json = {'numero': liste.numero, 'nom': liste.nom, 'nuance': liste.nuance_id,
+                          'bloc': liste.bloc.nom, 'candidats': candidats}
             listes_json.append(liste_json)
 
         file = DATA_DIR / "resultats" / "europeennes" / "2024" / "listes.json"
@@ -91,21 +71,20 @@ def exporter_resultats_france(engine: Engine, verbose: bool = False) -> None:
             session.add(resultats_france)
 
         resultats_dict = {
-            'zone': {
-                'type': "france",
+            'france': {
                 'regions': [reg.code_insee for reg in session.execute(select(Region)).scalars().all()],
                 'departements': [dpt.code_insee for dpt in session.execute(select(Departement)).scalars().all()],
                 'circonscriptions': [circo.id for circo in session.execute(select(Circonscription)).scalars().all()],
-                'geometry': {},
             },
-            'tour1': {
-                'inscrits': resultats_france.inscrits,
-                'votants': resultats_france.votants,
-                'abstentions': resultats_france.abstentions,
-                'exprimes': resultats_france.exprimes,
-                'blancs': resultats_france.blancs,
-                'nuls': resultats_france.nuls,
+            "tour1": {
+                "inscrits": resultats_france.inscrits,
+                "votants": resultats_france.votants,
+                "abstentions": resultats_france.abstentions,
+                "exprimes": resultats_france.exprimes,
+                "blancs": resultats_france.blancs,
+                "nuls": resultats_france.nuls,
             },
+            'geometry': {},
         }
 
         resultats_listes = {}
@@ -130,17 +109,12 @@ def exporter_resultats_regions(engine: Engine, verbose: bool = False) -> None:
 
         regions_iterator = tqdm(regions, desc="Régions") if verbose else regions
         for region in regions_iterator:
-            region_json = {
-                'type': "region",
-                'code_insee': region.code_insee, 'nom': region.libelle,
-                'departements': [dpt.code_insee for dpt in region.departements],
-                'circonscriptions': [
-                    circo.id for circo in session.execute(
-                        select(Circonscription).join(Departement).filter_by(region_code=region.code_insee))
-                    .scalars().all()
-                ],
-                'geometry': region.geometry,
-            }
+            region_json = {'code_insee': region.code_insee, 'nom': region.libelle,
+                           'departements': [dpt.code_insee for dpt in region.departements],
+                           'circonscriptions':
+                               [circo.id for circo in session.execute(
+                                   select(Circonscription).join(Departement).filter_by(region_code=region.code_insee))
+                                .scalars().all()]}
             regions_json.append(region_json)
 
             resultats_region = session.execute(select(ResultatsRegionEuropeennes2024)
@@ -152,7 +126,7 @@ def exporter_resultats_regions(engine: Engine, verbose: bool = False) -> None:
                 session.add(resultats_region)
 
             resultats_dict = {
-                'zone': region_json,
+                'region': region_json,
                 'tour1': {
                     'inscrits': resultats_region.inscrits,
                     'votants': resultats_region.votants,
@@ -161,6 +135,7 @@ def exporter_resultats_regions(engine: Engine, verbose: bool = False) -> None:
                     'blancs': resultats_region.blancs,
                     'nuls': resultats_region.nuls,
                 },
+                'geometry': region.geometry,
             }
 
             resultats_listes = {}
@@ -192,15 +167,10 @@ def exporter_resultats_departements(engine: Engine, verbose: bool = False) -> No
 
         iterator = tqdm(departements, desc="Départements") if verbose else departements
         for departement in iterator:
-            departement_json = {
-                'type': "departement",
-                'code_insee': departement.code_insee,
-                'nom': departement.libelle,
-                'region': departement.region_code,
-                'circonscriptions': [circo.id for circo in departement.circonscriptions],
-                'communes': [commune.code_insee for commune in departement.communes],
-                'geometry': departement.geometry,
-            }
+            departement_json = {'code_insee': departement.code_insee, 'nom': departement.libelle,
+                                'region': departement.region_code,
+                                'circonscriptions': [circo.id for circo in departement.circonscriptions],
+                                'communes': [commune.code_insee for commune in departement.communes]}
             departements_json.append(departement_json)
 
             resultats_departement = session.execute(
@@ -214,7 +184,7 @@ def exporter_resultats_departements(engine: Engine, verbose: bool = False) -> No
                 session.add(resultats_departement)
 
             resultats_dict = {
-                'zone': departement_json,
+                'departement': departement_json,
                 'tour1': {
                     'inscrits': resultats_departement.inscrits,
                     'votants': resultats_departement.votants,
@@ -223,6 +193,7 @@ def exporter_resultats_departements(engine: Engine, verbose: bool = False) -> No
                     'blancs': resultats_departement.blancs,
                     'nuls': resultats_departement.nuls,
                 },
+                'geometry': departement.geometry,
             }
 
             resultats_listes = {}
@@ -254,14 +225,9 @@ def exporter_resultats_circonscriptions(engine: Engine, verbose: bool = False) -
 
         iterator = tqdm(circonscriptions, desc="Circonscriptions") if verbose else circonscriptions
         for circonscription in iterator:
-            circonscription_json = {
-                'type': "circonscription",
-                'id': circonscription.id,
-                'departement': circonscription.departement_code,
-                'numero': circonscription.numero,
-                'bureaux_vote': [bv.id for bv in circonscription.bureaux_vote],
-                'geometry': circonscription.geometry,
-            }
+            circonscription_json = {'id': circonscription.id, 'departement': circonscription.departement_code,
+                                    'numero': circonscription.numero,
+                                    'bureaux_vote': [bv.id for bv in circonscription.bureaux_vote]}
             circonscriptions_json.append(circonscription_json)
 
             resultats_circonscription = session.execute(
@@ -276,7 +242,7 @@ def exporter_resultats_circonscriptions(engine: Engine, verbose: bool = False) -
                 session.add(resultats_circonscription)
 
             resultats_dict = {
-                'zone': circonscription_json,
+                'circonscription': circonscription_json,
                 'tour1': {
                     'inscrits': resultats_circonscription.inscrits,
                     'votants': resultats_circonscription.votants,
@@ -285,6 +251,7 @@ def exporter_resultats_circonscriptions(engine: Engine, verbose: bool = False) -
                     'blancs': resultats_circonscription.blancs,
                     'nuls': resultats_circonscription.nuls,
                 },
+                'geometry': circonscription.geometry,
             }
 
             resultats_listes = {}
@@ -317,14 +284,9 @@ def exporter_resultats_communes(engine: Engine, verbose: bool = False) -> None:
 
         iterator = tqdm(communes, desc="Communes") if verbose else communes
         for commune in iterator:
-            commune_json = {
-                'type': "commune",
-                'code_insee': commune.code_insee,
-                'nom': commune.libelle,
-                'departement': commune.departement_code,
-                'bureaux_vote': [bv.id for bv in commune.bureaux_vote],
-                'geometry': commune.geometry,
-            }
+            commune_json = {'code_insee': commune.code_insee, 'nom': commune.libelle,
+                            'departement': commune.departement_code,
+                            'bureaux_vote': [bv.id for bv in commune.bureaux_vote]}
             communes_json.append(commune_json)
 
             resultats_commune = session.execute(
@@ -337,7 +299,7 @@ def exporter_resultats_communes(engine: Engine, verbose: bool = False) -> None:
                 session.add(resultats_commune)
 
             resultats_dict = {
-                'zone': commune_json,
+                'commune': commune_json,
                 'tour1': {
                     'inscrits': resultats_commune.inscrits,
                     'votants': resultats_commune.votants,
@@ -346,6 +308,7 @@ def exporter_resultats_communes(engine: Engine, verbose: bool = False) -> None:
                     'blancs': resultats_commune.blancs,
                     'nuls': resultats_commune.nuls,
                 },
+                'geometry': commune.geometry,
             }
 
             resultats_listes = {}
@@ -377,14 +340,10 @@ def exporter_resultats_bureaux_vote(engine: Engine, verbose: bool = False) -> No
 
         iterator = tqdm(bureaux_vote, desc="Bureaux de vote") if verbose else bureaux_vote
         for bureau_vote in iterator:
-            bureau_vote_json = {
-                'type': "bureau_vote",
-                'id': bureau_vote.id,
-                'libelle': bureau_vote.libelle,
-                'commune': bureau_vote.commune_code,
-                'circonscription': bureau_vote.circo_code,
-                'geometry': bureau_vote.geometry,
-            }
+            bureau_vote_json = {'id': bureau_vote.id,
+                                'libelle': bureau_vote.libelle,
+                                'commune': bureau_vote.commune_code,
+                                'circonscription': bureau_vote.circo_code}
             bureaux_vote_json.append(bureau_vote_json)
 
             resultats_bureau_vote = session.execute(
@@ -397,7 +356,7 @@ def exporter_resultats_bureaux_vote(engine: Engine, verbose: bool = False) -> No
                 session.add(resultats_bureau_vote)
 
             resultats_dict = {
-                'zone': bureau_vote_json,
+                'bureau_vote': bureau_vote_json,
                 'tour1': {
                     'inscrits': resultats_bureau_vote.inscrits,
                     'votants': resultats_bureau_vote.votants,
@@ -406,6 +365,7 @@ def exporter_resultats_bureaux_vote(engine: Engine, verbose: bool = False) -> No
                     'blancs': resultats_bureau_vote.blancs,
                     'nuls': resultats_bureau_vote.nuls,
                 },
+                'geometry': bureau_vote.geometry,
             }
 
             resultats_listes = {}

nupes/scripts/legislatives2022/export_resultats.py

@@ -8,7 +8,7 @@ from tqdm import tqdm
 from nupes.models.geographie import BureauVote
 from nupes.models.legislatives2022 import *
 
-DATA_DIR = Path(__file__).parent.parent.parent.parent / 'data'
+DATA_DIR = Path(__file__).parent.parent.parent / 'data'
 
 
 def exporter_nuances(engine: Engine, verbose: bool = False) -> None:
@@ -77,12 +77,10 @@ def exporter_resultats_france(engine: Engine, verbose: bool = False) -> None:
             session.add(resultats_france)
 
         resultats_dict = {
-            'zone': {
-                'type': "france",
+            'france': {
                 'regions': [reg.code_insee for reg in session.execute(select(Region)).scalars().all()],
                 'departements': [dpt.code_insee for dpt in session.execute(select(Departement)).scalars().all()],
                 'circonscriptions': [circo.id for circo in session.execute(select(Circonscription)).scalars().all()],
-                'geometry': {},
             },
             'tour1': {
                 'inscrits': resultats_france.inscrits_t1,
@@ -100,6 +98,7 @@ def exporter_resultats_france(engine: Engine, verbose: bool = False) -> None:
                 'blancs': resultats_france.blancs_t2,
                 'nuls': resultats_france.nuls_t2,
             },
+            'geometry': {},
         }
 
         resultats_t1, resultats_t2 = {}, {}
@@ -126,18 +125,12 @@ def exporter_resultats_regions(engine: Engine, verbose: bool = False) -> None:
 
         regions_iterator = tqdm(regions, desc="Régions") if verbose else regions
         for region in regions_iterator:
-            region_json = {
-                'type': "region",
-                'code_insee': region.code_insee,
-                'nom': region.libelle,
-                'departements': [dpt.code_insee for dpt in region.departements],
-                'circonscriptions': [
-                    circo.id for circo in session.execute(
-                        select(Circonscription).join(Departement).filter_by(region_code=region.code_insee))
-                    .scalars().all()
-                ],
-                'geometry': region.geometry,
-            }
+            region_json = {'code_insee': region.code_insee, 'nom': region.libelle,
+                           'departements': [dpt.code_insee for dpt in region.departements],
+                           'circonscriptions':
+                               [circo.id for circo in session.execute(
+                                   select(Circonscription).join(Departement).filter_by(region_code=region.code_insee))
+                                .scalars().all()]}
             regions_json.append(region_json)
 
             resultats_region = session.execute(select(ResultatsRegionLegislatives2022)
@@ -149,7 +142,7 @@ def exporter_resultats_regions(engine: Engine, verbose: bool = False) -> None:
                 session.add(resultats_region)
 
             resultats_dict = {
-                'zone': region_json,
+                'region': region_json,
                 'tour1': {
                     'inscrits': resultats_region.inscrits_t1,
                     'votants': resultats_region.votants_t1,
@@ -166,6 +159,7 @@ def exporter_resultats_regions(engine: Engine, verbose: bool = False) -> None:
                     'blancs': resultats_region.blancs_t2,
                     'nuls': resultats_region.nuls_t2,
                 },
+                'geometry': region.geometry,
             }
 
             resultats_t1, resultats_t2 = {}, {}
@@ -199,15 +193,10 @@ def exporter_resultats_departements(engine: Engine, verbose: bool = False) -> No
 
         iterator = tqdm(departements, desc="Départements") if verbose else departements
         for departement in iterator:
-            departement_json = {
-                'type': "departement",
-                'code_insee': departement.code_insee,
-                'nom': departement.libelle,
-                'region': departement.region_code,
-                'circonscriptions': [circo.id for circo in departement.circonscriptions],
-                'communes': [commune.code_insee for commune in departement.communes],
-                'geometry': departement.geometry,
-            }
+            departement_json = {'code_insee': departement.code_insee, 'nom': departement.libelle,
+                                'region': departement.region_code,
+                                'circonscriptions': [circo.id for circo in departement.circonscriptions],
+                                'communes': [commune.code_insee for commune in departement.communes]}
             departements_json.append(departement_json)
 
             resultats_departement = session.execute(
@@ -221,7 +210,7 @@ def exporter_resultats_departements(engine: Engine, verbose: bool = False) -> No
                 session.add(resultats_departement)
 
             resultats_dict = {
-                'zone': departement_json,
+                'departement': departement_json,
                 'tour1': {
                     'inscrits': resultats_departement.inscrits_t1,
                     'votants': resultats_departement.votants_t1,
@@ -238,6 +227,7 @@ def exporter_resultats_departements(engine: Engine, verbose: bool = False) -> No
                     'blancs': resultats_departement.blancs_t2,
                     'nuls': resultats_departement.nuls_t2,
                 },
+                'geometry': departement.geometry,
             }
 
             resultats_t1, resultats_t2 = {}, {}
@@ -271,14 +261,9 @@ def exporter_resultats_circonscriptions(engine: Engine, verbose: bool = False) -
 
         iterator = tqdm(circonscriptions, desc="Circonscriptions") if verbose else circonscriptions
         for circonscription in iterator:
-            circonscription_json = {
-                'type': "circonscription",
-                'id': circonscription.id,
-                'departement': circonscription.departement_code,
-                'numero': circonscription.numero,
-                'bureaux_vote': [bv.id for bv in circonscription.bureaux_vote],
-                'geometry': circonscription.geometry,
-            }
+            circonscription_json = {'id': circonscription.id, 'departement': circonscription.departement_code,
+                                    'numero': circonscription.numero,
+                                    'bureaux_vote': [bv.id for bv in circonscription.bureaux_vote]}
             circonscriptions_json.append(circonscription_json)
 
             resultats_circonscription = session.execute(
@@ -293,7 +278,7 @@ def exporter_resultats_circonscriptions(engine: Engine, verbose: bool = False) -
                 session.add(resultats_circonscription)
 
             resultats_dict = {
-                'zone': circonscription_json,
+                'circonscription': circonscription_json,
                 'tour1': {
                     'inscrits': resultats_circonscription.inscrits_t1,
                     'votants': resultats_circonscription.votants_t1,
@@ -310,6 +295,7 @@ def exporter_resultats_circonscriptions(engine: Engine, verbose: bool = False) -
                     'blancs': resultats_circonscription.blancs_t2,
                     'nuls': resultats_circonscription.nuls_t2,
                 },
+                'geometry': circonscription.geometry,
             }
 
             resultats_t1, resultats_t2 = {}, {}
@@ -344,14 +330,9 @@ def exporter_resultats_communes(engine: Engine, verbose: bool = False) -> None:
 
         iterator = tqdm(communes, desc="Communes") if verbose else communes
         for commune in iterator:
-            commune_json = {
-                'type': "commune",
-                'code_insee': commune.code_insee,
-                'nom': commune.libelle,
-                'departement': commune.departement_code,
-                'bureaux_vote': [bv.id for bv in commune.bureaux_vote],
-                'geometry': commune.geometry,
-            }
+            commune_json = {'code_insee': commune.code_insee, 'nom': commune.libelle,
+                            'departement': commune.departement_code,
+                            'bureaux_vote': [bv.id for bv in commune.bureaux_vote]}
             communes_json.append(commune_json)
 
             resultats_commune = session.execute(
@@ -364,7 +345,7 @@ def exporter_resultats_communes(engine: Engine, verbose: bool = False) -> None:
                 session.add(resultats_commune)
 
             resultats_dict = {
-                'zone': commune_json,
+                'commune': commune_json,
                 'tour1': {
                     'inscrits': resultats_commune.inscrits_t1,
                     'votants': resultats_commune.votants_t1,
@@ -381,6 +362,7 @@ def exporter_resultats_communes(engine: Engine, verbose: bool = False) -> None:
                     'blancs': resultats_commune.blancs_t2,
                     'nuls': resultats_commune.nuls_t2,
                 },
+                'geometry': commune.geometry,
             }
 
             resultats_t1, resultats_t2 = {}, {}
@@ -414,14 +396,10 @@ def exporter_resultats_bureaux_vote(engine: Engine, verbose: bool = False) -> No
 
         iterator = tqdm(bureaux_vote, desc="Bureaux de vote") if verbose else bureaux_vote
         for bureau_vote in iterator:
-            bureau_vote_json = {
-                'type': "bureau_vote",
-                'id': bureau_vote.id,
-                'libelle': bureau_vote.libelle,
-                'commune': bureau_vote.commune_code,
-                'circonscription': bureau_vote.circo_code,
-                'geometry': bureau_vote.geometry,
-            }
+            bureau_vote_json = {'id': bureau_vote.id,
+                                'libelle': bureau_vote.libelle,
+                                'commune': bureau_vote.commune_code,
+                                'circonscription': bureau_vote.circo_code}
             bureaux_vote_json.append(bureau_vote_json)
 
             resultats_bureau_vote = session.execute(
@@ -434,7 +412,7 @@ def exporter_resultats_bureaux_vote(engine: Engine, verbose: bool = False) -> No
                 session.add(resultats_bureau_vote)
 
             resultats_dict = {
-                'zone': bureau_vote_json,
+                'bureau_vote': bureau_vote_json,
                 'tour1': {
                     'inscrits': resultats_bureau_vote.inscrits_t1,
                     'votants': resultats_bureau_vote.votants_t1,
@@ -451,6 +429,7 @@ def exporter_resultats_bureaux_vote(engine: Engine, verbose: bool = False) -> No
                     'blancs': resultats_bureau_vote.blancs_t2,
                     'nuls': resultats_bureau_vote.nuls_t2,
                 },
+                'geometry': bureau_vote.geometry,
             }
 
             resultats_t1, resultats_t2 = {}, {}

nupes/scripts/legislatives2022/import_resultats.py

@@ -123,12 +123,12 @@ def importer_resultats_bv(engine: Engine, verbose: bool = False) -> None:
                                                        .filter_by(bv_id=bv_id)).scalar_one()
 
                     if tour == 1:
-                        resultats_bv.inscrits_t1 = int(row[7])
-                        resultats_bv.votants_t1 = int(row[10])
-                        resultats_bv.abstentions_t1 = int(row[8])
-                        resultats_bv.exprimes_t1 = int(row[18])
-                        resultats_bv.blancs_t1 = int(row[12])
-                        resultats_bv.nuls_t1 = int(row[15])
+                        resultats_bv.inscrits_t1 = int(row[5])
+                        resultats_bv.votants_t1 = int(row[8])
+                        resultats_bv.abstentions_t1 = int(row[6])
+                        resultats_bv.exprimes_t1 = int(row[16])
+                        resultats_bv.blancs_t1 = int(row[10])
+                        resultats_bv.nuls_t1 = int(row[13])
                     elif tour == 2:
                         resultats_bv.inscrits_t2 = int(row[5])
                         resultats_bv.votants_t2 = int(row[8])
@@ -137,10 +137,10 @@ def importer_resultats_bv(engine: Engine, verbose: bool = False) -> None:
                         resultats_bv.blancs_t2 = int(row[10])
                         resultats_bv.nuls_t2 = int(row[13])
 
-                    row_voix = row[21:]
+                    row_voix = row[19:]
 
-                    for i in range(len(row_voix) // 8):
-                        bloc_voix = row_voix[i * 8:(i + 1) * 8]
+                    for i in range(len(row_voix) // 9):
+                        bloc_voix = row_voix[i * 9:(i + 1) * 9]
                         numero = bloc_voix[0]
                         voix = int(bloc_voix[5])