xiaofanglegoc/TC3_serveur.txt

## TC3_serveur.txt
# ==================== Q2-1.py===========================
import http.server
import socketserver

httpd = socketserver.TCPServer(("", 8080),http.server.SimpleHTTPRequestHandler)

httpd.serve_forever()

# ==================== END ===========================


# ====================  TD2/Q3-1.py===========================
# TD2/Q3-1.py

import http.server
import socketserver

# définition du nouveau handler
class RequestHandler(http.server.SimpleHTTPRequestHandler):

  # sous-répertoire racine des documents statiques
  static_dir = '/client'

  # on surcharge la méthode qui traite les requêtes GET
  def do_GET(self):

    # on modifie le chemin d'accès en insérant un répertoire préfixe
    self.path = self.static_dir + self.path

    # on traite la requête via la classe parent
    http.server.SimpleHTTPRequestHandler.do_GET(self)

# instanciation et lancement du serveur
httpd = socketserver.TCPServer(("", 8080), RequestHandler)
httpd.serve_forever()

# ==================== END ===========================

# ====================  TD2/Q4-1.py===========================
# TD2/Q4-1.py

import http.server
import socketserver
import os

#
# Définition du nouveau handler
#
class RequestHandler(http.server.SimpleHTTPRequestHandler):

  # sous-répertoire racine des documents statiques
  static_dir = '/client'

  # on utilise le nom de fichier pour identifier le serveur
  server_version = 'TD2/'+os.path.basename(__file__)+'/0.1'

  #
  # On surcharge la méthode qui traite les requêtes GET
  #
  def do_GET(self):

    # le chemin d'accès commence par /time
    if self.path.startswith('/time'):
      self.send_time()

    # ou pas...
    else:
      self.send_static()

  #
  # On surcharge la méthode qui traite les requêtes HEAD
  #
  def do_HEAD(self):
    self.send_static()

  #
  # On envoie le document statique demandé
  #
  def send_static(self):

    # on modifie le chemin d'accès en insérant un répertoire préfixe
    self.path = self.static_dir + self.path

    # on calcule le nom de la méthode parent à appeler (do_GET ou do_HEAD)
    # à partir du verbe HTTP (GET ou HEAD)
    method = 'do_{}'.format(self.command)

    # on traite la requête via la classe parent
    getattr(http.server.SimpleHTTPRequestHandler,method)(self)


  #
  # On envoie un document avec l'heure
  #
  def send_time(self):

    # on récupère l'heure
    time = self.date_time_string()

    # on génère un document au format html
    body = '<!doctype html>' + \
           '<meta charset="utf-8">' + \
           '<title>l\'heure</title>' + \
           '<div>Voici l\'heure du serveur :</div>' + \
           '<pre>{}</pre>'.format(time)

    # pour prévenir qu'il s'agit d'une ressource au format html
    headers = [('Content-Type','text/html;charset=utf-8')]

    # on envoie
    self.send(body,headers)


  #
  # On envoie les entêtes et le corps fourni
  #
  def send(self,body,headers=[]):

    # on encode la chaine de caractères à envoyer
    encoded = bytes(body, 'UTF-8')

    # on envoie la ligne de statut
    self.send_response(200)

    # on envoie les lignes d'entête et la ligne vide
    [self.send_header(*t) for t in headers]
    self.send_header('Content-Length',int(len(encoded)))
    self.end_headers()

    # on envoie le corps de la réponse
    self.wfile.write(encoded)


#
# Instanciation et lancement du serveur
#
httpd = socketserver.TCPServer(("", 8080), RequestHandler)
httpd.serve_forever()


#======================================================================================
# # TD2/Q5-1.py

import http.server
import socketserver
import os

from urllib.parse import urlparse, parse_qs
from datetime import datetime
from pytz import timezone
import pytz

