Rechercher dans les propriétés de la page

Cette page fournit une interface de navigation pour trouver toutes les valeurs d’une propriété et une page donnée. D’autres interfaces de recherche disponibles incluent la recherche de propriété, et le constructeur de requête ask.

Liste de résultats

<nowiki>import requests & … import requests

from bs4 import BeautifulSoup

class AQIRepository:

URL = "https://www.atmo-nouvelleaquitaine.org/air-commune/Bordeaux/33063/indice-atmo?date=2025-10-14"

def __init__(self):

self.cat_to_conc = {

'Bon': {'PM2.5': 5.0, 'PM10': 15.0, 'O3': 0.040, 'NO2': 20.0, 'SO2': 5.0},

'Moyen': {'PM2.5': 20.0, 'PM10': 40.0, 'O3': 0.060, 'NO2': 60.0, 'SO2': 20.0},

'Mauvais':{'PM2.5': 40.0, 'PM10': 100.0,'O3': 0.100, 'NO2': 150.0,'SO2': 100.0},

'Très mauvais':{'PM2.5':120.0,'PM10':300.0,'O3':0.180,'NO2':800.0,'SO2':500.0}

}

self.breakpoints = {

'PM2.5': [(0.0,12.0,0,50),(12.1,35.4,51,100),(35.5,55.4,101,150),(55.5,150.4,151,200)],

'PM10': [(0,54,0,50),(55,154,51,100),(155,254,101,150),(255,354,151,200)],

'O3': [(0.000,0.054,0,50),(0.055,0.070,51,100),(0.071,0.085,101,150)],

'NO2': [(0,53,0,50),(54,100,51,100),(101,360,101,150),(361,649,151,200)],

'SO2': [(0,35,0,50),(36,75,51,100),(76,185,101,150),(186,304,151,200)],

}

def linear_scale(self, C, C_low, C_high, I_low, I_high):

return round((I_high - I_low) / (C_high - C_low) * (C - C_low) + I_low)

def find_aqi_subindex(self, C, pollutant):

for (C_low, C_high, I_low, I_high) in self.breakpoints[pollutant]:

if C_low <= C <= C_high:

return self.linear_scale(C, C_low, C_high, I_low, I_high)

return None

def scrape_categories(self):

response = requests.get(self.URL, timeout=10)

soup = BeautifulSoup(response.text, "html.parser")

categories = {}

blocks = soup.select(".c-indice-polluant")

for block in blocks:

title_tag = block.select_one(".c-indice-polluant-title span")

cat_tag = block.select_one(".home-map-legend-item span")

if title_tag and cat_tag:

name = title_tag.get_text(strip=True).replace("₂", "2").replace("₃", "3")

cat = cat_tag.get_text(strip=True)

categories[name] = cat

return categories

def compute_aqi(self, categories):

concentrations = {k: self.cat_to_conc[v][k] for k, v in categories.items() if k in self.cat_to_conc[v]}

subindices = {k: self.find_aqi_subindex(concentrations[k], k) for k in concentrations}

aqi_global = max(v for v in subindices.values() if v is not None)

return aqi_global, subindices

import requests

class MeteoRepository:

def __init__(self, latitude=44.8378, longitude=-0.5792):

self.latitude = latitude

self.longitude = longitude

self.api_url = (

"https://api.open-meteo.com/v1/forecast?"

f"latitude={self.latitude}&longitude={self.longitude}"

"&hourly=temperature_2m,precipitation,weathercode"

"¤t_weather=true&timezone=Europe%2FParis"

)

def get_weather(self):

response = requests.get(self.api_url, timeout=10)

data = response.json()

return data.get("current_weather", {})

def compute_weather_score(self, weather):

wmo_scores = {

0: 100, 1: 90, 2: 80, 3: 70, 45: 60, 48: 55,

51: 50, 53: 45, 55: 40, 61: 35, 63: 25, 65: 15,

71: 25, 73: 15, 75: 5, 95: 10, 99: 0,

}

temp = weather.get("temperature", 20)

wind = weather.get("windspeed", 10)

code = weather.get("weathercode", 0)

base_score = wmo_scores.get(code, 60)

if temp < 0:

temp_penalty = 30

elif temp < 10:

temp_penalty = 15

elif temp > 30:

temp_penalty = 20

else:

temp_penalty = 0

wind_penalty = 0

if wind > 40:

wind_penalty = 20

elif wind > 25:

wind_penalty = 10

score = base_score - temp_penalty - wind_penalty

return round(max(0, min(100, score)))

import requests

import json

class TrafficRepository:

