get_ical.py

#!/usr/bin/python
#coding: utf8
import re, requests, json, datetime, time

def get_ical(code,start='2022-08-23',end='2023-07-17',year=10,fiche_etalon=''):
    url = 'https://adeprod.app.univ-paris-diderot.fr:443/jsp/custom/modules/plannings/anonymous_cal.jsp'
    params = {
            'calType': 'ical',
            'firstDate': start,
            'lastDate': end,
            'resources': '%s%s'%(fiche_etalon,code),
            'projectId': year
            }
    r = requests.get(url, params=params)
    return r.text

def modifdate(m,shift):
    """
    fonction auxiliaire qui corrige la chaine de deux lignes consecutives DTSTART DTEND
    ADE introduit un decalage qui depend de l'heure ete/hiver.
    Il y a en plus un probleme de 24h lorsque les heures voulues sont vers l'apres midi.
    - En 2021-2022 jusqu'au 15/10/21 le shift est de -10 et l'heure frontiere du jour perdu est à 12h.
      !le 16/10/21 le shift d'été est passé brutalement à -9 et l'heure frontiere à 13h!
    - En 2020-2021 le shift est de -11 en ete et l'heure frontiere du jour perdu est à 11h.
    - En 2019-2020 le shift est de -12 en ete et l'heure frontiere du jour perdu est à 10h.
      De plus les cours qui terminaient à 20h en 19-20 ne semble pas transmis par ADE...

    * REMARQUE dans tous ces cas on peut maintenant deviner la formule:

            heurefrontiere -shiftete = 22h

    * En hiver il faut encore retrancher 1 au shift.

    m est la valeur trouvee par:

        re.compile('DTSTART:(\d{8}T\d{6}Z).*?DTEND:(\d{8}T\d{6}Z)',re.DOTALL)
    """
    debut=datetime.datetime.strptime(m.group(1),'%Y%m%dT%H%M%SZ')
    fin=datetime.datetime.strptime(m.group(2),'%Y%m%dT%H%M%SZ')
    orig = "ORIGSTART:%d%02d%02dT%02d%02d%02dZ\r\nORIGEND:%d%02d%02dT%02d%02d%02dZ\r\n"%(debut.year,debut.month,debut.day,debut.hour,debut.minute,debut.second,fin.year,fin.month,fin.day,fin.hour,fin.minute,fin.second)

    # PB le shift change avec l'heure d'hiver/ete:
    D1 = datetime.datetime(debut.year,10,31)
    D2 = datetime.datetime(debut.year,3,31)
    lastdimancheoct = D1 - datetime.timedelta(days=(D1.weekday()+1)%7)
    lastdimanchemars = D2 - datetime.timedelta(days=(D2.weekday()+1)%7)
    # shift a ajouter aux heures recues en ete
    #shiftete_manuel = -10 # vaut -10 au semestre 1 2021-2022, avant 21/10/2021.
    #shiftete_manuel = -9 # vaut -9 au 22/10/2021. (base 2021-22)

    shiftete_manuel = -8 # vaut -8 au 3/6/2022 sur la base 2022-23

    # frontiere ou le bug de jour apparait
    # Remarque dans tous les exmples on a heurefrontiere = shiftete + 22
    #heurefrontiere_manuel = 12 # vaut 12h au semestre 1 2021-2022, avant 21/10/2021
    heurefrontiere_manuel = 13 # vaut 13, au 22/10/2021
    #
    # on utilise le shift etalon.
    shiftete = shift
    heurefrontiere = shiftete + 22
    if shift != shiftete_manuel:
        print("[WARNING] shift %d != %d. la valeur du shift n'est pas celle connue pour l'annee la plus recente"%(shift,shiftete_manuel))
        #print("[WARNING] on utilise l'heurefrontiere 22+shiftete; à VERIFIER!")




    if debut.month > 7:
        # l'annee vaut pour aout-decembre. (Semestre 1)

        #if debut.year == 2021:
            # annee 2021-2022
            #on a un etalon pour 2021-2022 on evite la config manuelle
            #heurefrontiere = 12
            #shiftete = -10

        if debut.year == 2020:
            # annee 2020-2021
            heurefrontiere = 11
            shiftete = -11
        if debut.year == 2019:
            # annee 2019-2020
            heurefrontiere = 10
            shiftete = -12

        if debut >= lastdimancheoct:
            #print("hiver")
            shift = shiftete -1
        else:
            #print("ete")
            shift = shiftete
    if debut.month<8:
        # l'annee vaut pour janvier-juillet (Semestre2)
        #if debut.year == 2022:
            # annee 2021-2022
            #on a un etalon pour 2021-2022 on evite la config manuelle
            #heurefrontiere = 13
            #shiftete = -9

        if debut.year == 2021:
            # annee 2020-2021
            heurefrontiere = 11
            shiftete = -11
        if debut.year == 2020:
            #annee 2019-2020
            heurefrontiere = 10
            shiftete = -12

        #Ces 4 reservations sont les jeudis de 10h45-12h45
        #2021-04-01|21:45:00|2021-03-31|23:45:00|ALGORITHMIQUE|432C
        #2021-02-11|22:45:00|2021-02-11|00:45:00|ALGORITHMIQUE|432C
        #2021-02-18|22:45:00|2021-02-18|00:45:00|ALGORITHMIQUE|432C
        #2021-03-04|22:45:00|2021-03-04|00:45:00|ALGORITHMIQUE|432C
        if debut<lastdimanchemars:
            #print("hiver")
            shift = shiftete -1
        else:
            #print("ete")
            shift = shiftete

    # parfois il manque un jour a la date de fin, Exemple:
    # ORIGSTART:20210915T201500Z
    # ORIGEND:20210914T221500Z
    #
    # il existe des creneaux dont le debut et la fin sont la veille!
    #
    #Ex 6736.ics (avec shift = -10)
    #debut et fin peuvent etre le jour d'avant
    #ORIGSTART:20210912T221500Z
    #ORIGEND:20210912T234500Z
    #
    #Ex 6658.ics
    #ORIGSTART:20210823T180000Z
    #ORIGEND:20210823T184500Z
    #SUMMARY:étalon pour Calendar
    # pour IP1 le lundi 13/9 a 13h45 (paris)
    #ORIGSTART:20210912T234500Z
    #ORIGEND:20210913T014500Z
    #
    #
    # En fait il semble que si l'heure voulue etait apres:
    # 12h au semestre1 2021-2022 (13h à partir du 16/10/21), et 11h en 2020-2021,
    # ADE a perdu un jour
    # en voulant faire une certaine modif de decalage.
    #
    if debut.hour >= heurefrontiere -shift  or debut.hour <= 20 - shift -24:
        # si l'heure voulue >= heurefrontiere et <= 20h
        # dans ce cas il faut augmenter d'un jour avant d'appliquer le shift
        #TODO: on peut maintenant reserver jusque 21h!
        debut = debut + datetime.timedelta(hours=24)

    if fin.hour >= heurefrontiere -shift or fin.hour <= 20 - shift -24:
        # si l'heure voulue >= heurefrontiere et <= 20h
        # dans ce cas il faut augmenter d'un jour
        fin = fin + datetime.timedelta(hours=24)

    # On a ajusté les decalages de jours, on peut appliquer le shift a tous.
    debut=debut + datetime.timedelta(hours=shift)
    fin = fin +datetime.timedelta(hours=shift)


    return orig+"DTSTART;TZID=Europe/Paris:%d%02d%02dT%02d%02d%02d\r\nDTEND;TZID=Europe/Paris:%d%02d%02dT%02d%02d%02d"%(debut.year,debut.month,debut.day,debut.hour,debut.minute,debut.second,fin.year,fin.month,fin.day,fin.hour,fin.minute,fin.second)