#
# Définition du nouveau handler
#
class RequestHandler(http.server.SimpleHTTPRequestHandler):

  # sous-répertoire racine des documents statiques
  static_dir = '/client'

  # on utilise le nom de fichier pour identifier le serveur
  server_version = 'TD2/'+os.path.basename(__file__)+'/0.1'


  #
  # On surcharge la méthode qui traite les requêtes GET
  #
  def do_GET(self):

    # on initialise nos variables d'instance
    self.init_vars()

    # le chemin d'accès commence par /time
    if self.path_info[0] == 'time':
      self.send_time()

    # ou pas...
    else:
      self.send_static()

  #
  # On surcharge la méthode qui traite les requêtes HEAD
  #
  def do_HEAD(self):
    self.send_static()

  #
  # On surcharge la méthode qui traite les requêtes GET
  #
  def do_POST(self):

    # on initialise nos variables d'instance
    self.init_vars()

    # le chemin d'accès commence par /time
    if self.path_info[0] == 'time':
      self.send_time()

    # ou pas...
    else:
      self.send_error(501,'Unsupported method (\'POST\')')

  #
  # On initialise les variables d'instance
  #
  def init_vars(self):
    # analyse de l'adresse
    info = urlparse(self.path)
    self.path_info = info.path.split('/')[1:]
    self.query_string = info.query
    self.params = parse_qs(info.query)
    print(self.path_info);

    # récupération du corps
    length = self.headers.get('Content-Length')
    ctype = self.headers.get('Content-Type')
    if length:
      self.body = str(self.rfile.read(int(length)),'utf-8')
      if ctype == 'application/x-www-form-urlencoded' :
        self.params = parse_qs(self.body)

    print(length,ctype,self.params)


  #
  # On envoie le document statique demandé
  #
  def send_static(self):

    # on modifie le chemin d'accès en insérant un répertoire préfixe
    self.path = self.static_dir + self.path

    # on calcule le nom de la méthode parent à appeler (do_GET ou do_HEAD)
    # à partir du verbe HTTP (GET ou HEAD)
    method = 'do_{}'.format(self.command)

    # on traite la requête via la classe parent
    getattr(http.server.SimpleHTTPRequestHandler,method)(self)

  #
  # On envoie un document avec l'heure
  #
  def send_time(self):

    # on récupère le fuseau horaire demandé
    if len(self.path_info) > 1:
      tz_name = '/'.join(self.path_info[1:])
    elif 'timezone' in self.params.keys():
      tz_name = self.params['timezone'][0]
    else:
      self.send_error(400,'No Time Zone')
      return

    try:
      tz = timezone(tz_name)
    except(pytz.exceptions.UnknownTimeZoneError):
      self.send_error(400,'Unknown Time Zone')
      return

    # on récupère la date et l'heure
    time = datetime.utcnow()

    # on convertit vers le fuseau demandé
    tz_time = tz.normalize(pytz.utc.localize(time).astimezone(tz))

    # on génère un document
    body = '<!doctype html>' + \
           '<meta charset="utf-8">' + \
           '<title>l\'heure dans le fuseau {}</title>'.format(tz_name) + \
           '<pre>Voici la date et l\'heure UTC du serveur :\n\n' + \
           '{}\n\n'.format(time) + \
           'Dans le fuseau {} il est :\n\n'.format(tz_name) + \
           '{}</pre>'.format(tz_time)

    # on envoie
    headers = [('Content-Type','text/html;charset=utf-8')]
    self.send(body,headers)


  #
  # On envoie les entêtes et le corps fourni
  #
  def send(self,body,headers=[]):

    # on encode la chaine de caractères à envoyer
    encoded = bytes(body, 'UTF-8')

    # on envoie la ligne de statut
    self.send_response(200)

    # on envoie les lignes d'entête et la ligne vide
    [self.send_header(*t) for t in headers]
    self.send_header('Content-Length',int(len(encoded)))
    self.end_headers()

    # on envoie le corps de la réponse
    self.wfile.write(encoded)


#
# Instanciation et lancement du serveur
#
httpd = socketserver.TCPServer(("", 8080), RequestHandler)
httpd.serve_forever()
#======================================================================================


# TD2/Q6-1.py

# pour le serveur web
import socketserver

# pour la gestion des noms de fichiers
import os

# pour l'accès base de données
import sqlite3


#
# Définition du nouveau handler
#
from server import generic