BASE_URL = "https://data.bordeaux-metropole.fr/geojson"

def __init__(self, api_key="2HH8S7FKPP", typename="ci_trafi_l"):

self.api_key = api_key

self.typename = typename

def get_traffic_by_gid(self, gid=2215):

params = {

"key": self.api_key,

"typename": self.typename,

"filter": json.dumps({"gid": gid}),

}

response = requests.get(self.BASE_URL, params=params, timeout=10)

if response.status_code != 200:

raise Exception(f"Erreur API {response.status_code} : {response.text}")

return response.json()

def compute_traffic_score(self, traffic_data):

features = traffic_data.get("features", [])

if not features:

return 50

props = features[0].get("properties", {})

etat = props.get("etat_trafic") or props.get("etat") or "INCONNU"

mapping = {"FLUIDE": 100, "RALENTI": 70, "EMBOUTEILLE": 30, "INCONNU": 50}

return mapping.get(etat.upper(), 50)

import requests

import json

from datetime import datetime, timezone

class TbmRepository:

BASE_URL = "https://data.bordeaux-metropole.fr/geojson"

def __init__(self, api_key="2HH8S7FKPP", arret_id=4037):

self.api_key = api_key

self.arret_id = arret_id

def get_next_tram(self, max_results=100):

params = {

"key": self.api_key,

"typename": "sv_horai_a",

"filter": json.dumps({"rs_sv_arret_p": self.arret_id}),

"orderby": json.dumps(["hor_theo"]),

"maxfeatures": max_results

}

response = requests.get(self.BASE_URL, params=params)

response.raise_for_status()

data = response.json()

now = datetime.now(timezone.utc)

for feature in data.get("features", []):

props = feature.get("properties", {})

hor_theo = props.get("hor_theo")

if not hor_theo:

continue

try:

tram_time = datetime.fromisoformat(hor_theo)

except ValueError:

continue

if tram_time > now:

diff_sec = int((tram_time - now).total_seconds())

return {"heure": tram_time, "seconds": diff_sec, "etat": props.get("etat"), "type": props.get("type")}

return None

from AQIRepository import AQIRepository

from MeteoRepository import MeteoRepository

from TrafficRepository import TrafficRepository

from TramRepository import TbmRepository

from fastapi import FastAPI

app = FastAPI()

@app.get("/")

def read_root():

longitude = -0.5935101

latitude = 44.8538665

borneTraficGID = 2215

Aqirepo = AQIRepository()

categories = Aqirepo.scrape_categories()

aqi, details = Aqirepo.compute_aqi(categories)

meteo = MeteoRepository(latitude=latitude, longitude=longitude)

weather = meteo.get_weather()

score_M = meteo.compute_weather_score(weather)

traffic = TrafficRepository()

data = traffic.get_traffic_by_gid(borneTraficGID)

score_T = traffic.compute_traffic_score(data)

tbm = TbmRepository(arret_id=4037)

prochain = tbm.get_next_tram()

if prochain and 'seconds' in prochain:

TP_seconds = prochain['seconds']

else:

TP_seconds = 3600

max_tp_seconds = 3600

TP_score = max(0, min(100, 100 - (TP_seconds / max_tp_seconds) * 100))

IMR = (

0.4 * (100 - aqi) +

0.3 * (100 - score_T) +

0.2 * TP_score +

0.1 * score_M

)

return {"IMR": round(IMR, 1)}

e(data) tbm = TbmRepository(arret_id=4037) prochain = tbm.get_next_tram() if prochain and 'seconds' in prochain: TP_seconds = prochain['seconds'] else: TP_seconds = 3600 max_tp_seconds = 3600 TP_score = max(0, min(100, 100 - (TP_seconds / max_tp_seconds) * 100)) IMR = ( 0.4 * (100 - aqi) + 0.3 * (100 - score_T) + 0.2 * TP_score + 0.1 * score_M ) return {"IMR": round(IMR, 1)} </nowiki>
Analyse des sources disponibles sur les sites de TBM et de Bordeaux Métropole pour identifier les bénéfices environnementaux du tramway et du réseau de bus. +
Bois, LED, papier transparent, éléments imprimés en 3D, ainsi que des cartes électroniques(Arduino ) pour la rotation et l’éclairage des LED. +
Chaque participant partage sa compréhension du thème. Toutes les idées et les mots-clés sont ensuite notés et organisés sous forme de schéma. +
Conception d’une machine capable d’analyser la qualité de l’air et le trafic, afin de proposer le meilleur moyen de transport entre bus, tram, voiture ou taxi. +