def modifsalle(matchsalle):
    """
    En entrée un match de:
        re.compile('LOCATION:([a-zA-Z]* - \w+ -) ([0-9]+)')
    Ex: Halle - 331C -
    en sortie: "TP" si c'est une salle de TP connue. sinon une chaine vide.
    """
    salle=matchsalle.group(1)
    effectif=matchsalle.group(2)
    sallesTP = []
    amphis = []

    ###########
    # Salles TP
    ###########
    tpHalle = ['331C', '446C', '452C', '557C', '443C', '449C', '532C', '548C']
    tpHalle +=['432C', '436C', '443C', '531C', '537C', '538C', '554C', '551C']
    sallesTP += [ "Halle - %s -"%i for i in tpHalle ]

    tpMoulins = ['688C', '785C', '789C', '791C', '797C']
    sallesTP += [ "Moulins - %s -"%i for i in tpMoulins ]

    tpGermain = [ '2001', '2003', '2004', '2005', '2006', '2027', '2028', '2031', '2032']
    sallesTP += [ "Germain - %s -"%i for i in tpGermain ]

    tpCondorcet = ['073A', '075A', '077A', '156A', '172A', '173A', '174A', '176A', '192A']
    tpCondorcet+= ['193A', '202A', '213A', '241A', '250A', '276A', '285A', '292A', '293A']
    tpCondorcet+= ['322A', '313A', '338A']
    sallesTP += ["Condorcet - %s -"%i for i in tpCondorcet]

    tpLavoisier = ['210', '240']
    sallesTP += ["Lavoisier - %s -"%i for i in tpLavoisier]

    tpLamarck = ['122B', '132B', '142B', '149B', '154B', '201B', '213B', '222B', '232B', '249B', '254B']
    tpLamarck += ['179B', '181B', '189B', '281B', '289B', '521A', '525A']
    sallesTP += ["Lamarck - %s -"%i for i in tpLamarck]

    #NB: Manque les TP de Gouges.

    #########
    # Amphis
    #########
    amphisHalle = ['11E', '7C', '10E', '12E', '3B', '4C', '5C', '6C', '9E', '13E', '1A', '2A', '8C'] # amphis
    amphisHalle+= ['234C', '247E', '580F'] # gdes salles 84 places
    amphisHalle+= ['027C', '064E', '226C', '227C', '264E', '265E', '418C', '419C', '470E', '471E'] # gd salles 70 places
    amphis += ["Halle - %s -"%i for i in amphisHalle]

    amphisGouges = [ 'Gouges - 1 -', 'Gouges - 2 -']
    amphis += amphisGouges


    if salle in sallesTP:
        salle = salle + "TP-"

    if salle in amphis:
        salle = salle + "CM?-"


    salle="LOCATION:"+salle+" (%sp)"%effectif

    return salle