class RequestHandler(generic.RequestHandler):

  # on utilise le nom de fichier pour identifier le serveur
  server_version = 'TD2/'+os.path.basename(__file__)+'/0.1'


  #
  # On surcharge la méthode qui traite les requêtes GET
  #
  def do_GET(self):

    # on initialise nos variables d'instance
    self.init_vars()

    # le chemin d'accès commence par /lignes
    if self.path_info[0] == 'lignes':
      self.send_trains()

    # ou pas...
    else:
      self.send_static()


  #
  # On envoie un document avec la liste des lignes
  #
  def send_trains(self):

    conn = sqlite3.connect('sncf.sqlite')
    c = conn.cursor()
    c.execute("SELECT DISTINCT c.hexadecimal, p.code_ligne, p.nom_ligne " +\
              "FROM ponctualite_transilien AS p, couleur_transilien as c " +\
              "WHERE c.code_ligne = p.code_ligne " +\
              "ORDER BY p.code_ligne")
    r = c.fetchall()

    header = '<tr><td colspan=2>code</td><td>ligne</td><tr>'
    rows = ['<tr><td style="background-color: {}">&nbsp;</td><td>{}</td><td>{}</td></tr>'.format(*a) for a in r]
    html = '<table>{}\n{}</table>'.format(header,'\n'.join(rows))

    headers = [('Content-Type','text/html;charset=utf-8')]
    self.send(html,headers)


#
# Instanciation et lancement du serveur
#
httpd = socketserver.TCPServer(("", 8080), RequestHandler)
httpd.serve_forever()
#=====================================================================================================
# TD2/Q6-2.py

# pour le serveur web
import socketserver

# pour la gestion des noms de fichiers
import os

# pour l'accès base de données
import sqlite3

# pour le tracé graphique
import matplotlib.pyplot as plt
from random import random

# pour la fonction d'interpolation
import numpy as np
from scipy import interpolate


#
# Définition du nouveau handler
#
from server import generic

class RequestHandler(generic.RequestHandler):

  # on utilise le nom de fichier pour identifier le serveur
  server_version = 'TD2/'+os.path.basename(__file__)+'/0.1'


  #
  # On surcharge la méthode qui traite les requêtes GET
  #
  def do_GET(self):

    # on initialise nos variables d'instance
    self.init_vars()

    # le chemin d'accès commence par /lignes
    if self.path_info[0] == 'lignes':
      self.send_trains()

    # le chemin d'accès commence par /ponctualite/RER
    elif self.path_info[0] == 'ponctualite':
      self.send_ponctualite()

    # ou pas...
    else:
      self.send_static()


  #
  # On envoie un document avec la liste des lignes
  #
  def send_trains(self):

    conn = sqlite3.connect('sncf.sqlite')
    c = conn.cursor()
    c.execute("SELECT DISTINCT c.hexadecimal, p.code_ligne, p.nom_ligne " +\
              "FROM ponctualite_transilien AS p, couleur_transilien as c " +\
              "WHERE c.code_ligne = p.code_ligne " +\
              "ORDER BY p.code_ligne")
    r = c.fetchall()

    header = '<tr><td colspan=2>code</td><td>ligne</td><tr>'
    rows = ['<tr><td style="background-color: {}">&nbsp;</td><td>{}</td><td>{}</td></tr>'.format(*a) for a in r]
    html = '<table>{}\n{}</table>'.format(header,'\n'.join(rows))

    headers = [('Content-Type','text/html;charset=utf-8')]
    self.send(html,headers)


  #
  # On génère et on renvoie un graphique de ponctualite (cf. TD1)
  #
  def send_ponctualite(self):

    conn = sqlite3.connect('sncf.sqlite')
    c = conn.cursor()

    # liste des lignes de RER avec leur code couleur
    condition_code_ligne = ("= '{}'".format(self.path_info[2]) if len(self.path_info) > 2 else "LIKE '%'")
    c.execute("SELECT DISTINCT ponctualite_transilien.code_ligne, couleur_transilien.hexadecimal \
           FROM ponctualite_transilien, couleur_transilien \
           WHERE ponctualite_transilien.code_ligne = couleur_transilien.code_ligne \
           AND ponctualite_transilien.type_ligne = '{}' \
           AND ponctualite_transilien.code_ligne {} \
           ORDER BY ponctualite_transilien.code_ligne".format(self.path_info[1],condition_code_ligne))
    lignes = c.fetchall()

    # configuration du tracé
    plt.figure(figsize=(18,6))
    plt.ylim(65,100)
    plt.grid(True)

    # boucle sur les lignes
    for l in (lignes):
      c.execute("SELECT ponctualite_transilien.* \
               FROM ponctualite_transilien \
               WHERE ponctualite_transilien.code_ligne = ? \
               ORDER BY annee, mois",l[0])
      a = c.fetchall()

      # il y a une valeur manquante pour le RER B
      x = [n for n in range(len(a)) if not a[n][7] == '']
      y = [r[7] for r in a if not r[7] == '']

      # interpolation spline
      spl = interpolate.splrep(x, y, s=0)
      x2 = [n/10 for n in range(10*(len(a)-1)+1)]
      y2 = interpolate.splev(x2, spl, der=0)

      # tracé de la courbe de régularité
      plt.plot(x2,y2,linewidth=2,color=l[1], label=('RER ' if self.path_info[1] == 'RER' else 'ligne ')+l[0])
      plt.plot(x,y,linewidth=0,marker='s',markeredgecolor='w',markerfacecolor=l[1],markersize=10)

    # configuration du tracé (titre, grille)
    plt.grid(which='major', color='#888888', linestyle='-')
    plt.grid(which='minor',axis='x', color='#888888', linestyle=':')
    plt.title('Ponctualité des lignes {} (en %)'.format(self.path_info[1]),fontsize=16)

    # configuration de l'axe du temps
    mois = ['Jan','Fév','Mar','Avr', 'Mai', 'Juin', 'Juil', 'Août', 'Sept', 'Oct', 'Nov', 'Déc']
    xticks = [n*4 for n in range(int(len(a)/4))]
    xlabels = ['{} {}'.format(mois[r[2]-1], r[1]) for r in [a[t] for t in xticks]]

    plt.xlim(0,len(a)-1)
    ax = plt.subplot(111)
    ax.set_xticks(xticks)
    ax.set_xticks(x, minor=True)
    ax.set_xticklabels(xlabels, fontsize=12)

    # légende
    plt.legend(loc='lower left')

    fichier = 'courbe_ponctualite.png'
    plt.savefig('client/{}'.format(fichier))

    html = '<img src="{}?{}" alt="ponctualite {}" width="100%">'.format(fichier,random(),self.path_info[1])

    headers = [('Content-Type','text/html;charset=utf-8')]
    self.send(html,headers)