from codesapogee import apogee,filtreECUE


def modifvevent(matchevent, shift, icalname):
    """
    En entrée, event est un match d'un VEVENT,
    en sortie le VEVENT modifé:
    - correction des heures en appelant modifdate
    - détection des salles de TP et ajout du tag
    """
    event=matchevent.group(0)
    # il vaut mieux celle ci au cas ou les nouvelles lignes ne soient pas \r\n selon l'OS.
    # pour rebeginend on suppose qu'ils sont ordonnes DTSTART avant DTEND
    #fonction de recherche pour les fichiers emis par ADE.
    rebeginend=re.compile('DTSTART:(\d{8}T\d{6}Z).*?DTEND:(\d{8}T\d{6}Z)',re.DOTALL)
    # on corrige les heures
    event=rebeginend.sub(lambda m: modifdate(m,shift), event)
    #
    resalle=re.compile('LOCATION:([a-zA-Z]* - [0-9A-Z]+ -) ([0-9]+)')
    event=resalle.sub(lambda m: modifsalle(m), event)

    resummary = re.compile('SUMMARY:(.*)')
    m = resummary.search(event)

    code = icalname

    if m != None:
        summary = m.group(1)
        if summary.endswith('\r'):
            summary =   summary.replace('\r','')
            chariot="\r"
        else:
            chariot=""

        if code in apogee:
            summary2 = summary.replace('\\','')

            if summary2 in apogee[code]:
                event = resummary.sub(lambda m: "SUMMARY:%s (%s)%s"%(summary,apogee[code][summary2],chariot), event)

    return event




def fix_timezone(ical,icalname=""):
    """
    La fonction transforme un calendrier en utilisant des fonctions auxilaires pour:
        - réparer les données de début et fin.
          DTSTART:20210915T183000Z
          DTEND:20210915T203000Z
        - Vérifier que le calendrier n'a pas de créneaux incohérents.
        - Détecter les salles de TP et amphis car ces données ne sont pas présentes dans le calendrier émis par ADE.
    """
    reshift = re.compile('(DTSTART:20\d{2}0823T)(\d{2})(\d{4})Z')
    # si l'on veut recuperer tout le vevent
    revevent=re.compile('BEGIN:VEVENT.*?END:VEVENT',re.DOTALL)
    # Fonction de recherche pour les fichiers modifies avec l'heure de Paris:
    rebeginendparis=re.compile('DTSTART;TZID=Europe/Paris:(\d{8}T\d{6}).*?DTEND;TZID=Europe/Paris:(\d{8}T\d{6})',re.DOTALL)
    index = 2

    m = reshift.search(ical)
    decalageUTC=0
    if not m:
        shift=-8-decalageUTC
        print('[WARNING] %s: no reference for etalon 0823T, set shift to %d'%(icalname, shift))
        # NB le shift passe de -10 a -9 le 22/10/2021
        # NB le shift sur la base 2022-23 semble etre à -8 ke 3/6/2022.
    else:
        shift = (-decalageUTC+ 8 - int(m.group(index)))   # le vrai shift sans le modulo.
        #if (shift != -decalageUTC -10):
        #    print("[WARNING] %s: %s -> shift = %d  != %d)"%(icalname, m.group(0),shift,-decalageUTC-10))

    #ical = rebeginend.sub(lambda m: modifdate(m,shift), ical)
    ical = revevent.sub(lambda m: modifvevent(m,shift,icalname), ical)

    # Quelques verifs
    Levent=revevent.finditer(ical)
    tmpcount=0
    for mevent in Levent:
        L=rebeginendparis.findall(mevent.group(0))
        if len(L)==1:
            m=L[0]
            debut=datetime.datetime.strptime(m[0],'%Y%m%dT%H%M%S')
            fin=datetime.datetime.strptime(m[1],'%Y%m%dT%H%M%S')
            tmpcount+=1
            if fin-debut < datetime.timedelta(hours=0):
                #probleme il reste un creneau negatif ou de plus de 8h.
                print("[FATAL] %s: creneau mal corrige %s"%(icalname, str(m)))
                return None
            if fin-debut > datetime.timedelta(hours=8):
                #tres rare mais ca existe, Ex en L1 info/biole 19/10/21
                print("[WARNING] %s: creneau de plus de 8h %s"%(icalname, str(m)))
            if fin-debut > datetime.timedelta(hours=13):
                # il y a maintenant des reservations de 8h-20h45 ...
                print("[FATAL] %s: creneau de plus de 13h %s"%(icalname, str(m)))
                return None
            if debut.weekday() == 6 or fin.weekday() == 6:
                print("[FATAL] %s: creneau sur un dimanche %s"%(icalname, str(m)))
                return None
        else:
            print("[FATAL] %s: vevent contient %d start/end: %s"%(icalname, len(L),mevent.group(0)))
            return None


    print("(%s): %d fiches trouvees/verifiees"%(icalname, tmpcount))


    return ical