#
# Instanciation et lancement du serveur
#
httpd = socketserver.TCPServer(("", 8080), RequestHandler)
httpd.serve_forever()
#======================================
	# ==================== Q2-1.py===========================
	import http.server
	import socketserver

	httpd = socketserver.TCPServer(("", 8080),http.server.SimpleHTTPRequestHandler)

	httpd.serve_forever()

	# ==================== END ===========================


	# ==================== TD2/Q3-1.py===========================
	# TD2/Q3-1.py

	import http.server
	import socketserver

	# définition du nouveau handler
	class RequestHandler(http.server.SimpleHTTPRequestHandler):

	# sous-répertoire racine des documents statiques
	static_dir = '/client'

	# on surcharge la méthode qui traite les requêtes GET
	def do_GET(self):

	# on modifie le chemin d'accès en insérant un répertoire préfixe
	self.path = self.static_dir + self.path

	# on traite la requête via la classe parent
	http.server.SimpleHTTPRequestHandler.do_GET(self)

	# instanciation et lancement du serveur
	httpd = socketserver.TCPServer(("", 8080), RequestHandler)
	httpd.serve_forever()

	# ==================== END ===========================

	# ==================== TD2/Q4-1.py===========================
	# TD2/Q4-1.py

	import http.server
	import socketserver
	import os

	#
	# Définition du nouveau handler
	#
	class RequestHandler(http.server.SimpleHTTPRequestHandler):

	# sous-répertoire racine des documents statiques
	static_dir = '/client'

	# on utilise le nom de fichier pour identifier le serveur
	server_version = 'TD2/'+os.path.basename(__file__)+'/0.1'

	#
	# On surcharge la méthode qui traite les requêtes GET
	#
	def do_GET(self):

	# le chemin d'accès commence par /time
	if self.path.startswith('/time'):
	self.send_time()

	# ou pas...
	else:
	self.send_static()

	#
	# On surcharge la méthode qui traite les requêtes HEAD
	#
	def do_HEAD(self):
	self.send_static()

	#
	# On envoie le document statique demandé
	#
	def send_static(self):

	# on modifie le chemin d'accès en insérant un répertoire préfixe
	self.path = self.static_dir + self.path

	# on calcule le nom de la méthode parent à appeler (do_GET ou do_HEAD)
	# à partir du verbe HTTP (GET ou HEAD)
	method = 'do_{}'.format(self.command)

	# on traite la requête via la classe parent
	getattr(http.server.SimpleHTTPRequestHandler,method)(self)


	#
	# On envoie un document avec l'heure
	#
	def send_time(self):

	# on récupère l'heure
	time = self.date_time_string()

	# on génère un document au format html
	body = '<!doctype html>' + \
	'<meta charset="utf-8">' + \
	'<title>l\'heure</title>' + \
	'<div>Voici l\'heure du serveur :</div>' + \
	'<pre>{}</pre>'.format(time)

	# pour prévenir qu'il s'agit d'une ressource au format html
	headers = [('Content-Type','text/html;charset=utf-8')]

	# on envoie
	self.send(body,headers)


	#
	# On envoie les entêtes et le corps fourni
	#
	def send(self,body,headers=[]):

	# on encode la chaine de caractères à envoyer
	encoded = bytes(body, 'UTF-8')

	# on envoie la ligne de statut
	self.send_response(200)

	# on envoie les lignes d'entête et la ligne vide
	[self.send_header(*t) for t in headers]
	self.send_header('Content-Length',int(len(encoded)))
	self.end_headers()

	# on envoie le corps de la réponse
	self.wfile.write(encoded)


	#
	# Instanciation et lancement du serveur
	#
	httpd = socketserver.TCPServer(("", 8080), RequestHandler)
	httpd.serve_forever()


	#======================================================================================
	# # TD2/Q5-1.py

	import http.server
	import socketserver
	import os

	from urllib.parse import urlparse, parse_qs
	from datetime import datetime
	from pytz import timezone
	import pytz

	#
	# Définition du nouveau handler
	#
	class RequestHandler(http.server.SimpleHTTPRequestHandler):

	# sous-répertoire racine des documents statiques
	static_dir = '/client'

	# on utilise le nom de fichier pour identifier le serveur
	server_version = 'TD2/'+os.path.basename(__file__)+'/0.1'


	#
	# On surcharge la méthode qui traite les requêtes GET
	#
	def do_GET(self):

	# on initialise nos variables d'instance
	self.init_vars()

	# le chemin d'accès commence par /time
	if self.path_info[0] == 'time':
	self.send_time()

	# ou pas...
	else:
	self.send_static()

	#
	# On surcharge la méthode qui traite les requêtes HEAD
	#
	def do_HEAD(self):
	self.send_static()

	#
	# On surcharge la méthode qui traite les requêtes GET
	#
	def do_POST(self):

	# on initialise nos variables d'instance
	self.init_vars()

	# le chemin d'accès commence par /time
	if self.path_info[0] == 'time':
	self.send_time()

	# ou pas...
	else:
	self.send_error(501,'Unsupported method (\'POST\')')

	#
	# On initialise les variables d'instance
	#
	def init_vars(self):
	# analyse de l'adresse
	info = urlparse(self.path)
	self.path_info = info.path.split('/')[1:]
	self.query_string = info.query
	self.params = parse_qs(info.query)
	print(self.path_info);

	# récupération du corps
	length = self.headers.get('Content-Length')
	ctype = self.headers.get('Content-Type')
	if length:
	self.body = str(self.rfile.read(int(length)),'utf-8')
	if ctype == 'application/x-www-form-urlencoded' :
	self.params = parse_qs(self.body)

	print(length,ctype,self.params)


	#
	# On envoie le document statique demandé
	#
	def send_static(self):

	# on modifie le chemin d'accès en insérant un répertoire préfixe
	self.path = self.static_dir + self.path

	# on calcule le nom de la méthode parent à appeler (do_GET ou do_HEAD)
	# à partir du verbe HTTP (GET ou HEAD)
	method = 'do_{}'.format(self.command)

	# on traite la requête via la classe parent
	getattr(http.server.SimpleHTTPRequestHandler,method)(self)

	#
	# On envoie un document avec l'heure
	#
	def send_time(self):

	# on récupère le fuseau horaire demandé
	if len(self.path_info) > 1:
	tz_name = '/'.join(self.path_info[1:])
	elif 'timezone' in self.params.keys():
	tz_name = self.params['timezone'][0]
	else:
	self.send_error(400,'No Time Zone')
	return

	try:
	tz = timezone(tz_name)
	except(pytz.exceptions.UnknownTimeZoneError):
	self.send_error(400,'Unknown Time Zone')
	return

	# on récupère la date et l'heure
	time = datetime.utcnow()

	# on convertit vers le fuseau demandé
	tz_time = tz.normalize(pytz.utc.localize(time).astimezone(tz))

	# on génère un document
	body = '<!doctype html>' + \
	'<meta charset="utf-8">' + \
	'<title>l\'heure dans le fuseau {}</title>'.format(tz_name) + \
	'<pre>Voici la date et l\'heure UTC du serveur :\n\n' + \
	'{}\n\n'.format(time) + \
	'Dans le fuseau {} il est :\n\n'.format(tz_name) + \
	'{}</pre>'.format(tz_time)

	# on envoie
	headers = [('Content-Type','text/html;charset=utf-8')]
	self.send(body,headers)


	#
	# On envoie les entêtes et le corps fourni
	#
	def send(self,body,headers=[]):

	# on encode la chaine de caractères à envoyer
	encoded = bytes(body, 'UTF-8')

	# on envoie la ligne de statut
	self.send_response(200)

	# on envoie les lignes d'entête et la ligne vide
	[self.send_header(*t) for t in headers]
	self.send_header('Content-Length',int(len(encoded)))
	self.end_headers()

	# on envoie le corps de la réponse
	self.wfile.write(encoded)


	#
	# Instanciation et lancement du serveur
	#
	httpd = socketserver.TCPServer(("", 8080), RequestHandler)
	httpd.serve_forever()
	#======================================================================================


	# TD2/Q6-1.py

	# pour le serveur web
	import socketserver

	# pour la gestion des noms de fichiers
	import os

	# pour l'accès base de données
	import sqlite3


	#
	# Définition du nouveau handler
	#
	from server import generic

	class RequestHandler(generic.RequestHandler):

	# on utilise le nom de fichier pour identifier le serveur
	server_version = 'TD2/'+os.path.basename(__file__)+'/0.1'


	#
	# On surcharge la méthode qui traite les requêtes GET
	#
	def do_GET(self):

	# on initialise nos variables d'instance
	self.init_vars()

	# le chemin d'accès commence par /lignes
	if self.path_info[0] == 'lignes':
	self.send_trains()

	# ou pas...
	else:
	self.send_static()


	#
	# On envoie un document avec la liste des lignes
	#
	def send_trains(self):

	conn = sqlite3.connect('sncf.sqlite')
	c = conn.cursor()
	c.execute("SELECT DISTINCT c.hexadecimal, p.code_ligne, p.nom_ligne " +\
	"FROM ponctualite_transilien AS p, couleur_transilien as c " +\
	"WHERE c.code_ligne = p.code_ligne " +\
	"ORDER BY p.code_ligne")
	r = c.fetchall()

	header = '<tr><td colspan=2>code</td><td>ligne</td><tr>'
	rows = ['<tr><td style="background-color: {}"> </td><td>{}</td><td>{}</td></tr>'.format(*a) for a in r]
	html = '<table>{}\n{}</table>'.format(header,'\n'.join(rows))

	headers = [('Content-Type','text/html;charset=utf-8')]
	self.send(html,headers)


	#
	# Instanciation et lancement du serveur
	#
	httpd = socketserver.TCPServer(("", 8080), RequestHandler)
	httpd.serve_forever()
	#=====================================================================================================
	# TD2/Q6-2.py

	# pour le serveur web
	import socketserver

	# pour la gestion des noms de fichiers
	import os

	# pour l'accès base de données
	import sqlite3

	# pour le tracé graphique
	import matplotlib.pyplot as plt
	from random import random

	# pour la fonction d'interpolation
	import numpy as np
	from scipy import interpolate


	#
	# Définition du nouveau handler
	#
	from server import generic

	class RequestHandler(generic.RequestHandler):

	# on utilise le nom de fichier pour identifier le serveur
	server_version = 'TD2/'+os.path.basename(__file__)+'/0.1'


	#
	# On surcharge la méthode qui traite les requêtes GET
	#
	def do_GET(self):

	# on initialise nos variables d'instance
	self.init_vars()

	# le chemin d'accès commence par /lignes
	if self.path_info[0] == 'lignes':
	self.send_trains()

	# le chemin d'accès commence par /ponctualite/RER
	elif self.path_info[0] == 'ponctualite':
	self.send_ponctualite()

	# ou pas...
	else:
	self.send_static()


	#
	# On envoie un document avec la liste des lignes
	#
	def send_trains(self):

	conn = sqlite3.connect('sncf.sqlite')
	c = conn.cursor()
	c.execute("SELECT DISTINCT c.hexadecimal, p.code_ligne, p.nom_ligne " +\
	"FROM ponctualite_transilien AS p, couleur_transilien as c " +\
	"WHERE c.code_ligne = p.code_ligne " +\
	"ORDER BY p.code_ligne")
	r = c.fetchall()

	header = '<tr><td colspan=2>code</td><td>ligne</td><tr>'
	rows = ['<tr><td style="background-color: {}"> </td><td>{}</td><td>{}</td></tr>'.format(*a) for a in r]
	html = '<table>{}\n{}</table>'.format(header,'\n'.join(rows))

	headers = [('Content-Type','text/html;charset=utf-8')]
	self.send(html,headers)


	#
	# On génère et on renvoie un graphique de ponctualite (cf. TD1)
	#
	def send_ponctualite(self):

	conn = sqlite3.connect('sncf.sqlite')
	c = conn.cursor()

	# liste des lignes de RER avec leur code couleur
	condition_code_ligne = ("= '{}'".format(self.path_info[2]) if len(self.path_info) > 2 else "LIKE '%'")
	c.execute("SELECT DISTINCT ponctualite_transilien.code_ligne, couleur_transilien.hexadecimal \
	FROM ponctualite_transilien, couleur_transilien \
	WHERE ponctualite_transilien.code_ligne = couleur_transilien.code_ligne \
	AND ponctualite_transilien.type_ligne = '{}' \
	AND ponctualite_transilien.code_ligne {} \
	ORDER BY ponctualite_transilien.code_ligne".format(self.path_info[1],condition_code_ligne))
	lignes = c.fetchall()

	# configuration du tracé
	plt.figure(figsize=(18,6))
	plt.ylim(65,100)
	plt.grid(True)

	# boucle sur les lignes
	for l in (lignes):
	c.execute("SELECT ponctualite_transilien.* \
	FROM ponctualite_transilien \
	WHERE ponctualite_transilien.code_ligne = ? \
	ORDER BY annee, mois",l[0])
	a = c.fetchall()

	# il y a une valeur manquante pour le RER B
	x = [n for n in range(len(a)) if not a[n][7] == '']
	y = [r[7] for r in a if not r[7] == '']

	# interpolation spline
	spl = interpolate.splrep(x, y, s=0)
	x2 = [n/10 for n in range(10*(len(a)-1)+1)]
	y2 = interpolate.splev(x2, spl, der=0)

	# tracé de la courbe de régularité
	plt.plot(x2,y2,linewidth=2,color=l[1], label=('RER ' if self.path_info[1] == 'RER' else 'ligne ')+l[0])
	plt.plot(x,y,linewidth=0,marker='s',markeredgecolor='w',markerfacecolor=l[1],markersize=10)

	# configuration du tracé (titre, grille)
	plt.grid(which='major', color='#888888', linestyle='-')
	plt.grid(which='minor',axis='x', color='#888888', linestyle=':')
	plt.title('Ponctualité des lignes {} (en %)'.format(self.path_info[1]),fontsize=16)

	# configuration de l'axe du temps
	mois = ['Jan','Fév','Mar','Avr', 'Mai', 'Juin', 'Juil', 'Août', 'Sept', 'Oct', 'Nov', 'Déc']
	xticks = [n*4 for n in range(int(len(a)/4))]
	xlabels = ['{} {}'.format(mois[r[2]-1], r[1]) for r in [a[t] for t in xticks]]

	plt.xlim(0,len(a)-1)
	ax = plt.subplot(111)
	ax.set_xticks(xticks)
	ax.set_xticks(x, minor=True)
	ax.set_xticklabels(xlabels, fontsize=12)

	# légende
	plt.legend(loc='lower left')

	fichier = 'courbe_ponctualite.png'
	plt.savefig('client/{}'.format(fichier))

	html = '<img src="{}?{}" alt="ponctualite {}" width="100%">'.format(fichier,random(),self.path_info[1])

	headers = [('Content-Type','text/html;charset=utf-8')]
	self.send(html,headers)

	#
	# Instanciation et lancement du serveur
	#
	httpd = socketserver.TCPServer(("", 8080), RequestHandler)
	httpd.serve_forever()
	#======================================