def cherchedeplacements(fcalen = 'calendars.json', outdir='data', oldoutdir='data.28', labelobsolete='obsolète'):
    """
    Cherche les différences dans les deux versions de tous les calendriers de chaque formation pour:

    - Créer pour chaque formation un calendrier 1234.ics où 1234 est le code de la formation.
      (ie en general (*) le code à gauche dans formations.json)
    - ce 1234.ics contient les anciens événements qui ont été modifiés ou supprimés.
    - si l'on déclare 1234.ics comme un groupe de la formation avec le label 'obsolète' , on pourra voir ces modifications.

    (*) En fait certain groupes ont une formation mère mais sont présents et affichés dans une autre.
    (ex en l3 mathinfo 2 codes formations meres: 2418 et 7426). On utilise donc le fichier
    calendars.json où l'on crée des listes de tous les labels attachés à la formation.
    """

    revevent=re.compile('BEGIN:VEVENT.*?END:VEVENT',re.DOTALL)
    revariable = re.compile('(DTSTAMP:.*\n)|(LAST-MODIFIED:.*\n)|(CREATED:.*\n)|(SEQUENCE:.*\n)|(ORIGSTART:.*\n)|(ORIGEND:.*\n)|(UID:.*\n)|(LAST-MODIFIED:.*\n)|\s\s.*|(DESCRIPTION:.*)')
    #revariable=re.compile('(?!DTSTART.*)*|(?!DTEND.*)*')
    rexeport = re.compile('\(.*?\)|\n',re.DOTALL)

    # on recupere les noms des boutons via le code, on utilise donc calendars.json
    noms = {}
    Lforma = {}
    obsoletetrouve = [] # la liste des formations qui ont un bouton obsolete.
    # deux ensembles pour s'assurer qu'un code de groupe n'a pas ete saisi dans un code pour bouton obsolete
    setobsolete = set()
    setgroupe = set()
    with open(fcalen) as calenfile:
        for l in json.load(calenfile):
            noms[ str(l["code"]) ] = l["label"]   # un dictionnaire pour trouver le label d'une formation
            # Une formation = année + parcours. Ex: l1 math
            if not l["parcours"]+l["year"] in Lforma:
                Lforma[l["parcours"]+l["year"]] = []
            if l["label"] == labelobsolete:
                # On place le code de la formation en premier
                Lforma[l["parcours"]+l["year"]] = [str(l["code"])] + Lforma[l["parcours"]+l["year"]]
                obsoletetrouve.append(l["parcours"]+l["year"])  # OK on note qu'il y a bien un bouton obsolete pour cette formation
                setobsolete.update({l["code"]})
            else:
                # ensuite on place les codes des groupes
                (Lforma[l["parcours"]+l["year"]]).append(str(l["code"]))
                setgroupe.update({l["code"]})

        assert( setobsolete.isdisjoint(setgroupe)),"Pb %s un code de fiche est present dans un code pour archive obsolete"%(setobsolete.intersection(setgroupe))


        for c in Lforma:
            # Une securité s'il n'y a pas de bouton obsolete pour cette formation
            # pour ne pas ecraser son calendrier
            if c in obsoletetrouve:
                # on etudie une formation
                changements = ""
                fiches=Lforma[c][1:]
                codeformation = Lforma[c][0]
                oldevents={}
                nborig = 0
                for code in fiches:
                    try:
                            fnew = open("%s/%s.ics"%(outdir,code),"r")
                            calnew = fnew.read()
                            fnew.close()
                            fold = open("%s/%s.ics"%(oldoutdir,code),"r")
                            calold= fold.read()
                            fold.close()
                            for mevent in revevent.finditer(calold):
                                event=mevent.group(0)
                                fiable = rexeport.sub('',revariable.sub('',event))
                                # on ajoute le groupe dans le hash au cas ou une fiche commune soit modifiee
                                #fiable=fiable.replace('\n','')
                                fiable=fiable.replace('\,','')
                                fiable=fiable.replace(',','')
                                fiable = fiable.replace("SUMMARY:","SUMMARY:[%s]"%(noms[code]))
                                oldevents[hash(fiable)] = event.replace("SUMMARY:","SUMMARY:[%s]"%(noms[code]))
                            nborig += len(oldevents)   # on regarde le total des evenements d'une page.
                            for mevent in revevent.finditer(calnew):
                                event=mevent.group(0)
                                fiable = rexeport.sub('',revariable.sub('',event))
                                #fiable=fiable.replace('\n','')
                                fiable=fiable.replace('\,','')
                                fiable=fiable.replace(',','')
                                # on ajoute le groupe dans le hash au cas ou une fiche commune soit modifiee
                                fiable = fiable.replace("SUMMARY:","SUMMARY:[%s]"%(noms[code]))
                                oldevents.pop(hash(fiable),None)
                    except:
                            print("[WARNING] echec ds diff de (%s) %s. (manque archive?) => on crée un cal. vide"%(code, c))

                # On ajoute un calendrier pour toutes les fiches.
                with open("%s/%s.ics"%(outdir, codeformation),'w') as f:
                        f.write("BEGIN:VCALENDAR\n")
                        f.write("METHOD:REQUEST\n")
                        f.write("PRODID:-//ADE/version 6.0\n")
                        f.write("VERSION:2.0\n")
                        f.write("CALSCALE:GREGORIAN\n")
                        if len(oldevents)<50 or len(oldevents)*4<nborig:
                            for key in oldevents:
                                f.write(revariable.sub('',oldevents[key])+"\n")
                        else:
                            print("[WARNING] (%s) plus de 50 chts et plus de 1/4 de modifications; on ne les enregistre pas."%(c))
                            print("[WARNING] si les données de référence (data.28) sont fiables il faut vérifier data\n(et voir s'il n'y a pas un problème de shift/calibrage ADE?)")

                        f.write("END:VCALENDAR\n")



def tests():
    """
    Une fonction de test pour traiter un exemple avec shift de -11h si l'on n'arrive pas
    a obtenir de tels exemples.
    """
    f=open("test_6651L1MATH3delta_moins11.ics")
    ical=f.read()
    ical=fix_timezone(ical)
    f.close()
    print("Test L1 MATH3 semaine du 11/10/21")
    dest=open("data/6651.ics","w")
    dest.write(ical)
    dest.close()
    f2=open("test_5510L3MIASHS1delta_moins11.ics")
    ical=f2.read()
    ical=fix_timezone(ical)
    f2.close()
    print("Test L3 MIASHS GR1 semaine du 15/11/21")
    dest2=open("data/5510.ics","w")
    dest2.write(ical)
    dest2.close()


def calendar_list(fname = 'formations.json'):
    """
    Le fichier formation contient le code d'une formation annuelle et de ses sous fiches ADE.
    On ajoute au calendrier de la sous fiche celui de la formation parente car certains evenements
    peuvent y etre saisis.
    """
    rep=[]
    with open(fname) as cfile:
        for c in json.load(cfile):
            fiches=(c["fiches"]).split(',')
            for j in fiches:
                if j !="":
                    rep.append(str(c['code'])+','+j)
                else:
                    rep.append(str(c['code']))

        return rep

def get_calendars(formations, outdir,
                  start='2022-08-23',end='2023-07-17',year=10,fiche_etalon='',
                  dryrun=False, verbose=False):

    for code in calendar_list(formations):

        #on prend le nom de la derniere fiche
        nomfiche = code.split(',')[-1]
        fname = '%s/%s.ics'%(outdir,nomfiche)
        if verbose:
            print('[FETCH] %s -> %s'%(code,fname))
        calendar = get_ical(code,start,end,year,fiche_etalon)
        # check we actually got a calendar
        if not calendar.startswith('BEGIN:VCALENDAR'):
            print('[ERROR] %s -> no ressource %s'%(code,calendar[:20]))
            # keep old file
            continue
        calendar = fix_timezone(calendar,nomfiche)
        # Ajout de sous calendriers par ECUE dans certaines formations
        if nomfiche in filtreECUE:
            subcalendars = mkfiltreECUE(nomfiche, calendar, filtreECUE[nomfiche])
            for sc in subcalendars:
                fnamesub = "%s/%s.ics"%(outdir,sc)
                tmp = subcalendars[sc]
                f = open(fnamesub,'w')
                f.write(tmp)
                f.close()

        # trop de requettes peuvent donner une erreur ??
        #requests.exceptions.ConnectionError: HTTPSConnectionPool(host='adeprod.app.univ-paris-diderot.fr', port=443): Max retries exceeded with url: /jsp/custom/modules/plannings/anonymous_cal.jsp?calType=ical&firstDate=2021-08-23&lastDate=2021-12-19&resources=2769%2C6593%2C6602&projectId=4 (Caused by NewConnectionError('<urllib3.connection.VerifiedHTTPSConnection object at 0x7f87c1e449d0>: Failed to establish a new connection: [Errno -2] Name or service not known'))

        time.sleep(0.8) # 0.5 etait meme court?
        if calendar is None:
            print("PB calendrier %s vide"%code)
            return
        if dryrun:
            print(calendar[:300])
        else:
            with open(fname,'w') as f:
                f.write( calendar )
        if verbose:
            print('[DONE]')

def mkfiltreECUE(code,ical,filtre):
    """
    Une fonction pour filtrer et creer des sous calendriers à partir d'un calendrier.
    code: le code du calendrier d'origine, ie num fiche ADE
    calendrier: le calendrier apres corrections
    filtre: un dictionnaire de filtres: code ECUE/ expression reg
    """
    subcals = {}
    debutcal =  "BEGIN:VCALENDAR\n"
    debutcal += "METHOD:REQUEST\n"
    debutcal += "PRODID:-//ADE/version 6.0\n"
    debutcal += "VERSION:2.0\n"
    debutcal += "CALSCALE:GREGORIAN"
    fincal = "\nEND:VCALENDAR"
    for ecue in filtre:
        tmp = str(code)+"."+ ecue
        subcals[tmp]= debutcal
    revevent=re.compile('BEGIN:VEVENT.*?END:VEVENT',re.DOTALL)
    rechercheUE =[ re.compile(filtre[ecue],re.DOTALL) for ecue in filtre]
    Levent=revevent.finditer(ical)

    for mevent in Levent:
        event = mevent.group(0)
        event = event.replace('\r','')
        for i in range(len(filtre)):
            s=rechercheUE[i]
            ecue=list(filtre)[i]
            if s.match(event) != None:
                subcals[str(code)+"."+ecue] += "\n"+event

    for sc in subcals:
        subcals[sc] += fincal

    return subcals


def get_external(fcalen, outdir,
        dryrun=False, verbose=False):
    """
    download external (non ADE) ressources
    fcalen must be a list of ::

      { 'id' : xxx, 'url' : www, ... }

    """
    def curl(url):
        r = requests.get(url)
        return r.text

    with open(fcalen) as calenfile:
        for c in json.load(calenfile):
            fname = '%s/%s.ics'%(outdir,c['id'])
            cal = curl(c['url'])
            if dryrun:
                print(cal[:200])
            else:
                with open(fname,'w') as f:
                    f.write(cal)
            if verbose:
                print('[DONE %s]'%fname)


def main(start, end, year=10, fiche_etalon='1607,',
        formations='formations.json',
        calendars='calendars.json',
        external='calendars_external.json',
        outdir='data',
        oldoutdir='data.28',
        dryrun=False, verbose=False):

    if formations:
        get_calendars(formations, outdir,
                start, end, year, fiche_etalon,
                dryrun=dryrun, verbose=verbose)

    if calendars:
        cherchedeplacements(calendars, outdir, oldoutdir)

    if external:
        get_external(external, outdir,
                dryrun=dryrun, verbose=verbose)

# paramètres ADE ufr maths
presets = {
       '2022-23': dict(start="2022-08-23", end="2023-07-17", year=10, fiche_etalon="1607,"),
       '2021-22': dict(start="2021-08-23", end="2022-07-17", year=4, fiche_etalon="2769,"),
       '2020-21': dict(start="2020-08-31", end="2021-07-14", year=15),
       '2019-20': dict(start="2019-08-31", end="2020-07-14", year=6),
       }

import argparse

parser = argparse.ArgumentParser(description='fetch icalendars from ADE.')
parser.add_argument('--dryrun', '-n', action='store_true',
        help='dry-run, do not write files')
parser.add_argument('--verbose', '-v', action='store_true',
        help='verbose, show progress')
parser.add_argument('--start', type=str, default='2022-08-23',
                    help='first day, format yyyy-mm-dd')
parser.add_argument('--end', type=str, default='2023-07-17',
                    help='last day, format yyyy-mm-dd')
parser.add_argument('--year', type=int, default=10,
                    help='ADE year')
parser.add_argument('--fiche_etalon', type=str, default='1607,',
                    help='fiches à ajouter à chaque récupération')
parser.add_argument('--formations', type=str, default='formations.json',
                    help='json file describing calendar views')
parser.add_argument('--calendars', type=str, default='calendars.json',
                    help='json file describing calendar views')
parser.add_argument('--outdir', type=str, default='data',
                    help='directory to save ics files'),
parser.add_argument('--oldoutdir', type=str, default='data.28',
                    help='directory to save old ics files for diff button')
parser.add_argument('--external', type=str, default='calendars_external.json',
                    help='json file listing external (non ADE) ressources')
parser.add_argument('--presets', choices=presets.keys(), help='automatic choice of --start, --end, --outdir options')

if __name__ == '__main__':
    args = parser.parse_args()
    if args.presets:
        args.outdir = 'data/%s'%args.presets
        args.oldoutdir = 'data.28/%s'%args.presets
        args.__dict__.update(presets[args.presets])
    main(args.start, args.end, args.year, args.fiche_etalon,
            formations=args.formations,
            calendars=args.calendars,
            external=args.external,
            outdir=args.outdir,
            dryrun=args.dryrun,
            verbose=args.verbose)